@fncts/base 0.0.1

package/collection/Iterable/constructors.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @tsplus static fncts.IterableOps make
+ * @tsplus location "@fncts/base/collection/Iterable/constructors"
+ */
+export declare function mkIterable<A>(iterator: () => Iterator<A>): Iterable<A>;
+/**
+ * @tsplus static fncts.IterableOps empty
+ * @tsplus location "@fncts/base/collection/Iterable/constructors"
+ */
+export declare function empty<A>(): Iterable<A>;
+/**
+ * @tsplus static fncts.IterableOps single
+ * @tsplus location "@fncts/base/collection/Iterable/constructors"
+ */
+export declare function single<A>(a: A): Iterable<A>;
+/**
+ * @tsplus static fncts.IterableOps makeBy
+ * @tsplus location "@fncts/base/collection/Iterable/constructors"
+ */
+export declare function makeBy<A>(n: number, f: (i: number) => A): Iterable<A>;
+/**
+ * @tsplus static fncts.IterableOps range
+ * @tsplus location "@fncts/base/collection/Iterable/constructors"
+ */
+export declare function range(start: number, end: number): Iterable<number>;

package/collection/Iterable/definition.d.ts

@@ -0,0 +1,14 @@
+declare global {
+    /**
+     * @tsplus type fncts.Iterable
+     */
+    export interface Iterable<T> {
+    }
+    export const Iterable: IterableOps;
+}
+/**
+ * @tsplus type fncts.IterableOps
+ */
+export interface IterableOps {
+}
+export declare const Iterable: IterableOps;

package/collection/Iterable.d.ts

@@ -0,0 +1,3 @@
+export * from "./Iterable/api.js";
+export * from "./Iterable/constructors.js";
+export * from "./Iterable/definition.js";

package/collection/compat/Array/api.d.ts

