@fncts/base 0.0.1

package/_src/util/rand/distribution/internals/ArrayInt.ts

@@ -0,0 +1,200 @@
+/**
+ * An ArrayInt represents an integer larger than what can be represented in classical JavaScript.
+ * The values stored in data must be in the range [0, 0xffffffff].
+ *
+ * @example
+ * ```js
+ * { sign:  1, data: [ 42 ] } // = 42
+ * { sign: -1, data: [ 42 ] } // = -42
+ * { sign: -1, data: [ 5, 42 ] } // = -1 * (5 * 2**32 + 42)
+ * { sign: -1, data: [ 1, 5, 42 ] } // = -1 * (1 * 2**64 + 5 * 2**32 + 42)
+ * ```
+ */
+export type ArrayInt = {
+  /**
+   * Sign of the represented number
+   */
+  sign: -1 | 1;
+  /**
+   * Value of the number, must only contain numbers in the range [0, 0xffffffff]
+   */
+  data: number[];
+};
+
+/**
+ * Add two ArrayInt
+ * @internal
+ */
+export function addArrayIntToNew(arrayIntA: ArrayInt, arrayIntB: ArrayInt): ArrayInt {
+  if (arrayIntA.sign !== arrayIntB.sign) {
+    return substractArrayIntToNew(arrayIntA, {
+      sign: -arrayIntB.sign as -1 | 1,
+      data: arrayIntB.data,
+    });
+  }
+  const data   = [];
+  let reminder = 0;
+  const dataA  = arrayIntA.data;
+  const dataB  = arrayIntB.data;
+  for (let indexA = dataA.length - 1, indexB = dataB.length - 1; indexA >= 0 || indexB >= 0; --indexA, --indexB) {
+    const vA      = indexA >= 0 ? dataA[indexA]! : 0;
+    const vB      = indexB >= 0 ? dataB[indexB]! : 0;
+    const current = vA + vB + reminder;
+    data.push(current >>> 0);
+    reminder = ~~(current / 0x100000000);
+  }
+  if (reminder !== 0) {
+    data.push(reminder);
+  }
+  return { sign: arrayIntA.sign, data: data.reverse() };
+}
+
+/**
+ * Add one to a given positive ArrayInt
+ * @internal
+ */
+export function addOneToPositiveArrayInt(arrayInt: ArrayInt): ArrayInt {
+  arrayInt.sign = 1; // handling case { sign: -1, data: [0,...,0] }
+  const data    = arrayInt.data;
+  for (let index = data.length - 1; index >= 0; --index) {
+    if (data[index] === 0xffffffff) {
+      data[index] = 0;
+    } else {
+      data[index] += 1;
+      return arrayInt;
+    }
+  }
+  data.unshift(1);
+  return arrayInt;
+}
+
+/** @internal */
+function isStrictlySmaller(dataA: number[], dataB: number[]): boolean {
+  const maxLength = Math.max(dataA.length, dataB.length);
+  for (let index = 0; index < maxLength; ++index) {
+    const indexA = index + dataA.length - maxLength;
+    const indexB = index + dataB.length - maxLength;
+    const vA     = indexA >= 0 ? dataA[indexA]! : 0;
+    const vB     = indexB >= 0 ? dataB[indexB]! : 0;
+    if (vA < vB) return true;
+    if (vA > vB) return false;
+  }
+  return false;
+}
+
+/**
+ * Substract two ArrayInt
+ * @internal
+ */
+export function substractArrayIntToNew(arrayIntA: ArrayInt, arrayIntB: ArrayInt): ArrayInt {
+  if (arrayIntA.sign !== arrayIntB.sign) {
+    return addArrayIntToNew(arrayIntA, { sign: -arrayIntB.sign as -1 | 1, data: arrayIntB.data });
+  }
+  const dataA = arrayIntA.data;
+  const dataB = arrayIntB.data;
+  if (isStrictlySmaller(dataA, dataB)) {
+    const out = substractArrayIntToNew(arrayIntB, arrayIntA);
+    out.sign  = -out.sign as -1 | 1;
+    return out;
+  }
+  const data   = [];
+  let reminder = 0;
+  for (let indexA = dataA.length - 1, indexB = dataB.length - 1; indexA >= 0 || indexB >= 0; --indexA, --indexB) {
+    const vA      = indexA >= 0 ? dataA[indexA]! : 0;
+    const vB      = indexB >= 0 ? dataB[indexB]! : 0;
+    const current = vA - vB - reminder;
+    data.push(current >>> 0);
+    reminder = current < 0 ? 1 : 0;
+  }
+  return { sign: arrayIntA.sign, data: data.reverse() };
+}
+
+/**
+ * Trim uneeded zeros in ArrayInt
+ * and uniform notation for zero: {sign: 1, data: [0]}
+ */
+export function trimArrayIntInplace(arrayInt: ArrayInt) {
+  const data       = arrayInt.data;
+  let firstNonZero = 0;
+  // eslint-disable-next-line no-empty
+  for (; firstNonZero !== data.length && data[firstNonZero] === 0; ++firstNonZero) {}
+  if (firstNonZero === data.length) {
+    // only zeros
+    arrayInt.sign = 1;
+    arrayInt.data = [0];
+    return arrayInt;
+  }
+  data.splice(0, firstNonZero);
+  return arrayInt;
+}
+
+// Helpers specific to 64 bits versions
+
+/** @internal */
+export type ArrayInt64 = Required<ArrayInt> & { data: [number, number] };
+
+/**
+ * We only accept safe integers here
+ * @internal
+ */
+export function fromNumberToArrayInt64(out: ArrayInt64, n: number): ArrayInt64 {
+  if (n < 0) {
+    const posN  = -n;
+    out.sign    = -1;
+    out.data[0] = ~~(posN / 0x100000000);
+    out.data[1] = posN >>> 0;
+  } else {
+    out.sign    = 1;
+    out.data[0] = ~~(n / 0x100000000);
+    out.data[1] = n >>> 0;
+  }
+  return out;
+}
+
+/**
+ * Substract two ArrayInt of 64 bits on 64 bits.
+ * With arrayIntA - arrayIntB >= 0
+ * @internal
+ */
+export function substractArrayInt64(out: ArrayInt64, arrayIntA: ArrayInt64, arrayIntB: ArrayInt64): ArrayInt64 {
+  const lowA  = arrayIntA.data[1];
+  const highA = arrayIntA.data[0];
+  const signA = arrayIntA.sign;
+  const lowB  = arrayIntB.data[1];
+  const highB = arrayIntB.data[0];
+  const signB = arrayIntB.sign;
+
+  // Requirement: arrayIntA - arrayIntB >= 0
+  out.sign = 1;
+
+  if (signA === 1 && signB === -1) {
+    // Operation is a simple sum of arrayIntA + abs(arrayIntB)
+    const low   = lowA + lowB;
+    const high  = highA + highB + (low > 0xffffffff ? 1 : 0);
+    out.data[0] = high >>> 0;
+    out.data[1] = low >>> 0;
+    return out;
+  }
+  // signA === -1 with signB === 1 is impossible given: arrayIntA - arrayIntB >= 0
+
+  // Operation is a substraction
+  let lowFirst   = lowA;
+  let highFirst  = highA;
+  let lowSecond  = lowB;
+  let highSecond = highB;
+  if (signA === -1) {
+    lowFirst   = lowB;
+    highFirst  = highB;
+    lowSecond  = lowA;
+    highSecond = highA;
+  }
+  let reminderLow = 0;
+  let low         = lowFirst - lowSecond;
+  if (low < 0) {
+    reminderLow = 1;
+    low         = low >>> 0;
+  }
+  out.data[0] = highFirst - highSecond - reminderLow;
+  out.data[1] = low;
+  return out;
+}

