@fncts/base 0.0.39 → 0.0.41

package/_src/data/Maybe/api.ts

@@ -15,19 +15,6 @@ export function ap<A>(fa: Maybe<A>) {
   };
 }
 
-/**
- * Applies `f` to the value contained in `Maybe` if it is `Just` and returns the result,
- * otherwise returns `Nothing`.
- *
- * @tsplus pipeable fncts.Maybe flatMap
- */
-export function flatMap<A, B>(f: (a: A) => Maybe<B>) {
-  return (self: Maybe<A>): Maybe<B> => {
-    self.concrete();
-    return self._tag === MaybeTag.Just ? f(self.value) : (self as Nothing);
-  };
-}
-
 /**
  * @tsplus pipeable fncts.Maybe elem
  */
@@ -38,28 +25,17 @@ export function elem<A>(elem: A, /** @tsplus auto */ E: Eq<A>) {
   };
 }
 
-/**
- * @tsplus pipeable fncts.Maybe some
- */
-export function some<A>(p: Predicate<A>) {
-  return (self: Maybe<A>): boolean => {
-    self.concrete();
-    return self._tag === MaybeTag.Just ? p(self.value) : false;
-  };
-}
-
 /**
  * @tsplus pipeable fncts.Maybe filter
  */
-export function filter<A>(p: Predicate<A>): <B>(self: Maybe<A>) => Maybe<A>;
+export function filter<A>(p: Predicate<A>): (self: Maybe<A>) => Maybe<A>;
 export function filter<A, B extends A>(p: Refinement<A, B>): (self: Maybe<A>) => Maybe<B>;
 export function filter<A>(p: Predicate<A>) {
-  return <B>(self: Maybe<A>): Maybe<A> => {
+  return (self: Maybe<A>): Maybe<A> => {
     self.concrete();
     return self._tag === MaybeTag.Just && p(self.value) ? self : Nothing();
   };
 }
-
 /**
  * @tsplus pipeable fncts.Maybe filter
  */
@@ -68,41 +44,24 @@ export function filterMap<A, B>(f: (a: A) => Maybe<B>) {
     return self.flatMap(f);
   };
 }
-
 /**
- * @tsplus getter fncts.Maybe flatten
- */
-export function flatten<A>(self: Maybe<Maybe<A>>): Maybe<A> {
-  return self.flatMap(identity);
-}
-
-/**
- * @tsplus pipeable fncts.Maybe partition
+ * Applies `f` to the value contained in `Maybe` if it is `Just` and returns the result,
+ * otherwise returns `Nothing`.
+ *
+ * @tsplus pipeable fncts.Maybe flatMap
  */
