@fncts/base 0.0.2 → 0.0.5

package/_src/internal/Stack.ts

@@ -13,6 +13,10 @@ export class Stack<A> {
     return !!this.node;
   }
 
+  get isEmpty(): boolean {
+    return !this.hasNext;
+  }
+
   peek(): A | undefined {
     if (this.node) {
       return this.node.value;

package/_src/json/EitherJson.ts

@@ -0,0 +1,28 @@
+export interface RightJson<A> {
+  readonly _tag: "Right";
+  readonly right: A;
+}
+
+export interface LeftJson<E> {
+  readonly _tag: "Left";
+  readonly left: E;
+}
+
+/**
+ * @tsplus type fncts.EitherJson
+ */
+export type EitherJson<E, A> = LeftJson<E> | RightJson<A>;
+
+/**
+ * @tsplus type fncts.EitherJsonOps
+ */
+export interface EitherJsonOps {}
+
+export const EitherJson: EitherJsonOps = {};
+
+/**
+ * @tsplus static fncts.EitherJsonOps getDecoder
+ */
+export function getDecoder<E, A>(left: Decoder<E>, right: Decoder<A>): Decoder<EitherJson<E, A>> {
+  return Derive();
+}

package/_src/json/MaybeJson.ts

@@ -0,0 +1,27 @@
+export interface NothingJson {
+  readonly _tag: "Nothing"
+}
+
+export interface JustJson<A> {
+  readonly _tag: "Just"
+  readonly value: A
+}
+
+/**
+ * @tsplus type fncts.MaybeJson
+ */
+export type MaybeJson<A> = NothingJson | JustJson<A>;
+
+/**
+ * @tsplus type fncts.MaybeJsonOps
+ */
+export interface MaybeJsonOps {}
+
+export const MaybeJson: MaybeJsonOps = {};
+
+/**
+ * @tsplus static fncts.MaybeJsonOps getDecoder
+ */
+export function getDecoder<A>(value: Decoder<A>): Decoder<MaybeJson<A>> {
+  return Derive();
+}

package/_src/json/TheseJson.ts

@@ -0,0 +1,31 @@
+export interface LeftJson<E> {
+  readonly _tag: "Left";
+  readonly left: E;
+}
+
+export interface RightJson<A> {
+  readonly _tag: "Right";
+  readonly right: A;
+}
+
+export interface BothJson<E, A> {
+  readonly _tag: "Both";
+  readonly left: E;
+  readonly right: A;
+}
+
+export type TheseJson<E, A> = LeftJson<E> | RightJson<A> | BothJson<E, A>;
+
+/**
+ * @tsplus type fncts.TheseJsonOps
+ */
+export interface TheseJsonOps {}
+
+export const TheseJson: TheseJsonOps = {};
+
+/**
+ * @tsplus static fncts.TheseJsonOps getDecoder
+ */
+export function getDecoder<E, A>(left: Decoder<E>, right: Decoder<A>): Decoder<TheseJson<E, A>> {
+  return Derive();
+}

package/_src/optics/Optional/definition.ts

@@ -37,10 +37,10 @@ export function mkPOptional<S, T, A, B>(F: POptionalMin<S, T, A, B>): POptional<
     modifyMaybe_,
     modifyMaybe: (f) => (s) => modifyMaybe_(s, f),
     ...PTraversal<S, T, A, B>({
-      modifyA_: (A) => (s, f) =>
+      modifyA: (s, f, A) =>
         F.getOrModify(s).match(
           (t) => A.pure(t),
-          (a) => A.map_(f(a), (b) => F.replace_(s, b)),
+          (a) => f(a).map((b) => F.replace_(s, b), A),
         ),
     }),
   };

package/_src/optics/Traversal/api/compose.ts

@@ -8,6 +8,6 @@ export function compose_<S, T, A, B, C, D>(
   that: PTraversal<A, B, C, D>,
 ): PTraversal<S, T, C, D> {
   return PTraversal<S, T, C, D>({
-    modifyA_: (F) => (s, f) => self.modifyA_(F)(s, (a) => that.modifyA_(F)(a, f)),
+    modifyA: (s, f, F) => self.modifyA(s, (a) => that.modifyA(a, f, F), F),
   });
 }

package/_src/optics/Traversal/api/fromTraversable.ts

@@ -5,46 +5,20 @@ import { PTraversal } from "@fncts/base/optics/Traversal/definition";
 /**
  * @tsplus static fncts.optics.PTraversalOps fromTraversable
  */
-export function fromTraversable<T extends HKT, C = HKT.None>(
-  T: P.Traversable<T, C>,
-): <
-  A,
-  B,
-  K = HKT.Low<T, "K">,
-  Q = HKT.Low<T, "Q">,
-  W = HKT.Low<T, "W">,
-  X = HKT.Low<T, "X">,
-  I = HKT.Low<T, "I">,
-  S = HKT.Low<T, "S">,
-  R = HKT.Low<T, "R">,
-  E = HKT.Low<T, "E">,
-  K1 = HKT.Low<T, "K">,
-  Q1 = HKT.Low<T, "Q">,
-  W1 = HKT.Low<T, "W">,
-  X1 = HKT.Low<T, "X">,
-  I1 = HKT.Low<T, "I">,
-  S1 = HKT.Low<T, "S">,
-  R1 = HKT.Low<T, "R">,
-  E1 = HKT.Low<T, "E">,
->() => PTraversal<HKT.Kind<T, C, K, Q, W, X, I, S, R, E, A>, HKT.Kind<T, C, K1, Q1, W1, X1, I1, S1, R1, E1, B>, A, B>;
-export function fromTraversable<T>(
-  T: P.Traversable<HKT.F<T>>,
-): <A, B>() => PTraversal<
-  HKT.FK<T, any, any, any, any, any, any, any, any, A>,
-  HKT.FK<T, any, any, any, any, any, any, any, any, B>,
-  A,
-  B
-> {
-  return <A, B>() =>
-    PTraversal<
-      HKT.FK<T, any, any, any, any, any, any, any, any, A>,
-      HKT.FK<T, any, any, any, any, any, any, any, any, B>,
-      A,
-      B
-    >({
-      modifyA_: (F) => {
-        const traverseF_ = T.traverse_(F);
-        return (s, f) => traverseF_(s, f);
-      },
+export function fromTraversable<T extends HKT>(T: P.Traversable<T>) {
+  return <
+    A,
+    B,
+    K = HKT.Low<"K">,
+    Q = HKT.Low<"Q">,
+    W = HKT.Low<"W">,
+    X = HKT.Low<"X">,
+    I = HKT.Low<"I">,
+    S = HKT.Low<"S">,
+    R = HKT.Low<"R">,
+    E = HKT.Low<"E">,
+  >() =>
+    PTraversal<HKT.Kind<T, K, Q, W, X, I, S, R, E, A>, HKT.Kind<T, K, Q, W, X, I, S, R, E, B>, A, B>({
+      modifyA: (s, f, F) => T.traverse(s, f, F),
     });
 }

package/_src/optics/Traversal/definition.ts

@@ -7,12 +7,19 @@ import { PSetter } from "@fncts/base/optics/Setter";
  * @tsplus type fncts.optics.PTraversal
  */
 export interface PTraversal<S, T, A, B> extends PSetter<S, T, A, B>, Fold<S, A> {
-  readonly modifyA_: modifyA_<S, T, A, B>;
-  readonly modifyA: modifyA<S, T, A, B>;
+  modifyA<F extends HKT, K, Q, W, X, I, _S, R, E>(
+    s: S,
+    f: (a: A) => HKT.Kind<F, K, Q, W, X, I, _S, R, E, B>,
+    /** @tsplus auto */ F: Applicative<F>,
+  ): HKT.Kind<F, K, Q, W, X, I, _S, R, E, T>;
 }
 
 export interface PTraversalMin<S, T, A, B> {
-  readonly modifyA_: modifyA_<S, T, A, B>;
+  modifyA<F extends HKT, K, Q, W, X, I, _S, R, E>(
+    s: S,
+    f: (a: A) => HKT.Kind<F, K, Q, W, X, I, _S, R, E, B>,
+    /** @tsplus auto */ F: Applicative<F>,
+  ): HKT.Kind<F, K, Q, W, X, I, _S, R, E, T>;
 }
 
 /**
@@ -27,17 +34,21 @@ export const PTraversal: PTraversalOps = {};
  */
 export function mkPTraversal<S, T, A, B>(F: PTraversalMin<S, T, A, B>): PTraversal<S, T, A, B> {
   return {
-    modifyA_: F.modifyA_,
-    modifyA: (A) => (f) => (s) => F.modifyA_(A)(s, f),
-    ...PSetter({
-      modify_: (s, f) => F.modifyA_(Identity.Applicative)(s, f),
-      set_: (s, b) => F.modifyA_(Identity.Applicative)(s, () => b),
+    modifyA: F.modifyA,
+    ...PSetter<S, T, A, B>({
+      modify_: (s, f) =>
+        F.modifyA(
+          s,
+          f.compose((b) => Identity.get(b)),
+          Identity.Applicative,
+        ).getIdentity,
+      set_: (s, b) => F.modifyA(s, () => Identity.get(b), Identity.Applicative).getIdentity,
     }),
-    ...Fold({
+    ...Fold<S, A>({
       foldMap_:
         <M>(M: Monoid<M>) =>
         (s: S, f: (a: A) => M) =>
-          F.modifyA_(Const.getApplicative(M))(s, (a) => Const(f(a))),
+          F.modifyA(s, (a) => Const(f(a)), Const.getApplicative(M)).getConst,
     }),
   };
 }
@@ -58,16 +69,3 @@ export interface TraversalOps extends PTraversalOps {}
 export function mkTraversal<S, A>(F: PTraversalMin<S, S, A, A>): Traversal<S, A> {
   return PTraversal(F);
 }
-
-export interface modifyA_<S, T, A, B> {
-  <F extends HKT, C = HKT.None>(F: Applicative<F, C>): <K, Q, W, X, I, _S, R, E>(
-    s: S,
-    f: (a: A) => HKT.Kind<F, C, K, Q, W, X, I, _S, R, E, B>,
-  ) => HKT.Kind<F, C, K, Q, W, X, I, _S, R, E, T>;
-}
-
-export interface modifyA<S, T, A, B> {
-  <F extends HKT, C = HKT.None>(F: Applicative<F, C>): <K, Q, W, X, I, _S, R, E>(
-    f: (a: A) => HKT.Kind<F, C, K, Q, W, X, I, _S, R, E, B>,
-  ) => (s: S) => HKT.Kind<F, C, K, Q, W, X, I, _S, R, E, T>;
-}

package/_src/typeclass/Align.ts

@@ -1,28 +1,14 @@
-import type { Nil, NilMin } from "@fncts/base/typeclass/Nil";
-import type { SemialignMin } from "@fncts/base/typeclass/Semialign";
-
-import { Semialign } from "@fncts/base/typeclass/Semialign";
+import type { Nil } from "@fncts/base/typeclass/Nil";
+import type { Semialign } from "@fncts/base/typeclass/Semialign";
 
 /**
  * @tsplus type fncts.Align
  */
-export interface Align<F extends HKT, FC = HKT.None> extends Semialign<F, FC>, Nil<F, FC> {}
+export interface Align<F extends HKT> extends Semialign<F>, Nil<F> {}
 
 /**
  * @tsplus type fncts.AlignOps
  */
 export interface AlignOps {}
 
-export const Align: AlignOps = {};
-
-export type AlignMin<F extends HKT, FC = HKT.None> = SemialignMin<F, FC> & NilMin<F, FC>;
-
-/**
- * @tsplus static fncts.AlignOps __call
- */
-export function mkAlign<F extends HKT, FC = HKT.None>(F: AlignMin<F, FC>): Align<F, FC> {
-  return HKT.instance<Align<F, FC>>({
-    ...Semialign(F),
-    nil: F.nil,
-  });
-}
+export const Align: AlignOps = {};

package/_src/typeclass/Alt.ts

@@ -1,13 +1,37 @@
-import type { FunctorMin } from "@fncts/base/typeclass/Functor";
-
-import { Functor } from "@fncts/base/typeclass/Functor";
+import type { Functor } from "@fncts/base/typeclass/Functor";
 
 /**
  * @tsplus type fncts.Alt
  */
-export interface Alt<F extends HKT, FC = HKT.None> extends Functor<F, FC> {
-  readonly alt_: alt_<F, FC>;
-  readonly alt: alt<F, FC>;
+export interface Alt<F extends HKT> extends Functor<F> {
+  alt<K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B>(
+    fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
+    that: Lazy<
+      HKT.Kind<
+        F,
+        HKT.Intro<"K", K, K1>,
+        HKT.Intro<"Q", Q, Q1>,
+        HKT.Intro<"W", W, W1>,
+        HKT.Intro<"X", X, X1>,
+        HKT.Intro<"I", I, I1>,
+        HKT.Intro<"S", S, S1>,
+        HKT.Intro<"R", R, R1>,
+        HKT.Intro<"E", E, E1>,
+        HKT.Intro<"A", A, B>
+      >
+    >,
+  ): HKT.Kind<
+    F,
+    HKT.Mix<"K", [K, K1]>,
+    HKT.Mix<"Q", [Q, Q1]>,
+    HKT.Mix<"W", [W, W1]>,
+    HKT.Mix<"X", [X, X1]>,
+    HKT.Mix<"I", [I, I1]>,
+    HKT.Mix<"S", [S, S1]>,
+    HKT.Mix<"R", [R, R1]>,
+    HKT.Mix<"E", [E, E1]>,
+    HKT.Mix<"A", [A, B]>
+  >;
 }
 
 /**
@@ -17,89 +41,34 @@ export interface AltOps {}
 
 export const Alt: AltOps = {};
 
-export type AltMin<F extends HKT, FC = HKT.None> = FunctorMin<F, FC> & {
-  readonly alt_: alt_<F, FC>;
-};
-
-/**
- * @tsplus static fncts.AltOps __call
- */
-export function mkAlt<F extends HKT, C = HKT.None>(F: AltMin<F, C>): Alt<F, C>;
-export function mkAlt<F>(F: AltMin<HKT.F<F>>): Alt<HKT.F<F>> {
-  return HKT.instance<Alt<HKT.F<F>>>({
-    ...Functor(F),
-    alt_: F.alt_,
-    alt: (that) => (fa) => F.alt_(fa, that),
-  });
-}
-
-export interface alt<F extends HKT, C = HKT.None> {
-  <K1, Q1, W1, X1, I1, S1, R1, E1, B>(that: () => HKT.Kind<F, C, K1, Q1, W1, X1, I1, S1, R1, E1, B>): <
-    K,
-    Q,
-    W,
-    X,
-    I,
-    S,
-    R,
-    E,
-    A,
-  >(
-    fa: HKT.Kind<
+export function alt<F extends HKT, K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B>(
+  self: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
+  that: Lazy<
+    HKT.Kind<
       F,
-      C,
-      HKT.Intro<F, "K", K1, K>,
-      HKT.Intro<F, "Q", Q1, Q>,
-      HKT.Intro<F, "W", W1, W>,
-      HKT.Intro<F, "X", X1, X>,
-      HKT.Intro<F, "I", I1, I>,
-      HKT.Intro<F, "S", S1, S>,
-      HKT.Intro<F, "R", R1, R>,
-      HKT.Intro<F, "E", E1, E>,
-      HKT.Intro<F, "A", B, A>
-    >,
-  ) => HKT.Kind<
-    F,
-    C,
-    HKT.Mix<F, "K", [K1, K]>,
-    HKT.Mix<F, "Q", [Q1, Q]>,
-    HKT.Mix<F, "W", [W1, W]>,
-    HKT.Mix<F, "X", [X1, X]>,
-    HKT.Mix<F, "I", [I1, I]>,
-    HKT.Mix<F, "S", [S1, S]>,
-    HKT.Mix<F, "R", [R1, R]>,
-    HKT.Mix<F, "E", [E1, E]>,
-    HKT.Mix<F, "A", [B, A]>
-  >;
-}
-
-export interface alt_<F extends HKT, C = HKT.None> {
-  <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B>(
-    fa: HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>,
-    that: () => HKT.Kind<
-      F,
-      C,
-      HKT.Intro<F, "K", K, K1>,
-      HKT.Intro<F, "Q", Q, Q1>,
-      HKT.Intro<F, "W", W, W1>,
-      HKT.Intro<F, "X", X, X1>,
-      HKT.Intro<F, "I", I, I1>,
-      HKT.Intro<F, "S", S, S1>,
-      HKT.Intro<F, "R", R, R1>,
-      HKT.Intro<F, "E", E, E1>,
-      HKT.Intro<F, "A", A, B>
-    >,
-  ): HKT.Kind<
-    F,
-    C,
-    HKT.Mix<F, "K", [K, K1]>,
-    HKT.Mix<F, "Q", [Q, Q1]>,
-    HKT.Mix<F, "W", [W, W1]>,
-    HKT.Mix<F, "X", [X, X1]>,
-    HKT.Mix<F, "I", [I, I1]>,
-    HKT.Mix<F, "S", [S, S1]>,
-    HKT.Mix<F, "R", [R, R1]>,
-    HKT.Mix<F, "E", [E, E1]>,
-    HKT.Mix<F, "A", [A, B]>
-  >;
+      HKT.Intro<"K", K, K1>,
+      HKT.Intro<"Q", Q, Q1>,
+      HKT.Intro<"W", W, W1>,
+      HKT.Intro<"X", X, X1>,
+      HKT.Intro<"I", I, I1>,
+      HKT.Intro<"S", S, S1>,
+      HKT.Intro<"R", R, R1>,
+      HKT.Intro<"E", E, E1>,
+      HKT.Intro<"A", A, B>
+    >
+  >,
+  /** @tsplus auto */ F: Alt<F>,
+): HKT.Kind<
+  F,
+  HKT.Mix<"K", [K, K1]>,
+  HKT.Mix<"Q", [Q, Q1]>,
+  HKT.Mix<"W", [W, W1]>,
+  HKT.Mix<"X", [X, X1]>,
+  HKT.Mix<"I", [I, I1]>,
+  HKT.Mix<"S", [S, S1]>,
+  HKT.Mix<"R", [R, R1]>,
+  HKT.Mix<"E", [E, E1]>,
+  HKT.Mix<"A", [A, B]>
+> {
+  return F.alt(self, that);
 }

package/_src/typeclass/Alternative.ts

@@ -1,14 +1,11 @@
-import type { AltMin } from "@fncts/base/typeclass/Alt";
-import type { ApplicativeMin } from "@fncts/base/typeclass/Applicative";
-import type { Nil, NilMin } from "@fncts/base/typeclass/Nil";
-
-import { Alt } from "@fncts/base/typeclass/Alt";
-import { Applicative } from "@fncts/base/typeclass/Applicative";
+import type { Alt } from "@fncts/base/typeclass/Alt";
+import type { Applicative } from "@fncts/base/typeclass/Applicative";
+import type { Nil } from "@fncts/base/typeclass/Nil";
 
 /**
  * @tsplus type fncts.Alternative
  */
-export interface Alternative<F extends HKT, FC = HKT.None> extends Applicative<F, FC>, Nil<F, FC>, Alt<F, FC> {}
+export interface Alternative<F extends HKT> extends Applicative<F>, Nil<F>, Alt<F> {}
 
 /**
  * @tsplus type fncts.AlternativeOps
@@ -16,16 +13,3 @@ export interface Alternative<F extends HKT, FC = HKT.None> extends Applicative<F
 export interface AlternativeOps {}
 
 export const Alternative: AlternativeOps = {};
-
-export type AlternativeMin<F extends HKT, FC = HKT.None> = ApplicativeMin<F, FC> & NilMin<F, FC> & AltMin<F, FC>;
-
-/**
- * @tsplus static fncts.AlternativeOps __call
- */
-export function mkAlternative<F extends HKT, C = HKT.None>(F: AlternativeMin<F, C>): Alternative<F, C> {
-  return HKT.instance<Alternative<F, C>>({
-    ...Applicative(F),
-    ...Alt(F),
-    nil: F.nil,
-  });
-}

package/_src/typeclass/Applicative.ts

@@ -1,10 +1,7 @@
-import type { ApplyMin } from "@fncts/base/typeclass/Apply";
-import type { PointedMin } from "@fncts/base/typeclass/Pointed";
+import type { Apply } from "@fncts/base/typeclass/Apply";
+import type { Pointed } from "@fncts/base/typeclass/Pointed";
 
-import { Apply } from "@fncts/base/typeclass/Apply";
-import { Pointed } from "@fncts/base/typeclass/Pointed";
-
-export interface Applicative<F extends HKT, FC = HKT.None> extends Apply<F, FC>, Pointed<F, FC> {}
+export interface Applicative<F extends HKT> extends Apply<F>, Pointed<F> {}
 
 /**
  * @tsplus type fncts.ApplicativeOps
@@ -12,20 +9,3 @@ export interface Applicative<F extends HKT, FC = HKT.None> extends Apply<F, FC>,
 export interface ApplicativeOps {}
 
 export const Applicative: ApplicativeOps = {};
-
-export type ApplicativeMin<F extends HKT, FC = HKT.None> = ApplyMin<F, FC> & PointedMin<F, FC>;
-
-/**
- * @tsplus static fncts.ApplicativeOps __call
- */
-export function mkApplicative<F extends HKT, FC = HKT.None>(F: ApplicativeMin<F, FC>): Applicative<F, FC> {
-  return HKT.instance<Applicative<F, FC>>({
-    ...Pointed(F),
-    ...Apply(F),
-  });
-}
-
-export type CompatibleApplicative<F extends HKT, C, A> = Applicative<F, C> &
-  ([A] extends [HKT.Kind<F, any, any, any, any, any, any, any, any, any, any>]
-    ? unknown
-    : ["invalid Applicative instance for", A]);