@fncts/base 0.0.1

package/optics/At/definition.d.ts

@@ -0,0 +1,22 @@
+import { Lens } from "@fncts/base/optics/Lens";
+/**
+ * @tsplus type fncts.optics.At
+ */
+export interface At<S, I, A> {
+    readonly at: (i: I) => Lens<S, A>;
+}
+export declare type AtMin<S, I, A> = {
+    readonly get: (i: I) => (s: S) => A;
+    readonly set: (i: I) => (s: S, a: A) => S;
+} | At<S, I, A>;
+/**
+ * @tsplus type fncts.optics.AtOps
+ */
+export interface AtOps {
+}
+export declare const At: AtOps;
+/**
+ * @tsplus static fncts.optics.AtOps __call
+ * @tsplus location "@fncts/base/optics/At/definition"
+ */
+export declare function mkAt<S, I, A>(F: AtMin<S, I, A>): At<S, I, A>;

package/optics/At.d.ts

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

package/optics/Fold/definition.d.ts

@@ -0,0 +1,28 @@
+import type { Monoid } from "@fncts/base/typeclass";
+export interface foldMap_<S, A> {
+    <M>(M: Monoid<M>): (s: S, f: (a: A) => M) => M;
+}
+export interface foldMap<S, A> {
+    <M>(M: Monoid<M>): (f: (a: A) => M) => (s: S) => M;
+}
+/**
+ * @tsplus type fncts.optics.Fold
+ */
+export interface Fold<S, A> {
+    readonly foldMap_: foldMap_<S, A>;
+    readonly foldMap: foldMap<S, A>;
+}
+/**
+ * @tsplus type fncts.optics.FoldOps
+ */
+export interface FoldOps {
+}
+export declare const Fold: FoldOps;
+export interface FoldMin<S, A> {
+    readonly foldMap_: foldMap_<S, A>;
+}
+/**
+ * @tsplus static fncts.optics.FoldOps __call
+ * @tsplus location "@fncts/base/optics/Fold/definition"
+ */
+export declare function mkFold<S, A>(F: FoldMin<S, A>): Fold<S, A>;

package/optics/Fold.d.ts

@@ -0,0 +1 @@
+export * from "./Fold/definition.js";

package/optics/Getter/definition.d.ts

@@ -0,0 +1,24 @@
+import type { Fold } from "@fncts/base/optics/Fold";
+export interface get<S, A> {
+    (s: S): A;
+}
+/**
+ * @tsplus type fncts.optics.Getter
+ */
+export interface Getter<S, A> extends Fold<S, A> {
+    readonly get: get<S, A>;
+}
+/**
+ * @tsplus type fncts.optics.GetterOps
+ */
+export interface GetterOps {
+}
+export declare const Getter: GetterOps;
+export interface GetterMin<S, A> {
+    readonly get: get<S, A>;
+}
+/**
+ * @tsplus static fncts.optics.GetterOps __call
+ * @tsplus location "@fncts/base/optics/Getter/definition"
+ */
+export declare function mkGetter<S, A>(F: GetterMin<S, A>): Getter<S, A>;

package/optics/Getter.d.ts

@@ -0,0 +1 @@
+export * from "./Getter/definition.js";

package/optics/Index/api.d.ts

@@ -0,0 +1,14 @@
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import type { At } from "@fncts/base/optics/At";
+import type { Iso } from "@fncts/base/optics/Iso";
+import { Index } from "@fncts/base/optics/Index/definition";
+/**
+ * @tsplus static fncts.optics.IndexOps fromAt
+ * @tsplus location "@fncts/base/optics/Index/api"
+ */
+export declare function fromAt<T, J, B>(at: At<T, J, Maybe<B>>): Index<T, J, B>;
+/**
+ * @tsplus static fncts.optics.IndexOps fromIso
+ * @tsplus location "@fncts/base/optics/Index/api"
+ */
+export declare function fromIso<T, S>(iso: Iso<T, S>): <I, A>(index: Index<S, I, A>) => Index<T, I, A>;

package/optics/Index/definition.d.ts

