@fncts/base 0.0.21 → 0.0.23

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

@@ -54,9 +54,9 @@ export function concat<B>(that: List<B>) {
 }
 
 /**
- * @tsplus pipeable fncts.List exists
+ * @tsplus pipeable fncts.List some
  */
-export function exists<A>(p: Predicate<A>) {
+export function some<A>(p: Predicate<A>) {
   return (self: List<A>): boolean => {
     let these = self;
     while (!these.isEmpty()) {
@@ -72,6 +72,8 @@ export function exists<A>(p: Predicate<A>) {
 /**
  * @tsplus pipeable fncts.List filter
  */
+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);
@@ -254,6 +256,7 @@ export function prependAll<B>(prefix: List<B>) {
     }
   };
 }
+
 /**
  * @tsplus getter fncts.List reverse
  */
@@ -266,18 +269,20 @@ export function reverse<A>(self: List<A>): List<A> {
   }
   return result;
 }
+
 /**
  * @tsplus pipeable fncts.List sort
  */
 export function sort<A>(/** @tsplus auto */ O: P.Ord<A>) {
   return (self: List<A>): List<A> => {
-    return self.sortWith(O.compare);
+    return self.sortWith((x, y) => O.compare(y)(x));
   };
 }
+
 /**
  * @tsplus pipeable fncts.List sortWith
  */
-export function sortWith_<A>(compare: (x: A, y: A) => P.Ordering) {
+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>();
@@ -297,16 +302,18 @@ export function sortWith_<A>(compare: (x: A, y: A) => P.Ordering) {
     return b.toList;
   };
 }
+
 /**
  * @tsplus getter fncts.List tail
  */
 export function tail<A>(self: List<A>): Maybe<List<A>> {
   return self.isEmpty() ? Nothing() : Just(self.tail);
 }
+
 /**
  * @tsplus pipeable fncts.List take
  */
-export function take_(n: number) {
+export function take(n: number) {
   return <A>(self: List<A>): List<A> => {
     if (self.isEmpty() || n <= 0) {
       return _Nil;
@@ -329,30 +336,33 @@ export function take_(n: number) {
     }
   };
 }
+
 /**
  * @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;
   }
   return these.head;
 }
+
 function copyToArrayWithIndex<A>(list: List<A>, arr: Array<[number, A]>): void {
   let these = list;
   let i     = 0;

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/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,16 +43,16 @@ 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 pipeable fncts.ImmutableQueue prepend
  */
 export function prepend<B>(elem: B) {
-  return <A>(queue: Queue<A>): Queue<A | B> => {
-    return new Queue(queue._in, queue._out.prepend(elem));
+  return <A>(self: Queue<A>): Queue<A | B> => {
+    return new Queue(self._in, self._out.prepend(elem));
   };
 }
 
@@ -60,20 +60,20 @@ export function prepend<B>(elem: B) {
  * @tsplus pipeable fncts.ImmutableQueue enqueue
  */
 export function enqueue<B>(elem: B) {
-  return <A>(queue: Queue<A>): Queue<A | B> => {
-    return new Queue(queue._in.prepend(elem), queue._out);
+  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");
   }
@@ -82,19 +82,19 @@ 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 pipeable fncts.ImmutableQueue map
  */
 export function map<A, B>(f: (a: A) => B) {
-  return (fa: Queue<A>): Queue<B> => {
-    return new Queue(fa._in.map(f), fa._out.map(f));
+  return (self: Queue<A>): Queue<B> => {
+    return new Queue(self._in.map(f), self._out.map(f));
   };
 }
 
@@ -102,9 +102,9 @@ export function map<A, B>(f: (a: A) => B) {
  * @tsplus pipeable fncts.ImmutableQueue foldLeft
  */
 export function foldLeft<A, B>(b: B, f: (b: B, a: A) => B) {
-  return (fa: Queue<A>): B => {
+  return (self: Queue<A>): B => {
     let acc   = b;
-    let these = fa;
+    let these = self;
     while (!these.isEmpty) {
       acc   = f(acc, these.unsafeHead);
       these = these.unsafeTail;
@@ -114,11 +114,11 @@ export function foldLeft<A, B>(b: B, f: (b: B, a: A) => B) {
 }
 
 /**
- * @tsplus pipeable fncts.ImmutableQueue exists
+ * @tsplus pipeable fncts.ImmutableQueue some
  */
-export function exists<A>(p: Predicate<A>) {
-  return (queue: Queue<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);
   };
 }
 
@@ -126,8 +126,8 @@ export function exists<A>(p: Predicate<A>) {
  * @tsplus pipeable fncts.ImmutableQueue find
  */
 export function find<A>(p: Predicate<A>) {
-  return (queue: Queue<A>): Maybe<A> => {
-    let these = queue;
+  return (self: Queue<A>): Maybe<A> => {
+    let these = self;
     while (!these.isEmpty) {
       const head = these.unsafeHead;
       if (p(head)) {
@@ -143,8 +143,8 @@ export function find<A>(p: Predicate<A>) {
  * @tsplus pipeable fncts.ImmutableQueue filter
  */
 export function filter<A>(p: Predicate<A>) {
-  return (queue: Queue<A>): Queue<A> => {
-    return new Queue(queue._in.filter(p), queue._out.filter(p));
+  return (self: Queue<A>): Queue<A> => {
+    return new Queue(self._in.filter(p), self._out.filter(p));
   };
 }
 
@@ -152,7 +152,7 @@ export function filter<A>(p: Predicate<A>) {
  * @tsplus pipeable fncts.ImmutableQueue count
  */
 export function count<A>(p: Predicate<A>) {
-  return (queue: Queue<A>): number => {
-    return queue.foldLeft(0, (b, a) => (p(a) ? b + 1 : b));
+  return (self: Queue<A>): number => {
+    return self.foldLeft(0, (b, a) => (p(a) ? b + 1 : b));
   };
 }

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/definition.ts

@@ -1,3 +1,6 @@
+export const RoseTreeVariance = Symbol.for("fncts.RoseTree.Variance");
+export type RoseTreeVariance = typeof RoseTreeVariance;
+
 export const RoseTreeTypeId = Symbol.for("fncts.RoseTree");
 export type RoseTreeTypeId = typeof RoseTreeTypeId;
 
@@ -13,8 +16,10 @@ export interface RoseTreeF extends HKT {
  * @tsplus companion fncts.RoseTreeOps
  */
 export class RoseTree<A> implements Hashable, Equatable {
-  readonly _typeId: RoseTreeTypeId = RoseTreeTypeId;
-  declare _A: () => A;
+  readonly [RoseTreeTypeId]: RoseTreeTypeId = RoseTreeTypeId;
+  declare [RoseTreeVariance]: {
+    readonly _A: (_: never) => A;
+  };
   constructor(readonly value: A, readonly forest: Vector<RoseTree<A>>) {}
 
   [Symbol.equals](that: unknown): boolean {
@@ -30,5 +35,5 @@ export class RoseTree<A> implements Hashable, Equatable {
 }
 
 export function isRoseTree(u: unknown): u is RoseTree<unknown> {
-  return hasTypeId(u, RoseTreeTypeId);
+  return isObject(u) && RoseTreeTypeId in u;
 }