@fncts/base 0.0.20 → 0.0.21

package/_src/util/rand.ts

@@ -4,10 +4,8 @@ import { uniformBigIntDistribution } from "@fncts/base/util/rand/distribution/Un
 import { uniformIntDistribution } from "@fncts/base/util/rand/distribution/UniformIntDistribution";
 import { MersenneTwister } from "@fncts/base/util/rand/generator/MersenneTwister";
 import { generateN, RandomGenerator, skipN } from "@fncts/base/util/rand/generator/RandomGenerator";
-
 export * from "@fncts/base/util/rand/distribution/internals/ArrayInt";
 export * from "@fncts/base/util/rand/Random";
-
 export {
   Distribution,
   generateN,

package/collection/Iterable/api/traverseConc.d.ts

@@ -5,9 +5,9 @@ import type * as P from "@fncts/base/typeclass";
  * @tsplus getter fncts.Iterable traverseToConcWithIndex
  * @tsplus location "@fncts/base/collection/Iterable/api/traverseConc"
  */
-export declare function traverseToConcWithIndex_<A>(ta: Iterable<A>): <G extends import("@fncts/typelevel/HKT").HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B>(f: (i: number, a: A) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, B>) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, import("../../immutable/Conc").Conc<B>>;
+export declare function _traverseToConcWithIndex<A>(ta: Iterable<A>): <G extends import("@fncts/typelevel/HKT").HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B>(f: (i: number, a: A) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, B>) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, import("../../immutable/Conc").Conc<B>>;
 /**
  * @tsplus getter fncts.Iterable traverseToConc
  * @tsplus location "@fncts/base/collection/Iterable/api/traverseConc"
  */
-export declare function traverseToConc_<A>(ta: Iterable<A>): <G extends HKT, GC = HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B>(f: (a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, B>) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, Conc<B>>;
+export declare function _traverseToConc<A>(ta: Iterable<A>): <G extends HKT, GC = HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B>(f: (a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, B>) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, Conc<B>>;

package/collection/Iterable/api.d.ts

@@ -4,149 +4,149 @@ import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Eval } from "@fncts/base/control/Eval/definition";
 import { Either } from "@fncts/base/data/Either/definition";
 import type * as P from "@fncts/base/typeclass";
+import { Iterable } from "@fncts/base/collection/Iterable/definition";
 /**
- * @tsplus fluent fncts.Iterable ap
+ * @tsplus pipeable fncts.Iterable ap
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-export declare function ap_<A, B>(self: Iterable<(a: A) => B>, fa: Iterable<A>): Iterable<B>;
+export declare function ap<A>(fa: Iterable<A>): <B>(self: Iterable<(a: A) => B>) => Iterable<B>;
 /**
- * @tsplus fluent fncts.Iterable append
+ * @tsplus pipeable fncts.Iterable append
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-export declare function append_<A, B>(self: Iterable<A>, b: B): Iterable<A | B>;
+export declare function append<B>(b: B): <A>(self: Iterable<A>) => Iterable<B | A>;
 /**
  * @tsplus getter fncts.Iterable asIterable
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
 export declare function asIterable<A>(self: Iterable<A>): Iterable<A>;
 /**
- * @tsplus fluent fncts.Iterable flatMap
+ * @tsplus pipeable fncts.Iterable flatMap
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-export declare function flatMap_<A, B>(self: Iterable<A>, f: (a: A) => Iterable<B>): Iterable<B>;
+export declare function flatMap<A, B>(f: (a: A) => Iterable<B>): (self: Iterable<A>) => Iterable<B>;
 /**
- * @tsplus fluent fncts.Iterable concat
+ * @tsplus pipeable fncts.Iterable concat
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-export declare function concat_<A>(self: Iterable<A>, ib: Iterable<A>): Iterable<A>;
+export declare function concat<A>(ib: Iterable<A>): (self: Iterable<A>) => Iterable<A>;
 /**
- * @tsplus fluent fncts.Iterable corresponds
+ * @tsplus pipeable fncts.Iterable corresponds
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-export declare function corresponds_<A, B>(left: Iterable<A>, right: Iterable<B>, f: (a: A, b: B) => boolean): boolean;
+export declare function corresponds<A, B>(right: Iterable<B>, f: (a: A, b: B) => boolean): (left: Iterable<A>) => boolean;
 /**
- * @tsplus fluent fncts.Iterable crossWith
+ * @tsplus pipeable fncts.Iterable crossWith
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-export declare function crossWith_<A, B, C>(self: Iterable<A>, fb: Iterable<B>, f: (a: A, b: B) => C): Iterable<C>;
+export declare function crossWith<A, B, C>(fb: Iterable<B>, f: (a: A, b: B) => C): (self: Iterable<A>) => Iterable<C>;
 /**
- * @tsplus fluent fncts.Iterable every
+ * @tsplus pipeable fncts.Iterable every
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-export declare function every_<A, B extends A>(self: Iterable<A>, p: Refinement<A, B>): boolean;
-export declare function every_<A>(self: Iterable<A>, p: Predicate<A>): boolean;
+export declare function every<A, B extends A>(p: Refinement<A, B>): (self: Iterable<A>) => boolean;
+export declare function every<A>(p: Predicate<A>): (self: Iterable<A>) => boolean;
 /**
- * @tsplus fluent fncts.Iterable everyWithIndex
+ * @tsplus pipeable fncts.Iterable everyWithIndex
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-export declare function everyWithIndex_<A, B extends A>(self: Iterable<A>, p: RefinementWithIndex<number, A, B>): boolean;
-export declare function everyWithIndex_<A>(self: Iterable<A>, p: PredicateWithIndex<number, A>): boolean;
+export declare function everyWithIndex<A, B extends A>(p: RefinementWithIndex<number, A, B>): (self: Iterable<A>) => boolean;
+export declare function everyWithIndex<A>(p: PredicateWithIndex<number, A>): (self: Iterable<A>) => boolean;
 /**
- * @tsplus fluent fncts.Iterable filter
+ * @tsplus pipeable fncts.Iterable filter
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-export declare function filter_<A, B extends A>(self: Iterable<A>, p: Refinement<A, B>): Iterable<B>;
-export declare function filter_<A>(self: Iterable<A>, p: Predicate<A>): Iterable<A>;
+export declare function filter<A, B extends A>(p: Refinement<A, B>): (self: Iterable<A>) => Iterable<B>;
+export declare function filter<A>(p: Predicate<A>): (self: Iterable<A>) => Iterable<A>;
 /**
- * @tsplus fluent fncts.Iterable filterMap
+ * @tsplus pipeable fncts.Iterable filterMap
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-export declare function filterMap_<A, B>(self: Iterable<A>, f: (a: A) => Maybe<B>): Iterable<B>;
+export declare function filterMap<A, B>(f: (a: A) => Maybe<B>): (self: Iterable<A>) => Iterable<B>;
 /**
- * @tsplus fluent fncts.Iterable filterMapWithIndex
+ * @tsplus pipeable fncts.Iterable filterMapWithIndex
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-export declare function filterMapWithIndex_<A, B>(self: Iterable<A>, f: (i: number, a: A) => Maybe<B>): Iterable<B>;
+export declare function filterMapWithIndex<A, B>(f: (i: number, a: A) => Maybe<B>): (self: Iterable<A>) => Iterable<B>;
 /**
- * @tsplus fluent fncts.Iterable filterWithIndex
+ * @tsplus pipeable fncts.Iterable filterWithIndex
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-export declare function filterWithIndex_<A, B extends A>(self: Iterable<A>, p: RefinementWithIndex<number, A, B>): Iterable<B>;
-export declare function filterWithIndex_<A>(self: Iterable<A>, p: PredicateWithIndex<number, A>): Iterable<A>;
+export declare function filterWithIndex<A, B extends A>(p: RefinementWithIndex<number, A, B>): (self: Iterable<A>) => Iterable<B>;
+export declare function filterWithIndex<A>(p: PredicateWithIndex<number, A>): (self: Iterable<A>) => Iterable<A>;
 /**
- * @tsplus fluent fncts.Iterable find
+ * @tsplus pipeable fncts.Iterable find
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-export declare function find_<A, B extends A>(ia: Iterable<A>, refinement: Refinement<A, B>): Maybe<B>;
-export declare function find_<A>(ia: Iterable<A>, predicate: Predicate<A>): Maybe<A>;
+export declare function find<A, B extends A>(refinement: Refinement<A, B>): (ia: Iterable<A>) => Maybe<B>;
+export declare function find<A>(predicate: Predicate<A>): (ia: Iterable<A>) => Maybe<A>;
 /**
- * @tsplus fluent fncts.Iterable findIndex
+ * @tsplus pipeable fncts.Iterable findIndex
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-export declare function findIndex<A>(self: Iterable<A>, p: Predicate<A>): number;
+export declare function findIndex<A>(p: Predicate<A>): (self: Iterable<A>) => number;
 /**
- * @tsplus fluent fncts.Iterable foldLeftWithIndex
+ * @tsplus pipeable fncts.Iterable foldLeftWithIndex
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-export declare function foldLeftWithIndex_<A, B>(fa: Iterable<A>, b: B, f: (i: number, b: B, a: A) => B): B;
+export declare function foldLeftWithIndex<A, B>(b: B, f: (i: number, b: B, a: A) => B): (fa: Iterable<A>) => B;
 /**
- * @tsplus fluent fncts.Iterable foldLeft
+ * @tsplus pipeable fncts.Iterable foldLeft
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-export declare function foldLeft_<A, B>(self: Iterable<A>, b: B, f: (b: B, a: A) => B): B;
+export declare function foldLeft<A, B>(b: B, f: (b: B, a: A) => B): (self: Iterable<A>) => B;
 /**
- * @tsplus fluent fncts.Iterable foldMap
+ * @tsplus pipeable fncts.Iterable foldMap
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-export declare function foldMap_<A, M>(self: Iterable<A>, f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): M;
+export declare function foldMap<A, M>(f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): (self: Iterable<A>) => M;
 /**
- * @tsplus fluent fncts.Iterable foldMapWithIndex
+ * @tsplus pipeable fncts.Iterable foldMapWithIndex
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-export declare function foldMapWithIndex_<A, M>(self: Iterable<A>, f: (i: number, a: A) => M, 
-/** @tsplus auto */ M: P.Monoid<M>): M;
+export declare function foldMapWithIndex<A, M>(f: (i: number, a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): (self: Iterable<A>) => M;
 /**
- * @tsplus fluent fncts.Iterable foldRightWithIndex
+ * @tsplus pipeable fncts.Iterable foldRightWithIndex
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-export declare function foldRightWithIndex_<A, B>(self: Iterable<A>, b: Eval<B>, f: (i: number, a: A, b: Eval<B>) => Eval<B>): Eval<B>;
+export declare function foldRightWithIndex<A, B>(b: Eval<B>, f: (i: number, a: A, b: Eval<B>) => Eval<B>): (self: Iterable<A>) => Eval<B>;
 /**
- * @tsplus fluent fncts.Iterable foldRight
+ * @tsplus pipeable fncts.Iterable foldRight
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-export declare function foldRight_<A, B>(self: Iterable<A>, b: Eval<B>, f: (a: A, b: Eval<B>) => Eval<B>): Eval<B>;
+export declare function foldRight<A, B>(b: Eval<B>, f: (a: A, b: Eval<B>) => Eval<B>): (self: Iterable<A>) => Eval<B>;
 /**
- * @tsplus fluent fncts.Iterable map
+ * @tsplus pipeable fncts.Iterable map
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-export declare function map_<A, B>(self: Iterable<A>, f: (a: A) => B): Iterable<B>;
+export declare function map<A, B>(f: (a: A) => B): (self: Iterable<A>) => Iterable<B>;
 /**
- * @tsplus fluent fncts.Iterable mapWithIndex
+ * @tsplus pipeable fncts.Iterable mapWithIndex
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-export declare function mapWithIndex_<A, B>(self: Iterable<A>, f: (i: number, a: A) => B): Iterable<B>;
+export declare function mapWithIndex<A, B>(f: (i: number, a: A) => B): (self: Iterable<A>) => Iterable<B>;
 /**
- * @tsplus fluent fncts.Iterable partitionMap
+ * @tsplus pipeable fncts.Iterable partitionMap
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-export declare function partitionMap_<A, B, C>(self: Iterable<A>, f: (a: A) => Either<B, C>): readonly [Iterable<B>, Iterable<C>];
+export declare function partitionMap<A, B, C>(f: (a: A) => Either<B, C>): (self: Iterable<A>) => readonly [Iterable<B>, Iterable<C>];
 /**
- * @tsplus fluent fncts.Iterable partitionMapWithIndex
+ * @tsplus pipeable fncts.Iterable partitionMapWithIndex
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-export declare function partitionMapWithIndex_<A, B, C>(fa: Iterable<A>, f: (i: number, a: A) => Either<B, C>): readonly [Iterable<B>, Iterable<C>];
+export declare function partitionMapWithIndex<A, B, C>(f: (i: number, a: A) => Either<B, C>): (fa: Iterable<A>) => readonly [Iterable<B>, Iterable<C>];
 /**
- * @tsplus fluent fncts.Iterable partition
+ * @tsplus pipeable fncts.Iterable partition
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-export declare function partition_<A, B extends A>(self: Iterable<A>, p: Refinement<A, B>): readonly [Iterable<A>, Iterable<B>];
-export declare function partition_<A>(self: Iterable<A>, p: Predicate<A>): readonly [Iterable<A>, Iterable<A>];
+export declare function partition<A, B extends A>(p: Refinement<A, B>): (self: Iterable<A>) => readonly [Iterable<A>, Iterable<B>];
+export declare function partition<A>(p: Predicate<A>): (self: Iterable<A>) => readonly [Iterable<A>, Iterable<A>];
 /**
- * @tsplus fluent fncts.Iterable partitionWithIndex
+ * @tsplus pipeable fncts.Iterable partitionWithIndex
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-export declare function partitionWithIndex_<A, B extends A>(self: Iterable<A>, p: RefinementWithIndex<number, A, B>): readonly [Iterable<A>, Iterable<B>];
-export declare function partitionWithIndex_<A>(self: Iterable<A>, p: PredicateWithIndex<number, A>): readonly [Iterable<A>, Iterable<A>];
+export declare function partitionWithIndex<A, B extends A>(p: RefinementWithIndex<number, A, B>): (self: Iterable<A>) => readonly [Iterable<A>, Iterable<B>];
+export declare function partitionWithIndex<A>(p: PredicateWithIndex<number, A>): (self: Iterable<A>) => readonly [Iterable<A>, Iterable<A>];
 /**
  * @tsplus getter fncts.Iterable size
  * @tsplus location "@fncts/base/collection/Iterable/api"
@@ -158,15 +158,15 @@ export declare function size<A>(self: Iterable<A>): number;
  */
 export declare function sum(self: Iterable<number>): number;
 /**
- * @tsplus fluent fncts.Iterable take
+ * @tsplus pipeable fncts.Iterable take
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-export declare function take<A>(self: Iterable<A>, n: number): Iterable<A>;
+export declare function take(n: number): <A>(self: Iterable<A>) => Iterable<A>;
 /**
- * @tsplus fluent fncts.Iterable zipWith
+ * @tsplus pipeable fncts.Iterable zipWith
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-export declare function zipWith_<A, B, C>(self: Iterable<A>, fb: Iterable<B>, f: (a: A, b: B) => C): Iterable<C>;
+export declare function zipWith<A, B, C>(fb: Iterable<B>, f: (a: A, b: B) => C): (self: Iterable<A>) => Iterable<C>;
 /**
  * @tsplus getter fncts.Iterable zipWithIndex
  * @tsplus location "@fncts/base/collection/Iterable/api"

package/collection/Iterable/constructors.d.ts

@@ -2,7 +2,7 @@
  * @tsplus static fncts.IterableOps make
  * @tsplus location "@fncts/base/collection/Iterable/constructors"
  */
-export declare function mkIterable<A>(iterator: () => Iterator<A>): Iterable<A>;
+export declare function makeIterable<A>(iterator: () => Iterator<A>): Iterable<A>;
 /**
  * @tsplus static fncts.IterableOps empty
  * @tsplus location "@fncts/base/collection/Iterable/constructors"

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

@@ -19,14 +19,14 @@ export declare function isEmpty<A>(self: ReadonlyArray<A>): boolean;
  */
 export declare function isNonEmpty<A>(self: ReadonlyArray<A>): self is ReadonlyNonEmptyArray<A>;
 /**
- * @tsplus fluent fncts.Array foldLeft
- * @tsplus fluent fncts.ReadonlyArray foldLeft
+ * @tsplus pipeable fncts.Array foldLeft
+ * @tsplus pipeable 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;
+export declare function foldLeft<A, B>(b: B, f: (b: B, a: A) => B): (self: ReadonlyArray<A>) => B;
 /**
- * @tsplus fluent fncts.Array foldLeftWithIndex
- * @tsplus fluent fncts.ReadonlyArray foldLeftWithIndex
+ * @tsplus pipeable fncts.Array foldLeftWithIndex
+ * @tsplus pipeable 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;
+export declare function foldLeftWithIndex<A, B>(b: B, f: (i: number, b: B, a: A) => B): (self: ReadonlyArray<A>) => B;

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

@@ -1,6 +1,7 @@
 import { Guard } from "@fncts/base/typeclass/Guard";
 import { Decoder } from "@fncts/base/data/Decoder/definition";
 import { These } from "@fncts/base/data/These";
+import { Encoder } from "@fncts/base/data/Encoder/definition";
 import type { Check } from "@fncts/typelevel/Check";
 /**
  * @tsplus derive fncts.Guard[fncts.Array]<_> 10
@@ -22,3 +23,13 @@ export declare function deriveDecoder<A extends Array<any>>(...[element]: [A] ex
  * @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>;
+/**
+ * @tsplus derive fncts.Encoder[fncts.Array]<_> 10
+ * @tsplus location "@fncts/base/collection/compat/Array/derivations"
+ */
+export declare function deriveEncoder<A extends Array<any>>(...[element]: [A] extends [Array<infer _A>] ? Check<Check.IsEqual<A, Array<_A>>> extends Check.True ? [element: Encoder<_A>] : never : never): Encoder<A>;
+/**
+ * @tsplus derive fncts.Encoder[fncts.ReadonlyArray]<_> 10
+ * @tsplus location "@fncts/base/collection/compat/Array/derivations"
+ */
+export declare function deriveReadonlyArrayEncoder<A extends ReadonlyArray<any>>(...[element]: [A] extends [ReadonlyArray<infer _A>] ? Check<Check.IsEqual<A, ReadonlyArray<_A>>> extends Check.True ? [element: Encoder<_A>] : never : never): Encoder<A>;

package/collection/compat/Record/instances.d.ts

@@ -1,5 +1,6 @@
 import { Guard } from "@fncts/base/typeclass/Guard";
 import { Decoder } from "@fncts/base/data/Decoder/definition";
+import { Encoder } from "@fncts/base/data/Encoder/definition";
 import type { Check } from "@fncts/typelevel/Check";
 /**
  * @tsplus derive fncts.Guard<_> 15
@@ -10,13 +11,36 @@ export declare function deriveDictionaryGuard<A extends Record<string, any>>(...
  * @tsplus derive fncts.Guard<_> 15
  * @tsplus location "@fncts/base/collection/compat/Record/instances"
  */
-export declare function deriveGuard<A extends Record<string, any>>(...[key, value, requiredKeys]: Check<Check.IsRecord<A>> extends Check.True ? [key: Guard<keyof A>, value: Guard<A[keyof A]>, requiredKeys: {
-    [k in keyof A]: 0;
-}] : never): Guard<A>;
+export declare function deriveGuard<A extends Record<string, any>>(...[key, value, requiredKeys]: Check<Check.IsRecord<A>> extends Check.True ? [
+    key: Guard<keyof A>,
+    value: Guard<A[keyof A]>,
+    requiredKeys: {
+        [k in keyof A]: 0;
+    }
+] : never): Guard<A>;
 /**
  * @tsplus derive fncts.Decoder<_> 15
  * @tsplus location "@fncts/base/collection/compat/Record/instances"
  */
-export declare function deriveDecoder<A extends Record<string, any>>(...[keyGuard, valueDecoder, requiredKeysRecord]: [A] extends [Record<infer X, infer Y>] ? Check<Check.Not<Check.IsUnion<A>> & Check.IsEqual<A, Record<X, Y>>> extends Check.True ? [keyGuard: Guard<X>, valueDecoder: Decoder<Y>, requiredKeysRecord: {
-    [k in X]: 0;
-}] : never : never): Decoder<A>;
+export declare function deriveDecoder<A extends Record<string, any>>(...[keyGuard, valueDecoder, requiredKeysRecord]: [A] extends [Record<infer X, infer Y>] ? Check<Check.Not<Check.IsUnion<A>> & Check.IsEqual<A, Record<X, Y>>> extends Check.True ? [
+    keyGuard: Guard<X>,
+    valueDecoder: Decoder<Y>,
+    requiredKeysRecord: {
+        [k in X]: 0;
+    }
+] : never : never): Decoder<A>;
+/**
+ * @tsplus derive fncts.Encoder<_> 15
+ * @tsplus location "@fncts/base/collection/compat/Record/instances"
+ */
+export declare function deriveDictionaryEncoder<A extends Record<string, any>>(...[value]: Check<Check.IsDictionary<A>> extends Check.True ? [value: Encoder<A[keyof A]>] : never): Encoder<A>;
+/**
+ * @tsplus derive fncts.Encoder<_> 15
+ * @tsplus location "@fncts/base/collection/compat/Record/instances"
+ */
+export declare function deriveEncoder<A extends Record<string, any>>(...[value, requiredKeys]: Check<Check.IsRecord<A>> extends Check.True ? [
+    value: Encoder<A[keyof A]>,
+    requiredKeys: {
+        [K in keyof A]: 0;
+    }
+] : never): Encoder<A>;