@fncts/base 0.0.26 → 0.0.28

package/_src/data/Either/definition.ts

@@ -1,3 +1,5 @@
+import type { EqualsContext } from "@fncts/base/data/Equatable";
+
 export const enum EitherTag {
   Left = "Left",
   Right = "Right",
@@ -17,38 +19,63 @@ export interface EitherF extends HKT {
   };
 }
 
+const IOTypeId = Symbol.for("fncts.io.IO");
+type IOTypeId = typeof IOTypeId;
+
 /**
  * @tsplus type fncts.Either
  * @tsplus companion fncts.EitherOps
  */
 export class Either<E, A> {
   readonly [EitherTypeId]: EitherTypeId = EitherTypeId;
+  readonly [IOTypeId]: IOTypeId         = IOTypeId;
+  readonly trace?: string | undefined   = undefined;
   declare [EitherVariance]: {
     readonly _E: (_: never) => E;
     readonly _A: (_: never) => A;
   };
 }
 
+const leftHash = Hashable.string(EitherTag.Left);
+
 /**
  * @tsplus type fncts.Either.Left
  * @tsplus companion fncts.Either.LeftOps
  */
 export class Left<E> extends Either<E, never> {
   readonly _tag = EitherTag.Left;
-  constructor(readonly left: E) {
+  constructor(readonly left: E, readonly trace?: string) {
     super();
   }
+
+  get [Symbol.hash](): number {
+    return Hashable.combine(leftHash, Hashable.unknown(this.left));
+  }
+
+  [Symbol.equals](that: unknown, context: EqualsContext): boolean {
+    return Either.isEither(that) && that.isLeft() && context.comparator(this.left, that.left);
+  }
 }
 
+const rightHash = Hashable.string(EitherTag.Right);
+
 /**
  * @tsplus type fncts.Either.Right
  * @tsplus companion fncts.Either.RightOps
  */
 export class Right<A> extends Either<never, A> {
   readonly _tag = EitherTag.Right;
-  constructor(readonly right: A) {
+  constructor(readonly right: A, readonly trace?: string) {
     super();
   }
+
+  get [Symbol.hash](): number {
+    return Hashable.combine(rightHash, Hashable.unknown(this.left));
+  }
+
+  [Symbol.equals](that: unknown, context: EqualsContext): boolean {
+    return Either.isEither(that) && that.isRight() && context.comparator(this.right, that.right);
+  }
 }
 
 /**

package/_src/data/Eq/api.ts

@@ -0,0 +1,8 @@
+/**
+ * @tsplus pipeable fncts.Eq contramap
+ */
+export function contramap<A, B>(f: (b: B) => A) {
+  return (self: Eq<A>): Eq<B> => {
+    return Eq({ equals: (b2) => (b1) => self.equals(f(b2))(f(b1)) });
+  };
+}

package/_src/data/Eq.ts

@@ -1,2 +1,3 @@
+export * from "./Eq/api.js";
 export * from "./Eq/definition.js";
 export {} from "./Eq/derivations.js";

package/_src/data/Equatable/api.ts

@@ -1,3 +1,5 @@
+import type { EqualsContext } from "@fncts/base/data/Equatable/definition";
+
 import { isEquatable } from "@fncts/base/data/Equatable/definition";
 import {
   createCircularEqualCreator,
@@ -5,30 +7,53 @@ import {
   sameValueZeroEqual,
 } from "@fncts/base/data/Equatable/fast-equals";
 
-/**
- * @tsplus static fncts.EquatableOps deepEquals
- */
-export const deepEquals = createComparator(
+const deepEqualsComparator = createComparator(
   createCircularEqualCreator((eq) => (a, b, meta) => {
+    const equalsContext: EqualsContext = { comparator: deepEquals };
     if (isEquatable(a)) {
-      return a[Symbol.equals](b);
+      return a[Symbol.equals](b, equalsContext);
     } else if (isEquatable(b)) {
-      return b[Symbol.equals](a);
+      return b[Symbol.equals](a, equalsContext);
     } else {
       return eq(a, b, meta);
     }
   }),
 );
 
+/**
+ * @tsplus static fncts.EquatableOps deepEquals
+ */
+export function deepEquals<A>(a: A, b: unknown): boolean {
+  const context: EqualsContext = { comparator: deepEquals };
+  if (isEquatable(a)) {
+    return a[Symbol.equals](b, context);
+  } else if (isEquatable(b)) {
+    return b[Symbol.equals](a, context);
+  } else {
+    return deepEqualsComparator(a, b);
+  }
+}
+
 /**
  * @tsplus static fncts.EquatableOps strictEquals
  * @tsplus operator fncts.Equatable ==
  */
 export function strictEquals<A>(a: A, b: unknown): boolean {
+  const context: EqualsContext = {
+    comparator: strictEquals,
+  };
   if (isEquatable(a)) {
-    return a[Symbol.equals](b);
+    return a[Symbol.equals](b, context);
   } else if (isEquatable(b)) {
-    return b[Symbol.equals](a);
+    return b[Symbol.equals](a, context);
   }
   return sameValueZeroEqual(a, b);
 }
+
+/**
+ * @tsplus static fncts.EquatableOps strictNotEquals
+ * @tsplus operator fncts.Equatable !=
+ */
+export function strictNotEquals<A>(a: A, b: unknown): boolean {
+  return !strictEquals(a, b);
+}

package/_src/data/Equatable/definition.ts

@@ -3,15 +3,19 @@
  */
 export const equalsSymbol: unique symbol = Symbol.for("fncts.Equatable");
 
+export interface EqualsContext {
+  comparator: (a: unknown, b: unknown) => boolean;
+}
+
 /**
  * @tsplus type fncts.Equatable
  */
 export interface Equatable {
-  [equalsSymbol](that: unknown): boolean;
+  [equalsSymbol](that: unknown, context: EqualsContext): boolean;
 }
 
 export function isEquatable(u: unknown): u is Equatable {
-  return isObject(u) && Symbol.equals in u;
+  return isObject(u) && typeof u[Symbol.equals] === "function";
 }
 
 /**

package/_src/data/Exit/api.ts

@@ -1,3 +1,5 @@
+import { IOError } from "@fncts/base/data/exceptions";
+
 import { identity, tuple } from "../function.js";
 import { ExitTag } from "./definition.js";
 
@@ -201,3 +203,27 @@ export function zipWithCause<E, A, G, B, C>(
     }
   };
 }
+
+/**
+ * Returns the Exit's Success value if it exists
+ *
+ * @tsplus getter fncts.Exit value
+ */
+export function value<E, A>(self: Exit<E, A>): A | undefined {
+  if (self.isFailure()) {
+    return undefined;
+  }
+  return self.value;
+}
+
+/**
+ * Returns the Exit's Success value if it exists, or throws the pretty-printed Cause if it doesn't
+ *
+ * @tsplus getter fncts.Exit valueOrThrow
+ */
+export function valueOrThrow<E, A>(self: Exit<E, A>): A {
+  if (self.isFailure()) {
+    throw new IOError(self.cause);
+  }
+  return self.value;
+}

package/_src/data/Exit/constructors.ts

@@ -3,14 +3,14 @@ import { Failure, Success } from "./definition.js";
 /**
  * @tsplus static fncts.ExitOps halt
  */
-export function halt(defect: unknown): Exit<never, never> {
+export function halt(defect: unknown, __tsplusTrace?: string): Exit<never, never> {
   return failCause(Cause.halt(defect));
 }
 
 /**
  * @tsplus static fncts.ExitOps fail
  */
-export function fail<E = never, A = never>(e: E): Exit<E, A> {
+export function fail<E = never, A = never>(e: E, __tsplusTrace?: string): Exit<E, A> {
   return failCause(Cause.fail(e));
 }
 
@@ -31,22 +31,22 @@ export function fromMaybe<E, A>(fa: Maybe<A>, onNothing: () => E): Exit<E, A> {
 /**
  * @tsplus static fncts.ExitOps failCause
  */
-export function failCause<E = never, A = never>(cause: Cause<E>): Exit<E, A> {
-  return new Failure(cause);
+export function failCause<E = never, A = never>(cause: Cause<E>, __tsplusTrace?: string): Exit<E, A> {
+  return new Failure(cause, __tsplusTrace);
 }
 
 /**
  * @tsplus static fncts.ExitOps interrupt
  */
-export function interrupt(id: FiberId): Exit<never, never> {
+export function interrupt(id: FiberId, __tsplusTrace?: string): Exit<never, never> {
   return failCause(Cause.interrupt(id));
 }
 
 /**
  * @tsplus static fncts.ExitOps succeed
  */
-export function succeed<E = never, A = never>(value: A): Exit<E, A> {
-  return new Success(value);
+export function succeed<E = never, A = never>(value: A, __tsplusTrace?: string): Exit<E, A> {
+  return new Success(value, __tsplusTrace);
 }
 
 /**

package/_src/data/Exit/definition.ts

@@ -23,6 +23,9 @@ export const enum ExitTag {
   Failure = "Failure",
 }
 
+const IOTypeId = Symbol.for("fncts.io.IO");
+type IOTypeId = typeof IOTypeId;
+
 const _failureHash = Hashable.string("fncts.Exit.Failure");
 const _successHash = Hashable.string("fncts.Exit.Success");
 
@@ -36,8 +39,9 @@ export class Failure<E> {
     readonly _E: (_: never) => E;
     readonly _A: (_: never) => never;
   };
-  readonly _tag = ExitTag.Failure;
-  constructor(readonly cause: Cause<E>) {}
+  readonly [IOTypeId]: IOTypeId = IOTypeId;
+  readonly _tag                 = ExitTag.Failure;
+  constructor(readonly cause: Cause<E>, readonly trace?: string) {}
 
   get [Symbol.hash](): number {
     return Hashable.combine(_failureHash, Hashable.unknown(this.cause));
@@ -57,8 +61,9 @@ export class Success<A> implements P.Hashable, P.Equatable {
     readonly _E: (_: never) => never;
     readonly _A: (_: never) => A;
   };
-  readonly _tag = ExitTag.Success;
-  constructor(readonly value: A) {}
+  readonly [IOTypeId]: IOTypeId = IOTypeId;
+  readonly _tag                 = ExitTag.Success;
+  constructor(readonly value: A, readonly trace?: string) {}
 
   get [Symbol.hash](): number {
     return Hashable.combine(_successHash, Hashable.unknown(this.value));

package/_src/data/FiberId/api.ts

@@ -5,20 +5,20 @@ import { Composite, isComposite, isNone } from "./definition.js";
  */
 export function combine(id1: FiberId) {
   return (id0: FiberId): FiberId => {
-    if (isNone(id0)) {
+    if (id0.isNone()) {
       return id1;
     }
-    if (isNone(id1)) {
+    if (id1.isNone()) {
       return id0;
     }
-    if (isComposite(id0)) {
-      if (isComposite(id1)) {
+    if (id0.isComposite()) {
+      if (id1.isComposite()) {
         return new Composite(id0.fiberIds.union(id1.fiberIds));
       } else {
         return new Composite(id0.fiberIds.add(id1));
       }
     }
-    if (isComposite(id1)) {
+    if (id1.isComposite()) {
       return new Composite(id1.fiberIds.add(id0));
     }
     return new Composite(HashSet.make(id0, id1));

package/_src/data/Maybe/constructors.ts

@@ -4,18 +4,16 @@ import type { Nullable } from "@fncts/base/types";
  * @tsplus static fncts.MaybeOps just
  * @tsplus static fncts.JustOps __call
  */
-export function just<A>(a: A): Maybe<A> {
-  return new Just(a);
+export function just<A>(a: A, __tsplusTrace?: string): Maybe<A> {
+  return new Just(a, __tsplusTrace);
 }
 
-const _Nothing = new Nothing();
-
 /**
  * @tsplus static fncts.MaybeOps nothing
  * @tsplus static fncts.NothingOps __call
  */
-export function nothing<A = never>(): Maybe<A> {
-  return _Nothing;
+export function nothing<A = never>(__tsplusTrace?: string): Maybe<A> {
+  return new Nothing(__tsplusTrace);
 }
 
 /**

package/_src/data/Maybe/definition.ts

@@ -11,6 +11,9 @@ export type MaybeVariance = typeof MaybeVariance;
 export const MaybeTypeId = Symbol.for("fncts.Maybe");
 export type MaybeTypeId = typeof MaybeTypeId;
 
+const IOTypeId = Symbol.for("fncts.io.IO");
+type IOTypeId = typeof IOTypeId;
+
 export interface MaybeF extends HKT {
   type: Maybe<this["A"]>;
   variance: {
@@ -30,6 +33,8 @@ export abstract class Maybe<A> {
     readonly _A: (_: never) => A;
   };
   readonly [MaybeTypeId]: MaybeTypeId = MaybeTypeId;
+  readonly [IOTypeId]: IOTypeId       = IOTypeId;
+  readonly trace?: string | undefined = undefined;
 }
 
 /**
@@ -38,7 +43,7 @@ export abstract class Maybe<A> {
  */
 export class Just<A> extends Maybe<A> {
   readonly _tag = MaybeTag.Just;
-  constructor(readonly value: A) {
+  constructor(readonly value: A, readonly trace?: string) {
     super();
   }
   [Symbol.equals](that: unknown): boolean {
@@ -55,6 +60,9 @@ export class Just<A> extends Maybe<A> {
  */
 export class Nothing extends Maybe<never> {
   readonly _tag = MaybeTag.Nothing;
+  constructor(readonly trace?: string) {
+    super();
+  }
   [Symbol.equals](that: unknown): boolean {
     return isMaybe(that) && that.isNothing();
   }

package/_src/data/Maybe/instances.ts

@@ -6,25 +6,43 @@ import { MaybeJson } from "@fncts/base/json/MaybeJson";
 import { filter, filterMap, flatMap, foldLeft, foldRight, map, partition, partitionMap, zip, zipWith } from "./api.js";
 import { just } from "./constructors.js";
 
+/**
+ * @tsplus static fncts.MaybeOps Functor
+ */
 export const Functor = HKT.instance<P.Functor<MaybeF>>({ map });
 
+/**
+ * @tsplus static fncts.MaybeOps Apply
+ */
 export const Apply = HKT.instance<P.Apply<MaybeF>>({ ...Functor, zip, zipWith });
 
+/**
+ * @tsplus static fncts.MaybeOps Applicative
+ */
 export const Applicative = HKT.instance<P.Applicative<MaybeF>>({
   ...Apply,
   pure: just,
 });
 
+/**
+ * @tsplus static fncts.MaybeOps Monad
+ */
 export const Monad = HKT.instance<P.Monad<MaybeF>>({
   ...Applicative,
   flatMap,
 });
 
+/**
+ * @tsplus static fncts.MaybeOps Foldable
+ */
 export const Foldable = HKT.instance<P.Foldable<MaybeF>>({
   foldLeft,
   foldRight,
 });
 
+/**
+ * @tsplus static fncts.MaybeOps Filterable
+ */
 export const Filterable = HKT.instance<P.Filterable<MaybeF>>({
   ...Functor,
   filter,

package/_src/data/Showable/show.ts

@@ -490,12 +490,12 @@ function reduceToSingleString(
   value?: any,
 ): string {
   let output = input;
-  if (context.compact >= 1) {
+  if (Number(context.compact) >= 1) {
     const entries = output.length;
     if (extrasType === ARRAY_EXTRAS_TYPE && entries > 6) {
       output = groupElements(context, output, value);
     }
-    if (context.currentDepth - context.recurseTimes < context.compact && entries === output.length) {
+    if (context.currentDepth - context.recurseTimes < Number(context.compact) && entries === output.length) {
       const start = output.length + context.indentationLevel + braces[0].length + base.length + 10;
       if (isBelowBreakLength(context, output, start, base)) {
         return `${base ? `${base} ` : ""}${braces[0]} ${output.join(", ")} ${braces[1]}`;

package/_src/data/exceptions/IOError.ts

@@ -0,0 +1,11 @@
+export const IOErrorTypeId = Symbol.for("fncts.base.exceptions.IOError");
+export type IOErrorTypeId = typeof IOErrorTypeId;
+
+export class IOError<E> {
+  readonly [IOErrorTypeId]: IOErrorTypeId = IOErrorTypeId;
+  constructor(readonly cause: Cause<E>) {}
+}
+
+export function isIOError(u: unknown): u is IOError<unknown> {
+  return isObject(u) && IOErrorTypeId in u;
+}

package/_src/data/exceptions/NoSuchElementError.ts

@@ -2,7 +2,7 @@ export const NoSuchElementErrorTag = "NoSuchElementError";
 
 export class NoSuchElementError extends Error {
   readonly _tag = NoSuchElementErrorTag;
-  constructor(message: string) {
+  constructor(message?: string) {
     super(message);
     this.name = NoSuchElementErrorTag;
   }

package/_src/data/exceptions.ts

@@ -5,6 +5,7 @@ export * from "./exceptions/IllegalStateError.js";
 export * from "./exceptions/IndexOutOfBoundsError.js";
 export * from "./exceptions/InterruptedException.js";
 export * from "./exceptions/InvalidCapacityError.js";
+export * from "./exceptions/IOError.js";
 export * from "./exceptions/NoSuchElementError.js";
 export * from "./exceptions/RuntimeError.js";
 // codegen:end

package/_src/data.ts

@@ -38,6 +38,7 @@ export type {} from "./data/Predicate.js";
 export type {} from "./data/Refinement.js";
 export type {} from "./data/Showable.js";
 export type {} from "./data/string.js";
+export type {} from "./data/Struct.js";
 export type {} from "./data/Tag.js";
 export type {} from "./data/These.js";
 export type {} from "./data/Trace.js";

package/_src/typeclass.ts

@@ -32,7 +32,7 @@ export * from "./typeclass/WitherableWithIndex.js";
 
 export { Eq } from "./data/Eq.js";
 export { Equatable } from "./data/Equatable.js";
-export { Guard } from "./data/Guard.js";
+export { Guard } from "./data/Guard/definition.js";
 export { Hash } from "./data/Hash.js";
 export { Hashable } from "./data/Hashable.js";
 export { HashEq } from "./data/HashEq.js";

package/_src/types.ts

@@ -1,5 +1,4 @@
 // codegen:start { preset: barrel, include: types/*.ts }
 export * from "./types/extractions.js";
-export * from "./types/test.js";
 export * from "./types/utility.js";
 // codegen:end

package/_src/util/predicates.ts

@@ -41,6 +41,10 @@ export function isObject<A>(value: A | Primitive): boolean {
   return typeof value === "object" && value !== null;
 }
 
+export function isRecord(value: unknown): value is object & Record<PropertyKey, unknown> {
+  return isObject(value) && !Array.isArray(value);
+}
+
 export function hasTypeId<X extends symbol>(
   value: unknown,
   typeId: X,

package/collection/immutable/Conc/api.d.ts

@@ -268,6 +268,11 @@ export declare function reverse<A>(self: Conc<A>): Iterable<A>;
  * @tsplus location "@fncts/base/collection/immutable/Conc/api"
  */
 export declare function separate<E, A>(self: Conc<Either<E, A>>): readonly [Conc<E>, Conc<A>];
+/**
+ * @tsplus pipeable fncts.Conc slice
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function slice(from: number, to: number): <A>(self: import("@fncts/base/collection/immutable/Conc/definition").Conc<A>) => import("@fncts/base/collection/immutable/Conc/definition").Conc<A>;
 /**
  * @tsplus pipeable fncts.Conc splitAt
  * @tsplus location "@fncts/base/collection/immutable/Conc/api"

package/collection/immutable/HashMap/api.d.ts

@@ -26,6 +26,11 @@ export declare function makeWith<K, V>(config: P.HashEq<K>): HashMap<K, V>;
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
 export declare function make<K, V>(...items: ReadonlyArray<readonly [K, V]>): HashMap<K, V>;
+/**
+ * @tsplus static fncts.HashMapOps from
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function from<K, V>(items: Iterable<readonly [K, V]>): HashMap<K, V>;
 /**
  * Make a new map that has randomly cached hash and structural equality
  * @tsplus static fncts.HashMapOps empty

package/collection/immutable/HashMap/internal.d.ts

@@ -48,7 +48,7 @@ export declare class CollisionNode<K, V> {
     constructor(edit: number, hash: number, children: Array<Node<K, V>>);
     modify(edit: number, keyEq: KeyEq<K>, shift: number, f: UpdateFn<V>, hash: number, key: K, size: SizeRef): Node<K, V>;
 }
-declare class IndexedNode<K, V> {
+export declare class IndexedNode<K, V> {
     edit: number;
     mask: number;
     children: Array<Node<K, V>>;
@@ -64,4 +64,3 @@ export declare class ArrayNode<K, V> {
     constructor(edit: number, size: number, children: Array<Node<K, V>>);
     modify(edit: number, keyEq: KeyEq<K>, shift: number, f: UpdateFn<V>, hash: number, key: K, size: SizeRef): Node<K, V>;
 }
-export {};

package/collection/immutable/List/definition.d.ts

@@ -1,3 +1,5 @@
+export declare const ListTypeId: unique symbol;
+export type ListTypeId = typeof ListTypeId;
 /**
  * @tsplus type fncts.List.Cons
  * @tsplus companion fncts.ConsOps
@@ -6,6 +8,7 @@ export declare class Cons<A> implements Iterable<A> {
     readonly head: A;
     tail: List<A>;
     readonly _tag = "Cons";
+    readonly [ListTypeId]: ListTypeId;
     constructor(head: A, tail?: List<A>);
     [Symbol.iterator](): Iterator<A>;
 }
@@ -15,8 +18,14 @@ export declare class Cons<A> implements Iterable<A> {
  */
 export declare class Nil<A> implements Iterable<A> {
     readonly _tag = "Nil";
+    readonly [ListTypeId]: ListTypeId;
     [Symbol.iterator](): Iterator<A>;
 }
+/**
+ * @tsplus static fncts.ListOps is
+ * @tsplus location "@fncts/base/collection/immutable/List/definition"
+ */
+export declare function isList(u: unknown): u is List<unknown>;
 export declare const _Nil: Nil<never>;
 /**
  * @tsplus type fncts.List

package/collection/immutable/Vector/api.d.ts

@@ -1,7 +1,7 @@
 import { Vector } from "@fncts/base/collection/immutable/Vector";
-import { Predicate } from "@fncts/base/data/Predicate/definition";
-import { Refinement } from "@fncts/base/data/Refinement/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { RefinementWithIndex, Refinement } from "@fncts/base/data/Refinement/definition";
+import { PredicateWithIndex, Predicate } from "@fncts/base/data/Predicate/definition";
 import { List } from "@fncts/base/collection/immutable/List/definition";
 import { HKT } from "@fncts/typelevel/HKT";
 import type { MutableVector, VectorF } from "@fncts/base/collection/immutable/Vector/definition";
@@ -15,6 +15,28 @@ import type * as P from "@fncts/base/typeclass";
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
 export declare function append<A>(a: A): (self: Vector<A>) => Vector<A>;
+/**
+ * @tsplus pipeable fncts.Vector filterMapWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function filterMapWithIndex<A, B>(f: (i: number, a: A) => Maybe<B>): (self: Vector<A>) => Vector<B>;
+/**
+ * @tsplus pipeable fncts.Vector filterMap
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function filterMap<A, B>(f: (a: A) => Maybe<B>): (self: Vector<A>) => Vector<B>;
+/**
+ * @tsplus pipeable fncts.Vector filterWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function filterWithIndex<A, B extends A>(refinement: RefinementWithIndex<number, A, B>): (self: Vector<A>) => Vector<B>;
+export declare function filterWithIndex<A>(predicate: PredicateWithIndex<number, A>): (self: Vector<A>) => Vector<A>;
+/**
+ * @tsplus pipeable fncts.Vector filter
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function filter<A, B extends A>(refinement: Refinement<A, B>): (self: Vector<A>) => Vector<B>;
+export declare function filter<A>(predicate: Predicate<A>): (self: Vector<A>) => Vector<A>;
 /**
  * Maps a function over a Vector and concatenates all the resulting
  * Vectors together.
@@ -261,6 +283,11 @@ export declare function groupWith<A>(f: (a: A, b: A) => boolean): (self: Vector<
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
 export declare function head<A>(self: Vector<A>): Maybe<NonNullable<A>>;
+/**
+ * @tsplus pipeable fncts.Vector includes
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function includes<A>(element: A): (self: Vector<A>) => boolean;
 /**
  * Returns the index of the _first_ element in the Vector that is equal
  * to the given element. If no such element is found `-1` is returned.
@@ -620,4 +647,4 @@ export declare function updateAt<A>(i: number, a: A): (self: Vector<A>) => Vecto
  * @tsplus static fncts.VectorOps __call
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function vector<A>(...elements: ReadonlyArray<A>): Vector<A>;
+export declare function vector<A extends ReadonlyArray<any>>(...elements: A): Vector<[A] extends [ReadonlyArray<infer X>] ? X : never>;

package/collection/immutable/Vector/definition.d.ts

@@ -51,6 +51,7 @@ export declare class Vector<A> implements Iterable<A> {
     [Symbol.equals](that: unknown): boolean;
 }
 /**
+ * @tsplus type fncts.Vector
  * @tsplus type fncts.MutableVector
  */
 export interface MutableVector<A> {

package/control/CompletablePromise.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @tsplus type fncts.CompletablePromise
+ * @tsplus companion fncts.CompletablePromiseOps
+ */
+export interface CompletablePromise<A> extends Promise<A> {
+    resolve: (a: A) => void;
+    reject: (reason: unknown) => void;
+}
+/**
+ * @tsplus static fncts.CompletablePromiseOps __call
+ * @tsplus location "@fncts/base/control/CompletablePromise"
+ */
+export declare function make<A>(): CompletablePromise<A>;

package/control.d.ts

@@ -1,3 +1,4 @@
+export type {} from "./control/CompletablePromise.js";
 export type {} from "./control/Eval.js";
 export type {} from "./control/LazyValue.js";
 export type {} from "./control/Z.js";