test.js

const Test = require('thunk-test')
const assert = require('assert')
const stream = require('stream')
const path = require('path')
const fs = require('fs')
const { Readable, Writable } = require('stream')
const util = require('util')
const Transducer = require('./Transducer')
const rubico = require('./rubico')
const isDeepEqual = require('./x/isDeepEqual')
const mapFrom = require('./_internal/mapFrom')
const sha256 = require('./_internal/sha256')

const {
  pipe, compose, tap,
  tryCatch, switchCase,
  all, assign, get, set, pick, omit,
  map, filter, flatMap, forEach, reduce, transform,
  some, every, and, or, not,
  eq, gt, lt, gte, lte,
  thunkify, always,
  curry, __,
} = rubico

const objectProto = Object.prototype

const symbolAsyncIterator = Symbol.asyncIterator

const nativeObjectToString = objectProto.toString

const objectToString = x => nativeObjectToString.call(x)

const ase = assert.strictEqual

const ade = assert.deepEqual

const aok = assert.ok

const sleep = ms => new Promise(resolve => { setTimeout(resolve, ms) })

const hi = x => `${x}hi`

const ho = x => `${x}ho`

const isOdd = x => (x % 2 === 1)

const square = x => x ** 2

const arrayOf = (getter, length) => Array.from(
  { length },
  typeof getter === 'function' ? getter : () => getter,
)

const async = func => async function asyncFunc(...args) {
  return func(...args)
}

const delay = (func, ms) => async function delayed(...args) {
  await new Promise(resolve => setTimeout(resolve, ms))
  return func(...args)
}

const asyncIsEven = x => new Promise(resolve => {
  setImmediate(() => resolve(x % 2 === 0))
})

const asyncHey = x => new Promise(resolve => {
  setImmediate(() => resolve(`${x}hey`))
})

const asyncMult = (y, xi) => new Promise(resolve => {
  setImmediate(() => resolve(y * xi))
})

const constructReadStream = iterable => {
  const y = new stream.Readable({ objectMode: true })
  y._read = () => {}
  for (const x of iterable) y.push(x)
  y.push(null)
  return y
}

const readStreamToArray = readStream => new Promise((resolve, reject) => {
  let result = ''
  readStream.on('data', chunk => (result += chunk))
  readStream.on('end', () => resolve(result))
  readStream.on('error', reject)
})

const consumeReadStreamPush = s => new Promise((resolve, reject) => {
  let y = ''
  s.on('data', chunk => { y += chunk })
  s.on('end', () => resolve(y))
  s.on('error', err => reject(err))
})

const consumeReadStreamPull = s => new Promise((resolve, reject) => {
  let y = ''
  s.on('readable', () => {
    let chunk = s.read()
    while (chunk != null) {
      y += `${chunk}`
      chunk = s.read()
    }
  })
  s.on('end', () => resolve(y))
  s.on('error', err => reject(err))
})

const makeNumbers = function*() {
  for (let i = 0; i < 5; i++) yield i + 1
}

const makeAsyncNumbers = async function*() {
  for (let i = 0; i < 5; i++) yield i + 1
}

const iteratorToArray = x => {
  let isAsync = false
  const y = []
  for (const xi of x) {
    if (xi instanceof Promise) isAsync = true
    y.push(xi)
  }
  return isAsync ? Promise.all(y) : y
}

const asyncIteratorToArray = async x => {
  const y = []
  for await (const xi of x) y.push(xi)
  return y
}

const typedArrayConstructors = [
  Uint8ClampedArray,
  Uint8Array, Int8Array,
  Uint16Array, Int16Array,
  Uint32Array, Int32Array,
  Float32Array, Float64Array,
  BigUint64Array, BigInt64Array,
]

const numberTypedArrayConstructors = [
  Uint8ClampedArray,
  Uint8Array, Int8Array,
  Uint16Array, Int16Array,
  Uint32Array, Int32Array,
  Float32Array, Float64Array,
]

const bigIntTypedArrayConstructors = [
  BigUint64Array, BigInt64Array,
]

const AssertionError = function (message) {
  this.message = message
  this.stack = new Error().stack
}

/* Assertion.test(reduce(add, 0), {
  args: { 0: [1, 2, 3, 4, 5] },
  result: 15,
}) */

const prettify = value => JSON.stringify(value, null, 2)

const Assertion = (func, result, ...args) => async function test() {
  const evaluatedResult = await func(...args)
  if (isDeepEqual(result, evaluatedResult)) {
    return undefined
  }
  throw new AssertionError(`
${func.toString()}

args - ${prettify(args)}

expected - ${prettify(result)}

actual - ${prettify(evaluatedResult)}
`)
}

const binaryToReadableStream = function (binary) {
  return new Readable({
    read() {
      this.push(binary)
      this.push(null)
    },
  })
}

const arrayToObjectReadableStream = function (array) {
  return new Readable({
    objectMode: true,
    read() {
      for (const item of array) {
        this.push(item)
      }
      this.push(null)
    },
  })
}

const MockWritable = function (array = []) {
  Writable.call(this)
  this.array = array
  this.handlers = new Map()
}

MockWritable.prototype = {
  write(chunk, encoding, callback) {
    this.array.push(chunk)
  },
  on(eventName, handler) {
    if (this.handlers.has(eventName)) {
      this.handlers.get(eventName).push(handler)
    } else {
      this.handlers.set(eventName, [handler])
    }
  },
  once(eventName, handler) {
    this.handlers.set(eventName, [handler])
  },
  emit(eventName, ...args) {
    if (!this.handlers.has(eventName)) {
      return undefined
    }
    return this.handlers.get(eventName).map(handler => handler(...args))
  }
}

const MockDuplexStream = function (values) {
  MockWritable.call(this)
  this.values = [...values]
}

MockDuplexStream.prototype = {
  ...MockWritable.prototype,
  async* [symbolAsyncIterator]() {
    for (const item of this.values) {
      yield item
    }
  },
}

const AsyncMockFoldable = function (values) {
  this.values = values
}

AsyncMockFoldable.prototype = {
  async reduce(reducer, init) {
    return this.values.reduce(reducer, init)
  },
}

const MockFoldable = function (values) {
  this.values = values
}

MockFoldable.prototype = {
  reduce(reducer, init) {
    return this.values.reduce(reducer, init)
  },
}

