@fncts/base 0.0.40 → 0.0.41

package/collection/{compat/Array → immutable/ReadonlyArray}/definition.d.ts

@@ -1,3 +1,4 @@
+import { HKT } from "@fncts/typelevel/HKT";
 declare global {
     /**
      * @tsplus type fncts.ReadonlyArray
@@ -15,6 +16,13 @@ declare global {
     export interface ArrayConstructor {
     }
 }
+export interface ReadonlyArrayF extends HKT {
+    type: ReadonlyArray<this["A"]>;
+    variance: {
+        A: "+";
+    };
+    index: number;
+}
 export type ESArray<A> = globalThis.Array<A>;
 export type ESReadonlyArray<A> = globalThis.ReadonlyArray<A>;
 export declare const ESArray: ArrayConstructor;

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

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

package/collection/immutable/ReadonlyArray.d.ts

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

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

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

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

@@ -0,0 +1,45 @@
+import { ReadonlyNonEmptyArray, NonEmptyArray } from "@fncts/base/collection/immutable/ReadonlyNonEmptyArray/definition";
+import { Maybe } from "@fncts/base/data/Maybe/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 identity
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyNonEmptyArray/constructors"
+ */
+export declare function unsafeAsNonEmptyArray<A>(self: ReadonlyArray<A>): ReadonlyNonEmptyArray<A>;
+/**
+ * @tsplus static fncts.ReadonlyNonEmptyArrayOps from
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyNonEmptyArray/constructors"
+ */
+export declare function from<A>(self: ReadonlyArray<A> & {
+    readonly 0: A;
+}): ReadonlyNonEmptyArray<A>;
+/**
+ * @tsplus static fncts.ReadonlyNonEmptyArrayOps fromArray
+ * @tsplus getter fncts.ImmutableArray toNonEmptyArray
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyNonEmptyArray/constructors"
+ */
+export declare function fromArray<A>(self: ReadonlyArray<A>): Maybe<ReadonlyNonEmptyArray<A>>;
+/**
+ * @tsplus static fncts.ReadonlyNonEmptyArrayOps __call
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyNonEmptyArray/constructors"
+ */
+export declare function make<A>(...values: NonEmptyArray<A>): ReadonlyNonEmptyArray<A>;
+/**
+ * @tsplus static fncts.ReadonlyNonEmptyArrayOps makeBy
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyNonEmptyArray/constructors"
+ */
+export declare function makeBy<A>(n: number, f: (i: number) => A): ReadonlyNonEmptyArray<A>;
+/**
+ * @tsplus static fncts.ReadonlyNonEmptyArray replicate
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyNonEmptyArray/constructors"
+ */
+export declare function replicate<A>(n: number, a: A): ReadonlyNonEmptyArray<A>;
+/**
+ * @tsplus static fncts.ReadonlyNonEmptyArrayOps range
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyNonEmptyArray/constructors"
+ */
+export declare function range(start: number, end: number): ReadonlyNonEmptyArray<number>;

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

@@ -0,0 +1,21 @@
+import { HKT } from "@fncts/typelevel/HKT";
+export interface ReadonlyNonEmptyArrayF extends HKT {
+    type: ReadonlyNonEmptyArray<this["A"]>;
+    variance: {
+        A: "+";
+    };
+    index: number;
+}
+/**
+ * @tsplus type fncts.NonEmptyArray
+ */
+export interface NonEmptyArray<T> extends Array<T> {
+    0: T;
+}
+/**
+ * @tsplus type fncts.ReadonlyNonEmptyArray
+ * @tsplus companion fncts.ReadonlyNonEmptyArrayOps
+ */
+export interface ReadonlyNonEmptyArray<T> extends ReadonlyArray<T> {
+    readonly 0: T;
+}

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

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

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

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

package/collection/immutable/ReadonlyNonEmptyArray.d.ts

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