package/_src/util/rand/distribution/internals/UniformArrayIntDistributionInternal.ts

@@ -0,0 +1,43 @@
+import type { ArrayInt } from "@fncts/base/util/rand/distribution/internals/ArrayInt";
+import type RandomGenerator from "@fncts/base/util/rand/generator/RandomGenerator";
+
+import { uniformIntDistributionInternal } from "@fncts/base/util/rand/distribution/internals/UniformIntDistributionInternal";
+
+/**
+ * Uniformly generate ArrayInt in range [0 ; rangeSize[
+ *
+ * @remarks
+ * In the worst case scenario it may discard half of the randomly generated value.
+ * Worst case being: most significant number is 1 and remaining part evaluates to 0.
+ *
+ * @internal
+ */
+export function uniformArrayIntDistributionInternal(
+  out: ArrayInt["data"],
+  rangeSize: ArrayInt["data"],
+  rng: RandomGenerator,
+): ArrayInt["data"] {
+  const rangeLength = rangeSize.length;
+
+  // We iterate until we find a valid value for arrayInt
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    // We compute a new value for arrayInt
+    for (let index = 0; index !== rangeLength; ++index) {
+      const indexRangeSize = index === 0 ? rangeSize[0]! + 1 : 0x100000000;
+      out[index]           = uniformIntDistributionInternal(indexRangeSize, rng);
+    }
+
+    // If in the correct range we can return it
+    for (let index = 0; index !== rangeLength; ++index) {
+      const current        = out[index]!;
+      const currentInRange = rangeSize[index]!;
+      if (current < currentInRange) {
+        return out; // arrayInt < rangeSize
+      } else if (current > currentInRange) {
+        break; // arrayInt > rangeSize
+      }
+    }
+    // Otherwise we need to try another one
+  }
+}

