@fncts/base 0.0.25 → 0.0.27

package/_src/data/Decoder/api.ts

@@ -58,7 +58,7 @@ export const bigint: Decoder<bigint> = fromGuard(BigInt.Guard, (u) => new Primit
  * @tsplus static fncts.DecoderOps object
  * @tsplus implicit
  */
-export const object: Decoder<{}> = fromGuard(Object.Guard, (u) => new PrimitiveError(u, "{}"), "{}");
+export const object: Decoder<object> = fromGuard(Object.Guard, (u) => new PrimitiveError(u, "{}"), "{}");
 
 /**
  * @tsplus static fncts.DecoderOps unknown
@@ -449,7 +449,7 @@ export function deriveRecord<A extends Record<string, any>>(
     : never
 ): Decoder<A> {
   return Decoder((u) => {
-    const recordResult = Derive<Decoder<{}>>().decode(u);
+    const recordResult = Derive<Decoder<object>>().decode(u);
     if (recordResult.isLeft()) {
       return recordResult;
     }

package/_src/data/Either/api.ts

@@ -284,6 +284,16 @@ export function partition<E, A>(p: Predicate<A>, /** @tsplus auto */ M: P.Monoid
   };
 }
 
+/**
+ * @tsplus getter fncts.Either toMaybe
+ */
+export function toMaybe<E, A>(self: Either<E, A>): Maybe<A> {
+  return self.match(
+    () => Nothing(),
+    (a) => Just(a),
+  );
+}
+
 // codegen:start { preset: barrel, include: api/*.ts }
 export * from "./api/align.js";
 export * from "./api/alignWith.js";

package/_src/data/Either/definition.ts

@@ -29,6 +29,8 @@ export class Either<E, A> {
   };
 }
 
+const leftHash = Hashable.string(EitherTag.Left);
+
 /**
  * @tsplus type fncts.Either.Left
  * @tsplus companion fncts.Either.LeftOps
@@ -38,8 +40,18 @@ export class Left<E> extends Either<E, never> {
   constructor(readonly left: E) {
     super();
   }
+
+  get [Symbol.hash](): number {
+    return Hashable.combine(leftHash, Hashable.unknown(this.left));
+  }
+
+  [Symbol.equals](that: unknown): boolean {
+    return Either.isEither(that) && that.isLeft() && Equatable.strictEquals(this.left, that.left);
+  }
 }
 
+const rightHash = Hashable.string(EitherTag.Right);
+
 /**
  * @tsplus type fncts.Either.Right
  * @tsplus companion fncts.Either.RightOps
@@ -49,6 +61,14 @@ export class Right<A> extends Either<never, A> {
   constructor(readonly right: A) {
     super();
   }
+
+  get [Symbol.hash](): number {
+    return Hashable.combine(rightHash, Hashable.unknown(this.left));
+  }
+
+  [Symbol.equals](that: unknown): boolean {
+    return Either.isEither(that) && that.isRight() && Equatable.strictEquals(this.right, that.right);
+  }
 }
 
 /**

package/_src/data/Equatable/api.ts

@@ -32,3 +32,11 @@ export function strictEquals<A>(a: A, b: unknown): boolean {
   }
   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/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/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.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/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/definition.d.ts

@@ -4,6 +4,7 @@ import { Equatable } from "@fncts/base/data/Equatable";
 import { isByte } from "@fncts/base/util/predicates";
 import { IndexOutOfBoundsError, ArrayIndexOutOfBoundsError } from "@fncts/base/data/exceptions";
 import { unsafeCoerce } from "@fncts/base/data/function/api";
+export declare const MAX_CONC_DEPTH = 256;
 export declare const BUFFER_SIZE = 64;
 export declare const UPDATE_BUFFER_SIZE = 256;
 export declare const ConcTypeId: unique symbol;
@@ -124,6 +125,7 @@ declare class PrependN<A> extends ConcImplementation<A> {
     readonly binary: boolean;
     readonly _tag = ConcTag.PrependN;
     length: number;
+    depth: number;
     left: Empty<never>;
     right: Empty<never>;
     constructor(end: ConcImplementation<A>, buffer: Array<unknown> | Uint8Array, bufferUsed: number, binary: boolean);

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/collection/mutable/HashMap.d.ts

@@ -21,6 +21,7 @@ export declare class HashMap<K, V> implements Iterable<readonly [K, V]> {
     get(key: K): Maybe<V>;
     set(key: K, value: V): Maybe<V>;
     delete(key: K): Maybe<V>;
+    clear(): void;
     updateWith(key: K, f: (v: Maybe<V>) => Maybe<V>): Maybe<V>;
     forEach<U>(f: (k: K, v: V) => U): void;
     private _set;

package/data/Branded/definition.d.ts

@@ -29,11 +29,12 @@ export declare namespace Brand {
  */
 export declare class Validation<in out A, in out K extends string> {
     readonly validate: Refinement<A, A & Brand.Valid<A, K>>;
-    constructor(validate: Refinement<A, A & Brand.Valid<A, K>>);
+    readonly name: K;
+    constructor(validate: Refinement<A, A & Brand.Valid<A, K>>, name: K);
 }
 /**
  * @tsplus static fncts.ValidationOps __call
  * @tsplus location "@fncts/base/data/Branded/definition"
  */
