@fncts/base 0.0.19 → 0.0.21

package/_src/data/Datum/api.ts

@@ -5,8 +5,6 @@ import type { Eq } from "@fncts/base/typeclass/Eq";
 import { DatumTag, Initial, Pending, Refresh, Replete } from "@fncts/base/data/Datum/definition";
 import { Zipped } from "@fncts/base/data/Zipped";
 
-import { TheseTag } from "../These.js";
-
 const _Initial = new Initial();
 
 /**
@@ -100,233 +98,257 @@ export function isLoading<A>(self: Datum<A>): self is Pending | Refresh<A> {
 }
 
 /**
- * @tsplus fluent fncts.Datum elem
+ * @tsplus pipeable fncts.Datum elem
  */
-export function elem<A>(self: Datum<A>, a: A, /** @tsplus auto */ E: Eq<A>): boolean {
-  return self.match({
-    Initial: () => false,
-    Pending: () => false,
-    Refresh: (value) => E.equals(a, value),
-    Replete: (value) => E.equals(a, value),
-  });
+export function elem<A>(a: A, /** @tsplus auto */ E: Eq<A>) {
+  return (self: Datum<A>): boolean => {
+    return self.match({
+      Initial: () => false,
+      Pending: () => false,
+      Refresh: (value) => E.equals(a, value),
+      Replete: (value) => E.equals(a, value),
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.Datum exists
+ * @tsplus pipeable fncts.Datum exists
  */
-export function exists<A, B extends A>(self: Datum<A>, p: Refinement<A, B>): self is Datum<B>;
-export function exists<A>(self: Datum<A>, p: Predicate<A>): boolean;
-export function exists<A>(self: Datum<A>, p: Predicate<A>): boolean {
-  return self.match({
-    Initial: () => false,
-    Pending: () => false,
-    Refresh: p,
-    Replete: p,
-  });
+export function exists<A, B extends A>(p: Refinement<A, B>): (self: Datum<A>) => self is Datum<B>;
+export function exists<A>(p: Predicate<A>): (self: Datum<A>) => boolean;
+export function exists<A>(p: Predicate<A>) {
+  return (self: Datum<A>): boolean => {
+    return self.match({
+      Initial: () => false,
+      Pending: () => false,
+      Refresh: p,
+      Replete: p,
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.Datum extend
+ * @tsplus pipeable fncts.Datum extend
  */
-export function extend<A, B>(self: Datum<A>, f: (wa: Datum<A>) => B): Datum<B> {
-  return Replete(f(self));
+export function extend<A, B>(f: (wa: Datum<A>) => B) {
+  return (self: Datum<A>): Datum<B> => {
+    return Replete(f(self));
+  };
 }
 
 /**
- * @tsplus fluent fncts.Datum filter
+ * @tsplus pipeable fncts.Datum filter
  */
-export function filter<A, B extends A>(self: Datum<A>, p: Refinement<A, B>): Datum<B>;
-export function filter<A>(self: Datum<A>, p: Predicate<A>): Datum<A>;
-export function filter<A>(self: Datum<A>, p: Predicate<A>): Datum<A> {
-  return self.match({
-    Initial: () => self,
-    Pending: () => self,
-    Refresh: (a) => (p(a) ? self : Initial()),
-    Replete: (a) => (p(a) ? self : Initial()),
-  });
+export function filter<A, B extends A>(p: Refinement<A, B>): (self: Datum<A>) => Datum<B>;
+export function filter<A>(p: Predicate<A>): (self: Datum<A>) => Datum<A>;
+export function filter<A>(p: Predicate<A>) {
+  return (self: Datum<A>): Datum<A> => {
+    return self.match({
+      Initial: () => self,
+      Pending: () => self,
+      Refresh: (a) => (p(a) ? self : Initial()),
+      Replete: (a) => (p(a) ? self : Initial()),
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.Datum filterMap
+ * @tsplus pipeable fncts.Datum filterMap
  */
-export function filterMap<A, B>(self: Datum<A>, f: (a: A) => Maybe<B>): Datum<B> {
-  return self.match({
-    Initial: () => unsafeCoerce(self),
-    Pending: () => unsafeCoerce(self),
-    Refresh: (value) =>
-      f(value).match(
-        () => Initial(),
-        (b) => Refresh(b),
-      ),
-    Replete: (value) =>
-      f(value).match(
-        () => Initial(),
-        (b) => Replete(b),
-      ),
-  });
+export function filterMap<A, B>(f: (a: A) => Maybe<B>) {
+  return (self: Datum<A>): Datum<B> => {
+    return self.match({
+      Initial: () => unsafeCoerce(self),
+      Pending: () => unsafeCoerce(self),
+      Refresh: (value) =>
+        f(value).match(
+          () => Initial(),
+          (b) => Refresh(b),
+        ),
+      Replete: (value) =>
+        f(value).match(
+          () => Initial(),
+          (b) => Replete(b),
+        ),
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.Datum flatMap
+ * @tsplus pipeable fncts.Datum flatMap
  */
-export function flatMap<A, B>(self: Datum<A>, f: (a: A) => Datum<B>): Datum<B> {
-  if (self.isEmpty()) {
-    return self;
-  }
-  const that = f(self.value);
-
-  if (that.isEmpty()) {
-    return that;
-  }
-  return self.isRefresh() || that.isRefresh() ? Refresh(that.value!) : Replete(that.value!);
+export function flatMap<A, B>(f: (a: A) => Datum<B>) {
+  return (self: Datum<A>): Datum<B> => {
+    if (self.isEmpty()) {
+      return self;
+    }
+    const that = f(self.value);
+    if (that.isEmpty()) {
+      return that;
+    }
+    return self.isRefresh() || that.isRefresh() ? Refresh(that.value!) : Replete(that.value!);
+  };
 }
 
 /**
- * @tsplus fluent fncts.Datum foldLeft
+ * @tsplus pipeable fncts.Datum foldLeft
  */
-export function foldLeft<A, B>(self: Datum<A>, b: B, f: (b: B, a: A) => B): B {
-  return self.match({
-    Initial: () => b,
-    Pending: () => b,
-    Refresh: (a) => f(b, a),
-    Replete: (a) => f(b, a),
-  });
-}
+export function foldLeft<A, B>(b: B, f: (b: B, a: A) => B) {
+  return (self: Datum<A>): B => {
+    return self.match({
+      Initial: () => b,
+      Pending: () => b,
+      Refresh: (a) => f(b, a),
+      Replete: (a) => f(b, a),
+    });
+  };
+}
 
 /**
- * @tsplus fluent fncts.Datum foldMap
+ * @tsplus pipeable fncts.Datum foldMap
  */
-export function foldMap<A, M>(self: Datum<A>, f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): M {
-  return self.match({
-    Initial: () => M.nat,
-    Pending: () => M.nat,
-    Refresh: f,
-    Replete: f,
-  });
-}
+export function foldMap<A, M>(f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>) {
+  return (self: Datum<A>): M => {
+    return self.match({
+      Initial: () => M.nat,
+      Pending: () => M.nat,
+      Refresh: f,
+      Replete: f,
+    });
+  };
+}
 
 /**
- * @tsplus fluent fncts.Datum foldRight
+ * @tsplus pipeable fncts.Datum foldRight
  */
-export function foldRight<A, B>(self: Datum<A>, b: B, f: (a: A, b: B) => B): B {
-  return self.match({
-    Initial: () => b,
-    Pending: () => b,
-    Refresh: (a) => f(a, b),
-    Replete: (a) => f(a, b),
-  });
+export function foldRight<A, B>(b: B, f: (a: A, b: B) => B) {
+  return (self: Datum<A>): B => {
+    return self.match({
+      Initial: () => b,
+      Pending: () => b,
+      Refresh: (a) => f(a, b),
+      Replete: (a) => f(a, b),
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.Datum getOrElse
+ * @tsplus pipeable fncts.Datum getOrElse
  */
-export function getOrElse<A, B>(self: Datum<A>, b: Lazy<B>): A | B {
-  return self.match({
-    Initial: b,
-    Pending: b,
-    Refresh: Function.identity,
-    Replete: Function.identity,
-  });
+export function getOrElse<B>(b: Lazy<B>) {
+  return <A>(self: Datum<A>): A | B => {
+    return self.match({
+      Initial: b,
+      Pending: b,
+      Refresh: Function.identity,
+      Replete: Function.identity,
+    });
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.Datum match
+ */
+export function match<A, B, C, D, E>(cases: {
+  Initial: () => B;
+  Pending: () => C;
+  Refresh: (a: A) => D;
+  Replete: (a: A) => E;
+}) {
+  return (self: Datum<A>): B | C | D | E => {
+    switch (self._tag) {
+      case DatumTag.Initial:
+        return cases.Initial();
+      case DatumTag.Pending:
+        return cases.Pending();
+      case DatumTag.Refresh:
+        return cases.Refresh(self.value);
+      case DatumTag.Replete:
+        return cases.Replete(self.value);
+    }
+  };
 }
 
 /**
- * @tsplus fluent fncts.Datum match
+ * @tsplus pipeable fncts.Datum match2
  */
-export function match<A, B, C, D, E>(
-  self: Datum<A>,
-  cases: {
-    Initial: () => B;
-    Pending: () => C;
-    Refresh: (a: A) => D;
-    Replete: (a: A) => E;
-  },
-): B | C | D | E {
-  switch (self._tag) {
-    case DatumTag.Initial:
-      return cases.Initial();
-    case DatumTag.Pending:
-      return cases.Pending();
-    case DatumTag.Refresh:
-      return cases.Refresh(self.value);
-    case DatumTag.Replete:
-      return cases.Replete(self.value);
-  }
+export function match2<A, B, C>(onEmpty: (isLoading: boolean) => B, onValue: (a: A, isLoading: boolean) => C) {
+  return (self: Datum<A>): B | C => {
+    switch (self._tag) {
+      case DatumTag.Initial:
+        return onEmpty(false);
+      case DatumTag.Pending:
+        return onEmpty(true);
+      case DatumTag.Refresh:
+        return onValue(self.value, true);
+      case DatumTag.Replete:
+        return onValue(self.value, false);
+    }
+  };
 }
 
 /**
- * @tsplus fluent fncts.Datum match2
+ * @tsplus pipeable fncts.Datum map
  */
-export function match2<A, B, C>(
-  self: Datum<A>,
-  onEmpty: (isLoading: boolean) => B,
-  onValue: (a: A, isLoading: boolean) => C,
-): B | C {
-  switch (self._tag) {
-    case DatumTag.Initial:
-      return onEmpty(false);
-    case DatumTag.Pending:
-      return onEmpty(true);
-    case DatumTag.Refresh:
-      return onValue(self.value, true);
-    case DatumTag.Replete:
-      return onValue(self.value, false);
-  }
+export function map<A, B>(f: (a: A) => B) {
+  return (self: Datum<A>): Datum<B> => {
+    switch (self._tag) {
+      case DatumTag.Initial:
+      case DatumTag.Pending:
+        return self;
+      case DatumTag.Refresh:
+        return Refresh(f(self.value));
+      case DatumTag.Replete:
+        return Replete(f(self.value));
+    }
+  };
 }
 
 /**
- * @tsplus fluent fncts.Datum map
+ * @tsplus pipeable fncts.Datum orElse
  */
-export function map<A, B>(self: Datum<A>, f: (a: A) => B): Datum<B> {
-  switch (self._tag) {
-    case DatumTag.Initial:
-    case DatumTag.Pending:
-      return self;
-    case DatumTag.Refresh:
-      return Refresh(f(self.value));
-    case DatumTag.Replete:
-      return Replete(f(self.value));
-  }
+export function orElse<B>(that: Lazy<Datum<B>>) {
+  return <A>(self: Datum<A>): Datum<A | B> => {
+    return self.match({
+      Initial: that,
+      Pending: that,
+      Refresh: () => self,
+      Replete: () => self,
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.Datum orElse
- */
-export function orElse<A, B>(self: Datum<A>, that: Lazy<Datum<B>>): Datum<A | B> {
-  return self.match({
-    Initial: that,
-    Pending: that,
-    Refresh: () => self,
-    Replete: () => self,
-  });
+ * @tsplus pipeable fncts.Datum partition
+ */
+export function partition<A, B extends A>(p: Refinement<A, B>): (self: Datum<A>) => [Datum<A>, Datum<B>];
+export function partition<A>(p: Predicate<A>): (self: Datum<A>) => [Datum<A>, Datum<A>];
+export function partition<A>(p: Predicate<A>) {
+  return (self: Datum<A>): [Datum<A>, Datum<A>] => {
+    return [self.filter(p.invert), self.filter(p)];
+  };
 }
 
 /**
- * @tsplus fluent fncts.Datum partition
+ * @tsplus pipeable fncts.Datum partitionMap
  */
-export function partition<A, B extends A>(self: Datum<A>, p: Refinement<A, B>): [Datum<A>, Datum<B>];
-export function partition<A>(self: Datum<A>, p: Predicate<A>): [Datum<A>, Datum<A>];
-export function partition<A>(self: Datum<A>, p: Predicate<A>): [Datum<A>, Datum<A>] {
-  return [self.filter(p.invert), self.filter(p)];
-}
-
-/**
- * @tsplus fluent fncts.Datum partitionMap
- */
-export function partitionMap<A, B, C>(self: Datum<A>, f: (a: A) => Either<B, C>): [Datum<B>, Datum<C>] {
-  return self.match({
-    Initial: () => [Initial(), Initial()],
-    Pending: () => [Pending(), Pending()],
-    Refresh: (a) =>
-      f(a).match(
-        (b) => [Refresh(b), Initial()],
-        (c) => [Initial(), Refresh(c)],
-      ),
-    Replete: (a) =>
-      f(a).match(
-        (b) => [Replete(b), Initial()],
-        (c) => [Initial(), Replete(c)],
-      ),
-  });
+export function partitionMap<A, B, C>(f: (a: A) => Either<B, C>) {
+  return (self: Datum<A>): [Datum<B>, Datum<C>] => {
+    return self.match({
+      Initial: () => [Initial(), Initial()],
+      Pending: () => [Pending(), Pending()],
+      Refresh: (a) =>
+        f(a).match(
+          (b) => [Refresh(b), Initial()],
+          (c) => [Initial(), Refresh(c)],
+        ),
+      Replete: (a) =>
+        f(a).match(
+          (b) => [Replete(b), Initial()],
+          (c) => [Initial(), Replete(c)],
+        ),
+    });
+  };
 }
 
 /**
@@ -344,33 +366,43 @@ export function toReplete<A>(self: Datum<A>): Datum<A> {
 }
 
 /**
- * @tsplus fluent fncts.Datum traverse
+ * @tsplus getter fncts.Datum traverse
  */
-export const traverse: P.Traversable<DatumF>["traverse"] = (self) => (A) => (f) =>
-  self.match({
-    Initial: () => A.pure(Initial()),
-    Pending: () => A.pure(Pending()),
-    Refresh: (a) => A.map(f(a), (b) => Refresh(b)),
-    Replete: (a) => A.map(f(a), (b) => Replete(b)),
-  });
+export function _traverse<A>(self: Datum<A>) {
+  return <G extends HKT, GC = HKT.None>(G: P.Applicative<G, GC>) =>
+    <K, Q, W, X, I, S, R, E1, B>(
+      f: (a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, B>,
+    ): HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, Datum<B>> =>
+      self.match({
+        Initial: () => G.pure(Initial()),
+        Pending: () => G.pure(Pending()),
+        Refresh: (a) => f(a).pipe(G.map((b) => Refresh(b))),
+        Replete: (a) => f(a).pipe(G.map((b) => Replete(b))),
+      });
+}
+
+export const traverse: P.Traversable<DatumF>["traverse"] = (G) => (f) => (self) => self.traverse(G)(f);
 
 /**
- * @tsplus fluent fncts.Datum zip
+ * @tsplus pipeable fncts.Datum zip
  */
-export function zip<A, B>(self: Datum<A>, that: Datum<B>): Datum<Zipped.Make<A, B>> {
-  return self.zipWith(that, (a, b) => Zipped(a, b));
+export function zip<B>(that: Datum<B>) {
+  return <A>(self: Datum<A>): Datum<Zipped.Make<A, B>> => {
+    return self.zipWith(that, (a, b) => Zipped(a, b));
+  };
 }
-
 /**
- * @tsplus fluent fncts.Datum zipWith
+ * @tsplus pipeable fncts.Datum zipWith
  */
-export function zipWith<A, B, C>(self: Datum<A>, that: Datum<B>, f: (a: A, b: B) => C): Datum<C> {
-  if (self.isEmpty()) {
-    return self;
-  }
-  if (that.isEmpty()) {
-    return that;
-  }
-  const c = f(self.value, that.value);
-  return self.isRefresh() || that.isRefresh() ? Refresh(c) : Replete(c);
+export function zipWith<A, B, C>(that: Datum<B>, f: (a: A, b: B) => C) {
+  return (self: Datum<A>): Datum<C> => {
+    if (self.isEmpty()) {
+      return self;
+    }
+    if (that.isEmpty()) {
+      return that;
+    }
+    const c = f(self.value, that.value);
+    return self.isRefresh() || that.isRefresh() ? Refresh(c) : Replete(c);
+  };
 }

package/_src/data/Datum/definition.ts

@@ -26,11 +26,8 @@ export type Datum<A> = Initial | Pending | Refresh<A> | Replete<A>;
 export interface DatumOps {}
 
 export const Datum: DatumOps = {};
-
-const datumHash = Hashable.string("fncts.Datum");
-
-const initialHash = Hashable.combine(datumHash, Hashable.string(DatumTag.Initial));
-
+const datumHash       = Hashable.string("fncts.Datum");
+const initialHash     = Hashable.combine(datumHash, Hashable.string(DatumTag.Initial));
 /**
  * @tsplus type fncts.Datum.Initial
  * @tsplus companion fncts.Datum.InitialOps