@fncts/base 0.0.20 → 0.0.22

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

@@ -3,18 +3,18 @@ import { Queue } from "@fncts/base/collection/immutable/Queue/definition";
 /**
  * @tsplus getter fncts.ImmutableQueue length
  */
-export function length<A>(queue: Queue<A>): number {
-  return queue._in.length + queue._out.length;
+export function length<A>(self: Queue<A>): number {
+  return self._in.length + self._out.length;
 }
 
 /**
  * @tsplus getter fncts.ImmutableQueue unsafeHead
  */
-export function unsafeHead<A>(queue: Queue<A>): A {
-  if (queue._out.isNonEmpty()) {
-    return queue._out.unsafeHead;
-  } else if (queue._in.isNonEmpty()) {
-    return queue._in.unsafeLast;
+export function unsafeHead<A>(self: Queue<A>): A {
+  if (self._out.isNonEmpty()) {
+    return self._out.unsafeHead;
+  } else if (self._in.isNonEmpty()) {
+    return self._in.unsafeLast;
   } else {
     throw new NoSuchElementError("unsafeHead on empty Queue");
   }
@@ -23,18 +23,18 @@ export function unsafeHead<A>(queue: Queue<A>): A {
 /**
  * @tsplus getter fncts.ImmutableQueue head
  */
-export function head<A>(queue: Queue<A>): Maybe<A> {
-  return queue.isEmpty ? Nothing() : Just(queue.unsafeHead);
+export function head<A>(self: Queue<A>): Maybe<A> {
+  return self.isEmpty ? Nothing() : Just(self.unsafeHead);
 }
 
 /**
  * @tsplus getter fncts.ImmutableQueue unsafeTail
  */
-export function unsafeTail<A>(queue: Queue<A>): Queue<A> {
-  if (queue._out.isNonEmpty()) {
-    return new Queue(queue._in, queue._out.tail);
-  } else if (queue._in.isNonEmpty()) {
-    return new Queue(List.empty(), queue._in.reverse.unsafeTail);
+export function unsafeTail<A>(self: Queue<A>): Queue<A> {
+  if (self._out.isNonEmpty()) {
+    return new Queue(self._in, self._out.tail);
+  } else if (self._in.isNonEmpty()) {
+    return new Queue(List.empty(), self._in.reverse.unsafeTail);
   } else {
     throw new NoSuchElementError("tail on empty Queue");
   }
@@ -43,33 +43,37 @@ export function unsafeTail<A>(queue: Queue<A>): Queue<A> {
 /**
  * @tsplus getter fncts.ImmutableQueue tail
  */
-export function tail<A>(queue: Queue<A>): Maybe<Queue<A>> {
-  return queue.isEmpty ? Nothing() : Just(queue.unsafeTail);
+export function tail<A>(self: Queue<A>): Maybe<Queue<A>> {
+  return self.isEmpty ? Nothing() : Just(self.unsafeTail);
 }
 
 /**
- * @tsplus fluent fncts.ImmutableQueue prepend
+ * @tsplus pipeable fncts.ImmutableQueue prepend
  */
-export function prepend_<A, B>(queue: Queue<A>, elem: B): Queue<A | B> {
-  return new Queue(queue._in, queue._out.prepend(elem));
+export function prepend<B>(elem: B) {
+  return <A>(self: Queue<A>): Queue<A | B> => {
+    return new Queue(self._in, self._out.prepend(elem));
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableQueue enqueue
+ * @tsplus pipeable fncts.ImmutableQueue enqueue
  */
-export function enqueue_<A, B>(queue: Queue<A>, elem: B): Queue<A | B> {
-  return new Queue(queue._in.prepend(elem), queue._out);
+export function enqueue<B>(elem: B) {
+  return <A>(self: Queue<A>): Queue<A | B> => {
+    return new Queue(self._in.prepend(elem), self._out);
+  };
 }
 
 /**
  * @tsplus getter fncts.ImmutableQueue unsafeDequeue
  */
-export function unasfeDequeue<A>(queue: Queue<A>): readonly [A, Queue<A>] {
-  if (queue._out.isEmpty() && queue._in.isNonEmpty()) {
-    const rev = queue._in.reverse;
+export function unasfeDequeue<A>(self: Queue<A>): readonly [A, Queue<A>] {
+  if (self._out.isEmpty() && self._in.isNonEmpty()) {
+    const rev = self._in.reverse;
     return [rev.unsafeHead, new Queue(Nil(), rev.unsafeTail)];
-  } else if (queue._out.isNonEmpty()) {
-    return [queue._out.unsafeHead, new Queue(queue._in, queue._out.unsafeTail)];
+  } else if (self._out.isNonEmpty()) {
+    return [self._out.unsafeHead, new Queue(self._in, self._out.unsafeTail)];
   } else {
     throw new NoSuchElementError("unsafeDequeue on empty Queue");
   }
@@ -78,65 +82,77 @@ export function unasfeDequeue<A>(queue: Queue<A>): readonly [A, Queue<A>] {
 /**
  * @tsplus getter fncts.ImmutableQueue dequeue
  */
-export function dequeue<A>(queue: Queue<A>): Maybe<readonly [A, Queue<A>]> {
-  if (queue.isEmpty) {
+export function dequeue<A>(self: Queue<A>): Maybe<readonly [A, Queue<A>]> {
+  if (self.isEmpty) {
     return Nothing();
   }
-  return Just(queue.unsafeDequeue);
+  return Just(self.unsafeDequeue);
 }
 
 /**
- * @tsplus fluent fncts.ImmutableQueue map
+ * @tsplus pipeable fncts.ImmutableQueue map
  */
-export function map_<A, B>(fa: Queue<A>, f: (a: A) => B): Queue<B> {
-  return new Queue(fa._in.map(f), fa._out.map(f));
+export function map<A, B>(f: (a: A) => B) {
+  return (self: Queue<A>): Queue<B> => {
+    return new Queue(self._in.map(f), self._out.map(f));
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableQueue foldLeft
+ * @tsplus pipeable fncts.ImmutableQueue foldLeft
  */
-export function foldLeft_<A, B>(fa: Queue<A>, b: B, f: (b: B, a: A) => B): B {
-  let acc   = b;
-  let these = fa;
-  while (!these.isEmpty) {
-    acc   = f(acc, these.unsafeHead);
-    these = these.unsafeTail;
-  }
-  return acc;
+export function foldLeft<A, B>(b: B, f: (b: B, a: A) => B) {
+  return (self: Queue<A>): B => {
+    let acc   = b;
+    let these = self;
+    while (!these.isEmpty) {
+      acc   = f(acc, these.unsafeHead);
+      these = these.unsafeTail;
+    }
+    return acc;
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableQueue exists
+ * @tsplus pipeable fncts.ImmutableQueue some
  */
-export function exists_<A>(queue: Queue<A>, p: Predicate<A>): boolean {
-  return queue._in.exists(p) || queue._out.exists(p);
+export function some<A>(p: Predicate<A>) {
+  return (self: Queue<A>): boolean => {
+    return self._in.some(p) || self._out.some(p);
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableQueue find
+ * @tsplus pipeable fncts.ImmutableQueue find
  */
-export function find_<A>(queue: Queue<A>, p: Predicate<A>): Maybe<A> {
-  let these = queue;
-  while (!these.isEmpty) {
-    const head = these.unsafeHead;
-    if (p(head)) {
-      return Just(head);
+export function find<A>(p: Predicate<A>) {
+  return (self: Queue<A>): Maybe<A> => {
+    let these = self;
+    while (!these.isEmpty) {
+      const head = these.unsafeHead;
+      if (p(head)) {
+        return Just(head);
+      }
+      these = these.unsafeTail;
     }
-    these = these.unsafeTail;
-  }
-  return Nothing();
+    return Nothing();
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableQueue filter
+ * @tsplus pipeable fncts.ImmutableQueue filter
  */
-export function filter_<A>(queue: Queue<A>, p: Predicate<A>): Queue<A> {
-  return new Queue(queue._in.filter(p), queue._out.filter(p));
+export function filter<A>(p: Predicate<A>) {
+  return (self: Queue<A>): Queue<A> => {
+    return new Queue(self._in.filter(p), self._out.filter(p));
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableQueue count
+ * @tsplus pipeable fncts.ImmutableQueue count
  */
-export function count_<A>(queue: Queue<A>, p: Predicate<A>): number {
-  return queue.foldLeft(0, (b, a) => (p(a) ? b + 1 : b));
+export function count<A>(p: Predicate<A>) {
+  return (self: Queue<A>): number => {
+    return self.foldLeft(0, (b, a) => (p(a) ? b + 1 : b));
+  };
 }

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

@@ -25,7 +25,6 @@ export class Queue<A> implements Iterable<A> {
     /* @internal */
     public _out: List<A>,
   ) {}
-
   [Symbol.iterator]() {
     return this._in.concat(this._out.reverse)[Symbol.iterator]();
   }

package/_src/collection/immutable/Queue/guards.ts

@@ -3,6 +3,6 @@ import type { Queue } from "./definition.js";
 /**
  * @tsplus getter fncts.ImmutableQueue isEmpty
  */
-export function isEmpty<A>(queue: Queue<A>): boolean {
-  return queue._in.isEmpty() && queue._out.isEmpty();
+export function isEmpty<A>(self: Queue<A>): boolean {
+  return self._in.isEmpty() && self._out.isEmpty();
 }

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

@@ -1,4 +1,5 @@
 import { RoseTree } from "./definition.js";
+
 /**
  * @tsplus static fncts.RoseTreeOps __call
  */
@@ -7,17 +8,21 @@ export function make<A>(value: A, forest: Vector<RoseTree<A>> = Vector.empty()):
 }
 
 /**
- * @tsplus fluent fncts.RoseTree foldLeft
+ * @tsplus pipeable fncts.RoseTree foldLeft
  */
-export function foldLeft<A, B>(self: RoseTree<A>, b: B, f: (b: B, a: A) => B): B {
-  return foldLeftLoop(f, b, Vector(self), Vector());
+export function foldLeft<A, B>(b: B, f: (b: B, a: A) => B) {
+  return (self: RoseTree<A>): B => {
+    return foldLeftLoop(f, b, Vector(self), Vector());
+  };
 }
 
 /**
- * @tsplus fluent fncts.RoseTree foldRight
+ * @tsplus pipeable fncts.RoseTree foldRight
  */
-export function foldRight<A, B>(self: RoseTree<A>, b: B, f: (a: A, b: B) => B): B {
-  return self.foldLeft(Vector<A>(), (b, a) => b.prepend(a)).foldLeft(b, (b, a) => f(a, b));
+export function foldRight<A, B>(b: B, f: (a: A, b: B) => B) {
+  return (self: RoseTree<A>): B => {
+    return self.foldLeft(Vector<A>(), (b, a) => b.prepend(a)).foldLeft(b, (b, a) => f(a, b));
+  };
 }
 
 /**
@@ -46,29 +51,31 @@ function foldLeftLoop<A, B>(
 }
 
 /**
- * @tsplus fluent fncts.RoseTree map
+ * @tsplus pipeable fncts.RoseTree map
  */
-export function map<A, B>(self: RoseTree<A>, f: (a: A) => B): RoseTree<B> {
-  return self.mapAccum(undefined, (_, a) => [undefined, f(a)])[1];
+export function map<A, B>(f: (a: A) => B) {
+  return (self: RoseTree<A>): RoseTree<B> => {
+    return self.mapAccum(undefined, (_, a) => [undefined, f(a)])[1];
+  };
 }
 
 /**
- * @tsplus fluent fncts.RoseTree mapAccum
+ * @tsplus pipeable fncts.RoseTree mapAccum
  */
-export function mapAccum<A, S, B>(
-  self: RoseTree<A>,
-  s: S,
-  f: (s: S, a: A) => readonly [S, B],
-): readonly [S, RoseTree<B>] {
-  const [state, b] = f(s, self.value);
-  return mapAccumLoop(f, state, { todo: self.forest, done: Vector(), label: b }, List());
+export function mapAccum<A, S, B>(s: S, f: (s: S, a: A) => readonly [S, B]) {
+  return (self: RoseTree<A>): readonly [S, RoseTree<B>] => {
+    const [state, b] = f(s, self.value);
+    return mapAccumLoop(f, state, { todo: self.forest, done: Vector(), label: b }, List());
+  };
 }
 
 /**
- * @tsplus fluent fncts.RoseTree mapWithIndex
+ * @tsplus pipeable fncts.RoseTree mapWithIndex
  */
-export function mapWithIndex<A, B>(self: RoseTree<A>, f: (i: number, a: A) => B): RoseTree<B> {
-  return self.mapAccum(0, (idx, elem) => [idx + 1, f(idx, elem)])[1];
+export function mapWithIndex<A, B>(f: (i: number, a: A) => B) {
+  return (self: RoseTree<A>): RoseTree<B> => {
+    return self.mapAccum(0, (idx, elem) => [idx + 1, f(idx, elem)])[1];
+  };
 }
 
 interface MapAcc<A, B> {
@@ -156,23 +163,22 @@ function unfoldLoop<A, B>(
 }
 
 /**
- * @tsplus fluent fncts.RoseTree zipWith
+ * @tsplus pipeable fncts.RoseTree zipWith
  */
-export function zipWith<A, B, C>(self: RoseTree<A>, that: RoseTree<B>, f: (a: A, b: B) => C): RoseTree<C> {
-  return self.zipWithAccum(that, undefined, (s, a, b) => [s, f(a, b)])[1];
+export function zipWith<A, B, C>(that: RoseTree<B>, f: (a: A, b: B) => C) {
+  return (self: RoseTree<A>): RoseTree<C> => {
+    return self.zipWithAccum(that, undefined, (s, a, b) => [s, f(a, b)])[1];
+  };
 }
 
 /**
- * @tsplus fluent fncts.RoseTree zipWithAccum
+ * @tsplus pipeable fncts.RoseTree zipWithAccum
  */
-export function zipWithAccum<A, S, B, C>(
-  self: RoseTree<A>,
-  that: RoseTree<B>,
-  s: S,
-  f: (s: S, a: A, b: B) => readonly [S, C],
-): readonly [S, RoseTree<C>] {
-  const [state, c] = f(s, self.value, that.value);
-  return zipWithAccumLoop(f, state, { todoL: self.forest, todoR: that.forest, done: Vector(), label: c }, List());
+export function zipWithAccum<A, S, B, C>(that: RoseTree<B>, s: S, f: (s: S, a: A, b: B) => readonly [S, C]) {
+  return (self: RoseTree<A>): readonly [S, RoseTree<C>] => {
+    const [state, c] = f(s, self.value, that.value);
+    return zipWithAccumLoop(f, state, { todoL: self.forest, todoR: that.forest, done: Vector(), label: c }, List());
+  };
 }
 
 export interface ZipWithAcc<A, B, C> {

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

@@ -16,9 +16,11 @@ export class RoseTree<A> implements Hashable, Equatable {
   readonly _typeId: RoseTreeTypeId = RoseTreeTypeId;
   declare _A: () => A;
   constructor(readonly value: A, readonly forest: Vector<RoseTree<A>>) {}
+
   [Symbol.equals](that: unknown): boolean {
     return isRoseTree(that) ? Equatable.strictEquals(this.value, that.value) && this.forest == that.forest : false;
   }
+
   get [Symbol.hash]() {
     let h = Hashable.symbol(RoseTreeTypeId);
     h    ^= Hashable.unknown(this.value);