@@ -0,0 +1,19 @@
+import type { Optional } from "@fncts/base/optics/Optional";
+/**
+ * @tsplus type fncts.optics.Index
+ */
+export interface Index<S, I, A> {
+    readonly index: (i: I) => Optional<S, A>;
+}
+export declare type IndexMin<S, I, A> = Index<S, I, A>;
+/**
+ * @tsplus type fncts.optics.IndexOps
+ */
+export interface IndexOps {
+}
+export declare const Index: IndexOps;
+/**
+ * @tsplus static fncts.optics.IndexOps __call
+ * @tsplus location "@fncts/base/optics/Index/definition"
+ */
+export declare function mkIndex<S, I, A>(F: IndexMin<S, I, A>): Index<S, I, A>;

package/optics/Index.d.ts

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

package/optics/Iso/api.d.ts

@@ -0,0 +1,6 @@
+import { PIso } from "@fncts/base/optics/Iso/definition";
+/**
+ * @tsplus fluent fncts.optics.PIso compose
+ * @tsplus location "@fncts/base/optics/Iso/api"
+ */
+export declare function compose_<S, T, A, B, C, D>(self: PIso<S, T, A, B>, that: PIso<A, B, C, D>): PIso<S, T, C, D>;

package/optics/Iso/definition.d.ts

@@ -0,0 +1,40 @@
+import type { get } from "@fncts/base/optics/Getter";
+import type { reverseGet } from "@fncts/base/optics/Prism";
+import { PLens } from "@fncts/base/optics/Lens";
+import { PPrism } from "@fncts/base/optics/Prism";
+/**
+ * @tsplus type fncts.optics.PIso
+ */
+export interface PIso<S, T, A, B> extends PLens<S, T, A, B>, PPrism<S, T, A, B> {
+    readonly reverse: () => PIso<B, A, T, S>;
+}
+/**
+ * @tsplus type fncts.optics.PIsoOps
+ */
+export interface PIsoOps {
+}
+export declare const PIso: PIsoOps;
+export interface PIsoMin<S, T, A, B> {
+    readonly get: get<S, A>;
+    readonly reverseGet: reverseGet<T, B>;
+}
+/**
+ * @tsplus static fncts.optics.PIsoOps __call
+ * @tsplus location "@fncts/base/optics/Iso/definition"
+ */
+export declare function mkPIso<S, T, A, B>(F: PIsoMin<S, T, A, B>): PIso<S, T, A, B>;
+/**
+ * @tsplus type fncts.optics.Iso
+ */
+export interface Iso<S, A> extends PIso<S, S, A, A> {
+}
+/**
+ * @tsplus type fncts.optics.IsoOps
+ */
+export interface IsoOps {
+}
+/**
+ * @tsplus static fncts.optics.IsoOps __call
+ * @tsplus location "@fncts/base/optics/Iso/definition"
+ */
+export declare function mkIso<S, A>(F: PIsoMin<S, S, A, A>): Iso<S, A>;

package/optics/Iso.d.ts

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

package/optics/Lens/api.d.ts