@@ -0,0 +1,32 @@
+import { ReadonlyNonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
+import type { Eq } from "@fncts/base/typeclass";
+/**
+ * @tsplus getter fncts.base.Array elem
+ * @tsplus getter fncts.base.ReadonlyArray elem
+ * @tsplus location "@fncts/base/collection/compat/Array/api"
+ */
+export declare function elem<A>(self: ReadonlyArray<A>): (eq: Eq<A>) => (a: A) => boolean;
+/**
+ * @tsplus fluent fncts.base.Array isEmpty
+ * @tsplus fluent fncts.base.ReadonlyArray isEmpty
+ * @tsplus location "@fncts/base/collection/compat/Array/api"
+ */
+export declare function isEmpty<A>(self: ReadonlyArray<A>): boolean;
+/**
+ * @tsplus fluent fncts.base.Array isNonEmpty
+ * @tsplus fluent fncts.base.ReadonlyArray isNonEmpty
+ * @tsplus location "@fncts/base/collection/compat/Array/api"
+ */
+export declare function isNonEmpty<A>(self: ReadonlyArray<A>): self is ReadonlyNonEmptyArray<A>;
+/**
+ * @tsplus fluent fncts.base.Array foldLeft
+ * @tsplus fluent fncts.base.ReadonlyArray foldLeft
+ * @tsplus location "@fncts/base/collection/compat/Array/api"
+ */
+export declare function foldLeft<A, B>(self: ReadonlyArray<A>, b: B, f: (b: B, a: A) => B): B;
+/**
+ * @tsplus fluent fncts.base.Array foldLeftWithIndex
+ * @tsplus fluent fncts.base.ReadonlyArray foldLeftWithIndex
+ * @tsplus location "@fncts/base/collection/compat/Array/api"
+ */
+export declare function foldLeftWithIndex<A, B>(self: ReadonlyArray<A>, b: B, f: (i: number, b: B, a: A) => B): B;

package/collection/compat/Array/definition.d.ts

@@ -0,0 +1,20 @@
+declare global {
+    /**
+     * @tsplus type fncts.base.ReadonlyArray
+     */
+    export interface ReadonlyArray<T> {
+    }
+    /**
+     * @tsplus type fncts.base.Array
+     */
+    export interface Array<T> {
+    }
+    /**
+     * @tsplus type fncts.base.ArrayOps
+     */
+    export interface ArrayConstructor {
+    }
+}
+export declare type ESArray<A> = globalThis.Array<A>;
+export declare type ESReadonlyArray<A> = globalThis.ReadonlyArray<A>;
+export declare const ESArray: ArrayConstructor;

package/collection/compat/Array.d.ts

@@ -0,0 +1,2 @@
+export * from "./Array/api.js";
+export * from "./Array/definition.js";

package/collection/compat/ArrayLike/api.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @tsplus getter fncts.ArrayLike asIterable
+ * @tsplus location "@fncts/base/collection/compat/ArrayLike/api"
+ */
+export declare function asIterable<A>(self: ArrayLike<A>): Iterable<A>;

package/collection/compat/ArrayLike/definition.d.ts

@@ -0,0 +1,13 @@
+declare global {
+    /**
+     * @tsplus type fncts.ArrayLike
+     */
+    interface ArrayLike<T> {
+    }
+    /**
+     * @tsplus type fncts.ArrayLike
+     */
+    interface RelativeIndexable<T> {
+    }
+}
+export {};

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

@@ -0,0 +1,6 @@
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+/**
+ * @tsplus static fncts.ConcOps empty
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api/empty"
+ */
+export declare function empty<B>(): Conc<B>;

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

@@ -0,0 +1,7 @@
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+/**
+ * Fills a Conc with the result of applying `f` `n` times
+ * @tsplus static fncts.ConcOps makeBy
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api/makeBy"
+ */
+export declare function makeBy<A>(n: number, f: (n: number) => A): Conc<A>;

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

@@ -0,0 +1,6 @@
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+/**
+ * @tsplus static fncts.ConcOps replicate
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api/replicate"
+ */
+export declare function replicate<A>(n: number, a: A): Conc<A>;

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

@@ -0,0 +1,368 @@
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { These } from "@fncts/base/data/These/definition";
+import { Either } from "@fncts/base/data/Either/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Predicate, PredicateWithIndex } from "@fncts/base/data/Predicate/definition";
+import { Refinement, RefinementWithIndex } from "@fncts/base/data/Refinement/definition";
+import type { ConcF } from "@fncts/base/collection/immutable/Conc/definition";
+import type { Eq } from "@fncts/base/typeclass";
+import * as P from "@fncts/base/typeclass";
+/**
+ * @tsplus fluent fncts.Conc align
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function align_<A, B>(self: Conc<A>, fb: Conc<B>): Conc<These<A, B>>;
+/**
+ * @tsplus fluent fncts.Conc alignWith
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function alignWith_<A, B, C>(self: Conc<A>, fb: Conc<B>, f: (_: These<A, B>) => C): Conc<C>;
+/**
+ * @tsplus fluent fncts.Conc append
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function append_<A1, A2>(self: Conc<A1>, a: A2): Conc<A1 | A2>;
+export declare class ConcBuilder<A> {
+    private conc;
+    constructor(conc: Conc<A>);
+    append(a: A): ConcBuilder<A>;
+    result(): Conc<A>;
+}
+/**
+ * @tsplus static fncts.ConcOps builder
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function builder<A>(): ConcBuilder<A>;
+/**
+ * @tsplus fluent fncts.Conc flatMap
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function flatMap_<A, B>(ma: Conc<A>, f: (a: A) => Conc<B>): Conc<B>;
+/**
+ * @tsplus static fncts.ConcOps chainRecDepthFirst
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function chainRecDepthFirst<A, B>(a: A, f: (a: A) => Conc<Either<A, B>>): Conc<B>;
+/**
+ * @tsplus static fncts.ConcOps chainRecBreadthFirst
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function chainRecBreadthFirst<A, B>(a: A, f: (a: A) => Conc<Either<A, B>>): Conc<B>;
+/**
+ * @tsplus fluent fncts.Conc chop
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function chop_<A, B>(self: Conc<A>, f: (as: Conc<A>) => readonly [B, Conc<A>]): Conc<B>;
+/**
+ * @tsplus fluent fncts.Conc chunksOf
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function chunksOf_<A>(self: Conc<A>, n: number): Conc<Conc<A>>;
+/**
+ * Transforms all elements of the Conc for as long as the specified partial function is defined.
+ * @tsplus fluent fncts.Conc collectWhile
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function collectWhile_<A, B>(as: Conc<A>, f: (a: A) => Maybe<B>): Conc<B>;
+/**
+ * @tsplus getter fncts.Conc compact
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function compact<A>(self: Conc<Maybe<A>>): Conc<A>;
+/**
+ * @tsplus fluent fncts.Conc concat
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function concat_<A, B>(self: Conc<A>, that: Conc<B>): Conc<A | B>;
+/**
+ * @tsplus getter fncts.Conc elem
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function elem_<A>(self: Conc<A>): (E: Eq<A>) => (a: A) => boolean;
+/**
+ * @tsplus fluent fncts.Conc exists
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function exists_<A>(as: Conc<A>, predicate: Predicate<A>): boolean;
+/**
+ * @tsplus fluent fncts.Conc drop
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function drop_<A>(self: Conc<A>, n: number): Conc<A>;
+/**
+ * @tsplus fluent fncts.Conc dropWhile
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function dropWhile_<A>(self: Conc<A>, p: Predicate<A>): Conc<A>;
+/**
+ * @tsplus fluent fncts.Conc filter
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function filter_<A, B extends A>(self: Conc<A>, p: Refinement<A, B>): Conc<B>;
+export declare function filter_<A>(self: Conc<A>, p: Predicate<A>): Conc<A>;
+/**
+ * @tsplus fluent fncts.Conc filterMap
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function filterMap_<A, B>(self: Conc<A>, f: (a: A) => Maybe<B>): Conc<B>;
+/**
+ * @tsplus fluent fncts.Conc filterMapWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function filterMapWithIndex_<A, B>(self: Conc<A>, f: (i: number, a: A) => Maybe<B>): Conc<B>;
+/**
+ * @tsplus fluent fncts.Conc filterWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function filterWithIndex_<A, B extends A>(self: Conc<A>, p: RefinementWithIndex<number, A, B>): Conc<B>;
+export declare function filterWithIndex_<A>(self: Conc<A>, p: PredicateWithIndex<number, A>): Conc<A>;
+/**
+ * @tsplus fluent fncts.Conc find
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function find_<A>(self: Conc<A>, f: (a: A) => boolean): Maybe<A>;
+/**
+ * @tsplus getter fncts.Conc flatten
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function flatten<A>(self: Conc<Conc<A>>): Conc<A>;
+/**
+ * Folds over the elements in this Conc from the left.
+ * Stops the fold early when the condition is not fulfilled.
+ * @tsplus fluent fncts.Conc foldLeftWhile
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function foldLeftWhile_<A, B>(as: Conc<A>, b: B, p: Predicate<B>, f: (b: B, a: A) => B): B;
+/**
+ * @tsplus fluent fncts.Conc foldLeft
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function foldLeft_<A, B>(self: Conc<A>, b: B, f: (b: B, a: A) => B): B;
+/**
+ * @tsplus fluent fncts.Conc foldLeftWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function foldLeftWithIndex_<A, B>(self: Conc<A>, b: B, f: (i: number, b: B, a: A) => B): B;
+/**
+ * @constrained
+ */
+export declare function foldMap_<M>(M: P.Monoid<M>): <A>(fa: import("@fncts/base/collection/immutable/Conc/definition").Conc<A>, f: (a: A) => M) => M;
+/**
+ * @tsplus getter fncts.Conc foldMap
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function foldMapSelf<A>(self: Conc<A>): <M>(M: P.Monoid<M>) => (f: (a: A) => M) => M;
+/**
+ * @constrained
+ */
+export declare function foldMapWithIndex_<M>(M: P.Monoid<M>): <A>(fa: import("@fncts/base/collection/immutable/Conc/definition").Conc<A>, f: (i: number, a: A) => M) => M;
+/**
+ * @tsplus getter fncts.Conc foldMapWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function foldMapWithIndexSelf<A>(self: Conc<A>): <M>(M: P.Monoid<M>) => (f: (i: number, a: A) => M) => M;
+/**
+ * @tsplus fluent fncts.Conc foldRight
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function foldRight_<A, B>(fa: Conc<A>, b: B, f: (a: A, b: B) => B): B;
+/**
+ * @tsplus fluent fncts.Conc foldRightWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function foldRightWithIndex_<A, B>(self: Conc<A>, b: B, f: (i: number, a: A, b: B) => B): B;
+/**
+ * @tsplus fluent fncts.Conc forEach
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function forEach_<A, B>(self: Conc<A>, f: (a: A) => B): void;
+/**
+ * @tsplus fluent fncts.Conc forEachWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function forEachWithIndex_<A, B>(self: Conc<A>, f: (i: number, a: A) => B): void;
+/**
+ * @tsplus fluent fncts.Conc get
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function get_<A>(as: Conc<A>, n: number): Maybe<A>;
+/**
+ * @tsplus getter fncts.Conc head
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function head<A>(self: Conc<A>): Maybe<A>;
+/**
+ * @tsplus getter fncts.Conc init
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function init<A>(self: Conc<A>): Maybe<Conc<A>>;
+/**
+ * @tsplus fluent fncts.Conc join
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function join_(self: Conc<string>, separator: string): string;
+/**
+ * @tsplus getter fncts.Conc last
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function last<A>(self: Conc<A>): Maybe<A>;
+/**
+ * @tsplus fluent fncts.Conc map
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function map_<A, B>(self: Conc<A>, f: (a: A) => B): Conc<B>;
+/**
+ * Statefully maps over the Conc, producing new elements of type `B`.
+ * @tsplus fluent fncts.Conc mapAccum
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function mapAccum_<A, S, B>(self: Conc<A>, s: S, f: (s: S, a: A) => readonly [B, S]): readonly [Conc<B>, S];
+/**
+ * @tsplus fluent fncts.Conc mapWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function mapWithIndex_<A, B>(self: Conc<A>, f: (i: number, a: A) => B): Conc<B>;
+/**
+ * @tsplus getter fncts.Conc isEmpty
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function isEmpty<A>(self: Conc<A>): boolean;
+/**
+ * @tsplus getter fncts.Conc isNonEmpty
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function isNonEmpty<A>(conc: Conc<A>): boolean;
+/**
+ * @tsplus fluent fncts.Conc partition
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function partition_<A, B extends A>(self: Conc<A>, p: Refinement<A, B>): readonly [Conc<A>, Conc<B>];
+export declare function partition_<A>(self: Conc<A>, p: Predicate<A>): readonly [Conc<A>, Conc<A>];
+/**
+ * @tsplus fluent fncts.Conc partitionMap
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function partitionMap_<A, B, C>(self: Conc<A>, f: (a: A) => Either<B, C>): readonly [Conc<B>, Conc<C>];
+/**
+ * @tsplus fluent fncts.Conc partitionMapWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function partitionMapWithIndex_<A, B, C>(fa: Conc<A>, f: (i: number, a: A) => Either<B, C>): readonly [Conc<B>, Conc<C>];
+/**
+ * @tsplus fluent fncts.Conc partitionWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function partitionWithIndex_<A, B extends A>(self: Conc<A>, p: RefinementWithIndex<number, A, B>): readonly [Conc<A>, Conc<B>];
+export declare function partitionWithIndex_<A>(self: Conc<A>, p: PredicateWithIndex<number, A>): readonly [Conc<A>, Conc<A>];
+/**
+ * @tsplus fluent fncts.Conc prepend
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function prepend_<A, B>(self: Conc<A>, a: B): Conc<A | B>;
+/**
+ * @tsplus getter fncts.Conc reverse
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function reverse<A>(self: Conc<A>): Iterable<A>;
+/**
+ * @tsplus getter fncts.Conc separate
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function separate<E, A>(self: Conc<Either<E, A>>): readonly [Conc<E>, Conc<A>];
+/**
+ * @tsplus fluent fncts.Conc splitAt
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function splitAt_<A>(self: Conc<A>, n: number): readonly [Conc<A>, Conc<A>];
+/**
+ * Splits this Conc on the first element that matches this predicate.
+ * @tsplus fluent fncts.Conc splitWhere
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function splitWhere_<A>(self: Conc<A>, f: (a: A) => boolean): readonly [Conc<A>, Conc<A>];
+/**
+ * @tsplus getter fncts.Conc tail
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function tail<A>(conc: Conc<A>): Maybe<Conc<A>>;
+/**
+ * @tsplus fluent fncts.Conc take
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function take_<A>(self: Conc<A>, n: number): Conc<A>;
+/**
+ * @tsplus fluent fncts.Conc takeWhile
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function takeWhile_<A>(self: Conc<A>, p: Predicate<A>): Conc<A>;
+export declare const traverse_: P.traverse_<ConcF>;
+/**
+ * @tsplus getter fncts.Conc traverse
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare const traverseSelf: P.traverseSelf<ConcF>;
+export declare const traverseWithIndex_: P.traverseWithIndex_<ConcF>;
+/**
+ * @tsplus getter fncts.Conc traverseWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare const traverseSelfWithIndex: P.traverseWithIndexSelf<ConcF>;
+/**
+ * @tsplus fluent fncts.ConcOps unfold
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function unfold<A, B>(b: B, f: (b: B) => Maybe<readonly [A, B]>): Conc<A>;
+/**
+ * @tsplus fluent fncts.Conc unsafeGet
+ * @tsplus index fncts.Conc
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function unsafeGet_<A>(self: Conc<A>, n: number): A;
+/**
+ * Returns the first element of this Conc. Note that this method is partial
+ * in that it will throw an exception if the Conc is empty. Consider using
+ * `head` to explicitly handle the possibility that the Conc is empty
+ * or iterating over the elements of the Conc in lower level, performance
+ * sensitive code unless you really only need the first element of the Conc.
+ * @tsplus getter fncts.Conc unsafeHead
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function unsafeHead<A>(as: Conc<A>): A;
+/**
+ * Returns every element after the first. Note that this method is partial
+ * in that it will throw an exception if the Conc is empty. Consider using
+ * `tail` to explicitly handle the possibility that the Conc is empty
+ * @tsplus getter fncts.Conc unsafeTail
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function unsafeTail<A>(self: Conc<A>): Conc<A>;
+/**
+ * @tsplus fluent fncts.Conc unsafeUpdateAt
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function unsafeUpdateAt_<A, A1>(self: Conc<A>, i: number, a: A1): Conc<A | A1>;
+/**
+ * @tsplus fluent fncts.Conc updateAt
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function updateAt_<A, A1>(self: Conc<A>, i: number, a: A1): Maybe<Conc<A | A1>>;
+/**
+ * @tsplus fluent fncts.Conc zip
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function zip_<A, B>(self: Conc<A>, fb: Conc<B>): Conc<readonly [A, B]>;
+/**
+ * @tsplus fluent fncts.Conc zipWith
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function zipWith_<A, B, C>(self: Conc<A>, fb: Conc<B>, f: (a: A, b: B) => C): Conc<C>;
+/**
+ * @tsplus getter fncts.Conc zipWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function zipWithIndex<A>(self: Conc<A>): Conc<readonly [A, number]>;
+/**
+ * @tsplus fluent fncts.Conc zipWithIndexOffset
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function zipWithIndexOffset_<A>(as: Conc<A>, offset: number): Conc<readonly [A, number]>;

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

@@ -0,0 +1,27 @@
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { Byte } from "@fncts/base/data/Byte";
+/**
+ * @tsplus static fncts.ConcOps from
+ * @tsplus location "@fncts/base/collection/immutable/Conc/constructors"
+ */
+export declare function from<A>(as: Iterable<A>): Conc<A>;
+/**
+ * @tsplus static fncts.ConcOps fromBuffer
+ * @tsplus location "@fncts/base/collection/immutable/Conc/constructors"
+ */
+export declare function fromBuffer(bytes: Uint8Array): Conc<Byte>;
+/**
+ * @tsplus static fncts.ConcOps __call
+ * @tsplus location "@fncts/base/collection/immutable/Conc/constructors"
+ */
+export declare function make<A>(...as: ReadonlyArray<A>): Conc<A>;
+/**
+ * @tsplus static fncts.ConcOps range
+ * @tsplus location "@fncts/base/collection/immutable/Conc/constructors"
+ */
+export declare function range(start: number, end: number): Conc<number>;
+/**
+ * @tsplus static fncts.ConcOps single
+ * @tsplus location "@fncts/base/collection/immutable/Conc/constructors"
+ */
+export declare function single<A>(a: A): Conc<A>;