package/_src/util/rand/distribution/internals/UniformIntDistributionInternal.ts

@@ -0,0 +1,47 @@
+import type { RandomGenerator } from "@fncts/base/util/rand/generator/RandomGenerator";
+
+/**
+ * Uniformly generate number in range [0 ; rangeSize[
+ * @internal
+ */
+export function uniformIntDistributionInternal(rangeSize: number, rng: RandomGenerator): number {
+  const MinRng    = rng.min();
+  const NumValues = rng.max() - rng.min() + 1;
+
+  // Range provided by the RandomGenerator is large enough
+  if (rangeSize <= NumValues) {
+    const MaxAllowed = NumValues - (NumValues % rangeSize);
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      const out    = rng.next();
+      const deltaV = out - MinRng;
+      if (deltaV < MaxAllowed) {
+        return deltaV % rangeSize; // Warning: we expect NumValues <= 2**32, so diff too
+      }
+    }
+  }
+
+  // Compute number of iterations required to have enough random
+  // to build uniform entries in the asked range
+  let FinalNumValues = NumValues * NumValues;
+  let NumIterations  = 2; // At least 2 (at this point in the code)
+  while (FinalNumValues < rangeSize) {
+    FinalNumValues *= NumValues;
+    ++NumIterations;
+  }
+  const MaxAcceptedRandom = rangeSize * Math.floor((1 * FinalNumValues) / rangeSize);
+
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    // Aggregate mutiple calls to next() into a single random value
+    let value = 0;
+    for (let num = 0; num !== NumIterations; ++num) {
+      const out = rng.next();
+      value     = NumValues * value + (out - MinRng); // Warning: we overflow may when diff > max_safe (eg: =max_safe-min_safe+1)
+    }
+    if (value < MaxAcceptedRandom) {
+      const inDiff = value - rangeSize * Math.floor((1 * value) / rangeSize);
+      return inDiff;
+    }
+  }
+}

package/_src/util/rand/generator/MersenneTwister.ts