@@ -0,0 +1,49 @@
+import { ReadonlyNonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
+import type { Optional } from "@fncts/base/optics/Optional";
+import type { AutoPath, Path } from "@fncts/typelevel/Object";
+import { Lens, PLens } from "@fncts/base/optics/Lens/definition";
+/**
+ * @tsplus fluent fncts.optics.PLens component
+ * @tsplus location "@fncts/base/optics/Lens/api"
+ */
+export declare function component_<S, A extends ReadonlyArray<unknown>, P extends keyof A>(self: Lens<S, A>, component: P): Lens<S, A[P]>;
+/**
+ * @tsplus fluent fncts.optics.PLens compose
+ * @tsplus location "@fncts/base/optics/Lens/api"
+ */
+export declare function compose_<S, T, A, B, C, D>(self: PLens<S, T, A, B>, that: PLens<A, B, C, D>): PLens<S, T, C, D>;
+/**
+ * @tsplus static fncts.optics.PLensOps fromNullable
+ * @tsplus location "@fncts/base/optics/Lens/api"
+ */
+export declare function fromNullable<S, A>(self: Lens<S, A>): Optional<S, NonNullable<A>>;
+/**
+ * @tsplus static fncts.optics.PLensOps getComponent
+ * @tsplus location "@fncts/base/optics/Lens/api"
+ */
+export declare function getComponent<A extends ReadonlyArray<unknown>>(): <P extends keyof A>(component: P) => Lens<A, A[P]>;
+/**
+ * @tsplus static fncts.optics.PLensOps getProp
+ * @tsplus location "@fncts/base/optics/Lens/api"
+ */
+export declare function getProp<A extends Record<string, any>>(): <P extends keyof A>(prop: P) => Lens<A, A[P]>;
+/**
+ * @tsplus static fncts.optics.PLensOps id
+ * @tsplus location "@fncts/base/optics/Lens/api"
+ */
+export declare function id<S, A = S>(): PLens<S, A, S, A>;
+/**
+ * @tsplus fluent fncts.optics.PLensOps invmap
+ * @tsplus location "@fncts/base/optics/Lens/api"
+ */
+export declare function invmap_<S, A, B>(self: Lens<S, A>, f: (a: A) => B, g: (b: B) => A): Lens<S, B>;
+/**
+ * @tsplus fluent fncts.optics.Lens prop
+ * @tsplus location "@fncts/base/optics/Lens/api"
+ */
+export declare function prop_<S, A extends Record<string, any>, P extends keyof A>(self: Lens<S, A>, prop: P): Lens<S, A[P]>;
+/**
+ * @tsplus fluent fncts.optics.Lens path
+ * @tsplus location "@fncts/base/optics/Lens/api"
+ */
+export declare function path_<S, A extends Record<string, unknown>, P extends Array<string>>(self: Lens<S, A>, path: readonly [...AutoPath<A, P>]): Lens<S, Path<A, P>>;

package/optics/Lens/definition.d.ts

@@ -0,0 +1,40 @@
+import type { get } from "@fncts/base/optics/Getter";
+import type { set_ } from "@fncts/base/optics/Setter";
+import { Getter } from "@fncts/base/optics/Getter";
+import { POptional } from "@fncts/base/optics/Optional";
+/**
+ * @tsplus type fncts.optics.PLens
+ */
+export interface PLens<S, T, A, B> extends POptional<S, T, A, B>, Getter<S, A> {
+}
+/**
+ * @tsplus type fncts.optics.PLensOps
+ */
+export interface PLensOps {
+}
+export declare const PLens: PLensOps;
+export interface PLensMin<S, T, A, B> {
+    readonly get: get<S, A>;
+    readonly set_: set_<S, T, B>;
+}
+/**
+ * @tsplus static fncts.optics.PLensOps __call
+ * @tsplus location "@fncts/base/optics/Lens/definition"
+ */
+export declare function mkPLens<S, T, A, B>(F: PLensMin<S, T, A, B>): PLens<S, T, A, B>;
+/**
+ * @tsplus type fncts.optics.Lens
+ */
+export interface Lens<S, A> extends PLens<S, S, A, A> {
+}
+/**
+ * @tsplus type fncts.optics.LensOps
+ */
+export interface LensOps extends PLensOps {
+}
+export declare const Lens: LensOps;
+/**
+ * @tsplus static fncts.optics.LensOps __call
+ * @tsplus location "@fncts/base/optics/Lens/definition"
+ */
+export declare function mkLens<S, A>(F: PLensMin<S, S, A, A>): Lens<S, A>;

package/optics/Lens.d.ts

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

package/optics/Optional/api/compose.d.ts

@@ -0,0 +1,6 @@
+import { POptional } from "@fncts/base/optics/Optional/definition";
+/**
+ * @tsplus fluent fncts.optics.POptional compose 3
+ * @tsplus location "@fncts/base/optics/Optional/api/compose"
+ */
+export declare function compose_<S, T, A, B, C, D>(self: POptional<S, T, A, B>, that: POptional<A, B, C, D>): POptional<S, T, C, D>;

package/optics/Optional/definition.d.ts

@@ -0,0 +1,62 @@
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Either } from "@fncts/base/data/Either/definition";
+import type { set_ } from "@fncts/base/optics/Setter";
+import { PTraversal } from "@fncts/base/optics/Traversal";
+/**
+ * @tsplus type fncts.optics.POptional
+ */
+export interface POptional<S, T, A, B> extends PTraversal<S, T, A, B> {
+    readonly getMaybe: getMaybe<S, A>;
+    readonly getOrModify: getOrModify<S, T, A>;
+    readonly modifyMaybe_: modifyMaybe_<S, T, A, B>;
+    readonly modifyMaybe: modifyMaybe<S, T, A, B>;
+}
+export interface POptionalMin<S, T, A, B> {
+    readonly getOrModify: getOrModify<S, T, A>;
+    readonly replace_: set_<S, T, B>;
+}
+/**
+ * @tsplus type fncts.optics.POptionalOps
+ */
+export interface POptionalOps {
+}
+export declare const POptional: POptionalOps;
+/**
+ * @tsplus static fncts.optics.POptionalOps __call
+ * @tsplus location "@fncts/base/optics/Optional/definition"
+ */
+export declare function mkPOptional<S, T, A, B>(F: POptionalMin<S, T, A, B>): POptional<S, T, A, B>;
+/**
+ * @tsplus type fncts.optics.Optional
+ */
+export interface Optional<S, A> extends POptional<S, S, A, A> {
+}
+/**
+ * @tsplus type fncts.optics.OptionalOps
+ */
+export interface OptionalOps extends POptionalOps {
+}
+export declare const Optional: OptionalOps;
+/**
+ * @tsplus static fncts.optics.OptionalOps __call
+ * @tsplus location "@fncts/base/optics/Optional/definition"
+ */
+export declare function mkOptional<S, A>(F: POptionalMin<S, S, A, A>): Optional<S, A>;
+export interface getMaybe<S, A> {
+    (s: S): Maybe<A>;
+}
+export interface getOrModify<S, T, A> {
+    (s: S): Either<T, A>;
+}
+export interface modifyMaybe_<S, T, A, B> {
+    (s: S, f: (a: A) => B): Maybe<T>;
+}
+export interface modifyMaybe<S, T, A, B> {
+    (f: (a: A) => B): (s: S) => Maybe<T>;
+}
+export interface replaceMaybe_<S, T, B> {
+    (s: S, b: B): Maybe<T>;
+}
+export interface replaceMaybe<S, T, B> {
+    (b: B): (s: S) => Maybe<T>;
+}

