@fncts/base 0.0.20 → 0.0.22

package/_src/data/string/instances.ts

@@ -6,19 +6,19 @@ import * as P from "../../typeclass.js";
  * @tsplus static fncts.StringOps Eq
  * @tsplus implicit
  */
-export const Eq: P.Eq<string> = P.Eq({ equals: (x, y) => x === y });
+export const Eq: P.Eq<string> = P.Eq({ equals: (y) => (x) => x === y });
 
 /**
  * @tsplus static fncts.StringOps Semigroup
  * @tsplus implicit
  */
-export const Semigroup: P.Semigroup<string> = P.Semigroup({ combine: (x, y) => x + y });
+export const Semigroup: P.Semigroup<string> = P.Semigroup({ combine: (y) => (x) => x + y });
 
 /**
  * @tsplus static fncts.StringOps Monoid
  * @tsplus implicit
  */
-export const Monoid: P.Monoid<string> = P.Monoid({ combine: (x, y) => x + y, nat: "" });
+export const Monoid: P.Monoid<string> = P.Monoid({ combine: (y) => (x) => x + y, nat: "" });
 
 /**
  * @tsplus static fncts.StringOps Ord
@@ -26,7 +26,7 @@ export const Monoid: P.Monoid<string> = P.Monoid({ combine: (x, y) => x + y, nat
  */
 export const Ord: P.Ord<string> = P.Ord({
   ...Eq,
-  compare: (x, y) => (x < y ? -1 : x > y ? 1 : 0),
+  compare: (y) => (x) => x < y ? -1 : x > y ? 1 : 0,
 });
 
 /**

package/_src/data.ts

@@ -10,13 +10,20 @@ export type {} from "./data/DecodeError.js";
 export type {} from "./data/Decoder.js";
 export type {} from "./data/Duration.js";
 export type {} from "./data/Either.js";
+export type {} from "./data/Encoder.js";
 export type {} from "./data/Environment.js";
 export type {} from "./data/EnvironmentPatch.js";
+export type {} from "./data/Eq.js";
+export type {} from "./data/Equatable.js";
 export type {} from "./data/exceptions.js";
 export type {} from "./data/ExecutionStrategy.js";
 export type {} from "./data/Exit.js";
 export type {} from "./data/FiberId.js";
 export type {} from "./data/function.js";
+export type {} from "./data/Guard.js";
+export type {} from "./data/Hash.js";
+export type {} from "./data/Hashable.js";
+export type {} from "./data/HashEq.js";
 export type {} from "./data/Identity.js";
 export type {} from "./data/Interval.js";
 export type {} from "./data/Intervals.js";
@@ -24,8 +31,11 @@ export type {} from "./data/Maybe.js";
 export type {} from "./data/Newtype.js";
 export type {} from "./data/number.js";
 export type {} from "./data/object.js";
+export type {} from "./data/Ord.js";
+export type {} from "./data/Ordering.js";
 export type {} from "./data/Predicate.js";
 export type {} from "./data/Refinement.js";
+export type {} from "./data/Showable.js";
 export type {} from "./data/string.js";
 export type {} from "./data/Tag.js";
 export type {} from "./data/These.js";

package/_src/global/api.ts

@@ -1,23 +1,18 @@
 /**
- * @tsplus fluent global if
+ * @tsplus pipeable global if
  */
 export function matchPredicate<A, B extends A, C, D>(
-  self: A,
   predicate: Refinement<A, B>,
   onFalse: (a: A) => C,
   onTrue: (a: B) => D,
-): C | D;
+): (self: A) => C | D;
 export function matchPredicate<A, B, C>(
-  self: A,
   predicate: Predicate<A>,
   onFalse: (a: A) => B,
   onTrue: (a: A) => C,
-): B | C;
-export function matchPredicate<A, B, C>(
-  self: A,
-  predicate: Predicate<A>,
-  onFalse: (a: A) => B,
-  onTrue: (a: A) => C,
-): B | C {
-  return predicate(self) ? onTrue(self) : onFalse(self);
+): (self: A) => B | C;
+export function matchPredicate<A, B, C>(predicate: Predicate<A>, onFalse: (a: A) => B, onTrue: (a: A) => C) {
+  return (self: A): B | C => {
+    return predicate(self) ? onTrue(self) : onFalse(self);
+  };
 }

