@fncts/base 0.0.13 → 0.0.16

package/_src/data/Maybe/definition.ts

@@ -23,7 +23,7 @@ const _nothingHash = Hashable.string("fncts.Nothing");
  * @tsplus companion fncts.MaybeOps
  */
 export class Maybe<A> {
-  readonly _A!: () => A;
+  declare _A: () => A;
   readonly _typeId: MaybeTypdId = MaybeTypeId;
 }
 
@@ -61,7 +61,7 @@ export class Nothing extends Maybe<never> {
 /**
  * @tsplus unify fncts.Maybe
  */
-export function unifyMaybe<X extends Maybe<any>>(self: X): Maybe<[X] extends [Maybe<infer A>] ? A : never> {
+export function unifyMaybe<X extends Maybe<any>>(self: X): Maybe<[X] extends [{ _A: () => infer A }] ? A : never> {
   return self;
 }
 

package/_src/data/Patch/api.ts

@@ -49,14 +49,14 @@ const OrdEnvironmentMap = Number.Ord.contramap((_: readonly [Tag<unknown>, reado
  * @tsplus static fncts.Environment.PatchOps diff
  */
 export function diff<In, Out>(oldValue: Environment<In>, newValue: Environment<Out>): Patch<In, Out> {
-  const sorted                   = newValue.map.toArray.sort(OrdEnvironmentMap.compare);
+  const sorted                   = newValue.map.toArray;
   const [missingServices, patch] = sorted.foldLeft(
     [oldValue.map.beginMutation, Patch.empty() as Patch<any, any>],
-    ([map, patch], [tag, [newService, newIndex]]) =>
+    ([map, patch], [tag, newService]) =>
       map.get(tag).match(
         () => [map.remove(tag), patch.compose(new AddService(newService, tag))],
-        ([oldService, oldIndex]) => {
-          if (oldService === newService && oldIndex === newIndex) {
+        (oldService) => {
+          if (oldService === newService) {
             return [map.remove(tag), patch];
           } else {
             return [map.remove(tag), patch.compose(new UpdateService((_: any) => newService, tag))];

package/_src/data/Tag/constructors.ts

@@ -1,6 +1,6 @@
 /**
  * @tsplus static fncts.TagOps __call
  */
-export function makeTag<T>(): Tag<T> {
-  return new Tag();
+export function makeTag<T>(id: string): Tag<T> {
+  return new Tag(id);
 }

package/_src/data/Tag/definition.ts

@@ -15,10 +15,11 @@ export class Tag<in out T> implements Hashable, Equatable {
   declare _T: (_: T) => T;
   readonly _typeId: TagTypeId = TagTypeId;
   private static counter      = new AtomicNumber(0);
-  readonly id                 = Tag.counter.getAndIncrement();
+
+  constructor(readonly id: string) {}
 
   get [Symbol.hash](): number {
-    return Hashable.combine(_tagHash, Hashable.number(this.id));
+    return Hashable.combine(_tagHash, Hashable.string(this.id));
   }
 
   [Symbol.equals](that: unknown): boolean {

package/_src/data/These/definition.ts

@@ -4,7 +4,7 @@ export const enum TheseTag {
   Both = "Both",
 }
 
-export const TheseTypeId = Symbol.for("fncts.base.data.These");
+export const TheseTypeId = Symbol.for("fncts.data.These");
 export type TheseTypeId = typeof TheseTypeId;
 
 /**

package/_src/data/string/api.ts

@@ -175,7 +175,7 @@ export const under = Pipeable(under_);
 /**
  * Join newline-separated strings together.
  *
- * @tsplus getter fncts.base.ImmutableArray unlines
+ * @tsplus getter fncts.ImmutableArray unlines
  */
 export function unlines(as: ReadonlyArray<string>): string {
   return as.join("\n");

package/_src/data.ts

@@ -0,0 +1,35 @@
+// codegen:start { preset: type-barrel, include: ./data/*.ts }
+export type {} from "./data/bigint.js";
+export type {} from "./data/boolean.js";
+export type {} from "./data/Branded.js";
+export type {} from "./data/Byte.js";
+export type {} from "./data/CaseClass.js";
+export type {} from "./data/Cause.js";
+export type {} from "./data/Const.js";
+export type {} from "./data/DecodeError.js";
+export type {} from "./data/Decoder.js";
+export type {} from "./data/Duration.js";
+export type {} from "./data/Either.js";
+export type {} from "./data/Environment.js";
+export type {} from "./data/exceptions.js";
+export type {} from "./data/ExecutionStrategy.js";
+export type {} from "./data/Exit.js";
+export type {} from "./data/FiberId.js";
+export type {} from "./data/function.js";
+export type {} from "./data/Identity.js";
+export type {} from "./data/Interval.js";
+export type {} from "./data/Intervals.js";
+export type {} from "./data/Maybe.js";
+export type {} from "./data/Newtype.js";
+export type {} from "./data/number.js";
+export type {} from "./data/object.js";
+export type {} from "./data/Patch.js";
+export type {} from "./data/Predicate.js";
+export type {} from "./data/Refinement.js";
+export type {} from "./data/string.js";
+export type {} from "./data/Tag.js";
+export type {} from "./data/These.js";
+export type {} from "./data/Trace.js";
+export type {} from "./data/TraceElement.js";
+export type {} from "./data/Zipped.js";
+// codegen:end

package/_src/global.ts

@@ -0,0 +1,252 @@
+/**
+ * @tsplus global
+ */
+import type {} from "@fncts/base";
+
+/**
+ * @tsplus global
+ */
+import {} from "@fncts/base/collection/compat/Array";
+/**
+ * @tsplus global
+ */
+import { Conc, ConcBuilder } from "@fncts/base/collection/immutable/Conc";
+/**
+ * @tsplus global
+ */
+import { Dictionary } from "@fncts/base/collection/immutable/Dictionary/definition";
+/**
+ * @tsplus global
+ */
+import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
+/**
+ * @tsplus global
+ */
+import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
+/**
+ * @tsplus global
+ */
+import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
+/**
+ * @tsplus global
+ */
+import {
+  ImmutableNonEmptyArray,
+  NonEmptyArray,
+  ReadonlyNonEmptyArray,
+} from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
+/**
+ * @tsplus global
+ */
+import { Cons, List, Nil } from "@fncts/base/collection/immutable/List/definition";
+/**
+ * @tsplus global
+ */
+import { Queue as ImmutableQueue } from "@fncts/base/collection/immutable/Queue/definition";
+/**
+ * @tsplus global
+ */
+import { RoseTree } from "@fncts/base/collection/immutable/RoseTree";
+/**
+ * @tsplus global
+ */
+import { SortedMap } from "@fncts/base/collection/immutable/SortedMap/definition";
+/**
+ * @tsplus global
+ */
+import { Vector } from "@fncts/base/collection/immutable/Vector";
+/**
+ * @tsplus global
+ */
+import { Iterable } from "@fncts/base/collection/Iterable/definition";
+/**
+ * @tsplus global
+ */
+import { HashMap as MutableHashMap } from "@fncts/base/collection/mutable/HashMap";
+/**
+ * @tsplus global
+ */
+import { HashSet as MutableHashSet } from "@fncts/base/collection/mutable/HashSet";
+/**
+ * @tsplus global
+ */
+import { ListBuffer } from "@fncts/base/collection/mutable/ListBuffer";
+/**
+ * @tsplus global
+ */
+import { Eval } from "@fncts/base/control/Eval/definition";
+/**
+ * @tsplus global
+ */
+import { LazyValue } from "@fncts/base/control/LazyValue";
+/**
+ * @tsplus global
+ */
+import { Z } from "@fncts/base/control/Z/definition";
+/**
+ * @tsplus global
+ */
+import { Byte } from "@fncts/base/data/Byte";
+/**
+ * @tsplus global
+ */
+import { CaseClass } from "@fncts/base/data/CaseClass";
+/**
+ * @tsplus global
+ */
+import { Cause } from "@fncts/base/data/Cause/definition";
+/**
+ * @tsplus global
+ */
+import { Const } from "@fncts/base/data/Const/definition";
+/**
+ * @tsplus global
+ */
+import { Datum } from "@fncts/base/data/Datum/definition";
+/**
+ * @tsplus global
+ */
+import { DatumEither } from "@fncts/base/data/DatumEither/definition";
+/**
+ * @tsplus global
+ */
+import { Decoder } from "@fncts/base/data/Decoder";
+/**
+ * @tsplus global
+ */
+import { Duration } from "@fncts/base/data/Duration/definition";
+/**
+ * @tsplus global
+ */
+import { Either } from "@fncts/base/data/Either/definition";
+/**
+ * @tsplus global
+ */
+import { Environment } from "@fncts/base/data/Environment/definition";
+/**
+ * @tsplus global
+ */
+import {
+  ArrayIndexOutOfBoundsError,
+  IllegalArgumentError,
+  IllegalStateError,
+  IndexOutOfBoundsError,
+  InterruptedException,
+  InvalidCapacityError,
+  isInterruptedException,
+  isInvalidCapacityError,
+  NoSuchElementError,
+} from "@fncts/base/data/exceptions";
+/**
+ * @tsplus global
+ */
+import { ExecutionStrategy } from "@fncts/base/data/ExecutionStrategy";
+/**
+ * @tsplus global
+ */
+import { Exit } from "@fncts/base/data/Exit/definition";
+/**
+ * @tsplus global
+ */
+import { FiberId } from "@fncts/base/data/FiberId/definition";
+/**
+ * @tsplus global
+ */
+import { unsafeCoerce } from "@fncts/base/data/function/api";
+/**
+ * @tsplus global
+ */
+import { Lazy } from "@fncts/base/data/function/definition";
+/**
+ * @tsplus global
+ */
+import { Identity } from "@fncts/base/data/Identity/definition";
+/**
+ * @tsplus global
+ */
+import { Interval } from "@fncts/base/data/Interval";
+/**
+ * @tsplus global
+ */
+import { Intervals } from "@fncts/base/data/Intervals";
+/**
+ * @tsplus global
+ */
+import { Just, Maybe, MaybeTag, Nothing } from "@fncts/base/data/Maybe/definition";
+/**
+ * @tsplus global
+ */
+import { Newtype, NewtypeIso } from "@fncts/base/data/Newtype";
+/**
+ * @tsplus global
+ */
+import {} from "@fncts/base/data/number/definition";
+import {} from "@fncts/base/data/object/definition";
+/**
+ * @tsplus global
+ */
+import {} from "@fncts/base/data/object/definition";
+/**
+ * @tsplus global
+ */
+import { Predicate, PredicateWithIndex } from "@fncts/base/data/Predicate/definition";
+/**
+ * @tsplus global
+ */
+import { Refinement, RefinementWithIndex } from "@fncts/base/data/Refinement/definition";
+/**
+ * @tsplus global
+ */
+import {} from "@fncts/base/data/string/definition";
+/**
+ * @tsplus global
+ */
+import { Struct } from "@fncts/base/data/Struct/definition";
+/**
+ * @tsplus global
+ */
+import { Tag } from "@fncts/base/data/Tag/definition";
+/**
+ * @tsplus global
+ */
+import { These } from "@fncts/base/data/These";
+/**
+ * @tsplus global
+ */
+import { Trace } from "@fncts/base/data/Trace/definition";
+/**
+ * @tsplus global
+ */
+import { TraceElement } from "@fncts/base/data/TraceElement/definition";
+/**
+ * @tsplus global
+ */
+import { Zipped } from "@fncts/base/data/Zipped";
+/**
+ * @tsplus global
+ */
+import { Stack } from "@fncts/base/internal/Stack";
+/**
+ * @tsplus global
+ */
+import { Equatable } from "@fncts/base/typeclass/Equatable";
+/**
+ * @tsplus global
+ */
+import { Guard } from "@fncts/base/typeclass/Guard";
+/**
+ * @tsplus global
+ */
+import { Has } from "@fncts/base/typeclass/Has";
+/**
+ * @tsplus global
+ */
+import { Hashable } from "@fncts/base/typeclass/Hashable";
+/**
+ * @tsplus global
+ */
+import { hasTypeId, isByte, isObject } from "@fncts/base/util/predicates";
+/**
+ * @tsplus global
+ */
+import { HKT } from "@fncts/typelevel/HKT";

package/_src/index.ts

@@ -0,0 +1,8 @@
+export type {} from "./collection.js";
+export type {} from "./control.js";
+export type {} from "./data.js";
+export type {} from "./json.js";
+export type {} from "./optics.js";
+export type {} from "./typeclass.js";
+export type {} from "./types.js";
+export type {} from "./util.js";

package/_src/json.ts

@@ -0,0 +1,5 @@
+// codegen:start { preset: type-barrel, include: ./json/*.ts }
+export type {} from "./json/EitherJson.js";
+export type {} from "./json/MaybeJson.js";
+export type {} from "./json/TheseJson.js";
+// codegen:end

package/_src/optics.ts

@@ -0,0 +1,12 @@
+// codegen:start { preset: type-barrel, include: ./optics/*.ts }
+export type {} from "./optics/At.js";
+export type {} from "./optics/Fold.js";
+export type {} from "./optics/Getter.js";
+export type {} from "./optics/Index.js";
+export type {} from "./optics/Iso.js";
+export type {} from "./optics/Lens.js";
+export type {} from "./optics/Optional.js";
+export type {} from "./optics/Prism.js";
+export type {} from "./optics/Setter.js";
+export type {} from "./optics/Traversal.js";
+// codegen:end

package/_src/typeclass/Showable/show.ts

@@ -72,7 +72,7 @@ export interface ShowOptions {
 
 export class ShowContext extends CaseClass<ShowContextArgs> {}
 
-export type ShowComputationZ<A> = Z<never, ShowContext, ShowContext, unknown, never, A>;
+export type ShowComputationZ<A> = Z<never, ShowContext, ShowContext, never, never, A>;
 export type ShowComputation = ShowComputationZ<string>;
 export type ShowComputationChunk = ShowComputationZ<Conc<string>>;
 
@@ -240,7 +240,7 @@ function getInspectionInfo(context: ShowContext, value: object, typedArray?: str
 
   if (value[Symbol.iterator as keyof typeof value] || constructor === null) {
     noIterator = false;
-    if (Conc.isConc(value)) {
+    if (Conc.is(value)) {
       braces = [`Chunk (${(value as Conc<unknown>).length}) [`, "]"];
       if ((value as Conc<unknown>).length == 0) {
         return inspectionEarlyReturn(`${braces[0]}]`);

package/_src/util.ts

@@ -0,0 +1,8 @@
+// codegen:start { preset: type-barrel, include: ./util/*.ts }
+export type {} from "./util/AnsiFormat.js";
+export type {} from "./util/assert.js";
+export type {} from "./util/pattern.js";
+export type {} from "./util/PCGRandom.js";
+export type {} from "./util/predicates.js";
+export type {} from "./util/rand.js";
+// codegen:end

package/collection/compat/Array/api.d.ts

@@ -1,32 +1,32 @@
 import { ReadonlyNonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
 import type { Eq } from "@fncts/base/typeclass";
 /**
- * @tsplus getter fncts.base.Array elem
- * @tsplus getter fncts.base.ReadonlyArray elem
+ * @tsplus getter fncts.Array elem
+ * @tsplus getter fncts.ReadonlyArray elem
  * @tsplus location "@fncts/base/collection/compat/Array/api"
  */
 export declare function elem<A>(self: ReadonlyArray<A>): (eq: Eq<A>) => (a: A) => boolean;
 /**
- * @tsplus fluent fncts.base.Array isEmpty
- * @tsplus fluent fncts.base.ReadonlyArray isEmpty
+ * @tsplus fluent fncts.Array isEmpty
+ * @tsplus fluent fncts.ReadonlyArray isEmpty
  * @tsplus location "@fncts/base/collection/compat/Array/api"
  */
 export declare function isEmpty<A>(self: ReadonlyArray<A>): boolean;
 /**
- * @tsplus fluent fncts.base.Array isNonEmpty
- * @tsplus fluent fncts.base.ReadonlyArray isNonEmpty
+ * @tsplus fluent fncts.Array isNonEmpty
+ * @tsplus fluent fncts.ReadonlyArray isNonEmpty
  * @tsplus location "@fncts/base/collection/compat/Array/api"
  */
 export declare function isNonEmpty<A>(self: ReadonlyArray<A>): self is ReadonlyNonEmptyArray<A>;
 /**
- * @tsplus fluent fncts.base.Array foldLeft
- * @tsplus fluent fncts.base.ReadonlyArray foldLeft
+ * @tsplus fluent fncts.Array foldLeft
+ * @tsplus fluent fncts.ReadonlyArray foldLeft
  * @tsplus location "@fncts/base/collection/compat/Array/api"
  */
 export declare function foldLeft<A, B>(self: ReadonlyArray<A>, b: B, f: (b: B, a: A) => B): B;
 /**
- * @tsplus fluent fncts.base.Array foldLeftWithIndex
- * @tsplus fluent fncts.base.ReadonlyArray foldLeftWithIndex
+ * @tsplus fluent fncts.Array foldLeftWithIndex
+ * @tsplus fluent fncts.ReadonlyArray foldLeftWithIndex
  * @tsplus location "@fncts/base/collection/compat/Array/api"
  */
 export declare function foldLeftWithIndex<A, B>(self: ReadonlyArray<A>, b: B, f: (i: number, b: B, a: A) => B): B;

package/collection/compat/Array/definition.d.ts

@@ -1,16 +1,16 @@
 declare global {
     /**
-     * @tsplus type fncts.base.ReadonlyArray
+     * @tsplus type fncts.ReadonlyArray
      */
     export interface ReadonlyArray<T> {
     }
     /**
-     * @tsplus type fncts.base.Array
+     * @tsplus type fncts.Array
      */
     export interface Array<T> {
     }
     /**
-     * @tsplus type fncts.base.ArrayOps
+     * @tsplus type fncts.ArrayOps
      */
     export interface ArrayConstructor {
     }

package/collection/compat/Array/derivations.d.ts

@@ -0,0 +1,24 @@
+import { Guard } from "@fncts/base/typeclass/Guard";
+import { Decoder } from "@fncts/base/data/Decoder";
+import { These } from "@fncts/base/data/These";
+import type { Check } from "@fncts/typelevel/Check";
+/**
+ * @tsplus derive fncts.Guard[fncts.Array]<_> 10
+ * @tsplus location "@fncts/base/collection/compat/Array/derivations"
+ */
+export declare function deriveGuard<A extends Array<any>>(...[element]: [A] extends [Array<infer _A>] ? Check<Check.IsEqual<A, Array<_A>>> extends Check.True ? [element: Guard<_A>] : never : never): Guard<A>;
+/**
+ * @tsplus derive fncts.Guard[fncts.ReadonlyArray]<_> 10
+ * @tsplus location "@fncts/base/collection/compat/Array/derivations"
+ */
+export declare const deriveReadonlyArrayGuard: <A extends ReadonlyArray<any>>(...[element]: [A] extends [ReadonlyArray<infer _A>] ? Check<Check.IsEqual<A, ReadonlyArray<_A>>> extends Check.True ? [element: Guard<_A>] : never : never) => Guard<A>;
+/**
+ * @tsplus derive fncts.Decoder[fncts.Array]<_> 10
+ * @tsplus location "@fncts/base/collection/compat/Array/derivations"
+ */
+export declare function deriveDecoder<A extends Array<any>>(...[element]: [A] extends [Array<infer _A>] ? Check<Check.IsEqual<A, Array<_A>>> extends Check.True ? [element: Decoder<_A>] : never : never): Decoder<A>;
+/**
+ * @tsplus derive fncts.Decoder[fncts.ReadonlyArray]<_> 10
+ * @tsplus location "@fncts/base/collection/compat/Array/derivations"
+ */
+export declare function deriveReadonlyArrayDecoder<A extends ReadonlyArray<any>>(...[element]: [A] extends [ReadonlyArray<infer _A>] ? Check<Check.IsEqual<A, ReadonlyArray<_A>>> extends Check.True ? [element: Decoder<_A>] : never : never): Decoder<A>;

package/collection/compat/Array.d.ts

@@ -1,2 +1,3 @@
 export * from "./Array/api.js";
 export * from "./Array/definition.js";
+export * from "./Array/derivations.js";

package/collection/compat.d.ts

@@ -0,0 +1,2 @@
+export type {} from "./compat/Array.js";
+export type {} from "./compat/Record.js";

package/collection/immutable/Conc/definition.d.ts

@@ -31,7 +31,7 @@ export interface ConcF extends HKT {
  * @tsplus companion fncts.ConcOps
  */
 export declare abstract class Conc<A> implements Iterable<A>, Hashable, Equatable {
-    readonly _A: () => A;
+    _A: () => A;
     readonly _typeId: ConcTypeId;
     abstract readonly length: number;
     abstract [Symbol.iterator](): Iterator<A>;
@@ -40,7 +40,7 @@ export declare abstract class Conc<A> implements Iterable<A>, Hashable, Equatabl
 }
 declare abstract class ConcImplementation<A> implements Iterable<A> {
     readonly _typeId: ConcTypeId;
-    readonly _A: () => A;
+    _A: () => A;
     get [Symbol.hash](): number;
     [Symbol.equals](that: unknown): boolean;
     abstract readonly length: number;
@@ -83,10 +83,11 @@ export declare class Empty<A> extends ConcImplementation<A> {
     arrayIterator(): Iterator<Array<A>>;
     reverseArrayIterator(): Iterator<Array<A>>;
 }
-export declare const _Empty: Empty<any>;
+export declare const _Empty: Empty<never>;
 export declare class Concat<A> extends ConcImplementation<A> {
     readonly left: ConcImplementation<A>;
     readonly right: ConcImplementation<A>;
+    _A: () => A;
     readonly _tag = ConcTag.Concat;
     length: number;
     depth: number;
@@ -107,8 +108,8 @@ declare class AppendN<A> extends ConcImplementation<A> {
     readonly _tag = ConcTag.AppendN;
     length: number;
     depth: number;
-    left: Empty<any>;
-    right: Empty<any>;
+    left: Empty<never>;
+    right: Empty<never>;
     constructor(start: ConcImplementation<A>, buffer: Array<unknown> | Uint8Array, bufferUsed: number, binary: boolean);
     [Symbol.iterator](): Iterator<A>;
     append<A1>(a: A1): ConcImplementation<A | A1>;
@@ -123,8 +124,8 @@ declare class PrependN<A> extends ConcImplementation<A> {
     readonly binary: boolean;
     readonly _tag = ConcTag.PrependN;
     length: number;
-    left: Empty<any>;
-    right: Empty<any>;
+    left: Empty<never>;
+    right: Empty<never>;
     constructor(end: ConcImplementation<A>, buffer: Array<unknown> | Uint8Array, bufferUsed: number, binary: boolean);
     [Symbol.iterator](): Iterator<A>;
     prepend<A1>(a: A1): ConcImplementation<A | A1>;
@@ -137,8 +138,8 @@ export declare class Singleton<A> extends ConcImplementation<A> {
     readonly _tag = ConcTag.Singleton;
     length: number;
     depth: number;
-    left: Empty<any>;
-    right: Empty<any>;
+    left: Empty<never>;
+    right: Empty<never>;
     binary: boolean;
     constructor(value: A);
     get(n: number): A;
@@ -156,8 +157,8 @@ export declare class Slice<A> extends ConcImplementation<A> {
     length: number;
     binary: boolean;
     depth: number;
-    left: Empty<any>;
-    right: Empty<any>;
+    left: Empty<never>;
+    right: Empty<never>;
     constructor(conc: ConcImplementation<A>, offset: number, l: number);
     get(n: number): A;
     forEach<B>(startIndex: number, f: (i: number, a: A) => B): void;
@@ -168,8 +169,8 @@ export declare class Chunk<A> extends ConcImplementation<A> {
     readonly _tag = ConcTag.Chunk;
     length: number;
     depth: number;
-    left: Empty<any>;
-    right: Empty<any>;
+    left: Empty<never>;
+    right: Empty<never>;
     binary: boolean;
     constructor(_array: ReadonlyArray<A>);
     get(n: number): A;
@@ -184,8 +185,8 @@ export declare class ByteChunk<A> extends ConcImplementation<A> {
     readonly _tag = ConcTag.ByteChunk;
     length: number;
     depth: number;
-    left: Empty<any>;
-    right: Empty<any>;
+    left: Empty<never>;
+    right: Empty<never>;
     binary: boolean;
     constructor(_array: Uint8Array);
     get(n: number): A;
@@ -205,7 +206,7 @@ export declare function concrete<A>(_: Conc<A>): asserts _ is Empty<A> | Singlet
  */
 export declare function fromArray<A>(array: ArrayLike<A>): ConcImplementation<A>;
 /**
- * @tsplus static fncts.ConcOps isConc
+ * @tsplus static fncts.ConcOps is
  * @tsplus location "@fncts/base/collection/immutable/Conc/definition"
  */
 export declare function isConc<A>(u: Iterable<A>): u is Conc<A>;

package/collection/immutable/Conc/derivations.d.ts

@@ -0,0 +1,14 @@
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { Guard } from "@fncts/base/typeclass/Guard";
+import { Decoder } from "@fncts/base/data/Decoder";
+import type { Check } from "@fncts/typelevel/Check";
+/**
+ * @tsplus derive fncts.Guard[fncts.Conc]<_> 10
+ * @tsplus location "@fncts/base/collection/immutable/Conc/derivations"
+ */
+export declare function deriveGuard<A extends Conc<any>>(...[elem]: [A] extends [Conc<infer _A>] ? [elem: Guard<_A>] : never): Guard<A>;
+/**
+ * @tsplus derive fncts.Decoder[fncts.Conc]<_> 10
+ * @tsplus location "@fncts/base/collection/immutable/Conc/derivations"
+ */
+export declare function deriveDecoder<A extends Conc<any>>(...[array, elem]: [A] extends [Conc<infer _A>] ? Check<Check.IsEqual<A, Conc<_A>>> extends Check.True ? [array: Decoder<Array<_A>>, elem: Decoder<_A>] : never : never): Decoder<A>;

package/collection/immutable/Conc.d.ts

@@ -1,6 +1,7 @@
 export * from "./Conc/api.js";
 export * from "./Conc/constructors.js";
 export * from "./Conc/definition.js";
+export * from "./Conc/derivations.js";
 export * from "./Conc/api/empty.js";
 export * from "./Conc/api/makeBy.js";
 export * from "./Conc/api/replicate.js";