@fncts/base 0.0.20 → 0.0.22

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

@@ -4,25 +4,26 @@ 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 { HKT } from "@fncts/typelevel/HKT";
 import { Byte } from "@fncts/base/data/Byte";
 import type { ConcF } from "@fncts/base/collection/immutable/Conc/definition";
 import type { Eq } from "@fncts/base/typeclass";
-import * as P from "@fncts/base/typeclass";
+import type * as P from "@fncts/base/typeclass";
 /**
- * @tsplus fluent fncts.Conc align
+ * @tsplus pipeable 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>>;
+export declare function align<B>(fb: Conc<B>): <A>(self: import("@fncts/base/collection/immutable/Conc/definition").Conc<A>) => import("@fncts/base/collection/immutable/Conc/definition").Conc<import("../../../data/These").These<A, B>>;
 /**
- * @tsplus fluent fncts.Conc alignWith
+ * @tsplus pipeable 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>;
+export declare function alignWith<A, B, C>(fb: Conc<B>, f: (_: These<A, B>) => C): (self: Conc<A>) => Conc<C>;
 /**
- * @tsplus fluent fncts.Conc append
+ * @tsplus pipeable 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 function append<A2>(a: A2): <A1>(self: import("@fncts/base/collection/immutable/Conc/definition").Conc<A1>) => import("@fncts/base/collection/immutable/Conc/definition").Conc<A2 | A1>;
 export declare class ConcBuilder<A> {
     private conc;
     constructor(conc?: Conc<A>);
@@ -35,10 +36,10 @@ export declare class ConcBuilder<A> {
  */
 export declare function builder<A>(): ConcBuilder<A>;
 /**
- * @tsplus fluent fncts.Conc flatMap
+ * @tsplus pipeable 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>;
+export declare function flatMap<A, B>(f: (a: A) => Conc<B>): (ma: Conc<A>) => Conc<B>;
 /**
  * @tsplus static fncts.ConcOps chainRecDepthFirst
  * @tsplus location "@fncts/base/collection/immutable/Conc/api"
@@ -50,83 +51,83 @@ export declare function chainRecDepthFirst<A, B>(a: A, f: (a: A) => Conc<Either<
  */
 export declare function chainRecBreadthFirst<A, B>(a: A, f: (a: A) => Conc<Either<A, B>>): Conc<B>;
 /**
- * @tsplus fluent fncts.Conc chop
+ * @tsplus pipeable 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>;
+export declare function chop<A, B>(f: (as: Conc<A>) => readonly [B, Conc<A>]): (self: Conc<A>) => Conc<B>;
 /**
- * @tsplus fluent fncts.Conc chunksOf
+ * @tsplus pipeable fncts.Conc chunksOf
  * @tsplus location "@fncts/base/collection/immutable/Conc/api"
  */
-export declare function chunksOf_<A>(self: Conc<A>, n: number): Conc<Conc<A>>;
+export declare function chunksOf(n: number): <A>(self: import("@fncts/base/collection/immutable/Conc/definition").Conc<A>) => import("@fncts/base/collection/immutable/Conc/definition").Conc<import("@fncts/base/collection/immutable/Conc/definition").Conc<A>>;
 /**
  * Transforms all elements of the Conc for as long as the specified partial function is defined.
- * @tsplus fluent fncts.Conc collectWhile
+ * @tsplus pipeable 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>;
+export declare function collectWhile<A, B>(f: (a: A) => Maybe<B>): (as: Conc<A>) => 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 pipeable 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>;
+export declare function concat<B>(that: Conc<B>): <A>(self: import("@fncts/base/collection/immutable/Conc/definition").Conc<A>) => import("@fncts/base/collection/immutable/Conc/definition").Conc<B | A>;
 /**
- * @tsplus fluent fncts.Conc elem
+ * @tsplus pipeable fncts.Conc elem
  * @tsplus location "@fncts/base/collection/immutable/Conc/api"
  */
