@fncts/base 0.0.21 → 0.0.23

package/_src/global.ts

@@ -131,6 +131,14 @@ import { Environment } from "@fncts/base/data/Environment/definition";
  * @tsplus global
  */
 import { EnvironmentPatch } from "@fncts/base/data/EnvironmentPatch";
+/**
+ * @tsplus global
+ */
+import { Eq } from "@fncts/base/data/Eq/definition";
+/**
+ * @tsplus global
+ */
+import { Equatable } from "@fncts/base/data/Equatable";
 /**
  * @tsplus global
  */
@@ -165,6 +173,14 @@ import { unsafeCoerce } from "@fncts/base/data/function/api";
  * @tsplus global
  */
 import { Lazy } from "@fncts/base/data/function/definition";
+/**
+ * @tsplus global
+ */
+import { Guard } from "@fncts/base/data/Guard";
+/**
+ * @tsplus global
+ */
+import { Hashable } from "@fncts/base/data/Hashable";
 /**
  * @tsplus global
  */
@@ -194,6 +210,14 @@ import {} from "@fncts/base/data/object/definition";
  * @tsplus global
  */
 import {} from "@fncts/base/data/object/definition";
+/**
+ * @tsplus global
+ */
+import { Ord } from "@fncts/base/data/Ord/definition";
+/**
+ * @tsplus global
+ */
+import { Ordering } from "@fncts/base/data/Ordering";
 /**
  * @tsplus global
  */
@@ -234,22 +258,10 @@ 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
  */

package/_src/typeclass/Apply.ts

@@ -83,9 +83,9 @@ export function ap<F extends HKT, FC = HKT.None>(
   return (fa) => F.zipWith(fa, (f, a) => f(a));
 }
 /**
- * @tsplus static fncts.ApplyOps apFirst
+ * @tsplus static fncts.ApplyOps zipLeft
  */
