@fncts/base 0.0.39 → 0.0.41

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

@@ -0,0 +1,614 @@
+import { These } from "@fncts/base/data/These";
+import { Lazy } from "@fncts/base/data/function/definition";
+import { Either } from "@fncts/base/data/Either/definition";
+import { ReadonlyNonEmptyArray, NonEmptyArray } from "@fncts/base/collection/immutable/ReadonlyNonEmptyArray/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Eval } from "@fncts/base/control/Eval/definition";
+import { Zipped } from "@fncts/base/data/Zipped";
+import { Predicate, PredicateWithIndex } from "@fncts/base/data/Predicate/definition";
+import { Refinement, RefinementWithIndex } from "@fncts/base/data/Refinement/definition";
+import { HKT } from "@fncts/typelevel/HKT";
+import type { ReadonlyArrayF } from "@fncts/base/collection/immutable/ReadonlyArray/definition";
+import type { Monoid } from "@fncts/base/typeclass";
+import * as P from "@fncts/base/typeclass";
+/**
+ * @tsplus pipeable fncts.ReadonlyArray align
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function align<B>(fb: ReadonlyArray<B>): <A>(self: ReadonlyArray<A>) => ReadonlyArray<These<A, B>>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray alignWith
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function alignWith<A, B, C>(fb: ReadonlyArray<B>, f: (_: These<A, B>) => C): (self: ReadonlyArray<A>) => ReadonlyArray<C>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray alt
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function alt<B>(that: Lazy<ReadonlyArray<B>>): <A>(self: ReadonlyArray<A>) => ReadonlyArray<A | B>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray ap
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function ap<A>(fa: ReadonlyArray<A>): <B>(self: ReadonlyArray<(a: A) => B>) => ReadonlyArray<B>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray append
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function append<B>(last: B): <A>(self: ReadonlyArray<A>) => ReadonlyArray<A | B>;
+/**
+ * @tsplus static fncts.ReadonlyArrayOps chainRecBreadthFirst
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function chainRecBreadthFirst<A, B>(a: A, f: (a: A) => ReadonlyArray<Either<A, B>>): ReadonlyArray<B>;
+/**
+ * @tsplus static fncts.ReadonlyArrayOps chainRecDepthFirst
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function chainRecDepthFirst<A, B>(a: A, f: (a: A) => ReadonlyArray<Either<A, B>>): ReadonlyArray<B>;
+/**
+ * A useful recursion pattern for processing a `Array` to produce a new `Array`,
+ * often used for "chopping" up the input `Array`. Typically chop is called with some function
+ * that will consume an initial prefix of the `Array` and produce a value and the rest of the `Array`.
+ * @tsplus pipeable fncts.ReadonlyArray chop
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function chop<A, B>(f: (as: ReadonlyNonEmptyArray<A>) => readonly [B, ReadonlyArray<A>]): (as: ReadonlyArray<A>) => ReadonlyArray<B>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray collectWhile
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function collectWhile<A, B>(f: (a: A) => Maybe<B>): (as: ReadonlyArray<A>) => ReadonlyArray<B>;
+/**
+ * @tsplus static fncts.ReadonlyArrayOps comprehension
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function comprehension<A, B, C, D, R>(input: [ReadonlyArray<A>, ReadonlyArray<B>, ReadonlyArray<C>, ReadonlyArray<D>], f: (a: A, b: B, c: C, d: D) => R, g?: (a: A, b: B, c: C, d: D) => boolean): ReadonlyArray<R>;
+export declare function comprehension<A, B, C, R>(input: [ReadonlyArray<A>, ReadonlyArray<B>, ReadonlyArray<C>], f: (a: A, b: B, c: C) => R, g?: (a: A, b: B, c: C) => boolean): ReadonlyArray<R>;
+export declare function comprehension<A, B, R>(input: [ReadonlyArray<A>, ReadonlyArray<B>], f: (a: A, b: B) => R, g?: (a: A, b: B) => boolean): ReadonlyArray<R>;
+export declare function comprehension<A, R>(input: [ReadonlyArray<A>], f: (a: A) => R, g?: (a: A) => boolean): ReadonlyArray<R>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray concat
+ * @tsplus pipeable-operator fncts.ReadonlyArray +
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function concat<B>(that: ReadonlyArray<B>): <A>(self: ReadonlyArray<A>) => ReadonlyArray<A | B>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray cross
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function cross<B>(fb: ReadonlyArray<B>): <A>(self: ReadonlyArray<A>) => ReadonlyArray<Zipped.Make<A, B>>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray crossWith
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function crossWith<A, B, C>(fb: ReadonlyArray<B>, f: (a: A, b: B) => C): (self: ReadonlyArray<A>) => ReadonlyArray<C>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray deleteAt
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function deleteAt(i: number): <A>(as: ReadonlyArray<A>) => Maybe<ReadonlyArray<A>>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray difference
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function difference<A>(ys: ReadonlyArray<A>, /** @tsplus auto */ E: P.Eq<A>): (self: ReadonlyArray<A>) => ReadonlyArray<A>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray drop
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function drop(n: number): <A>(self: ReadonlyArray<A>) => ReadonlyArray<A>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray dropLast
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function dropLast(n: number): <A>(self: ReadonlyArray<A>) => ReadonlyArray<A>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray dropLastWhile
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function dropLastWhile<A>(p: Predicate<A>): (as: ReadonlyArray<A>) => ReadonlyArray<A>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray dropWhile
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function dropWhile<A>(p: Predicate<A>): (self: ReadonlyArray<A>) => ReadonlyArray<A>;
+/**
+ * Test if a value is a member of an array. Takes an `Eq<A>` as a single
+ * argument which returns the function to use to search for a value of type `A` in
+ * an array of type `ReadonlyArray<A>`.
+ * @tsplus pipeable fncts.ReadonlyArray elem
+ * @tsplus pipeable fncts.Array elem
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function elem<A>(a: A, /** @tsplus auto */ E: P.Eq<A>): (as: ReadonlyArray<A>) => boolean;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray every
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function every<A, B extends A>(p: Refinement<A, B>): (self: ReadonlyArray<A>) => self is ReadonlyArray<B>;
+export declare function every<A>(p: Predicate<A>): (self: ReadonlyArray<A>) => boolean;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray everyWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function everyWithIndex<A, B extends A>(p: RefinementWithIndex<number, A, B>): (self: ReadonlyArray<A>) => self is ReadonlyArray<B>;
+export declare function everyWithIndex<A>(p: PredicateWithIndex<number, A>): (self: ReadonlyArray<A>) => boolean;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray filter
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function filter<A, B extends A>(p: Refinement<A, B>): (self: ReadonlyArray<A>) => ReadonlyArray<B>;
+export declare function filter<A>(p: Predicate<A>): (self: ReadonlyArray<A>) => ReadonlyArray<A>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray filterMap
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function filterMap<A, B>(f: (a: A) => Maybe<B>): (self: ReadonlyArray<A>) => ReadonlyArray<B>;
+/**
+ * @tsplus pipeable fncts.Array filterMap
+ * @tsplus pipeable fncts.ReadonlyArray filterMap
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function filterMapUndefined<A, B>(f: (a: A) => B | undefined): (self: ReadonlyArray<A>) => ReadonlyArray<B>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray filterMapWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function filterMapWithIndex<A, B>(f: (i: number, a: A) => Maybe<B>): (fa: ReadonlyArray<A>) => ReadonlyArray<B>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray filterWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function filterWithIndex<A, B extends A>(p: RefinementWithIndex<number, A, B>): (self: ReadonlyArray<A>) => ReadonlyArray<B>;
+export declare function filterWithIndex<A>(p: PredicateWithIndex<number, A>): (self: ReadonlyArray<A>) => ReadonlyArray<A>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray find
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function find<A, B extends A>(p: Refinement<A, B>): (self: ReadonlyArray<A>) => Maybe<B>;
+export declare function find<A>(p: Predicate<A>): (self: ReadonlyArray<A>) => Maybe<A>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray findIndex
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function findIndex<A>(predicate: Predicate<A>): (as: ReadonlyArray<A>) => Maybe<number>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray findLast
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function findLast<A, B extends A>(p: Refinement<A, B>): (as: ReadonlyArray<A>) => Maybe<B>;
+export declare function findLast<A>(p: Predicate<A>): (as: ReadonlyArray<A>) => Maybe<A>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray findLastIndex
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function findLastIndex<A>(p: Predicate<A>): (self: ReadonlyArray<A>) => Maybe<number>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray findLastMap
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function findLastMap<A, B>(f: (a: A) => Maybe<B>): (as: ReadonlyArray<A>) => Maybe<B>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray findLastMapWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function findLastMapWithIndex<A, B>(f: (i: number, a: A) => Maybe<B>): (as: ReadonlyArray<A>) => Maybe<B>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray findMap
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function findMap<A, B>(f: (a: A) => Maybe<B>): (as: ReadonlyArray<A>) => Maybe<B>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray findMapWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function findMapWithIndex<A, B>(f: (index: number, a: A) => Maybe<B>): (as: ReadonlyArray<A>) => Maybe<B>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray findWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function findWithIndex<A, B extends A>(p: RefinementWithIndex<number, A, B>): (as: ReadonlyArray<A>) => Maybe<B>;
+export declare function findWithIndex<A>(p: PredicateWithIndex<number, A>): (as: ReadonlyArray<A>) => Maybe<A>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray flatMap
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function flatMap<A, B>(f: (a: A) => ReadonlyArray<B>): (self: ReadonlyArray<A>) => ReadonlyArray<B>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray flatMapWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function flatMapWithIndex<A, B>(f: (i: number, a: A) => ReadonlyArray<B>): (self: ReadonlyArray<A>) => ReadonlyArray<B>;
+/**
+ * @tsplus getter fncts.ReadonlyArray flatten
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function flatten<A>(self: ReadonlyArray<ReadonlyArray<A>>): ReadonlyArray<A>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray fold
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function fold<M>(/** @tsplus auto */ M: Monoid<M>): (self: ReadonlyArray<M>) => M;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray foldLeft
+ * @tsplus pipeable fncts.Array foldLeft
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function foldLeft<A, B>(b: B, f: (b: B, a: A) => B): (self: ReadonlyArray<A>) => B;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray foldLeftWhile
+ * @tsplus pipeable fncts.Array foldLeftWhile
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function foldLeftWhile<A, B>(b: B, p: Predicate<B>, f: (b: B, a: A) => B): (self: ReadonlyArray<A>) => B;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray foldLeftWithIndex
+ * @tsplus pipeable fncts.Array foldLeftWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function foldLeftWithIndex<A, B>(b: B, f: (i: number, b: B, a: A) => B): (self: ReadonlyArray<A>) => B;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray foldLeftWithIndexWhile
+ * @tsplus pipeable fncts.Array foldLeftWithIndexWhile
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function foldLeftWithIndexWhile<A, B>(b: B, p: Predicate<B>, f: (i: number, b: B, a: A) => B): (self: ReadonlyArray<A>) => B;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray foldMap
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function foldMap<A, M>(f: (a: A) => M, /** @tsplus auto */ M: Monoid<M>): (self: ReadonlyArray<A>) => M;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray foldMapWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function foldMapWithIndex<A, M>(f: (i: number, a: A) => M, /** @tsplus auto */ M: Monoid<M>): (self: ReadonlyArray<A>) => M;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray foldRight
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function foldRight<A, B>(b: B, f: (a: A, b: B) => B): (self: ReadonlyArray<A>) => B;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray foldRighWhile
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function foldRightWhile<A, B>(b: B, p: Predicate<B>, f: (a: A, b: B) => B): (self: ReadonlyArray<A>) => B;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray foldRightWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function foldRightWithIndex<A, B>(b: B, f: (i: number, a: A, b: B) => B): (self: ReadonlyArray<A>) => B;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray foldRightWithIndexWhile
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function foldRightWithIndexWhile<A, B>(b: B, predicate: Predicate<B>, f: (i: number, a: A, b: B) => B): (self: ReadonlyArray<A>) => B;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray forEach
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function forEach<A, B>(f: (a: A) => B): (self: ReadonlyArray<A>) => void;
+/**
+ * @tsplus static fncts.ArrayOps fromValue
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function fromValue<A>(value: A): A extends Array<any> ? A : A extends ReadonlyArray<any> ? A : ReadonlyArray<A>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray get
+ * @tsplus pipeable fncts.MutableArray get
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function get(i: number): <A>(self: ReadonlyArray<A>) => Maybe<A>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray group
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function group<A>(E: P.Eq<A>): (self: ReadonlyArray<A>) => ReadonlyArray<ReadonlyNonEmptyArray<A>>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray groupBy
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function groupBy<A>(f: (a: A) => string): (self: ReadonlyArray<A>) => Readonly<Record<string, ReadonlyNonEmptyArray<A>>>;
+/**
+ * @tsplus getter fncts.ReadonlyArray head
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function head<A>(self: ReadonlyArray<A>): Maybe<A>;
+/**
+ * @tsplus getter fncts.ReadonlyArray init
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function init<A>(self: ReadonlyArray<A>): Maybe<ReadonlyArray<A>>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray insertAt
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function insertAt<A>(i: number, a: A): (self: ReadonlyArray<A>) => Maybe<ReadonlyNonEmptyArray<A>>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray intersection
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function intersection<A>(that: ReadonlyArray<A>, /** @tsplus auto */ E: P.Eq<A>): (self: ReadonlyArray<A>) => ReadonlyArray<A>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray intersperse
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function intersperse<A>(a: A): (self: ReadonlyArray<A>) => ReadonlyArray<A>;
+/**
+ * @tsplus fluent fncts.ReadonlyArray isEmpty
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function isEmpty<A>(self: ReadonlyArray<A>): boolean;
+/**
+ * @tsplus fluent fncts.ReadonlyArray isNonEmpty
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function isNonEmpty<A>(self: ReadonlyArray<A>): self is ReadonlyNonEmptyArray<A>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray isOutOfBound
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function isOutOfBound(i: number): <A>(self: ReadonlyArray<A>) => boolean;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray join
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function join(separator: string): (self: ReadonlyArray<string>) => string;
+/**
+ * @tsplus getter fncts.ReadonlyArray last
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function last<A>(self: ReadonlyArray<A>): Maybe<A>;
+/**
+ * @tsplus getter fncts.ReadonlyArray lefts
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function lefts<E, A>(self: ReadonlyArray<Either<E, A>>): ReadonlyArray<E>;
+/**
+ * @tsplus getter fncts.ReadonlyArray length
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function length<A>(self: ReadonlyArray<A>): number;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray map
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function map<A, B>(f: (a: A) => B): (self: ReadonlyArray<A>) => ReadonlyArray<B>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray mapAccum
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function mapAccum<A, S, B>(s: S, f: (s: S, a: A) => readonly [B, S]): (self: ReadonlyArray<A>) => readonly [ReadonlyArray<B>, S];
+/**
+ * @tsplus pipeable fncts.ReadonlyArray mapWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function mapWithIndex<A, B>(f: (i: number, a: A) => B): (self: ReadonlyArray<A>) => ReadonlyArray<B>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray modifyAt
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function modifyAt<A>(i: number, f: (a: A) => A): (self: ReadonlyArray<A>) => Maybe<ReadonlyArray<A>>;
+/**
+ * @tsplus getter fncts.ReadonlyArray mutableClone
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function mutableClone<A>(self: ReadonlyArray<A>): Array<A>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray mutate
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function mutate<A>(f: (self: Array<A>) => void): (self: ReadonlyArray<A>) => ReadonlyArray<A>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray partition
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function partition<A, B extends A>(p: Refinement<A, B>): (self: ReadonlyArray<A>) => readonly [ReadonlyArray<A>, ReadonlyArray<B>];
+export declare function partition<A>(p: Predicate<A>): (self: ReadonlyArray<A>) => readonly [ReadonlyArray<A>, ReadonlyArray<A>];
+/**
+ * @tsplus pipeable fncts.ReadonlyArray partitionMap
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function partitionMap<A, B, C>(f: (a: A) => Either<B, C>): (self: ReadonlyArray<A>) => readonly [ReadonlyArray<B>, ReadonlyArray<C>];
+/**
+ * @tsplus pipeable fncts.ReadonlyArray partitionMapWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function partitionMapWithIndex<A, B, C>(f: (i: number, a: A) => Either<B, C>): (self: ReadonlyArray<A>) => readonly [ReadonlyArray<B>, ReadonlyArray<C>];
+/**
+ * @tsplus pipeable fncts.ReadonlyArray partitionWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function partitionWithIndex<A, B extends A>(p: RefinementWithIndex<number, A, B>): (self: ReadonlyArray<A>) => readonly [ReadonlyArray<A>, ReadonlyArray<B>];
+export declare function partitionWithIndex<A>(p: PredicateWithIndex<number, A>): (self: ReadonlyArray<A>) => readonly [ReadonlyArray<A>, ReadonlyArray<A>];
+/**
+ * @tsplus pipeable fncts.ReadonlyArray prepend
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function prepend<B>(head: B): <A>(self: ReadonlyArray<A>) => ReadonlyArray<A | B>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray prependAll
+ * @tsplus pipeable fncts.Array prependAll
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function prependAll<A>(a: A): (self: ReadonlyArray<A>) => ReadonlyArray<A>;
+/**
+ * @tsplus getter fncts.ReadonlyArray reverse
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function reverse<A>(self: ReadonlyArray<A>): ReadonlyArray<A>;
+/**
+ * @tsplus getter fncts.ReadonlyArray rights
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function rights<E, A>(self: ReadonlyArray<Either<E, A>>): ReadonlyArray<A>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray rotate
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function rotate(n: number): <A>(self: ReadonlyArray<A>) => ReadonlyArray<A>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray scanLeft
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function scanLeft<A, B>(b: B, f: (b: B, a: A) => B): (self: ReadonlyArray<A>) => ReadonlyArray<B>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray scanRight
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function scanRight<A, B>(b: B, f: (a: A, b: B) => B): (self: ReadonlyArray<A>) => ReadonlyArray<B>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray some
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function some<A>(p: Predicate<A>): (self: ReadonlyArray<A>) => self is ReadonlyNonEmptyArray<A>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray sort
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function sort<A>(/** @tsplus auto */ O: P.Ord<A>): (self: ReadonlyArray<A>) => ReadonlyArray<A>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray sortBy
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function sortBy<A>(Os: ReadonlyArray<P.Ord<A>>): (self: ReadonlyArray<A>) => ReadonlyArray<A>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray spanIndexLeft
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function spanIndexLeft<A>(p: Predicate<A>): (self: ReadonlyArray<A>) => number;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray spanIndexRight
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function spanIndexRight<A>(predicate: Predicate<A>): (as: ReadonlyArray<A>) => number;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray spanLeft
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function spanLeft<A, B extends A>(p: Refinement<A, B>): (self: ReadonlyArray<A>) => readonly [ReadonlyArray<B>, ReadonlyArray<A>];
+export declare function spanLeft<A>(p: Predicate<A>): (self: ReadonlyArray<A>) => readonly [ReadonlyArray<A>, ReadonlyArray<A>];
+/**
+ * @tsplus pipeable fncts.ReadonlyArray spanRight
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function spanRight<A, B extends A>(p: Refinement<A, B>): (self: ReadonlyArray<A>) => readonly [ReadonlyArray<A>, ReadonlyArray<B>];
+export declare function spanRight<A>(p: Predicate<A>): (self: ReadonlyArray<A>) => readonly [ReadonlyArray<A>, ReadonlyArray<A>];
+/**
+ * @tsplus getter fncts.ReadonlyArray tail
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function tail<A>(self: ReadonlyArray<A>): Maybe<ReadonlyArray<A>>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray take
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function take(n: number): <A>(self: ReadonlyArray<A>) => ReadonlyArray<A>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray takeLast
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function takeLast(n: number): <A>(as: ReadonlyArray<A>) => ReadonlyArray<A>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray takeWhile
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function takeWhile<A, B extends A>(p: Refinement<A, B>): (self: ReadonlyArray<A>) => ReadonlyArray<B>;
+export declare function takeWhile<A>(p: Predicate<A>): (self: ReadonlyArray<A>) => ReadonlyArray<A>;
+/**
+ * @tsplus getter fncts.ReadonlyArray traverse
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function traverse_<A>(self: ReadonlyArray<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, ReadonlyArray<B>>;
+/**
+ * @tsplus getter fncts.ReadonlyArray traverseWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function traverseWithIndex_<A>(self: ReadonlyArray<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, ReadonlyArray<B>>;
+export declare const traverseWithIndex: P.TraversableWithIndex<ReadonlyArrayF>["traverseWithIndex"];
+export declare const traverse: P.Traversable<ReadonlyArrayF>["traverse"];
+/**
+ * @tsplus pipeable fncts.ReadonlyArray union
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function union<A>(that: ReadonlyArray<A>, /** @tsplus auto */ E: P.Eq<A>): (self: ReadonlyArray<A>) => ReadonlyArray<A>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray uniq
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function uniq<A>(/** @tsplus auto */ E: P.Eq<A>): (self: ReadonlyArray<A>) => ReadonlyArray<A>;
+/**
+ * @tsplus getter fncts.ReadonlyArray unprepend
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function unprepend<A>(self: ReadonlyArray<A>): Maybe<readonly [A, ReadonlyArray<A>]>;
+/**
+ * @tsplus getter fncts.ReadonlyArray unsafeAsMutable
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function unsafeAsMutable<A>(self: ReadonlyArray<A>): Array<A>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray unsafeDeleteAt
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function unsafeDeleteAt(i: number): <A>(self: ReadonlyArray<A>) => ReadonlyArray<A>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray unsafeInsertAt
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function unsafeInsertAt<A>(i: number, a: A): (as: ReadonlyArray<A>) => ReadonlyNonEmptyArray<A>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray unsafeModifyAt
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function unsafeModifyAt<A>(i: number, f: (a: A) => A): (as: ReadonlyArray<A>) => ReadonlyArray<A>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray unsafeUpdateAt
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function unsafeUpdateAt<A>(i: number, a: A): (as: ReadonlyArray<A>) => ReadonlyArray<A>;
+/**
+ * @tsplus getter fncts.ReadonlyArray unzip
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function unzip<A, B>(self: ReadonlyArray<readonly [A, B]>): readonly [ReadonlyArray<A>, ReadonlyArray<B>];
+/**
+ * @tsplus pipeable fncts.ReadonlyArray updateAt
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function updateAt<A>(i: number, a: A): (as: ReadonlyArray<A>) => Maybe<ReadonlyArray<A>>;
+/**
+ * @tsplus getter fncts.ReadonlyArray wilt
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function wilt_<A>(self: ReadonlyArray<A>): <G extends HKT, GC = HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B, B2>(f: (a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, Either<B, B2>>) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, readonly [ReadonlyArray<B>, ReadonlyArray<B2>]>;
+/**
+ * @tsplus getter fncts.ReadonlyArray wiltWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function wiltWithIndex_<A>(self: ReadonlyArray<A>): <G extends HKT, GC = HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B, B2>(f: (i: number, a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, Either<B, B2>>) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, readonly [ReadonlyArray<B>, ReadonlyArray<B2>]>;
+/**
+ * @tsplus getter fncts.ReadonlyArray wither
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function wither_<A>(self: ReadonlyArray<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, Maybe<B>>) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, ReadonlyArray<B>>;
+/**
+ * @tsplus getter fncts.ReadonlyArray witherWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function witherWithIndex_<A>(self: ReadonlyArray<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, Maybe<B>>) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, ReadonlyArray<B>>;
+export declare const wiltWithIndex: P.WitherableWithIndex<ReadonlyArrayF>["wiltWithIndex"];
+export declare const wilt: P.WitherableWithIndex<ReadonlyArrayF>["wilt"];
+export declare const witherWithIndex: P.WitherableWithIndex<ReadonlyArrayF>["witherWithIndex"];
+export declare const wither: P.Witherable<ReadonlyArrayF>["wither"];
+/**
+ * @tsplus pipeable fncts.ReadonlyArray zip
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function zip<B>(that: ReadonlyArray<B>): <A>(self: ReadonlyArray<A>) => ReadonlyArray<readonly [A, B]>;
+/**
+ * @tsplus pipeable fncts.ReadonlyArray zipWith
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api"
+ */
+export declare function zipWith<A, B, C>(fb: ReadonlyArray<B>, f: (a: A, b: B) => C): (self: ReadonlyArray<A>) => ReadonlyArray<C>;

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

@@ -0,0 +1,30 @@
+/**
+ * @tsplus static fncts.ArrayOps empty
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/constructors"
+ */
+export declare function empty<A = never>(): ReadonlyArray<A>;
+/**
+ * @tsplus static fncts.ArrayOps makeBy
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/constructors"
+ */
+export declare function makeBy<A>(n: number, f: (i: number) => A): ReadonlyArray<A>;
+/**
+ * @tsplus static fncts.ArrayOps range
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/constructors"
+ */
+export declare function range(start: number, end: number): ReadonlyArray<number>;
+/**
+ * @tsplus static fncts.ArrayOps replicate
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/constructors"
+ */
+export declare function replicate<A>(n: number, a: A): ReadonlyArray<A>;
+/**
+ * tsplus static fncts.ArrayOps __call
+ */
+export declare function make<A>(...values: ReadonlyArray<A>): ReadonlyArray<A>;
+/**
+ * @tsplus getter fncts.Array asReadonlyArray
+ * @tsplus macro identity
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/constructors"
+ */
+export declare function asReadonlyArray<A>(self: Array<A>): ReadonlyArray<A>;