@fncts/base 0.0.1

package/_src/optics/Prism/definition.ts

@@ -0,0 +1,59 @@
+import type { getOrModify } from "@fncts/base/optics/Optional";
+
+import { identity } from "@fncts/base/data/function";
+import { POptional } from "@fncts/base/optics/Optional";
+
+/**
+ * @tsplus type fncts.optics.PPrism
+ */
+export interface PPrism<S, T, A, B> extends POptional<S, T, A, B> {
+  readonly reverseGet: reverseGet<T, B>;
+}
+
+/**
+ * @tsplus type fncts.optics.PPrismOps
+ */
+export interface PPrismOps {}
+
+export const PPrism: PPrismOps = {};
+
+export interface PPrismMin<S, T, A, B> {
+  readonly getOrModify: getOrModify<S, T, A>;
+  readonly reverseGet: reverseGet<T, B>;
+}
+
+/**
+ * @tsplus static fncts.optics.PPrismOps __call
+ */
+export function mkPPrism<S, T, A, B>(F: PPrismMin<S, T, A, B>): PPrism<S, T, A, B> {
+  return {
+    reverseGet: F.reverseGet,
+    ...POptional({
+      getOrModify: F.getOrModify,
+      replace_: (s, b) => F.getOrModify(s).match(identity, () => F.reverseGet(b)),
+    }),
+  };
+}
+
+/**
+ * @tsplus type fncts.optics.Prism
+ */
+export interface Prism<S, A> extends PPrism<S, S, A, A> {}
+
+/**
+ * @tsplus type fncts.optics.PrismOps
+ */
+export interface PrismOps extends PPrismOps {}
+
+export const Prism: PrismOps = {};
+
+/**
+ * @tsplus static fncts.optics.PrismOps __call
+ */
+export function mkPrism<S, A>(F: PPrismMin<S, S, A, A>): Prism<S, A> {
+  return PPrism(F);
+}
+
+export interface reverseGet<T, B> {
+  (b: B): T;
+}

package/_src/optics/Prism.ts

@@ -0,0 +1,9 @@
+// codegen:start { preset: barrel, include: ./Prism/*.ts }
+export * from "./Prism/definition.js";
+// codegen:end
+
+// codegen:start { preset: barrel, include: ./Prism/api/*.ts }
+export * from "./Prism/api/compose.js";
+export * from "./Prism/api/fromNullable.js";
+export * from "./Prism/api/just.js";
+// codegen:end

package/_src/optics/Setter/definition.ts

@@ -0,0 +1,66 @@
+/**
+ * @tsplus type fncts.optics.PSetter
+ */
+export interface PSetter<S, T, A, B> {
+  readonly modify_: modify_<S, T, A, B>;
+  readonly modify: modify<S, T, A, B>;
+  readonly set_: set_<S, T, B>;
+  readonly set: set<S, T, B>;
+}
+
+export interface PSetterMin<S, T, A, B> {
+  readonly modify_: modify_<S, T, A, B>;
+  readonly set_: set_<S, T, B>;
+}
+
+/**
+ * @tsplus type fncts.optics.PSetterOps
+ */
+export interface PSetterOps {}
+
+export const PSetter: PSetterOps = {};
+
+/**
+ * @tsplus static fncts.optics.PSetterOps __call
+ */
+export function mkPSetter<S, T, A, B>(F: PSetterMin<S, T, A, B>): PSetter<S, T, A, B> {
+  return {
+    modify_: F.modify_,
+    modify: (f) => (s) => F.modify_(s, f),
+    set_: F.set_,
+    set: (b) => (s) => F.set_(s, b),
+  };
+}
+
+/**
+ * @tsplus type fncts.optics.Setter
+ */
+export interface Setter<S, A> extends PSetter<S, S, A, A> {}
+
+/**
+ * @tsplus type fncts.optics.SetterOps
+ */
+export interface SetterOps extends PSetterOps {}
+
+/**
+ * @tsplus static fncts.optics.SetterOps __call
+ */
+export function mkSetter<S, A>(F: PSetterMin<S, S, A, A>): Setter<S, A> {
+  return PSetter(F);
+}
+
+export interface modify_<S, T, A, B> {
+  (s: S, f: (a: A) => B): T;
+}
+
+export interface modify<S, T, A, B> {
+  (f: (a: A) => B): (s: S) => T;
+}
+
+export interface set_<S, T, B> {
+  (s: S, b: B): T;
+}
+
+export interface set<S, T, B> {
+  (b: B): (s: S) => T;
+}

