@fncts/base 0.0.20 → 0.0.21

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(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));
+        }
+    }
+  };
 }
 
 /**
- * @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(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);
+    }
+  };
 }
 
 /**
- * @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/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/string/api.ts

@@ -58,19 +58,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 +77,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)(0, n));
+  };
 }
 
-/**
- * @tsplus static fncts.StringOps take
- */
-export const take = Pipeable(take_);
-
 /**
  * Keep the specified number of characters from the end of a string.
  *
@@ -103,79 +95,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)(0, s.length - Math.floor(n)), 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");

package/_src/data.ts

@@ -10,6 +10,7 @@ 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/exceptions.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
  */

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;
   }
 }