@fncts/base 0.0.20 → 0.0.22

package/_src/data/These/api.ts

@@ -2,7 +2,6 @@ import type { Both, Left, Right } from "@fncts/base/data/These/definition";
 import type * as P from "@fncts/base/typeclass";
 
 import { TheseTag } from "@fncts/base/data/These/definition";
-
 /**
  * @tsplus fluent fncts.These isLeft
  */
@@ -25,142 +24,141 @@ export function isBoth<E, A>(self: These<E, A>): self is Both<E, A> {
 }
 
 /**
- * @tsplus fluent fncts.These map
+ * @tsplus pipeable fncts.These map
  */
-export function map<E, A, B>(self: These<E, A>, f: (a: A) => B): These<E, B> {
-  switch (self._tag) {
-    case TheseTag.Left:
-      return self;
-    case TheseTag.Right:
-      return These.right(f(self.right));
-    case TheseTag.Both:
-      return These.both(self.left, f(self.right));
-  }
+export function map<A, B>(f: (a: A) => B) {
+  return <E>(self: These<E, A>): These<E, B> => {
+    switch (self._tag) {
+      case TheseTag.Left:
+        return self;
+      case TheseTag.Right:
+        return These.right(f(self.right));
+      case TheseTag.Both:
+        return These.both(self.left, f(self.right));
+    }
+  };
 }
 
 /**
- * @tsplus fluent fncts.These mapLeft
+ * @tsplus pipeable fncts.These mapLeft
  */
-export function mapLeft<E, A, E1>(self: These<E, A>, f: (e: E) => E1): These<E1, A> {
-  switch (self._tag) {
-    case TheseTag.Left:
-      return These.left(f(self.left));
-    case TheseTag.Right:
-      return self;
-    case TheseTag.Both:
-      return These.both(f(self.left), self.right);
-  }
+export function mapLeft<E, E1>(f: (e: E) => E1) {
+  return <A>(self: These<E, A>): These<E1, A> => {
+    switch (self._tag) {
+      case TheseTag.Left:
+        return These.left(f(self.left));
+      case TheseTag.Right:
+        return self;
+      case TheseTag.Both:
+        return These.both(f(self.left), self.right);
+    }
+  };
 }
 
 /**
- * @tsplus fluent fncts.These bimap
+ * @tsplus pipeable fncts.These bimap
  */
-export function bimap<E, A, E1, B>(self: These<E, A>, f: (e: E) => E1, g: (a: A) => B): These<E1, B> {
-  switch (self._tag) {
-    case TheseTag.Left:
-      return These.left(f(self.left));
-    case TheseTag.Right:
-      return These.right(g(self.right));
-    case TheseTag.Both:
-      return These.both(f(self.left), g(self.right));
-  }
+export function bimap<E, A, E1, B>(f: (e: E) => E1, g: (a: A) => B) {
+  return (self: These<E, A>): These<E1, B> => {
+    switch (self._tag) {
+      case TheseTag.Left:
+        return These.left(f(self.left));
+      case TheseTag.Right:
+        return These.right(g(self.right));
+      case TheseTag.Both:
+        return These.both(f(self.left), g(self.right));
+    }
+  };
 }
 
 /**
- * @tsplus fluent fncts.These zipWith
+ * @tsplus pipeable fncts.These zipWith
  */
-export function zipWith<E, A, B, C>(
-  self: These<E, A>,
-  that: These<E, B>,
-  f: (a: A, b: B) => C,
-  /** @tsplus auto */ S: P.Semigroup<E>,
-): These<E, C> {
-  switch (self._tag) {
-    case TheseTag.Left:
-      switch (that._tag) {
-        case TheseTag.Left:
-          return These.left(S.combine(self.left, that.left));
-        case TheseTag.Right:
-          return self;
-        case TheseTag.Both:
-          return These.left(S.combine(self.left, that.left));
-      }
-    case TheseTag.Right:
-      switch (that._tag) {
-        case TheseTag.Left:
-          return that;
-        case TheseTag.Right:
-          return These.right(f(self.right, that.right));
-        case TheseTag.Both:
-          return These.left(that.left);
-      }
-    case TheseTag.Both:
-      switch (that._tag) {
-        case TheseTag.Left:
-          return These.left(S.combine(self.left, that.left));
-        case TheseTag.Right:
-          return These.both(self.left, f(self.right, that.right));
-        case TheseTag.Both:
-          return These.both(S.combine(self.left, that.left), f(self.right, that.right));
-      }
-  }
+export function zipWith<E, A, B, C>(that: These<E, B>, f: (a: A, b: B) => C, /** @tsplus auto */ S: P.Semigroup<E>) {
+  return (self: These<E, A>): These<E, C> => {
+    switch (self._tag) {
+      case TheseTag.Left:
+        switch (that._tag) {
+          case TheseTag.Left:
+            return These.left(S.combine(that.left)(self.left));
+          case TheseTag.Right:
+            return self;
+          case TheseTag.Both:
+            return These.left(S.combine(that.left)(self.left));
+        }
+      case TheseTag.Right:
+        switch (that._tag) {
+          case TheseTag.Left:
+            return that;
+          case TheseTag.Right:
+            return These.right(f(self.right, that.right));
+          case TheseTag.Both:
+            return These.left(that.left);
+        }
+      case TheseTag.Both:
+        switch (that._tag) {
+          case TheseTag.Left:
+            return These.left(S.combine(that.left)(self.left));
+          case TheseTag.Right:
+            return These.both(self.left, f(self.right, that.right));
+          case TheseTag.Both:
+            return These.both(S.combine(that.left)(self.left), f(self.right, that.right));
+        }
+    }
+  };
 }
 
 /**
- * @tsplus fluent fncts.These zip
+ * @tsplus pipeable fncts.These zip
  */
-export function zip<E, A, B>(
-  self: These<E, A>,
-  that: These<E, B>,
-  /** @tsplus auto */ S: P.Semigroup<E>,
-): These<E, readonly [A, B]> {
-  return self.zipWith(that, (a, b) => [a, b], S);
+export function zip<E, B>(that: These<E, B>, /** @tsplus auto */ S: P.Semigroup<E>) {
+  return <A>(self: These<E, A>): These<E, readonly [A, B]> => {
+    return self.zipWith(that, (a, b) => [a, b], S);
+  };
 }
 
 /**
- * @tsplus fluent fncts.These ap
+ * @tsplus pipeable fncts.These ap
  */
-export function ap<E, A, B>(
-  self: These<E, (a: A) => B>,
-  that: These<E, A>,
-  /** @tsplus auto */ S: P.Semigroup<E>,
-): These<E, B> {
-  return self.zipWith(that, (f, a) => f(a), S);
+export function ap<E, A>(that: These<E, A>, /** @tsplus auto */ S: P.Semigroup<E>) {
+  return <B>(self: These<E, (a: A) => B>): These<E, B> => {
+    return self.zipWith(that, (f, a) => f(a), S);
+  };
 }
 
 /**
- * @tsplus fluent fncts.These flatMap
+ * @tsplus pipeable fncts.These flatMap
  */
-export function flatMap<E, A, B>(
-  self: These<E, A>,
-  f: (a: A) => These<E, B>,
-  /** @tsplus auto */ S: P.Semigroup<E>,
-): These<E, B> {
-  if (self._tag === TheseTag.Left) {
-    return self;
-  }
-  if (self._tag === TheseTag.Right) {
-    return f(self.right);
-  }
-  const that = f(self.right);
-  switch (that._tag) {
-    case TheseTag.Left:
-      return These.left(S.combine(self.left, that.left));
-    case TheseTag.Right:
-      return These.both(self.left, that.right);
-    case TheseTag.Both:
-      return These.both(S.combine(self.left, that.left), that.right);
-  }
+export function flatMap<E, A, B>(f: (a: A) => These<E, B>, /** @tsplus auto */ S: P.Semigroup<E>) {
+  return (self: These<E, A>): These<E, B> => {
+    if (self._tag === TheseTag.Left) {
+      return self;
+    }
+    if (self._tag === TheseTag.Right) {
+      return f(self.right);
+    }
+    const that = f(self.right);
+    switch (that._tag) {
+      case TheseTag.Left:
+        return These.left(S.combine(that.left)(self.left));
+      case TheseTag.Right:
+        return These.both(self.left, that.right);
+      case TheseTag.Both:
+        return These.both(S.combine(that.left)(self.left), that.right);
+    }
+  };
 }
 
 /**
- * @tsplus fluent fncts.These catchAll
+ * @tsplus pipeable fncts.These catchAll
  */
-export function catchAll_<E, A, B>(self: These<E, A>, f: (e: E) => These<E, B>): These<E, A | B> {
-  if (self._tag === TheseTag.Left) {
-    return f(self.left);
-  }
-  return self;
+export function catchAll<E, B>(f: (e: E) => These<E, B>) {
+  return <A>(self: These<E, A>): These<E, A | B> => {
+    if (self._tag === TheseTag.Left) {
+      return f(self.left);
+    }
+    return self;
+  };
 }
 
 /**
@@ -174,11 +172,13 @@ export function condemn<E, A>(self: These<E, A>): These<E, A> {
 }
 
 /**
- * @tsplus fluent fncts.These condemnWhen
+ * @tsplus pipeable fncts.These condemnWhen
  */
-export function condemnWhen<E, A>(self: These<E, A>, p: Predicate<E>): These<E, A> {
-  if (self._tag === TheseTag.Both && p(self.left)) {
-    return These.left(self.left);
-  }
-  return self;
+export function condemnWhen<E>(p: Predicate<E>) {
+  return <A>(self: These<E, A>): These<E, A> => {
+    if (self._tag === TheseTag.Both && p(self.left)) {
+      return These.left(self.left);
+    }
+    return self;
+  };
 }

package/_src/data/These/destructors.ts

@@ -29,33 +29,32 @@ export function leftMaybe<E, A>(self: These<E, A>): Maybe<E> {
 }
 
 /**
- * @tsplus fluent fncts.These match
+ * @tsplus pipeable fncts.These match
  */
-export function match_<E, A, B, C, D>(
-  self: These<E, A>,
-  left: (e: E) => B,
-  right: (a: A) => C,
-  both: (e: E, a: A) => D,
-): B | C | D {
-  switch (self._tag) {
-    case TheseTag.Left:
-      return left(self.left);
-    case TheseTag.Right:
-      return right(self.right);
-    case TheseTag.Both:
-      return both(self.left, self.right);
-  }
+export function match<E, A, B, C, D>(left: (e: E) => B, right: (a: A) => C, both: (e: E, a: A) => D) {
+  return (self: These<E, A>): B | C | D => {
+    switch (self._tag) {
+      case TheseTag.Left:
+        return left(self.left);
+      case TheseTag.Right:
+        return right(self.right);
+      case TheseTag.Both:
+        return both(self.left, self.right);
+    }
+  };
 }
 
 /**
- * @tsplus fluent fncts.These match2
+ * @tsplus pipeable fncts.These match2
  */
-export function match2<E, A, B, C>(self: These<E, A>, left: (e: E) => B, right: (e: Maybe<E>, a: A) => C): B | C {
-  switch (self._tag) {
-    case TheseTag.Left:
-      return left(self.left);
-    case TheseTag.Right:
-    case TheseTag.Both:
-      return right(self.leftMaybe, self.right);
-  }
+export function match2<E, A, B, C>(left: (e: E) => B, right: (e: Maybe<E>, a: A) => C) {
+  return (self: These<E, A>): B | C => {
+    switch (self._tag) {
+      case TheseTag.Left:
+        return left(self.left);
+      case TheseTag.Right:
+      case TheseTag.Both:
+        return right(self.leftMaybe, self.right);
+    }
+  };
 }

package/_src/data/Trace/api.ts

@@ -1,8 +1,10 @@
 /**
- * @tsplus fluent fncts.Trace combine
+ * @tsplus pipeable fncts.Trace combine
  */
-export function combine_(self: Trace, that: Trace): Trace {
-  return new Trace(self.fiberId.combine(that.fiberId), self.stackTrace.concat(that.stackTrace));
+export function combine(that: Trace) {
+  return (self: Trace): Trace => {
+    return new Trace(self.fiberId.combine(that.fiberId), self.stackTrace.concat(that.stackTrace));
+  };
 }
 
 /**

package/_src/data/Zipped.ts

@@ -1,11 +1,10 @@
-import { assert } from "@fncts/base/util/assert";
 import { isArray } from "@fncts/base/util/predicates";
 
 export const ZippedTypeId = Symbol.for("fncts.Zipped");
 export type ZippedTypeId = typeof ZippedTypeId;
-
-export type Zipped<A extends Array<any>> = Readonly<A> & { readonly [ZippedTypeId]: ZippedTypeId };
-
+export type Zipped<A extends Array<any>> = Readonly<A> & {
+  readonly [ZippedTypeId]: ZippedTypeId;
+};
 export declare namespace Zipped {
   type Make<A, B> = [A] extends [Zipped<infer X>]
     ? [B] extends [Zipped<infer Y>]

package/_src/data/bigint/instances.ts

@@ -3,6 +3,7 @@ import { isBigInt } from "@fncts/base/util/predicates";
 
 /**
  * @tsplus static fncts.BigIntOps Guard
+ * @tsplus static fncts.GuardOps bigint
  * @tsplus implicit
  */
 export const Guard: P.Guard<bigint> = P.Guard(isBigInt);

package/_src/data/boolean/instances.ts

@@ -3,6 +3,7 @@ import { isBoolean } from "@fncts/base/util/predicates";
 
 /**
  * @tsplus static fncts.BooleanOps Guard
+ * @tsplus static fncts.GuardOps boolean
  * @tsplus implicit
  */
 export const Guard: P.Guard<boolean> = P.Guard(isBoolean);

package/_src/data/function/api.ts

@@ -1,11 +1,10 @@
 /**
- * @tsplus fluent fncts.Function compose
+ * @tsplus pipeable fncts.Function compose
  */
-export function compose_<A extends ReadonlyArray<any>, B, C>(
-  f: (...params: A) => B,
-  g: (b: B) => C,
-): (...params: A) => C {
-  return (...params) => g(f(...params));
+export function compose<B, C>(g: (b: B) => C) {
+  return <A extends ReadonlyArray<any>>(f: (...params: A) => B): ((...params: A) => C) => {
+    return (...params) => g(f(...params));
+  };
 }
 
 /**
@@ -42,6 +41,6 @@ export function tupled<A, B, C>(f: (a: A, b: B) => C): (_: readonly [A, B]) => C
  * @tsplus static fncts.FunctionOps unsafeCoerce
  * @tsplus macro identity
  */
-export function unsafeCoerce<A, B>(a: A): B {
+export function unsafeCoerce<B, A = unknown>(a: A): B {
   return a as unknown as B;
 }

package/_src/data/function/pipe.ts

@@ -1,6 +1,14 @@
 /**
  * @tsplus macro pipe
- * @tsplus fluent fncts.global via
+ * @tsplus operator fncts.global >>
+ */
+export function pipeOperator<A, B>(a: A, f: (a: A) => B): B {
+  return f(a);
+}
+
+/**
+ * @tsplus macro pipe
+ * @tsplus fluent global pipe
  */
 export function pipe<A>(a: A): A;
 export function pipe<A, B>(a: A, ab: (a: A) => B): B;

package/_src/data/number/instances.ts

@@ -1,25 +1,25 @@
+import { EQ, GT, LT } from "@fncts/base/data/Ordering";
 import { isNumber } from "@fncts/base/util/predicates";
 
 import * as P from "../../typeclass.js";
-import { EQ, GT, LT } from "../../typeclass.js";
 
 /**
  * @tsplus static fncts.NumberOps Eq
  * @tsplus implicit
  */
-export const Eq: P.Eq<number> = P.Eq({ equals: (x, y) => x === y });
+export const Eq: P.Eq<number> = P.Eq({ equals: (y) => (x) => x === y });
 
 /**
  * @tsplus static fncts.NumberOps Ord
  * @tsplus implicit
  */
 export const Ord: P.Ord<number> = P.Ord({
-  compare: (x, y) => (x < y ? LT : x > y ? GT : EQ),
-  equals: (x, y) => x === y,
+  compare: (y) => (x) => x < y ? LT : x > y ? GT : EQ,
+  equals: (y) => (x) => x === y,
 });
 
 /**
  * @tsplus static fncts.NumberOps Guard
- * @tsplus implicit
+ * @tsplus static fncts.GuardOps number
  */
 export const Guard: P.Guard<number> = P.Guard(isNumber);

package/_src/data/object/instances.ts

@@ -1,17 +1,6 @@
-import type { Check } from "@fncts/typelevel/Check";
-
 import * as P from "@fncts/base/typeclass";
 
 /**
  * @tsplus static fncts.globalOps Guard
  */
 export const Guard: P.Guard<{}> = P.Guard(isObject);
-
-/**
- * @tsplus derive fncts.Guard<_> 10
- */
-export function deriveGuard<A extends {}>(
-  ..._: Check<Check.IsEqual<A, {}>> extends Check.True ? [] : never
-): P.Guard<A> {
-  return P.Guard((u): u is A => typeof u === "object" && u !== null);
-}

package/_src/data/string/api.ts

@@ -1,5 +1,3 @@
-import { Ord } from "../../typeclass.js";
-
 /**
  * Capitalize the first letter of the string
  *
@@ -58,19 +56,14 @@ export function reverse(s: string): string {
  * Surround a string. Equivalent to calling `prepend` and `append` with the
  * same outer value.
  *
- * @tsplus fluent fncts.String surround
- */
-export function surround_(s: string, x: string): string {
-  return x + s + x;
-}
-
-/**
- * Surround a string. Equivalent to calling `prepend` and `append` with the
- * same outer value.
- *
+ * @tsplus pipeable fncts.String surround
  * @tsplus static fncts.StringOps surround
  */
-export const surround = Pipeable(surround_);
+export function surround(x: string) {
+  return (s: string): string => {
+    return x + s + x;
+  };
+}
 
 /**
  * Keep the specified number of characters from the start of a string.
@@ -82,17 +75,14 @@ export const surround = Pipeable(surround_);
  *
  * If `n` is a float, it will be rounded down to the nearest integer.
  *
- * @tsplus fluent fncts.String take
+ * @tsplus pipeable fncts.String take
  */
-export function take_(s: string, n: number): string {
-  return s.slice(0, Ord.max(Number.Ord)(0, n));
+export function take(n: number) {
+  return (s: string): string => {
+    return s.slice(0, Ord.max(Number.Ord)(n)(0));
+  };
 }
 
-/**
- * @tsplus static fncts.StringOps take
- */
-export const take = Pipeable(take_);
-
 /**
  * Keep the specified number of characters from the end of a string.
  *
@@ -103,79 +93,67 @@ export const take = Pipeable(take_);
  *
  * If `n` is a float, it will be rounded down to the nearest integer.
  *
- * @tsplus fluent fncts.String takeLast
+ * @tsplus pipeable fncts.String takeLast
  */
-export function takeLast_(s: string, n: number): string {
-  return s.slice(Ord.max(Number.Ord)(0, s.length - Math.floor(n)), Infinity);
+export function takeLast(n: number) {
+  return (s: string): string => {
+    return s.slice(Ord.max(Number.Ord)(s.length - Math.floor(n))(0), Infinity);
+  };
 }
 
-/**
- * @tsplus static fncts.StringOps takeLast
- */
-export const takeLast = Pipeable(takeLast_);
-
 /**
  * Removes the given string from the beginning, if it exists
  *
- * @tsplus fluent fncts.String unprepend
+ * @tsplus pipeable fncts.String unprepend
  */
-export function unprepend_(s: string, s1: string): string {
-  return s.startsWith(s1) ? s.slice(s1.length) : s;
+export function unprepend(s1: string) {
+  return (s: string): string => {
+    return s.startsWith(s1) ? s.slice(s1.length) : s;
+  };
 }
 
-/**
- * @tsplus static fncts.StringOps unprepend
- */
-export const unprepend = Pipeable(unprepend_);
-
 /**
  * Remove the end of a string, if it exists.
  *
- * @tsplus fluent fncts.String unappend
- */
-export function unappend_(s: string, x: string): string {
-  return s.endsWith(x) ? s.substring(0, s.lastIndexOf(x)) : s;
-}
-
-/**
  * @tsplus static fncts.StringOps unappend
+ * @tsplus pipeable fncts.String unappend
  */
-export const unappend = Pipeable(unappend_);
+export function unappend(x: string) {
+  return (s: string): string => {
+    return s.endsWith(x) ? s.substring(0, s.lastIndexOf(x)) : s;
+  };
+}
 
 /**
  * Remove the start and end of a string, if they both exist.
  *
- * @tsplus fluent fncts.String unsurround
- */
-export function unsurround_(s: string, x: string): string {
-  return s.startsWith(x) && s.endsWith(x) ? s.unprepend(x).unappend(x) : s;
-}
-
-/**
  * @tsplus static fncts.StringOps unsurround
+ * @tsplus pipeable fncts.String unsurround
  */
-export const unsurround = Pipeable(unsurround_);
+export function unsurround(x: string) {
+  return (s: string): string => {
+    return s.startsWith(x) && s.endsWith(x) ? s.unprepend(x).unappend(x) : s;
+  };
+}
 
 /**
  * Apply an endomorphism upon an array of characters against a string.
  * This is useful as it allows you to run many polymorphic functions targeting
  * arrays against strings without having to rewrite them.
  *
- * @tsplus fluent fncts.String under
- */
-export function under_(s: string, f: (chars: Array<string>) => Array<string>): string {
-  return f(s.split("")).join("");
-}
-
-/**
  * @tsplus static fncts.StringOps under
+ * @tsplus pipeable fncts.String under
  */
-export const under = Pipeable(under_);
+export function under(f: (chars: Array<string>) => Array<string>) {
+  return (s: string): string => {
+    return f(s.split("")).join("");
+  };
+}
 
 /**
  * Join newline-separated strings together.
  *
- * @tsplus getter fncts.ImmutableArray unlines
+ * @tsplus getter fncts.ReadonlyArray unlines
  */
 export function unlines(as: ReadonlyArray<string>): string {
   return as.join("\n");