describe('rubico', () => {
  describe('pipe', () => {
    it('behaves eagerly when passed any amount of arguments before the array of functions', async () => {
      const array = pipe(1, 2, 3, [
        Array.of,
        numbers => numbers.map(number => number * 3),
      ])
      assert.deepEqual(array, [3, 6, 9])
    })
    it('behaves eagerly and resolves any amount of Promise arguments before the array of functions', async () => {
      const array = await pipe(Promise.resolve(1), 2, Promise.resolve(3), [
        Array.of,
        numbers => numbers.map(number => number * 3),
      ])
      assert.deepEqual(array, [3, 6, 9])
    })
    it('chains async and regular functions together', async () => {
      ase(await pipe([hi, ho, asyncHey])('yo'), 'yohihohey')
    })
    it('does something without arguments', async () => {
      ase(await pipe([hi, ho, asyncHey])(), 'undefinedhihohey')
    })
    it('chaining one fn is the same as just calling that fn', async () => {
      ase(await pipe([asyncHey])('yo'), await asyncHey('yo'))
    })
    it('returns the raw value (no promise required) if all functions are sync', async () => {
      ase(pipe([hi, hi, hi])('yo'), 'yohihihi')
    })
    it('returns a promise if any fns async', async () => {
      aok(pipe([hi, hi, hi, asyncHey])('yo') instanceof Promise)
    })
    it('pipe(Array<GeneratorFunction>)(Generator)', async () => {
      const numbersGen = function* () {
        yield 1; yield 2; yield 3; yield 4; yield 5
      }
      const isOddGen = function* (iter) {
        for (const item of iter) {
          if (item % 2 == 1) yield item
        }
      }
      const squareGen = function* (iter) {
        for (const item of iter) {
          yield item ** 2
        }
      }
      const iter = pipe([isOddGen, squareGen])(numbersGen())
      const arr = [...iter]
      assert.deepEqual(arr, [1, 9, 25])
    })
    it('pipe(Array<AsyncGeneratorFunction>)(AsyncGenerator)', async () => {
      const asyncNumbersGen = async function* () {
        yield 1; yield 2; yield 3; yield 4; yield 5
      }
      const isOddGen = async function* (iter) {
        for await (const item of iter) {
          if (item % 2 == 1) yield item
        }
      }
      const squareGen = async function* (iter) {
        for await (const item of iter) {
          yield item ** 2
        }
      }
      const iter = pipe([isOddGen, squareGen])(asyncNumbersGen())
      const arr = []
      for await (const item of iter) arr.push(item)
      assert.deepEqual(arr, [1, 9, 25])
    })
    it('throws a TypeError if first argument not an array', async () => {
      assert.throws(
        () => {
          pipe(() => 1, undefined, () => 2)()
        },
        new TypeError('funcs.reduce is not a function')
      )
    })
    it('throws a TypeError if passed less than one function', async () => {
      assert.throws(
        () => pipe([])(),
        new TypeError('Reduce of empty array with no initial value'),
      )
    })
    it('throws a TypeError if any arguments are not a function', async () => {
      assert.throws(
        () => {
          pipe([() => 1, undefined, () => 2])()
        },
        new TypeError('funcB is not a function'),
      )
    })
    it('handles sync errors', async () => {
      assert.throws(
        () => pipe([hi, hi, x => { throw new Error(`throwing ${x}`) }])('yo'),
        new Error('throwing yohihi'),
      )
    })
    it('handles async errors', async () => {
      assert.rejects(
        () => pipe([hi, asyncHey, x => { throw new Error(`throwing ${x}`) }])('yo'),
        new Error('throwing yohihey'),
      )
    })
  })

  describe('compose', () => {
    it('chains functions in reverse', async () => {
      ade(
        compose([1, 2, 3, 4, 5], [
          map(number => number ** 2),
          map(number => number + 2),
          filter(number => number % 2 == 1)
        ]),
        [9, 25, 49],
      )

      ade(
        compose([
          map(number => number ** 2),
          map(number => number + 2),
          filter(number => number % 2 == 1)
        ])([1, 2, 3, 4, 5]),
        [9, 25, 49],
      )

      ade(
        await compose([
          map(async number => number ** 2),
          map(number => number + 2),
          filter(async number => number % 2 == 1)
        ])([1, 2, 3, 4, 5]),
        [9, 25, 49],
      )

      ade(
        await compose(Promise.resolve([1, 2, 3, 4, 5]), [
          map(number => number ** 2),
          map(number => number + 2),
          filter(number => number % 2 == 1)
        ]),
        [9, 25, 49],
      )
    })
  })

  describe('all', () => {
    it('API coverage', async () => {
      ade(
        all(1, 2, 3, [
          Array.of,
          Array.of,
          Array.of,
        ]),
        [
          [1, 2, 3],
          [1, 2, 3],
          [1, 2, 3],
        ],
      )

      ade(
        all([
          Array.of,
          Array.of,
          Array.of,
        ])(1, 2, 3),
        [
          [1, 2, 3],
          [1, 2, 3],
          [1, 2, 3],
        ],
      )

      ade(
        all([
          Array.of,
          Array.of,
          Array.of,
          4,
        ])(1, 2, 3),
        [
          [1, 2, 3],
          [1, 2, 3],
          [1, 2, 3],
          4,
        ],
      )

      ade(
        await all(Promise.resolve(1), 2, Promise.resolve(3), [
          Array.of,
          Array.of,
          Array.of,
        ]),
        [
          [1, 2, 3],
          [1, 2, 3],
          [1, 2, 3],
        ],
      )

      ade(
        all(1, 2, 3, {
          a: Array.of,
          b: Array.of,
          c: Array.of,
        }),
        {
          a: [1, 2, 3],
          b: [1, 2, 3],
          c: [1, 2, 3],
        },
      )

      ade(
        all({
          a: Array.of,
          b: Array.of,
          c: Array.of,
        })(1, 2, 3),
        {
          a: [1, 2, 3],
          b: [1, 2, 3],
          c: [1, 2, 3],
        },
      )

      ade(
        await all(Promise.resolve(1), 2, Promise.resolve(3), {
          a: Array.of,
          b: Array.of,
          c: Array.of,
        }),
        {
          a: [1, 2, 3],
          b: [1, 2, 3],
          c: [1, 2, 3],
        },
      )

      ade(
        all({
          a: Array.of,
          b: Array.of,
          c: Array.of,
          d: 4,
        })(1, 2, 3),
        {
          a: [1, 2, 3],
          b: [1, 2, 3],
          c: [1, 2, 3],
          d: 4,
        },
      )
    })
    it('maps input to array of sync functions', async () => {
      ade(all([hi, hi, hi])('hi'), ['hihi', 'hihi', 'hihi'])
    })
    it('maps input to object of sync functions', async () => {
      ade(
        all({ a: hi, b: hi, c: hi })('hi'),
        { a: 'hihi', b: 'hihi', c: 'hihi' },
      )
    })
    it('maps input to array of async functions', async () => {
      aok(all([asyncHey, asyncHey, asyncHey])('hi') instanceof Promise)
      ade(
        await all([asyncHey, asyncHey, asyncHey])('hey'),
        ['heyhey', 'heyhey', 'heyhey'],
      )
    })
    it('maps input to object of async functions', async () => {
      aok(all({ a: asyncHey, b: asyncHey, c: asyncHey })('yo') instanceof Promise)
      ade(
        await all({ a: asyncHey, b: asyncHey, c: asyncHey })('hey'),
        { a: 'heyhey', b: 'heyhey', c: 'heyhey' },
      )
    })
    it('any functions async => Promise', async () => {
      aok(all([asyncHey, asyncHey, hi])('1') instanceof Promise)
      ade(
        await all([asyncHey, asyncHey, hi])('1'),
        ['1hey', '1hey', '1hi'],
      )
    })
    it('only nonfunctions', async () => {
      ade(all([1, 2, 3]), [1, 2, 3])
      ade(await all(Promise.resolve([Promise.resolve(1), 2, 3])), [1, 2, 3])
      ade(await all([Promise.resolve(1), Promise.resolve(2), 3]), [1, 2, 3])
      ade(all([]), [])
      ade(all({ a: 1, b: 2, c: 3 }), { a: 1, b: 2, c: 3 })
      ade(await all(Promise.resolve({
        a: Promise.resolve(1),
        b: 2,
        c: 3,
      })), { a: 1, b: 2, c: 3 })
      ade(await all({
        a: Promise.resolve(1),
        b: Promise.resolve(2),
        c: 3,
      }), { a: 1, b: 2, c: 3 })
      ade(all({}), {})
    })
  })

  describe('all.series', () => {
    it('API coverage', async () => {
      ade(
        all.series(1, 2, 3, [
          Array.of,
          Array.of,
          Array.of,
        ]),
        [
          [1, 2, 3],
          [1, 2, 3],
          [1, 2, 3],
        ],
      )

      ade(
        all.series([
          Array.of,
          Array.of,
          Array.of,
        ])(1, 2, 3),
        [
          [1, 2, 3],
          [1, 2, 3],
          [1, 2, 3],
        ],
      )

      ade(
        await all.series(Promise.resolve(1), 2, Promise.resolve(3), [
          Array.of,
          Array.of,
          Array.of,
        ]),
        [
          [1, 2, 3],
          [1, 2, 3],
          [1, 2, 3],
        ],
      )
    })

    it('evaluates input against array of functions in series (sync)', async () => {
      const arr = []
      ade(
        all.series([
          () => { arr.push(1); return 'a' },
          () => { arr.push(2); return 'b' },
          () => { arr.push(3); return 'c' },
        ])(),
        ['a', 'b', 'c']
      )
      ade(arr, [1, 2, 3])
    })
    it('evaluates input against array of functions in series (async)', async () => {
      const arr = []
      const staggeredPush = all.series([
        () => sleep(10).then(() => { arr.push(1); return 'a' }),
        () => sleep(5).then(() => { arr.push(2); return 'b' }),
        () => { arr.push(3); return 'c' },
      ])()
      aok(staggeredPush instanceof Promise)
      ade(await staggeredPush, ['a', 'b', 'c'])
      ade(arr, [1, 2, 3])
      const arr2 = []
      const parallelPush = all([
        () => sleep(10).then(() => { arr2.push(1); return 'a' }),
        () => sleep(5).then(() => { arr2.push(2); return 'b' }),
        () => { arr2.push(3); return 'c' },
      ])()
      aok(parallelPush instanceof Promise)
      ade(await parallelPush, ['a', 'b', 'c'])
      ade(arr2, [3, 2, 1])
    })
    it('throws TypeError for all([])', async () => {
      assert.deepEqual(all.series([])(), [])
    })
    it('throws TypeError for all([nonFunction])', async () => {
      assert.throws(
        () => all.series(['hey'])(),
        new TypeError('funcs[funcsIndex] is not a function')
      )
    })
  })

  describe('assign', () => {
    it('API coverage', async () => {
      ade(await assign({}, {
        a: () => 1,
        b: () => 2,
        c: () => 3,
        e: 4,
        f: Promise.resolve(5),
      }), { a: 1, b: 2, c: 3, e: 4, f: 5 })

      ade(assign({
        a: () => 1,
        b: () => 2,
        c: () => 3,
      })({}), { a: 1, b: 2, c: 3 })

      ade(await assign(Promise.resolve({}), {
        a: () => 1,
        b: () => 2,
        c: () => 3,
      }), { a: 1, b: 2, c: 3 })
    })
    it('maps input to object of sync functions then merges', async () => {
      ade(
        assign({
          b: x => `${x.a}yo`,
          c: x => `${x.a}yaya`,
        })({ a: 'a' }),
        { a: 'a', b: 'ayo', c: 'ayaya' },
      )
    })
    it('maps input to object of async functions then merges', async () => {
      aok(assign({
        b: async x => `${x.a}yo`,
        c: async x => `${x.a}yaya`,
      })({ a: 'a' }) instanceof Promise)
      ade(
        await assign({
          b: async x => `${x.a}yo`,
          c: async x => `${x.a}yaya`,
        })({ a: 'a' }),
        { a: 'a', b: 'ayo', c: 'ayaya' },
      )
    })
    it('assign(Set)(nonObject) -> {}', async () => {
      assert.deepEqual(assign(new Set(['hey']))(), {})
    })
    it('assign(...)(string) -> { 0: s, 1: t, ... }', async () => {
      assert.deepEqual(
        assign({ a: value => value })('hi'),
        { '0': 'h', '1': 'i', a: 'hi' },
      )
    })
  })

  describe('tap', () => {
    it('[sync] calls a provided function with input, returning input', async () => {
      ase(tap(x => x + 1)(1), 1)
    })
    it('[async] calls a provided function with input, returning input', async () => {
      aok(tap(async x => x + 1)(1) instanceof Promise)
      ase(await tap(async x => x + 1)(1), 1)
    })
    it('Promise arguments', async () => {
      const arr = []
      await tap(Promise.resolve(1), Promise.resolve(2), 3, (a, b, c) => {
        arr.push(a, b, c)
      })
      assert.deepEqual(arr, [1, 2, 3])
    })
    it('multiple arguments', async () => {
      const array = []
      const point = tap((...args) => (array.push(...args)))(1, 2, 3, 4, 5)
      assert.strictEqual(point, 1)
      assert.deepEqual(array, [1, 2, 3, 4, 5])
    })
    it('eager API', async () => {
      let val = null
      tap('a', 'b', 'c', (...args) => {
        val = args
      })
      assert.deepEqual(val, ['a', 'b', 'c'])
    })
  })

  describe('tap.if', () => {
    describe('tap.if(condition, f); conditional tap; only calls fn on truthy condition', () => {
      it('sync', async () => {
        const isOdd = x => x % 2 === 1
        const oddNumbers = []
        const pushOddNumbers = number => oddNumbers.push(number)
        const numbers = [1, 2, 3, 4, 5]
        numbers.forEach(number => {
          assert.strictEqual(tap.if(isOdd, pushOddNumbers)(number), number)
        })
        assert.deepEqual(oddNumbers, [1, 3, 5])

        tap.if(7, isOdd, pushOddNumbers)
        assert.deepEqual(oddNumbers, [1, 3, 5, 7])

        await tap.if(Promise.resolve(9), isOdd, pushOddNumbers)
        assert.deepEqual(oddNumbers, [1, 3, 5, 7, 9])
      })
      it('async', async () => {
        const isOdd = x => x % 2 === 1
        const oddNumbers = []
        const pushOddNumbers = number => oddNumbers.push(number)
        const numbers = [1, 2, 3, 4, 5]
        for (const number of numbers) {
          assert.strictEqual(await tap.if(async(isOdd), pushOddNumbers)(number), number)
        }
        assert.deepEqual(oddNumbers, [1, 3, 5])
        for (const number of numbers) {
          assert.strictEqual(await tap.if(isOdd, delay(pushOddNumbers, 10))(number), number)
        }
        assert.deepEqual(oddNumbers, [1, 3, 5, 1, 3, 5])
      })
    })
  })

  describe('tryCatch', () => {
    it('behaves eagerly when supplied any amount of arguments before the tryer and catcher', async () => {
      const add = (a, b) => a + b

      let sum = null

      tryCatch(1, 2, 3, function throwSum(...numbers) {
        const sum = numbers.reduce(add)
        throw new Error(`${sum}`)
      }, function logErrorMessage(error) {
        sum = Number(error.message)
      })

      assert.equal(sum, 6)
    })

    it('behaves eagerly when supplied any amount of Promise arguments before the tryer and catcher', async () => {
      const add = (a, b) => a + b

      let sum = null

      await tryCatch(Promise.resolve(1), 2, Promise.resolve(3), function throwSum(...numbers) {
        const sum = numbers.reduce(add)
        throw new Error(`${sum}`)
      }, function logErrorMessage(error) {
        sum = Number(error.message)
      })

      assert.equal(sum, 6)
    })

    it('async eager tryCatch', async () => {
      const add = (a, b) => a + b

      let sum = null

      await tryCatch(1, 2, 3, async function throwSum(...numbers) {
        const sum = numbers.reduce(add)
        throw new Error(`${sum}`)
      }, async function logErrorMessage(error) {
        sum = Number(error.message)
      })

      assert.equal(sum, 6)
    })

    it('tries a sync function and catches with a sync function', async () => {
      const errProp = (err, x) => { err.x = x; return err }
      const throwError = x => { throw new Error(x) }
      ase(tryCatch(x => x + 1, errProp)(1), 2)
      const e1 = tryCatch(throwError, errProp)(1)
      aok(e1 instanceof Error)
      ase(e1.name, 'Error')
      ase(e1.message, '1')
      ase(e1.x, 1)
    })

    it('tries an async function and catches with a sync function', async () => {
      const errProp = (err, x) => { err.x = x; return err }
      const asyncThrowError = async x => { throw new Error(x) }
      const reject = x => Promise.reject(new Error(x))
      aok(tryCatch(async x => x + 1, errProp)(1) instanceof Promise)
      ase(await tryCatch(async x => x + 1, errProp)(1), 2)
      aok(tryCatch(asyncThrowError, errProp)(1) instanceof Promise)
      const e1 = await tryCatch(asyncThrowError, errProp)(1)
      aok(e1 instanceof Error)
      ase(e1.name, 'Error')
      ase(e1.message, '1')
      ase(e1.x, 1)
      aok(tryCatch(reject, errProp)(1) instanceof Promise)
      const e2 = await tryCatch(reject, errProp)(1)
      aok(e2 instanceof Error)
      ase(e2.name, 'Error')
      ase(e2.message, '1')
      ase(e2.x, 1)
    })
    it('tries a sync function and catches with an async function', async () => {
      const asyncErrProp = async (err, x) => { err.x = x; return err }
      const throwError = x => { throw new Error(x) }
      ase(tryCatch(x => x + 1, asyncErrProp)(1), 2)
      aok(tryCatch(throwError, asyncErrProp)(1) instanceof Promise)
      const e1 = await tryCatch(throwError, asyncErrProp)(1)
      aok(e1 instanceof Error)
      ase(e1.name, 'Error')
      ase(e1.message, '1')
      ase(e1.x, 1)
    })
    it('tries an async function and catches with an async function', async () => {
      const asyncErrProp = async (err, x) => { err.x = x; return err }
      const asyncThrowError = async x => { throw new Error(x) }
      const reject = x => Promise.reject(new Error(x))
      aok(tryCatch(async x => x + 1, asyncErrProp)(1) instanceof Promise)
      ase(await tryCatch(async x => x + 1, asyncErrProp)(1), 2)
      aok(tryCatch(asyncThrowError, asyncErrProp)(1) instanceof Promise)
      const e1 = await tryCatch(asyncThrowError, asyncErrProp)(1)
      aok(e1 instanceof Error)
      ase(e1.name, 'Error')
      ase(e1.message, '1')
      ase(e1.x, 1)
      aok(tryCatch(reject, asyncErrProp)(1) instanceof Promise)
      const e2 = await tryCatch(reject, asyncErrProp)(1)
      aok(e2 instanceof Error)
      ase(e2.name, 'Error')
      ase(e2.message, '1')
      ase(e2.x, 1)
    })
    it('throws a TypeError if passed a non function tryer', async () => {
      assert.deepEqual(
        tryCatch('hey', (...args) => args)('sup'),
        [new TypeError('tryer is not a function'), 'sup'],
      )
    })
    it('won\'t enforce the catcher function typecheck', async () => {
      assert.deepEqual(
        tryCatch(() => 'ayo', Buffer.from('abc'))('hey'),
        'ayo',
      )
    })
  })

  describe('switchCase', () => {
    it('API coverage', async () => {
      ase(
        switchCase(1, [
          x => x === 1, () => 'hi',
          x => x === 2, () => 'ho',
          () => 'hey',
        ]),
        'hi',
      )

      ase(
        await switchCase(Promise.resolve(1), [
          x => x === 1, () => 'hi',
          x => x === 2, () => 'ho',
          () => 'hey',
        ]),
        'hi',
      )
    })
    it('switches on values (including Promises), evaluating eagerly', async () => {
      ase(switchCase([true, 'hey', 'ho']), 'hey')
      ase(await switchCase([
        Promise.resolve(true),
        Promise.resolve('hey'),
        'ho',
      ]), 'hey')
      ase(await switchCase([
        true,
        Promise.resolve('hey'),
        'ho',
      ]), 'hey')
      ase(await switchCase([
        false,
        Promise.resolve('hey'),
        'ho',
      ]), 'ho')
      ase(await switchCase([
        false,
        Promise.resolve('hey'),
        Promise.resolve('ho'),
      ]), 'ho')
      ase(switchCase([false, 'hey', false, 'ho', 'default']), 'default')
      ase(switchCase([false, 'hey', false, 'hey', true, 'ho']), 'ho')
      ase(switchCase([false, 'hey', false, 'hey', false, 'ho']), undefined)
    })
    it('defaults with undefined for an even number of cases', async () => {
      ase(switchCase([false, 'hey', false, 'hey', false, 'hey']), undefined)
    })
    it('switches on provided sync functions', async () => {
      ase(
        switchCase([
          x => x === 1, () => 'hi',
          x => x === 2, () => 'ho',
          () => 'hey',
        ])(1),
        'hi',
      )
      ase(
        switchCase([
          x => x === 1, () => 'hi',
          x => x === 2, () => 'ho',
          () => 'hey',
        ])(2),
        'ho',
      )
      ase(
        switchCase([
          x => x === 1, () => 'hi',
          x => x === 2, () => 'ho',
          () => 'hey',
        ])(3),
        'hey',
      )
      ase(
        switchCase([
          x => x === 1, async () => 'hi',
          x => x === 2, async () => 'ho',
          () => 'hey',
        ])(3),
        'hey',
      )
    })
    it('switches on provided async functions or values', async () => {
      aok(
        switchCase([
          async x => x === 1, async () => 'hi',
          async x => x === 2, async () => 'ho',
          async () => 'hey',
        ])(1) instanceof Promise,
      )
      aok(
        switchCase([
          async x => x === 1, () => 'hi',
          x => x === 2, () => 'ho',
          () => 'hey',
        ])(1) instanceof Promise,
      )
      ase(
        await switchCase([
          async x => x === 1, async () => 'hi',
          async x => x === 2, async () => 'ho',
          async () => 'hey',
        ])(1),
        'hi',
      )
      ase(
        await switchCase([
          async x => x === 1, 'hi',
          async x => x === 2, async () => 'ho',
          async () => 'hey',
        ])(1),
        'hi',
      )
      ase(
        await switchCase([
          async x => x === 1, async () => 'hi',
          async x => x === 2, async () => 'ho',
          async () => 'hey',
        ])(2),
        'ho',
      )
      ase(
        await switchCase([
          async x => x === 1, async () => 'hi',
          async x => x === 2, async () => 'ho',
          async () => 'hey',
        ])(3),
        'hey',
      )
    })
    it('undefined for empty array', async () => {
      ase(switchCase([]), undefined)
    })
    it('acts as identity for a single case', async () => {
      assert.strictEqual(switchCase([() => false])(), false)
    })
    it('even number of array items default returns undefined', async () => {
      assert.strictEqual(switchCase([() => true, () => 'hey'])(), 'hey')
      assert.strictEqual(switchCase([() => false, () => 'hey'])(), undefined)
      assert.strictEqual(switchCase([
        () => false, 'hey',
        false, 'hey',
        false, 'hey',
      ])(), undefined)
    })
  })

  describe('map', () => {
    it('API coverage', async () => {
      const myArray = [1, 2, 3]
      assert.deepEqual(
        map(myArray, number => number ** 2),
        [1, 4, 9]
      )
      assert.deepEqual(
        await map(Promise.resolve(myArray), number => number ** 2),
        [1, 4, 9]
      )
    })

    it('Test', Test('map', map(number => number ** 2))
      .case(Promise.resolve(1), 1)
      .case(Promise.resolve(2), 4)
      .case(Promise.resolve(3), 9)
    )

    describe('map(func A=>Promise|B)(Array<A>) -> Promise|Array<B>', () => {
      it('func A=>B; B', async () => {
        assert.deepEqual(
          map(number => number ** 2)([1, 2, 3, 4, 5]),
          [1, 4, 9, 16, 25],
        )
      })
      it('func A=>Promise<B>; Promise<B>', async () => {
        assert.deepEqual(
          await map(async number => number ** 2)([1, 2, 3, 4, 5]),
          [1, 4, 9, 16, 25],
        )
      })
    })

    describe('map(func A=>Promise|B)(Set<A>) -> Promise|Set<B>', () => {
      it('func A=>B; B', async () => {
        assert.deepEqual(
          map(number => number ** 2)(new Set([1, 2, 3, 4, 5])),
          new Set([1, 4, 9, 16, 25]),
        )
      })
      it('func A=>Promise<B>; Promise<B>', async () => {
        assert.deepEqual(
          await map(async number => number ** 2)(new Set([1, 2, 3, 4, 5])),
          new Set([1, 4, 9, 16, 25]),
        )
      })
    })

    describe('map(func A=>Promise|B)(Map<any, A>) -> Promise|Map<any, B>', () => {
      it('func A=>B; B', async () => {
        assert.deepEqual(
          map(number => number ** 2)(new Map([['a', 1], ['b', 2], ['c', 3], ['d', 4], ['e', 5]])),
          new Map([['a', 1], ['b', 4], ['c', 9], ['d', 16], ['e', 25]]),
        )
      })
      it('func A=>Promise<B>; Promise<B>', async () => {
        assert.deepEqual(
          await map(async number => number ** 2)(new Map([['a', 1], ['b', 2], ['c', 3], ['d', 4], ['e', 5]])),
          new Map([['a', 1], ['b', 4], ['c', 9], ['d', 16], ['e', 25]]),
        )
      })
    })

    describe('map(func A=>Promise|B)(String<A>) -> Promise|String<B>', () => {
      it('func A=>B; B', async () => {
        assert.deepEqual(
          map(number => number ** 2)('12345'),
          '1491625',
        )
      })
      it('func A=>Promise<B>; Promise<B>', async () => {
        assert.deepEqual(
          await map(async number => number ** 2)('12345'),
          '1491625',
        )
      })
    })

    describe('map(func A=>Promise|B)(Object<A>) -> Promise|Object<B>', () => {
      it('func A=>B; B', async () => {
        assert.deepEqual(
          map(number => number ** 2)({ a: 1, b: 2, c: 3, d: 4, e: 5 }),
          { a: 1, b: 4, c: 9, d: 16, e: 25 },
        )
      })
      it('func A=>Promise<B>; Promise<B>', async () => {
        assert.deepEqual(
          await map(async number => number ** 2)({ a: 1, b: 2, c: 3, d: 4, e: 5 }),
          { a: 1, b: 4, c: 9, d: 16, e: 25 },
        )
        assert.deepEqual(
          await map(
            number => number % 2 == 1 ? Promise.resolve(number ** 2) : number ** 2,
          )({ a: 1, b: 2, c: 3, d: 4, e: 5 }),
          { a: 1, b: 4, c: 9, d: 16, e: 25 },
        )
      })
    })

    describe('map(func A=>B)(Iterator<A>) -> Iterator<B>', () => {
      it('func A=>B; B', async () => {
        const numbers = function* () { let i = 0; while (++i < 6) yield i }
        const squaresIterator = map(number => number ** 2)(numbers())
        assert.deepEqual([...squaresIterator], [1, 4, 9, 16, 25])
      })
    })

    describe('map(func A=>Promise|B)(AsyncIterator<A>) -> AsyncIterator<B>', () => {
      it('func A=>B; AsyncIterator<B>', async () => {
        const asyncNumbers = async function* () { let i = 0; while (++i < 6) yield i }
        const asyncSquaresGenerator = map(number => number ** 2)(asyncNumbers())
        const squaresArray = []
        for await (const number of asyncSquaresGenerator) squaresArray.push(number)
        assert.deepEqual(squaresArray, [1, 4, 9, 16, 25])
      })
      it('func A=>Promise<B>; AsyncIterator<B>', async () => {
        const asyncNumbers = async function* () { let i = 0; while (++i < 6) yield i }
        const asyncSquaresGenerator = map(async number => number ** 2)(asyncNumbers())
        const squaresArray = []
        for await (const number of asyncSquaresGenerator) squaresArray.push(number)
        assert.deepEqual(squaresArray, [1, 4, 9, 16, 25])
      })
    })

    describe('map(func A=>Promise|B)(Reducer<A>) -> Reducer<B>', () => {
      it('func A=>B; Reducer<B>', async () => {
        const add = (a, b) => a + b
        assert.strictEqual(
          [1, 2, 3, 4, 5].reduce(Transducer.map(number => number ** 2)(add), 0),
          55,
        )
      })
      it('func A=>B; async Reducer<A>; Reducer<B>', async () => {
        const asyncAdd = async (a, b) => a + b
        const asyncReducer = Transducer.map(number => number ** 2)(asyncAdd)
        let total = 0
        for (const number of [1, 2, 3, 4, 5]) {
          total = await asyncReducer(total, number)
        }
        assert.strictEqual(total, 55)
      })
      it('func A=>Promise<B>; Reducer<B>', async () => {
        const add = (a, b) => a + b
        const asyncReducer = Transducer.map(async number => number ** 2)(add)
        let total = 0
        for (const number of [1, 2, 3, 4, 5]) {
          total = await asyncReducer(total, number)
        }
        assert.strictEqual(total, 55)
      })
    })

    describe('map(func A=>B)(Mappable<A>) -> Mappable<B>', () => {
      it('func A=>B; B', async () => {
        const Mappable = function (value) {
          this.value = value
        }
        Mappable.prototype.map = function (func) {
          return new Mappable(func(this.value))
        }
        assert.deepEqual(
          map(value => value ** 2)(new Mappable(3)),
          new Mappable(9),
        )
      })
    })

    describe('map(func A=>Promise|B)(A) -> Promise|B', () => {
      it('func A=>B; B', async () => {
        assert.strictEqual(map(value => value)(1), 1)
      })
      it('func A=>Promise<B>; Promise<B>', async () => {
        assert.strictEqual(await map(async value => value)(1), 1)
      })
    })

    it('undefined; undefined', async () => {
      assert.strictEqual(map(value => value)(undefined), undefined)
    })

    it('null; null', async () => {
      assert.strictEqual(map(value => value)(null), null)
    })
  })

  describe('map.entries', () => {
    it('eager', async () => {
      assert.deepEqual(
        map.entries(
          { a: 1, b: 2, c: 3 },
          ([key, value]) => [`${key}${key}`, value ** 2]
        ),
        { aa: 1, bb: 4, cc: 9 },
      )

      assert.deepEqual(
        await map.entries(
          Promise.resolve({ a: 1, b: 2, c: 3 }),
          ([key, value]) => [`${key}${key}`, value ** 2]
        ),
        { aa: 1, bb: 4, cc: 9 },
      )
    })
    it('is like map but over entries rather than values',
      Test(map.entries)
        .case(([key, value]) => [key, value], mappingEntries => {
          assert.deepEqual(mappingEntries({ a: 1, b: 2, c: 3 }), { a: 1, b: 2, c: 3 })
          assert.deepEqual(mappingEntries(mapFrom({ a: 1, b: 2, c: 3 })), mapFrom({ a: 1, b: 2, c: 3 }))
          assert.throws(() => mappingEntries([]), new TypeError('value is not an Object or Map'))
          assert.throws(() => mappingEntries(null), new TypeError('value is not an Object or Map'))
          assert.throws(() => mappingEntries(), new TypeError('value is not an Object or Map'))
        })
        .case(async ([key, value]) => [key, value], async mappingEntries => {
          assert.deepEqual(await mappingEntries({ a: 1, b: 2, c: 3 }), { a: 1, b: 2, c: 3 })
          assert.deepEqual(await mappingEntries(mapFrom({ a: 1, b: 2, c: 3 })), mapFrom({ a: 1, b: 2, c: 3 }))
          assert.throws(() => mappingEntries([]), new TypeError('value is not an Object or Map'))
          assert.throws(() => mappingEntries(null), new TypeError('value is not an Object or Map'))
          assert.throws(() => mappingEntries(), new TypeError('value is not an Object or Map'))
        })
        .case(([key, value]) => value % 2 == 1 ? Promise.resolve([key, value]) : [key, value], async mappingEntries => {
          assert.deepEqual(await mappingEntries({ a: 1, b: 2, c: 3 }), { a: 1, b: 2, c: 3 })
          assert.deepEqual(await mappingEntries(mapFrom({ a: 1, b: 2, c: 3 })), mapFrom({ a: 1, b: 2, c: 3 }))
          assert.throws(() => mappingEntries([]), new TypeError('value is not an Object or Map'))
          assert.throws(() => mappingEntries(null), new TypeError('value is not an Object or Map'))
          assert.throws(() => mappingEntries(), new TypeError('value is not an Object or Map'))
        })
    )
  })

  describe('map.series', () => {
    describe('map.series(func A=>Promise|B)(Array<A>) -> Promise|Array<B>', () => {
      it('func A=>Promise<B>', async () => {
        const createNumbersPromises = () => [
          sleep(15).then(() => 1),
          sleep(10).then(() => 2),
          sleep(5).then(() => 3),
        ]
        {
          const arr = []
          await map(
            p => p.then(number => arr.push(number))
          )(createNumbersPromises())
          assert.deepEqual(arr, [3, 2, 1])
        }
        {
          const arr = []
          await map.series(
            p => p.then(number => arr.push(number))
          )(createNumbersPromises())
          assert.deepEqual(arr, [1, 2, 3])
        }
      })
      it('func A=>B', async () => {
        const square = number => number ** 2
        assert.deepEqual(
          map.series(square)([1, 2, 3, 4, 5]),
          [1, 4, 9, 16, 25],
        )
      })
      it('func A=>B', async () => {
        const variadicAsyncSquare = number => number % 2 == 1 ? number ** 2 : Promise.resolve(number ** 2)
        const variadicAsyncSquare2 = number => number % 2 == 0 ? number ** 2 : Promise.resolve(number ** 2)
        assert.deepEqual(
          await map.series(variadicAsyncSquare)([1, 2, 3, 4, 5]),
          [1, 4, 9, 16, 25],
        )
        assert.deepEqual(
          await map.series(variadicAsyncSquare2)([1, 2, 3, 4, 5]),
          [1, 4, 9, 16, 25],
        )
      })
      it('map.series index', async () => {
        const square = (_number, index) => index
        assert.deepEqual(
          map.series(square)([1, 2, 4]),
          [0, 1, 2],
        )
      })
    })
    it('syncly maps into array of functions', async () => {
      const arr = []
      ade(
        map.series(x => { arr.push(x); return x })([1, 2, 3]),
        [1, 2, 3],
      )
      ade(arr, [1, 2, 3])
    })

    it('arrays', async () => {
      const array = [100, 80, 60, 40, 20]
      const order0 = []
      const result0 = await map.series(array, async n => {
        await sleep(n)
        order0.push(n)
        return n
      })
      assert.deepEqual(result0, [100, 80, 60, 40, 20])
      assert.deepEqual(order0, [100, 80, 60, 40, 20])

      const order1 = []
      const result1 = await map.series(async n => {
        await sleep(n)
        order1.push(n)
        return n
      })(array)
      assert.deepEqual(result1, [100, 80, 60, 40, 20])
      assert.deepEqual(order1, [100, 80, 60, 40, 20])
    })

    it('sets', async () => {
      const set = new Set([100, 80, 60, 40, 20])
      const order0 = []
      const result0 = await map.series(set, async n => {
        await sleep(n)
        order0.push(n)
        return n
      })
      assert.deepEqual(result0, new Set([100, 80, 60, 40, 20]))
      assert.deepEqual(order0, [100, 80, 60, 40, 20])

      const order1 = []
      const result1 = await map.series(async n => {
        await sleep(n)
        order1.push(n)
        return n
      })(set)
      assert.deepEqual(result1, new Set([100, 80, 60, 40, 20]))
      assert.deepEqual(order1, [100, 80, 60, 40, 20])

      const order2 = []
      const result2 = await map.series(set, n => {
        order2.push(n)
        return n
      })
      assert.deepEqual(result2, new Set([100, 80, 60, 40, 20]))
      assert.deepEqual(order2, [100, 80, 60, 40, 20])
    })

    it('maps', async () => {
      const m = new Map([['a', 100], ['b', 80], ['c', 60], ['d', 40], ['e', 20]])
      const order0 = []
      const result0 = await map.series(m, async n => {
        await sleep(n)
        order0.push(n)
        return n
      })
      assert.deepEqual(result0, new Map([['a', 100], ['b', 80], ['c', 60], ['d', 40], ['e', 20]]))
      assert.deepEqual(order0, [100, 80, 60, 40, 20])

      const order1 = []
      const result1 = await map.series(async n => {
        await sleep(n)
        order1.push(n)
        return n
      })(m)
      assert.deepEqual(result1, new Map([['a', 100], ['b', 80], ['c', 60], ['d', 40], ['e', 20]]))
      assert.deepEqual(order1, [100, 80, 60, 40, 20])

      const order2 = []
      const result2 = await map.series(m, n => {
        order2.push(n)
        return n
      })
      assert.deepEqual(result2, new Map([['a', 100], ['b', 80], ['c', 60], ['d', 40], ['e', 20]]))
      assert.deepEqual(order2, [100, 80, 60, 40, 20])
    })

    it('objects', async () => {
      const o = { a: 100, b: 80, c: 60, d: 40, e: 20 }
      const order0 = []
      const result0 = await map.series(o, async n => {
        await sleep(n)
        order0.push(n)
        return n
      })
      assert.deepEqual(result0, { a: 100, b: 80, c: 60, d: 40, e: 20 })
      assert.deepEqual(order0, [100, 80, 60, 40, 20])

      const order1 = []
      const result1 = await map.series(async n => {
        await sleep(n)
        order1.push(n)
        return n
      })(o)
      assert.deepEqual(result1, { a: 100, b: 80, c: 60, d: 40, e: 20 })
      assert.deepEqual(order1, [100, 80, 60, 40, 20])

      const order2 = []
      const result2 = map.series(n => {
        order2.push(n)
        return n
      })(o)
      assert.deepEqual(result2, { a: 100, b: 80, c: 60, d: 40, e: 20 })
      assert.deepEqual(order2, [100, 80, 60, 40, 20])
    })

    it('strings', async () => {
      const s = '98765'
      const order0 = []
      const result0 = await map.series(s, async n => {
        await sleep(Number(n))
        order0.push(n)
        return n
      })
      assert.deepEqual(result0, '98765')
      assert.deepEqual(order0, ['9', '8', '7', '6', '5'])

      const order1 = []
      const result1 = await map.series(async n => {
        await sleep(Number(n))
        order1.push(n)
        return n
      })(s)
      assert.deepEqual(result1, '98765')
      assert.deepEqual(order1, ['9', '8', '7', '6', '5'])

      const order2 = []
      const result2 = map.series(s, n => {
        order2.push(n)
        return n
      })
      assert.deepEqual(result2, '98765')
      assert.deepEqual(order2, ['9', '8', '7', '6', '5'])
    })

    it('invalid', async () => {
      assert.throws(
        () => map.series(undefined, () => {}),
        new TypeError('invalid collection undefined'),
      )
      assert.throws(
        () => map.series(null, () => {}),
        new TypeError('invalid collection null'),
      )
      assert.throws(
        () => map.series(3, () => {}),
        new TypeError('invalid collection 3'),
      )
    })
  })

  describe('map.pool', () => {
    it('maps with asynchronous limit for Arrays', async () => {
      const square = n => n ** 2
      const asyncSquare = async x => x ** 2
      aok(map.pool(1, asyncSquare)([1, 2, 3, 4, 5]) instanceof Promise)
      ade(map.pool(await Promise.resolve([1, 2, 3, 4, 5]), 1, square), [1, 4, 9, 16, 25])
      ade(map.pool(1, square)([1, 2, 3, 4, 5]), [1, 4, 9, 16, 25])
      ade(await map.pool(1, asyncSquare)([1, 2, 3, 4, 5]), [1, 4, 9, 16, 25])
      ade(await map.pool(9, asyncSquare)([1, 2, 3, 4, 5]), [1, 4, 9, 16, 25])
      ade(await map.pool(100, asyncSquare)([1, 2, 3, 4, 5]), [1, 4, 9, 16, 25])
      ade(await map.pool(1, asyncSquare)([1, 2, 3, 4, 5]), [1, 4, 9, 16, 25])
      ade(await map.pool(9, asyncSquare)([1, 2, 3, 4, 5]), [1, 4, 9, 16, 25])
    })
    it('alternating Promises', async () => {
      const alternatingAsyncSquare = x => x % 2 == 1 ? Promise.resolve(x ** 2) : x ** 2
      ade(await map.pool(1, alternatingAsyncSquare)([1, 2, 3, 4, 5]), [1, 4, 9, 16, 25])
      ade(await map.pool(9, alternatingAsyncSquare)([1, 2, 3, 4, 5]), [1, 4, 9, 16, 25])
    })
    it('=> [] for empty array', async () => {
      const asyncSquare = async x => x ** 2
      assert.deepEqual(await map.pool(1, asyncSquare)([]), [])
    })
    it('works for arrays of undefined values', async () => {
      ade(await map.pool(1, x => x)(Array(5)), Array(5).fill(undefined))
      ade(await map.pool(1, x => x)(Array(5).fill(null)), Array(5).fill(null))
    })
    it('null/invalid', async () => {
      assert.throws(
        () => map.pool(null, 1, () => {}),
        new TypeError('invalid collection null')
      )
      assert.throws(
        () => map.pool(1, 1, () => {}),
        new TypeError('invalid collection 1')
      )
    })
    it('maps with asynchronous limit for strings', async () => {
      const s = 'abcde'
      const sdupe = 'aabbccddee'
      const duplicate = s => `${s}${s}`
      const asyncDuplicate = async s => `${s}${s}`
      const alternatingAsyncDuplicate = async s => (
        ['a', 'c', 'e'].includes(s) ? Promise.resolve(`${s}${s}`) : `${s}${s}`
      )
      aok(map.pool(1, asyncDuplicate)(s) instanceof Promise)
      ade(await map.pool(1, asyncDuplicate)(s), sdupe)
      ade(await map.pool(9, asyncDuplicate)(s), sdupe)
      ade(await map.pool(100, asyncDuplicate)(s), sdupe)
      ade(await map.pool(1, asyncDuplicate)(s), sdupe)
      ade(await map.pool(9, asyncDuplicate)(s), sdupe)
      ade(await map.pool(s, 9, alternatingAsyncDuplicate), sdupe)
      ade(map.pool(s, 9, duplicate), sdupe)
    })
    it('maps with asynchronous limit for Sets', async () => {
      const square = n => n ** 2
      const asyncSquare = async x => x ** 2
      const alternatingAsyncSquare = x => x % 2 == 1 ? Promise.resolve(x ** 2) : x ** 2
      const numbersSet = new Set([1, 2, 3, 4, 5])
      const squaresSet = new Set([1, 4, 9, 16, 25])
      aok(map.pool(1, asyncSquare)(numbersSet) instanceof Promise)
      ade(map.pool(numbersSet, 1, square), squaresSet)
      ade(map.pool(1, square)(numbersSet), squaresSet)
      ade(await map.pool(numbersSet, 1, asyncSquare), squaresSet)
      ade(await map.pool(numbersSet, 1, alternatingAsyncSquare), squaresSet)
      ade(await map.pool(9, asyncSquare)(numbersSet), squaresSet)
      ade(await map.pool(100, asyncSquare)(numbersSet), squaresSet)
      ade(await map.pool(1, asyncSquare)(numbersSet), squaresSet)
      ade(await map.pool(numbersSet, 9, asyncSquare), squaresSet)
    })
    it('maps with asynchronous limit for Maps', async () => {
      const square = n => n ** 2
      const asyncSquare = async x => x ** 2
      const alternatingAsyncSquare = x => x % 2 == 1 ? Promise.resolve(x ** 2) : x ** 2
      const numbersMap = new Map([[1, 1], [2, 2], [3, 3], [4, 4], [5, 5]])
      const squaresMap = new Map([[1, 1], [2, 4], [3, 9], [4, 16], [5, 25]])
      aok(map.pool(1, asyncSquare)(numbersMap) instanceof Promise)
      ade(map.pool(1, square)(numbersMap), squaresMap)
      ade(await map.pool(1, asyncSquare)(numbersMap), squaresMap)
      ade(await map.pool(numbersMap, 1, asyncSquare), squaresMap)
      ade(await map.pool(numbersMap, 1, alternatingAsyncSquare), squaresMap)
      ade(await map.pool(9, asyncSquare)(numbersMap), squaresMap)
      ade(await map.pool(100, asyncSquare)(numbersMap), squaresMap)
      ade(await map.pool(1, asyncSquare)(numbersMap), squaresMap)
      ade(await map.pool(9, asyncSquare)(numbersMap), squaresMap)
    })
    it('maps with asynchronous limit for Objects', async () => {
      const square = x => x ** 2
      const asyncSquare = async x => x ** 2
      const squareEntry = entry => entry.map(asyncSquare)
      const alternatingAsyncSquare = x => x % 2 == 1 ? Promise.resolve(x ** 2) : x ** 2
      const numbersObject = { a: 1, b: 2, c: 3, d: 4, e: 5 }
      const squaresObject = { a: 1, b: 4, c: 9, d: 16, e: 25 }
      aok(map.pool(1, asyncSquare)(numbersObject) instanceof Promise)
      ade(await map.pool(numbersObject, 1, alternatingAsyncSquare), squaresObject)
      ade(await map.pool(1, asyncSquare)(numbersObject), squaresObject)
      ade(await map.pool(9, asyncSquare)(numbersObject), squaresObject)
      ade(await map.pool(100, asyncSquare)(numbersObject), squaresObject)
      ade(await map.pool(1, asyncSquare)(numbersObject), squaresObject)
      ade(await map.pool(9, asyncSquare)(numbersObject), squaresObject)
      ade(map.pool(numbersObject, 9, square), squaresObject)
    })
    it('abides by asynchronous limit for arrays and sets', async () => {
      const numbers = [1, 2, 3, 4, 5, 6]
      const period = 10
      let i = 0
      let maxi = 0
      const plusSleepMinus = n => (async () => {
        i += 1
        maxi = Math.max(maxi, i)
      })().then(() => sleep(period)).
then(() => {
        i -= 1
        return n
      })
      ade(await map.pool(2, plusSleepMinus)(numbers), numbers)
      assert.strictEqual(maxi, 2)
      assert.strictEqual(i, 0)
      maxi = 0
      ade(await map.pool(3, plusSleepMinus)([1, 2, 3, 4, 5, 6]), numbers)
      assert.strictEqual(maxi, 3)
      assert.strictEqual(i, 0)
      maxi = 0
    }).timeout(20000)
    it('throws TypeError on map.pool(NaN)', async () => {
      assert.throws(
        () => map.pool(NaN)(NaN),
        new TypeError('invalid collection NaN'),
      )
    })
    it('handles sync errors', async () => {
      assert.throws(
        () => map.pool(1, x => { throw new Error(`throwing ${x}`) })(['yo']),
        new Error('throwing yo')
      )
    })
    it('handles async errors', async () => {
      assert.rejects(
        () => map.pool(1, async x => { throw new Error(`throwing ${x}`) })(['yo']),
        new Error('throwing yo'),
      )
    })

    it('sets', async () => {
    })
  })

  describe('filter', () => {
    it('eager', async () => {
      const numbers = [1, 2, 3]
      const odds = filter(numbers, number => number % 2 == 1)
      assert.deepEqual(odds, [1, 3])
    })

    describe('filter(predicate T=>Promise|boolean)(Array<T>) -> Promise|Array<T>', () => {
      it('predicate T=>boolean', async () => {
        const isOdd = number => number % 2 == 1
        assert.deepEqual(
          filter(isOdd)([1, 2, 3, 4, 5]),
          [1, 3, 5],
        )
      })
      it('predicate T=>Promise<boolean>', async () => {
        const asyncIsOdd = async number => number % 2 == 1
        assert.deepEqual(
          await filter(asyncIsOdd)([1, 2, 3, 4, 5]),
          [1, 3, 5],
        )
      })
      it('predicate T=>Promise|boolean', async () => {
        const variadicAsyncIsOdd = number => number % 2 == 1 ? Promise.resolve(true) : false
        assert.deepEqual(
          await filter(variadicAsyncIsOdd)([1, 2, 3, 4, 5]),
          [1, 3, 5],
        )
        assert.deepEqual(
          await filter(variadicAsyncIsOdd)([2, 3, 4, 5, 6]),
          [3, 5],
        )
      })
    })

    describe('filter(predicate T=>Promise|boolean)(Set<T>) -> Promise|Set<T>', () => {
      it('predicate T=>Promise|boolean', async () => {
        const isOdd = number => number % 2 == 1
        const variadicAsyncIsOdd = number => number % 2 == 1 ? Promise.resolve(true) : false
        assert.deepEqual(
          filter(isOdd)(new Set([1, 2, 3, 4, 5])),
          new Set([1, 3, 5]),
        )
        assert.deepEqual(
          await filter(async(isOdd))(new Set([1, 2, 3, 4, 5])),
          new Set([1, 3, 5]),
        )
        assert.deepEqual(
          await filter(variadicAsyncIsOdd)(new Set([1, 2, 3, 4, 5])),
          new Set([1, 3, 5]),
        )
      })
    })

    describe('filter(predicate T=>Promise|boolean)(Map<any=>T>) -> Promise|Map<any=>T>', () => {
      it('predicate T=>Promise|boolean', async () => {
        const isOdd = number => number % 2 == 1
        const variadicAsyncIsOdd = number => number % 2 == 1 ? Promise.resolve(true) : false
        const numbersMap = new Map([['a', 1], ['b', 2], ['c', 3], ['d', 4], ['e', 5]])
        const oddNumbersMap = new Map([['a', 1], ['c', 3], ['e', 5]])
        assert.deepEqual(
          filter(isOdd)(numbersMap),
          oddNumbersMap,
        )
        assert.deepEqual(
          await filter(async(isOdd))(numbersMap),
          oddNumbersMap,
        )
        assert.deepEqual(
          await filter(variadicAsyncIsOdd)(numbersMap),
          oddNumbersMap,
        )
      })
    })

    describe('filter(predicate T=>Promise|boolean)({ filter: function }) -> Promise|any', () => {
      it('predicate T=>Promise|boolean', async () => {
        const myFilterable = { filter: () => 'hey' }
        assert.strictEqual(filter(isOdd)(myFilterable), 'hey')
      })
    })

    describe('filter(predicate T=>Promise|boolean)(number) -> number', () => {
      it('id', async () => {
        assert.strictEqual(filter(isOdd)(1), 1)
      })
    })

    describe('filter(predicate T=>Promise|boolean)(String<T>) -> Promise|String<T>', () => {
      it('predicate T=>Promise|boolean', async () => {
        const isOdd = number => Number(number) % 2 == 1
        const variadicAsyncIsOdd = number => Number(number) % 2 == 1 ? Promise.resolve(true) : false
        assert.deepEqual(
          filter(isOdd)('12345'),
          '135',
        )
        assert.deepEqual(
          await filter(async(isOdd))('12345'),
          '135',
        )
        assert.deepEqual(
          await filter(variadicAsyncIsOdd)('12345'),
          '135',
        )
      })

      it('predicate T=>Promise|boolean', async () => {
        const isOdd = number => number % 2 == 1
        const variadicAsyncIsOdd = number => number % 2 == 1 ? Promise.resolve(true) : false
        const numbersMap = new Map([['a', 1], ['b', 2], ['c', 3], ['d', 4], ['e', 5]])
        const oddNumbersMap = new Map([['a', 1], ['c', 3], ['e', 5]])
        assert.deepEqual(
          filter(isOdd)(numbersMap),
          oddNumbersMap,
        )
        assert.deepEqual(
          await filter(async(isOdd))(numbersMap),
          oddNumbersMap,
        )
        assert.deepEqual(
          await filter(variadicAsyncIsOdd)(numbersMap),
          oddNumbersMap,
        )
      })
    })

    describe('filter(predicate T=>Promise|boolean)(Object<T>) -> Promise|Object<T>', () => {
      it('predicate T=>boolean', async () => {
        const isOdd = number => number % 2 == 1
        assert.deepEqual(
          filter(isOdd)({ a: 1, b: 2, c: 3, d: 4, e: 5 }),
          { a: 1, c: 3, e: 5 },
        )
      })
      it('predicate T=>Promise<boolean>', async () => {
        const asyncIsOdd = async number => number % 2 == 1
        assert.deepEqual(
          await filter(asyncIsOdd)({ a: 1, b: 2, c: 3, d: 4, e: 5 }),
          { a: 1, c: 3, e: 5 },
        )
      })
      it('predicate T=>Promise|boolean', async () => {
        const variadicAsyncIsOdd = number => number % 2 == 1 ? Promise.resolve(true) : false
        assert.deepEqual(
          await filter(variadicAsyncIsOdd)({ a: 1, b: 2, c: 3, d: 4, e: 5 }),
          { a: 1, c: 3, e: 5 },
        )
        assert.deepEqual(
          await filter(variadicAsyncIsOdd)({ b: 2, c: 3, d: 4, e: 5, f: 6 }),
          { c: 3, e: 5 },
        )
      })
    })
    describe('filter(predicate T=>boolean)(Iterator<T>) -> Iterator<T>', () => {
      it('predicate T=>boolean', async () => {
        const numbers = function* () { let i = 0; while (++i < 6) yield i }
        const isOdd = number => number % 2 == 1
        const oddNumbersIterator = filter(isOdd)(numbers())
        assert.deepEqual([...oddNumbersIterator], [1, 3, 5])
      })
    })
    describe('filter(predicate T=>Promise|boolean)(AsyncIterator<T>) -> AsyncIterator<T>', () => {
      const asyncNumbers = async function* () { let i = 0; while (++i < 6) yield i }
      it('predicate T=>boolean', async () => {
        const isOdd = number => number % 2 == 1
        const asyncOddNumbersIterator = filter(isOdd)(asyncNumbers())
        const oddNumbersArray = []
        for await (const number of asyncOddNumbersIterator) oddNumbersArray.push(number)
        assert.deepEqual(oddNumbersArray, [1, 3, 5])
      })
    })
    describe('filter(predicate T=>Promise|boolean)(Reducer<T>) -> Reducer<T>', () => {
      const concat = (array, values) => array.concat(values)
      it('predicate T=>boolean', async () => {
        const isOdd = number => number % 2 == 1
        const concatOdds = Transducer.filter(isOdd)(concat)
        assert.deepEqual([1, 2, 3, 4, 5].reduce(concatOdds, []), [1, 3, 5])
      })
      it('predicate T=>Promise<boolean>', async () => {
        const asyncIsOdd = async number => number % 2 == 1
        const concatOdds = Transducer.filter(asyncIsOdd)(concat)
        let oddNumbers = []
        for (const number of [1, 2, 3, 4, 5]) {
          oddNumbers = await concatOdds(oddNumbers, number)
        }
        assert.deepEqual(oddNumbers, [1, 3, 5])
      })
      it('predicate T=>Promise|boolean', async () => {
        const variadicAsyncIsOdd = number => number % 2 == 1 ? Promise.resolve(true) : false
        const concatOdds = Transducer.filter(variadicAsyncIsOdd)(concat)
        let oddNumbers = []
        for (const number of [1, 2, 3, 4, 5]) {
          oddNumbers = await concatOdds(oddNumbers, number)
        }
        assert.deepEqual(oddNumbers, [1, 3, 5])
      })
    })
    describe('filter(predicate T=>boolean)(Filterable<T>) -> Filterable<T>', () => {
      it('predicate T=>boolean', async () => {
        const isOdd = number => number % 2 == 1
        const Filterable = function (value) {
          this.value = value
        }
        Filterable.prototype.filter = function (func) {
          return new Filterable(this.value.filter(func))
        }
        assert.deepEqual(
          filter(isOdd)(new Filterable([1, 2, 3, 4, 5])),
          new Filterable([1, 3, 5]),
        )
      })
    })
    describe('filter(predicate T=>boolean)(null) -> null', () => {
      it('predicate T=>boolean', async () => {
        assert.strictEqual(filter(() => true)(null), null)
      })
    })
    describe('filter(predicate T=>boolean)(undefined) -> undefined', () => {
      it('predicate T=>boolean', async () => {
        assert.strictEqual(filter(() => true)(undefined), undefined)
      })
    })
  })

  describe('reduce', () => {
    it('eager', async () => {
      const numbers = [1, 2, 3, 4, 5]
      const sum1 = reduce(numbers, (a, b) => a + b)
      const sum2 = reduce(numbers, (a, b) => a + b, 0)
      const sum3 = reduce(numbers, (a, b) => a + b, () => 0)
      const sum4 = await reduce(numbers, (a, b) => a + b, async () => 0)
      const sum5 = await reduce(numbers, (a, b) => a + b, Promise.resolve(0))
      assert.equal(sum1, 15)
      assert.equal(sum2, 15)
      assert.equal(sum3, 15)
      assert.equal(sum4, 15)
      assert.equal(sum5, 15)
    })

    it('eager Promise arguments', async () => {
      const numbers = Promise.resolve([1, 2, 3, 4, 5])
      const sum1 = await reduce(numbers, (a, b) => a + b)
      const sum2 = await reduce(numbers, (a, b) => a + b, 0)
      const sum3 = await reduce(numbers, (a, b) => a + b, () => 0)
      const sum4 = await reduce(numbers, (a, b) => a + b, async () => 0)
      const sum5 = await reduce(numbers, (a, b) => a + b, Promise.resolve(0))
      assert.equal(sum1, 15)
      assert.equal(sum2, 15)
      assert.equal(sum3, 15)
      assert.equal(sum4, 15)
      assert.equal(sum5, 15)
    })

    describe(`
Reducer<T> (any, T)=>Promise|any

Reducible<T> {
  reduce: (reducer Reducer<T>, init any)=>(result any),
}

reduce(
  reducer Reducer,
  init undefined|function|any,
) -> ...any=>function|Promise|any

reduce(
  reducer Reducer<T>,
  init undefined
    |((collection, ...restArgs)=>Promise|any)
    |any,
)(
  collection Iterable<T>|Iterator<T>
    |AsyncIterable<T>|AsyncIterator<T>
    |Reducible<T>|Object<T>,
  restArgs ...any,
) -> Promise|any

reduce(
  reducer Reducer<T>,
  init undefined
    |((collectionFactory, ...restArgs)=>Promise|any)
    |any,
)(
  collectionFactory (...any=>Iterator<T>)
    |(...any=>AsyncIterator<T>)
    |Reducer<T>,
  restArgs ...any,
) -> reducingFunction ...any=>Promise|any
`, () => {
  describe('reducer (any, T)=>Promise|any', () => {
    const add = (a, b) => a + b
    const asyncAdd = async (a, b) => a + b
    const variadicAsyncAdd = (a, b) => b % 2 == 1 ? Promise.resolve(a + b) : a + b
    xit('collection Promise<Array<number>>', async () => {
      assert.strictEqual(
        reduce(add, 0)(Promise.resolve([1, 2, 3, 4, 5])), 15)
      assert.strictEqual(
        await reduce(asyncAdd, 0)(Promise.resolve([1, 2, 3, 4, 5])), 15)
      assert.strictEqual(
        await reduce(variadicAsyncAdd, 0)(Promise.resolve([1, 2, 3, 4, 5])), 15)
    })
    it('collection Array<number>', async () => {
      assert.strictEqual(
        reduce(add, 0)([1, 2, 3, 4, 5]), 15)
      assert.strictEqual(
        await reduce(asyncAdd, 0)([1, 2, 3, 4, 5]), 15)
      assert.strictEqual(
        await reduce(variadicAsyncAdd, 0)([1, 2, 3, 4, 5]), 15)
    })
    it('collection Array<>', async () => {
      assert.strictEqual(
        reduce(add, 0)([]), 0)
      assert.strictEqual(
        reduce(asyncAdd, 0)([]), 0)
      assert.strictEqual(
        reduce(variadicAsyncAdd, 0)([]), 0)
    })
    it('collection { chain: function }', async () => {
      const Max = function (number) {
        this.number = number
      }
      Max.prototype.chain = function (flatMapper) {
        const monad = flatMapper(this.number)
        if (monad.constructor == Max) {
          return new Max(monad.number > this.number ? monad.number : this.number)
        }
        return monad
      }
      assert.strictEqual(reduce(add, 0)(new Max(5)), 5)
      assert.strictEqual(await reduce(asyncAdd, 0)(new Max(5)), 5)
      assert.strictEqual(await reduce(variadicAsyncAdd, 0)(new Max(5)), 5)
    })
    it('collection { chain: function }', async () => {
      const AsyncMax = function (number) {
        this.number = number
      }
      AsyncMax.prototype.chain = async function (flatMapper) {
        const monad = await flatMapper(this.number)
        if (monad.constructor == AsyncMax) {
          return new AsyncMax(monad.number > this.number ? monad.number : this.number)
        }
        return monad
      }
      assert.strictEqual(await reduce(add, 0)(new AsyncMax(5)), 5)
      assert.strictEqual(await reduce(asyncAdd, 0)(new AsyncMax(5)), 5)
      assert.strictEqual(await reduce(variadicAsyncAdd, 0)(new AsyncMax(5)), 5)
    })
    it('collection { flatMap: function }', async () => {
      const Max = function (number) {
        this.number = number
      }
      Max.prototype.flatMap = function (flatMapper) {
        const monad = flatMapper(this.number)
        if (monad.constructor == Max) {
          return new Max(monad.number > this.number ? monad.number : this.number)
        }
        return monad
      }
      assert.strictEqual(reduce(add, 0)(new Max(5)), 5)
      assert.strictEqual(await reduce(asyncAdd, 0)(new Max(5)), 5)
      assert.strictEqual(await reduce(variadicAsyncAdd, 0)(new Max(5)), 5)
    })
    it('collection Generator<number>', async () => {
      const numbers = function* () { yield 1; yield 2; yield 3; yield 4; yield 5 }
      assert.strictEqual(
        reduce(add, 0)(numbers()), 15)
      assert.strictEqual(
        await reduce(asyncAdd, 0)(numbers()), 15)
      assert.strictEqual(
        await reduce(variadicAsyncAdd, 0)(numbers()), 15)
    })
    it('collection Generator<>', async () => {
      const numbers = function* () {}
      assert.strictEqual(
        reduce(add, 0)(numbers()), 0)
      assert.strictEqual(
        await reduce(asyncAdd, 0)(numbers()), 0)
      assert.strictEqual(
        await reduce(variadicAsyncAdd, 0)(numbers()), 0)
    })
    it('collection AsyncGenerator<number>', async () => {
      const numbers = async function* () { yield 1; yield 2; yield 3; yield 4; yield 5 }
      assert.strictEqual(
        await reduce(add, 0)(numbers()), 15)
      assert.strictEqual(
        await reduce(asyncAdd, 0)(numbers()), 15)
      assert.strictEqual(
        await reduce(variadicAsyncAdd, 0)(numbers()), 15)
    })
    it('collection AsyncGenerator<>', async () => {
      const numbers = async function* () {}
      assert.equal(typeof reduce(add, 0)(numbers()).then, 'function')
      assert.strictEqual(
        await reduce(add, 0)(numbers()), 0)
      assert.strictEqual(
        await reduce(asyncAdd, 0)(numbers()), 0)
      assert.strictEqual(
        await reduce(variadicAsyncAdd, 0)(numbers()), 0)
    })
    it('collection Reducible<number>', async () => {
      const reducible = {
        reduce(reducer, init) {
          return [1, 2, 3, 4, 5].reduce(reducer, init)
        },
      }
      assert.strictEqual(
        reduce(add, 0)(reducible), 15)
    })
    it('collection Object<number>', async () => {
      const numbers = { a: 1, b: 2, c: 3, d: 4, e: 5 }
      assert.strictEqual(
        reduce(add, 0)(numbers), 15)
      assert.strictEqual(
        reduce(add, () => 0)(numbers), 15)
      assert.strictEqual(
        reduce(add)(numbers), 15)
      assert.strictEqual(
        await reduce(asyncAdd, 0)(numbers), 15)
      assert.strictEqual(
        await reduce(variadicAsyncAdd, 0)(numbers), 15)
    })
    it('collection Object<>', async () => {
      const numbers = {}
      assert.strictEqual(
        reduce(add, 0)(numbers), 0)
      assert.strictEqual(
        reduce(add, () => 0)(numbers), 0)
      assert.strictEqual(
        await reduce(asyncAdd, 0)(numbers), 0)
      assert.strictEqual(
        await reduce(variadicAsyncAdd, 0)(numbers), 0)
    })
    it('collection Map<[string, number]>', async () => {
      const StringNumberMap = function (size) {
        const result = new Map()
        let index = -1
        while (++index < size) {
          result.set(sha256(String(index)), index)
        }
        return result
      }
      const stringNumberMap5 = StringNumberMap(5)
      assert.equal(reduce(add, 0)(stringNumberMap5), 10)
      assert.equal(reduce(add, () => 0)(stringNumberMap5), 10)
      assert.equal(await reduce(add, async () => 0)(stringNumberMap5), 10)
      assert.equal(await reduce(asyncAdd, async () => 0)(stringNumberMap5), 10)
      assert.equal(reduce(add)(stringNumberMap5), 10)
    })
    it('collection atomic', async () => {
      assert.strictEqual(
        reduce((a, b) => a + b, 0)(10),
        10,
      )
      assert.strictEqual(
        reduce((a, b) => a + b)(10)(5),
        15,
      )
      assert.strictEqual(
        reduce((a, b) => a + b, 0)(10),
        10,
      )
    })
    it('collection null', async () => {
      assert.strictEqual(
        reduce(value => value, 'hey')(null),
        'hey',
      )
    })
    it('collection undefined', async () => {
      assert.strictEqual(
        reduce(value => value, () => 'hey')(undefined),
        'hey',
      )
      assert.strictEqual(
        await reduce(value => value, async () => 'hey')(undefined),
        'hey',
      )
      assert.strictEqual(
        reduce(value => value, 'hey')(),
        'hey',
      )
      assert.equal(
        typeof reduce(value => value, undefined)(undefined),
        'function'
      )
    })
  })
})
  })

  describe('reduce - v1.5.10 regression', () => {
    const iterables = [
      [1, 2, 3, 4, 5],
      { a: 1, b: 2, c: 3, d: 4, e: 5 },
      new Set([1, 2, 3, 4, 5]),
      {
        [Symbol.iterator]: function* () {
          for (let i = 1; i < 6; i++) yield i
        },
      },
    ]
    const makeAsyncIterables = () => [
      stream.Readable.from([1, 2, 3, 4, 5]),
      stream.Readable.from((async function* () {
        for (let i = 1; i < 6; i++) yield i
      })()),
      constructReadStream([1, 2, 3, 4, 5]),
      {
        [Symbol.asyncIterator]: async function* () {
          await sleep(1)
          for (let i = 1; i < 6; i++) yield i
        },
      },
    ]
    it('reduces any iterable with a sync reducer', async () => {
      for (const x of iterables) {
        ase(reduce((y, xi) => y + xi)(x), 15)
        ase(reduce((y, xi) => y + xi, 10)(x), 25)
      }
    })
    it('reduces any iterable with an async reducer', async () => {
      aok(asyncMult(1, 2) instanceof Promise)
      for (const x of iterables) {
        aok(reduce(asyncMult)(x) instanceof Promise)
        ase(await reduce(asyncMult)(x), 120)
        ase(await reduce(asyncMult, 10)(x), 1200)
      }
    })
    it('reduces any async iterable with a sync reducer', async () => {
      for (const x of makeAsyncIterables()) {
        ase(await reduce((y, xi) => Number(y) + Number(xi))(x), 15)
      }
      for (const x of makeAsyncIterables()) {
        ase(await reduce((y, xi) => Number(y) + Number(xi), 10)(x), 25)
      }
    })
    it('reduces any async iterable with an async reducer', async () => {
      aok(asyncMult(1, 2) instanceof Promise)
      for (const x of makeAsyncIterables()) {
        aok(reduce(asyncMult)(x) instanceof Promise)
      }
      for (const x of makeAsyncIterables()) {
        ase(await reduce(asyncMult)(x), 120)
      }
      for (const x of makeAsyncIterables()) {
        ase(await reduce(asyncMult, 10)(x), 1200)
      }
    })
    it('reduces an iterable with variadic sync/async reducer', async () => {
      ade(
        await reduce(
          (a, b) => b === 1 ? a + b : Promise.resolve(a + b),
          0,
        )([1, 2, 3, 4, 5]),
        15,
      )
    })
    it('initial value can be a function', async () => {
      ade(
        reduce((a, b) => a + b, () => 0)([1, 2, 3, 4, 5]),
        15,
      )
      const asyncNumbers = async function*() {
        for (let i = 1; i <= 5; i++) yield i
      }
      ade(
        await reduce((a, b) => a + b, () => 0)(asyncNumbers()),
        15,
      )
      ade(
        await reduce((a, b) => a + b, () => 0)({ a: 1, b: 2, c: 3, d: 4, e: 5 }),
        15,
      )
    })
    it('initial value can be an async function', async () => {
      ade(
        await reduce((a, b) => a + b, async () => 0)([1, 2, 3, 4, 5]),
        15,
      )
      const asyncNumbers = async function*() {
        for (let i = 1; i <= 5; i++) yield i
      }
      ade(
        await reduce((a, b) => a + b, async () => 0)(asyncNumbers()),
        15,
      )
      ade(
        await reduce((a, b) => a + b, async () => 0)({ a: 1, b: 2, c: 3, d: 4, e: 5 }),
        15,
      )
    })
    it('referential initial values are unsafe', async () => {
      const square = x => x ** 2
      const unsafeSquareAll = reduce((a, b) => { a.push(square(b)); return a }, [])
      ade(
        unsafeSquareAll([1, 2, 3]),
        [1, 4, 9],
      )
      ade(
        unsafeSquareAll([1, 2, 3]),
        [1, 4, 9, 1, 4, 9],
      )
      const safeSquareAll = reduce((a, b) => { a.push(square(b)); return a }, () => [])
      ade(
        safeSquareAll([1, 2, 3]),
        [1, 4, 9],
      )
      ade(
        safeSquareAll([1, 2, 3]),
        [1, 4, 9],
      )
    })
    it('=> [] for initial () => [] and input []', async () => {
      const square = x => x ** 2
      ade(
        reduce(map(square)((a, b) => (a.push(b), a)), () => [])([]),
        [],
      )
      const emptyAsyncIterator = (async function*(){})()
      ade(
        await reduce(map(square)((a, b) => (a.push(b), a)), () => [])(emptyAsyncIterator),
        [],
      )
    })
  })

  describe('transform', () => {
    describe(`
transform(
  transducer function,
  init function|any,
)(...any) -> Promise|any

Reducer<T> = (any, T)=>Promise|any

Transducer = Reducer=>Reducer

Semigroup = Array|string|Set|TypedArray
  |{ concat: function }|{ write: function }|Object

transform(
  transducer Transducer,
  init ((collection, ...restArgs)=>Promise|Semigroup|any)
    |Semigroup
    |any,
)(
  collection Iterable|Iterator
    |AsyncIterable|AsyncIterator
    |{ reduce: function }|Object|any,
  restArgs ...any
) -> Semigroup Promise|any

transform(
  transducer Transducer,
  init (...args=>Promise|Semigroup|any)
    |Semigroup
    |any,
)(
  generatorFunction (...args=>Generator)|(...args=>AsyncGenerator),
) -> reducingFunction (args ...any)=>Promise|Semigroup|any

transform(
  transducer Transducer,
  init (...args=>Promise|Semigroup|any)
    |Semigroup
    |any,
)(
  anotherReducer Reducer, moreReducers ...Reducer
) -> chainedReducingFunction (args ...any)=>Promise|any
    `, () => {
      describe('collection x init', () => {
        const square = number => number ** 2
        it('API coverage', async () => {
          assert.deepEqual(
            transform([1, 2, 3, 4, 5], Transducer.map(square), []),
            [1, 4, 9, 16, 25],
          )
          assert.deepEqual(
            transform([1, 2, 3, 4, 5], Transducer.map(square), () => []),
            [1, 4, 9, 16, 25],
          )
          assert.deepEqual(
            await transform([1, 2, 3, 4, 5], Transducer.map(square), async () => []),
            [1, 4, 9, 16, 25],
          )
          assert.deepEqual(
            await transform([1, 2, 3, 4, 5], Transducer.map(square), Promise.resolve([])),
            [1, 4, 9, 16, 25],
          )
          assert.deepEqual(
            await transform(Promise.resolve([1, 2, 3, 4, 5]), Transducer.map(square), []),
            [1, 4, 9, 16, 25],
          )
        })
        it('init []|() => []', async () => {
          assert.deepEqual(
            transform(Transducer.map(square), [])([1, 2, 3, 4, 5]),
            [1, 4, 9, 16, 25],
          )
          assert.deepEqual(
            await transform(Transducer.map(square), Promise.resolve([]))([1, 2, 3, 4, 5]),
            [1, 4, 9, 16, 25],
          )
          assert.deepEqual(
            transform(Transducer.map(square), () => [])([1, 2, 3, 4, 5]),
            [1, 4, 9, 16, 25],
          )
          assert.deepEqual(
            await transform(Transducer.map(square), async () => [])([1, 2, 3, 4, 5]),
            [1, 4, 9, 16, 25],
          )
          assert.deepEqual(
            transform(Transducer.map(square), [])([1, 2, 3, 4, 5][Symbol.iterator]()),
            [1, 4, 9, 16, 25],
          )
          const duplicate = item => [item, item]
          assert.deepEqual(
            transform(Transducer.map(duplicate), [])([1, 2, 3, 4, 5]),
            [1, 1, 2, 2, 3, 3, 4, 4, 5, 5],
          )
          assert.deepEqual(
            transform(Transducer.map(duplicate), () => [])([1, 2, 3, 4, 5]),
            [1, 1, 2, 2, 3, 3, 4, 4, 5, 5],
          )
          assert.deepEqual(
            await transform(Transducer.map(async number => duplicate(number)), async () => [])([1, 2, 3, 4, 5]),
            [1, 1, 2, 2, 3, 3, 4, 4, 5, 5],
          )
        })
        it('init \'\'|(()=>\'\')', async () => {
          assert.strictEqual(
            transform(Transducer.map(square), '')([1, 2, 3, 4, 5]),
            '1491625',
          )
          assert.strictEqual(
            transform(Transducer.map(square), () => '')([1, 2, 3, 4, 5]),
            '1491625',
          )
          assert.strictEqual(
            await transform(Transducer.map(async number => number ** 2), async () => '')([1, 2, 3, 4, 5]),
            '1491625',
          )
        })
        it('init Set|()=>Set', async () => {
          assert.deepEqual(
            transform(Transducer.map(square), new Set())([1, 2, 3, 4, 5]),
            new Set([1, 4, 9, 16, 25]),
          )
          assert.deepEqual(
            transform(Transducer.map(square), () => new Set())([1, 2, 3, 4, 5]),
            new Set([1, 4, 9, 16, 25]),
          )
          assert.deepEqual(
            await transform(Transducer.map(square), async () => new Set())([1, 2, 3, 4, 5]),
            new Set([1, 4, 9, 16, 25]),
          )
          const SetWithSquare = number => new Set([number, number ** 2])
          assert.deepEqual(
            transform(Transducer.map(SetWithSquare), new Set())([1, 2, 3, 4, 5]),
            new Set([1, 2, 4, 3, 9, 4, 16, 5, 25]),
          )
          assert.deepEqual(
            transform(Transducer.map(SetWithSquare), () => new Set())([1, 2, 3, 4, 5]),
            new Set([1, 2, 4, 3, 9, 4, 16, 5, 25]),
          )
          assert.deepEqual(
            await transform(Transducer.map(async number => SetWithSquare(number)), async () => new Set())([1, 2, 3, 4, 5]),
            new Set([1, 2, 4, 3, 9, 4, 16, 5, 25]),
          )
        })
        it('init TypedArray|()=>TypedArray', async () => {
          for (const constructor of numberTypedArrayConstructors) {
            assert.deepEqual(
              transform(Transducer.map(square), new constructor())([1, 2, 3, 4, 5]),
              new constructor([1, 4, 9, 16, 25])
            )
            assert.deepEqual(
              transform(Transducer.map(square), () => new constructor())([1, 2, 3, 4, 5]),
              new constructor([1, 4, 9, 16, 25])
            )
            assert.deepEqual(
              await transform(Transducer.map(async number => number ** 2), async () => new constructor())([1, 2, 3, 4, 5]),
              new constructor([1, 4, 9, 16, 25])
            )
            assert.deepEqual(
              transform(Transducer.map(number => new constructor([number ** 2])), () => new constructor())([1, 2, 3, 4, 5]),
              new constructor([1, 4, 9, 16, 25])
            )
            assert.deepEqual(
              await transform(Transducer.map(async number => new constructor([number ** 2])), async () => new constructor())([1, 2, 3, 4, 5]),
              new constructor([1, 4, 9, 16, 25])
            )
          }
          for (const constructor of bigIntTypedArrayConstructors) {
            assert.deepEqual(
              transform(Transducer.map(number => number ** 2n), new constructor())([1n, 2n, 3n, 4n, 5n]),
              new constructor([1n, 4n, 9n, 16n, 25n])
            )
            assert.deepEqual(
              transform(Transducer.map(number => number ** 2n), () => new constructor())([1n, 2n, 3n, 4n, 5n]),
              new constructor([1n, 4n, 9n, 16n, 25n])
            )
            assert.deepEqual(
              await transform(Transducer.map(async number => number ** 2n), async () => new constructor())([1n, 2n, 3n, 4n, 5n]),
              new constructor([1n, 4n, 9n, 16n, 25n])
            )
            assert.deepEqual(
              transform(Transducer.map(number => new constructor([number ** 2n])), () => new constructor())([1n, 2n, 3n, 4n, 5n]),
              new constructor([1n, 4n, 9n, 16n, 25n])
            )
            assert.deepEqual(
              await transform(Transducer.map(async number => new constructor([number ** 2n])), async () => new constructor())([1n, 2n, 3n, 4n, 5n]),
              new constructor([1n, 4n, 9n, 16n, 25n])
            )
          }
        })
        it('init { concat: function }|()=>({ concat: function })', async () => {
          const Max = function (number) {
            this.number = number
          }
          Max.prototype.concat = function (otherMax) {
            return new Max(otherMax.constructor == Max
              ? Math.max(this.number, otherMax.number)
              : Math.max(this.number, otherMax))
          }
          assert.deepEqual(
            transform(Transducer.map(number => number ** 2), new Max(-Infinity))([1, 2, 3, 4, 5]),
            new Max(25),
          )
          assert.deepEqual(
            transform(Transducer.map(number => number ** 2), () => new Max(-Infinity))([1, 2, 3, 4, 5]),
            new Max(25),
          )
          assert.deepEqual(
            await transform(Transducer.map(async number => number ** 2), async () => new Max(-Infinity))([1, 2, 3, 4, 5]),
            new Max(25),
          )
        })
        it('init { write: function }|()=>({ write: function })', async () => {
          assert.deepEqual(
            transform(Transducer.map(number => number ** 2), new MockWritable([]))([1, 2, 3, 4, 5]),
            new MockWritable([1, 4, 9, 16, 25]),
          )
          assert.deepEqual(
            transform(Transducer.map(number => number ** 2), () => new MockWritable([]))([1, 2, 3, 4, 5]),
            new MockWritable([1, 4, 9, 16, 25]),
          )
          assert.deepEqual(
            await transform(Transducer.map(async number => number ** 2), async () => new MockWritable([]))([1, 2, 3, 4, 5]),
            new MockWritable([1, 4, 9, 16, 25]),
          )
          const numberToSquaredReadable = number => binaryToReadableStream(Buffer.from([number ** 2]))
          assert.deepEqual(
            await transform(Transducer.map(numberToSquaredReadable), new MockWritable([]))([1, 2, 3, 4, 5]),
            new MockWritable([1, 4, 9, 16, 25].map(number => new Uint8Array([number]))),
          )
          const numberToNumberObjectReadable = number => arrayToObjectReadableStream([{ number }])
          assert.deepEqual(
            await transform(Transducer.map(numberToNumberObjectReadable), new MockWritable([]))([1, 2, 3, 4, 5]),
            new MockWritable([
              { number: 1 },
              { number: 2 },
              { number: 3 },
              { number: 4 },
              { number: 5 },
            ]),
          )
          const numberToDuplicateString = number => `${number}${number}`
          assert.deepEqual(
            await transform(Transducer.map(numberToDuplicateString), new MockWritable([]))([1, 2, 3, 4, 5]),
            new MockWritable(['11', '22', '33', '44', '55']),
          )
          const numberToDuplicateUint8Array = number => new Uint8Array([number, number])
          assert.deepEqual(
            transform(Transducer.map(numberToDuplicateUint8Array), new MockWritable([]))([1, 2, 3, 4, 5]),
            new MockWritable([
              new Uint8Array([1, 1]),
              new Uint8Array([2, 2]),
              new Uint8Array([3, 3]),
              new Uint8Array([4, 4]),
              new Uint8Array([5, 5]),
            ]),
          )
          const numberToObjectNumber = number => ({ number })
          assert.deepEqual(
            transform(Transducer.map(numberToObjectNumber), new MockWritable([]))([1, 2, 3, 4, 5]),
            new MockWritable([
              { number: 1 },
              { number: 2 },
              { number: 3 },
              { number: 4 },
              { number: 5 },
            ]),
          )
          const toNull = () => null
          assert.deepEqual(
            transform(Transducer.map(toNull), new MockWritable([]))([1, 2, 3, 4, 5]),
            new MockWritable([null, null, null, null, null]),
          )
          const getEmptyReadable = () => binaryToReadableStream(Buffer.from([]))
          assert.deepEqual(
            await transform(Transducer.map(getEmptyReadable), new MockWritable([]))([1, 2, 3, 4, 5]),
            new MockWritable([]),
          )
          assert.throws(
            () => transform(Transducer.map(function () {
              throw new Error('hey')
            }), new MockWritable([]))([1, 2, 3, 4, 5]),
            new Error('hey'),
          )
        })
        it('init 3', async () => {
          assert.strictEqual(
            transform(Transducer.map(square), 3)([1, 2, 3, 4, 5]),
            3,
          )
        })
        it('init null|undefined', async () => {
          assert.strictEqual(
            transform(Transducer.map(square), null)([1, 2, 3, 4, 5]),
            null,
          )
          assert.strictEqual(
            transform(Transducer.map(square), undefined)([1, 2, 3, 4, 5]),
            undefined,
          )
          assert.strictEqual(
            transform(Transducer.map(square))([1, 2, 3, 4, 5]),
            undefined,
          )
        })
      })
    })
  })

  describe('transform - misc', () => {
    const squareOdds = compose([Transducer.filter(isOdd), Transducer.map(square)])
    const asyncEvens = Transducer.filter(asyncIsEven)
    const bigNumbers = [1n, 2n, 3n, 4n, 5n]
    const squareOddsToString = compose([
      Transducer.filter(isOdd),
      Transducer.map(pipe([square, x => `${x}`])),
    ])
    it('sync transforms iterable to null', async () => {
      let y = ''
      ase(transform(Transducer.map(tap(x => { y += x })), null)([1, 2, 3, 4, 5]), null)
      ase(y, '12345')
    })
    it('async transforms iterable to null', async () => {
      let y = ''
      aok(transform(Transducer.map(tap(async () => {})), null)([1, 2, 3, 4, 5]) instanceof Promise)
      ase(await transform(Transducer.map(tap(async x => { y += x })), null)([1, 2, 3, 4, 5]), null)
      ase(y, '12345')
    })
    it('sync transforms iterable to array', async () => {
      ade(transform(squareOdds, [])([1, 2, 3, 4, 5]), [1, 9, 25])
    })
    it('async transforms iterable to array', async () => {
      aok(transform(asyncEvens, [99])([1, 2, 3, 4, 5]) instanceof Promise)
      ade(await transform(asyncEvens, [99])([1, 2, 3, 4, 5]), [99, 2, 4])
    })
    it('sync transforms iterable to string', async () => {
      ase(transform(squareOdds, '')([1, 2, 3, 4, 5]), '1925')
    })
    it('async transforms iterable to string', async () => {
      aok(transform(asyncEvens, '99')([1, 2, 3, 4, 5]) instanceof Promise)
      ase(await transform(asyncEvens, '99')([1, 2, 3, 4, 5]), '9924')
    })
    it('sync transforms iterable to set', async () => {
      ade(transform(squareOdds, new Set())([1, 2, 3, 4, 5]), new Set([1, 9, 25]))
    })
    it('async transforms iterable to set', async () => {
      aok(transform(asyncEvens, new Set([99]))([1, 2, 3, 4, 5]) instanceof Promise)
      ade(
        await transform(asyncEvens, new Set([99, 2]))([1, 2, 3, 4, 5]),
        new Set([99, 2, 4]),
      )
    })
    it('strings are converted to numbers', async () => {
      for (const constructor of numberTypedArrayConstructors) {
        ade(
          transform(squareOddsToString, new constructor(0))([1, 2, 3, 4, 5]),
          new constructor([1, 9, 25]),
        )
      }
      ade(
        transform(squareOddsToString, Buffer.alloc(0))([1, 2, 3, 4, 5]),
        Buffer.from([1, 9, 25]),
      )
    })
    it('coerces booleans to 0 and 1', async () => {
      for (const constructor of numberTypedArrayConstructors) {
        assert.deepEqual(
          transform(Transducer.map(x => x), new constructor(0))([true, false, false]),
          new constructor([1, 0, 0])
        )
      }
      for (const constructor of bigIntTypedArrayConstructors) {
        assert.deepEqual(
          transform(Transducer.map(x => x), new constructor(0))([true, false, false]),
          new constructor([1n, 0n, 0n])
        )
      }
    })
    it('async transforms iterable to number TypedArray', async () => {
      for (const constructor of numberTypedArrayConstructors) {
        const buffer99 = new constructor([9, 9])
        const buffer9924 = transform(asyncEvens, buffer99)([1, 2, 3, 4, 5])
        aok(buffer9924 instanceof Promise)
        ade(await buffer9924, new constructor([9, 9, 2, 4]))
      }
    })
    it('sync transforms iterable to a bigint TypedArray', async () => {
      const isBigOdd = x => (x % 2n === 1n)
      const bigSquare = x => x ** 2n
      const squareBigOdds = compose([Transducer.filter(isBigOdd), Transducer.map(bigSquare)])
      for (const constructor of bigIntTypedArrayConstructors) {
        ade(
          transform(squareBigOdds, new constructor(0))(bigNumbers),
          new constructor([1n, 9n, 25n]),
        )
      }
    })
    it('async transforms iterable to a bigint TypedArray', async () => {
      const asyncIsBigEven = async x => (x % 2n === 0n)
      const asyncBigEvens = Transducer.filter(asyncIsBigEven)
      for (const constructor of bigIntTypedArrayConstructors) {
        const buffer99 = new constructor([9n, 9n])
        const buffer9924 = transform(asyncBigEvens, buffer99)(bigNumbers)
        aok(buffer9924 instanceof Promise)
        ade(await buffer9924, new constructor([9n, 9n, 2n, 4n]))
      }
    })

    it('sync transforms an iterable to an object', async () => {
      ade(
        transform(Transducer.map(n => ({ [n]: n })), {})([1, 2, 3, 4, 5]),
        { '1': 1, '2': 2, '3': 3, '4': 4, '5': 5 },
      )
    })
    it('async transforms an iterable to an object', async () => {
      aok(
        transform(Transducer.map(async n => [n, n]), {})([1, 2, 3, 4, 5]) instanceof Promise,
      )
      aok(
        transform(Transducer.map(async n => ({ [n]: n })), {})([1, 2, 3, 4, 5]) instanceof Promise,
      )
      ade(
        await transform(Transducer.map(async n => ({ [n]: n })), {})([1, 2, 3, 4, 5]),
        { '1': 1, '2': 2, '3': 3, '4': 4, '5': 5 },
      )
    })
    it('initial value can be a function', async () => {
      const square = x => x ** 2
      ade(
        transform(Transducer.map(square), () => [])([1, 2, 3]),
        [1, 4, 9],
      )
    })
    it('initial value can be an async function', async () => {
      const square = x => x ** 2
      aok(
        transform(Transducer.map(square), async () => [])([1, 2, 3]) instanceof Promise,
      )
      ade(
        await transform(Transducer.map(square), async () => [])([1, 2, 3]),
        [1, 4, 9],
      )
    })
    it('nonfunction initial values can be unsafe', async () => {
      const square = x => x ** 2
      const unsafeSquareAllTransform = transform(Transducer.map(square), [])
      ade(
        unsafeSquareAllTransform([1, 2, 3]),
        [1, 4, 9],
      )
      ade(
        unsafeSquareAllTransform([1, 2, 3]),
        [1, 4, 9, 1, 4, 9],
      )
      const safeSquareAllTransform = transform(Transducer.map(square), () => [])
      ade(
        safeSquareAllTransform([1, 2, 3]),
        [1, 4, 9],
      )
      ade(
        safeSquareAllTransform([1, 2, 3]),
        [1, 4, 9],
      )
    })
    it('=> [] for initial () => [] and input []', async () => {
      const square = x => x ** 2
      ade(
        transform(Transducer.map(square), () => [])([]),
        [],
      )
      const emptyAsyncIterator = (async function*(){})()
      ade(
        await transform(Transducer.map(square), () => [])(emptyAsyncIterator),
        [],
      )
    })
  })

  describe('flatMap', () => {
    describe(`
type FlatMappable = Array|String|Set|Iterator|AsyncIterator
type Iterable = Iterable|AsyncIterable|Object<value any>

flatMap(
  value FlatMappable,
  flatMapper (item any)=>Promise|Iterable,
) -> result Promise|FlatMappable

flatMap(
  flatMapper (item any)=>Promise|Iterable,
)(value FlatMappable) -> result Promise|FlatMappable
    `, () => {

      it('API coverage', async () => {
        assert.deepEqual(
          flatMap([1, 2, 3, 4, 5], number => isOdd(number) ? [number] : []),
          [1, 3, 5],
        )
        assert.deepEqual(
          flatMap(number => isOdd(number) ? [number] : [])([1, 2, 3, 4, 5]),
          [1, 3, 5],
        )
        assert.deepEqual(
          await flatMap(Promise.resolve([1, 2, 3, 4, 5]), number => isOdd(number) ? [number] : []),
          [1, 3, 5],
        )
      })

      const async = func => async function asyncFunc(...args) {
        return func(...args)
      }

      const numbersArray = [1, 2, 3, 4, 5]
      const numbersDuplicates = [1, 1, 2, 2, 3, 3, 4, 4, 5, 5]
      const numbersObject = { a: 1, b: 2, c: 3, d: 4, e: 5 }
      const numbersUint8Array = new Uint8Array([1, 2, 3, 4, 5])
      const numbersUint8ArrayDuplicates = new Uint8Array([1, 1, 2, 2, 3, 3, 4, 4, 5, 5])
      const numbersInt8Array = new Int8Array([1, 2, 3, 4, 5])
      const numbersInt8ArrayDuplicates = new Int8Array([1, 1, 2, 2, 3, 3, 4, 4, 5, 5])
      const numbersUint16Array = new Uint16Array([1, 2, 3, 4, 5])
      const numbersUint16ArrayDuplicates = new Uint16Array([1, 1, 2, 2, 3, 3, 4, 4, 5, 5])
      const numbersInt16Array = new Int16Array([1, 2, 3, 4, 5])
      const numbersInt16ArrayDuplicates = new Int16Array([1, 1, 2, 2, 3, 3, 4, 4, 5, 5])
      const numbersUint32Array = new Uint32Array([1, 2, 3, 4, 5])
      const numbersUint32ArrayDuplicates = new Uint32Array([1, 1, 2, 2, 3, 3, 4, 4, 5, 5])
      const numbersInt32Array = new Int32Array([1, 2, 3, 4, 5])
      const numbersInt32ArrayDuplicates = new Int32Array([1, 1, 2, 2, 3, 3, 4, 4, 5, 5])
      const numbersFloat32Array = new Float32Array([1, 2, 3, 4, 5])
      const numbersFloat32ArrayDuplicates = new Float32Array([1, 1, 2, 2, 3, 3, 4, 4, 5, 5])
      const numbersFloat64Array = new Float64Array([1, 2, 3, 4, 5])
      const numbersFloat64ArrayDuplicates = new Float64Array([1, 1, 2, 2, 3, 3, 4, 4, 5, 5])
      const numbersBigUint64Array = new BigUint64Array([1n, 2n, 3n, 4n, 5n])
      const numbersBigUint64ArrayDuplicates = new BigUint64Array([1n, 1n, 2n, 2n, 3n, 3n, 4n, 4n, 5n, 5n])
      const numbersBigInt64Array = new BigInt64Array([1n, 2n, 3n, 4n, 5n])
      const numbersBigInt64ArrayDuplicates = new BigInt64Array([1n, 1n, 2n, 2n, 3n, 3n, 4n, 4n, 5n, 5n])
      const bigIntsArray = [1n, 2n, 3n, 4n, 5n]
      const bigIntsDuplicates = [1n, 1n, 2n, 2n, 3n, 3n, 4n, 4n, 5n, 5n]
      const numbersSet = new Set([1, 2, 3, 4, 5])
      const bigIntsSet = new Set([1n, 2n, 3n, 4n, 5n])
      const numbersSetWithAyo = new Set([1, 2, 3, 4, 5, 'ayo'])
      const alphabetString = 'abcde'
      const numbersDuplexStream = new MockDuplexStream([1, 2, 3, 4, 5])
      const numbersGeneratorFunction = function* () { for (let i = 1; i < 6; i++) yield i }
      const asyncNumbersGeneratorFunction = async function* () { for (let i = 1; i < 6; i++) yield i }

      const identity = value => value
      const duplicateArray = value => [value, value]
      const duplicateObject = value => ({ [value * 10]: value, [value * 100]: value })
      const duplicateObjectString = value => ({ [value]: value, [`${value}${value}`]: value })
      const duplicateObjectBigInt = value => ({ [value * 10n]: value, [value * 100n]: value })
      const nestedObject = value => ({ a: { a: value }, b: { b: value } })
      const duplicateString = value => `${value}${value}`
      const setWithAyo = value => new Set([value, 'ayo'])
      const duplicateUint8ClampedArray = value => new Uint8ClampedArray([value, value])
      const duplicateUint8Array = value => new Uint8Array([value, value])
      const duplicateArrayOfUint8Array = value => [new Uint8Array([value]), new Uint8Array([value])]
      const duplicateInt8Array = value => new Int8Array([value, value])
      const duplicateUint16Array = value => new Uint16Array([value, value])
      const duplicateInt16Array = value => new Int16Array([value, value])
      const duplicateUint32Array = value => new Uint32Array([value, value])
      const duplicateInt32Array = value => new Int32Array([value, value])
      const duplicateFloat32Array = value => new Float32Array([value, value])
      const duplicateFloat64Array = value => new Float64Array([value, value])
      const duplicateBigUint64Array = value => new BigUint64Array([value, value])
      const duplicateBigInt64Array = value => new BigInt64Array([value, value])
      const duplicateReadableStream = value => binaryToReadableStream(Buffer.from([value, value]))
      const duplicateBuffer = value => Buffer.from([value, value])
      const duplicateMockFoldable = value => new MockFoldable([value, value])
      const duplicateAsyncMockFoldable = value => new AsyncMockFoldable([value, value])
      const duplicateMockFoldableObjects = value => new MockFoldable([{ [value * 10]: value }, { [value * 100]: value }])

      const DuplicateArray = function (value) {
        this.value = value
      }
      DuplicateArray.prototype = {
        chain(flatMapper) {
          return flatMapper([this.value, this.value])
        },
      }
      DuplicateArray.of = value => new DuplicateArray(value)

      const AsyncDuplicateArray = value => ({
        async chain(flatMapper) {
          return flatMapper([value, value])
        },
      })
      const AsyncDuplicateArrayFlatMap = value => ({
        async flatMap(flatMapper) {
          return flatMapper([value, value])
        },
      })

      const DuplicateObject = function (value) {
        this.value = value
      }
      DuplicateObject.prototype = {
        chain(flatMapper) {
          const value = this.value
          return flatMapper({ [value * 10]: value, [value * 100]: value })
        },
      }
      DuplicateObject.of = value => new DuplicateObject(value)

      const AsyncDuplicateObject = value => ({
        async chain(flatMapper) {
          return flatMapper({ [value * 10]: value, [value * 100]: value })
        }
      })
      const AsyncDuplicateObjectFlatMap = value => ({
        async flatMap(flatMapper) {
          return flatMapper({ [value * 10]: value, [value * 100]: value })
        }
      })

      const Identity = function (value) {
        this.value = value
      }
      Identity.prototype = {
        flatMap(flatMapper) {
          return flatMapper(this.value)
        },
      }
      Identity.of = value => new Identity(value)

      const assertions = [
        [Promise.resolve(1), identity, 1],
        [numbersArray, () => null, [null, null, null, null, null]],
        [numbersArray, () => [null, null], [null, null, null, null, null, null, null, null, null, null]],
        [numbersArray, () => undefined, [undefined, undefined, undefined, undefined, undefined]],
        [numbersArray, identity, numbersArray],
        [numbersArray, Promise.resolve.bind(Promise), numbersArray],
        [numbersArray, duplicateArray, numbersDuplicates],
        [numbersArray, async(duplicateArray), numbersDuplicates],
        [numbersArray, DuplicateArray.of, numbersArray.map(duplicateArray)], // calling .chain is 1 flat
        [numbersArray, async(DuplicateArray.of), numbersArray.map(duplicateArray)],
        [numbersArray, AsyncDuplicateArray, numbersArray.map(duplicateArray)], // calling .chain is 1 flat
        [numbersArray, async(AsyncDuplicateArray), numbersArray.map(duplicateArray)],
        [numbersArray, AsyncDuplicateArrayFlatMap, numbersArray.map(duplicateArray)], // calling .chain is 1 flat
        [numbersArray, async(AsyncDuplicateArrayFlatMap), numbersArray.map(duplicateArray)],
        [numbersArray, Identity.of, numbersArray],
        [numbersArray, async(Identity.of), numbersArray],
        [numbersArray, duplicateMockFoldable, numbersDuplicates],
        [numbersArray, async(duplicateMockFoldable), numbersDuplicates],
        [numbersArray, duplicateAsyncMockFoldable, numbersDuplicates],
        [numbersArray, async(duplicateAsyncMockFoldable), numbersDuplicates],
        [numbersArray, duplicateObject, numbersDuplicates],
        [numbersArray, async(duplicateObject), numbersDuplicates],
        [numbersArray, duplicateString, ['1', '1', '2', '2', '3', '3', '4', '4', '5', '5']],
        [numbersArray, async(duplicateString), ['1', '1', '2', '2', '3', '3', '4', '4', '5', '5']],
        [numbersArray, setWithAyo, [1, 'ayo', 2, 'ayo', 3, 'ayo', 4, 'ayo', 5, 'ayo']],
        [numbersArray, async(setWithAyo), [1, 'ayo', 2, 'ayo', 3, 'ayo', 4, 'ayo', 5, 'ayo']],
        [numbersArray, duplicateUint8ClampedArray, numbersDuplicates],
        [numbersArray, async(duplicateUint8ClampedArray), numbersDuplicates],
        [numbersArray, duplicateUint8Array, numbersDuplicates],
        [numbersArray, async(duplicateUint8Array), numbersDuplicates],
        [numbersArray, duplicateInt8Array, numbersDuplicates],
        [numbersArray, async(duplicateInt8Array), numbersDuplicates],
        [numbersArray, duplicateUint16Array, numbersDuplicates],
        [numbersArray, async(duplicateUint16Array), numbersDuplicates],
        [numbersArray, duplicateInt16Array, numbersDuplicates],
        [numbersArray, async(duplicateInt16Array), numbersDuplicates],
        [numbersArray, duplicateUint32Array, numbersDuplicates],
        [numbersArray, async(duplicateUint32Array), numbersDuplicates],
        [numbersArray, duplicateInt32Array, numbersDuplicates],
        [numbersArray, async(duplicateInt32Array), numbersDuplicates],
        [numbersArray, duplicateFloat32Array, numbersDuplicates],
        [numbersArray, async(duplicateFloat32Array), numbersDuplicates],
        [numbersArray, duplicateFloat64Array, numbersDuplicates],
        [numbersArray, async(duplicateFloat64Array), numbersDuplicates],
        [numbersArray, duplicateReadableStream, numbersArray.map(duplicateBuffer)], // 1 flat removes the stream
        [numbersArray, async(duplicateReadableStream), numbersArray.map(duplicateBuffer)],
        [bigIntsArray, identity, bigIntsArray],
        [bigIntsArray, duplicateBigUint64Array, bigIntsDuplicates],
        [bigIntsArray, async(duplicateBigUint64Array), bigIntsDuplicates],
        [bigIntsArray, duplicateBigInt64Array, bigIntsDuplicates],
        [bigIntsArray, async(duplicateBigInt64Array), bigIntsDuplicates],

        [alphabetString, identity, alphabetString],
        [alphabetString, duplicateArray, 'aabbccddee'],
        [alphabetString, async(duplicateArray), 'aabbccddee'],
        [alphabetString, DuplicateArray.of, 'a,ab,bc,cd,de,e'], // calling .chain is 1 flat
        [alphabetString, async(DuplicateArray.of), 'a,ab,bc,cd,de,e'],
        [alphabetString, Identity.of, alphabetString],
        [alphabetString, async(Identity.of), alphabetString],
        [alphabetString, duplicateMockFoldable, 'aabbccddee'],
        [alphabetString, async(duplicateMockFoldable), 'aabbccddee'],
        [alphabetString, duplicateAsyncMockFoldable, 'aabbccddee'],
        [alphabetString, async(duplicateAsyncMockFoldable), 'aabbccddee'],
        [alphabetString, duplicateObjectString, 'aabbccddee'],
        [alphabetString, async(duplicateObjectString), 'aabbccddee'],
        [alphabetString, duplicateString, 'aabbccddee'],
        [alphabetString, async(duplicateString), 'aabbccddee'],
        [alphabetString, setWithAyo, 'aayobayocayodayoeayo'],
        [alphabetString, async(setWithAyo), 'aayobayocayodayoeayo'],

        [numbersSet, identity, numbersSet],
        [numbersSet, () => null, new Set([null])],
        [numbersSet, duplicateArray, numbersSet],
        [numbersSet, async(duplicateArray), numbersSet],
        [numbersSet, DuplicateArray.of, new Set([...numbersSet].map(duplicateArray))],
        [numbersSet, async(DuplicateArray.of), new Set([...numbersSet].map(duplicateArray))],
        [numbersSet, Identity.of, numbersSet],
        [numbersSet, async(Identity.of), numbersSet],
        [numbersSet, duplicateMockFoldable, numbersSet],
        [numbersSet, async(duplicateMockFoldable), numbersSet],
        [numbersSet, duplicateAsyncMockFoldable, numbersSet],
        [numbersSet, async(duplicateAsyncMockFoldable), numbersSet],
        [numbersSet, duplicateObject, numbersSet],
        [numbersSet, async(duplicateObject), numbersSet],
        [numbersSet, setWithAyo, new Set([1, 2, 3, 4, 5, 'ayo'])],
        [numbersSet, async(setWithAyo), new Set([1, 2, 3, 4, 5, 'ayo'])],
        [numbersSet, duplicateString, new Set(['1', '2', '3', '4', '5'])],
        [numbersSet, async(duplicateString), new Set(['1', '2', '3', '4', '5'])],
        [numbersSet, duplicateUint8Array, numbersSet],
        [numbersSet, async(duplicateUint8Array), numbersSet],
        [numbersSet, duplicateInt8Array, numbersSet],
        [numbersSet, async(duplicateInt8Array), numbersSet],
        [numbersSet, duplicateUint16Array, numbersSet],
        [numbersSet, async(duplicateUint16Array), numbersSet],
        [numbersSet, duplicateInt16Array, numbersSet],
        [numbersSet, async(duplicateInt16Array), numbersSet],
        [numbersSet, duplicateUint32Array, numbersSet],
        [numbersSet, async(duplicateUint32Array), numbersSet],
        [numbersSet, duplicateInt32Array, numbersSet],
        [numbersSet, async(duplicateInt32Array), numbersSet],
        [numbersSet, duplicateFloat32Array, numbersSet],
        [numbersSet, async(duplicateFloat32Array), numbersSet],
        [numbersSet, duplicateFloat64Array, numbersSet],
        [numbersSet, async(duplicateFloat64Array), numbersSet],
        [numbersSet, duplicateReadableStream, new Set(numbersArray.map(duplicateBuffer))],
        [numbersSet, async(duplicateReadableStream), new Set(numbersArray.map(duplicateBuffer))],

        [numbersGeneratorFunction(), identity, numbersArray, function (expected, actual) {
          assert.deepEqual([...actual], expected)
        }],
        [numbersGeneratorFunction(), duplicateArray, numbersDuplicates, function (expected, actual) {
          assert.deepEqual([...actual], expected)
        }],
        [numbersGeneratorFunction(), async(duplicateArray), numbersArray.map(duplicateArray), async function (expected, actual) {
          assert.deepEqual(await Promise.all(actual), expected) // flatten will only see promises, so async does not get flattened
        }],
        [numbersGeneratorFunction(), DuplicateArray.of, numbersArray.map(duplicateArray), function (expected, actual) {
          assert.deepEqual([...actual], expected)
        }],
        [numbersGeneratorFunction(), async(DuplicateArray.of), numbersArray.map(DuplicateArray.of), async function (expected, actual) {
          assert.deepEqual(await Promise.all(actual), expected) // flatten will only see promises, so async does not get flattened
        }],
        [numbersGeneratorFunction(), Identity.of, numbersArray, function (expected, actual) {
          const actualArray = [...actual]
          assert.deepEqual(actualArray, expected)
        }],
        [numbersGeneratorFunction(), async(Identity.of), numbersArray.map(Identity.of), async function (expected, actual) {
          assert.deepEqual(await Promise.all(actual), expected) // flatten will only see promises, so async does not get flattened
        }],
        [numbersGeneratorFunction(), duplicateMockFoldable, numbersDuplicates, function (expected, actual) {
          assert.deepEqual([...actual], expected)
        }],
        [numbersGeneratorFunction(), async(duplicateMockFoldable), numbersArray.map(duplicateMockFoldable), async function (expected, actual) {
          assert.deepEqual(await Promise.all(actual), expected) // flatten will only see promises, so async does not get flattened
        }],
        [numbersGeneratorFunction(), duplicateObject, numbersDuplicates, function (expected, actual) {
          assert.deepEqual([...actual], expected)
        }],
        [numbersGeneratorFunction(), async(duplicateObject), numbersArray.map(duplicateObject), async function (expected, actual) {
          assert.deepEqual(await Promise.all(actual), expected) // flatten will only see promises, so async does not get flattened
        }],

        [asyncNumbersGeneratorFunction(), identity, numbersArray, async function (expected, actual) {
          const actualArray = []
          for await (const item of actual) actualArray.push(item)
          assert.deepEqual(actualArray, expected)
        }],
        [asyncNumbersGeneratorFunction(), duplicateArray, numbersDuplicates, async function (expected, actual) {
          const actualArray = []
          for await (const item of actual) actualArray.push(item)
          assert.deepEqual(actualArray, expected)
        }],
        [asyncNumbersGeneratorFunction(), async(duplicateArray), numbersDuplicates, async function (expected, actual) {
          const actualArray = []
          for await (const item of actual) actualArray.push(item)
          assert.deepEqual(actualArray, expected)
        }],

        [asyncNumbersGeneratorFunction(), DuplicateArray.of, numbersArray.map(duplicateArray), async function (expected, actual) {
          const actualArray = []
          for await (const item of actual) actualArray.push(item)
          assert.deepEqual(actualArray, expected)
        }],

        [asyncNumbersGeneratorFunction(), async(DuplicateArray.of), numbersArray.map(duplicateArray), async function (expected, actual) {
          const actualArray = []
          for await (const item of actual) actualArray.push(item)
          assert.deepEqual(actualArray, expected)
        }],
        [asyncNumbersGeneratorFunction(), duplicateMockFoldable, numbersDuplicates, async function (expected, actual) {
          const actualArray = []
          for await (const item of actual) actualArray.push(item)
          assert.deepEqual(actualArray, expected)
        }],
        [asyncNumbersGeneratorFunction(), async(duplicateMockFoldable), numbersDuplicates, async function (expected, actual) {
          const actualArray = []
          for await (const item of actual) actualArray.push(item)
          assert.deepEqual(actualArray, expected)
        }],
        [asyncNumbersGeneratorFunction(), duplicateObject, numbersDuplicates, async function (expected, actual) {
          const actualArray = []
          for await (const item of actual) actualArray.push(item)
          assert.deepEqual(actualArray, expected)
        }],
        [asyncNumbersGeneratorFunction(), async(duplicateObject), numbersDuplicates, async function (expected, actual) {
          const actualArray = []
          for await (const item of actual) actualArray.push(item)
          assert.deepEqual(actualArray, expected)
        }],
        [asyncNumbersGeneratorFunction(), duplicateString, numbersDuplicates, async function (expected, actual) {
          const actualArray = []
          for await (const item of actual) actualArray.push(item)
          assert.deepEqual(actualArray, expected)
        }],
        [asyncNumbersGeneratorFunction(), async(duplicateString), numbersDuplicates, async function (expected, actual) {
          const actualArray = []
          for await (const item of actual) actualArray.push(item)
          assert.deepEqual(actualArray, expected)
        }],
        [asyncNumbersGeneratorFunction(), duplicateBuffer, numbersDuplicates, async function (expected, actual) {
          const actualArray = []
          for await (const item of actual) actualArray.push(item)
          assert.deepEqual(actualArray, expected)
        }],
        [asyncNumbersGeneratorFunction(), async(duplicateBuffer), numbersDuplicates, async function (expected, actual) {
          const actualArray = []
          for await (const item of actual) actualArray.push(item)
          assert.deepEqual(actualArray, expected)
        }],
        [asyncNumbersGeneratorFunction(), duplicateUint8Array, numbersDuplicates, async function (expected, actual) {
          const actualArray = []
          for await (const item of actual) actualArray.push(item)
          assert.deepEqual(actualArray, expected)
        }],
        [asyncNumbersGeneratorFunction(), async(duplicateUint8Array), numbersDuplicates, async function (expected, actual) {
          const actualArray = []
          for await (const item of actual) actualArray.push(item)
          assert.deepEqual(actualArray, expected)
        }],
        [asyncNumbersGeneratorFunction(), duplicateReadableStream, numbersArray.map(duplicateBuffer), async function (expected, actual) {
          const actualArray = []
          for await (const item of actual) actualArray.push(item)
          assert.deepEqual(actualArray, expected)
        }],
        [asyncNumbersGeneratorFunction(), async(duplicateReadableStream), numbersArray.map(duplicateBuffer), async function (expected, actual) {
          const actualArray = []
          for await (const item of actual) actualArray.push(item)
          assert.deepEqual(actualArray, expected)
        }],

        [numbersObject, identity, {}],
        [numbersObject, async(identity), {}],
        [numbersObject, duplicateArray, {}],
        [numbersObject, async(duplicateArray), {}],
        [numbersObject, number => [{ [number]: number }, { [number]: number }], { 1: 1, 2: 2, 3: 3, 4: 4, 5: 5 }],
        [numbersObject, number => null, {}],
        [numbersObject, number => [{ [number]: null }, { [number]: null }], { 1: null, 2: null, 3: null, 4: null, 5: null }],
        [numbersObject, duplicateObject, {
          '10': 1, '100': 1, '20': 2, '200': 2, '30': 3, '300': 3, '40': 4, '400': 4, '50': 5, '500': 5,
        }],
        [numbersObject, async(duplicateObject), {
          '10': 1, '100': 1, '20': 2, '200': 2, '30': 3, '300': 3, '40': 4, '400': 4, '50': 5, '500': 5,
        }],
        [numbersObject, duplicateReadableStream, { 0: 5, 1: 5 }],
        [numbersObject, async(duplicateReadableStream), { 0: 5, 1: 5 }],
        [numbersObject, duplicateObjectString, { 1: 1, 11: 1, 2: 2, 22: 2, 3: 3, 33: 3, 4: 4, 44: 4, 5: 5, 55: 5 }],
        [numbersObject, async(duplicateObjectString), { 1: 1, 11: 1, 2: 2, 22: 2, 3: 3, 33: 3, 4: 4, 44: 4, 5: 5, 55: 5 }],
        [numbersObject, duplicateMockFoldable, {}],
        [numbersObject, duplicateAsyncMockFoldable, {}],
        [numbersObject, async(duplicateMockFoldable), {}],
        [numbersObject, duplicateMockFoldableObjects, { 10: 1, 100: 1, 20: 2, 200: 2, 30: 3, 300: 3, 40: 4, 400: 4, 50: 5, 500: 5 }],
        [numbersObject, async(duplicateMockFoldableObjects), { 10: 1, 100: 1, 20: 2, 200: 2, 30: 3, 300: 3, 40: 4, 400: 4, 50: 5, 500: 5 }],
        [numbersObject, DuplicateObject.of, { 10: 1, 100: 1, 20: 2, 200: 2, 30: 3, 300: 3, 40: 4, 400: 4, 50: 5, 500: 5 }],
        [numbersObject, async(DuplicateObject.of), { 10: 1, 100: 1, 20: 2, 200: 2, 30: 3, 300: 3, 40: 4, 400: 4, 50: 5, 500: 5 }],
        [numbersObject, AsyncDuplicateObject, { 10: 1, 100: 1, 20: 2, 200: 2, 30: 3, 300: 3, 40: 4, 400: 4, 50: 5, 500: 5 }],
        [numbersObject, async(AsyncDuplicateObject), { 10: 1, 100: 1, 20: 2, 200: 2, 30: 3, 300: 3, 40: 4, 400: 4, 50: 5, 500: 5 }],
        [numbersObject, AsyncDuplicateObjectFlatMap, { 10: 1, 100: 1, 20: 2, 200: 2, 30: 3, 300: 3, 40: 4, 400: 4, 50: 5, 500: 5 }],
        [numbersObject, async(AsyncDuplicateObjectFlatMap), { 10: 1, 100: 1, 20: 2, 200: 2, 30: 3, 300: 3, 40: 4, 400: 4, 50: 5, 500: 5 }],
        [numbersObject, Identity.of, {}],
        [numbersObject, async(Identity.of), {}],
        [{ a: { a: 1 }, b: { b: 2 }, c: { c: 3 }, d: { d: 4 }, e: { e: 5 } }, Identity.of, numbersObject],
        [{ a: { a: 1 }, b: { b: 2 }, c: { c: 3 }, d: { d: 4 }, e: { e: 5 } }, async(Identity.of), numbersObject],

        [{ chain: flatMapper => flatMapper('ayo') }, duplicateArray, ['ayo', 'ayo']],
        [{ chain: flatMapper => flatMapper('ayo') }, async(duplicateArray), ['ayo', 'ayo']],
        [DuplicateArray.of('ayo'), DuplicateArray.of, DuplicateArray.of(['ayo', 'ayo'])],
        [DuplicateArray.of('ayo'), async(DuplicateArray.of), DuplicateArray.of(['ayo', 'ayo'])],
        [Identity.of('ayo'), Identity.of, Identity.of('ayo')],
        [Identity.of('ayo'), async(Identity.of), Identity.of('ayo')],

      ]

      const arrayOfLast = (array, n = 1) => array.slice(array.length - n, array.length)

      assertions.forEach(function ([value, flatMapper, result, asserter = assert.deepEqual]) {
        it(`flatMap(${flatMapper.name})(${value.constructor.name}<${value}>) - ${result}`, async () => {
          await asserter(
            result,
            await flatMap(flatMapper)(value),
          )
        })
      })

      it('value undefined', async () => {
        assert.strictEqual(flatMap(() => 'hey')(undefined), 'hey')
        assert.strictEqual(flatMap(() => 'hey')(), 'hey')
      })
      it('value null', async () => {
        assert.strictEqual(flatMap(() => 'hey')(null), 'hey')
      })

      it('value number', async () => {
        assert.deepEqual(flatMap(duplicateArray)(1), [1, 1])
        assert.deepEqual(flatMap(1, duplicateArray), [1, 1])
      })
    })

    describe('FlatMappingAsyncIterator', () => {
      const asyncNumbers = async function* () {
        yield 1; yield 2; yield 3; yield 4; yield 5
      }
      const flatMappingAsyncIterator = flatMap(value => value)(asyncNumbers())
      it('[object FlatMappingAsyncIterator]', async () => {
        assert.strictEqual(flatMappingAsyncIterator.toString(), '[object FlatMappingAsyncIterator]')
      })
    })
  })

  describe('flatMap - misc', () => {
    it('maps then flattens an array, async + parallel', async () => {
      const asyncPowers = async x => [x ** 2, x ** 3]
      aok(flatMap(asyncPowers)([1, 2, 3, 4, 5]) instanceof Promise)
      ade(
        await flatMap(asyncPowers)([1, 2, 3, 4, 5]),
        [1, 1, 4, 8, 9, 27, 16, 64, 25, 125],
      )
    })
    it('maps then flattens an array, sync', async () => {
      const powers = x => [x ** 2, x ** 3]
      ade(
        flatMap(powers)([1, 2, 3, 4, 5]),
        [1, 1, 4, 8, 9, 27, 16, 64, 25, 125],
      )
      ade(
        flatMap(powers)([1, 2, 3, 4, 5]),
        [1, 1, 4, 8, 9, 27, 16, 64, 25, 125],
      )
      ade(
        flatMap(x => new Set([x ** 2]))([1, 2, 3, 4, 5]),
        [1, 4, 9, 16, 25],
      )
      ade(
        flatMap(
          x => x,
        )(
          flatMap(x => new Map([[x, x ** 2]]))([1, 2, 3, 4, 5]),
        ),
        [1, 1, 2, 4, 3, 9, 4, 16, 5, 25],
      )
      ade(
        flatMap(x => x)([1, 2, [3, 4], 5]),
        [1, 2, 3, 4, 5],
      )
    })
    it('maps then flattens objects', async () => {
      const createObject = () => ({ a: 1, b: 2, c: 3 })
      ade(
        flatMap(x => x)(arrayOf(createObject, 3)),
        [1, 2, 3, 1, 2, 3, 1, 2, 3],
      )
    })
    it('maps then flattens a Set', async () => {
      const powers = x => [x ** 2, x ** 3]
      ade(
        flatMap(
          powers,
        )(new Set([1, 2, 3])),
        new Set([1, 4, 8, 9, 27]),
      )
      ade(
        flatMap(
          x => new Set(powers(x)),
        )(new Set([1, 2, 3])),
        new Set([1, 4, 8, 9, 27]),
      )
    })
    it('maps then flattens objects', async () => {
      ade(
        flatMap(x => ({ square: x ** 2, cube: x ** 3 }))(new Set([1, 2, 3])),
        new Set([1, 4, 8, 9, 27])
      )
    })
    it('[async] maps then flattens a Set', async () => {
      const powers = async x => [x ** 2, x ** 3]
      aok(
        flatMap(
          powers,
        )(new Set([1, 2, 3])) instanceof Promise
      )
      ade(
        await flatMap(
          powers,
        )(new Set([1, 2, 3])),
        new Set([1, 4, 8, 9, 27]),
      )
      aok(
        flatMap(
          x => powers(x).then(x => new Set(x))
        )(new Set([1, 2, 3])) instanceof Promise
      )
      ade(
        await flatMap(
          x => powers(x).then(x => new Set(x))
        )(new Set([1, 2, 3])),
        new Set([1, 4, 8, 9, 27]),
      )
    })
    it('maps then flattens a reducer function', async () => {
      const powers = x => [x ** 2, x ** 3]
      ade(
        transform(
          Transducer.flatMap(powers),
          [],
        )([1, 2, 3]),
        [1, 1, 4, 8, 9, 27],
      )
    })
    it('[async] maps then flattens a reducer function', async () => {
      const powers = async x => [x ** 2, x ** 3]
      aok(
        transform(
          Transducer.flatMap(powers),
          [],
        )([1, 2, 3]) instanceof Promise
      )
      ade(
        await transform(
          Transducer.flatMap(powers),
          [],
        )([1, 2, 3]),
        [1, 1, 4, 8, 9, 27],
      )
    })
  })

  describe('forEach', () => {
    describe(`
     Reducer<T> = (any, T)=>Promise|any

     var T any,
       callback T=>(),
       collection Iterable<T>|AsyncIterable<T>{ forEach: callback=>() }|Object<T>
       
     forEach(callback)(collection) -> ()
    `,
    () => {
      it('API coverage', async () => {
        let sum1 = 0
        forEach([1, 2, 3, 4, 5], number => {
          sum1 += number
        })
        assert.equal(sum1, 15)

        let sum2 = 0
        await forEach(Promise.resolve([1, 2, 3, 4, 5]), number => {
          sum2 += number
        })
        assert.equal(sum2, 15)
      })
      it('collection Array testing promises', async () => {
        let total = 0
        const addTotal = number => (total += number),
          variadicAsyncAddTotal = number => number % 2 == 1 ? (total += number) : Promise.resolve(total += number)
        forEach(addTotal)([1, 2, 3, 4, 5])
        assert.strictEqual(total, 15)
        total = 0
        const operation = forEach(async(addTotal))([1, 2, 3, 4, 5])
        assert(typeof operation.then == 'function')
        await operation
        assert.strictEqual(total, 15)
      })

      let total = 0
      const addTotal = number => (total += number),
        variadicAsyncAddTotal = number => number % 2 == 1 ? (total += number) : Promise.resolve(total += number)

      const ThunkAssertion = (
        func, value, asserter,
      ) => function thunkAssertion() {
        it(`${func.name}(${util.inspect(value)}) - ${asserter}`, async () => {
          await asserter(await func(value))
        })
      }

      const numbersGenerator = function* () {
        yield 1; yield 2; yield 3; yield 4; yield 5
      }
      const numbersAsyncGenerator = async function* () {
        yield 1; yield 2; yield 3; yield 4; yield 5
      }

      const thunkAssertions = [
        ThunkAssertion(forEach(addTotal), [1, 2, 3, 4, 5], result => {
          assert.deepEqual(result, [1, 2, 3, 4, 5])
          assert.strictEqual(total, 15)
          total = 0
        }),

        ThunkAssertion(forEach(async(addTotal)), [1, 2, 3, 4, 5], result => {
          assert.deepEqual(result, [1, 2, 3, 4, 5])
          assert.strictEqual(total, 15)
          total = 0
        }),

        ThunkAssertion(forEach(variadicAsyncAddTotal), [1, 2, 3, 4, 5], result => {
          assert.deepEqual(result, [1, 2, 3, 4, 5])
          assert.strictEqual(total, 15)
          total = 0
        }),

        ThunkAssertion(forEach(addTotal), numbersGenerator(), result => {
          assert.deepEqual([...result], [])
          assert.strictEqual(total, 15)
          total = 0
        }),

        ThunkAssertion(forEach(async(addTotal)), numbersGenerator(), result => {
          assert.deepEqual([...result], [])
          assert.strictEqual(total, 15)
          total = 0
        }),
        ThunkAssertion(forEach(variadicAsyncAddTotal), numbersGenerator(), result => {
          assert.deepEqual([...result], [])
          assert.strictEqual(total, 15)
          total = 0
        }),
        ThunkAssertion(forEach(addTotal), numbersAsyncGenerator(), async result => {
          assert.deepEqual(await asyncIteratorToArray(result), [])
          assert.strictEqual(total, 15)
          total = 0
        }),
        ThunkAssertion(forEach(async(addTotal)), numbersAsyncGenerator(), async result => {
          assert.deepEqual(await asyncIteratorToArray(result), [])
          assert.strictEqual(total, 15)
          total = 0
        }),
        ThunkAssertion(forEach(variadicAsyncAddTotal), numbersAsyncGenerator(), async result => {
          assert.deepEqual(await asyncIteratorToArray(result), [])
          assert.strictEqual(total, 15)
          total = 0
        }),
        ThunkAssertion(forEach(addTotal), { a: 1, b: 2, c: 3, d: 4, e: 5 }, result => {
          assert.deepEqual(result, { a: 1, b: 2, c: 3, d: 4, e: 5 })
          assert.strictEqual(total, 15)
          total = 0
        }),
        ThunkAssertion(forEach(async(addTotal)), { a: 1, b: 2, c: 3, d: 4, e: 5 }, result => {
          assert.deepEqual(result, { a: 1, b: 2, c: 3, d: 4, e: 5 })
          assert.strictEqual(total, 15)
          total = 0
        }),
        ThunkAssertion(forEach(variadicAsyncAddTotal), { a: 1, b: 2, c: 3, d: 4, e: 5 }, result => {
          assert.deepEqual(result, { a: 1, b: 2, c: 3, d: 4, e: 5 })
          assert.strictEqual(total, 15)
          total = 0
        }),
      ]

      thunkAssertions.forEach(thunk => thunk())

      const noop = function () {}
      it('forEach(noop)(1)', async () => {
        assert.strictEqual(forEach(noop)(1), 1)
      })
      it('forEach(noop)(null)', async () => {
        assert.strictEqual(forEach(noop)(null), null)
      })
      it('forEach(noop)(undefined)', async () => {
        assert.strictEqual(forEach(noop)(undefined), undefined)
      })
      it('forEach(noop)()', async () => {
        assert.strictEqual(forEach(noop)(), undefined)
      })

      it('execute a function for each item of a collection, returning the collection', async () => {
        let total = 0
        assert.deepEqual(
          forEach(number => total += number)([1, 2, 3]),
          [1, 2, 3],
        )
        assert.strictEqual(total, 6)
      })
    })
  })

  describe('forEach.series', () => {
    it('arrays', async () => {
      const array = [100, 80, 60, 40, 20]
      const result = []
      await forEach.series(array, async item => {
        await sleep(item)
        result.push(item)
      })

      assert.deepEqual(result, [100, 80, 60, 40, 20])

      const result1 = []
      await forEach.series(async item => {
        await sleep(item)
        result1.push(item)
      })(array)

      assert.deepEqual(result1, [100, 80, 60, 40, 20])

      const result2 = []
      await forEach.series(array, item => {
        result2.push(item)
      })
      assert.deepEqual(result2, [100, 80, 60, 40, 20])
    }).timeout(60000)

    it('objects', async () => {
      const obj = { a: 100, b: 80, c: 60, d: 40, e: 20 }
      const result = []
      await forEach.series(obj, async item => {
        await sleep(item)
        result.push(item)
      })
      assert.deepEqual(result, [100, 80, 60, 40, 20])

      const result1 = []
      await forEach.series(async item => {
        await sleep(item)
        result1.push(item)
      })(obj)
      assert.deepEqual(result1, [100, 80, 60, 40, 20])

      const result2 = []
      forEach.series(obj, item => {
        result2.push(item)
      })
      assert.deepEqual(result2, [100, 80, 60, 40, 20])
    }).timeout(60000)

    it('objects varying async', async () => {
      const obj = { a: 100, b: 80, c: 60, d: 40, e: 20 }
      const result = []
      await forEach.series(obj, item => {
        if (item < 50) {
          return Promise.resolve(item).then(item => {
            result.push(item)
          })
        }
        result.push(item)
        return undefined
      })
      assert.equal(result.length, 5)
    })

    it('iterators', async () => {
      const gen = function* () {
        yield 100; yield 80; yield 60; yield 40; yield 20
      }

      const result = []
      await forEach.series(gen(), async item => {
        await sleep(item)
        result.push(item)
      })

      assert.deepEqual(result, [100, 80, 60, 40, 20])

      const result1 = []
      await forEach.series(async item => {
        await sleep(item)
        result1.push(item)
      })(gen())

      assert.deepEqual(result1, [100, 80, 60, 40, 20])
    }).timeout(60000)

    it('asyncIterators', async () => {
      const gen = async function* () {
        yield 100; yield 80; yield 60; yield 40; yield 20
      }

      const result = []
      await forEach.series(gen(), async item => {
        await sleep(item)
        result.push(item)
      })

      assert.deepEqual(result, [100, 80, 60, 40, 20])

      const result1 = []
      await forEach.series(async item => {
        await sleep(item)
        result1.push(item)
      })(gen())

      assert.deepEqual(result1, [100, 80, 60, 40, 20])
    }).timeout(60000)

    it('other', async () => {
      assert.throws(
        () => forEach.series(1, () => {}),
        new TypeError('invalid collection 1'),
      )

      assert.throws(
        () => forEach.series(null, () => {}),
        new TypeError('invalid collection null'),
      )

      assert.throws(
        () => forEach.series(undefined, () => {}),
        new TypeError('invalid collection undefined'),
      )
    })
  })

  describe('get', () => {
    const aaaaa = { a: { a: { a: { a: { a: 1 } } } } }
    const nested = [[[[[1]]]]]
    it('API coverage', async () => {
      ase(get({ a: 1 }, 'a'), 1)
      ase(get(null, 'a'), undefined)
      ase(get(undefined, 'a'), undefined)
      ase(await get(Promise.resolve({ a: 1 }), 'a'), 1)
      ase(get('a')({ a: 1 }), 1)
    })
    it('accesses a property of an object by name', async () => {
      ase(get('a')({ a: 1 }), 1)
      ase(get('b')({ a: 1 }), undefined)
      ase(get('b', 0)({ a: 1 }), 0)
      ase(get(0)([1]), 1)
      ase(get(1)([1]), undefined)
      ase(get(1, 0)([1]), 0)
    })
    it('accesses a property by array[index]', async () => {
      ase(get('[0][0][0][0][0]')(nested), 1)
      ase(get('[0][0][0][0][0')(nested), 1)
      ase(get('0][0][0][0][0]')(nested), 1)
      ase(get('0][0][0][0][0')(nested), 1)
    })
    it('accesses a property of an object by dot notation', async () => {
      ase(get('a.a.a.a.a')(aaaaa), 1)
      ase(get('a.a.a.a.b')(aaaaa), undefined)
      ase(get('a.a.a.a.b', 0)(aaaaa), 0)
      ase(get('0.0.0.0.0')(nested), 1)
      ase(get('0.0.0.0.1')(nested), undefined)
      ase(get('0.0.0.0.1', 0)(nested), 0)
    })
    it('accesses a property of an object by array', async () => {
      ase(get(['a', 'a', 'a', 'a', 'a'])(aaaaa), 1)
      ase(get(['a', 'a', 'a', 'a', 'b'])(aaaaa), undefined)
      ase(get(['a', 'a', 'a', 'a', 'b'], 0)(aaaaa), 0)
      ase(get([0, 0, 0, 0, 0])(nested), 1)
      ase(get([0, 0, 0, 0, 1])(nested), undefined)
      ase(get([0, 0, 0, 0, 1], 0)(nested), 0)
      ase(get(['a', 0])({ a: [1] }), 1)
    })
    it('handles null and undefined initial value with default or undefined', async () => {
      ase(get('a')(null), undefined)
      ase(get('a', () => 'yo')(null), 'yo')
      ase(get('a', 'yo')(null), 'yo')
      ase(get('a', 'yo')(undefined), 'yo')
    })
    it('defaultValue can be a function', async () => {
      ase(get('a', obj => obj.b)({ b: 1 }), 1)
      ase(get('a', obj => obj.b)({}), undefined)
    })
    it('clears cache at size 500', async () => {
    })
  })

  describe('set', () => {
    it('set a property of an object', async () => {
      ade(set('a', 1)(null), null)
      ade(set('a', 1)(undefined), undefined)
      ade(set('a', 1)('yo'), 'yo')
      ade(set('a', 1)({ b: 2 }), { a: 1, b: 2 })
      ade(await set('a', Promise.resolve(1))({ b: 2 }), { a: 1, b: 2 })
      ade(set('a.b', 1)({ a: { c: 2 } }), { a: { b: 1, c: 2 } })
      ade(set('a.b', 1)({ a: 1 }), { a: { b: 1 } })
      ade(set(['a', 'b'], 1)({ a: { c: 2 } }), { a: { b: 1, c: 2 } })
      ade(set('a[0].b.c', 4)({ 'a': [{ 'b': { 'c': 3 } }] }), { 'a': [{ 'b': { 'c': 4 } }] })
      ade(set('a.b.c.d', 1)({}), { a: { b: { c: { d: 1 } } } })
    })

    it('eagerly set a property of an object', async () => {
      ade(set(null, 'a', 1), null)
      ade(set(undefined, 'a', 1), undefined)
      ade(set('yo', 'a', 1), 'yo')
      ade(set({ b: 2 }, 'a', 1), { a: 1, b: 2 })
      ade(set({ a: { c: 2 } }, 'a.b', 1), { a: { b: 1, c: 2 } })
      ade(set({ a: 1 }, 'a.b', 1), { a: { b: 1 } })
      ade(set({ a: { c: 2 } }, ['a', 'b'], 1), { a: { b: 1, c: 2 } })
      ade(await set(Promise.resolve({ 'a': [{ 'b': { 'c': 3 } }] }), 'a[0].b.c', 4), { 'a': [{ 'b': { 'c': 4 } }] })
      ade(await set({ 'a': [{ 'b': { 'c': 3 } }] }, 'a[0].b.c', Promise.resolve(4)), { 'a': [{ 'b': { 'c': 4 } }] })
      ade(await set(Promise.resolve({}), 'a.b.c.d', 1), { a: { b: { c: { d: 1 } } } })
      ade(await set({}, 'a.b.c.d', Promise.resolve(1)), { a: { b: { c: { d: 1 } } } })
    })

    it('the property value may be a resolver', async () => {
      { // sync
        const myObj = { a: 1 }
        const myNewObj = set('b', obj => obj.a + 2)(myObj)
        assert.deepEqual(myNewObj, { a: 1, b: 3 })
      }

      { // async
        const myObj = { a: 1 }
        const myNewObj = await set('b', async obj => obj.a + 2)(myObj)
        assert.deepEqual(myNewObj, { a: 1, b: 3 })
      }
    })
  })

  describe('pick', () => {
    const abc = { a: 1, b: 2, c: 3 }
    const nested = { a: { b: { c: { d: 1, e: [2, 3] } } } }

    it('API coverage', async () => {
      ade(pick(abc, ['a']), { a: 1 })
      ade(pick(abc, ['a', 'd']), { a: 1 })
      ade(pick(abc, ['d']), {})
      ade(await pick(Promise.resolve(abc), ['a']), { a: 1 })
      ade(await pick(Promise.resolve(abc), ['a', 'd']), { a: 1 })
      ade(await pick(Promise.resolve(abc), ['d']), {})
    })
    it('picks properties off an object defined by array', async () => {
      ade(pick(['a'])(abc), { a: 1 })
      ade(pick(['a', 'd'])(abc), { a: 1 })
      ade(pick(['d'])(abc), {})
      ade(pick(['d'])(null), null)
      ade(pick(['d'])(undefined), undefined)
      ade(pick(['d'])(), undefined)
    })
    it('picks nested properties', async () => {
      assert.deepEqual(pick(['a.b.c.d'])(nested), { a: { b: { c: { d: 1 } } } })
      // assert.deepEqual(pick(['a.b.f.g'])(nested), nested)
      // assert.deepEqual(pick(['a.b.c.d', 'a.b.c.e[0]'])(nested), { a: { b: { c: { e: [, 3] } } } })
      // assert.deepEqual(pick(['a[0][0].d'])({ a: [[{ b: 1, c: 2, d: 3 }]] }), { a: [[{ b: 1, c: 2 }]] })
      // assert.deepEqual(pick(['a[0][0].d'])({ a: [[{ b: 1, c: 2, d: null }]] }), { a: [[{ b: 1, c: 2 }]] })
    })
  })

  describe('omit', () => {
    const abc = { a: 1, b: 2, c: 3 }
    const nested = { a: { b: { c: { d: 1, e: [2, 3] } } } }

    it('API coverage', async () => {
      ade(omit(nested, []), nested)
      ade(await omit(Promise.resolve(nested), []), nested)
      ade(omit([1, 2, 3], []), [1, 2, 3])
      ade(await omit(Promise.resolve([1, 2, 3]), []), [1, 2, 3])
      ade(omit(abc, ['a']), { b: 2, c: 3 })
      ade(omit(abc, ['a', 'd']), { b: 2, c: 3 })
      ade(omit(abc, ['d']), { a: 1, b: 2, c: 3 })
    })
    it('omits properties from an object defined by array', async () => {
      assert(omit([])(nested) !== nested)
      ade(omit([])(nested), nested)
      ade(omit([])([1, 2, 3]), [1, 2, 3])
      ade(omit(['a'])(abc), { b: 2, c: 3 })
      ade(omit(['a', 'd'])(abc), { b: 2, c: 3 })
      ade(omit(['d'])(abc), { a: 1, b: 2, c: 3 })
      ade(omit(['d'])({ d: null }), {})
      ase(omit(['d'])(null), null)
      ase(omit(['d'])(undefined), undefined)
      ase(omit(['d'])(), undefined)
      ase(omit([])(null), null)
      ase(omit([])(1), 1)
    })
    it('omits nested properties', async () => {
      assert.deepEqual(omit(['a.b.c.d'])(nested), { a: { b: { c: { e: [2, 3] } } } })
      assert.deepEqual(omit(['a.b.f.g'])(nested), nested)
      assert.deepEqual(omit(['a.b.c.d', 'a.b.c.e[0]'])(nested), { a: { b: { c: { e: [, 3] } } } })
      assert.deepEqual(omit(['a[0][0].d'])({ a: [[{ b: 1, c: 2, d: 3 }]] }), { a: [[{ b: 1, c: 2 }]] })
      assert.deepEqual(omit(['a[0][0].d'])({ a: [[{ b: 1, c: 2, d: null }]] }), { a: [[{ b: 1, c: 2 }]] })
    })
    it('more nested',
      Test(
        'omit nested',
        omit(['a.b.c.e[0]']))
        .case({
          a: {
            b: {
              c: {
                d: 1,
                e: [2, 3],
              },
            }
          },
        }, {
          a: {
            b: {
              c: {
                d: 1,
                e: [, 3],
              },
            }
          },
        })
    .case(null, null)
    .case({}, {})
    .case([], []))
  })

  describe('some', () => {
    it('API coverage', async () => {
      ase(
        some([1, 2, 3, 4, 5], number => number > 3),
        true,
      )

      ase(
        await some(Promise.resolve([1, 2, 3, 4, 5]), number => number > 3),
        true,
      )
    })

    const numbersArray = [1, 2, 3, 4, 5]
    const evenNumbersArray = [2, 4, 6, 8, 10]
    const numbersGenerator = function* () {
      yield 1; yield 2; yield 3; yield 4; yield 5
    }
    const evenNumbersGenerator = function* () {
      yield 2; yield 4; yield 6; yield 8; yield 10
    }
    const asyncNumbersGenerator = async function* () {
      yield 1; yield 2; yield 3; yield 4; yield 5
    }
    const asyncEvenNumbersGenerator = async function* () {
      yield 2; yield 4; yield 6; yield 8; yield 10
    }
    const isOdd = number => number % 2 == 1
    const variadicAsyncIsOdd = number => number % 2 == 1 ? Promise.resolve(true) : false
    const variadicAsyncIsEven = number => number % 2 == 0 ? Promise.resolve(true) : false

    const cases = [
      [isOdd, [2, 3, 4], true],
      [async(isOdd), [2, 3, 4], true],
      [isOdd, new MockFoldable([2, 3, 4]), true],
      [isOdd, numbersArray, true],
      [isOdd, evenNumbersArray, false],
      [isOdd, new MockFoldable(numbersArray), true],
      [isOdd, new MockFoldable(evenNumbersArray), false],
      [isOdd, new AsyncMockFoldable(numbersArray), true],
      [isOdd, new AsyncMockFoldable(evenNumbersArray), false],
      [async(isOdd), new MockFoldable(numbersArray), true],
      [async(isOdd), new MockFoldable(evenNumbersArray), false],
      [async(isOdd), new AsyncMockFoldable(numbersArray), true],
      [async(isOdd), new AsyncMockFoldable(evenNumbersArray), false],
      [variadicAsyncIsOdd, numbersArray, true],
      [variadicAsyncIsOdd, evenNumbersArray, false],
      [async(isOdd), numbersArray, true],
      [async(isOdd), evenNumbersArray, false],
      [isOdd, numbersGenerator(), true],
      [isOdd, evenNumbersGenerator(), false],
      [async(isOdd), numbersGenerator(), true],
      [async(isOdd), evenNumbersGenerator(), false],
      [isOdd, asyncNumbersGenerator(), true],
      [isOdd, asyncEvenNumbersGenerator(), false],
      [async(isOdd), asyncNumbersGenerator(), true],
      [async(isOdd), asyncEvenNumbersGenerator(), false],
      [variadicAsyncIsOdd, asyncNumbersGenerator(), true],
      [variadicAsyncIsOdd, asyncEvenNumbersGenerator(), false],
      [isOdd, asyncNumbersGenerator(), true],
      [isOdd, asyncEvenNumbersGenerator(), false],
      [async(isOdd), asyncNumbersGenerator(), true],
      [async(isOdd), asyncEvenNumbersGenerator(), false],
      [variadicAsyncIsOdd, asyncNumbersGenerator(), true],
      [variadicAsyncIsOdd, asyncEvenNumbersGenerator(), false],
    ]

    cases.forEach(([func, value, result, asserter = assert.strictEqual]) => {
      it(`${func.name}(${JSON.stringify(value)}) -> ${result}`, async () => {
        asserter(await some(func)(value), result)
      })
    })

    it('max concurrency 20', async () => {
      const asyncRange = async function* (to) {
        for (let index = 1; index < to; index++) {
          yield index
        }
      }
      let concurrencyCount = 0,
        maxConcurrencyCount = 0
      assert.strictEqual(await some(async number => {
        concurrencyCount += 1
        maxConcurrencyCount = Math.max(maxConcurrencyCount, concurrencyCount)
        await sleep(10)
        concurrencyCount -= 1
        return false
      })(asyncRange(40)), false)
      assert.strictEqual(concurrencyCount, 0)
      assert.strictEqual(maxConcurrencyCount, 20)
      assert.strictEqual(await some(async number => {
        maxConcurrencyCount = Math.max(maxConcurrencyCount, concurrencyCount)
        await sleep(10)
        if (number == 19) {
          return true
        }
        return false
      })(asyncRange(40)), true)
    })

    it('1', async () => {
      assert.strictEqual(some(() => true)(1), true)
    })
    it('null', async () => {
      assert.strictEqual(some(() => true)(null), true)
    })
    it('undefined', async () => {
      assert.strictEqual(some(() => true)(undefined), true)
      assert.strictEqual(some(() => true)(), true)
    })
  })

  describe('some - v1.5.15 regression', () => {
    const numbers = [1, 2, 3, 4, 5]
    const numbersObject = { a: 1, b: 2, c: 3, d: 4, e: 5 }
    it('[sync] tests fn against all items of iterable, true if any evaluation is truthy', async () => {
      ase(some(x => x > 5)(numbers), false)
      ase(some(x => x > 0)(numbers), true)
      ase(some(x => x > 5)(new Set(numbers)), false)
      ase(some(x => x > 0)(new Set(numbers)), true)
      ase(some(x => x > 5)(numbersObject), false)
      ase(some(x => x > 0)(numbersObject), true)
    })
    it('[async] tests fn against all items of iterable, true if any evaluation is truthy', async () => {
      aok(some(async x => x > 5)(numbers) instanceof Promise)
      ase(await some(async x => x > 5)(numbers), false)
      ase(await some(async x => x > 0)(numbers), true)
      ase(await some(async x => x > 5)(new Set(numbers)), false)
      ase(await some(async x => x > 0)(new Set(numbers)), true)
      ase(await some(async x => x > 5)(numbersObject), false)
      ase(await some(async x => x > 0)(numbersObject), true)
    })
    it('tests a variadic async function', async () => {
      ase(
        await some(x => x < 2 ? Promise.resolve(false) : true)([1, 2, 3, 4, 5]),
        true,
      )
    })
  })

  describe('every', () => {
    it('API coverage', async () => {
      ase(
        every([1, 2, 3, 4, 5], number => number > 0),
        true,
      )

      ase(
        await every(Promise.resolve([1, 2, 3, 4, 5]), number => number > 0),
        true,
      )
    })

    const numbersArray = [1, 2, 3, 4, 5]
    const evenNumbersArray = [2, 4, 6, 8, 10]
    const numbersGenerator = function* () {
      yield 1; yield 2; yield 3; yield 4; yield 5
    }
    const evenNumbersGenerator = function* () {
      yield 2; yield 4; yield 6; yield 8; yield 10
    }
    const asyncNumbersGenerator = async function* () {
      yield 1; yield 2; yield 3; yield 4; yield 5
    }
    const asyncEvenNumbersGenerator = async function* () {
      yield 2; yield 4; yield 6; yield 8; yield 10
    }
    const isOdd = number => number % 2 == 1
    const isEven = number => number % 2 == 0
    const variadicAsyncIsOdd = number => number % 2 == 1 ? Promise.resolve(true) : false
    const variadicAsyncIsEven = number => number % 2 == 0 ? Promise.resolve(true) : false

    const cases = [
      [isEven, numbersArray, false],
      [async(isEven), numbersArray, false],
      [isEven, evenNumbersArray, true],
      [isEven, new MockFoldable(numbersArray), false],
      [isEven, new MockFoldable(evenNumbersArray), true],
      [async(isEven), new MockFoldable(numbersArray), false],
      [async(isEven), new MockFoldable(evenNumbersArray), true],
      [async(isEven), evenNumbersArray, true],
      [variadicAsyncIsEven, numbersArray, false],
      [variadicAsyncIsEven, evenNumbersArray, true],
      [isEven, numbersGenerator(), false],
      [isEven, evenNumbersGenerator(), true],
      [async(isEven), numbersGenerator(), false],
      [async(isEven), evenNumbersGenerator(), true],
      [isEven, asyncNumbersGenerator(), false],
      [isEven, asyncEvenNumbersGenerator(), true],
      [async(isEven), asyncNumbersGenerator(), false],
      [async(isEven), asyncEvenNumbersGenerator(), true],
      [variadicAsyncIsEven, asyncNumbersGenerator(), false],
      [variadicAsyncIsEven, asyncEvenNumbersGenerator(), true],
      [isEven, asyncNumbersGenerator(), false],
      [isEven, asyncEvenNumbersGenerator(), true],
      [async(isEven), asyncNumbersGenerator(), false],
      [async(isEven), asyncEvenNumbersGenerator(), true],
      [variadicAsyncIsEven, asyncNumbersGenerator(), false],
      [variadicAsyncIsEven, asyncEvenNumbersGenerator(), true],
    ]

    cases.forEach(([func, value, result, asserter = assert.strictEqual]) => {
      it(`${func.name}(${JSON.stringify(value)}) -> ${result}`, async () => {
        asserter(await every(func)(value), result)
      })
    })

    it('max concurrency 20', async () => {
      const asyncRange = async function* (to) {
        for (let index = 1; index < to; index++) {
          yield index
        }
      }
      let concurrencyCount = 0,
        maxConcurrencyCount = 0
      assert.strictEqual(await every(async number => {
        concurrencyCount += 1
        maxConcurrencyCount = Math.max(maxConcurrencyCount, concurrencyCount)
        await sleep(10)
        concurrencyCount -= 1
        return true
      })(asyncRange(40)), true)
      assert.strictEqual(concurrencyCount, 0)
      assert.strictEqual(maxConcurrencyCount, 20)
      assert.strictEqual(await every(async number => {
        maxConcurrencyCount = Math.max(maxConcurrencyCount, concurrencyCount)
        await sleep(10)
        if (number == 19) {
          return false
        }
        return true
      })(asyncRange(40)), false)
    })

    it('1', async () => {
      assert.strictEqual(every(() => true)(1), true)
    })
    it('null', async () => {
      assert.strictEqual(every(() => true)(null), true)
    })
    it('undefined', async () => {
      assert.strictEqual(every(() => true)(undefined), true)
      assert.strictEqual(every(() => true)(), true)
    })
  })

  describe('every - v1.5.15 regression', () => {
    const numbers = [1, 2, 3, 4, 5]
    const numbersObject = { a: 1, b: 2, c: 3, d: 4, e: 5 }
    it('syncly evaluates fn against all items in iterable, true if all evaluations are truthy', async () => {
      ase(every(x => x > 5)(numbers), false)
      ase(every(x => x > 0)(numbers), true)
      ase(every(x => x > 5)(new Set(numbers)), false)
      ase(every(x => x > 0)(new Set(numbers)), true)
      ase(every(x => x > 5)(numbersObject), false)
      ase(every(x => x > 0)(numbersObject), true)
    })
    it('asyncly evaluates fn against all items in iterable, true if all evaluations are truthy', async () => {
      aok(every(async x => x > 5)(numbers) instanceof Promise)
      ase(await every(async x => x > 5)(numbers), false)
      ase(await every(async x => x > 0)(numbers), true)
      ase(await every(async x => x > 5)(new Set(numbers)), false)
      ase(await every(async x => x > 0)(new Set(numbers)), true)
      ase(await every(async x => x > 5)(numbersObject), false)
      ase(await every(async x => x > 0)(numbersObject), true)
    })
    it('tests a variadic async function', async () => {
      ase(
        await every(x => x < 2 ? Promise.resolve(true) : false)([1, 2, 3, 4, 5]),
        false,
      )
    })
  })

  describe('not', () => {
    it('API coverage', async () => {
      ase(
        not(1, 2, 3, (...numbers) => (
          numbers.every(num => typeof num == 'number')
        )),
        false,
      )

      ase(
        await not(Promise.resolve(1), 2, Promise.resolve(3), (...numbers) => (
          numbers.every(num => typeof num == 'number')
        )),
        false,
      )
    })
    it('not(someValue) -> !someValue', async () => {
      assert.strictEqual(not(false), true)
      assert.strictEqual(not(null), true)
      assert.strictEqual(not(1), false)
      assert.strictEqual(not(0), true)
    })
    it('[sync] not(isOdd)(x) === !isOdd(x)', async () => {
      ase(not(isOdd)(2), true)
      ase(not(isOdd)(1), false)
    })
    it('[async] not(isEven)(x) === !(await isEven(x))', async () => {
      aok(not(asyncIsEven)(2) instanceof Promise)
      ase(await not(asyncIsEven)(2), false)
      ase(await not(asyncIsEven)(1), true)
    })
  })

  describe('and', () => {
    it('API coverage', async () => {
      aok(
        and(1, 2, 3, [
          (...numbers) => numbers.every(num => typeof num == 'number'),
          (...numbers) => numbers.every(num => num < 5),
          (...numbers) => numbers.every(num => num > 0),
        ])
      )

      aok(
        await and(Promise.resolve(1), 2, Promise.resolve(3), [
          (...numbers) => numbers.every(num => typeof num == 'number'),
          (...numbers) => numbers.every(num => num < 5),
          (...numbers) => numbers.every(num => num > 0),
        ])
      )
    })

    it('all nonfunctions', async () => {
      assert.strictEqual(and([true, true, true]), true)
      assert.strictEqual(and([true, true, false]), false)
      assert.strictEqual(and([false, true, true]), false)
      assert.strictEqual(await and([Promise.resolve(true), true, true]), true)
      assert.strictEqual(await and([true, true, Promise.resolve(false)]), false)
      assert.strictEqual(await and([Promise.resolve(false), true, true]), false)
    })

    it('predicates', async () => {
      const isOdd = number => number % 2 == 1
      const isEven = number => number % 2 == 0
      const variadicAsyncIsOdd = number => number % 2 == 1 ? Promise.resolve(true) : false
      assert.strictEqual(and([isOdd, isOdd, isOdd, true])(3), true)
      assert.strictEqual(and([isOdd, isOdd, isOdd])(2), false)
      assert.strictEqual(and([isEven, isEven, isOdd])(2), false)
      assert.strictEqual(await and([async(isOdd), isOdd, isOdd, true])(3), true)
      assert.strictEqual(await and([isOdd, async(isOdd), isOdd])(3), true)
      assert.strictEqual(await and([isOdd, isOdd, async(isOdd)])(3), true)
      assert.strictEqual(await and([async(isOdd), async(isOdd), async(isOdd)])(3), true)
      assert.strictEqual(await and([variadicAsyncIsOdd, variadicAsyncIsOdd, variadicAsyncIsOdd])(3), true)
    })

    it('0 predicates true', async () => {
      assert.strictEqual(and([]), true)
    })

    it('null', async () => {
      assert.strictEqual(and([isOdd, isOdd, isOdd])(null), false)
    })

    it('undefined', async () => {
      assert.strictEqual(and([isOdd, isOdd, isOdd])(undefined), false)
      assert.strictEqual(and([isOdd, isOdd, isOdd])(), false)
    })

    const isGreaterThan1 = x => x > 1
    it('sync tests input against provided array of functions, true if all evaluations are truthy', async () => {
      ase(and([isOdd, isGreaterThan1])(3), true)
      ase(and([isOdd, isGreaterThan1])(1), false)
    })

    it('async tests input against provided array of functions, true if all evaluations are truthy', async () => {
      aok(and([asyncIsEven, isGreaterThan1])(2) instanceof Promise)
      ase(await and([asyncIsEven, isGreaterThan1])(2), true)
      ase(await and([asyncIsEven, isGreaterThan1])(0), false)
    })
  })

  describe('or', () => {
    it('API coverage', async () => {
      aok(
        or(1, 2, 3, [
          (...numbers) => numbers.every(num => typeof num == 'number'),
          false,
          false,
        ])
      )

      aok(
        await or(Promise.resolve(1), 2, Promise.resolve(3), [
          (...numbers) => numbers.every(num => typeof num == 'number'),
          false,
          false,
        ])
      )
    })

    it('all nonfunctions', async () => {
      assert.strictEqual(or([true, true, true]), true)
      assert.strictEqual(or([false, false, false]), false)
      assert.strictEqual(or([false, false, true]), true)
      assert.strictEqual(await or([true, true, Promise.resolve(true)]), true)
      assert.strictEqual(await or([Promise.resolve(false), false, false]), false)
      assert.strictEqual(await or([false, false, Promise.resolve(true)]), true)
    })

    const isOdd = number => number % 2 == 1
    const isEven = number => number % 2 == 0
    const variadicAsyncIsOdd = number => number % 2 == 1 ? Promise.resolve(true) : false
    it('predicates', async () => {
      assert.strictEqual(or([isOdd, isEven, true])(0), true)
      assert.strictEqual(or([isOdd, isOdd, isOdd])(0), false)
      assert.strictEqual(or([isOdd, isOdd, isOdd])(1), true)
      assert.strictEqual(or([isOdd, isOdd, isOdd, false])(3955), true)
      assert.strictEqual(await or([isOdd, isEven])(0), true)
      assert.strictEqual(await or([isOdd, async(isOdd), false, async(isEven)])(0), true)
      assert.strictEqual(await or([false, variadicAsyncIsOdd, variadicAsyncIsOdd, variadicAsyncIsOdd])(3955), true)
      assert.strictEqual(await or([variadicAsyncIsOdd, () => false, () => false])(3955), true)
      assert.strictEqual(await or([variadicAsyncIsOdd, () => false, () => false])(3956), false)
      assert.strictEqual(await or([() => false, variadicAsyncIsOdd, () => false])(3955), true)
      assert.strictEqual(await or([() => false, variadicAsyncIsOdd, () => false])(3956), false)
      assert.strictEqual(await or([async(isOdd), isEven])(0), true)
      assert.strictEqual(await or([async(isOdd), isOdd, isOdd])(0), false)
    })
  })

  describe('or - v1.5.15 regression', () => {
    const isGreaterThan1 = x => x > 1
    it('sync tests input against provided array of functions, true if any evaluations are truthy', async () => {
      ase(or([isOdd, isGreaterThan1])(3), true)
      ase(or([isOdd, isGreaterThan1])(0), false)
    })
    it('async tests input against provided array of functions, true if any evaluations are truthy', async () => {
      aok(or([asyncIsEven, isGreaterThan1])(2) instanceof Promise)
      ase(await or([asyncIsEven, isGreaterThan1])(2), true)
      ase(await or([asyncIsEven, isGreaterThan1])(1), false)
    })
  })

  describe('eq', () => {
    it('API coverage', async () => {
      aok(eq(2, 2))
      aok(await eq(Promise.resolve(2), 2))
      aok(await eq(2, Promise.resolve(2)))
      aok(await eq(Promise.resolve(2), Promise.resolve(2)))
      aok(
        eq(2, number => number * 2, number => number + 2)
      )
      aok(
        eq(number => number * 2, number => number + 2)(2)
      )
      aok(
        await eq(Promise.resolve(2), number => number * 2, number => number + 2)
      )
      aok(eq(2, number => number * 2, 4))
      aok(await eq(Promise.resolve(2), number => number * 2, 4))
      aok(eq(2, 4, number => number ** 2))
      aok(await eq(Promise.resolve(2), 4, number => number ** 2))
    })

    it('[sync] eq(f, g)(x) == (f(x) == g(x))', async () => {
      ase(eq(x => `${x}`, x => x)('hey'), true)
      ase(eq(x => `${x}`, x => x)(1), true)
    })
    it('[async] eq(f, g)(x) == (f(x) == g(x))', async () => {
      aok(eq(x => `${x}`, async x => x)('hey') instanceof Promise)
      ase(await eq(async x => `${x}`, async x => x)('hey'), true)
      ase(await eq(async x => `${x}`, async x => x)(1), true)
    })
    it('[sync] eq(f, value)(x) == (valueA == valueB)', async () => {
      ase(eq(() => 'hey', 'hey')('abc'), true)
      ase(eq(() => 'hey', 'ho')('abc'), false)
    })
    it('[async] eq(f, value)(x) == (valueA == valueB)', async () => {
      ase(await eq(async () => 'hey', 'hey')('abc'), true)
      ase(await eq('hey', async () => 'ho')('abc'), false)
    })
    it('[sync] eq(value, g)(x) == (valueA == valueB)', async () => {
      ase(eq('hey', () => 'hey')('abc'), true)
      ase(eq('hey', () => 'ho')('abc'), false)
    })
    it('[async] eq(value, g)(x) == (value == g(x))', async () => {
      aok(eq('hey', async x => x)('hey') instanceof Promise)
      ase(await eq('hey', async x => x)('hey'), true)
      ase(await eq(async x => x, 'hey')('hey'), true)
      ase(await eq('ho', async x => x)(1), false)
    })
    it('[sync] eq(valueA, valueB) == (valueA == valueB)', () => {
      ase(eq('hey', 'hey'), true)
      ase(eq('hey', 'ho'), false)
    })
    it('false for eq(string,)', () => {
      assert.strictEqual(eq('hey',), false)
    })
  })

  describe('gt', () => {
    it('API coverage', async () => {
      aok(
        gt(1, number => number, number => number * 0)
      )
      aok(
        await gt(Promise.resolve(1), number => number, number => number * 0)
      )
      aok(gt(1, number => number, 0))
      aok(await gt(Promise.resolve(1), number => number, 0))
      aok(gt(1, 3, number => number * 0))
      aok(await gt(Promise.resolve(1), 3, number => number * 0))
    })
    it('[sync] gt(f, g)(x) === (f(x) > g(x))', async () => {
      ase(gt(x => x + 1, x => x)(1), true)
      ase(gt(x => x, x => x)(1), false)
      ase(gt(x => x, x => x + 1)(1), false)
    })
    it('[async] gt(f, g)(x) === (f(x) > g(x))', async () => {
      aok(gt(x => x + 1, async x => x)(1) instanceof Promise)
      ase(await gt(x => x + 1, async x => x)(1), true)
      ase(await gt(async x => x, x => x)(1), false)
      ase(await gt(async x => x, async x => x + 1)(1), false)
    })
    it('[sync] gt(f, value)(x) === (valueA > valueB)', async () => {
      ase(gt(() => 1, 0)('abc'), true)
      ase(gt(() => 1, 1)('abc'), false)
      ase(gt(() => 0, 1)('abc'), false)
    })
    it('[sync] gt(value, g)(x) === (valueA > valueB)', async () => {
      ase(gt(1, () => 0)('abc'), true)
      ase(gt(1, () => 1)('abc'), false)
      ase(gt(0, () => 1)('abc'), false)
    })
    it('[async] gt(value, g)(x) === (value > g(x))', async () => {
      aok(gt(1, async x => x)(2) instanceof Promise)
      ase(await gt(1, async x => x)(0), true)
      ase(await gt(1, async x => x)(1), false)
      ase(await gt(1, async x => x)(2), false)
      ase(await gt(async x => x, 0)(1), true)
      ase(await gt(async x => x, 1)(1), false)
      ase(await gt(async x => x, 2)(1), false)
    })
    it('[sync] gt(valueA, valueB) === (valueA > valueB)', () => {
      ase(gt(1, 0), true)
      ase(gt(1, 1), false)
      ase(gt(0, 1), false)
    })
    it('throws RangeError on not enough arguments', async () => {
      assert.strictEqual(gt('hey'), false)
    })
  })

  describe('lt', () => {
    it('API coverage', async () => {
      aok(
        lt(5, number => number - 3, number => number + 3)
      )
      aok(
        await lt(Promise.resolve(5), number => number - 3, number => number + 3)
      )
      aok(lt(5, 2, number => number + 3))
      aok(await lt(Promise.resolve(5), 2, number => number + 3))
      aok(lt(5, number => number - 3, 5))
      aok(await lt(Promise.resolve(5), number => number - 3, 5))
    })
    it('[sync] lt(f, g)(x) === (f(x) < g(x))', async () => {
      ase(lt(x => x + 1, x => x)(1), false)
      ase(lt(x => x, x => x)(1), false)
      ase(lt(x => x, x => x + 1)(1), true)
    })
    it('[async] lt(f, g)(x) === (f(x) < g(x))', async () => {
      aok(lt(x => x + 1, async x => x)(1) instanceof Promise)
      ase(await lt(x => x + 1, async x => x)(1), false)
      ase(await lt(async x => x, x => x)(1), false)
      ase(await lt(async x => x, async x => x + 1)(1), true)
    })
    it('[sync] lt(f, value)(x) === (valueA < valueB)', async () => {
      ase(lt(() => 1, 0)('abc'), false)
      ase(lt(() => 1, 1)('abc'), false)
      ase(lt(() => 0, 1)('abc'), true)
    })
    it('[sync] lt(value, g)(x) === (valueA < valueB)', async () => {
      ase(lt(1, () => 0)('abc'), false)
      ase(lt(1, () => 1)('abc'), false)
      ase(lt(0, () => 1)('abc'), true)
    })
    it('[async] lt(value, g)(x) === (value < g(x))', async () => {
      aok(lt(1, async x => x)(2) instanceof Promise)
      ase(await lt(1, async x => x)(0), false)
      ase(await lt(1, async x => x)(1), false)
      ase(await lt(1, async x => x)(2), true)
      ase(await lt(async x => x, 0)(1), false)
      ase(await lt(async x => x, 1)(1), false)
      ase(await lt(async x => x, 2)(1), true)
    })
    it('[sync] lt(valueA, valueB) === (valueA < valueB)', () => {
      ase(lt(1, 0), false)
      ase(lt(1, 1), false)
      ase(lt(0, 1), true)
    })
    it('throws RangeError on not enough arguments', () => {
      assert.strictEqual(lt('hey'), false)
    })
  })

  describe('gte', () => {
    it('API coverage', async () => {
      aok(
        gte(5, number => number + 3, number => number + 3)
      )
      aok(
        await gte(Promise.resolve(5), number => number + 3, number => number + 3)
      )
      aok(gte(5, 10, number => number + 3))
      aok(await gte(Promise.resolve(5), 10, number => number + 3))
      aok(gte(5, number => number + 3, 5))
      aok(await gte(Promise.resolve(5), number => number + 3, 5))
    })
    it('[sync] gte(f, g)(x) === (f(x) >= g(x))', async () => {
      ase(gte(x => x + 1, x => x)(1), true)
      ase(gte(x => x, x => x)(1), true)
      ase(gte(x => x, x => x + 1)(1), false)
    })
    it('[async] gte(f, g)(x) === (f(x) >= g(x))', async () => {
      aok(gte(x => x + 1, async x => x)(1) instanceof Promise)
      ase(await gte(x => x + 1, async x => x)(1), true)
      ase(await gte(async x => x, x => x)(1), true)
      ase(await gte(async x => x, async x => x + 1)(1), false)
    })
    it('[sync] gte(f, value)(x) === (valueA >= valueB)', async () => {
      ase(gte(() => 1, 0)('abc'), true)
      ase(gte(() => 1, 1)('abc'), true)
      ase(gte(() => 0, 1)('abc'), false)
    })
    it('[sync] gte(value, g)(x) === (valueA >= valueB)', async () => {
      ase(gte(1, () => 0)('abc'), true)
      ase(gte(1, () => 1)('abc'), true)
      ase(gte(0, () => 1)('abc'), false)
    })
    it('[async] gte(value, g)(x) === (value >= g(x))', async () => {
      aok(gte(1, async x => x)(2) instanceof Promise)
      ase(await gte(1, async x => x)(0), true)
      ase(await gte(1, async x => x)(1), true)
      ase(await gte(1, async x => x)(2), false)
      ase(await gte(async x => x, 0)(1), true)
      ase(await gte(async x => x, 1)(1), true)
      ase(await gte(async x => x, 2)(1), false)
    })
    it('[sync] gte(valueA, valueB)(x) === (valueA >= valueB)', () => {
      ase(gte(1, 0), true)
      ase(gte(1, 1), true)
      ase(gte(0, 1), false)
    })
    it('throws RangeError on not enough arguments', () => {
      assert.strictEqual(gte('hey'), false)
    })
  })

  describe('lte', () => {
    it('API coverage', async () => {
      aok(
        lte(5, number => number + 3, number => number + 3)
      )
      aok(
        await lte(Promise.resolve(5), number => number + 3, number => number + 3)
      )
      aok(lte(5, 0, number => number + 3))
      aok(await lte(Promise.resolve(5), 0, number => number + 3))
      aok(lte(5, number => number + 3, 10))
      aok(await lte(Promise.resolve(5), number => number + 3, 10))
    })
    it('[sync] lte(f, g)(x) === (f(x) <= g(x))', async () => {
      ase(lte(x => x + 1, x => x)(1), false)
      ase(lte(x => x, x => x)(1), true)
      ase(lte(x => x, x => x + 1)(1), true)
    })
    it('[async] lte(f, g)(x) === (f(x) <= g(x))', async () => {
      aok(lte(x => x + 1, async x => x)(1) instanceof Promise)
      ase(await lte(x => x + 1, async x => x)(1), false)
      ase(await lte(async x => x, x => x)(1), true)
      ase(await lte(async x => x, async x => x + 1)(1), true)
    })
    it('[sync] lte(f, value)(x) === (valueA <= valueB)', async () => {
      ase(lte(() => 1, 0)('abc'), false)
      ase(lte(() => 1, 1)('abc'), true)
      ase(lte(() => 0, 1)('abc'), true)
    })
    it('[sync] lte(value, g)(x) === (valueA <= valueB)', async () => {
      ase(lte(1, () => 0)('abc'), false)
      ase(lte(1, () => 1)('abc'), true)
      ase(lte(0, () => 1)('abc'), true)
    })
    it('[async] lte(value, g)(x) === (value <= g(x))', async () => {
      aok(lte(1, async x => x)(2) instanceof Promise)
      ase(await lte(1, async x => x)(0), false)
      ase(await lte(1, async x => x)(1), true)
      ase(await lte(1, async x => x)(2), true)
      ase(await lte(async x => x, 0)(1), false)
      ase(await lte(async x => x, 1)(1), true)
      ase(await lte(async x => x, 2)(1), true)
    })
    it('[sync] lte(valueA, valueB)(x) === (valueA <= valueB)', () => {
      ase(lte(1, 0), false)
      ase(lte(1, 1), true)
      ase(lte(0, 1), true)
    })
    it('throws RangeError on not enough arguments', () => {
      assert.strictEqual(lte('hey'), false)
    })
  })

  describe('thunkify', () => {
    const add2 = (a, b) => a + b
    const thunkAdd212 = thunkify(add2, 1, 2)
    it('creates a thunk', async () => {
      assert.strictEqual(thunkAdd212.length, 0)
      assert.strictEqual(thunkAdd212(), 3)
    })

    const asyncThunkAdd212 = thunkify(add2, Promise.resolve(1), 2)
    it('creates a thunk that resolves any promise arguments', async () => {
      assert.strictEqual(asyncThunkAdd212.length, 0)
      assert.strictEqual(await asyncThunkAdd212(), 3)
    })
  })

  describe('always', () => {
    it('always returns a value', async () => {
      assert.strictEqual(always(1)(), 1)
      assert.strictEqual(always(null)(), null)
      assert.strictEqual(always(NaN)(), NaN)
    })
  })

  describe('curry', () => {
    const add3 = (a, b, c) => a + b + c
    const curriedAdd3 = curry(add3)
    it('round robin', async () => {
      assert.strictEqual(curry(add3, 'a', 'b', 'c'), 'abc')
      assert.strictEqual(curry(add3)('a', 'b', 'c'), 'abc')
      assert.strictEqual(curry(add3, 'a')('b', 'c'), 'abc')
      assert.strictEqual(curry(add3, 'a', 'b')('c'), 'abc')
      assert.strictEqual(curry(add3)('a', 'b')('c'), 'abc')
      assert.strictEqual(curry(add3)('a')('b', 'c'), 'abc')
      assert.strictEqual(curry(add3)('a')('b')('c'), 'abc')
    })

    it('with placeholder __', async () => {
      assert.strictEqual(curry(add3, __, 'b', 'c')('a'), 'abc')
      assert.strictEqual(curry(add3, 'a', __, 'c')('b'), 'abc')
      assert.strictEqual(curry(add3, 'a', 'b', __)('c'), 'abc')
      assert.strictEqual(curry(add3, 'a', __, __)('b', 'c'), 'abc')
      assert.strictEqual(curry(add3, __, 'b', __)('a', 'c'), 'abc')
      assert.strictEqual(curry(add3, __, __, 'c')('a', 'b'), 'abc')
      assert.strictEqual(curry(add3, __, __, __)('a', 'b', 'c'), 'abc')
      assert.strictEqual(curry(add3, __, __, __)(__, __, __)('a', 'b', 'c'), 'abc')
      assert.strictEqual(curry(add3, __, __, __)(__, 'b', 'c')('a'), 'abc')
      assert.strictEqual(curry(add3, __, __, __)('a', __, 'c')('b'), 'abc')
      assert.strictEqual(curry(add3, __, __, __)('a', 'b', __)('c'), 'abc')
      assert.strictEqual(curry(add3)(__, __)(__)('a', 'b', __)('c'), 'abc')
      assert.strictEqual(curry(add3)(__)(__, __)('a')('b')(__)('c'), 'abc')
      assert.strictEqual(curry(add3)(__)(__)(__)('a', 'b', __)('c'), 'abc')
      assert.strictEqual(curry(add3)(__)(__)(__)('a')('b')(__)('c'), 'abc')
    })
  })

  describe('curry.arity', () => {
    const add3 = (a, b, c) => a + b + c
    const curriedAdd3 = curry.arity(3, add3)
    it('round robin', async () => {
      assert.strictEqual(curry.arity(3, add3, 'a', 'b', 'c'), 'abc')
      assert.strictEqual(curry.arity(3, add3)('a', 'b', 'c'), 'abc')
      assert.strictEqual(curry.arity(3, add3, 'a')('b', 'c'), 'abc')
      assert.strictEqual(curry.arity(3, add3, 'a', 'b')('c'), 'abc')
      assert.strictEqual(curry.arity(3, add3)('a', 'b')('c'), 'abc')
      assert.strictEqual(curry.arity(3, add3)('a')('b', 'c'), 'abc')
      assert.strictEqual(curry.arity(3, add3)('a')('b')('c'), 'abc')
    })

    it('with placeholder __', async () => {
      assert.strictEqual(curry.arity(3, add3, __, 'b', 'c')('a'), 'abc')
      assert.strictEqual(curry.arity(3, add3, 'a', __, 'c')('b'), 'abc')
      assert.strictEqual(curry.arity(3, add3, 'a', 'b', __)('c'), 'abc')
      assert.strictEqual(curry.arity(3, add3, 'a', __, __)('b', 'c'), 'abc')
      assert.strictEqual(curry.arity(3, add3, __, 'b', __)('a', 'c'), 'abc')
      assert.strictEqual(curry.arity(3, add3, __, __, 'c')('a', 'b'), 'abc')
      assert.strictEqual(curry.arity(3, add3, __, __, __)('a', 'b', 'c'), 'abc')
      assert.strictEqual(curry.arity(3, add3, __, __, __)(__, __, __)('a', 'b', 'c'), 'abc')
      assert.strictEqual(curry.arity(3, add3, __, __, __)(__, 'b', 'c')('a'), 'abc')
      assert.strictEqual(curry.arity(3, add3, __, __, __)('a', __, 'c')('b'), 'abc')
      assert.strictEqual(curry.arity(3, add3, __, __, __)('a', 'b', __)('c'), 'abc')
      assert.strictEqual(curry.arity(3, add3)(__, __)(__)('a', 'b', __)('c'), 'abc')
      assert.strictEqual(curry.arity(3, add3)(__)(__, __)('a')('b')(__)('c'), 'abc')
      assert.strictEqual(curry.arity(3, add3)(__)(__)(__)('a', 'b', __)('c'), 'abc')
      assert.strictEqual(curry.arity(3, add3)(__)(__)(__)('a', 'b', __)('c'), 'abc')
      assert.strictEqual(curry.arity(3, add3)(__)(__)(__)('a')('b')(__)('c'), 'abc')
    })
  })

  describe('__', () => {
    it('is Symbol(placeholder)', async () => {
      assert.strictEqual(typeof __, 'symbol')
    })
  })

  it('exports 31 functions', async () => {
    ase(Object.keys(rubico).length, 31)
  })
})