@fncts/base 0.0.20 → 0.0.22

package/_src/collection/immutable/ImmutableNonEmptyArray/constructors.ts

@@ -1,9 +1,16 @@
 import { ImmutableNonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
 
-export function allocWithHead<A>(head: A, length: number): Array<A> & { 0: A } {
+export function allocWithHead<A>(
+  head: A,
+  length: number,
+): Array<A> & {
+  0: A;
+} {
   const as = new Array(length);
   as[0]    = head;
-  return as as Array<A> & { 0: A };
+  return as as Array<A> & {
+    0: A;
+  };
 }
 
 /**
@@ -14,13 +21,21 @@ export function unsafeAsNonEmptyArray<A>(self: ReadonlyArray<A>): ImmutableNonEm
   if (self.length === 0) {
     throw new IndexOutOfBoundsError("0 length Array supplied to Array#unsafeAsNonEmpty");
   }
-  return new ImmutableNonEmptyArray(self as ReadonlyArray<A> & { readonly 0: A });
+  return new ImmutableNonEmptyArray(
+    self as ReadonlyArray<A> & {
+      readonly 0: A;
+    },
+  );
 }
 
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps from
  */
-export function from<A>(self: ReadonlyArray<A> & { readonly 0: A }): ImmutableNonEmptyArray<A> {
+export function from<A>(
+  self: ReadonlyArray<A> & {
+    readonly 0: A;
+  },
+): ImmutableNonEmptyArray<A> {
   return new ImmutableNonEmptyArray(self);
 }
 

package/_src/collection/immutable/ImmutableNonEmptyArray/definition.ts

@@ -1,5 +1,4 @@
 import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
-
 export interface ImmutableNonEmptyArrayF extends HKT {
   type: ImmutableNonEmptyArray<this["A"]>;
   variance: {

package/_src/collection/immutable/ImmutableNonEmptyArray/instances.ts

@@ -2,17 +2,16 @@ import type { ImmutableNonEmptyArrayF } from "@fncts/base/collection/immutable/I
 import type * as P from "@fncts/base/typeclass";
 
 import {
-  align_,
-  alignWith_,
-  cross_,
-  crossWith_,
-  flatMap_,
-  foldLeft_,
-  foldLeftWithIndex_,
-  foldRight_,
-  foldRightWithIndex_,
-  map_,
-  mapWithIndex_,
+  alignWith,
+  cross,
+  crossWith,
+  flatMap,
+  foldLeft,
+  foldLeftWithIndex,
+  foldRight,
+  foldRightWithIndex,
+  map,
+  mapWithIndex,
   traverse,
   traverseWithIndex,
 } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api";
@@ -22,23 +21,23 @@ import { make } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/co
  * @tsplus static fncts.ImmutableNonEmptyArrayOps Semialign
  */
 export const Semialign = HKT.instance<P.Semialign<ImmutableNonEmptyArrayF>>({
-  map: map_,
-  alignWith: alignWith_,
+  map,
+  alignWith,
 });
 
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps Functor
  */
 export const Functor = HKT.instance<P.Functor<ImmutableNonEmptyArrayF>>({
-  map: map_,
+  map,
 });
 
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps FunctorWithIndex
  */
 export const FunctorWithIndex = HKT.instance<P.FunctorWithIndex<ImmutableNonEmptyArrayF>>({
-  map: map_,
-  mapWithIndex: mapWithIndex_,
+  map,
+  mapWithIndex,
 });
 
 /**
@@ -46,8 +45,8 @@ export const FunctorWithIndex = HKT.instance<P.FunctorWithIndex<ImmutableNonEmpt
  */
 export const Apply = HKT.instance<P.Apply<ImmutableNonEmptyArrayF>>({
   ...Functor,
-  zip: cross_,
-  zipWith: crossWith_,
+  zip: cross,
+  zipWith: crossWith,
 });
 
 /**
@@ -63,15 +62,15 @@ export const Applicative = HKT.instance<P.Applicative<ImmutableNonEmptyArrayF>>(
  */
 export const Monad = HKT.instance<P.Monad<ImmutableNonEmptyArrayF>>({
   ...Applicative,
-  flatMap: flatMap_,
+  flatMap,
 });
 
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps Foldable
  */
 export const Foldable = HKT.instance<P.Foldable<ImmutableNonEmptyArrayF>>({
-  foldLeft: foldLeft_,
-  foldRight: foldRight_,
+  foldLeft,
+  foldRight,
 });
 
 /**
@@ -79,8 +78,8 @@ export const Foldable = HKT.instance<P.Foldable<ImmutableNonEmptyArrayF>>({
  */
 export const FoldableWithIndex = HKT.instance<P.FoldableWithIndex<ImmutableNonEmptyArrayF>>({
   ...Foldable,
-  foldLeftWithIndex: foldLeftWithIndex_,
-  foldRightWithIndex: foldRightWithIndex_,
+  foldLeftWithIndex,
+  foldRightWithIndex,
 });
 
 /**

package/_src/collection/immutable/ImmutableNonEmptyArray.ts

@@ -2,7 +2,6 @@
 export * from "./ImmutableNonEmptyArray/api.js";
 export * from "./ImmutableNonEmptyArray/constructors.js";
 export * from "./ImmutableNonEmptyArray/definition.js";
-export * from "./ImmutableNonEmptyArray/derivations.js";
 export * from "./ImmutableNonEmptyArray/destructors.js";
 export * from "./ImmutableNonEmptyArray/instances.js";
 // codegen:end

package/_src/collection/immutable/List/api/foldLeft.ts

@@ -1,12 +1,14 @@
 /**
- * @tsplus fluent fncts.List foldLeft
+ * @tsplus pipeable fncts.List foldLeft
  */
-export function foldLeft_<A, B>(self: List<A>, b: B, f: (b: B, a: A) => B): B {
-  let acc   = b;
-  let these = self;
-  while (!these.isEmpty()) {
-    acc   = f(acc, these.head);
-    these = these.tail;
-  }
-  return acc;
+export function foldLeft<A, B>(b: B, f: (b: B, a: A) => B) {
+  return (self: List<A>): B => {
+    let acc   = b;
+    let these = self;
+    while (!these.isEmpty()) {
+      acc   = f(acc, these.head);
+      these = these.tail;
+    }
+    return acc;
+  };
 }

package/_src/collection/immutable/List/api.ts

@@ -18,56 +18,66 @@ import { _Nil } from "@fncts/base/collection/immutable/List/definition";
 import { ListBuffer } from "@fncts/base/collection/mutable/ListBuffer";
 
 /**
- * @tsplus fluent fncts.List flatMap
+ * @tsplus pipeable fncts.List flatMap
  */
-export function flatMap_<A, B>(self: List<A>, f: (a: A) => List<B>): List<B> {
-  let rest = self;
-  let h: Cons<B> | undefined;
-  let t: Cons<B> | undefined;
-  while (!rest.isEmpty()) {
-    let bs = f(rest.head);
-    while (!bs.isEmpty()) {
-      const nx = new Cons(bs.head, _Nil);
-      if (t === undefined) {
-        h = nx;
-      } else {
-        t.tail = nx;
+export function flatMap<A, B>(f: (a: A) => List<B>) {
+  return (self: List<A>): List<B> => {
+    let rest = self;
+    let h: Cons<B> | undefined;
+    let t: Cons<B> | undefined;
+    while (!rest.isEmpty()) {
+      let bs = f(rest.head);
+      while (!bs.isEmpty()) {
+        const nx = new Cons(bs.head, _Nil);
+        if (t === undefined) {
+          h = nx;
+        } else {
+          t.tail = nx;
+        }
+        t  = nx;
+        bs = bs.tail;
       }
-      t  = nx;
-      bs = bs.tail;
+      rest = rest.tail;
     }
-    rest = rest.tail;
-  }
-  if (h === undefined) return _Nil;
-  else return h;
+    if (h === undefined) return _Nil;
+    else return h;
+  };
 }
 
 /**
- * @tsplus fluent fncts.List concat
+ * @tsplus pipeable fncts.List concat
  */
-export function concat_<A, B>(self: List<A>, that: List<B>): List<A | B> {
-  return that.prependAll(self);
+export function concat<B>(that: List<B>) {
+  return <A>(self: List<A>): List<A | B> => {
+    return that.prependAll(self);
+  };
 }
 
 /**
- * @tsplus fluent fncts.List exists
+ * @tsplus pipeable fncts.List some
  */
-export function exists_<A>(self: List<A>, p: Predicate<A>): boolean {
-  let these = self;
-  while (!these.isEmpty()) {
-    if (p(these.head)) {
-      return true;
+export function some<A>(p: Predicate<A>) {
+  return (self: List<A>): boolean => {
+    let these = self;
+    while (!these.isEmpty()) {
+      if (p(these.head)) {
+        return true;
+      }
+      these = these.tail;
     }
-    these = these.tail;
-  }
-  return false;
+    return false;
+  };
 }
 
 /**
- * @tsplus fluent fncts.List filter
+ * @tsplus pipeable fncts.List filter
  */
-export function filter_<A>(self: List<A>, p: Predicate<A>): List<A> {
-  return filterCommon_(self, p, false);
+export function filter<A, B extends A>(p: Refinement<A, B>): (self: List<A>) => List<B>;
+export function filter<A>(p: Predicate<A>): (self: List<A>) => List<A>;
+export function filter<A>(p: Predicate<A>) {
+  return (self: List<A>): List<A> => {
+    return filterCommon(self, p, false);
+  };
 }
 
 function noneIn<A>(l: List<A>, p: Predicate<A>, isFlipped: boolean): List<A> {
@@ -105,14 +115,12 @@ function partialFill<A>(origStart: List<A>, firstMiss: List<A>, p: Predicate<A>,
   const newHead   = new Cons(unsafeHead(origStart), _Nil);
   let toProcess   = origStart.unsafeTail as Cons<A>;
   let currentLast = newHead;
-
   while (!(toProcess === firstMiss)) {
     const newElem    = Cons(unsafeHead(toProcess), _Nil);
     currentLast.tail = newElem;
     currentLast      = newElem;
     toProcess        = unsafeCoerce(toProcess.tail);
   }
-
   let next                = firstMiss.tail;
   let nextToCopy: Cons<A> = unsafeCoerce(next);
   while (!next.isEmpty()) {
@@ -138,19 +146,21 @@ function partialFill<A>(origStart: List<A>, firstMiss: List<A>, p: Predicate<A>,
   return newHead;
 }
 
-function filterCommon_<A>(list: List<A>, p: Predicate<A>, isFlipped: boolean): List<A> {
+function filterCommon<A>(list: List<A>, p: Predicate<A>, isFlipped: boolean): List<A> {
   return noneIn(list, p, isFlipped);
 }
 
 /**
- * @tsplus fluent fncts.List forEach
+ * @tsplus pipeable fncts.List forEach
  */
-export function forEach_<A, U>(self: List<A>, f: (a: A) => U): void {
-  let these = self;
-  while (!these.isEmpty()) {
-    f(these.head);
-    these = these.tail;
-  }
+export function forEach<A, U>(f: (a: A) => U) {
+  return (self: List<A>): void => {
+    let these = self;
+    while (!these.isEmpty()) {
+      f(these.head);
+      these = these.tail;
+    }
+  };
 }
 
 /**
@@ -161,13 +171,15 @@ export function head<A>(self: List<A>): Maybe<A> {
 }
 
 /**
- * @tsplus fluent fncts.List join
+ * @tsplus pipeable fncts.List join
  */
-export function join(self: List<string>, separator: string): string {
-  if (self.isEmpty()) {
-    return "";
-  }
-  return self.unsafeTail.foldLeft(self.unsafeHead, (acc, s) => acc + separator + s);
+export function join(separator: string) {
+  return (self: List<string>): string => {
+    if (self.isEmpty()) {
+      return "";
+    }
+    return self.unsafeTail.foldLeft(self.unsafeHead, (acc, s) => acc + separator + s);
+  };
 }
 
 /**
@@ -184,30 +196,34 @@ export function length<A>(list: List<A>): number {
 }
 
 /**
- * @tsplus fluent fncts.List map
+ * @tsplus pipeable fncts.List map
  */
-export function map_<A, B>(self: List<A>, f: (a: A) => B): List<B> {
-  if (self.isEmpty()) {
-    return self as unknown as List<B>;
-  } else {
-    const h        = new Cons(f(self.head), _Nil);
-    let t: Cons<B> = h;
-    let rest       = self.tail;
-    while (!rest.isEmpty()) {
-      const nx = new Cons(f(rest.head), _Nil);
-      t.tail   = nx;
-      t        = nx;
-      rest     = rest.tail;
+export function map<A, B>(f: (a: A) => B) {
+  return (self: List<A>): List<B> => {
+    if (self.isEmpty()) {
+      return self as unknown as List<B>;
+    } else {
+      const h        = new Cons(f(self.head), _Nil);
+      let t: Cons<B> = h;
+      let rest       = self.tail;
+      while (!rest.isEmpty()) {
+        const nx = new Cons(f(rest.head), _Nil);
+        t.tail   = nx;
+        t        = nx;
+        rest     = rest.tail;
+      }
+      return h;
     }
-    return h;
-  }
+  };
 }
 
 /**
- * @tsplus fluent fncts.List prepend
+ * @tsplus pipeable fncts.List prepend
  */
-export function prepend_<A, B>(self: List<A>, elem: B): List<A | B> {
-  return new Cons<A | B>(elem, self);
+export function prepend<B>(elem: B) {
+  return <A>(self: List<A>): List<A | B> => {
+    return new Cons<A | B>(elem, self);
+  };
 }
 
 /**
@@ -218,25 +234,27 @@ export function prependOperator<A, B>(elem: A, self: List<B>): List<A | B> {
 }
 
 /**
- * @tsplus fluent fncts.List prependAll
+ * @tsplus pipeable fncts.List prependAll
  */
-export function prependAll_<A, B>(self: List<A>, prefix: List<B>): List<A | B> {
-  if (self.isEmpty()) {
-    return prefix;
-  } else if (prefix.isEmpty()) {
-    return self;
-  } else {
-    const result = new Cons<A | B>(prefix.head, self);
-    let curr     = result;
-    let that     = prefix.tail;
-    while (!that.isEmpty()) {
-      const temp = new Cons<A | B>(that.head, self);
-      curr.tail  = temp;
-      curr       = temp;
-      that       = that.tail;
+export function prependAll<B>(prefix: List<B>) {
+  return <A>(self: List<A>): List<A | B> => {
+    if (self.isEmpty()) {
+      return prefix;
+    } else if (prefix.isEmpty()) {
+      return self;
+    } else {
+      const result = new Cons<A | B>(prefix.head, self);
+      let curr     = result;
+      let that     = prefix.tail;
+      while (!that.isEmpty()) {
+        const temp = new Cons<A | B>(that.head, self);
+        curr.tail  = temp;
+        curr       = temp;
+        that       = that.tail;
+      }
+      return result;
     }
-    return result;
-  }
+  };
 }
 
 /**
@@ -246,39 +264,43 @@ export function reverse<A>(self: List<A>): List<A> {
   let result: List<A> = Nil();
   let these           = self;
   while (!these.isEmpty()) {
-    result = prepend_(result, these.head);
+    result = result.prepend(these.head);
     these  = these.tail;
   }
   return result;
 }
 
 /**
- * @tsplus fluent fncts.List sort
+ * @tsplus pipeable fncts.List sort
  */
-export function sort<A>(self: List<A>, /** @tsplus auto */ O: P.Ord<A>): List<A> {
-  return sortWith_(self, O.compare);
+export function sort<A>(/** @tsplus auto */ O: P.Ord<A>) {
+  return (self: List<A>): List<A> => {
+    return self.sortWith((x, y) => O.compare(y)(x));
+  };
 }
 
 /**
- * @tsplus fluent fncts.List sortWith
+ * @tsplus pipeable fncts.List sortWith
  */
-export function sortWith_<A>(self: List<A>, compare: (x: A, y: A) => P.Ordering): List<A> {
-  const len = length(self);
-  const b   = new ListBuffer<A>();
-  if (len === 1) {
-    b.append(unsafeHead(self));
-  } else if (len > 1) {
-    const arr = new Array<[number, A]>(len);
-    copyToArrayWithIndex(self, arr);
-    arr.sort(([i, x], [j, y]) => {
-      const c = compare(x, y);
-      return c !== 0 ? c : i < j ? -1 : 1;
-    });
-    for (let i = 0; i < len; i++) {
-      b.append(arr[i]![1]!);
+export function sortWith<A>(compare: (x: A, y: A) => P.Ordering) {
+  return (self: List<A>): List<A> => {
+    const len = length(self);
+    const b   = new ListBuffer<A>();
+    if (len === 1) {
+      b.append(unsafeHead(self));
+    } else if (len > 1) {
+      const arr = new Array<[number, A]>(len);
+      copyToArrayWithIndex(self, arr);
+      arr.sort(([i, x], [j, y]) => {
+        const c = compare(x, y);
+        return c !== 0 ? c : i < j ? -1 : 1;
+      });
+      for (let i = 0; i < len; i++) {
+        b.append(arr[i]![1]!);
+      }
     }
-  }
-  return b.toList;
+    return b.toList;
+  };
 }
 
 /**
@@ -289,49 +311,51 @@ export function tail<A>(self: List<A>): Maybe<List<A>> {
 }
 
 /**
- * @tsplus fluent fncts.List take
+ * @tsplus pipeable fncts.List take
  */
-export function take_<A>(self: List<A>, n: number): List<A> {
-  if (self.isEmpty() || n <= 0) {
-    return _Nil;
-  } else {
-    const h  = new Cons(self.head, _Nil);
-    let t    = h;
-    let rest = self.tail;
-    let i    = 1;
-    while (i < n) {
-      if (rest.isEmpty()) {
-        return self;
+export function take(n: number) {
+  return <A>(self: List<A>): List<A> => {
+    if (self.isEmpty() || n <= 0) {
+      return _Nil;
+    } else {
+      const h  = new Cons(self.head, _Nil);
+      let t    = h;
+      let rest = self.tail;
+      let i    = 1;
+      while (i < n) {
+        if (rest.isEmpty()) {
+          return self;
+        }
+        i       += 1;
+        const nx = new Cons(rest.head, _Nil);
+        t.tail   = nx;
+        t        = nx;
+        rest     = rest.tail;
       }
-      i       += 1;
-      const nx = new Cons(rest.head, _Nil);
-      t.tail   = nx;
-      t        = nx;
-      rest     = rest.tail;
+      return h;
     }
-    return h;
-  }
+  };
 }
 
 /**
  * @tsplus getter fncts.List unsafeHead
  */
-export function unsafeHead<A>(list: List<A>): A {
-  if (list.isEmpty()) {
+export function unsafeHead<A>(self: List<A>): A {
+  if (self.isEmpty()) {
     throw new NoSuchElementError("unsafeHead on empty List");
   }
-  return list.head;
+  return self.head;
 }
 
 /**
  * @tsplus getter fncts.List unsafeLast
  */
-export function unsafeLast<A>(list: List<A>): A {
-  if (list.isEmpty()) {
+export function unsafeLast<A>(self: List<A>): A {
+  if (self.isEmpty()) {
     throw new NoSuchElementError("unsafeLast on empty List");
   }
-  let these = list;
-  let scout = list.tail;
+  let these = self;
+  let scout = self.tail;
   while (!scout.isEmpty()) {
     these = scout;
     scout = scout.tail;

package/_src/collection/immutable/List/constructors.ts

@@ -30,7 +30,7 @@ export function empty<A>(): List<A> {
 
 /**
  * @tsplus static fncts.ListOps from
- * @tsplus getter fncts.Iterable asList
+ * @tsplus getter fncts.Iterable toList
  */
 export function from<A>(prefix: Iterable<A>): List<A> {
   const iter = prefix[Symbol.iterator]();

package/_src/collection/immutable/List.ts

@@ -3,7 +3,6 @@ export * from "./List/api.js";
 export * from "./List/constructors.js";
 export * from "./List/definition.js";
 // codegen:end
-
 // codegen:start { preset: barrel, include: "./List/api/*.ts" }
 export * from "./List/api/foldLeft.js";
 export * from "./List/api/unsafeTail.js";