rubico 2.2.2 → 2.3.0

package/README.md

@@ -6,7 +6,6 @@
 [![codecov](https://codecov.io/gh/a-synchronous/rubico/branch/master/graph/badge.svg)](https://codecov.io/gh/a-synchronous/rubico)
 [![npm version](https://img.shields.io/npm/v/rubico.svg?style=flat)](https://www.npmjs.com/package/rubico)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
-[![Gitter](https://badges.gitter.im/Join_Chat.svg)](https://gitter.im/a-synchronous/rubico)
 
 ### [a]synchronous functional programming
 
@@ -94,7 +93,7 @@ const {
   // compose functions
   pipe, compose,
 
-  // compose effects
+  // handle effects
   tap, forEach,
 
   // control flow

package/Transducer.js

@@ -21,22 +21,20 @@ const Transducer = {}
  *
  * @synopsis
  * ```coffeescript [specscript]
- * type Reducer = (accumulator any, item any)=>(nextAccumulator Promise|any)
+ * type Reducer = (
+ *   accumulator any,
+ *   value any,
+ *   indexOrKey? number|string,
+ *   collection? Foldable,
+ * )=>(nextAccumulator Promise|any)
+ *
  * type Transducer = Reducer=>Reducer
  *
  * Transducer.map(mapperFunc function) -> mappingTransducer Transducer
  * ```
  *
  * @description
- * Creates a mapping transducer with a provided reducer. A reducer is a variadic function that depicts a relationship between an accumulator and any number of arguments. A transducer is a function that accepts a reducer as an argument and returns another reducer.
- *
- * ```coffeescript [specscript]
- * type Reducer = (accumulator any, item any)=>(nextAccumulator Promise|any)
- *
- * type Transducer = Reducer=>Reducer
- * ```
- *
- * The transducer signature enables chaining functionality for reducers. `map` is core to this mechanism, and provides a way via transducers to transform the items of reducers.
+ * Creates a mapping transducer. Items in the final reducing operation are transformed by the mapper function. It is possible to use an asynchronous mapper, however the reducing operation must support asynchronous execution. This library provides such implementations as [reduce](/docs/reduce) and [transform](/docs/transform).
  *
  * ```javascript [playground]
  * const square = number => number ** 2
@@ -51,25 +49,21 @@ const Transducer = {}
  * // is a reducer with chained functionality square and concat
  *
  * console.log(
- *   [1, 2, 3, 4, 5].reduce(squareConcatReducer, []),
+ *   reduce([1, 2, 3, 4, 5], squareConcatReducer, [])
  * ) // [1, 4, 9, 16, 25]
  *
+ * // the same squareConcatReducer is consumable with vanilla JavaScript
  * console.log(
- *   [1, 2, 3, 4, 5].reduce(squareConcatReducer, ''),
- * ) // '1491625'
- * ```
- *
- * Create reducers with chained functionality by using the `Transducer.map` eager API.
- *
- * ```javascript [playground]
- * const square = number => number ** 2
- *
- * const concat = (array, item) => array.concat(item)
+ *   [1, 2, 3, 4, 5].reduce(squareConcatReducer, [])
+ * ) // [1, 4, 9, 16, 25]
  *
- * const squareConcatReducer = Transducer.map(concat, square)
- * // now mapSquare is passed the reducer function concat; squareConcatReducer
- * // is a reducer with chained functionality square and concat
+ * // concat is implicit when transforming into arrays
+ * console.log(
+ *   transform([1, 2, 3, 4, 5], Transducer.map(square), [])
+ * ) // [1, 4, 9, 16, 25]
  * ```
+ *
+ * Read more on transducers [here](/blog/transducers-crash-course-rubico-v2).
  */
 Transducer.map = function transducerMap(mapper) {
   return curry2(reducerMap, __, mapper)
@@ -80,14 +74,20 @@ Transducer.map = function transducerMap(mapper) {
  *
  * @synopsis
  * ```coffeescript [specscript]
- * type Reducer = (accumulator any, item any)=>(nextAccumulator Promise|any)
+ * type Reducer = (
+ *   accumulator any,
+ *   value any,
+ *   indexOrKey? number|string,
+ *   collection? Foldable,
+ * )=>(nextAccumulator Promise|any)
+ *
  * type Transducer = Reducer=>Reducer
  *
  * Transducer.filter(predicate function) -> filteringTransducer Transducer
  * ```
  *
  * @description
- * A reducer in filterable position creates a filtering reducer - one that skips items of the reducer's reducing operation if they test falsy by the predicate. It is possible to use an asynchronous predicate when filtering a reducer, however the implementation of `reduce` must support asynchronous operations. This library provides such an implementation as `reduce`.
+ * Creates a filtering transducer. A filtering reducer skips items of reducing operation if they test falsy by the predicate. It is possible to use an asynchronous predicate, however the reducing operation must support asynchronous execution. This library provides such implementations as [reduce](/docs/reduce) and [transform](/docs/transform).
  *
  * ```javascript [playground]
  * const isOdd = number => number % 2 == 1
@@ -110,33 +110,32 @@ Transducer.filter = function transducerFilter(predicate) {
  *
  * @synopsis
  * ```coffeescript [specscript]
- * type Reducer = (accumulator any, item any)=>(nextAccumulator Promise|any)
+ * type Reducer = (
+ *   accumulator any,
+ *   value any,
+ *   indexOrKey? number|string,
+ *   collection? Foldable,
+ * )=>(nextAccumulator Promise|any)
+ *
  * type Transducer = Reducer=>Reducer
  *
  * Transducer.flatMap(flatMapper) -> flatMappingTransducer Transducer
  * ```
  *
  * @description
- * Additionally, `flatMap` is a powerful option when working with transducers. A flatMapping transducer applies a flatMapper to each item of a reducer's reducing operation, calling each item of each execution with the reducer.
+ * Creates a flatMapping transducer. A flatMapping transducer applies the flatMapping function to each item of the reducing operation, concatenating the results of the flatMapper execution into the final result. It is possible to use an asynchronous flatMapper, however the reducing operation must support asynchronous execution. This library provides such implementations as [reduce](/docs/reduce) and [transform](/docs/transform).
  *
  * ```javascript [playground]
- * const isOdd = number => number % 2 == 1
- *
  * const powers = number => [number, number ** 2, number ** 3]
  *
- * const oddPowers = pipe([
- *   filter(isOdd),
- *   flatMap(powers),
- * ])
- *
- * const arrayConcat = (array, value) => array.concat(value)
+ * const numbers = [1, 2, 3, 4, 5]
  *
  * console.log(
- *   reduce(oddPowers(arrayConcat), [])([1, 2, 3, 4, 5]),
- * ) // [1, 1, 1, 3, 9, 27, 5, 25, 125]
+ *   transform(numbers, Transducer.flatMap(powers), [])
+ * ) // [1, 1, 1, 2, 4, 8, 3, 9, 27, 4, 16, 64, 5, 25, 125]
  * ```
  *
- * In the case above, each item of the array of numbers returned by `powers` is called with the reducer `arrayConcat` for flattening into the final result.
+ * Read more on transducers [here](/blog/transducers-crash-course-rubico-v2).
  */
 Transducer.flatMap = function transducerFlatMap(flatMapper) {
   return curry2(reducerFlatMap, __, flatMapper)
@@ -147,11 +146,28 @@ Transducer.flatMap = function transducerFlatMap(flatMapper) {
  *
  * @synopsis
  * ```coffeescript [specscript]
- * type Reducer = (accumulator any, item any)=>(nextAccumulator Promise|any)
+ * type Reducer = (
+ *   accumulator any,
+ *   value any,
+ *   indexOrKey? number|string,
+ *   collection? Foldable,
+ * )=>(nextAccumulator Promise|any)
+ *
  * type Transducer = Reducer=>Reducer
  *
  * Transducer.forEach(func function) -> forEachTransducer Transducer
  * ```
+ *
+ * @description
+ * Creates an effectful pasthrough transducer. The effectful passthrough transducer applies the effectful function to each item of the reducing operation, leaving the reducing operation unchanged. It is possible to use an asynchronous effectful function, however the reducing operation must support asynchronous execution. This library provides such implementations as [reduce](/docs/reduce) and [transform](/docs/transform).
+ *
+ * ```javascript [playground]
+ * const numbers = [1, 2, 3, 4, 5]
+ * transform(numbers, compose([
+ *   Transducer.map(number => number ** 2),
+ *   Transducer.forEach(console.log), // 1 4 9 16 25
+ * ]), null)
+ * ```
  */
 Transducer.forEach = function transducerForEach(func) {
   return curry2(reducerForEach, __, func)
@@ -162,11 +178,33 @@ Transducer.forEach = function transducerForEach(func) {
  *
  * @synopsis
  * ```coffeescript [specscript]
- * type Reducer = (accumulator any, item any)=>(nextAccumulator Promise|any)
+ * type Reducer = (
+ *   accumulator any,
+ *   value any,
+ *   indexOrKey? number|string,
+ *   collection? Foldable,
+ * )=>(nextAccumulator Promise|any)
+ *
  * type Transducer = Reducer=>Reducer
  *
  * Transducer.passthrough(func function) -> passthroughTransducer Transducer
  * ```
+ *
+ * @description
+ * Creates a pasthrough transducer. The passthrough transducer passes each item of the reducing operation through, leaving the reducing operation unchanged.
+ *
+ * ```javascript [playground]
+ * const createAsyncNumbers = async function* () {
+ *   let number = 0
+ *   while (number < 10) {
+ *     yield number
+ *     number += 1
+ *   }
+ * }
+ *
+ * transform(createAsyncNumbers(), Transducer.passthrough, [])
+ *   .then(console.log) // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+ * ```
  */
 Transducer.passthrough = function transducerPassthrough(reducer) {
   return reducer
@@ -177,11 +215,51 @@ Transducer.passthrough = function transducerPassthrough(reducer) {
  *
  * @synopsis
  * ```coffeescript [specscript]
- * type Reducer = (accumulator any, item any)=>(nextAccumulator Promise|any)
+ * type Reducer = (
+ *   accumulator any,
+ *   item any,
+ *   indexOrKey? number|string,
+ *   collection? Foldable,
+ * )=>(nextAccumulator Promise|any)
+ *
  * type Transducer = Reducer=>Reducer
  *
- * Transducer.tryCatch(func function) -> tryCatchTransducer Transducer
+ * Transducer.tryCatch(
+ *   transducerTryer Transducer,
+ *   catcher (error Error, item any)=>Promise|any,
+ * ) -> tryCatchTransducer Transducer
  * ```
+ *
+ * @description
+ * Creates an error handling transducer. The error handling transducer wraps a transducer and catches any errors thrown by the transducer with the catcher function. The catcher function is provided the error as well as the original item (before any processing by the transducer) for which the error was thrown. It is possible for either the transducer or the catcher to be asynchronous, however the reducing operation must support asynchronous execution. This library provides such implementations as [reduce](/docs/reduce) and [transform](/docs/transform).
+ *
+ * ```javascript [playground]
+ * const db = new Map()
+ * db.set('a', { id: 'a', name: 'George' })
+ * db.set('b', { id: 'b', name: 'Jane' })
+ * db.set('c', { id: 'c', name: 'Jill' })
+ * db.set('e', { id: 'e', name: 'Jim' })
+ *
+ * const userIds = ['a', 'b', 'c', 'd', 'e']
+ *
+ * transform(userIds, Transducer.tryCatch(compose([
+ *   Transducer.map(async userId => {
+ *     if (db.has(userId)) {
+ *       return db.get(userId)
+ *     }
+ *     throw new Error(`user ${userId} not found`)
+ *   }),
+ *
+ *   Transducer.forEach(user => {
+ *     console.log('Found', user.name)
+ *   })
+ * ]), (error, userId) => {
+ *   console.error(error)
+ *   console.log('userId in catcher:', userId)
+ *   // original userId for which the error was thrown is provided
+ * }), null)
+ * ```
+
  */
 Transducer.tryCatch = function transducerTryCatch(transducerTryer, catcher) {
   return curry3(reducerTryCatch, __, transducerTryer, catcher)

package/_internal/ComparisonOperator.d.ts

@@ -0,0 +1,2 @@
+export = ComparisonOperator;
+declare function ComparisonOperator(comparator: any): (...args: any[]) => any;

package/_internal/FilteringAsyncIterator.d.ts

@@ -0,0 +1,29 @@
+export = FilteringAsyncIterator;
+/**
+ * @name FilteringAsyncIterator
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * const filteringAsyncIterator = new FilteringAsyncIterator(
+ *   asyncIterator AsyncIterator<T>,
+ *   predicate T=>boolean,
+ * ) -> FilteringAsyncIterator<T>
+ *
+ * filteringAsyncIterator.next() -> { value: Promise, done: boolean }
+ * ```
+ */
+declare function FilteringAsyncIterator(asyncIterator: any, predicate: any): {
+    [x: number]: () => {
+        [x: number]: any;
+        isAsyncIteratorDone: boolean;
+        next(): Promise<{
+            value: any;
+            done: boolean;
+        }>;
+    };
+    isAsyncIteratorDone: boolean;
+    next(): Promise<{
+        value: any;
+        done: boolean;
+    }>;
+};

package/_internal/FilteringIterator.d.ts

@@ -0,0 +1,25 @@
+export = FilteringIterator;
+/**
+ * @name FilteringIterator
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * FilteringIterator<
+ *   T any,
+ *   iterator Iterator<T>,
+ *   predicate T=>boolean, # no async
+ * >(iterator, predicate) -> filteringIterator Iterator<T>
+ *
+ * filteringIterator.next() -> { value: T, done: boolean }
+ * ```
+ *
+ * @description
+ * Creates a filtering iterator, i.e. an iterator that filteres a source iterator by predicate.
+ */
+declare function FilteringIterator(iterator: any, predicate: any): {
+    [x: number]: () => {
+        [x: number]: any;
+        next(): any;
+    };
+    next(): any;
+};

package/_internal/FlatMappingAsyncIterator.d.ts

@@ -0,0 +1,34 @@
+export = FlatMappingAsyncIterator;
+/**
+ * @name FlatMappingAsyncIterator
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * new FlatMappingAsyncIterator(
+ *   asyncIterator AsyncIterator, flatMapper function,
+ * ) -> FlatMappingAsyncIterator AsyncIterator
+ * ```
+ *
+ * @execution concurrent
+ *
+ * @muxing
+ */
+declare function FlatMappingAsyncIterator(asyncIterator: any, flatMapper: any): {
+    [x: number]: () => any;
+    isAsyncIteratorDone: boolean;
+    toString(): string;
+    /**
+     * @name FlatMappingAsyncIterator.prototype.next
+     *
+     * @synopsis
+     * ```coffeescript [specscript]
+     * new FlatMappingAsyncIterator(
+     *   asyncIterator AsyncIterator, flatMapper function,
+     * ).next() -> Promise<{ value, done }>
+     * ```
+     */
+    next(): Promise<{
+        value: any;
+        done: boolean;
+    }>;
+};

package/_internal/FlatMappingIterator.d.ts

@@ -0,0 +1,15 @@
+export = FlatMappingIterator;
+/**
+ * @name FlatMappingIterator
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * FlatMappingIterator(
+ *   iterator Iterator, flatMapper function,
+ * ) -> FlatMappingIterator { next, SymbolIterator }
+ * ```
+ */
+declare function FlatMappingIterator(iterator: any, flatMapper: any): {
+    [x: number]: () => any;
+    next(): any;
+};

package/_internal/MappingAsyncIterator.d.ts

@@ -0,0 +1,21 @@
+export = MappingAsyncIterator;
+/**
+ * @name MappingAsyncIterator
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * mappingAsyncIterator = new MappingAsyncIterator(
+ *   asyncIter AsyncIterator<T>,
+ *   mapper T=>Promise|any,
+ * ) -> mappingAsyncIterator AsyncIterator
+ *
+ * mappingAsyncIterator.next() -> Promise<{ value: any, done: boolean }>
+ * ```
+ */
+declare function MappingAsyncIterator(asyncIterator: any, mapper: any): {
+    [x: number]: () => {
+        [x: number]: any;
+        next(): Promise<any>;
+    };
+    next(): Promise<any>;
+};

package/_internal/MappingIterator.d.ts

@@ -0,0 +1,29 @@
+export = MappingIterator;
+/**
+ * @name MappingIterator
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * MappingIterator<
+ *   T any,
+ *   iterator Iterator<T>,
+ *   mapper T=>any,
+ * >(iterator, mapper) -> mappingIterator Object
+ *
+ * mappingIterator.next() -> nextIteration { value: any, done: boolean }
+ * ```
+ *
+ * @description
+ * Creates a mapping iterator, i.e. an iterator that applies a mapper to each item of a source iterator.
+ *
+ * Note: consuming the mapping iterator also consumes the source iterator.
+ */
+declare function MappingIterator(iterator: any, mapper: any): {
+    [x: number]: () => {
+        [x: number]: any;
+        toString(): string;
+        next(): any;
+    };
+    toString(): string;
+    next(): any;
+};

package/_internal/NextIteration.d.ts

@@ -0,0 +1,14 @@
+export = NextIteration;
+/**
+ * @name NextIteration
+ *
+ * @synopsis
+ * NextIteration(value any) -> nextIteration { value, done: false }
+ *
+ * @description
+ * Create an object to send for the next iteration
+ */
+declare function NextIteration(value: any): {
+    value: any;
+    done: boolean;
+};

package/_internal/SelfReferencingPromise.d.ts

@@ -0,0 +1,10 @@
+export = SelfReferencingPromise;
+/**
+ * @name SelfReferencingPromise
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * SelfReferencingPromise(basePromise Promise<T>) -> Promise<[T, basePromise]>
+ * ```
+ */
+declare function SelfReferencingPromise(basePromise: any): any;

package/_internal/add.d.ts

@@ -0,0 +1,11 @@
+export = add;
+/**
+ * @name add
+ *
+ * @synopsis
+ * add (a any, b any) -> a + b
+ *
+ * @description
+ * `+` two things
+ */
+declare function add(a: any, b: any): any;

package/_internal/always.d.ts

@@ -0,0 +1,13 @@
+export = always;
+/**
+ * @name always
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * always(value any) -> getter ()=>value
+ * ```
+ *
+ * @description
+ * Create a function that always returns a value.
+ */
+declare function always(value: any): () => any;

package/_internal/areAllValuesNonfunctions.d.ts

@@ -0,0 +1,10 @@
+export = areAllValuesNonfunctions;
+/**
+ * @name areAllValuesNonfunctions
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * areAllValuesNonfunctions(values Array<function|value>) -> boolean
+ * ```
+ */
+declare function areAllValuesNonfunctions(values: any): boolean;

package/_internal/areAnyValuesPromises.d.ts

@@ -0,0 +1,10 @@
+export = areAnyValuesPromises;
+/**
+ * @name areAnyValuesPromises
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * areAnyValuesPromises(values Array) -> boolean
+ * ```
+ */
+declare function areAnyValuesPromises(values: any): boolean;

package/_internal/arrayConditional.d.ts

@@ -0,0 +1,20 @@
+export = arrayConditional;
+/**
+ * @name arrayConditional
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * arrayConditional(
+ *   array Array<function|value>,
+ *   args Array,
+ *   funcsIndex number,
+ * ) -> Promise|any
+ * ```
+ *
+ * @description
+ * Conditional operator `a ? b : c ? d : e ? ...` for functions.
+ *
+ * @TODO isPromise conditional await
+ * @TODO benchmark vs regular promise handling
+ */
+declare function arrayConditional(array: any, args: any, funcsIndex: any): any;

package/_internal/arrayEvery.d.ts

@@ -0,0 +1,10 @@
+export = arrayEvery;
+/**
+ * @name arrayEvery
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * arrayEvery(array Array, predicate ...any=>boolean) -> boolean
+ * ```
+ */
+declare function arrayEvery(array: any, predicate: any): any;

package/_internal/arrayExtend.d.ts

@@ -0,0 +1,13 @@
+export = arrayExtend;
+/**
+ * @name arrayExtend
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * arrayExtend(array Array, values Array) -> array
+ * ```
+ *
+ * @description
+ * Extend an array with values.
+ */
+declare function arrayExtend(array: any, values: any): any;

package/_internal/arrayExtendMap.d.ts

@@ -0,0 +1,20 @@
+export = arrayExtendMap;
+/**
+ * @name arrayExtendMap
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * any -> value; any -> mapped
+ *
+ * arrayExtendMap(
+ *   array Array<mapped>,
+ *   values Array<value>,
+ *   valuesIndex number,
+ *   valuesMapper value=>mapped,
+ * ) -> array
+ * ```
+ *
+ * @description
+ * `arrayExtend` while mapping
+ */
+declare function arrayExtendMap(array: any, values: any, valuesMapper: any, valuesIndex: any): any;

package/_internal/arrayFilter.d.ts

@@ -0,0 +1,16 @@
+export = arrayFilter;
+/**
+ * @name arrayFilter
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * arrayFilter<T>(
+ *   array Array<T>,
+ *   predicate T=>Promise|boolean,
+ * ) -> result Promise|Array<T>
+ * ```
+ *
+ * @description
+ * Filter an array concurrently by predicate. `predicate` may be asynchronous.
+ */
+declare function arrayFilter(array: any, predicate: any): any;

package/_internal/arrayFilterByConditions.d.ts

@@ -0,0 +1,20 @@
+export = arrayFilterByConditions;
+/**
+ * @name arrayFilterByConditions
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * arrayFilterByConditions(
+ *   array Array,
+ *   result Array,
+ *   index number,
+ *   conditions Array<boolean>,
+ * ) -> result
+ * ```
+ *
+ * @description
+ * Filter an array by a boolean array of conditions
+ *
+ * @TODO switch positions of index and conditions
+ */
+declare function arrayFilterByConditions(array: any, result: any, index: any, conditions: any): any;

package/_internal/arrayFlatMap.d.ts

@@ -0,0 +1,20 @@
+export = arrayFlatMap;
+/**
+ * @name arrayFlatMap
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * Stream<T> = { read: ()=>T, write: T=>() }
+ * Monad<T> = Array<T>|String<T>|Set<T>
+ *   |TypedArray<T>|Stream<T>|Iterator<Promise|T>
+ *   |{ chain: T=>Monad<T> }|{ flatMap: T=>Monad<T> }|Object<T>
+ * Reducer<T> = (any, T)=>Promise|any
+ * Foldable<T> = Iterable<T>|AsyncIterable<T>|{ reduce: Reducer<T> }|Object<T>
+ *
+ * arrayFlatMap<T>(
+ *   array Array<T>,
+ *   flatMapper T=>Promise|Monad<T>|Foldable<T>|T,
+ * ) -> Promise|Array<T>
+ * ```
+ */
+declare function arrayFlatMap(array: any, flatMapper: any): any;

package/_internal/arrayFlatten.d.ts

@@ -0,0 +1,20 @@
+export = arrayFlatten;
+/**
+ * @name arrayFlatten
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * Stream<T> = { read: ()=>T, write: T=>() }
+ * Monad<T> = Array<T>|String<T>|Set<T>
+ *   |TypedArray<T>|Stream<T>|Iterator<Promise|T>
+ *   |{ chain: T=>Monad<T> }|{ flatMap: T=>Monad<T> }|Object<T>
+ * Reducer<T> = (any, T)=>Promise|any
+ * Foldable<T> = Iterable<T>|AsyncIterable<T>|{ reduce: Reducer<T> }|Object<T>
+ *
+ * arrayFlatten<
+ *   T any,
+ *   array Array<Monad<T>|Foldable<T>|T>
+ * >(array) -> Array<T>
+ * ```
+ */
+declare function arrayFlatten(array: any): any;