-export declare function elem_<A>(self: Conc<A>, a: A, /** @tsplus auto */ E: Eq<A>): boolean;
+export declare function elem<A>(a: A, /** @tsplus auto */ E: Eq<A>): (self: Conc<A>) => boolean;
 /**
- * @tsplus fluent fncts.Conc exists
+ * @tsplus pipeable fncts.Conc some
  * @tsplus location "@fncts/base/collection/immutable/Conc/api"
  */
-export declare function exists_<A>(as: Conc<A>, predicate: Predicate<A>): boolean;
+export declare function some<A>(predicate: Predicate<A>): (as: Conc<A>) => boolean;
 /**
- * @tsplus fluent fncts.Conc drop
+ * @tsplus pipeable fncts.Conc drop
  * @tsplus location "@fncts/base/collection/immutable/Conc/api"
  */
-export declare function drop_<A>(self: Conc<A>, n: number): Conc<A>;
+export declare function drop(n: number): <A>(self: import("@fncts/base/collection/immutable/Conc/definition").Conc<A>) => import("@fncts/base/collection/immutable/Conc/definition").Conc<A>;
 /**
- * @tsplus fluent fncts.Conc dropUntil
+ * @tsplus pipeable fncts.Conc dropUntil
  * @tsplus location "@fncts/base/collection/immutable/Conc/api"
  */
-export declare function dropUntil<A>(self: Conc<A>, p: Predicate<A>): Conc<A>;
+export declare function dropUntil<A>(p: Predicate<A>): (self: Conc<A>) => Conc<A>;
 /**
- * @tsplus fluent fncts.Conc dropWhile
+ * @tsplus pipeable fncts.Conc dropWhile
  * @tsplus location "@fncts/base/collection/immutable/Conc/api"
  */
-export declare function dropWhile_<A>(self: Conc<A>, p: Predicate<A>): Conc<A>;
+export declare function dropWhile<A>(p: Predicate<A>): (self: Conc<A>) => Conc<A>;
 /**
- * @tsplus fluent fncts.Conc filter
+ * @tsplus pipeable 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>;
+export declare function filter<A, B extends A>(p: Refinement<A, B>): (self: Conc<A>) => Conc<B>;
+export declare function filter<A>(p: Predicate<A>): (self: Conc<A>) => Conc<A>;
 /**
- * @tsplus fluent fncts.Conc filterMap
+ * @tsplus pipeable 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>;
+export declare function filterMap<A, B>(f: (a: A) => Maybe<B>): (self: Conc<A>) => Conc<B>;
 /**
- * @tsplus fluent fncts.Conc filterMapWithIndex
+ * @tsplus pipeable 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>;
+export declare function filterMapWithIndex<A, B>(f: (i: number, a: A) => Maybe<B>): (self: Conc<A>) => Conc<B>;
 /**
- * @tsplus fluent fncts.Conc filterWithIndex
+ * @tsplus pipeable 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>;
+export declare function filterWithIndex<A, B extends A>(p: RefinementWithIndex<number, A, B>): (self: Conc<A>) => Conc<B>;
+export declare function filterWithIndex<A>(p: PredicateWithIndex<number, A>): (self: Conc<A>) => Conc<A>;
 /**
- * @tsplus fluent fncts.Conc find
+ * @tsplus pipeable 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>;
+export declare function find<A>(f: (a: A) => boolean): (self: Conc<A>) => Maybe<A>;
 /**
  * @tsplus getter fncts.Conc flatten
  * @tsplus location "@fncts/base/collection/immutable/Conc/api"
@@ -135,55 +136,55 @@ 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 pipeable 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;
+export declare function foldLeftWhile<A, B>(b: B, p: Predicate<B>, f: (b: B, a: A) => B): (as: Conc<A>) => B;
 /**
- * @tsplus fluent fncts.Conc foldLeft
+ * @tsplus pipeable 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;
+export declare function foldLeft<A, B>(b: B, f: (b: B, a: A) => B): (self: Conc<A>) => B;
 /**
- * @tsplus fluent fncts.Conc foldLeftWithIndex
+ * @tsplus pipeable 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;
+export declare function foldLeftWithIndex<A, B>(b: B, f: (i: number, b: B, a: A) => B): (self: Conc<A>) => B;
 /**
- * @tsplus fluent fncts.Conc foldMap
+ * @tsplus pipeable fncts.Conc foldMap
  * @tsplus location "@fncts/base/collection/immutable/Conc/api"
  */
