@fncts/base 0.0.39 → 0.0.41

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

@@ -1,34 +0,0 @@
-import { HKT } from "@fncts/typelevel/HKT";
-import { Equatable } from "@fncts/base/data/Equatable";
-import { Hashable } from "@fncts/base/data/Hashable";
-export declare const ImmutableArrayVariance: unique symbol;
-export type ImmutableArrayVariance = typeof ImmutableArrayVariance;
-export declare const ImmutableArrayTypeId: unique symbol;
-export type ImmutableArrayTypeId = typeof ImmutableArrayTypeId;
-export interface ImmutableArrayF extends HKT {
-    type: ImmutableArray<this["A"]>;
-    variance: {
-        A: "+";
-    };
-    index: number;
-}
-/**
- * @tsplus type fncts.ImmutableArray
- * @tsplus companion fncts.ImmutableArrayOps
- */
-export declare class ImmutableArray<A> implements Equatable, Hashable, Iterable<A> {
-    readonly _array: ReadonlyArray<A>;
-    readonly [ImmutableArrayTypeId]: ImmutableArrayTypeId;
-    [ImmutableArrayVariance]: {
-        readonly _A: (_: never) => A;
-    };
-    constructor(_array: ReadonlyArray<A>);
-    [Symbol.equals](that: unknown): boolean;
-    get [Symbol.hash](): number;
-    [Symbol.iterator](): ArrayIterator<A>;
-}
-/**
- * @tsplus static fncts.ImmutableArrayOps is
- * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/definition"
- */
-export declare function isImmutableArray(u: unknown): u is ImmutableArray<unknown>;

package/collection/immutable/ImmutableArray/instances.d.ts

@@ -1,87 +0,0 @@
-import type { ImmutableArrayF } from "@fncts/base/collection/immutable/ImmutableArray/definition";
-import type * as P from "@fncts/base/typeclass";
-/**
- * @tsplus implicit
- * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
- */
-export declare const Align: P.Align<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
-/**
- * @tsplus implicit
- * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
- */
-export declare const Functor: P.Functor<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
-/**
- * @tsplus implicit
- * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
- */
-export declare const FunctorWithIndex: P.FunctorWithIndex<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
-/**
- * @tsplus implicit
- * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
- */
-export declare const Apply: P.Apply<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
-/**
- * @tsplus implicit
- * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
- */
-export declare const Applicative: P.Applicative<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
-/**
- * @tsplus implicit
- * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
- */
-export declare const Alt: P.Alt<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
-/**
- * @tsplus implicit
- * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
- */
-export declare const Alternative: P.Alternative<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
-/**
- * @tsplus implicit
- * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
- */
-export declare const Filterable: P.Filterable<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
-/**
- * @tsplus implicit
- * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
- */
-export declare const FilterableWithIndex: P.FilterableWithIndex<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
-/**
- * @tsplus implicit
- * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
- */
-export declare const Foldable: P.Foldable<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
-/**
- * @tsplus implicit
- * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
- */
-export declare const FoldableWithIndex: P.FoldableWithIndex<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
-/**
- * @tsplus implicit
- * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
- */
-export declare const FlatMap: P.FlatMap<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
-/**
- * @tsplus implicit
- * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
- */
-export declare const Monad: P.Monad<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
-/**
- * @tsplus implicit
- * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
- */
-export declare const Traversable: P.Traversable<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
-/**
- * @tsplus implicit
- * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
- */
-export declare const TraversableWithIndex: P.TraversableWithIndex<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
-/**
- * @tsplus implicit
- * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
- */
-export declare const Witherable: P.Witherable<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
-/**
- * @tsplus implicit
- * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
- */
-export declare const WitherableWithIndex: P.WitherableWithIndex<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;

package/collection/immutable/ImmutableArray.d.ts

