@fncts/base 0.0.3 → 0.0.4

package/_src/data/Either/api.ts

@@ -1,14 +1,17 @@
 import type * as P from "../../typeclass.js";
-import type { EitherF } from "./instances.js";
+import type { EitherF } from "./definition.js";
 
 import { hasTypeId } from "../../util/predicates.js";
 import { identity } from "../function.js";
+import { concrete } from "./definition.js";
 import { EitherTag, EitherTypeId, Left, Right } from "./definition.js";
 
 /**
  * @tsplus fluent fncts.Either ap
  */
 export function ap_<E1, A, E2, B>(self: Either<E1, (a: A) => B>, fa: Either<E2, A>): Either<E1 | E2, B> {
+  self.concrete();
+  fa.concrete();
   return self._tag === EitherTag.Left ? self : fa._tag === EitherTag.Left ? fa : Right(self.right(fa.right));
 }
 
@@ -16,6 +19,7 @@ export function ap_<E1, A, E2, B>(self: Either<E1, (a: A) => B>, fa: Either<E2,
  * @tsplus fluent fncts.Either bimap
  */
 export function bimap_<E1, A, E2, B>(self: Either<E1, A>, f: (e: E1) => E2, g: (a: A) => B): Either<E2, B> {
+  self.concrete();
   return self._tag === EitherTag.Left ? Left(f(self.left)) : Right(g(self.right));
 }
 
@@ -23,6 +27,7 @@ export function bimap_<E1, A, E2, B>(self: Either<E1, A>, f: (e: E1) => E2, g: (
  * @tsplus fluent fncts.Either catchAll
  */
 export function catchAll_<E1, A, E2, B>(self: Either<E1, A>, f: (e: E1) => Either<E2, B>): Either<E2, A | B> {
+  self.concrete();
   return self._tag === EitherTag.Left ? f(self.left) : self;
 }
 
@@ -47,6 +52,7 @@ export function catchMap_<E, A, B>(self: Either<E, A>, f: (e: E) => B): Either<n
  * @tsplus fluent fncts.Either flatMap
  */
 export function flatMap_<E1, A, E2, B>(self: Either<E1, A>, f: (a: A) => Either<E2, B>): Either<E1 | E2, B> {
+  self.concrete();
   return self._tag === EitherTag.Left ? self : f(self.right);
 }
 
@@ -54,6 +60,7 @@ export function flatMap_<E1, A, E2, B>(self: Either<E1, A>, f: (a: A) => Either<
  * @tsplus fluent fncts.Either foldLeft
  */
 export function foldLeft_<E, A, B>(self: Either<E, A>, b: B, f: (b: B, a: A) => B): B {
+  self.concrete();
   return self._tag === EitherTag.Left ? b : f(b, self.right);
 }
 
@@ -61,23 +68,16 @@ export function foldLeft_<E, A, B>(self: Either<E, A>, b: B, f: (b: B, a: A) =>
  * @tsplus fluent fncts.Either foldRight
  */
 export function foldRight_<E, A, B>(self: Either<E, A>, b: B, f: (a: A, b: B) => B): B {
+  self.concrete();
   return self._tag === EitherTag.Left ? b : f(self.right, b);
 }
 
 /**
- * @constrained
+ * @tsplus fluent fncts.Either foldMap
  */
-export function foldMap_<M>(M: P.Monoid<M>) {
-  return <E, A>(self: Either<E, A>, f: (a: A) => M): M => (self._tag === EitherTag.Left ? M.nat : f(self.right));
-}
-
-/**
- * @tsplus getter fncts.Either foldMap
- */
-export function foldMapSelf<E, A>(self: Either<E, A>) {
-  return <M>(M: P.Monoid<M>) =>
-    (f: (a: A) => M): M =>
-      foldMap_(M)(self, f);
+export function foldMap_<E, A, M>(self: Either<E, A>, f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): M {
+  self.concrete();
+  return self._tag === EitherTag.Left ? M.nat : f(self.right);
 }
 
 /**
@@ -119,6 +119,7 @@ export function isEither(u: unknown): u is Either<unknown, unknown> {
  * @tsplus static fncts.EitherOps isLeft
  */
 export function isLeft<E, A>(self: Either<E, A>): self is Left<E> {
+  self.concrete();
   return self._tag === EitherTag.Left;
 }
 
@@ -127,6 +128,7 @@ export function isLeft<E, A>(self: Either<E, A>): self is Left<E> {
  * @tsplus static fncts.EitherOps isRight
  */
 export function isRight<E, A>(self: Either<E, A>): self is Right<A> {
+  self.concrete();
   return self._tag === EitherTag.Right;
 }
 
@@ -134,6 +136,7 @@ export function isRight<E, A>(self: Either<E, A>): self is Right<A> {
  * @tsplus fluent fncts.Either map
  */
 export function map_<E, A, B>(self: Either<E, A>, f: (a: A) => B): Either<E, B> {
+  self.concrete();
   return self._tag === EitherTag.Left ? self : Right(f(self.right));
 }
 
@@ -141,6 +144,7 @@ export function map_<E, A, B>(self: Either<E, A>, f: (a: A) => B): Either<E, B>
  * @tsplus fluent fncts.Either mapLeft
  */
 export function mapLeft_<E1, A, E2>(self: Either<E1, A>, f: (e: E1) => E2): Either<E2, A> {
+  self.concrete();
   return self._tag === EitherTag.Left ? Left(f(self.left)) : self;
 }
 
@@ -155,45 +159,96 @@ export function merge<E, A>(self: Either<E, A>): E | A {
  * @tsplus fluent fncts.Either orElse
  */
 export function orElse_<E1, A, E2, B>(self: Either<E1, A>, that: Lazy<Either<E2, B>>): Either<E1 | E2, A | B> {
+  self.concrete();
   return self._tag === EitherTag.Left ? that() : self;
 }
 
-export const sequence: P.sequence<EitherF> = (A) => (self) => traverse_(A)(self, identity);
-
-/**
- * @tsplus getter fncts.Either sequence
- */
-export const sequenceSelf: P.sequenceSelf<EitherF> = (self) => (A) =>
-  unsafeCoerce(traverse_(A)(self, unsafeCoerce(identity)));
-
 /**
  * @tsplus getter fncts.Either swap
  */
 export function swap<E, A>(self: Either<E, A>): Either<A, E> {
+  self.concrete();
   return self._tag === EitherTag.Left ? Right(self.left) : Left(self.right);
 }
 
-export const traverse_: P.traverse_<EitherF> = (A) => (self, f) =>
+/**
+ * @tsplus fluent fncts.Either traverse
+ */
+export const traverse_: P.Traversable<EitherF>["traverse"] = (self, f, A) =>
   self.match(
     (e) => A.pure(Left(e)),
-    (a) => f(a).via(A.map((b) => Right(b))),
+    (a) => f(a).map((b) => Right(b), A),
   );
 
-export const traverse: P.traverse<EitherF> = (A) => (f) => (self) => traverse_(A)(self, f);
-
-/**
- * @tsplus getter fncts.Either traverse
- */
-export const traverseSelf: P.traverseSelf<EitherF> = (self) => (A) => (f) => traverse_(A)(self, f);
-
 export function zipWith_<E1, A, E2, B, C>(
   self: Either<E1, A>,
   fb: Either<E2, B>,
   f: (a: A, b: B) => C,
 ): Either<E1 | E2, C> {
+  self.concrete();
+  fb.concrete();
   return self._tag === EitherTag.Left ? self : fb._tag === EitherTag.Left ? fb : Right(f(self.right, fb.right));
 }
 
+/**
+ * @tsplus fluent fncts.Either filterMap
+ */
+export function filterMap<E, A, B>(
+  self: Either<E, A>,
+  f: (a: A) => Maybe<B>,
+  /** @tsplus auto */ M: P.Monoid<E>,
+): Either<E, B> {
+  self.concrete();
+  return self._tag === EitherTag.Left
+    ? self
+    : f(self.right).match(
+        () => Left(M.nat),
+        (b) => Right(b),
+      );
+}
+
+/**
+ * @tsplus fluent fncts.Either filter
+ */
+export function filter<E, A>(self: Either<E, A>, f: Predicate<A>, /** @tsplus auto */ M: P.Monoid<E>): Either<E, A> {
+  self.concrete();
+  return self._tag === EitherTag.Left ? self : f(self.right) ? self : Left(M.nat);
+}
+
+/**
+ * @tsplus fluent fncts.Either partitionMap
+ */
+export function partitionMap<E, A, B, C>(
+  self: Either<E, A>,
+  f: (a: A) => Either<B, C>,
+  /** @tsplus auto */ M: P.Monoid<E>,
+): readonly [Either<E, B>, Either<E, C>] {
+  self.concrete();
+  if (self._tag === EitherTag.Left) {
+    return [self, self];
+  }
+  const fb: Either<B, C> = f(self.right);
+  fb.concrete();
+  switch (fb._tag) {
+    case EitherTag.Left:
+      return [Right(fb.left), Left(M.nat)];
+    case EitherTag.Right:
+      return [Left(M.nat), fb];
+  }
+}
+
+/**
+ * @tsplus fluent fncts.Either partition
+ */
+export function partition<E, A>(
+  self: Either<E, A>,
+  p: Predicate<A>,
+  /** @tsplus auto */ M: P.Monoid<E>,
+): readonly [Either<E, A>, Either<E, A>] {
+  self.concrete();
+  return self._tag === EitherTag.Left ? [self, self] : p(self.right) ? [Left(M.nat), self] : [self, Left(M.nat)];
+}
+
 // codegen:start { preset: barrel, include: api/*.ts }
 export * from "./api/align.js";
 export * from "./api/alignWith.js";

package/_src/data/Either/definition.ts

@@ -6,37 +6,50 @@ export const enum EitherTag {
 export const EitherTypeId = Symbol.for("fncts.base.data.Either");
 export type EitherTypeId = typeof EitherTypeId;
 
+export interface EitherF extends Either<any, any> {}
+export interface Either1F<E> extends Either1<E, any> {}
+
 /**
- * @tsplus type fncts.Either.Left
- * @tsplus companion fncts.Either.LeftOps
+ * @tsplus type fncts.Either
+ * @tsplus companion fncts.EitherOps
  */
-export class Left<E> {
+export class Either<E, A> {
   readonly _typeId: EitherTypeId = EitherTypeId;
-  readonly _tag                  = EitherTag.Left;
-  constructor(readonly left: E) {}
+  readonly [HKT.F]!: EitherF;
+  readonly [HKT.E]!: () => E;
+  readonly [HKT.A]!: () => A;
+  readonly [HKT.T]!: Either<HKT._E<this>, HKT._A<this>>;
 }
 
-/**
- * @tsplus type fncts.Either.Right
- * @tsplus companion fncts.Either.RightOps
- */
-export class Right<A> {
-  readonly _typeId: EitherTypeId = EitherTypeId;
-  readonly _tag                  = EitherTag.Right;
-  constructor(readonly right: A) {}
+export interface Either1<E, A> {
+  readonly _typeId: EitherTypeId;
+  readonly [HKT.F]: EitherF;
+  readonly [HKT.E]: () => E;
+  readonly [HKT.A]: () => A;
+  readonly [HKT.T]: Either<E, HKT._A<this>>;
 }
 
 /**
- * @tsplus type fncts.Either
+ * @tsplus type fncts.Either.Left
+ * @tsplus companion fncts.Either.LeftOps
  */
-export type Either<E, A> = Left<E> | Right<A>;
+export class Left<E> extends Either<E, never> {
+  readonly _tag = EitherTag.Left;
+  constructor(readonly left: E) {
+    super();
+  }
+}
 
 /**
- * @tsplus type fncts.EitherOps
+ * @tsplus type fncts.Either.Right
+ * @tsplus companion fncts.Either.RightOps
  */
-export interface EitherOps {}
-
-export const Either: EitherOps = {};
+export class Right<A> extends Either<never, A> {
+  readonly _tag = EitherTag.Right;
+  constructor(readonly right: A) {
+    super();
+  }
+}
 
 /**
  * @tsplus unify fncts.Either
@@ -46,3 +59,12 @@ export function unifyEither<X extends Either<any, any>>(
 ): Either<[X] extends [Either<infer E, any>] ? E : never, [X] extends [Either<any, infer A>] ? A : never> {
   return self;
 }
+
+/**
+ * @tsplus fluent fncts.Either concrete
+ * @tsplus static fncts.EitherOps concrete
+ * @tsplus macro remove
+ */
+export function concrete<E, A>(self: Either<E, A>): asserts self is Left<E> | Right<A> {
+  //
+}

package/_src/data/Either/destructors.ts

@@ -4,6 +4,7 @@ import { EitherTag } from "./definition.js";
  * @tsplus fluent fncts.Either match
  */
 export function match_<E, A, B, C>(self: Either<E, A>, left: (e: E) => B, right: (a: A) => C): B | C {
+  self.concrete();
   switch (self._tag) {
     case EitherTag.Left:
       return left(self.left);

package/_src/data/Either/instances.ts

@@ -1,80 +1,131 @@
+import type { Either1F, EitherF } from "@fncts/base/data/Either/definition.js";
+
+import { map_ } from "@fncts/base/data/Either/api";
+import { concrete, Either, EitherTag, Right } from "@fncts/base/data/Either/definition";
+import { EitherJson } from "@fncts/base/json/EitherJson";
+
 import * as P from "../../typeclass.js";
-import { map_ } from "./api.js";
-import { EitherTag, Left, Right } from "./definition.js";
 
-export interface EitherF extends HKT {
-  readonly type: Either<this["E"], this["A"]>;
-  readonly variance: {
-    E: "+";
-    A: "+";
-  };
-}
+/**
+ * @tsplus implicit
+ */
+export const Functor: P.Functor<EitherF> = {
+  map: map_,
+};
 
 /**
  * @tsplus static fncts.EitherOps getEq
  */
 export function getEq<E, A>(EE: P.Eq<E>, EA: P.Eq<A>): P.Eq<Either<E, A>> {
   return P.Eq({
-    equals_: (x, y) =>
+    equals: (x, y) =>
       x === y ||
       x.match(
         (e1) =>
           y.match(
-            (e2) => EE.equals_(e1, e2),
+            (e2) => EE.equals(e1, e2),
             () => false,
           ),
         (a1) =>
           y.match(
             () => false,
-            (a2) => EA.equals_(a1, a2),
+            (a2) => EA.equals(a1, a2),
           ),
       ),
   });
 }
 
 /**
- * @tsplus static fncts.EitherOps getEq
+ * @tsplus derive fncts.Eq[fncts.Either]<_> 10
  */
-export function getFilerable<E>(ME: P.Monoid<E>) {
-  type FixE = HKT.Fix<"E", E>;
-
-  const empty = Left(ME.nat);
+export function deriveEq<A extends Either<any, any>>(
+  ...[left, right]: [A] extends [Either<infer E, infer A>] ? [left: P.Eq<E>, right: P.Eq<A>] : never
+): P.Eq<A> {
+  return Either.getEq(left, right);
+}
 
-  const partitionMap_: P.partitionMap_<EitherF, FixE> = (fa, f) => {
-    if (fa._tag === EitherTag.Left) {
-      return [fa, fa];
-    }
-    const fb = f(fa.right);
-    switch (fb._tag) {
-      case EitherTag.Left:
-        return [Right(fb.left), empty];
-      case EitherTag.Right:
-        return [empty, fb];
-    }
+/**
+ * @tsplus static fncts.EitherOps getFilterable
+ */
+export function getFilerable<E>(/** @tsplus auto */ ME: P.Monoid<E>): P.Filterable<Either1F<E>> {
+  return <P.Filterable<Either1F<E>>>{
+    ...Functor,
+    partitionMap: (fa, f) => {
+      concrete(fa);
+      if (fa._tag === EitherTag.Left) {
+        return [fa, fa];
+      }
+      const fb = f(fa.right);
+      concrete(fb);
+      switch (fb._tag) {
+        case EitherTag.Left:
+          return [Right(fb.left), Either.left(ME.nat)];
+        case EitherTag.Right:
+          return [Either.left(ME.nat), fb];
+      }
+    },
+    filter: <A>(fa: Either<E, A>, p: Predicate<A>) => {
+      concrete(fa);
+      switch (fa._tag) {
+        case EitherTag.Left:
+          return fa;
+        case EitherTag.Right:
+          return p(fa.right) ? fa : Either.left(ME.nat);
+      }
+    },
+    filterMap: (fa, f) => {
+      concrete(fa);
+      if (fa._tag === EitherTag.Left) {
+        return fa;
+      }
+      return f(fa.right).match(
+        () => Either.left(ME.nat),
+        (b) => Either.right(b),
+      );
+    },
+    partition: <A>(fa: Either<E, A>, p: Predicate<A>): readonly [Either<E, A>, Either<E, A>] => {
+      concrete(fa);
+      if (fa._tag === EitherTag.Left) {
+        return [fa, fa];
+      }
+      return p(fa.right) ? [Either.left(ME.nat), fa] : [fa, Either.left(ME.nat)];
+    },
   };
+}
 
-  const partition_: P.partition_<EitherF, FixE> = <A>(
-    fa: Either<E, A>,
-    p: Predicate<A>,
-  ): readonly [Either<E, A>, Either<E, A>] =>
-    fa._tag === EitherTag.Left ? [fa, fa] : p(fa.right) ? [empty, fa] : [fa, empty];
-
-  const filterMap_: P.filterMap_<EitherF, FixE> = (fa, f) =>
-    fa._tag === EitherTag.Left
-      ? fa
-      : f(fa.right).match(
-          () => empty,
-          (b) => Right(b),
-        );
-
-  const filter_: P.filter_<EitherF, FixE> = <A>(fa: Either<E, A>, p: Predicate<A>): Either<E, A> =>
-    fa._tag === EitherTag.Left ? fa : p(fa.right) ? fa : empty;
-
-  return P.Filterable<EitherF, FixE>({
-    map_,
-    filter_,
-    filterMap_,
-    partition_,
-    partitionMap_,
+/**
+ * @tsplus derive fncts.Guard[fncts.Either]<_> 10
+ */
+export function deriveGuard<A extends Either<any, any>>(
+  ...[left, right]: [A] extends [Either<infer E, infer A>] ? [left: Guard<E>, right: Guard<A>] : never
+): Guard<A> {
+  return Guard((u): u is A => {
+    if (Either.isEither(u)) {
+      if (u.isLeft()) {
+        return left.is(u.left);
+      }
+      if (u.isRight()) {
+        return right.is(u.right);
+      }
+    }
+    return false;
   });
 }
+
+/**
+ * @tsplus derive fncts.Decoder[fncts.Either]<_> 10
+ */
+export function deriveDecoder<A extends Either<any, any>>(
+  ...[left, right]: [A] extends [Either<infer E, infer A>] ? [left: Decoder<E>, right: Decoder<A>] : never
+): Decoder<A> {
+  const jsonDecoder = EitherJson.getDecoder(left, right);
+  return Decoder(
+    (u) =>
+      jsonDecoder
+        .decode(u)
+        .map((result) =>
+          result._tag === "Left" ? (Either.left(result.left) as A) : (Either.right(result.right) as A),
+        ),
+    `Either<${left.label}, ${right.label}>`,
+  );
+}

package/_src/data/Environment/api.ts

@@ -2,7 +2,8 @@
  * @tsplus fluent fncts.Environment add
  */
 export function add<R, S, H extends S = S>(self: Environment<R>, service: H, tag: Tag<S>): Environment<R & Has<S>> {
-  return new Environment(self.map.set(tag, [service, self.index]), self.index + 1);
+  const self0 = self.index === Number.MAX_SAFE_INTEGER ? self.clean : self;
+  return new Environment(self0.map.set(tag, [service, self0.index]), self0.index + 1);
 }
 
 /**
@@ -36,12 +37,27 @@ export function make(): Environment<unknown> {
  * @tsplus fluent fncts.Environment union
  */
 export function union<R, R1>(self: Environment<R>, that: Environment<R1>): Environment<R & R1> {
+  const [self0, that0] = self.index + that.index < self.index ? [self.clean, that.clean] : [self, that];
   return new Environment(
-    self.map.union(that.map.map(([service, index]) => [service, self.index + index] as const)),
-    self.index + that.index,
+    self0.map.union(that0.map.map(([service, index]) => [service, self0.index + index] as const)),
+    self0.index + that0.index,
   );
 }
 
+/**
+ * @tsplus getter fncts.Environment clean
+ */
+export function clean<R>(self: Environment<R>): Environment<R> {
+  const [map, index] = self.map.toList
+    .sort(Number.Ord.contramap(([, [, idx]]) => idx))
+    .foldLeft(
+      [HashMap.makeDefault<Tag<unknown>, readonly [unknown, number]>(), 0],
+      ([map, index], [tag, [service]]) => [map.set(tag, [service, index] as const), index + 1],
+    );
+
+  return new Environment(map, index);
+}
+
 /**
  * @tsplus fluent fncts.Environment unsafeGet
  */
@@ -67,7 +83,6 @@ export function unsafeGet<R, S>(self: Environment<R>, tag: Tag<S>): S {
     },
     (a) => a as S,
   );
-  // return self.cache.unsafeGet(tag) as S;
 }
 
 /**

package/_src/data/Identity/api.ts

@@ -2,14 +2,14 @@
  * @tsplus fluent fncts.Identity ap
  */
 export function ap_<A, B>(fab: Identity<(a: A) => B>, fa: Identity<A>): Identity<B> {
-  return fab(fa);
+  return Identity.get(Identity.reverseGet(fab)(Identity.reverseGet(fa)));
 }
 
 /**
  * @tsplus fluent fncts.Identity map
  */
 export function map_<A, B>(fa: Identity<A>, f: (a: A) => B): Identity<B> {
-  return f(fa);
+  return Identity.get(f(Identity.reverseGet(fa)));
 }
 
 /**
@@ -17,12 +17,27 @@ export function map_<A, B>(fa: Identity<A>, f: (a: A) => B): Identity<B> {
  * @tsplus static fncts.IdentityOps __call
  */
 export function pure<A>(a: A): Identity<A> {
-  return a;
+  return Identity.get(a);
 }
 
 /**
  * @tsplus fluent fncts.Identity zipWith
  */
 export function zipWith_<A, B, C>(fa: Identity<A>, fb: Identity<B>, f: (a: A, b: B) => C): Identity<C> {
-  return f(fa, fb);
+  return Identity.get(f(Identity.reverseGet(fa), Identity.reverseGet(fb)));
 }
+
+/**
+ * @tsplus fluent fncts.Identity zip
+ */
+export function zip_<A, B>(fa: Identity<A>, fb: Identity<B>): Identity<readonly [A, B]> {
+  return fa.zipWith(fb, (a, b) => [a, b]);
+}
+
+/**
+ * @tsplus getter fncts.Identity getIdentity
+ * @tsplus macro identity
+ */
+export function getIdentity<A>(self: Identity<A>): A {
+  return Identity.reverseGet(self);
+}

package/_src/data/Identity/definition.ts

@@ -1,11 +1,15 @@
+export interface IdentityN {
+  readonly [HKT.T]: Identity<HKT._A<this>>
+}
+
 /**
  * @tsplus type fncts.Identity
  */
-export type Identity<A> = A;
+export interface Identity<A> extends Newtype<"Identity", A> {}
 
 /**
  * @tsplus type fncts.IdentityOps
  */
-export interface IdentityOps {}
+export interface IdentityOps extends NewtypeIso<IdentityN> {}
 
-export const Identity: IdentityOps = {};
+export const Identity: IdentityOps = Newtype<IdentityN>();

package/_src/data/Identity/instances.ts

@@ -1,21 +1,28 @@
-import * as P from "../../typeclass.js";
-import { ap_, map_, pure, zipWith_ } from "./api.js";
+import type * as P from "../../typeclass.js";
+import type { IdentityN } from "@fncts/base/data/Identity/definition";
 
-export interface IdentityF extends HKT {
-  readonly type: Identity<this["A"]>;
-}
+import { ap_, map_, pure, zip_, zipWith_ } from "./api.js";
 
 /**
  * @tsplus static fncts.IdentityOps Functor
  */
-export const Functor = P.Functor<IdentityF>({ map_ });
+export const Functor: P.Functor<IdentityN> = {
+  map: map_,
+};
 
 /**
  * @tsplus static fncts.IdentityOps Apply
  */
-export const Apply = P.Apply<IdentityF>({ map_, ap_, zipWith_ });
+export const Apply: P.Apply<IdentityN> = {
+  ...Functor,
+  zip: zip_,
+  zipWith: zipWith_,
+};
 
 /**
  * @tsplus static fncts.IdentityOps Applicative
  */
-export const Applicative = P.Applicative<IdentityF>({ map_, ap_, zipWith_, pure });
+export const Applicative: P.Applicative<IdentityN> = {
+  ...Apply,
+  pure,
+};