package/optics/Optional.d.ts

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

package/optics/Prism/api/compose.d.ts

@@ -0,0 +1,6 @@
+import { PPrism } from "@fncts/base/optics/Prism/definition";
+/**
+ * @tsplus fluent fncts.optics.PPrism compose
+ * @tsplus location "@fncts/base/optics/Prism/api/compose"
+ */
+export declare function compose_<S, T, A, B, C, D>(self: PPrism<S, T, A, B>, that: PPrism<A, B, C, D>): PPrism<S, T, C, D>;

package/optics/Prism/api/fromNullable.d.ts

@@ -0,0 +1,6 @@
+import { Prism } from "@fncts/base/optics/Prism/definition";
+/**
+ * @tsplus static fncts.optics.PPrismOps fromNullable
+ * @tsplus location "@fncts/base/optics/Prism/api/fromNullable"
+ */
+export declare function fromNullable<A>(): Prism<A, NonNullable<A>>;

package/optics/Prism/api/just.d.ts

@@ -0,0 +1,7 @@
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Prism } from "@fncts/base/optics/Prism/definition";
+/**
+ * @tsplus static fncts.optics.PPrismOps just
+ * @tsplus location "@fncts/base/optics/Prism/api/just"
+ */
+export declare function just<A>(): Prism<Maybe<A>, A>;

package/optics/Prism/definition.d.ts

@@ -0,0 +1,42 @@
+import type { getOrModify } from "@fncts/base/optics/Optional";
+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 declare 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
+ * @tsplus location "@fncts/base/optics/Prism/definition"
+ */
+export declare function mkPPrism<S, T, A, B>(F: PPrismMin<S, T, A, B>): PPrism<S, T, A, 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 declare const Prism: PrismOps;
+/**
+ * @tsplus static fncts.optics.PrismOps __call
+ * @tsplus location "@fncts/base/optics/Prism/definition"
+ */
+export declare function mkPrism<S, A>(F: PPrismMin<S, S, A, A>): Prism<S, A>;
+export interface reverseGet<T, B> {
+    (b: B): T;
+}

package/optics/Prism.d.ts

@@ -0,0 +1,4 @@
+export * from "./Prism/definition.js";
+export * from "./Prism/api/compose.js";
+export * from "./Prism/api/fromNullable.js";
+export * from "./Prism/api/just.js";

package/optics/Setter/definition.d.ts