-export declare function foldMap_<A, M>(fa: Conc<A>, f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): M;
+export declare function foldMap<A, M>(f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): (fa: Conc<A>) => M;
 /**
- * @tsplus fluent fncts.Conc foldMapWithIndex
+ * @tsplus pipeable fncts.Conc foldMapWithIndex
  * @tsplus location "@fncts/base/collection/immutable/Conc/api"
  */
-export declare function foldMapWithIndex_<A, M>(fa: Conc<A>, f: (i: number, a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): M;
+export declare function foldMapWithIndex<A, M>(f: (i: number, a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): (fa: Conc<A>) => M;
 /**
- * @tsplus fluent fncts.Conc foldRight
+ * @tsplus pipeable 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;
+export declare function foldRight<A, B>(b: B, f: (a: A, b: B) => B): (fa: Conc<A>) => B;
 /**
- * @tsplus fluent fncts.Conc foldRightWithIndex
+ * @tsplus pipeable 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;
+export declare function foldRightWithIndex<A, B>(b: B, f: (i: number, a: A, b: B) => B): (self: Conc<A>) => B;
 /**
- * @tsplus fluent fncts.Conc forEach
+ * @tsplus pipeable 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;
+export declare function forEach<A, B>(f: (a: A) => B): (self: Conc<A>) => void;
 /**
- * @tsplus fluent fncts.Conc forEachWithIndex
+ * @tsplus pipeable 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;
+export declare function forEachWithIndex<A, B>(f: (i: number, a: A) => B): (self: Conc<A>) => void;
 /**
- * @tsplus fluent fncts.Conc get
+ * @tsplus pipeable fncts.Conc get
  * @tsplus location "@fncts/base/collection/immutable/Conc/api"
  */
-export declare function get_<A>(as: Conc<A>, n: number): Maybe<A>;
+export declare function get(n: number): <A>(as: import("@fncts/base/collection/immutable/Conc/definition").Conc<A>) => import("../../../data/Maybe").Maybe<A>;
 /**
  * @tsplus getter fncts.Conc head
  * @tsplus location "@fncts/base/collection/immutable/Conc/api"
@@ -195,31 +196,31 @@ export declare function head<A>(self: Conc<A>): Maybe<A>;
  */
 export declare function init<A>(self: Conc<A>): Maybe<Conc<A>>;
 /**
- * @tsplus fluent fncts.Conc join
+ * @tsplus pipeable fncts.Conc join
  * @tsplus location "@fncts/base/collection/immutable/Conc/api"
  */
-export declare function join_(self: Conc<string>, separator: string): string;
+export declare function join(separator: string): (self: Conc<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 pipeable 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>;
+export declare function map<A, B>(f: (a: A) => B): (self: Conc<A>) => Conc<B>;
 /**
  * Statefully maps over the Conc, producing new elements of type `B`.
- * @tsplus fluent fncts.Conc mapAccum
+ * @tsplus pipeable 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 [S, B]): readonly [S, Conc<B>];
+export declare function mapAccum<A, S, B>(s: S, f: (s: S, a: A) => readonly [S, B]): (self: Conc<A>) => readonly [S, Conc<B>];
 /**
- * @tsplus fluent fncts.Conc mapWithIndex
+ * @tsplus pipeable 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>;
+export declare function mapWithIndex<A, B>(f: (i: number, a: A) => B): (self: Conc<A>) => Conc<B>;
 /**
  * @tsplus getter fncts.Conc isEmpty
  * @tsplus location "@fncts/base/collection/immutable/Conc/api"
@@ -231,32 +232,32 @@ export declare function isEmpty<A>(self: Conc<A>): boolean;
  */
 export declare function isNonEmpty<A>(conc: Conc<A>): boolean;
 /**
- * @tsplus fluent fncts.Conc partition
+ * @tsplus pipeable 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>];
+export declare function partition<A, B extends A>(p: Refinement<A, B>): (self: Conc<A>) => readonly [Conc<A>, Conc<B>];
+export declare function partition<A>(p: Predicate<A>): (self: Conc<A>) => readonly [Conc<A>, Conc<A>];
 /**
- * @tsplus fluent fncts.Conc partitionMap
+ * @tsplus pipeable 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>];
+export declare function partitionMap<A, B, C>(f: (a: A) => Either<B, C>): (self: Conc<A>) => readonly [Conc<B>, Conc<C>];
 /**
- * @tsplus fluent fncts.Conc partitionMapWithIndex
+ * @tsplus pipeable 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>];
+export declare function partitionMapWithIndex<A, B, C>(f: (i: number, a: A) => Either<B, C>): (fa: Conc<A>) => readonly [Conc<B>, Conc<C>];
 /**
- * @tsplus fluent fncts.Conc partitionWithIndex
+ * @tsplus pipeable 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>];
+export declare function partitionWithIndex<A, B extends A>(p: RefinementWithIndex<number, A, B>): (self: Conc<A>) => readonly [Conc<A>, Conc<B>];
+export declare function partitionWithIndex<A>(p: PredicateWithIndex<number, A>): (self: Conc<A>) => readonly [Conc<A>, Conc<A>];
 /**
- * @tsplus fluent fncts.Conc prepend
+ * @tsplus pipeable 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>;
+export declare function prepend<B>(a: B): <A>(self: import("@fncts/base/collection/immutable/Conc/definition").Conc<A>) => import("@fncts/base/collection/immutable/Conc/definition").Conc<B | A>;
 /**
  * @tsplus getter fncts.Conc reverse
  * @tsplus location "@fncts/base/collection/immutable/Conc/api"
@@ -268,57 +269,59 @@ export declare function reverse<A>(self: Conc<A>): Iterable<A>;
  */
 export declare function separate<E, A>(self: Conc<Either<E, A>>): readonly [Conc<E>, Conc<A>];
 /**
- * @tsplus fluent fncts.Conc splitAt
+ * @tsplus pipeable 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>];
+export declare function splitAt(n: number): <A>(self: import("@fncts/base/collection/immutable/Conc/definition").Conc<A>) => readonly [import("@fncts/base/collection/immutable/Conc/definition").Conc<A>, import("@fncts/base/collection/immutable/Conc/definition").Conc<A>];
 /**
  * Splits this Conc on the first element that matches this predicate.
- * @tsplus fluent fncts.Conc splitWhere
+ * @tsplus pipeable 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>];
+export declare function splitWhere<A>(f: (a: A) => boolean): (self: Conc<A>) => 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 pipeable fncts.Conc take
  * @tsplus location "@fncts/base/collection/immutable/Conc/api"
  */
-export declare function take_<A>(self: Conc<A>, n: number): Conc<A>;
+export declare function take(n: number): <A>(self: import("@fncts/base/collection/immutable/Conc/definition").Conc<A>) => import("@fncts/base/collection/immutable/Conc/definition").Conc<A>;
 /**
- * @tsplus fluent fncts.Conc takeWhile
+ * @tsplus pipeable 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 function takeWhile<A>(p: Predicate<A>): (self: Conc<A>) => Conc<A>;
+export declare const traverse: P.Traversable<ConcF>["traverse"];
+export declare const traverseWithIndex: P.TraversableWithIndex<ConcF>["traverseWithIndex"];
 /**
- * @tsplus getter fncts.Conc traverse
+ * @tsplus getter fncts.Conc traverseWithIndex
  * @tsplus location "@fncts/base/collection/immutable/Conc/api"
  */
-export declare const traverse: P.Traversable<ConcF>["traverse"];
+export declare function _traverseWithIndex<A>(self: Conc<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, Conc<B>>;
 /**
- * @tsplus getter fncts.Conc traverseWithIndex
+ * @tsplus getter fncts.Conc traverse
  * @tsplus location "@fncts/base/collection/immutable/Conc/api"
  */
-export declare const traverseWithIndex: <KF, QF, WF, XF, IF, SF, RF, EF, A>(ta: import("@fncts/base/collection/immutable/Conc/definition").Conc<A>) => <G extends import("@fncts/typelevel/HKT").HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <KG, QG, WG, XG, IG, SG, RG, EG, B>(f: (i: number, a: A) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, B>) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, import("@fncts/base/collection/immutable/Conc/definition").Conc<B>>;
+export declare function _traverse<A>(self: Conc<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, Conc<B>>;
 /**
  * @tsplus getter fncts.Conc toBuffer
  * @tsplus location "@fncts/base/collection/immutable/Conc/api"
  */
 export declare function toBuffer(self: Conc<Byte>): Uint8Array;
 /**
- * @tsplus fluent fncts.ConcOps unfold
+ * @tsplus static 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 pipeable fncts.Conc unsafeGet
+ * @tsplus pipeable-index fncts.Conc
  * @tsplus location "@fncts/base/collection/immutable/Conc/api"
  */
-export declare function unsafeGet_<A>(self: Conc<A>, n: number): A;
+export declare function unsafeGet(n: number): <A>(self: import("@fncts/base/collection/immutable/Conc/definition").Conc<A>) => 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
@@ -338,32 +341,32 @@ export declare function unsafeHead<A>(as: Conc<A>): A;
  */
 export declare function unsafeTail<A>(self: Conc<A>): Conc<A>;
 /**
- * @tsplus fluent fncts.Conc unsafeUpdateAt
+ * @tsplus pipeable 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>;
+export declare function unsafeUpdateAt<A1>(i: number, a: A1): <A>(self: import("@fncts/base/collection/immutable/Conc/definition").Conc<A>) => import("@fncts/base/collection/immutable/Conc/definition").Conc<A1 | A>;
 /**
- * @tsplus fluent fncts.Conc updateAt
+ * @tsplus pipeable 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>>;
+export declare function updateAt<A1>(i: number, a: A1): <A>(self: import("@fncts/base/collection/immutable/Conc/definition").Conc<A>) => import("../../../data/Maybe").Maybe<import("@fncts/base/collection/immutable/Conc/definition").Conc<A1 | A>>;
 /**
- * @tsplus fluent fncts.Conc zip
+ * @tsplus pipeable 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]>;
+export declare function zip<B>(fb: Conc<B>): <A>(self: import("@fncts/base/collection/immutable/Conc/definition").Conc<A>) => import("@fncts/base/collection/immutable/Conc/definition").Conc<readonly [A, B]>;
 /**
- * @tsplus fluent fncts.Conc zipWith
+ * @tsplus pipeable 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>;
+export declare function zipWith<A, B, C>(fb: Conc<B>, f: (a: A, b: B) => C): (self: Conc<A>) => 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 pipeable 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]>;
+export declare function zipWithIndexOffset(offset: number): <A>(as: import("@fncts/base/collection/immutable/Conc/definition").Conc<A>) => import("@fncts/base/collection/immutable/Conc/definition").Conc<readonly [A, number]>;

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

@@ -1,6 +1,6 @@
 import { HKT } from "@fncts/typelevel/HKT";
-import { Hashable } from "@fncts/base/typeclass/Hashable";
-import { Equatable } from "@fncts/base/typeclass/Equatable";
+import { Hashable } from "@fncts/base/data/Hashable";
+import { Equatable } from "@fncts/base/data/Equatable";
 import { isByte } from "@fncts/base/util/predicates";
 import { IndexOutOfBoundsError, ArrayIndexOutOfBoundsError } from "@fncts/base/data/exceptions";
 import { unsafeCoerce } from "@fncts/base/data/function/api";
@@ -212,10 +212,10 @@ export declare function fromArray<A>(array: ArrayLike<A>): ConcImplementation<A>
 export declare function isConc<A>(u: Iterable<A>): u is Conc<A>;
 export declare function isConc(u: unknown): u is Conc<unknown>;
 /**
- * @tsplus fluent fncts.Conc corresponds
+ * @tsplus pipeable fncts.Conc corresponds
  * @tsplus location "@fncts/base/collection/immutable/Conc/definition"
  */
-export declare function corresponds_<A, B>(self: Conc<A>, bs: Conc<B>, f: (a: A, b: B) => boolean): boolean;
+export declare function corresponds<A, B>(bs: Conc<B>, f: (a: A, b: B) => boolean): (self: Conc<A>) => boolean;
 /**
  * @tsplus getter fncts.Conc toArray
  * @tsplus location "@fncts/base/collection/immutable/Conc/definition"

package/collection/immutable/Conc.d.ts

@@ -1,7 +1,6 @@
 export * from "./Conc/api.js";
 export * from "./Conc/constructors.js";
 export * from "./Conc/definition.js";
-export * from "./Conc/derivations.js";
 export * from "./Conc/api/empty.js";
 export * from "./Conc/api/makeBy.js";
 export * from "./Conc/api/replicate.js";

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

@@ -1,35 +1,35 @@
 import { Dictionary } from "@fncts/base/collection/immutable/Dictionary/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 /**
- * @tsplus fluent fncts.Dictionary foldLeft
+ * @tsplus pipeable fncts.Dictionary foldLeft
  * @tsplus location "@fncts/base/collection/immutable/Dictionary/api"
  */
-export declare function foldLeft_<A, B>(self: Dictionary<A>, b: B, f: (b: B, a: A) => B): B;
+export declare function foldLeft<A, B>(b: B, f: (b: B, a: A) => B): (self: Dictionary<A>) => B;
 /**
- * @tsplus fluent fncts.Dictionary foldLeftWithIndex
+ * @tsplus pipeable fncts.Dictionary foldLeftWithIndex
  * @tsplus location "@fncts/base/collection/immutable/Dictionary/api"
  */
-export declare function foldLeftWithIndex_<A, B>(self: Dictionary<A>, b: B, f: (k: string, b: B, a: A) => B): B;
+export declare function foldLeftWithIndex<A, B>(b: B, f: (k: string, b: B, a: A) => B): (self: Dictionary<A>) => B;
 /**
- * @tsplus fluent fncts.Dictionary get
+ * @tsplus pipeable fncts.Dictionary get
  * @tsplus location "@fncts/base/collection/immutable/Dictionary/api"
  */
-export declare function get_<A>(self: Dictionary<A>, key: string): Maybe<A>;
+export declare function get(key: string): <A>(self: import("./definition").Dictionary<A>) => import("../../../data/Maybe").Maybe<A>;
 /**
  * @tsplus getter fncts.Dictionary keys
  * @tsplus location "@fncts/base/collection/immutable/Dictionary/api"
  */
 export declare function keys<A>(self: Dictionary<A>): ReadonlyArray<string>;
 /**
- * @tsplus fluent fncts.Dictionary map
+ * @tsplus pipeable fncts.Dictionary map
  * @tsplus location "@fncts/base/collection/immutable/Dictionary/api"
  */
-export declare function map_<A, B>(self: Dictionary<A>, f: (a: A) => B): Dictionary<B>;
+export declare function map<A, B>(f: (a: A) => B): (self: Dictionary<A>) => Dictionary<B>;
 /**
- * @tsplus fluent fncts.Dictionary mapWithIndex
+ * @tsplus pipeable fncts.Dictionary mapWithIndex
  * @tsplus location "@fncts/base/collection/immutable/Dictionary/api"
  */
-export declare function mapWithIndex_<A, B>(self: Dictionary<A>, f: (k: string, a: A) => B): Dictionary<B>;
+export declare function mapWithIndex<A, B>(f: (k: string, a: A) => B): (self: Dictionary<A>) => Dictionary<B>;
 /**
  * @tsplus getter fncts.Dictionary toRecord
  * @tsplus macro identity
@@ -37,7 +37,7 @@ export declare function mapWithIndex_<A, B>(self: Dictionary<A>, f: (k: string,
  */
 export declare function toRecord<A>(self: Dictionary<A>): Record<string, A>;
 /**
- * @tsplus fluent fncts.Dictionary unsafeGet
+ * @tsplus pipeable fncts.Dictionary unsafeGet
  * @tsplus location "@fncts/base/collection/immutable/Dictionary/api"
  */
-export declare function unsafeGet_<A>(self: Dictionary<A>, key: string): A | undefined;
+export declare function unsafeGet(key: string): <A>(self: import("./definition").Dictionary<A>) => A | undefined;

package/collection/immutable/Dictionary.d.ts

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