-export declare function makeValidation<A, K extends string>(p: Predicate<A>): Validation<A, K>;
+export declare function makeValidation<A, K extends string>(p: Predicate<A>, name: K): Validation<A, K>;
 export {};

package/data/Cause/api.d.ts

@@ -12,7 +12,7 @@ import { Both, Cause, Fail, Halt, Interrupt, Then } from "./definition.js";
  * @tsplus pipeable fncts.Cause as
  * @tsplus location "@fncts/base/data/Cause/api"
  */
-export declare function as_<B>(b: Lazy<B>): <A>(self: Cause<A>) => Cause<B>;
+export declare function as<B>(b: Lazy<B>): <A>(self: Cause<A>) => Cause<B>;
 /**
  * Constructs a `Cause` from two `Cause`s, representing parallel failures.
  * @note If one of the `Cause`s is `Empty`, the non-empty `Cause` is returned

package/data/Decoder/api.d.ts

@@ -40,7 +40,7 @@ export declare const bigint: Decoder<bigint>;
  * @tsplus implicit
  * @tsplus location "@fncts/base/data/Decoder/api"
  */
-export declare const object: Decoder<{}>;
+export declare const object: Decoder<object>;
 /**
  * @tsplus static fncts.DecoderOps unknown
  * @tsplus location "@fncts/base/data/Decoder/api"

package/data/Either/api.d.ts

@@ -146,5 +146,10 @@ export declare function partitionMap<E, A, B, C>(f: (a: A) => Either<B, C>, /**
  * @tsplus location "@fncts/base/data/Either/api"
  */
 export declare function partition<E, A>(p: Predicate<A>, /** @tsplus auto */ M: P.Monoid<E>): (self: Either<E, A>) => readonly [Either<E, A>, Either<E, A>];
+/**
+ * @tsplus getter fncts.Either toMaybe
+ * @tsplus location "@fncts/base/data/Either/api"
+ */
+export declare function toMaybe<E, A>(self: Either<E, A>): Maybe<A>;
 export * from "./api/align.js";
 export * from "./api/alignWith.js";

package/data/Either/definition.d.ts

@@ -1,4 +1,6 @@
 import { HKT } from "@fncts/typelevel/HKT";