-export function apFirst<F extends HKT, FC = HKT.None>(
+export function zipLeft<F extends HKT, FC = HKT.None>(
   F: Apply<F, FC>,
 ): <K1, Q1, W1, X1, I1, S1, R1, E1, K2, Q2, W2, X2, I2, S2, R2, E2, B>(
   fb: HKT.Kind<
@@ -118,10 +118,11 @@ export function apFirst<F extends HKT, FC = HKT.None>(
 > {
   return (fb) => F.zipWith(fb, (a, _) => a);
 }
+
 /**
- * @tsplus static fncts.ApplyOps apSecond
+ * @tsplus static fncts.ApplyOps zipRight
  */
-export function apSecond<F extends HKT, FC = HKT.None>(
+export function zipRight<F extends HKT, FC = HKT.None>(
   F: Apply<F, FC>,
 ): <K1, Q1, W1, X1, I1, S1, R1, E1, K2, Q2, W2, X2, I2, S2, R2, E2, B>(
   fb: HKT.Kind<

package/_src/typeclass/Closure.ts

@@ -2,7 +2,7 @@
  * @tsplus type fncts.Closure
  */
 export interface Closure<A> {
-  readonly combine: (x: A, y: A) => A;
+  readonly combine: (y: A) => (x: A) => A;
 }
 
 /**
@@ -15,6 +15,6 @@ export const Closure: ClosureOps = {};
 /**
  * @tsplus static fncts.ClosureOps __call
  */
-export function mkClosure<A>(F: Closure<A>): Closure<A> {
+export function makeClosure<A>(F: Closure<A>): Closure<A> {
   return F;
 }

package/_src/typeclass/Foldable.ts

@@ -30,5 +30,5 @@ export function foldMap<F extends HKT, FC = HKT.None>(
   f: (a: A) => M,
   /** @tsplus auto */ M: Monoid<M>,
 ) => <K, Q, W, X, I, S, R, E>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>) => M {
-  return (f, M) => F.foldLeft(M.nat, (b, a) => M.combine(b, f(a)));
+  return (f, M) => F.foldLeft(M.nat, (b, a) => M.combine(f(a))(b));
 }

package/_src/typeclass/FoldableWithIndex.ts

@@ -31,5 +31,5 @@ export function foldMapWithIndex<F extends HKT, FC = HKT.None>(
   f: (k: HKT.IndexFor<F, K>, a: A) => M,
   /** @tsplus auto */ M: Monoid<M>,
 ) => <Q, W, X, I, S, R, E>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>) => M {
-  return (f, M) => F.foldLeftWithIndex(M.nat, (i, b, a) => M.combine(b, f(i, a)));
+  return (f, M) => F.foldLeftWithIndex(M.nat, (i, b, a) => M.combine(f(i, a))(b));
 }

package/_src/typeclass/Monoid.ts

@@ -37,11 +37,11 @@ export function mkMonoid<A>(F: MonoidMin<A>): Monoid<A> {
 export function deriveLazy<A>(fn: (_: Monoid<A>) => Monoid<A>): Monoid<A> {
   let cached: Monoid<A> | undefined;
   const M: Monoid<A> = Monoid({
-    combine: (x, y) => {
+    combine: (y) => (x) => {
       if (!cached) {
         cached = fn(M);
       }
-      return cached.combine(x, y);
+      return cached.combine(y)(x);
     },
     get nat() {
       if (!cached) {

package/_src/typeclass/Semialign.ts

@@ -225,7 +225,7 @@ export function alignCombine<F extends HKT, FC = HKT.None>(
   HKT.Mix<F, "E", [E, E1]>,
   A
 > {
-  return (that, S) => F.alignWith(that, (th) => th.match(identity, identity, S.combine));
+  return (that, S) => F.alignWith(that, (th) => th.match(identity, identity, (a, b) => S.combine(b)(a)));
 }
 
 export interface padZip<F extends HKT, FC = HKT.None> {

package/_src/typeclass/Semigroup/api.ts

@@ -1,6 +1,5 @@
-import type { Ord } from "@fncts/base/typeclass/Ord";
-
 import { Semigroup } from "@fncts/base/typeclass/Semigroup/definition";
+
 /**
  * @tsplus static fncts.SemigroupOps min
  */
@@ -9,6 +8,7 @@ export function min<A>(O: Ord<A>): Semigroup<A> {
     combine: O.min,
   });
 }
+
 /**
  * @tsplus static fncts.SemigroupOps max
  */

package/_src/typeclass/Semigroup/definition.ts

@@ -1,16 +1,20 @@
 import type { Closure } from "@fncts/base/typeclass/Closure";
 
-import { mkClosure } from "@fncts/base/typeclass/Closure";
+import { makeClosure } from "@fncts/base/typeclass/Closure";
+
 /**
  * @tsplus type fncts.Semigroup
  */
 export interface Semigroup<A> extends Closure<A> {}
+
 /**
  * @tsplus type fncts.SemigroupOps
  */
 export interface SemigroupOps {}
+
 export const Semigroup: SemigroupOps = {};
+
 /**
  * @tsplus static fncts.SemigroupOps __call
  */
-export const mkSemigroup = mkClosure;
+export const makeSemigroup = makeClosure;

package/_src/typeclass/Semigroup/derivations.ts

@@ -2,21 +2,23 @@ import type { Check } from "@fncts/typelevel/Check";
 import type { OptionalKeys, RequiredKeys } from "@fncts/typelevel/Object";
 
 import { Semigroup } from "@fncts/base/typeclass/Semigroup/definition";
+
 /**
  * @tsplus derive fncts.Semigroup lazy
  */
 export function deriveLazy<A>(fn: (_: Semigroup<A>) => Semigroup<A>): Semigroup<A> {
   let cached: Semigroup<A> | undefined;
   const eq: Semigroup<A> = Semigroup({
-    combine: (x, y) => {
+    combine: (y) => (x) => {
       if (!cached) {
         cached = fn(eq);
       }
-      return cached.combine(x, y);
+      return cached.combine(y)(x);
     },
   });
   return eq;
 }
+
 /**
  * @tsplus derive fncts.Semigroup<_> 20
  * @tsplus static fncts.SemigroupOps deriveStruct
@@ -40,10 +42,10 @@ export function deriveStruct<A extends Record<string, any>>(
     : never
 ): Semigroup<A> {
   return Semigroup({
-    combine: (x, y) => {
+    combine: (y) => (x) => {
       const out: Record<string, unknown> = {};
       for (const field in requiredFields) {
-        out[field] = (requiredFields[field]! as Semigroup<any>).combine(x[field], y[field]);
+        out[field] = (requiredFields[field]! as Semigroup<any>).combine(y[field])(x[field]);
       }
       for (const field in optionalFields) {
         const xf = x[field];
@@ -53,7 +55,7 @@ export function deriveStruct<A extends Record<string, any>>(
         } else if (!(field in y)) {
           out[field] = xf;
         } else {
-          out[field] = optionalFields[field].combine(xf, yf);
+          out[field] = optionalFields[field].combine(yf)(xf);
         }
       }
       return out as A;

package/_src/typeclass.ts

@@ -8,8 +8,6 @@ export * from "./typeclass/Apply.js";
 export * from "./typeclass/builtin.js";
 export * from "./typeclass/Chain.js";
 export * from "./typeclass/Closure.js";
-export * from "./typeclass/Eq.js";
-export * from "./typeclass/Equatable.js";
 export * from "./typeclass/Fail.js";
 export * from "./typeclass/Filterable.js";
 export * from "./typeclass/FilterableWithIndex.js";
@@ -17,17 +15,11 @@ export * from "./typeclass/Foldable.js";
 export * from "./typeclass/FoldableWithIndex.js";
 export * from "./typeclass/Functor.js";
 export * from "./typeclass/FunctorWithIndex.js";
-export * from "./typeclass/Guard.js";
 export * from "./typeclass/Has.js";
-export * from "./typeclass/Hash.js";
-export * from "./typeclass/Hashable.js";
-export * from "./typeclass/HashEq.js";
 export * from "./typeclass/Monad.js";
 export * from "./typeclass/MonadExcept.js";
 export * from "./typeclass/Monoid.js";
 export * from "./typeclass/Nil.js";
-export * from "./typeclass/Ord.js";
-export * from "./typeclass/Ordering.js";
 export * from "./typeclass/Pointed.js";
 export * from "./typeclass/Semialign.js";
 export * from "./typeclass/Semigroup.js";
@@ -37,3 +29,12 @@ export * from "./typeclass/TraversableWithIndex.js";
 export * from "./typeclass/Witherable.js";
 export * from "./typeclass/WitherableWithIndex.js";
 // codegen:end
+
+export { Eq } from "./data/Eq.js";
+export { Equatable } from "./data/Equatable.js";
+export { Guard } from "./data/Guard.js";
+export { Hash } from "./data/Hash.js";
+export { Hashable } from "./data/Hashable.js";
+export { HashEq } from "./data/HashEq.js";
+export { Ord } from "./data/Ord.js";
+export { Ordering } from "./data/Ordering.js";

package/_src/util/predicates.ts

@@ -45,9 +45,9 @@ export function hasTypeId<X extends symbol>(
   value: unknown,
   typeId: X,
 ): value is {
-  readonly _typeId: X;
+  readonly [K in X]: X;
 } & Record<PropertyKey, unknown> {
-  return isObject(value) && "_typeId" in value && value["_typeId"] === typeId;
+  return isObject(value) && typeId in value;
 }
 
 export function isFunction(value: unknown): value is Function {

package/collection/Iterable/api.d.ts

@@ -16,10 +16,10 @@ export declare function ap<A>(fa: Iterable<A>): <B>(self: Iterable<(a: A) => B>)
  */
 export declare function append<B>(b: B): <A>(self: Iterable<A>) => Iterable<B | A>;
 /**
- * @tsplus getter fncts.Iterable asIterable
+ * @tsplus getter fncts.Iterable toIterable
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-export declare function asIterable<A>(self: Iterable<A>): Iterable<A>;
+export declare function toIterable<A>(self: Iterable<A>): Iterable<A>;
 /**
  * @tsplus pipeable fncts.Iterable flatMap
  * @tsplus location "@fncts/base/collection/Iterable/api"
@@ -39,7 +39,7 @@ export declare function corresponds<A, B>(right: Iterable<B>, f: (a: A, b: B) =>
  * @tsplus pipeable fncts.Iterable crossWith
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-export declare function crossWith<A, B, C>(fb: Iterable<B>, f: (a: A, b: B) => C): (self: Iterable<A>) => Iterable<C>;
+export declare function crossWith<A, B, C>(that: Iterable<B>, f: (a: A, b: B) => C): (self: Iterable<A>) => Iterable<C>;
 /**
  * @tsplus pipeable fncts.Iterable every
  * @tsplus location "@fncts/base/collection/Iterable/api"
@@ -78,8 +78,8 @@ export declare function filterWithIndex<A>(p: PredicateWithIndex<number, A>): (s
  * @tsplus pipeable fncts.Iterable find
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-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>;
+export declare function find<A, B extends A>(refinement: Refinement<A, B>): (self: Iterable<A>) => Maybe<B>;
+export declare function find<A>(predicate: Predicate<A>): (self: Iterable<A>) => Maybe<A>;
 /**
  * @tsplus pipeable fncts.Iterable findIndex
  * @tsplus location "@fncts/base/collection/Iterable/api"
@@ -89,7 +89,7 @@ export declare function findIndex<A>(p: Predicate<A>): (self: Iterable<A>) => nu
  * @tsplus pipeable fncts.Iterable foldLeftWithIndex
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-export declare function foldLeftWithIndex<A, B>(b: B, f: (i: number, b: B, a: A) => B): (fa: Iterable<A>) => B;
+export declare function foldLeftWithIndex<A, B>(b: B, f: (i: number, b: B, a: A) => B): (self: Iterable<A>) => B;
 /**
  * @tsplus pipeable fncts.Iterable foldLeft
  * @tsplus location "@fncts/base/collection/Iterable/api"
@@ -134,7 +134,7 @@ export declare function partitionMap<A, B, C>(f: (a: A) => Either<B, C>): (self:
  * @tsplus pipeable fncts.Iterable partitionMapWithIndex
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-export declare function partitionMapWithIndex<A, B, C>(f: (i: number, a: A) => Either<B, C>): (fa: Iterable<A>) => readonly [Iterable<B>, Iterable<C>];
+export declare function partitionMapWithIndex<A, B, C>(f: (i: number, a: A) => Either<B, C>): (self: Iterable<A>) => readonly [Iterable<B>, Iterable<C>];
 /**
  * @tsplus pipeable fncts.Iterable partition
  * @tsplus location "@fncts/base/collection/Iterable/api"
@@ -147,6 +147,11 @@ export declare function partition<A>(p: Predicate<A>): (self: Iterable<A>) => re
  */
 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 static fncts.IterableOps replicate
+ * @tsplus location "@fncts/base/collection/Iterable/api"
+ */
+export declare function replicate<A>(n: number, a: A): Iterable<A>;
 /**
  * @tsplus getter fncts.Iterable size
  * @tsplus location "@fncts/base/collection/Iterable/api"

package/collection/compat/Array.d.ts

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

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

@@ -1,5 +1,5 @@
 /**
- * @tsplus getter fncts.ArrayLike asIterable
+ * @tsplus getter fncts.ArrayLike toIterable
  * @tsplus location "@fncts/base/collection/compat/ArrayLike/api"
  */
-export declare function asIterable<A>(self: ArrayLike<A>): Iterable<A>;
+export declare function toIterable<A>(self: ArrayLike<A>): Iterable<A>;

package/collection/compat.d.ts

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

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

@@ -82,10 +82,10 @@ export declare function concat<B>(that: Conc<B>): <A>(self: import("@fncts/base/
  */
 export declare function elem<A>(a: A, /** @tsplus auto */ E: Eq<A>): (self: Conc<A>) => boolean;
 /**
- * @tsplus pipeable fncts.Conc exists
+ * @tsplus pipeable fncts.Conc some
  * @tsplus location "@fncts/base/collection/immutable/Conc/api"
  */
-export declare function exists<A>(predicate: Predicate<A>): (as: Conc<A>) => boolean;
+export declare function some<A>(predicate: Predicate<A>): (as: Conc<A>) => boolean;
 /**
  * @tsplus pipeable fncts.Conc drop
  * @tsplus location "@fncts/base/collection/immutable/Conc/api"

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

@@ -1,6 +1,6 @@
 import { HKT } from "@fncts/typelevel/HKT";
-import { Hashable } from "@fncts/base/typeclass/Hashable";
-import { Equatable } from "@fncts/base/typeclass/Equatable";
+import { Hashable } from "@fncts/base/data/Hashable";
+import { Equatable } from "@fncts/base/data/Equatable";
 import { isByte } from "@fncts/base/util/predicates";
 import { IndexOutOfBoundsError, ArrayIndexOutOfBoundsError } from "@fncts/base/data/exceptions";
 import { unsafeCoerce } from "@fncts/base/data/function/api";
@@ -32,14 +32,14 @@ export interface ConcF extends HKT {
  */
 export declare abstract class Conc<A> implements Iterable<A>, Hashable, Equatable {
     _A: () => A;
-    readonly _typeId: ConcTypeId;
+    readonly [ConcTypeId]: ConcTypeId;
     abstract readonly length: number;
     abstract [Symbol.iterator](): Iterator<A>;
     get [Symbol.hash](): number;
     [Symbol.equals](that: unknown): boolean;
 }
 declare abstract class ConcImplementation<A> implements Iterable<A> {
-    readonly _typeId: ConcTypeId;
+    readonly [ConcTypeId]: ConcTypeId;
     _A: () => A;
     get [Symbol.hash](): number;
     [Symbol.equals](that: unknown): boolean;

package/collection/immutable/Conc.d.ts

@@ -1,7 +1,6 @@
 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";

package/collection/immutable/Dictionary.d.ts

@@ -0,0 +1,2 @@
+export * from "./Dictionary/api.js";
+export * from "./Dictionary/definition.js";