@@ -1,8 +0,0 @@
-export * from "./ImmutableArray/api.js";
-export * from "./ImmutableArray/constructors.js";
-export * from "./ImmutableArray/definition.js";
-export * from "./ImmutableArray/instances.js";
-export * from "./ImmutableArray/api/chunksOf.js";
-export * from "./ImmutableArray/api/slice.js";
-export * from "./ImmutableArray/api/splitAt.js";
-export * from "./ImmutableArray/api/splitWhere.js";

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

@@ -1,186 +0,0 @@
-import { These } from "@fncts/base/data/These";
-import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
-import { Zipped } from "@fncts/base/data/Zipped";
-import { HKT } from "@fncts/typelevel/HKT";
-import type { ImmutableNonEmptyArrayF } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
-import { ImmutableNonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
-import * as P from "@fncts/base/typeclass";
-/**
- * @tsplus pipeable fncts.ImmutableNonEmptyArray ap
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
- */
-export declare function ap_<A>(fa: ImmutableNonEmptyArray<A>): <B>(self: ImmutableNonEmptyArray<(a: A) => B>) => ImmutableNonEmptyArray<B>;
-/**
- * @tsplus pipeable fncts.ImmutableNonEmptyArray append
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
- */
-export declare function append<B>(last: B): <A>(self: ImmutableNonEmptyArray<A>) => ImmutableNonEmptyArray<A | B>;
-/**
- * @tsplus pipeable fncts.ImmutableNonEmptyArray align
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
- */
-export declare function align<B>(fb: ImmutableNonEmptyArray<B>): <A>(self: ImmutableNonEmptyArray<A>) => ImmutableNonEmptyArray<These<A, B>>;
-/**
- * @tsplus pipeable fncts.ImmutableNonEmptyArray alignWith
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
- */
-export declare function alignWith<A, B, C>(fb: ImmutableNonEmptyArray<B>, f: (_: These<A, B>) => C): (self: ImmutableNonEmptyArray<A>) => ImmutableNonEmptyArray<C>;
-/**
- * @tsplus pipeable fncts.ImmutableNonEmptyArray flatMap
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
- */
-export declare function flatMap<A, B>(f: (a: A) => ImmutableNonEmptyArray<B>): (self: ImmutableNonEmptyArray<A>) => ImmutableNonEmptyArray<B>;
-/**
- * @tsplus pipeable fncts.ImmutableNonEmptyArray flatMapWithIndex
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
- */
-export declare function flatMapWithIndex<A, B>(f: (i: number, a: A) => ImmutableNonEmptyArray<B>): (self: ImmutableNonEmptyArray<A>) => ImmutableNonEmptyArray<B>;
-/**
- * @tsplus pipeable fncts.ImmutableNonEmptyArray chop
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
- */
-export declare function chop<A, B>(f: (as: ImmutableNonEmptyArray<A>) => readonly [B, ImmutableArray<A>]): (self: ImmutableNonEmptyArray<A>) => ImmutableNonEmptyArray<B>;
-/**
- * @tsplus pipeable fncts.ImmutableNonEmptyArray chunksOf
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
- */
-export declare function chunksOf(n: number): <A>(self: ImmutableNonEmptyArray<A>) => ImmutableNonEmptyArray<ImmutableNonEmptyArray<A>>;
-/**
- * @tsplus pipeable fncts.ImmutableNonEmptyArray concat
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
- */
-export declare function concat<B>(that: ImmutableArray<B>): <A>(self: ImmutableNonEmptyArray<A>) => ImmutableNonEmptyArray<A | B>;
-/**
- * @tsplus pipeable fncts.ImmutableNonEmptyArray crossWith
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
- */
-export declare function crossWith<A, B, C>(fb: ImmutableNonEmptyArray<B>, f: (a: A, b: B) => C): (self: ImmutableNonEmptyArray<A>) => ImmutableNonEmptyArray<C>;
-/**
- * @tsplus pipeable fncts.ImmutableNonEmptyArray cross
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
- */
-export declare function cross<B>(fb: ImmutableNonEmptyArray<B>): <A>(self: ImmutableNonEmptyArray<A>) => ImmutableNonEmptyArray<Zipped.Make<A, B>>;
-/**
- * @tsplus pipeable fncts.ImmutableNonEmptyArray elem
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
- */
-export declare function elem<A>(a: A, /** @tsplus auto */ E: P.Eq<A>): (self: ImmutableNonEmptyArray<A>) => boolean;
-/**
- * @tsplus getter fncts.ImmutableNonEmptyArray flatten
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
- */
-export declare function flatten<A>(self: ImmutableNonEmptyArray<ImmutableNonEmptyArray<A>>): ImmutableNonEmptyArray<A>;
-/**
- * @tsplus pipeable fncts.ImmutableNonEmptyArray fold
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
- */
-export declare function fold<A>(/** @tsplus auto */ S: P.Semigroup<A>): (self: ImmutableNonEmptyArray<A>) => A;
-/**
- * @tsplus pipeable fncts.ImmutableNonEmptyArray foldLeft
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
- */
-export declare function foldLeft<A, B>(b: B, f: (b: B, a: A) => B): (self: ImmutableNonEmptyArray<A>) => B;
-/**
- * @tsplus pipeable fncts.ImmutableNonEmptyArray foldLeftWithIndex
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
- */
-export declare function foldLeftWithIndex<A, B>(b: B, f: (i: number, b: B, a: A) => B): (self: ImmutableNonEmptyArray<A>) => B;
-/**
- * @tsplus pipeable fncts.ImmutableNonEmptyArray foldMapWithIndex
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
- */
-export declare function foldMapWithIndex<A, M>(f: (i: number, a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): (self: ImmutableNonEmptyArray<A>) => M;
-/**
- * @tsplus pipeable fncts.ImmutableNonEmptyArray foldMap
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
- */
-export declare function foldMap<A, M>(f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): (self: ImmutableNonEmptyArray<A>) => M;
-/**
- * @tsplus pipeable fncts.ImmutableNonEmptyArray foldRight
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
- */
-export declare function foldRight<A, B>(b: B, f: (a: A, b: B) => B): (self: ImmutableNonEmptyArray<A>) => B;
-/**
- * @tsplus pipeable fncts.ImmutableNonEmptyArray foldRightWithIndex
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
- */
-export declare function foldRightWithIndex<A, B>(b: B, f: (i: number, a: A, b: B) => B): (self: ImmutableNonEmptyArray<A>) => B;
-/**
- * @tsplus pipeable fncts.ImmutableNonEmptyArray group
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
- */
-export declare function group<A>(/** @tsplus auto */ E: P.Eq<A>): (self: ImmutableNonEmptyArray<A>) => ImmutableNonEmptyArray<ImmutableNonEmptyArray<A>>;
-export declare function groupSort<A>(as: ImmutableNonEmptyArray<A>, 
-/** @tsplus auto */ O: P.Ord<A>): ImmutableNonEmptyArray<ImmutableNonEmptyArray<A>>;
-/**
- * @tsplus pipeable fncts.ImmutableNonEmptyArray isOutOfBound
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
- */
-export declare function isOutOfBound(i: number): <A>(as: ImmutableNonEmptyArray<A>) => boolean;
-/**
- * @tsplus pipeable fncts.ImmutableNonEmptyArray map
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
- */
-export declare function map<A, B>(f: (a: A) => B): (self: ImmutableNonEmptyArray<A>) => ImmutableNonEmptyArray<B>;
-/**
- * @tsplus pipeable fncts.ImmutableNonEmptyArray mapWithIndex
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
- */
-export declare function mapWithIndex<A, B>(f: (i: number, a: A) => B): (self: ImmutableNonEmptyArray<A>) => ImmutableNonEmptyArray<B>;
-/**
- * @tsplus pipeable fncts.ImmutableNonEmptyArray max
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
- */
-export declare function max<A>(/** @tsplus auto */ O: P.Ord<A>): (self: ImmutableNonEmptyArray<A>) => A;
-/**
- * @tsplus pipeable fncts.ImmutableNonEmptyArray max
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
- */
-export declare function min<A>(/** @tsplus auto */ O: P.Ord<A>): (self: ImmutableNonEmptyArray<A>) => A;
-/**
- * @tsplus getter fncts.ImmutableNonEmptyArray mutableClone
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
- */
-export declare function mutableClone<A>(as: ImmutableNonEmptyArray<A>): ImmutableNonEmptyArray<A>;
-/**
- * @tsplus pipeable fncts.ImmutableNonEmptyArray prepend
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
- */
-export declare function prepend<B>(head: B): <A>(self: ImmutableNonEmptyArray<A>) => ImmutableNonEmptyArray<A | B>;
-/**
- * @tsplus getter fncts.ImmutableNonEmptyArray reverse
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
- */
-export declare function reverse<A>(self: ImmutableNonEmptyArray<A>): ImmutableNonEmptyArray<A>;
-/**
- * @tsplus pipeable fncts.ImmutableNonEmptyArray splitAt
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
- */
-export declare function splitAt(n: number): <A>(self: ImmutableNonEmptyArray<A>) => readonly [ImmutableNonEmptyArray<A>, ImmutableArray<A>];
-/**
- * @tsplus pipeable fncts.ImmutableNonEmptyArray sort
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
- */
-export declare function sort<A>(/** @tsplus auto */ O: P.Ord<A>): (self: ImmutableNonEmptyArray<A>) => ImmutableNonEmptyArray<A>;
-/**
- * @tsplus getter fncts.ImmutableNonEmptyArray traverseWithIndex
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
- */
-export declare function _traverseWithIndex<A>(self: ImmutableNonEmptyArray<A>): <G extends HKT, GC = HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B>(f: (i: number, a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, B>) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, ImmutableNonEmptyArray<B>>;
-/**
- * @tsplus getter fncts.ImmutableNonEmptyArray traverse
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
- */
-export declare function _traverse<A>(self: ImmutableNonEmptyArray<A>): <G extends HKT, GC = HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B>(f: (a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, B>) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, ImmutableNonEmptyArray<B>>;
-export declare const traverseWithIndex: P.TraversableWithIndex<ImmutableNonEmptyArrayF>["traverseWithIndex"];
-export declare const traverse: P.Traversable<ImmutableNonEmptyArrayF>["traverse"];
-/**
- * @tsplus pipeable fncts.ImmutableNonEmptyArray uniq
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
- */
-export declare function uniq<A>(/** @tsplus auto */ E: P.Eq<A>): (self: ImmutableNonEmptyArray<A>) => ImmutableNonEmptyArray<A>;
-/**
- * @tsplus pipeable fncts.ImmutableNonEmptyArray zipWith
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
- */
-export declare function zipWith<A, B, C>(fb: ImmutableNonEmptyArray<B>, f: (a: A, b: B) => C): (self: ImmutableNonEmptyArray<A>) => ImmutableNonEmptyArray<C>;

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

@@ -1,46 +0,0 @@
-import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
-import { Maybe } from "@fncts/base/data/Maybe/definition";
-import { NonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
-import { ImmutableNonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
-export declare function allocWithHead<A>(head: A, length: number): Array<A> & {
-    0: A;
-};
-/**
- * @tsplus getter fncts.ReadonlyArray unsafeAsNonEmptyArray
- * @tsplus getter fncts.Array unsafeAsNonEmptyArray
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/constructors"
- */
-export declare function unsafeAsNonEmptyArray<A>(self: ReadonlyArray<A>): ImmutableNonEmptyArray<A>;
-/**
- * @tsplus static fncts.ImmutableNonEmptyArrayOps from
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/constructors"
- */
-export declare function from<A>(self: ReadonlyArray<A> & {
-    readonly 0: A;
-}): ImmutableNonEmptyArray<A>;
-/**
- * @tsplus static fncts.ImmutableNonEmptyArrayOps fromArray
- * @tsplus getter fncts.ImmutableArray toNonEmptyArray
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/constructors"
- */
-export declare function fromArray<A>(self: ImmutableArray<A>): Maybe<ImmutableNonEmptyArray<A>>;
-/**
- * @tsplus static fncts.ImmutableNonEmptyArrayOps __call
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/constructors"
- */
-export declare function make<A>(...values: NonEmptyArray<A>): ImmutableNonEmptyArray<A>;
-/**
- * @tsplus static fncts.ImmutableNonEmptyArrayOps makeBy
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/constructors"
- */
-export declare function makeBy<A>(n: number, f: (i: number) => A): ImmutableNonEmptyArray<A>;
-/**
- * @tsplus static fncts.ImmutableNonEmptyArray replicate
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/constructors"
- */
-export declare function replicate<A>(n: number, a: A): ImmutableNonEmptyArray<A>;
-/**
- * @tsplus static fncts.ImmutableNonEmptyArrayOps range
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/constructors"
- */
-export declare function range(start: number, end: number): ImmutableNonEmptyArray<number>;

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

@@ -1,40 +0,0 @@
-import { HKT } from "@fncts/typelevel/HKT";
-import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
-export interface ImmutableNonEmptyArrayF extends HKT {
-    type: ImmutableNonEmptyArray<this["A"]>;
-    variance: {
-        A: "+";
-    };
-    index: number;
-}
-/**
- * @tsplus type fncts.ImmutableNonEmptyArray
- * @tsplus companion fncts.ImmutableNonEmptyArrayOps
- */
-export declare class ImmutableNonEmptyArray<A> extends ImmutableArray<A> {
-    readonly _array: ReadonlyNonEmptyArray<A>;
-    readonly _A: () => A;
-    constructor(_array: ReadonlyNonEmptyArray<A>);
-}
-/**
- * @tsplus type fncts.NonEmptyArray
- */
-export interface NonEmptyArray<T> extends Array<T> {
-    0: T;
-}
-/**
- * @tsplus type fncts.ReadonlyNonEmptyArray
- */
-export interface ReadonlyNonEmptyArray<T> extends ReadonlyArray<T> {
-    readonly 0: T;
-}
-/**
- * @tsplus getter fncts.ImmutableArray length
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition"
- */
-export declare function length<A>(self: ImmutableArray<A>): number;
-/**
- * @tsplus fluent fncts.ImmutableArray isNonEmpty
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition"
- */
-export declare function isNonEmpty<A>(self: ImmutableArray<A>): self is ImmutableNonEmptyArray<A>;

package/collection/immutable/ImmutableNonEmptyArray/destructors.d.ts

@@ -1,32 +0,0 @@
-import { ImmutableNonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
-import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
-/**
- * @tsplus getter fncts.ImmutableNonEmptyArray head
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/destructors"
- */
-export declare function head<A>(self: ImmutableNonEmptyArray<A>): A;
-/**
- * @tsplus getter fncts.ImmutableNonEmptyArray init
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/destructors"
- */
-export declare function init<A>(self: ImmutableNonEmptyArray<A>): ImmutableArray<A>;
-/**
- * @tsplus getter fncts.ImmutableNonEmptyArray last
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/destructors"
- */
-export declare function last<A>(self: ImmutableNonEmptyArray<A>): A;
-/**
- * @tsplus getter fncts.ImmutableNonEmptyArray tail
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/destructors"
- */
-export declare function tail<A>(self: ImmutableNonEmptyArray<A>): ImmutableArray<A>;
-/**
- * @tsplus getter fncts.ImmutableNonEmptyArray unappend
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/destructors"
- */
-export declare function unappend<A>(self: ImmutableNonEmptyArray<A>): readonly [ImmutableArray<A>, A];
-/**
- * @tsplus getter fncts.ImmutableNonEmptyArray unprepend
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/destructors"
- */
-export declare function unprepend<A>(self: ImmutableNonEmptyArray<A>): readonly [A, ImmutableArray<A>];

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

@@ -1,52 +0,0 @@
-import type { ImmutableNonEmptyArrayF } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
-import type * as P from "@fncts/base/typeclass";
-/**
- * @tsplus static fncts.ImmutableNonEmptyArrayOps Semialign
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/instances"
- */
-export declare const Semialign: P.Semialign<ImmutableNonEmptyArrayF, import("@fncts/typelevel/HKT").HKT.None>;
-/**
- * @tsplus static fncts.ImmutableNonEmptyArrayOps Functor
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/instances"
- */
-export declare const Functor: P.Functor<ImmutableNonEmptyArrayF, import("@fncts/typelevel/HKT").HKT.None>;
-/**
- * @tsplus static fncts.ImmutableNonEmptyArrayOps FunctorWithIndex
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/instances"
- */
-export declare const FunctorWithIndex: P.FunctorWithIndex<ImmutableNonEmptyArrayF, import("@fncts/typelevel/HKT").HKT.None>;
-/**
- * @tsplus static fncts.ImmutableNonEmptyArrayOps Apply
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/instances"
- */
-export declare const Apply: P.Apply<ImmutableNonEmptyArrayF, import("@fncts/typelevel/HKT").HKT.None>;
-/**
- * @tsplus static fncts.ImmutableNonEmptyArrayOps Applicative
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/instances"
- */
-export declare const Applicative: P.Applicative<ImmutableNonEmptyArrayF, import("@fncts/typelevel/HKT").HKT.None>;
-/**
- * @tsplus static fncts.ImmutableNonEmptyArrayOps Monad
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/instances"
- */
-export declare const Monad: P.Monad<ImmutableNonEmptyArrayF, import("@fncts/typelevel/HKT").HKT.None>;
-/**
- * @tsplus static fncts.ImmutableNonEmptyArrayOps Foldable
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/instances"
- */
-export declare const Foldable: P.Foldable<ImmutableNonEmptyArrayF, import("@fncts/typelevel/HKT").HKT.None>;
-/**
- * @tsplus static fncts.ImmutableNonEmptyArrayOps FoldableWithIndex
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/instances"
- */
-export declare const FoldableWithIndex: P.FoldableWithIndex<ImmutableNonEmptyArrayF, import("@fncts/typelevel/HKT").HKT.None>;
-/**
- * @tsplus static fncts.ImmutableNonEmptyArrayOps Traversable
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/instances"
- */
-export declare const Traversable: P.Traversable<ImmutableNonEmptyArrayF, import("@fncts/typelevel/HKT").HKT.None>;
-/**
- * @tsplus static fncts.ImmutableNonEmptyArrayOps TraversableWithIndex
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/instances"
- */
-export declare const TraversableWithIndex: P.TraversableWithIndex<ImmutableNonEmptyArrayF, import("@fncts/typelevel/HKT").HKT.None>;

package/collection/immutable/ImmutableNonEmptyArray.d.ts

@@ -1,5 +0,0 @@
-export * from "./ImmutableNonEmptyArray/api.js";
-export * from "./ImmutableNonEmptyArray/constructors.js";
-export * from "./ImmutableNonEmptyArray/definition.js";
-export * from "./ImmutableNonEmptyArray/destructors.js";
-export * from "./ImmutableNonEmptyArray/instances.js";

package/control/Eval/api/sequenceArray.d.ts

@@ -1,6 +0,0 @@
-import { Eval } from "@fncts/base/control/Eval/definition";
-/**
- * @tsplus static fncts.control.EvalOps sequenceArray
- * @tsplus location "@fncts/base/control/Eval/api/sequenceArray"
- */
-export declare function sequenceArray<A>(evals: ReadonlyArray<Eval<A>>): Eval<ReadonlyArray<A>>;