@fncts/base 0.0.1 → 0.0.4

package/_src/typeclass/WitherableWithIndex.ts

@@ -1,223 +1,26 @@
 import type { Applicative } from "@fncts/base/typeclass/Applicative";
-import type { FilterableWithIndexMin } from "@fncts/base/typeclass/FilterableWithIndex";
-import type { TraversableWithIndexMin } from "@fncts/base/typeclass/TraversableWithIndex";
-import type { WitherableMin } from "@fncts/base/typeclass/Witherable";
-
-import { FilterableWithIndex } from "@fncts/base/typeclass/FilterableWithIndex";
-import { TraversableWithIndex } from "@fncts/base/typeclass/TraversableWithIndex";
-import { Witherable } from "@fncts/base/typeclass/Witherable";
+import type { FilterableWithIndex } from "@fncts/base/typeclass/FilterableWithIndex";
+import type { TraversableWithIndex } from "@fncts/base/typeclass/TraversableWithIndex";
+import type { Witherable } from "@fncts/base/typeclass/Witherable";
 
 /**
  * @tsplus type fncts.WitherableWithIndex
  */
-export interface WitherableWithIndex<F extends HKT, FC = HKT.None>
-  extends FilterableWithIndex<F, FC>,
-    TraversableWithIndex<F, FC>,
-    Witherable<F, FC> {
-  readonly witherWithIndex_: witherWithIndex_<F, FC>;
-  readonly witherWithIndex: witherWithIndex<F, FC>;
-  readonly wiltWithIndex_: wiltWithIndex_<F, FC>;
-  readonly wiltWithIndex: wiltWithIndex<F, FC>;
-}
-
-/**
- * @tsplus type fncts.WitherableWithIndexOps
- */
-export interface WitherableWithIndexOps {}
-
-export const WitherableWithIndex: WitherableWithIndexOps = {};
-
-export type WitherableWithIndexMin<F extends HKT, FC = HKT.None> = FilterableWithIndexMin<F, FC> &
-  TraversableWithIndexMin<F, FC> &
-  WitherableMin<F, FC> & {
-    readonly witherWithIndex_: witherWithIndex_<F, FC>;
-    readonly wiltWithIndex_: wiltWithIndex_<F, FC>;
-  };
-
-/**
- * @tsplus static fncts.WitherableWithIndexOps __call
- */
-export function mkWitherableWithIndex<F extends HKT, FC = HKT.None>(
-  F: WitherableWithIndexMin<F, FC>,
-): WitherableWithIndex<F, FC> {
-  return HKT.instance({
-    ...FilterableWithIndex(F),
-    ...TraversableWithIndex(F),
-    ...Witherable(F),
-    wiltWithIndex_: F.wiltWithIndex_,
-    wiltWithIndex: <G extends HKT, CG = HKT.None>(AG: Applicative<G, CG>) => {
-      const wiltWithIndex_ = F.wiltWithIndex_(AG);
-      return <KG, QG, WG, XG, IG, SG, RG, EG, A, B, B1, KF>(
-          f: (
-            k: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>,
-            a: A,
-          ) => HKT.Kind<G, CG, KG, QG, WG, XG, IG, SG, RG, EG, Either<B, B1>>,
-        ) =>
-        <QF, WF, XF, IF, SF, RF, EF>(wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>) =>
-          wiltWithIndex_(wa, f);
-    },
-    witherWithIndex_: F.witherWithIndex_,
-    witherWithIndex: <G extends HKT, CG = HKT.None>(AG: Applicative<G, CG>) => {
-      const witherWithIndex_ = F.witherWithIndex_(AG);
-      return <KG, QG, WG, XG, IG, SG, RG, EG, A, B, KF>(
-          f: (
-            k: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>,
-            a: A,
-          ) => HKT.Kind<G, CG, KG, QG, WG, XG, IG, SG, RG, EG, Maybe<B>>,
-        ) =>
-        <QF, WF, XF, IF, SF, RF, EF>(wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>) =>
-          witherWithIndex_(wa, f);
-    },
-  });
-}
-
-export interface witherWithIndex<F extends HKT, FC = HKT.None> {
-  <G extends HKT, GC = HKT.None>(F: Applicative<G, GC>): <KG, QG, WG, XG, IG, SG, RG, EG, A, B, KF>(
-    f: (k: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>, a: A) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, Maybe<B>>,
-  ) => <QF, WF, XF, IF, SF, RF, EF>(
-    wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
-  ) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>>;
-}
-
-export interface witherWithIndex_<F extends HKT, FC = HKT.None> {
-  <G extends HKT, GC = HKT.None>(F: Applicative<G, GC>): <
-    KF,
-    QF,
-    WF,
-    XF,
-    IF,
-    SF,
-    RF,
-    EF,
-    KG,
-    QG,
-    WG,
-    XG,
-    IG,
-    SG,
-    RG,
-    EG,
-    A,
-    B,
-  >(
-    wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
-    f: (k: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>, a: A) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, Maybe<B>>,
-  ) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>>;
-}
-
-export interface witherWithIndexSelf<F extends HKT, FC = HKT.None> {
-  <KF, QF, WF, XF, IF, SF, RF, EF, A>(self: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>): <
-    G extends HKT,
-    GC = HKT.None,
-  >(
-    F: Applicative<G, GC>,
-  ) => <KG, QG, WG, XG, IG, SG, RG, EG, B>(
-    f: (k: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>, a: A) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, Maybe<B>>,
-  ) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>>;
-}
-
-export function mkWitherWithIndex<F extends HKT, FC = HKT.None>(): (
-  i: <KF, QF, WF, XF, IF, SF, RF, EF, A, B, G>(_: {
-    A: A;
-    B: B;
-    G: G;
-    FK: KF;
-    FQ: QF;
-    FW: WF;
-    FX: XF;
-    FI: IF;
-    FS: SF;
-    FR: RF;
-    FE: EF;
-  }) => (
-    G: Applicative<HKT.F<G>>,
-  ) => (
-    f: (i: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>, a: A) => HKT.FK1<G, Maybe<B>>,
-  ) => (
-    wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
-  ) => HKT.FK1<G, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>>,
-) => witherWithIndex<F, FC>;
-export function mkWitherWithIndex() {
-  return (i: any) => i();
-}
-
-export function mkWitherWithIndex_<F extends HKT, FC = HKT.None>(): (
-  i: <KF, QF, WF, XF, IF, SF, RF, EF, A, B, G>(_: {
-    A: A;
-    B: B;
-    G: G;
-    FK: KF;
-    FQ: QF;
-    FW: WF;
-    FX: XF;
-    FI: IF;
-    FS: SF;
-    FR: RF;
-    FE: EF;
-  }) => (
-    G: Applicative<HKT.F<G>>,
-  ) => (
-    wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
-    f: (i: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>, a: A) => HKT.FK1<G, Maybe<B>>,
-  ) => HKT.FK1<G, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>>,
-) => witherWithIndex_<F, FC>;
-export function mkWitherWithIndex_() {
-  return (i: any) => i();
-}
-
-export interface wiltWithIndex<F extends HKT, FC = HKT.None> {
-  <G extends HKT, GC = HKT.None>(F: Applicative<G, GC>): <KG, QG, WG, XG, IG, SG, RG, EG, A, B, B2, KF>(
-    f: (
-      k: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>,
-      a: A,
-    ) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, Either<B, B2>>,
-  ) => <QF, WF, XF, IF, SF, RF, EF>(
-    wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
-  ) => HKT.Kind<
-    G,
-    GC,
-    KG,
-    QG,
-    WG,
-    XG,
-    IG,
-    SG,
-    RG,
-    EG,
-    readonly [HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B2>]
-  >;
-}
-
-export interface wiltWithIndex_<F extends HKT, FC = HKT.None> {
-  <G extends HKT, GC = HKT.None>(F: Applicative<G, GC>): <
-    KF,
-    QF,
-    WF,
-    XF,
-    IF,
-    SF,
-    RF,
-    EF,
-    KG,
-    QG,
-    WG,
-    XG,
-    IG,
-    SG,
-    RG,
-    EG,
-    A,
-    B,
-    B2,
-  >(
-    wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
-    f: (
-      k: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>,
-      a: A,
-    ) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, Either<B, B2>>,
-  ) => HKT.Kind<
+export interface WitherableWithIndex<F extends HKT>
+  extends FilterableWithIndex<F>,
+    TraversableWithIndex<F>,
+    Witherable<F> {
+  witherWithIndex<G extends HKT, KF, QF, WF, XF, IF, SF, RF, EF, KG, QG, WG, XG, IG, SG, RG, EG, A, B>(
+    wa: HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, A>,
+    f: (k: HKT.IndexFor<F, KF>, a: A) => HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, Maybe<B>>,
+    /** @tsplus auto */ G: Applicative<G>,
+  ): HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, B>>;
+  wiltWithIndex<G extends HKT, KF, QF, WF, XF, IF, SF, RF, EF, KG, QG, WG, XG, IG, SG, RG, EG, A, B, B2>(
+    wa: HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, A>,
+    f: (k: HKT.IndexFor<F, KF>, a: A) => HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, Either<B, B2>>,
+    /** @tsplus auto */ G: Applicative<G>,
+  ): HKT.Kind<
     G,
-    GC,
     KG,
     QG,
     WG,
@@ -226,134 +29,123 @@ export interface wiltWithIndex_<F extends HKT, FC = HKT.None> {
     SG,
     RG,
     EG,
-    readonly [HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B2>]
+    readonly [HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, B>, HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, B2>]
   >;
 }
 
-export interface wiltWithIndexSelf<F extends HKT, FC = HKT.None> {
-  <KF, QF, WF, XF, IF, SF, RF, EF, A>(self: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>): <
-    G extends HKT,
-    GC = HKT.None,
-  >(
-    F: Applicative<G, GC>,
-  ) => <KG, QG, WG, XG, IG, SG, RG, EG, B1, B2>(
-    f: (
-      k: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>,
-      a: A,
-    ) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, Either<B1, B2>>,
-  ) => HKT.Kind<
-    G,
-    GC,
-    KG,
-    QG,
-    WG,
-    XG,
-    IG,
-    SG,
-    RG,
-    EG,
-    readonly [HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B1>, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B2>]
-  >;
-}
-
-export function mkWiltWithIndex<F extends HKT, FC = HKT.None>(): (
-  i: <KF, QF, WF, XF, IF, SF, RF, EF, A, B, B2, G>(_: {
-    A: A;
-    B: B;
-    B2: B2;
-    G: G;
-    FK: KF;
-    FQ: QF;
-    FW: WF;
-    FX: XF;
-    FI: IF;
-    FS: SF;
-    FR: RF;
-    FE: EF;
-  }) => (
-    G: Applicative<HKT.F<G>>,
-  ) => (
-    f: (i: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>, a: A) => HKT.FK1<G, Either<B, B2>>,
-  ) => (
-    wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
-  ) => HKT.FK1<
-    G,
-    readonly [HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B2>]
-  >,
-) => wiltWithIndex<F, FC>;
-export function mkWiltWithIndex() {
-  return (i: any) => i();
-}
-
-export function mkWiltWithIndex_<F extends HKT, FC = HKT.None>(): (
-  i: <KF, QF, WF, XF, IF, SF, RF, EF, A, B1, B2, G>(_: {
-    G: G;
-    FK: KF;
-    FQ: QF;
-    FW: WF;
-    FX: XF;
-    FI: IF;
-    FS: SF;
-    FR: RF;
-    FE: EF;
-    A: A;
-    B: B1;
-    B2: B2;
-  }) => (
-    G: Applicative<HKT.F<G>>,
-  ) => (
-    wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
-    f: (i: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>, a: A) => HKT.FK1<G, Either<B1, B2>>,
-  ) => HKT.FK1<
-    G,
-    readonly [HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B1>, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B2>]
-  >,
-) => wiltWithIndex_<F, FC>;
-export function mkWiltWithIndex_() {
-  return (i: any) => i();
-}
-
-export interface FilterWithIndexAFn_<F extends HKT, CF = HKT.None> {
-  <G extends HKT, CG = HKT.None>(G: Applicative<G, CG>): <
-    KF,
-    QF,
-    WF,
-    XF,
-    IF,
-    SF,
-    RF,
-    EF,
-    AF,
-    KG,
-    QG,
-    WG,
-    XG,
-    IG,
-    SG,
-    RG,
-    EG,
-  >(
-    fa: HKT.Kind<F, CF, KF, QF, WF, XF, IF, SF, RF, EF, AF>,
-    p: (i: HKT.IndexFor<F, HKT.OrFix<CF, "K", KF>>, a: AF) => HKT.Kind<G, CG, KG, QG, WG, XG, IG, SG, RG, EG, boolean>,
-  ) => HKT.Kind<G, CG, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, CF, KF, QF, WF, XF, IF, SF, RF, EF, AF>>;
-}
+/**
+ * @tsplus type fncts.WitherableWithIndexOps
+ */
+export interface WitherableWithIndexOps {}
 
-export function filterWithIndexAF_<F extends HKT, CF = HKT.None>(
-  F: WitherableWithIndexMin<F, CF>,
-): FilterWithIndexAFn_<F, CF> {
-  return (G) => (fa, p) => F.witherWithIndex_(G)(fa, (i, a) => G.map_(p(i, a), (bb) => (bb ? Just(a) : Nothing())));
-}
+export const WitherableWithIndex: WitherableWithIndexOps = {};
 
-export interface filterWithIndexA<F extends HKT, CF = HKT.None> {
-  <G extends HKT, CG = HKT.None>(G: Applicative<G, CG>): <KF, AF, KG, QG, WG, XG, IG, SG, RG, EG>(
-    p: (i: HKT.IndexFor<F, HKT.OrFix<CF, "K", KF>>, a: AF) => HKT.Kind<G, CG, KG, QG, WG, XG, IG, SG, RG, EG, boolean>,
-  ) => <QF, WF, XF, IF, SF, RF, EF>(
-    fa: HKT.Kind<F, CF, KF, QF, WF, XF, IF, SF, RF, EF, AF>,
-  ) => HKT.Kind<G, CG, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, CF, KF, QF, WF, XF, IF, SF, RF, EF, AF>>;
+/**
+ * @tsplus fluent fncts.Kind witherWithIndex
+ */
+export function witherWithIndex<
+  F extends HKT,
+  G extends HKT,
+  KF,
+  QF,
+  WF,
+  XF,
+  IF,
+  SF,
+  RF,
+  EF,
+  KG,
+  QG,
+  WG,
+  XG,
+  IG,
+  SG,
+  RG,
+  EG,
+  A,
+  B,
+>(
+  wa: HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, A>,
+  f: (k: HKT.IndexFor<F, KF>, a: A) => HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, Maybe<B>>,
+  /** @tsplus auto */
+  F: WitherableWithIndex<F>,
+  /** @tsplus auto */
+  G: Applicative<G>,
+): HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, B>> {
+  return F.witherWithIndex(wa, f);
 }
 
-export function filterWithIndexAF<F extends HKT, CF = HKT.None>(
-  F: WitherableWithIndexMin<F, CF>,
-): filterWithIndexA<F, CF> {
-  return (G) => (p) => (fa) => filterWithIndexAF_(F)(G)(fa, p);
+/**
+ * @tsplus fluent fncts.Kind wiltWithIndex
+ */
+export function wiltWithIndex<
+  F extends HKT,
+  G extends HKT,
+  KF,
+  QF,
+  WF,
+  XF,
+  IF,
+  SF,
+  RF,
+  EF,
+  KG,
+  QG,
+  WG,
+  XG,
+  IG,
+  SG,
+  RG,
+  EG,
+  A,
+  B,
+  B2,
+>(
+  wa: HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, A>,
+  f: (k: HKT.IndexFor<F, KF>, a: A) => HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, Either<B, B2>>,
+  /** @tsplus auto */
+  F: WitherableWithIndex<F>,
+  /** @tsplus auto */ G: Applicative<G>,
+): HKT.Kind<
+  G,
+  KG,
+  QG,
+  WG,
+  XG,
+  IG,
+  SG,
+  RG,
+  EG,
+  readonly [HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, B>, HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, B2>]
+> {
+  return F.wiltWithIndex(wa, f);
+}
+
+export function filterWithIndexA<
+  F extends HKT,
+  G extends HKT,
+  KF,
+  QF,
+  WF,
+  XF,
+  IF,
+  SF,
+  RF,
+  EF,
+  AF,
+  KG,
+  QG,
+  WG,
+  XG,
+  IG,
+  SG,
+  RG,
+  EG,
+>(
+  fa: HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, AF>,
+  p: (i: HKT.IndexFor<F, KF>, a: AF) => HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, boolean>,
+  /** @tsplus auto */ F: WitherableWithIndex<F>,
+  /** @tsplus auto */ G: Applicative<G>,
+): HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, AF>> {
+  return fa.witherWithIndex((i, a) => p(i, a).map((bb) => (bb ? Just(a) : Nothing()), G));
 }

package/_src/typeclass.ts

@@ -17,6 +17,7 @@ export * from "./typeclass/Foldable.js";
 export * from "./typeclass/FoldableWithIndex.js";
 export * from "./typeclass/Functor.js";
 export * from "./typeclass/FunctorWithIndex.js";
+export * from "./typeclass/Guard.js";
 export * from "./typeclass/Has.js";
 export * from "./typeclass/Hash.js";
 export * from "./typeclass/Hashable.js";
@@ -36,3 +37,4 @@ export * from "./typeclass/TraversableWithIndex.js";
 export * from "./typeclass/Witherable.js";
 export * from "./typeclass/WitherableWithIndex.js";
 // codegen:end
+

package/_src/util/predicates.ts

@@ -64,6 +64,10 @@ export function isNumber(value: unknown): value is number {
   return typeof value === "number";
 }
 
+export function isBigInt(value: unknown): value is bigint {
+  return typeof value === "bigint";
+}
+
 export function isByte(n: unknown): n is number {
   return typeof n === "number" && Number.isInteger(n) && n >= 0 && n <= 255;
 }

package/collection/Iterable/api/traverseConc.d.ts

@@ -2,12 +2,14 @@ import { HKT } from "@fncts/typelevel/HKT";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
 import type * as P from "@fncts/base/typeclass";
 /**
- * @tsplus getter fncts.Iterable traverseToConcWithIndex
+ * @tsplus fluent fncts.Iterable traverseToConcWithIndex
  * @tsplus location "@fncts/base/collection/Iterable/api/traverseConc"
  */
-export declare function traverseToConcWithIndex_<A>(ta: Iterable<A>): <G extends HKT, CG>(G: P.Applicative<G, CG>) => <K, Q, W, X, I, S, R, E, B>(f: (i: number, a: A) => HKT.Kind<G, CG, K, Q, W, X, I, S, R, E, B>) => HKT.Kind<G, CG, K, Q, W, X, I, S, R, E, Conc<B>>;
+export declare function traverseToConcWithIndex_<G extends HKT, K, Q, W, X, I, S, R, E, A, B>(ta: Iterable<A>, f: (i: number, a: A) => HKT.Kind<G, K, Q, W, X, I, S, R, E, B>, 
+/** @tsplus auto */ G: P.Applicative<G>): HKT.Kind<G, K, Q, W, X, I, S, R, E, Conc<B>>;
 /**
- * @tsplus getter fncts.Iterable traverseToConc
+ * @tsplus fluent fncts.Iterable traverseToConc
  * @tsplus location "@fncts/base/collection/Iterable/api/traverseConc"
  */
-export declare function traverseToConc_<A>(ta: Iterable<A>): <G extends import("@fncts/typelevel/HKT").HKT, GC>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B>(f: (a: A) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, B>) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, import("../../immutable/Conc").Conc<B>>;
+export declare function traverseToConc_<G extends HKT, K, Q, W, X, I, S, R, E, A, B>(ta: Iterable<A>, f: (a: A) => HKT.Kind<G, K, Q, W, X, I, S, R, E, B>, 
+/** @tsplus auto */ G: P.Applicative<G>): HKT.Kind<G, K, Q, W, X, I, S, R, E, Conc<B>>;

package/collection/Iterable/api.d.ts

@@ -4,7 +4,6 @@ import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Eval } from "@fncts/base/control/Eval/definition";
 import { Either } from "@fncts/base/data/Either/definition";
 import type * as P from "@fncts/base/typeclass";
-import { Iterable } from "@fncts/base/collection/Iterable/definition";
 /**
  * @tsplus fluent fncts.Iterable ap
  * @tsplus location "@fncts/base/collection/Iterable/api"
@@ -91,23 +90,16 @@ export declare function foldLeftWithIndex_<A, B>(fa: Iterable<A>, b: B, f: (i: n
  */
 export declare function foldLeft_<A, B>(self: Iterable<A>, b: B, f: (b: B, a: A) => B): B;
 /**
- * @constrained
- */
-export declare function foldMap_<M>(M: P.Monoid<M>): <A>(self: Iterable<A>, f: (a: A) => M) => M;
-/**
- * @tsplus getter fncts.Iterable foldMap
+ * @tsplus fluent fncts.Iterable foldMap
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-export declare function foldMapSelf<A>(self: Iterable<A>): <M>(M: P.Monoid<M>) => (f: (a: A) => M) => M;
-/**
- * @constrained
- */
-export declare function foldMapWithIndex_<M>(M: P.Monoid<M>): <A>(self: Iterable<A>, f: (i: number, a: A) => M) => M;
+export declare function foldMap_<A, M>(self: Iterable<A>, f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): M;
 /**
- * @tsplus getter fncts.Iterable foldMapWithIndex
+ * @tsplus fluent fncts.Iterable foldMapWithIndex
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-export declare function foldMapWithIndexSelf<A>(self: Iterable<A>): <M>(M: P.Monoid<M>) => (f: (i: number, a: A) => M) => M;
+export declare function foldMapWithIndex_<A, M>(self: Iterable<A>, f: (i: number, a: A) => M, 
+/** @tsplus auto */ M: P.Monoid<M>): M;
 /**
  * @tsplus fluent fncts.Iterable foldRightWithIndex
  * @tsplus location "@fncts/base/collection/Iterable/api"

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

@@ -1,12 +1,13 @@
 import { Conc } from "@fncts/base/collection/immutable/Conc";
-import { These } from "@fncts/base/data/These/definition";
+import { These } from "@fncts/base/data/These";
 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 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 location "@fncts/base/collection/immutable/Conc/api"
@@ -75,10 +76,10 @@ export declare function compact<A>(self: Conc<Maybe<A>>): Conc<A>;
  */
 export declare function concat_<A, B>(self: Conc<A>, that: Conc<B>): Conc<A | B>;
 /**
- * @tsplus getter fncts.Conc elem
+ * @tsplus fluent 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;
+export declare function elem_<A>(self: Conc<A>, a: A, /** @tsplus auto */ E: Eq<A>): boolean;
 /**
  * @tsplus fluent fncts.Conc exists
  * @tsplus location "@fncts/base/collection/immutable/Conc/api"
@@ -144,23 +145,15 @@ export declare function foldLeft_<A, B>(self: Conc<A>, b: B, f: (b: B, a: A) =>
  */
 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 fluent 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;
+export declare function foldMap_<A, M>(fa: Conc<A>, f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): M;
 /**
- * @tsplus getter fncts.Conc foldMapWithIndex
+ * @tsplus fluent 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;
+export declare function foldMapWithIndex_<A, M>(fa: Conc<A>, f: (i: number, a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): M;
 /**
  * @tsplus fluent fncts.Conc foldRight
  * @tsplus location "@fncts/base/collection/immutable/Conc/api"
@@ -216,7 +209,7 @@ export declare function map_<A, B>(self: Conc<A>, f: (a: A) => B): Conc<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];
+export declare function mapAccum_<A, S, B>(self: Conc<A>, s: S, f: (s: S, a: A) => readonly [S, B]): readonly [S, Conc<B>];
 /**
  * @tsplus fluent fncts.Conc mapWithIndex
  * @tsplus location "@fncts/base/collection/immutable/Conc/api"
@@ -295,18 +288,17 @@ export declare function take_<A>(self: Conc<A>, n: number): Conc<A>;
  * @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 fluent 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>;
+export declare const traverse: P.Traversable<ConcF>["traverse"];
 /**
- * @tsplus getter fncts.Conc traverseWithIndex
+ * @tsplus fluent fncts.Conc traverseWithIndex
  * @tsplus location "@fncts/base/collection/immutable/Conc/api"
  */
-export declare const traverseSelfWithIndex: P.traverseWithIndexSelf<ConcF>;
+export declare function traverseWithIndex<G extends HKT, KG, QG, WG, XG, IG, SG, RG, EG, A, B>(self: Conc<A>, f: (i: number, a: A) => HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, B>, 
+/** @tsplus auto */ G: P.Applicative<G>): HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, Conc<B>>;
 /**
  * @tsplus fluent fncts.ConcOps unfold
  * @tsplus location "@fncts/base/collection/immutable/Conc/api"