@@ -0,0 +1,51 @@
+/**
+ * @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 declare const PSetter: PSetterOps;
+/**
+ * @tsplus static fncts.optics.PSetterOps __call
+ * @tsplus location "@fncts/base/optics/Setter/definition"
+ */
+export declare function mkPSetter<S, T, A, B>(F: PSetterMin<S, T, A, B>): PSetter<S, T, A, 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
+ * @tsplus location "@fncts/base/optics/Setter/definition"
+ */
+export declare function mkSetter<S, A>(F: PSetterMin<S, S, A, A>): Setter<S, A>;
+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/optics/Setter.d.ts

@@ -0,0 +1 @@
+export * from "./Setter/definition.js";

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

@@ -0,0 +1,6 @@
+import { PTraversal } from "@fncts/base/optics/Traversal/definition";
+/**
+ * @tsplus fluent fncts.optics.PTraversal compose 4
+ * @tsplus location "@fncts/base/optics/Traversal/api/compose"
+ */
+export declare 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>;

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

@@ -0,0 +1,8 @@
+import { HKT } from "@fncts/typelevel/HKT";
+import type * as P from "@fncts/base/typeclass";
+import { PTraversal } from "@fncts/base/optics/Traversal/definition";
+/**
+ * @tsplus static fncts.optics.PTraversalOps fromTraversable
+ * @tsplus location "@fncts/base/optics/Traversal/api/fromTraversable"
+ */
+export declare 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>;

package/optics/Traversal/definition.d.ts

@@ -0,0 +1,46 @@
+import { HKT } from "@fncts/typelevel/HKT";
+import type { Applicative } 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 declare const PTraversal: PTraversalOps;
+/**
+ * @tsplus static fncts.optics.PTraversalOps __call
+ * @tsplus location "@fncts/base/optics/Traversal/definition"
+ */
+export declare function mkPTraversal<S, T, A, B>(F: PTraversalMin<S, T, A, B>): PTraversal<S, T, A, B>;
+/**
+ * @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
+ * @tsplus location "@fncts/base/optics/Traversal/definition"
+ */
+export declare function mkTraversal<S, A>(F: PTraversalMin<S, S, A, A>): Traversal<S, A>;
+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/optics/Traversal.d.ts

@@ -0,0 +1,3 @@
+export * from "./Traversal/definition.js";
+export * from "./Traversal/api/compose.js";
+export * from "./Traversal/api/fromTraversable.js";

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@fncts/base",
+  "version": "0.0.1",
+  "dependencies": {
+    "@fncts/typelevel": "0.0.1"
+  },
+  "exports": {
+    "./*": {
+      "import": "./_mjs/*",
+      "require": "./_cjs/*"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/typeclass/Align.d.ts

@@ -0,0 +1,21 @@
+import { HKT } from "@fncts/typelevel/HKT";
+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 declare const Align: AlignOps;
+export declare type AlignMin<F extends HKT, FC = HKT.None> = SemialignMin<F, FC> & NilMin<F, FC>;
+/**
+ * @tsplus static fncts.AlignOps __call
+ * @tsplus location "@fncts/base/typeclass/Align"
+ */
+export declare function mkAlign<F extends HKT, FC = HKT.None>(F: AlignMin<F, FC>): Align<F, FC>;

package/typeclass/Alt.d.ts

@@ -0,0 +1,30 @@
+import { HKT } from "@fncts/typelevel/HKT";
+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 declare const Alt: AltOps;
+export declare type AltMin<F extends HKT, FC = HKT.None> = FunctorMin<F, FC> & {
+    readonly alt_: alt_<F, FC>;
+};
+/**
+ * @tsplus static fncts.AltOps __call
+ * @tsplus location "@fncts/base/typeclass/Alt"
+ */
+export declare function mkAlt<F extends HKT, C = HKT.None>(F: AltMin<F, C>): Alt<F, C>;
+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/typeclass/Alternative.d.ts

@@ -0,0 +1,23 @@
+import { HKT } from "@fncts/typelevel/HKT";
+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 declare const Alternative: AlternativeOps;
+export declare type AlternativeMin<F extends HKT, FC = HKT.None> = ApplicativeMin<F, FC> & NilMin<F, FC> & AltMin<F, FC>;
+/**
+ * @tsplus static fncts.AlternativeOps __call
+ * @tsplus location "@fncts/base/typeclass/Alternative"
+ */
+export declare function mkAlternative<F extends HKT, C = HKT.None>(F: AlternativeMin<F, C>): Alternative<F, C>;