package/_src/optics/Setter.ts

@@ -0,0 +1,3 @@
+// codegen:start { preset: barrel, include: ./Setter/*.ts }
+export * from "./Setter/definition.js";
+// codegen:end

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

@@ -0,0 +1,13 @@
+import { PTraversal } from "@fncts/base/optics/Traversal/definition";
+
+/**
+ * @tsplus fluent fncts.optics.PTraversal compose 4
+ */
+export function compose_<S, T, A, B, C, D>(
+  self: PTraversal<S, T, A, B>,
+  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)),
+  });
+}

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

@@ -0,0 +1,50 @@
+import type * as P from "@fncts/base/typeclass";
+
+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);
+      },
+    });
+}

package/_src/optics/Traversal/definition.ts

@@ -0,0 +1,73 @@
+import type { Applicative, Monoid } from "@fncts/base/typeclass";
+
+import { Fold } from "@fncts/base/optics/Fold";
+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>;
+}
+
+export interface PTraversalMin<S, T, A, B> {
+  readonly modifyA_: modifyA_<S, T, A, B>;
+}
+
+/**
+ * @tsplus type fncts.optics.PTraversalOps
+ */
+export interface PTraversalOps {}
+
+export const PTraversal: PTraversalOps = {};
+
+/**
+ * @tsplus static fncts.optics.PTraversalOps __call
+ */
+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),
+    }),
+    ...Fold({
+      foldMap_:
+        <M>(M: Monoid<M>) =>
+        (s: S, f: (a: A) => M) =>
+          F.modifyA_(Const.getApplicative(M))(s, (a) => Const(f(a))),
+    }),
+  };
+}
+
+/**
+ * @tsplus type fncts.optics.Traversal
+ */
+export interface Traversal<S, A> extends PTraversal<S, S, A, A> {}
+
+/**
+ * @tsplus type fncts.optics.TraversalOps
+ */
+export interface TraversalOps extends PTraversalOps {}
+
+/**
+ * @tsplus static fncts.optics.TraversalOps __call
+ */
+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/optics/Traversal.ts

@@ -0,0 +1,8 @@
+// codegen:start { preset: barrel, include: ./Traversal/*.ts }
+export * from "./Traversal/definition.js";
+// codegen:end
+
+// codegen:start { preset: barrel, include: ./Traversal/api/*.ts }
+export * from "./Traversal/api/compose.js";
+export * from "./Traversal/api/fromTraversable.js";
+// codegen:end

package/_src/typeclass/Align.ts

@@ -0,0 +1,28 @@
+import type { Nil, NilMin } from "@fncts/base/typeclass/Nil";
+import type { SemialignMin } from "@fncts/base/typeclass/Semialign";
+
+import { 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> {}
+
+/**
+ * @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,
+  });
+}

package/_src/typeclass/Alt.ts

@@ -0,0 +1,105 @@
+import type { FunctorMin } from "@fncts/base/typeclass/Functor";
+
+import { 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>;
+}
+
+/**
+ * @tsplus type fncts.AltOps
+ */
+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<
+      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]>
+  >;
+}

package/_src/typeclass/Alternative.ts

@@ -0,0 +1,31 @@
+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";
+
+/**
+ * @tsplus type fncts.Alternative
+ */
+export interface Alternative<F extends HKT, FC = HKT.None> extends Applicative<F, FC>, Nil<F, FC>, Alt<F, FC> {}
+
+/**
+ * @tsplus type fncts.AlternativeOps
+ */
+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

@@ -0,0 +1,31 @@
+import type { ApplyMin } from "@fncts/base/typeclass/Apply";
+import type { PointedMin } 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> {}
+
+/**
+ * @tsplus type fncts.ApplicativeOps
+ */
+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]);