@fncts/base 0.0.20 → 0.0.21

package/_src/data/Exit/api.ts

@@ -2,52 +2,66 @@ import { identity, tuple } from "../function.js";
 import { ExitTag } from "./definition.js";
 
 /**
- * @tsplus fluent fncts.Exit ap
+ * @tsplus pipeable fncts.Exit ap
  */
-export function ap_<E, A, G, B>(fab: Exit<G, (a: A) => B>, fa: Exit<E, A>): Exit<E | G, B> {
-  return fab.flatMap((f) => fa.map((a) => f(a)));
+export function ap<E, A>(fa: Exit<E, A>) {
+  return <G, B>(fab: Exit<G, (a: A) => B>): Exit<E | G, B> => {
+    return fab.flatMap((f) => fa.map((a) => f(a)));
+  };
 }
 
 /**
- * @tsplus fluent fncts.Exit apFirst
+ * @tsplus pipeable fncts.Exit apFirst
  */
-export function apFirst_<E, G, A, B>(fa: Exit<E, A>, fb: Exit<G, B>): Exit<E | G, A> {
-  return fa.zipWithCause(fb, (a, _) => a, Cause.then);
+export function apFirst<G, B>(fb: Exit<G, B>) {
+  return <E, A>(fa: Exit<E, A>): Exit<E | G, A> => {
+    return fa.zipWithCause(fb, (a, _) => a, Cause.then);
+  };
 }
 
 /**
- * @tsplus fluent fncts.Exit apSecond
+ * @tsplus pipeable fncts.Exit apSecond
  */
-export function apSecond_<E, G, A, B>(fa: Exit<E, A>, fb: Exit<G, B>): Exit<E | G, B> {
-  return fa.zipWithCause(fb, (_, b) => b, Cause.then);
+export function apSecond<G, B>(fb: Exit<G, B>) {
+  return <E, A>(fa: Exit<E, A>): Exit<E | G, B> => {
+    return fa.zipWithCause(fb, (_, b) => b, Cause.then);
+  };
 }
 
 /**
- * @tsplus fluent fncts.Exit apFirstC
+ * @tsplus pipeable fncts.Exit apFirstC
  */
-export function apFirstC_<E, G, A, B>(fa: Exit<E, A>, fb: Exit<G, B>): Exit<E | G, A> {
-  return fa.zipWithCause(fb, (a, _) => a, Cause.both);
+export function apFirstC<G, B>(fb: Exit<G, B>) {
+  return <E, A>(fa: Exit<E, A>): Exit<E | G, A> => {
+    return fa.zipWithCause(fb, (a, _) => a, Cause.both);
+  };
 }
 
 /**
- * @tsplus fluent fncts.Exit apSecondC
+ * @tsplus pipeable fncts.Exit apSecondC
  */
-export function apSecondC_<E, G, A, B>(fa: Exit<E, A>, fb: Exit<G, B>): Exit<E | G, B> {
-  return fa.zipWithCause(fb, (_, b) => b, Cause.both);
+export function apSecondC<G, B>(fb: Exit<G, B>) {
+  return <E, A>(fa: Exit<E, A>): Exit<E | G, B> => {
+    return fa.zipWithCause(fb, (_, b) => b, Cause.both);
+  };
 }
 
 /**
- * @tsplus fluent fncts.Exit flatMap
+ * @tsplus pipeable fncts.Exit flatMap
  */
-export function flatMap_<E, A, G, B>(ma: Exit<E, A>, f: (a: A) => Exit<G, B>): Exit<E | G, B> {
-  return ma.isFailure() ? ma : f(ma.value);
+export function flatMap<A, G, B>(f: (a: A) => Exit<G, B>) {
+  return <E>(ma: Exit<E, A>): Exit<E | G, B> => {
+    return ma.isFailure() ? ma : f(ma.value);
+  };
 }
 
 /**
- * @tsplus fluent fncts.Exit bimap
+ * @tsplus pipeable fncts.Exit bimap
  */
-export function bimap_<E1, A, E2, B>(self: Exit<E1, A>, f: (e: E1) => E2, g: (a: A) => B): Exit<E2, B> {
-  return self.isFailure() ? Exit.failCause(self.cause.map(f)) : Exit.succeed(g(self.value));
+export function bimap<E1, A, E2, B>(f: (e: E1) => E2, g: (a: A) => B) {
+  return (self: Exit<E1, A>): Exit<E2, B> => {
+    return self.isFailure() ? Exit.failCause(self.cause.map(f)) : Exit.succeed(g(self.value));
+  };
 }
 
 /**
@@ -72,101 +86,118 @@ export function collectAllC<E, A>(exits: Conc<Exit<E, A>>): Maybe<Exit<E, Conc<A
  * @tsplus getter fncts.Exit flatten
  */
 export function flatten<E, G, A>(mma: Exit<E, Exit<G, A>>): Exit<E | G, A> {
-  return flatMap_(mma, identity);
+  return mma.flatMap(identity);
 }
 
 /**
- * @tsplus fluent fncts.Exit map
+ * @tsplus pipeable fncts.Exit map
  */
-export function map_<E, A, B>(fa: Exit<E, A>, f: (a: A) => B): Exit<E, B> {
-  return fa.isFailure() ? fa : Exit.succeed(f(fa.value));
+export function map<A, B>(f: (a: A) => B) {
+  return <E>(fa: Exit<E, A>): Exit<E, B> => {
+    return fa.isFailure() ? fa : Exit.succeed(f(fa.value));
+  };
 }
 
 /**
- * @tsplus fluent fncts.Exit mapError
+ * @tsplus pipeable fncts.Exit mapError
  */
-export function mapError_<E1, A, E2>(self: Exit<E1, A>, f: (e: E1) => E2): Exit<E2, A> {
-  return self.isFailure() ? Exit.failCause(self.cause.map(f)) : self;
+export function mapError<E1, E2>(f: (e: E1) => E2) {
+  return <A>(self: Exit<E1, A>): Exit<E2, A> => {
+    return self.isFailure() ? Exit.failCause(self.cause.map(f)) : self;
+  };
 }
 
 /**
- * @tsplus fluent fncts.Exit mapErrorCause
+ * @tsplus pipeable fncts.Exit mapErrorCause
  */
-export function mapErrorCause_<E1, A, E2>(self: Exit<E1, A>, f: (e: Cause<E1>) => Cause<E2>): Exit<E2, A> {
-  return self.isFailure() ? Exit.failCause(f(self.cause)) : self;
+export function mapErrorCause<E1, E2>(f: (e: Cause<E1>) => Cause<E2>) {
+  return <A>(self: Exit<E1, A>): Exit<E2, A> => {
+    return self.isFailure() ? Exit.failCause(f(self.cause)) : self;
+  };
 }
 
 /**
- * @tsplus fluent fncts.Exit match
+ * @tsplus pipeable fncts.Exit match
  */
-export function match_<E, A, B, C>(exit: Exit<E, A>, onFailure: (e: Cause<E>) => B, onSuccess: (a: A) => C): B | C {
-  switch (exit._tag) {
-    case ExitTag.Success: {
-      return onSuccess(exit.value);
-    }
-    case ExitTag.Failure: {
-      return onFailure(exit.cause);
+export function match<E, A, B, C>(onFailure: (e: Cause<E>) => B, onSuccess: (a: A) => C) {
+  return (exit: Exit<E, A>): B | C => {
+    switch (exit._tag) {
+      case ExitTag.Success: {
+        return onSuccess(exit.value);
+      }
+      case ExitTag.Failure: {
+        return onFailure(exit.cause);
+      }
     }
-  }
+  };
 }
 
 /**
- * @tsplus fluent fncts.Exit zipWith
+ * @tsplus pipeable fncts.Exit zipWith
  */
-export function zipWith_<EA, A, EB, B, C>(fa: Exit<EA, A>, fb: Exit<EB, B>, f: (a: A, b: B) => C): Exit<EA | EB, C> {
-  return fa.zipWithCause(fb, f, Cause.then);
+export function zipWith<A, EB, B, C>(fb: Exit<EB, B>, f: (a: A, b: B) => C) {
+  return <EA>(fa: Exit<EA, A>): Exit<EA | EB, C> => {
+    return fa.zipWithCause(fb, f, Cause.then);
+  };
 }
 
 /**
- * @tsplus fluent fncts.Exit zip
+ * @tsplus pipeable fncts.Exit zip
  */
-export function zip<EA, A, EB, B>(self: Exit<EA, A>, that: Exit<EB, B>): Exit<EA | EB, readonly [A, B]> {
-  return self.zipWith(that, tuple);
+export function zip<EB, B>(that: Exit<EB, B>) {
+  return <EA, A>(self: Exit<EA, A>): Exit<EA | EB, readonly [A, B]> => {
+    return self.zipWith(that, tuple);
+  };
 }
 
 /**
- * @tsplus fluent fncts.Exit zipWithC
+ * @tsplus pipeable fncts.Exit zipWithC
  */
-export function zipWithC_<EA, A, EB, B, C>(fa: Exit<EA, A>, fb: Exit<EB, B>, f: (a: A, b: B) => C): Exit<EA | EB, C> {
-  return fa.zipWithCause(fb, f, Cause.both);
+export function zipWithC<A, EB, B, C>(fb: Exit<EB, B>, f: (a: A, b: B) => C) {
+  return <EA>(fa: Exit<EA, A>): Exit<EA | EB, C> => {
+    return fa.zipWithCause(fb, f, Cause.both);
+  };
 }
 
 /**
- * @tsplus fluent fncts.Exit zipC
+ * @tsplus pipeable fncts.Exit zipC
  */
-export function zipC<EA, A, EB, B>(self: Exit<EA, A>, that: Exit<EB, B>): Exit<EA | EB, readonly [A, B]> {
-  return self.zipWithC(that, tuple);
+export function zipC<EB, B>(that: Exit<EB, B>) {
+  return <EA, A>(self: Exit<EA, A>): Exit<EA | EB, readonly [A, B]> => {
+    return self.zipWithC(that, tuple);
+  };
 }
 
 /**
- * @tsplus fluent fncts.Exit zipWithCause
+ * @tsplus pipeable fncts.Exit zipWithCause
  */
-export function zipWithCause_<E, A, G, B, C>(
-  fa: Exit<E, A>,
+export function zipWithCause<E, A, G, B, C>(
   fb: Exit<G, B>,
   f: (a: A, b: B) => C,
   g: (ea: Cause<E>, eb: Cause<G>) => Cause<E | G>,
-): Exit<E | G, C> {
-  switch (fa._tag) {
-    case ExitTag.Failure: {
-      switch (fb._tag) {
-        case ExitTag.Success: {
-          return fa;
-        }
-        case ExitTag.Failure: {
-          return Exit.failCause(g(fa.cause, fb.cause));
+) {
+  return (fa: Exit<E, A>): Exit<E | G, C> => {
+    switch (fa._tag) {
+      case ExitTag.Failure: {
+        switch (fb._tag) {
+          case ExitTag.Success: {
+            return fa;
+          }
+          case ExitTag.Failure: {
+            return Exit.failCause(g(fa.cause, fb.cause));
+          }
         }
       }
-    }
-    case ExitTag.Success: {
-      switch (fb._tag) {
-        case ExitTag.Success: {
-          return Exit.succeed(f(fa.value, fb.value));
-        }
-        case ExitTag.Failure: {
-          return fb;
+      case ExitTag.Success: {
+        switch (fb._tag) {
+          case ExitTag.Success: {
+            return Exit.succeed(f(fa.value, fb.value));
+          }
+          case ExitTag.Failure: {
+            return fb;
+          }
         }
       }
     }
-  }
+  };
 }

package/_src/data/Exit/constructors.ts

@@ -24,7 +24,7 @@ export function fromEither<E = never, A = never>(e: Either<E, A>): Exit<E, A> {
 /**
  * @tsplus static fncts.ExitOps fromMaybe
  */
-export function fromMaybe_<E, A>(fa: Maybe<A>, onNothing: () => E): Exit<E, A> {
+export function fromMaybe<E, A>(fa: Maybe<A>, onNothing: () => E): Exit<E, A> {
   return fa.match(() => fail(onNothing()), succeed);
 }
 
@@ -38,7 +38,7 @@ export function failCause<E = never, A = never>(cause: Cause<E>): Exit<E, A> {
 /**
  * @tsplus static fncts.ExitOps interrupt
  */
-export function interrupt(id: FiberId) {
+export function interrupt(id: FiberId): Exit<never, never> {
   return failCause(Cause.interrupt(id));
 }
 

package/_src/data/FiberId/api.ts

@@ -1,26 +1,28 @@
 import { Composite, isComposite, isNone } from "./definition.js";
 
 /**
- * @tsplus fluent fncts.FiberId combine
+ * @tsplus pipeable fncts.FiberId combine
  */
-export function combine_(id0: FiberId, id1: FiberId): FiberId {
-  if (isNone(id0)) {
-    return id1;
-  }
-  if (isNone(id1)) {
-    return id0;
-  }
-  if (isComposite(id0)) {
+export function combine(id1: FiberId) {
+  return (id0: FiberId): FiberId => {
+    if (isNone(id0)) {
+      return id1;
+    }
+    if (isNone(id1)) {
+      return id0;
+    }
+    if (isComposite(id0)) {
+      if (isComposite(id1)) {
+        return new Composite(id0.fiberIds.union(id1.fiberIds));
+      } else {
+        return new Composite(id0.fiberIds.add(id1));
+      }
+    }
     if (isComposite(id1)) {
-      return new Composite(id0.fiberIds.union(id1.fiberIds));
-    } else {
-      return new Composite(id0.fiberIds.add(id1));
+      return new Composite(id1.fiberIds.add(id0));
     }
-  }
-  if (isComposite(id1)) {
-    return new Composite(id1.fiberIds.add(id0));
-  }
-  return new Composite(HashSet.fromDefault(id0, id1));
+    return new Composite(HashSet.fromDefault(id0, id1));
+  };
 }
 
 /**

package/_src/data/FiberId/constructors.ts

@@ -4,8 +4,7 @@ import { None, Runtime } from "./definition.js";
 /**
  * @tsplus static fncts.FiberIdOps none
  */
-export const none = new None();
-
+export const none          = new None();
 const _fiberCounter = new AtomicNumber(0);
 
 /**

package/_src/data/Identity/api.ts

@@ -1,15 +1,19 @@
 /**
- * @tsplus fluent fncts.Identity ap
+ * @tsplus pipeable fncts.Identity ap
  */
-export function ap_<A, B>(fab: Identity<(a: A) => B>, fa: Identity<A>): Identity<B> {
-  return Identity.get(Identity.reverseGet(fab)(Identity.reverseGet(fa)));
+export function ap<A>(fa: Identity<A>) {
+  return <B>(fab: Identity<(a: A) => B>): Identity<B> => {
+    return Identity.get(Identity.reverseGet(fab)(Identity.reverseGet(fa)));
+  };
 }
 
 /**
- * @tsplus fluent fncts.Identity map
+ * @tsplus pipeable fncts.Identity map
  */
-export function map_<A, B>(fa: Identity<A>, f: (a: A) => B): Identity<B> {
-  return Identity.get(f(Identity.reverseGet(fa)));
+export function map<A, B>(f: (a: A) => B) {
+  return (fa: Identity<A>): Identity<B> => {
+    return Identity.get(f(Identity.reverseGet(fa)));
+  };
 }
 
 /**
@@ -21,17 +25,21 @@ export function pure<A>(a: A): Identity<A> {
 }
 
 /**
- * @tsplus fluent fncts.Identity zipWith
+ * @tsplus pipeable fncts.Identity zipWith
  */
-export function zipWith_<A, B, C>(fa: Identity<A>, fb: Identity<B>, f: (a: A, b: B) => C): Identity<C> {
-  return Identity.get(f(Identity.reverseGet(fa), Identity.reverseGet(fb)));
+export function zipWith<A, B, C>(fb: Identity<B>, f: (a: A, b: B) => C) {
+  return (fa: Identity<A>): Identity<C> => {
+    return Identity.get(f(Identity.reverseGet(fa), Identity.reverseGet(fb)));
+  };
 }
 
 /**
- * @tsplus fluent fncts.Identity zip
+ * @tsplus pipeable fncts.Identity zip
  */
-export function zip_<A, B>(fa: Identity<A>, fb: Identity<B>): Identity<Zipped.Make<A, B>> {
-  return fa.zipWith(fb, (a, b) => Zipped(a, b));
+export function zip<B>(fb: Identity<B>) {
+  return <A>(fa: Identity<A>): Identity<Zipped.Make<A, B>> => {
+    return fa.zipWith(fb, (a, b) => Zipped(a, b));
+  };
 }
 
 /**

package/_src/data/Identity/instances.ts

@@ -1,24 +1,21 @@
 import type * as P from "../../typeclass.js";
 import type { IdentityN } from "@fncts/base/data/Identity/definition";
 
-import { map_, pure, zip_, zipWith_ } from "./api.js";
-
+import { map, pure, zip, zipWith } from "./api.js";
 /**
  * @tsplus static fncts.IdentityOps Functor
  */
 export const Functor = HKT.instance<P.Functor<IdentityN>>({
-  map: map_,
+  map,
 });
-
 /**
  * @tsplus static fncts.IdentityOps Apply
  */
 export const Apply = HKT.instance<P.Apply<IdentityN>>({
   ...Functor,
-  zip: zip_,
-  zipWith: zipWith_,
+  zip,
+  zipWith,
 });
-
 /**
  * @tsplus static fncts.IdentityOps Applicative
  */

package/_src/data/Interval.ts

@@ -33,49 +33,57 @@ export function isEmpty(self: Interval): boolean {
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule.Interval intersect
+ * @tsplus pipeable fncts.io.Schedule.Interval intersect
  */
-export function intersect_(self: Interval, that: Interval): Interval {
-  const start = Math.max(self.startMilliseconds, that.startMilliseconds);
-  const end   = Math.min(self.endMilliseconds, that.endMilliseconds);
-  return Interval(start, end);
+export function intersect_(that: Interval) {
+  return (self: Interval): Interval => {
+    const start = Math.max(self.startMilliseconds, that.startMilliseconds);
+    const end   = Math.min(self.endMilliseconds, that.endMilliseconds);
+    return Interval(start, end);
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule.Interval lt
- * @tsplus operator fncts.io.Schedule.Interval <
+ * @tsplus pipeable fncts.io.Schedule.Interval lt
+ * @tsplus pipeable-operator fncts.io.Schedule.Interval <
  */
-export function lt_(self: Interval, that: Interval): boolean {
-  return self.min(that) === self;
+export function lt(that: Interval) {
+  return (self: Interval): boolean => {
+    return self.min(that) === self;
+  };
 }
 
 /**
  * @tsplus static fncts.io.Schedule.IntervalOps __call
  */
 export function makeInterval(start: number, end: number): Interval {
-  if (start <= end) return Interval(start, end);
+  if (start <= end) return new Interval(start, end);
   else return Interval.empty;
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule.Interval max
+ * @tsplus pipeable fncts.io.Schedule.Interval max
  */
-export function max_(self: Interval, that: Interval): Interval {
-  const m = self.min(that);
-  if (m === self) return that;
-  else return self;
+export function max(that: Interval) {
+  return (self: Interval): Interval => {
+    const m = self.min(that);
+    if (m === self) return that;
+    else return self;
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule.Interval min
+ * @tsplus pipeable fncts.io.Schedule.Interval min
  */
-export function min_(self: Interval, that: Interval): Interval {
-  if (self.endMilliseconds <= that.startMilliseconds) return self;
-  if (that.endMilliseconds <= self.startMilliseconds) return that;
-  if (self.startMilliseconds < that.startMilliseconds) return self;
-  if (that.startMilliseconds < self.startMilliseconds) return that;
-  if (self.endMilliseconds <= that.endMilliseconds) return self;
-  return that;
+export function min(that: Interval) {
+  return (self: Interval): Interval => {
+    if (self.endMilliseconds <= that.startMilliseconds) return self;
+    if (that.endMilliseconds <= self.startMilliseconds) return that;
+    if (self.startMilliseconds < that.startMilliseconds) return self;
+    if (that.startMilliseconds < self.startMilliseconds) return that;
+    if (self.endMilliseconds <= that.endMilliseconds) return self;
+    return that;
+  };
 }
 
 /**
@@ -93,11 +101,13 @@ export function size(self: Interval): number {
 }
 
 /**
- * @tsplus fluent fncts.io.Schedule.Interval union
+ * @tsplus pipeable fncts.io.Schedule.Interval union
  */
-export function union_(self: Interval, that: Interval): Maybe<Interval> {
-  const istart = Math.max(self.startMilliseconds, that.startMilliseconds);
-  const iend   = Math.min(self.endMilliseconds, that.endMilliseconds);
-  if (istart <= iend) return Nothing();
-  else return Just(Interval(istart, iend));
+export function union(that: Interval) {
+  return (self: Interval): Maybe<Interval> => {
+    const istart = Math.max(self.startMilliseconds, that.startMilliseconds);
+    const iend   = Math.min(self.endMilliseconds, that.endMilliseconds);
+    if (istart <= iend) return Nothing();
+    else return Just(Interval(istart, iend));
+  };
 }

package/_src/data/Intervals.ts

@@ -14,19 +14,21 @@ export function make(intervals: List<Interval>): Intervals {
 }
 
 /**
- * @tsplus fluent fncts.Intervals union
- * @tsplus operator fncts.Intervals ||
+ * @tsplus pipeable fncts.Intervals union
+ * @tsplus pipeable-operator fncts.Intervals ||
  */
-export function union(self: Intervals, that: Intervals): Intervals {
-  if (that.intervals.isEmpty()) {
-    return self;
-  } else if (self.intervals.isEmpty()) {
-    return that;
-  } else if (self.intervals.head.startMilliseconds < that.intervals.head.startMilliseconds) {
-    return unionLoop(self.intervals.tail, that.intervals, self.intervals.head, Nil());
-  } else {
-    return unionLoop(self.intervals, that.intervals.tail, that.intervals.head, Nil());
-  }
+export function union(that: Intervals) {
+  return (self: Intervals): Intervals => {
+    if (that.intervals.isEmpty()) {
+      return self;
+    } else if (self.intervals.isEmpty()) {
+      return that;
+    } else if (self.intervals.head.startMilliseconds < that.intervals.head.startMilliseconds) {
+      return unionLoop(self.intervals.tail, that.intervals, self.intervals.head, Nil());
+    } else {
+      return unionLoop(self.intervals, that.intervals.tail, that.intervals.head, Nil());
+    }
+  };
 }
 
 /**
@@ -64,11 +66,13 @@ function unionLoop(left: List<Interval>, right: List<Interval>, interval: Interv
 }
 
 /**
- * @tsplus fluent fncts.Intervals intersect
- * @tsplus operator fncts.Intervals &&
+ * @tsplus pipeable fncts.Intervals intersect
+ * @tsplus pipeable-operator fncts.Intervals &&
  */
-export function intersect(self: Intervals, that: Intervals): Intervals {
-  return intersectLoop(self.intervals, that.intervals, Nil());
+export function intersect(that: Intervals) {
+  return (self: Intervals): Intervals => {
+    return intersectLoop(self.intervals, that.intervals, Nil());
+  };
 }
 
 /**
@@ -104,18 +108,22 @@ export function end(self: Intervals): number {
 }
 
 /**
- * @tsplus fluent fncts.Intervals lt
- * @tsplus operator fncts.Intervals <
+ * @tsplus pipeable fncts.Intervals lt
+ * @tsplus pipeable-operator fncts.Intervals <
  */
-export function lt(self: Intervals, that: Intervals): boolean {
-  return self.start < that.start;
+export function lt(that: Intervals) {
+  return (self: Intervals): boolean => {
+    return self.start < that.start;
+  };
 }
 
 /**
- * @tsplus fluent fncts.Intervals max
+ * @tsplus pipeable fncts.Intervals max
  */
-export function max(self: Intervals, that: Intervals): Intervals {
-  return self < that ? that : self;
+export function max(that: Intervals) {
+  return (self: Intervals): Intervals => {
+    return self < that ? that : self;
+  };
 }
 
 /**