-export function partition<A>(p: Predicate<A>): (self: Maybe<A>) => readonly [Maybe<A>, Maybe<A>];
-export function partition<A, B extends A>(p: Refinement<A, B>): (self: Maybe<A>) => readonly [Maybe<A>, Maybe<B>];
-export function partition<A>(p: Predicate<A>) {
-  return (self: Maybe<A>): readonly [Maybe<A>, Maybe<A>] => {
+export function flatMap<A, B>(f: (a: A) => Maybe<B>) {
+  return (self: Maybe<A>): Maybe<B> => {
     self.concrete();
-    return self._tag === MaybeTag.Just && p(self.value) ? [Nothing(), self] : [self, Nothing()];
+    return self._tag === MaybeTag.Just ? f(self.value) : (self as Nothing);
   };
 }
 
 /**
- * @tsplus pipeable fncts.Maybe partitionMap
+ * @tsplus getter fncts.Maybe flatten
  */
-export function partitionMap<A, B, C>(f: (a: A) => Either<B, C>) {
-  return (self: Maybe<A>): readonly [Maybe<B>, Maybe<C>] => {
-    self.concrete();
-    if (self._tag === MaybeTag.Just) {
-      return f(self.value).match(
-        (b) => [Just(b), Nothing()],
-        (c) => [Nothing(), Just(c)],
-      );
-    } else {
-      return [Nothing(), Nothing()];
-    }
-  };
+export function flatten<A>(self: Maybe<Maybe<A>>): Maybe<A> {
+  return self.flatMap(identity);
 }
 
 /**
@@ -116,25 +75,23 @@ export function foldLeft<A, B>(b: B, f: (b: B, a: A) => B) {
 }
 
 /**
- * @tsplus pipeable fncts.Maybe foldRight
+ * @tsplus pipeable fncts.Maybe foldMap
  */
-export function foldRight<A, B>(b: B, f: (a: A, b: B) => B) {
-  return (self: Maybe<A>): B => {
+export function foldMap<A, M>(f: (a: A) => M, /** @tsplus auto */ M: Monoid<M>) {
+  return (self: Maybe<A>): M => {
     self.concrete();
-    return self._tag === MaybeTag.Just ? f(self.value, b) : b;
+    return self._tag === MaybeTag.Just ? f(self.value) : M.nat;
   };
 }
-
 /**
- * @tsplus pipeable fncts.Maybe foldMap
+ * @tsplus pipeable fncts.Maybe foldRight
  */
-export function foldMap<A, M>(f: (a: A) => M, /** @tsplus auto */ M: Monoid<M>) {
-  return (self: Maybe<A>): M => {
+export function foldRight<A, B>(b: B, f: (a: A, b: B) => B) {
+  return (self: Maybe<A>): B => {
     self.concrete();
-    return self._tag === MaybeTag.Just ? f(self.value) : M.nat;
+    return self._tag === MaybeTag.Just ? f(self.value, b) : b;
   };
 }
-
 /**
  * Extracts the value from `Maybe` if it exists, or returns the result of `orElse`.
  *
@@ -147,6 +104,19 @@ export function getOrElse<B>(orElse: Lazy<B>) {
   };
 }
 
+/**
+ * @tsplus getter fncts.Maybe getOrThrow
+ */
+export function getOrThrow<A>(self: Maybe<A>): A {
+  self.concrete();
+  switch (self._tag) {
+    case MaybeTag.Nothing:
+      throw new NoSuchElementError("getOrThrow called on Nothing");
+    case MaybeTag.Just:
+      return self.value;
+  }
+}
+
 /**
  * Applies `f` to the value contained in `Maybe` if it is `Just`, otherwise returns `Nothing`.
  *
@@ -160,7 +130,7 @@ export function map<A, B>(f: (a: A) => B) {
 }
 
 /**
- * `chain` + `fromNullable`
+ * `flatMap(fromNullable)`
  *
  * @tsplus pipeable fncts.Maybe mapNullable
  */
@@ -179,6 +149,45 @@ export function orElse<B>(fb: Lazy<Maybe<B>>) {
     return self._tag === MaybeTag.Nothing ? fb() : self;
   };
 }
+/**
+ * @tsplus pipeable fncts.Maybe partition
+ */
+export function partition<A>(p: Predicate<A>): (self: Maybe<A>) => readonly [Maybe<A>, Maybe<A>];
+export function partition<A, B extends A>(p: Refinement<A, B>): (self: Maybe<A>) => readonly [Maybe<A>, Maybe<B>];
+
+export function partition<A>(p: Predicate<A>) {
+  return (self: Maybe<A>): readonly [Maybe<A>, Maybe<A>] => {
+    self.concrete();
+    return self._tag === MaybeTag.Just && p(self.value) ? [Nothing(), self] : [self, Nothing()];
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.Maybe partitionMap
+ */
+export function partitionMap<A, B, C>(f: (a: A) => Either<B, C>) {
+  return (self: Maybe<A>): readonly [Maybe<B>, Maybe<C>] => {
+    self.concrete();
+    if (self._tag === MaybeTag.Just) {
+      return f(self.value).match(
+        (b) => [Just(b), Nothing()],
+        (c) => [Nothing(), Just(c)],
+      );
+    } else {
+      return [Nothing(), Nothing()];
+    }
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.Maybe some
+ */
+export function some<A>(p: Predicate<A>) {
+  return (self: Maybe<A>): boolean => {
+    self.concrete();
+    return self._tag === MaybeTag.Just ? p(self.value) : false;
+  };
+}
 
 /**
  * Extracts the value from `Maybe` if it is `Just`, otherwise returns `undefined`
@@ -189,6 +198,15 @@ export function toUndefined<A>(self: Maybe<A>): A | undefined {
   return self.match(() => undefined, identity);
 }
 
+/**
+ * @tsplus pipeable fncts.Maybe zip
+ */
+export function zip<B>(that: Maybe<B>) {
+  return <A>(self: Maybe<A>): Maybe<Zipped.Make<A, B>> => {
+    return self.zipWith(that, (a, b) => Zipped(a, b));
+  };
+}
+
 /**
  * @tsplus pipeable fncts.Maybe zipWith
  */
@@ -199,12 +217,3 @@ export function zipWith<A, B, C>(fb: Maybe<B>, f: (a: A, b: B) => C) {
     return self._tag === MaybeTag.Just && fb._tag === MaybeTag.Just ? Just(f(self.value, fb.value)) : Nothing();
   };
 }
-
-/**
- * @tsplus pipeable fncts.Maybe zip
- */
-export function zip<B>(that: Maybe<B>) {
-  return <A>(self: Maybe<A>): Maybe<Zipped.Make<A, B>> => {
-    return self.zipWith(that, (a, b) => Zipped(a, b));
-  };
-}

package/_src/data/Maybe/constructors.ts

@@ -1,21 +1,5 @@
 import type { Nullable } from "@fncts/base/types";
 
-/**
- * @tsplus static fncts.MaybeOps just
- * @tsplus static fncts.JustOps __call
- */
-export function just<A>(a: A, __tsplusTrace?: string): Maybe<A> {
-  return new Just(a, __tsplusTrace);
-}
-
-/**
- * @tsplus static fncts.MaybeOps nothing
- * @tsplus static fncts.NothingOps __call
- */
-export function nothing<A = never>(__tsplusTrace?: string): Maybe<A> {
-  return new Nothing(__tsplusTrace);
-}
-
 /**
  * @tsplus static fncts.MaybeOps fromNullable
  */
@@ -38,31 +22,19 @@ export function fromPredicate<A, B extends A>(a: A, p: Refinement<A, B>): Maybe<
 export function fromPredicate<A>(a: A, p: Predicate<A>): Maybe<A> {
   return p(a) ? Just(a) : Nothing();
 }
-
 /**
- * @tsplus static fncts.MaybeOps tryCatch
+ * @tsplus static fncts.MaybeOps just
+ * @tsplus static fncts.JustOps __call
  */
-export function tryCatch<A>(thunk: () => A): Maybe<A> {
-  try {
-    return Just(thunk());
-  } catch {
-    return Nothing();
-  }
+export function just<A>(a: A, __tsplusTrace?: string): Maybe<A> {
+  return new Just(a, __tsplusTrace);
 }
-
 /**
- * @tsplus static fncts.MaybeOps tryCatchK
+ * @tsplus static fncts.MaybeOps nothing
+ * @tsplus static fncts.NothingOps __call
  */
-export function tryCatchK<P extends ReadonlyArray<unknown>, A>(f: (...params: P) => A) {
-  return (...params: P): Maybe<A> => tryCatch(() => f(...params));
-}
-
-class PartialException {
-  readonly _tag = "PartialException";
-}
-
-function raisePartial(): never {
-  throw new PartialException();
+export function nothing<A = never>(__tsplusTrace?: string): Maybe<A> {
+  return new Nothing(__tsplusTrace);
 }
 
 /**
@@ -80,3 +52,29 @@ export function partial<P extends ReadonlyArray<unknown>, A>(f: (miss: () => nev
     }
   };
 }
+
+class PartialException {
+  readonly _tag = "PartialException";
+}
+
+function raisePartial(): never {
+  throw new PartialException();
+}
+
+/**
+ * @tsplus static fncts.MaybeOps tryCatch
+ */
+export function tryCatch<A>(thunk: () => A): Maybe<A> {
+  try {
+    return Just(thunk());
+  } catch {
+    return Nothing();
+  }
+}
+
+/**
+ * @tsplus static fncts.MaybeOps tryCatchK
+ */
+export function tryCatchK<P extends ReadonlyArray<unknown>, A>(f: (...params: P) => A) {
+  return (...params: P): Maybe<A> => tryCatch(() => f(...params));
+}

package/_src/data/Showable/util.ts

@@ -54,7 +54,7 @@ for (let n = 0; n <= 0xff; ++n) {
   const hexOctet = n.toString(16).padStart(2, "0");
   byteToHex.push(hexOctet);
 }
-export function hex(arrayBuffer: ArrayBuffer) {
+export function hex(arrayBuffer: ArrayBuffer | Uint8Array<ArrayBuffer>) {
   const buff      = new Uint8Array(arrayBuffer);
   const hexOctets = Array<string>(buff.length);
   for (let i = 0; i < buff.length; ++i) {

package/_src/data/Struct/api.ts

@@ -101,7 +101,7 @@ export function omit<A extends {}, N extends ReadonlyArray<keyof A>>(keys: [...N
   ): Struct<{
     readonly [P in Exclude<keyof A, N[number]>]: A[P];
   }> => {
-    const newKeys = keys.asImmutableArray.difference(self.keys.asImmutableArray, Eq({ equals: (y) => (x) => x === y }));
+    const newKeys = keys.asReadonlyArray.difference(self.keys, Eq({ equals: (y) => (x) => x === y }));
     const out     = {} as any;
     for (const key of newKeys) {
       out[key] = self.getStruct[key];

package/_src/data/These/api.ts

@@ -2,18 +2,87 @@ 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
+ * @tsplus pipeable fncts.These ap
  */
-export function isLeft<E, A>(self: These<E, A>): self is Left<E> {
-  return self._tag === TheseTag.Left;
+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 isRight
+ * @tsplus pipeable fncts.These bimap
  */
-export function isRight<E, A>(self: These<E, A>): self is Right<A> {
-  return self._tag === TheseTag.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 pipeable fncts.These catchAll
+ */
+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;
+  };
+}
+
+/**
+ * @tsplus getter fncts.These condemn
+ */
+export function condemn<E, A>(self: These<E, A>): These<E, A> {
+  if (self._tag === TheseTag.Both) {
+    return These.left(self.left);
+  }
+  return self;
+}
+
+/**
+ * @tsplus pipeable fncts.These condemnWhen
+ */
+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;
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.These flatMap
+ */
+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);
+    }
+  };
 }
 
 /**
@@ -23,6 +92,20 @@ export function isBoth<E, A>(self: These<E, A>): self is Both<E, A> {
   return self._tag === TheseTag.Both;
 }
 
+/**
+ * @tsplus fluent fncts.These isLeft
+ */
+export function isLeft<E, A>(self: These<E, A>): self is Left<E> {
+  return self._tag === TheseTag.Left;
+}
+
+/**
+ * @tsplus fluent fncts.These isRight
+ */
+export function isRight<E, A>(self: These<E, A>): self is Right<A> {
+  return self._tag === TheseTag.Right;
+}
+
 /**
  * @tsplus pipeable fncts.These map
  */
@@ -56,18 +139,11 @@ export function mapLeft<E, E1>(f: (e: E) => E1) {
 }
 
 /**
- * @tsplus pipeable fncts.These bimap
+ * @tsplus pipeable fncts.These zip
  */
-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));
-    }
+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);
   };
 }
 
@@ -107,78 +183,3 @@ export function zipWith<E, A, B, C>(that: These<E, B>, f: (a: A, b: B) => C, /**
     }
   };
 }
-
-/**
- * @tsplus pipeable fncts.These zip
- */
-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 pipeable fncts.These ap
- */
-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 pipeable fncts.These flatMap
- */
-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 pipeable fncts.These catchAll
- */
-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;
-  };
-}
-
-/**
- * @tsplus getter fncts.These condemn
- */
-export function condemn<E, A>(self: These<E, A>): These<E, A> {
-  if (self._tag === TheseTag.Both) {
-    return These.left(self.left);
-  }
-  return self;
-}
-
-/**
- * @tsplus pipeable fncts.These condemnWhen
- */
-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.ts

@@ -38,6 +38,7 @@ export type {} from "./data/Environment.js";
 export type {} from "./data/Either.js";
 export type {} from "./data/Duration.js";
 export type {} from "./data/DatumEither.js";
+export type {} from "./data/Datum.js";
 export type {} from "./data/Date.js";
 export type {} from "./data/Data.js";
 export type {} from "./data/Const.js";

package/_src/global.ts

@@ -3,10 +3,6 @@
  */
 import type {} from "@fncts/base";
 
-/**
- * @tsplus global
- */
-import {} from "@fncts/base/collection/compat/Array";
 /**
  * @tsplus global
  */
@@ -26,23 +22,22 @@ import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
 /**
  * @tsplus global
  */
-import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
+import { Cons, List, Nil } from "@fncts/base/collection/immutable/List/definition";
 /**
  * @tsplus global
  */
-import {
-  ImmutableNonEmptyArray,
-  NonEmptyArray,
-  ReadonlyNonEmptyArray,
-} from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
+import { Queue as ImmutableQueue } from "@fncts/base/collection/immutable/Queue/definition";
 /**
  * @tsplus global
  */
-import { Cons, List, Nil } from "@fncts/base/collection/immutable/List/definition";
+import {} from "@fncts/base/collection/immutable/ReadonlyArray/definition";
 /**
  * @tsplus global
  */
-import { Queue as ImmutableQueue } from "@fncts/base/collection/immutable/Queue/definition";
+import {
+  NonEmptyArray,
+  ReadonlyNonEmptyArray,
+} from "@fncts/base/collection/immutable/ReadonlyNonEmptyArray/definition";
 /**
  * @tsplus global
  */

package/_src/internal/Stack.ts

@@ -13,6 +13,9 @@ export class Stack<A> {
   get isEmpty(): boolean {
     return !this.hasNext;
   }
+  get size(): number {
+    return this.node?.size ?? 0;
+  }
   peek(): A | undefined {
     if (this.node) {
       return this.node.value;
@@ -26,13 +29,14 @@ export class Stack<A> {
     }
   }
   push(value: A): void {
-    this.node = { value, previous: this.node };
+    this.node = { value, previous: this.node, size: (this.node?.size ?? 0) + 1 };
   }
 }
 
 interface Node<A> {
   readonly value: A;
   readonly previous?: Node<A>;
+  readonly size: number;
 }
 
 /**
@@ -46,5 +50,5 @@ export function makeStack<A>(): Stack<A> {
  * @tsplus static fncts.StackOps single
  */
 export function single<A>(value: A): Stack<A> {
-  return new Stack({ value });
+  return new Stack({ value, size: 1 });
 }

package/_src/optics/Index/api.ts

@@ -27,7 +27,7 @@ export function array<A = never>(): Index<ReadonlyArray<A>, number, A> {
     index: (i) =>
       Optional({
         getOrModify: (s) => (i in s ? Either.right(s[i]!) : Either.left(s)),
-        set: (a) => (s) => s.updateAt(i, a),
+        set: (a) => (s) => s.unsafeUpdateAt(i, a),
       }),
   });
 }