package/_src/global.ts

@@ -119,6 +119,10 @@ import { Duration } from "@fncts/base/data/Duration/definition";
  * @tsplus global
  */
 import { Either } from "@fncts/base/data/Either/definition";
+/**
+ * @tsplus global
+ */
+import { Encoder } from "@fncts/base/data/Encoder/definition";
 /**
  * @tsplus global
  */
@@ -127,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
  */
@@ -161,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
  */
@@ -190,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
  */
@@ -230,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/internal/AtomicBoolean.ts

@@ -1,5 +1,4 @@
 import { AtomicReference } from "./AtomicReference.js";
-
 export class AtomicBoolean extends AtomicReference<boolean> {
   constructor(b: boolean) {
     super(b);

package/_src/internal/AtomicNumber.ts

@@ -1,28 +1,21 @@
 import { AtomicReference } from "./AtomicReference.js";
-
 export class AtomicNumber extends AtomicReference<number> {
   constructor(n: number) {
     super(n);
-
     this.incrementAndGet = this.incrementAndGet.bind(this);
     this.decrementAndGet = this.decrementAndGet.bind(this);
   }
-
   incrementAndGet() {
     this.set(this.get + 1);
     return this.get;
   }
-
   decrementAndGet() {
     this.set(this.get - 1);
     return this.get;
   }
-
   getAndIncrement(): number {
     const ret = this.get;
-
     this.set(this.get + 1);
-
     return ret;
   }
 }

package/_src/internal/AtomicReference.ts

@@ -3,15 +3,12 @@ export class AtomicReference<A> {
   constructor(readonly initial: A) {
     this.current = initial;
   }
-
   get get() {
     return this.current;
   }
-
   set(value: A) {
     this.current = value;
   }
-
   compareAndSet(old: A, value: A) {
     if (this.get === old) {
       this.set(value);
@@ -19,7 +16,6 @@ export class AtomicReference<A> {
     }
     return false;
   }
-
   getAndSet(value: A) {
     const previous = this.current;
     this.current   = value;

package/_src/internal/Stack.ts

@@ -4,25 +4,20 @@
  */
 export class Stack<A> {
   constructor(private node?: Node<A>) {}
-
   clone(): Stack<A> {
     return new Stack(this.node);
   }
-
   get hasNext(): boolean {
     return !!this.node;
   }
-
   get isEmpty(): boolean {
     return !this.hasNext;
   }
-
   peek(): A | undefined {
     if (this.node) {
       return this.node.value;
     }
   }
-
   pop(): A | undefined {
     if (this.node) {
       const value = this.node.value;
@@ -30,7 +25,6 @@ export class Stack<A> {
       return value;
     }
   }
-
   push(value: A): void {
     this.node = { value, previous: this.node };
   }
@@ -44,7 +38,7 @@ interface Node<A> {
 /**
  * @tsplus static fncts.StackOps __call
  */
-export function mkStack<A>(): Stack<A> {
+export function makeStack<A>(): Stack<A> {
   return new Stack();
 }
 

package/_src/optics/At/definition.ts

@@ -1,5 +1,4 @@
 import { Lens } from "@fncts/base/optics/Lens";
-
 /**
  * @tsplus type fncts.optics.At
  */
@@ -8,7 +7,10 @@ export interface At<S, I, A> {
 }
 
 export type AtMin<S, I, A> =
-  | { readonly get: (i: I) => (s: S) => A; readonly set: (i: I) => (s: S, a: A) => S }
+  | {
+      readonly get: (i: I) => (s: S) => A;
+      readonly set: (i: I) => (a: A) => (s: S) => S;
+    }
   | At<S, I, A>;
 
 /**
@@ -26,7 +28,7 @@ export function mkAt<S, I, A>(F: AtMin<S, I, A>): At<S, I, A> {
     return F;
   } else {
     return {
-      at: (i) => Lens({ get: F.get(i), set_: F.set(i) }),
+      at: (i) => Lens({ get: F.get(i), set: F.set(i) }),
     };
   }
 }

package/_src/optics/Fold/definition.ts

@@ -1,9 +1,4 @@
 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;
 }
@@ -12,7 +7,6 @@ export interface foldMap<S, A> {
  * @tsplus type fncts.optics.Fold
  */
 export interface Fold<S, A> {
-  readonly foldMap_: foldMap_<S, A>;
   readonly foldMap: foldMap<S, A>;
 }
 
@@ -24,15 +18,14 @@ export interface FoldOps {}
 export const Fold: FoldOps = {};
 
 export interface FoldMin<S, A> {
-  readonly foldMap_: foldMap_<S, A>;
+  readonly foldMap: foldMap<S, A>;
 }
 
 /**
  * @tsplus static fncts.optics.FoldOps __call
  */
-export function mkFold<S, A>(F: FoldMin<S, A>): Fold<S, A> {
+export function makeFold<S, A>(F: FoldMin<S, A>): Fold<S, A> {
   return {
-    foldMap_: F.foldMap_,
-    foldMap: (M) => (f) => (s) => F.foldMap_(M)(s, f),
+    foldMap: F.foldMap,
   };
 }

package/_src/optics/Getter/definition.ts

@@ -25,10 +25,9 @@ export interface GetterMin<S, A> {
 /**
  * @tsplus static fncts.optics.GetterOps __call
  */
-export function mkGetter<S, A>(F: GetterMin<S, A>): Getter<S, A> {
+export function makeGetter<S, A>(F: GetterMin<S, A>): Getter<S, A> {
   return {
     get: F.get,
-    foldMap_: (_) => (s, f) => f(F.get(s)),
     foldMap: (_) => (f) => (s) => f(F.get(s)),
   };
 }

package/_src/optics/Index/definition.ts

@@ -19,6 +19,6 @@ export const Index: IndexOps = {};
 /**
  * @tsplus static fncts.optics.IndexOps __call
  */
-export function mkIndex<S, I, A>(F: IndexMin<S, I, A>): Index<S, I, A> {
+export function makeIndex<S, I, A>(F: IndexMin<S, I, A>): Index<S, I, A> {
   return { index: F.index };
 }

package/_src/optics/Iso/api.ts

@@ -1,11 +1,13 @@
 import { PIso } from "@fncts/base/optics/Iso/definition";
 
 /**
- * @tsplus fluent fncts.optics.PIso compose
+ * @tsplus pipeable fncts.optics.PIso compose
  */
-export 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> {
-  return PIso({
-    get: self.get.compose(that.get),
-    reverseGet: that.reverseGet.compose(self.reverseGet),
-  });
+export function compose<A, B, C, D>(that: PIso<A, B, C, D>) {
+  return <S, T>(self: PIso<S, T, A, B>): PIso<S, T, C, D> => {
+    return PIso({
+      get: self.get.compose(that.get),
+      reverseGet: that.reverseGet.compose(self.reverseGet),
+    });
+  };
 }

package/_src/optics/Iso/definition.ts

@@ -26,10 +26,10 @@ export interface PIsoMin<S, T, A, B> {
 /**
  * @tsplus static fncts.optics.PIsoOps __call
  */
-export function mkPIso<S, T, A, B>(F: PIsoMin<S, T, A, B>): PIso<S, T, A, B> {
+export function makePIso<S, T, A, B>(F: PIsoMin<S, T, A, B>): PIso<S, T, A, B> {
   return {
     ...PPrism({ getOrModify: F.get.compose(Either.right), reverseGet: F.reverseGet }),
-    ...PLens({ get: F.get, set_: (_s, b) => F.reverseGet(b) }),
+    ...PLens({ get: F.get, set: (b) => () => F.reverseGet(b) }),
     reverse: () => PIso({ get: F.reverseGet, reverseGet: F.get }),
   };
 }
@@ -47,6 +47,6 @@ export interface IsoOps {}
 /**
  * @tsplus static fncts.optics.IsoOps __call
  */
-export function mkIso<S, A>(F: PIsoMin<S, S, A, A>): Iso<S, A> {
+export function makeIso<S, A>(F: PIsoMin<S, S, A, A>): Iso<S, A> {
   return PIso(F);
 }

package/_src/optics/Lens/api.ts

@@ -6,23 +6,24 @@ import { Lens, PLens } from "@fncts/base/optics/Lens/definition";
 import { Prism } from "@fncts/base/optics/Prism";
 
 /**
- * @tsplus fluent fncts.optics.PLens component
+ * @tsplus pipeable fncts.optics.PLens component
  */
-export function component_<S, A extends ReadonlyArray<unknown>, P extends keyof A>(
-  self: Lens<S, A>,
-  component: P,
-): Lens<S, A[P]> {
-  return self.compose(Lens.getComponent<A>()(component));
+export function component<A extends ReadonlyArray<unknown>, P extends keyof A>(component: P) {
+  return <S>(self: Lens<S, A>): Lens<S, A[P]> => {
+    return self.compose(Lens.getComponent<A>()(component));
+  };
 }
 
 /**
- * @tsplus fluent fncts.optics.PLens compose
+ * @tsplus pipeable fncts.optics.PLens compose
  */
-export 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> {
-  return PLens({
-    get: self.get.compose(that.get),
-    set_: (s, d) => self.modify_(s, that.set(d)),
-  });
+export function compose<A, B, C, D>(that: PLens<A, B, C, D>) {
+  return <S, T>(self: PLens<S, T, A, B>): PLens<S, T, C, D> => {
+    return PLens({
+      get: self.get.compose(that.get),
+      set: (d) => self.modify(that.set(d)),
+    });
+  };
 }
 
 /**
@@ -39,7 +40,7 @@ export function getComponent<A extends ReadonlyArray<unknown>>() {
   return <P extends keyof A>(component: P): Lens<A, A[P]> =>
     Lens({
       get: (s) => s[component],
-      set_: (s, ap) => {
+      set: (ap) => (s) => {
         if (ap === s[component]) {
           return s;
         }
@@ -57,7 +58,7 @@ export function getProp<A extends Record<string, any>>() {
   return <P extends keyof A>(prop: P): Lens<A, A[P]> =>
     Lens({
       get: (s) => s[prop],
-      set_: (s, ap) => {
+      set: (ap) => (s) => {
         if (ap === s[prop]) {
           return s;
         }
@@ -72,32 +73,35 @@ export function getProp<A extends Record<string, any>>() {
 export function id<S, A = S>(): PLens<S, A, S, A> {
   return PLens({
     get: identity,
-    set_: (_, t) => t,
+    set: (t) => () => t,
   });
 }
 
 /**
- * @tsplus fluent fncts.optics.PLensOps invmap
+ * @tsplus pipeable fncts.optics.PLensOps invmap
  */
-export function invmap_<S, A, B>(self: Lens<S, A>, f: (a: A) => B, g: (b: B) => A): Lens<S, B> {
-  return Lens({
-    get: self.get.compose(f),
-    set_: (s, b) => self.set_(s, g(b)),
-  });
+export function invmap_<A, B>(f: (a: A) => B, g: (b: B) => A) {
+  return <S>(self: Lens<S, A>): Lens<S, B> => {
+    return Lens({
+      get: self.get.compose(f),
+      set: (b) => self.set(g(b)),
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.optics.Lens prop
+ * @tsplus pipeable fncts.optics.Lens prop
  */
-export function prop_<S, A extends Record<string, any>, P extends keyof A>(self: Lens<S, A>, prop: P): Lens<S, A[P]> {
-  return self.compose(Lens.getProp<A>()(prop));
+export function prop<A extends Record<string, any>, P extends keyof A>(prop: P) {
+  return <S>(self: Lens<S, A>): Lens<S, A[P]> => {
+    return self.compose(Lens.getProp<A>()(prop));
+  };
 }
 
 function nestPath<A>(p: ReadonlyNonEmptyArray<string>, a: A): Record<string, unknown> {
   const out: Record<string, unknown> = {};
   let view = out;
   let last = "";
-
   for (let i = 0; i < p.length; i++) {
     const pi = p[i]!;
     view[pi] = {};
@@ -106,27 +110,25 @@ function nestPath<A>(p: ReadonlyNonEmptyArray<string>, a: A): Record<string, unk
     }
     last = pi;
   }
-
   view[last] = a;
   return out;
 }
 
 /**
- * @tsplus fluent fncts.optics.Lens path
+ * @tsplus pipeable fncts.optics.Lens path
  */
-export 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>> {
-  return Lens({
-    get: (s) => path.foldLeft<string, Record<string, unknown>>(self.get(s), (b, p) => b[p] as A) as Path<A, P>,
-    set_: (s, a) => {
-      const os = self.get(s);
-      const oa = path.foldLeft(os, (b, p) => b[p as string] as A);
-      if (a === oa) {
-        return s;
-      }
-      return self.set_(s, Object.assign({}, os, path.isNonEmpty() ? nestPath(path, a) : a));
-    },
-  });
+export function path<A extends Record<string, unknown>, P extends Array<string>>(path: readonly [...AutoPath<A, P>]) {
+  return <S>(self: Lens<S, A>): Lens<S, Path<A, P>> => {
+    return Lens({
+      get: (s) => path.foldLeft<string, Record<string, unknown>>(self.get(s), (b, p) => b[p] as A) as Path<A, P>,
+      set: (a) => (s) => {
+        const os = self.get(s);
+        const oa = path.foldLeft(os, (b, p) => b[p as string] as A);
+        if (a === oa) {
+          return s;
+        }
+        return s.pipe(self.set(Object.assign({}, os, path.isNonEmpty() ? nestPath(path, a) : a)));
+      },
+    });
+  };
 }

package/_src/optics/Lens/definition.ts

@@ -1,5 +1,5 @@
 import type { get } from "@fncts/base/optics/Getter";
-import type { set_ } from "@fncts/base/optics/Setter";
+import type { set } from "@fncts/base/optics/Setter";
 
 import { Getter } from "@fncts/base/optics/Getter";
 import { POptional } from "@fncts/base/optics/Optional";
@@ -18,15 +18,15 @@ export const PLens: PLensOps = {};
 
 export interface PLensMin<S, T, A, B> {
   readonly get: get<S, A>;
-  readonly set_: set_<S, T, B>;
+  readonly set: set<S, T, B>;
 }
 
 /**
  * @tsplus static fncts.optics.PLensOps __call
  */
-export function mkPLens<S, T, A, B>(F: PLensMin<S, T, A, B>): PLens<S, T, A, B> {
+export function makePLens<S, T, A, B>(F: PLensMin<S, T, A, B>): PLens<S, T, A, B> {
   return {
-    ...POptional({ replace_: F.set_, getOrModify: (s) => Either.right(F.get(s)) }),
+    ...POptional({ set: F.set, getOrModify: (s) => Either.right(F.get(s)) }),
     ...Getter({ get: F.get }),
   };
 }
@@ -46,6 +46,6 @@ export const Lens: LensOps = {};
 /**
  * @tsplus static fncts.optics.LensOps __call
  */
-export function mkLens<S, A>(F: PLensMin<S, S, A, A>): Lens<S, A> {
+export function makeLens<S, A>(F: PLensMin<S, S, A, A>): Lens<S, A> {
   return PLens(F);
 }

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

@@ -2,14 +2,14 @@ import { identity } from "@fncts/base/data/function";
 import { POptional } from "@fncts/base/optics/Optional/definition";
 
 /**
- * @tsplus fluent fncts.optics.POptional compose 3
+ * @tsplus pipeable fncts.optics.POptional compose 3
  */
-export 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> {
-  return POptional({
-    getOrModify: (s) => self.getOrModify(s).flatMap((a) => that.getOrModify(a).bimap((b) => self.set_(s, b), identity)),
-    replace_: (s, d) => self.modify_(s, that.set(d)),
-  });
+export function compose<A, B, C, D>(that: POptional<A, B, C, D>) {
+  return <S, T>(self: POptional<S, T, A, B>): POptional<S, T, C, D> => {
+    return POptional({
+      getOrModify: (s) =>
+        self.getOrModify(s).flatMap((a) => that.getOrModify(a).bimap((b) => s.pipe(self.set(b)), identity)),
+      set: (d) => self.modify(that.set(d)),
+    });
+  };
 }