@@ -0,0 +1,160 @@
+/* eslint-disable prefer-const */
+/* 
+  Original MT19937 license:
+
+  A C-program for MT19937, with initialization improved 2002/1/26.
+  Coded by Takuji Nishimura and Makoto Matsumoto.
+
+  Before using, initialize the state by using init_genrand(seed)  
+  or init_by_array(init_key, key_length).
+
+  Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
+  All rights reserved.                          
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions
+  are met:
+
+    1. Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+
+    3. The names of its contributors may not be used to endorse or promote 
+      products derived from this software without specific prior written 
+      permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+  Any feedback is very welcome.
+  http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
+  email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)
+*/
+
+import type { RandomGenerator } from "@fncts/base/util/rand/generator/RandomGenerator";
+
+const MAX_INT    = 4294967296.0;
+const N          = 624;
+const M          = 397;
+const UPPER_MASK = 0x80000000;
+const LOWER_MASK = 0x7fffffff;
+const MATRIX_A   = 0x9908b0df;
+
+export class MersenneTwister implements RandomGenerator {
+  private mt: Array<number>;
+  private mti: number;
+
+  constructor(seed?: number) {
+    this.mt  = new Array(N);
+    this.mti = N + 1;
+    this.setSeed(seed ?? Date.now());
+  }
+
+  setSeed(seed: number) {
+    let s: number;
+
+    this.mt[0] = seed >>> 0;
+
+    for (this.mti = 1; this.mti < N; this.mti++) {
+      s                    = this.mt[this.mti - 1]! ^ (this.mt[this.mti - 1]! >>> 30);
+      this.mt[this.mti]    = ((((s & 0xffff0000) >>> 16) * 1812433253) << 16) + (s & 0x0000ffff) * 1812433253 + this.mti;
+      this.mt[this.mti] >>>= 0;
+    }
+  }
+
+  seedArray(vector: ReadonlyArray<number>) {
+    let i = 1,
+      j = 0,
+      k = N > vector.length ? N : vector.length,
+      s: number;
+
+    this.setSeed(19650218);
+
+    for (; k > 0; k--) {
+      s = this.mt[i - 1]! ^ (this.mt[i - 1]! >>> 30);
+
+      this.mt[i] =
+        (this.mt[i]! ^ (((((s & 0xffff0000) >>> 16) * 1664525) << 16) + (s & 0x0000ffff) * 1664525)) + vector[j]! + j;
+      this.mt[i] >>>= 0;
+      i++;
+      j++;
+      if (i >= N) {
+        this.mt[0] = this.mt[N - 1]!;
+        i          = 1;
+      }
+      if (j >= vector.length) {
+        j = 0;
+      }
+    }
+
+    for (k = N - 1; k; k--) {
+      s = this.mt[i - 1]! ^ (this.mt[i - 1]! >>> 30);
+      this.mt[i] =
+        (this.mt[i]! ^ (((((s & 0xffff0000) >>> 16) * 1566083941) << 16) + (s & 0x0000ffff) * 1566083941)) - i;
+      this.mt[i] >>>= 0;
+      i++;
+      if (i >= N) {
+        this.mt[0] = this.mt[N - 1]!;
+        i          = 1;
+      }
+    }
+
+    this.mt[0] = 0x80000000;
+  }
+
+  next() {
+    let y: number,
+      kk: number,
+      mag01: [number, number] = [0, MATRIX_A];
+
+    if (this.mti >= N) {
+      if (this.mti === N + 1) {
+        this.setSeed(5489);
+      }
+
+      for (kk = 0; kk < N - M; kk++) {
+        y           = (this.mt[kk]! & UPPER_MASK) | (this.mt[kk + 1]! & LOWER_MASK);
+        this.mt[kk] = this.mt[kk + M]! ^ (y >>> 1) ^ mag01[y & 1]!;
+      }
+
+      for (; kk < N - 1; kk++) {
+        y           = (this.mt[kk]! & UPPER_MASK) | (this.mt[kk + 1]! & LOWER_MASK);
+        this.mt[kk] = this.mt[kk + (M - N)]! ^ (y >>> 1) ^ mag01[y & 1]!;
+      }
+
+      y              = (this.mt[N - 1]! & UPPER_MASK) | (this.mt[0]! & LOWER_MASK);
+      this.mt[N - 1] = this.mt[M - 1]! ^ (y >>> 1) ^ mag01[y & 1]!;
+      this.mti       = 0;
+    }
+
+    y = this.mt[this.mti++]!;
+
+    y ^= y >>> 11;
+    y ^= (y << 7) & 0x9d2c5680;
+    y ^= (y << 15) & 0xefc60000;
+    y ^= y >>> 18;
+
+    return y >>> 0;
+  }
+
+  min(): number {
+    return 0;
+  }
+
+  max(): number {
+    return 0xffffffff;
+  }
+}