+import { Hashable } from "@fncts/base/data/Hashable";
+import { Equatable } from "@fncts/base/data/Equatable";
 export declare const enum EitherTag {
     Left = "Left",
     Right = "Right"
@@ -33,6 +35,8 @@ export declare class Left<E> extends Either<E, never> {
     readonly left: E;
     readonly _tag = EitherTag.Left;
     constructor(left: E);
+    get [Symbol.hash](): number;
+    [Symbol.equals](that: unknown): boolean;
 }
 /**
  * @tsplus type fncts.Either.Right
@@ -42,6 +46,8 @@ export declare class Right<A> extends Either<never, A> {
     readonly right: A;
     readonly _tag = EitherTag.Right;
     constructor(right: A);
+    get [Symbol.hash](): number;
+    [Symbol.equals](that: unknown): boolean;
 }
 /**
  * @tsplus unify fncts.Either

package/data/Equatable/api.d.ts

@@ -9,3 +9,9 @@ export declare const deepEquals: (a: any, b: any, meta?: any) => boolean;
  * @tsplus location "@fncts/base/data/Equatable/api"
  */
 export declare function strictEquals<A>(a: A, b: unknown): boolean;
+/**
+ * @tsplus static fncts.EquatableOps strictNotEquals
+ * @tsplus operator fncts.Equatable !=
+ * @tsplus location "@fncts/base/data/Equatable/api"
+ */
+export declare function strictNotEquals<A>(a: A, b: unknown): boolean;

package/data/Maybe/instances.d.ts

@@ -4,11 +4,35 @@ import { Decoder } from "@fncts/base/data/Decoder/definition";
 import { Encoder } from "@fncts/base/data/Encoder/definition";
 import type * as P from "../../typeclass.js";
 import type { MaybeF } from "@fncts/base/data/Maybe/definition";
+/**
+ * @tsplus static fncts.MaybeOps Functor
+ * @tsplus location "@fncts/base/data/Maybe/instances"
+ */
 export declare const Functor: P.Functor<MaybeF, import("@fncts/typelevel/HKT.js").HKT.None>;
+/**
+ * @tsplus static fncts.MaybeOps Apply
+ * @tsplus location "@fncts/base/data/Maybe/instances"
+ */
 export declare const Apply: P.Apply<MaybeF, import("@fncts/typelevel/HKT.js").HKT.None>;
+/**
+ * @tsplus static fncts.MaybeOps Applicative
+ * @tsplus location "@fncts/base/data/Maybe/instances"
+ */
 export declare const Applicative: P.Applicative<MaybeF, import("@fncts/typelevel/HKT.js").HKT.None>;
+/**
+ * @tsplus static fncts.MaybeOps Monad
+ * @tsplus location "@fncts/base/data/Maybe/instances"
+ */
 export declare const Monad: P.Monad<MaybeF, import("@fncts/typelevel/HKT.js").HKT.None>;
+/**
+ * @tsplus static fncts.MaybeOps Foldable
+ * @tsplus location "@fncts/base/data/Maybe/instances"
+ */
 export declare const Foldable: P.Foldable<MaybeF, import("@fncts/typelevel/HKT.js").HKT.None>;
+/**
+ * @tsplus static fncts.MaybeOps Filterable
+ * @tsplus location "@fncts/base/data/Maybe/instances"
+ */
 export declare const Filterable: P.Filterable<MaybeF, import("@fncts/typelevel/HKT.js").HKT.None>;
 /**
  * @tsplus derive fncts.Guard[fncts.Maybe]<_> 10

package/data.d.ts

@@ -37,6 +37,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fncts/base",
-  "version": "0.0.25",
+  "version": "0.0.27",
   "dependencies": {
     "@fncts/typelevel": "0.0.15",
     "uuid": "^9.0.0"

package/typeclass.d.ts

@@ -29,7 +29,7 @@ export * from "./typeclass/Witherable.js";
 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/util/predicates.d.ts

@@ -11,6 +11,7 @@ export declare function isArray<A>(value: unknown): value is Array<A>;
 export declare function isObject<A extends Function>(value: A): false;
 export declare function isObject(value: unknown): value is object & Record<PropertyKey, any>;
 export declare function isObject<A>(value: A | Primitive): value is A & Record<PropertyKey, unknown>;
+export declare function isRecord(value: unknown): value is object & Record<PropertyKey, unknown>;
 export declare function hasTypeId<X extends symbol>(value: unknown, typeId: X): value is {
     readonly [K in X]: X;
 } & Record<PropertyKey, unknown>;