package/_src/util/rand/generator/RandomGenerator.ts

@@ -0,0 +1,22 @@
+export default interface RandomGenerator {
+  setSeed(seed: number): void;
+  next(): number;
+  jump?(): RandomGenerator;
+  min(): number; //inclusive
+  max(): number; //inclusive
+}
+
+function generateN(rng: RandomGenerator, num: number): number[] {
+  const out: number[] = [];
+  for (let idx = 0; idx != num; ++idx) {
+    const nextOut = rng.next();
+    out.push(nextOut);
+  }
+  return out;
+}
+
+function skipN(rng: RandomGenerator, num: number): void {
+  generateN(rng, num);
+}
+
+export { generateN, RandomGenerator, skipN };

package/_src/util/rand.ts

@@ -0,0 +1,20 @@
+import Distribution from "@fncts/base/util/rand/distribution/Distribution";
+import { uniformArrayIntDistribution } from "@fncts/base/util/rand/distribution/UniformArrayIntDistribution";
+import { uniformBigIntDistribution } from "@fncts/base/util/rand/distribution/UniformBigIntDistribution";
+import { uniformIntDistribution } from "@fncts/base/util/rand/distribution/UniformIntDistribution";
+import { MersenneTwister } from "@fncts/base/util/rand/generator/MersenneTwister";
+import { generateN, RandomGenerator, skipN } from "@fncts/base/util/rand/generator/RandomGenerator";
+
+export * from "@fncts/base/util/rand/distribution/internals/ArrayInt";
+export * from "@fncts/base/util/rand/Random";
+
+export {
+  Distribution,
+  generateN,
+  MersenneTwister,
+  RandomGenerator,
+  skipN,
+  uniformArrayIntDistribution,
+  uniformBigIntDistribution,
+  uniformIntDistribution,
+};

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

@@ -0,0 +1,13 @@
+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 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>>;
+/**
+ * @tsplus getter 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>>;

package/collection/Iterable/api.d.ts

@@ -0,0 +1,172 @@
+import { Refinement, RefinementWithIndex } from "@fncts/base/data/Refinement/definition";
+import { Predicate, PredicateWithIndex } from "@fncts/base/data/Predicate/definition";
+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"
+ */
+export declare function ap_<A, B>(self: Iterable<(a: A) => B>, fa: Iterable<A>): Iterable<B>;
+/**
+ * @tsplus fluent fncts.Iterable append
+ * @tsplus location "@fncts/base/collection/Iterable/api"
+ */
+export declare function append_<A, B>(self: Iterable<A>, b: B): Iterable<A | B>;
+/**
+ * @tsplus getter fncts.Iterable asIterable
+ * @tsplus location "@fncts/base/collection/Iterable/api"
+ */
+export declare function asIterable<A>(self: Iterable<A>): Iterable<A>;
+/**
+ * @tsplus fluent fncts.Iterable flatMap
+ * @tsplus location "@fncts/base/collection/Iterable/api"
+ */
+export declare function flatMap_<A, B>(self: Iterable<A>, f: (a: A) => Iterable<B>): Iterable<B>;
+/**
+ * @tsplus fluent fncts.Iterable concat
+ * @tsplus location "@fncts/base/collection/Iterable/api"
+ */
+export declare function concat_<A>(self: Iterable<A>, ib: Iterable<A>): Iterable<A>;
+/**
+ * @tsplus fluent fncts.Iterable corresponds
+ * @tsplus location "@fncts/base/collection/Iterable/api"
+ */
+export declare function corresponds_<A, B>(left: Iterable<A>, right: Iterable<B>, f: (a: A, b: B) => boolean): boolean;
+/**
+ * @tsplus fluent fncts.Iterable crossWith
+ * @tsplus location "@fncts/base/collection/Iterable/api"
+ */
+export declare function crossWith_<A, B, C>(self: Iterable<A>, fb: Iterable<B>, f: (a: A, b: B) => C): Iterable<C>;
+/**
+ * @tsplus fluent fncts.Iterable every
+ * @tsplus location "@fncts/base/collection/Iterable/api"
+ */
+export declare function every_<A, B extends A>(self: Iterable<A>, p: Refinement<A, B>): boolean;
+export declare function every_<A>(self: Iterable<A>, p: Predicate<A>): boolean;
+/**
+ * @tsplus fluent fncts.Iterable everyWithIndex
+ * @tsplus location "@fncts/base/collection/Iterable/api"
+ */
+export declare function everyWithIndex_<A, B extends A>(self: Iterable<A>, p: RefinementWithIndex<number, A, B>): boolean;
+export declare function everyWithIndex_<A>(self: Iterable<A>, p: PredicateWithIndex<number, A>): boolean;
+/**
+ * @tsplus fluent fncts.Iterable filter
+ * @tsplus location "@fncts/base/collection/Iterable/api"
+ */
+export declare function filter_<A, B extends A>(self: Iterable<A>, p: Refinement<A, B>): Iterable<B>;
+export declare function filter_<A>(self: Iterable<A>, p: Predicate<A>): Iterable<A>;
+/**
+ * @tsplus fluent fncts.Iterable filterMap
+ * @tsplus location "@fncts/base/collection/Iterable/api"
+ */
+export declare function filterMap_<A, B>(self: Iterable<A>, f: (a: A) => Maybe<B>): Iterable<B>;
+/**
+ * @tsplus fluent fncts.Iterable filterMapWithIndex
+ * @tsplus location "@fncts/base/collection/Iterable/api"
+ */
+export declare function filterMapWithIndex_<A, B>(self: Iterable<A>, f: (i: number, a: A) => Maybe<B>): Iterable<B>;
+/**
+ * @tsplus fluent fncts.Iterable filterWithIndex
+ * @tsplus location "@fncts/base/collection/Iterable/api"
+ */
+export declare function filterWithIndex_<A, B extends A>(self: Iterable<A>, p: RefinementWithIndex<number, A, B>): Iterable<B>;
+export declare function filterWithIndex_<A>(self: Iterable<A>, p: PredicateWithIndex<number, A>): Iterable<A>;
+/**
+ * @tsplus fluent fncts.Iterable find
+ * @tsplus location "@fncts/base/collection/Iterable/api"
+ */
+export declare function find_<A, B extends A>(ia: Iterable<A>, refinement: Refinement<A, B>): Maybe<B>;
+export declare function find_<A>(ia: Iterable<A>, predicate: Predicate<A>): Maybe<A>;
+/**
+ * @tsplus fluent fncts.Iterable foldLeftWithIndex
+ * @tsplus location "@fncts/base/collection/Iterable/api"
+ */
+export declare function foldLeftWithIndex_<A, B>(fa: Iterable<A>, b: B, f: (i: number, b: B, a: A) => B): B;
+/**
+ * @tsplus fluent fncts.Iterable foldLeft
+ * @tsplus location "@fncts/base/collection/Iterable/api"
+ */
+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 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;
+/**
+ * @tsplus getter 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;
+/**
+ * @tsplus fluent fncts.Iterable foldRightWithIndex
+ * @tsplus location "@fncts/base/collection/Iterable/api"
+ */
+export declare function foldRightWithIndex_<A, B>(self: Iterable<A>, b: Eval<B>, f: (i: number, a: A, b: Eval<B>) => Eval<B>): Eval<B>;
+/**
+ * @tsplus fluent fncts.Iterable foldRight
+ * @tsplus location "@fncts/base/collection/Iterable/api"
+ */
+export declare function foldRight_<A, B>(self: Iterable<A>, b: Eval<B>, f: (a: A, b: Eval<B>) => Eval<B>): Eval<B>;
+/**
+ * @tsplus fluent fncts.Iterable map
+ * @tsplus location "@fncts/base/collection/Iterable/api"
+ */
+export declare function map_<A, B>(self: Iterable<A>, f: (a: A) => B): Iterable<B>;
+/**
+ * @tsplus fluent fncts.Iterable mapWithIndex
+ * @tsplus location "@fncts/base/collection/Iterable/api"
+ */
+export declare function mapWithIndex_<A, B>(self: Iterable<A>, f: (i: number, a: A) => B): Iterable<B>;
+/**
+ * @tsplus fluent fncts.Iterable partitionMap
+ * @tsplus location "@fncts/base/collection/Iterable/api"
+ */
+export declare function partitionMap_<A, B, C>(self: Iterable<A>, f: (a: A) => Either<B, C>): readonly [Iterable<B>, Iterable<C>];
+/**
+ * @tsplus fluent fncts.Iterable partitionMapWithIndex
+ * @tsplus location "@fncts/base/collection/Iterable/api"
+ */
+export declare function partitionMapWithIndex_<A, B, C>(fa: Iterable<A>, f: (i: number, a: A) => Either<B, C>): readonly [Iterable<B>, Iterable<C>];
+/**
+ * @tsplus fluent fncts.Iterable partition
+ * @tsplus location "@fncts/base/collection/Iterable/api"
+ */
+export declare function partition_<A, B extends A>(self: Iterable<A>, p: Refinement<A, B>): readonly [Iterable<A>, Iterable<B>];
+export declare function partition_<A>(self: Iterable<A>, p: Predicate<A>): readonly [Iterable<A>, Iterable<A>];
+/**
+ * @tsplus fluent fncts.Iterable partitionWithIndex
+ * @tsplus location "@fncts/base/collection/Iterable/api"
+ */
+export declare function partitionWithIndex_<A, B extends A>(self: Iterable<A>, p: RefinementWithIndex<number, A, B>): readonly [Iterable<A>, Iterable<B>];
+export declare function partitionWithIndex_<A>(self: Iterable<A>, p: PredicateWithIndex<number, A>): readonly [Iterable<A>, Iterable<A>];
+/**
+ * @tsplus getter fncts.Iterable size
+ * @tsplus location "@fncts/base/collection/Iterable/api"
+ */
+export declare function size<A>(self: Iterable<A>): number;
+/**
+ * @tsplus fluent fncts.Iterable take
+ * @tsplus location "@fncts/base/collection/Iterable/api"
+ */
+export declare function take<A>(self: Iterable<A>, n: number): Iterable<A>;
+/**
+ * @tsplus fluent fncts.Iterable zipWith
+ * @tsplus location "@fncts/base/collection/Iterable/api"
+ */
+export declare function zipWith_<A, B, C>(self: Iterable<A>, fb: Iterable<B>, f: (a: A, b: B) => C): Iterable<C>;
+/**
+ * @tsplus getter fncts.Iterable zipWithIndex
+ * @tsplus location "@fncts/base/collection/Iterable/api"
+ */
+export declare function zipWithIndex<A>(self: Iterable<A>): Iterable<readonly [number, A]>;