import { compose } from "@commonly/function"

const composed = compose(String, Math.sin)
composed(7)      // -> "0.6569865987187891"

import { curry } from "@commonly/function"

const power = curry(Math.pow)
power(2)(3)     // -> 8

import { debounce } from "@commonly/function"

document.body.onscroll = debounce(alert, 250)     // -> A prompt will be shown only once for every time scrolling happens

import { delegate } from "@commonly/function"

import { identity } from "@commonly/function"

identity(2)     // -> 2
identity(3)     // -> 3
identity(5)     // -> 5

import { negate } from "@commonly/function"

const isUnsealed = negate(Object.isSealed)
isUnsealed(window)  // -> true

import { noop } from "@commonly/function"

noop(1, 1, 2, 3, 5)     // -> undefined

 import { partial } from "@commonly/function"

const isNaN = partial(Object.is, NaN)
isNaN(NaN)  // -> true

import { tap } from "@commonly/function"

Promise.resolve(3)
.then(tap(alert))    // -> value `x` will be shown in the alert box, it will equal to 3
.then(x => x * x)    // -> x is still equal to 3, chain is preserved
.then(tap(alert))    // -> value `x` will be shown again, this time it will equal to 9

import { throttle } from "@commonly/function"

document.body.onscroll = throttle(alert, 1250)     // -> A prompt will be shown once every 1250 milliseconds while scrolling

import { chain } from "@commonly/iterable"

chain(x => [ x, x * x ], [ 0, 1, 1, 2, 3, 5, 8 ])     // -> [ 0, 0, 1, 1, 1, 1, 2, 4, 3, 9, 5, 25, 8, 64 ]

import { distinct } from "@commonly/iterable"

distinct([ 0, 1, 1, 2, 3, 5, 8 ])     // -> [ 0, 1, 2, 3, 5, 8 ]

import { drop } from "@commonly/iterable"

drop(5, [ 0, 1, 1, 2, 3, 5, 8 ])     // -> [ 5, 8 ]

import { dropWhile } from "@commonly/iterable"

dropWhile(value => value <= 3, [ 0, 1, 1, 2, 3, 5, 8 ])     // -> [ 5, 8 ]

import { every } from "@commonly/iterable"

every(x => x % 2, [ 0, 1, 1, 2, 3, 5, 8 ])      // -> false

import { find } from "@commonly/iterable"

find(x => x > 2, [ 0, 1, 1, 2, 3, 5, 8 ])      // -> 3

import { filter } from "@commonly/iterable"

filter(x => x % 2, [ 0, 1, 1, 2, 3, 5, 8 ])      // -> [ 1, 1, 2, 3, 5 ]

import { flatten } from "@commonly/iterable"

flatten([ 0, [ 1 ], [ 1, 2 ], [ 3 , 5, 8 ] ])     // -> [ 0, 1, 1, 2, 3, 5, 8 ]

import { head } from "@commonly/iterable"

head([ 0, 1, 1, 2, 3, 5, 8 ])     // -> 0

import { last } from "@commonly/iterable"

last([ 0, 1, 1, 2, 3, 5, 8 ])     // -> 8

import { map } from "@commonly/iterable"

map(x => x * x, [ 0, 1, 1, 2, 3, 5, 8 ])         // -> [ 0, 1, 1, 4, 9, 25, 64 ]

import { nth } from "@commonly/iterable"

nth(4, [ 0, 1, 1, 2, 3, 5, 8 ])     // -> 3

import { partition } from "@commonly/iterable"

partition(2, [ 0, 1, 1, 2, 3, 5, 8 ])     // -> [ [ 0, 1 ], [ 1, 2 ], [ 3, 5 ], [ 8 ] ]

import { partitionBy } from "@commonly/iterable"

partitionBy(number => number > 2, [ 0, 1, 1, 2, 3, 5, 8 ])     // -> [ [ 0, 1, 1, 2 ], [ 3, 5, 8 ] ]

import { reduce } from "@commonly/iterable"

reduce((accumulator, value) => accumulator + value, 0, [0, 1, 1, 2, 3])      // -> 7

import { reverse } from "@commonly/iterable"

reverse([ 0, 1, 1, 2, 3, 5, 8 ])     // -> [ 8, 5, 3, 2, 1, 1, 0 ]

import { size } from "@commonly/iterable"

size([ 0, 1, 1, 2, 3, 5, 8 ])     // -> 7

import { slice } from "@commonly/iterable"

slice(1, 5, [ 0, 1, 1, 2, 3, 5, 8 ])     // -> [ 1, 1, 2, 3, 5 ]

import { some } from "@commonly/iterable"

some(x => x % 2, [ 0, 1, 1, 2, 3, 5, 8 ])      // -> true

import { sort } from "@commonly/iterable"

sort((a, b) => b - a, [ 0, 1, 1, 2, 3, 5, 8 ])     // -> [ 8, 5, 3, 2, 1, 1, 0 ]

import { take } from "@commonly/iterable"

take(5, [ 0, 1, 1, 2, 3, 5, 8 ])     // -> [ 0, 1, 1, 2, 3 ]

import { takeWhile } from "@commonly/iterable"

takeWhile(value => value <= 3, [ 0, 1, 1, 2, 3, 5, 8 ])     // -> [ 0, 1, 1, 2, 3 ]

import { tail } from "@commonly/iterable"

tail([ 0, 1, 1, 2, 3, 5, 8 ])     // -> [ 1, 1, 2, 3, 5, 8 ]

import { add } from "@commonly/math"

add(3, 2)   // -> 5

import { decrement } from "@commonly/math"

decrement(7)    // -> 6

import { divide } from "@commonly/math"

divide(3, 2)    // -> 1.5

import { decrement } from "@commonly/Math"

decrement(7)    // -> 8

import { maximum } from "@commonly/math"

maximum([ 0, 1, 1, 2, 3, 5, 8 ])    // -> 8

import { minimum } from "@commonly/math"

minimum([ 0, 1, 1, 2, 3, 5, 8 ])    // -> 0

import { multiply } from "@commonly/math"

multiply(3, 2)  // -> 6

import { subtract } from "@commonly/math"

subtract(3, 2)  // -> 1

import { isArray } from "@commonly/reflect"

isArray([])     //-> true
isArray({})      //-> false

import { isBoolean } from "@commonly/reflect"

isBoolean(true)     //-> true
isBoolean(false)    //-> true
isBoolean(NaN)      //-> false

import { isError } from "@commonly/reflect"

isError(new Error())    //-> true
isError(TypeError())    //-> true
isError(NaN)            //-> false

import { isFunction } from "@commonly/reflect"

isFunction(Math.add)        //-> true
isFunction(() => void 0))   //-> true
isFunction(Math.PI)         //-> false

import { isMap } from "@commonly/reflect"

isMap(new Map())     //-> true
isMap(NaN)           //-> false

import { isNil } from "@commonly/reflect"

isNil(undefined)   //-> true
isNil(null)        //-> true
isNil(NaN)         //-> false

import { isNull } from "@commonly/reflect"

isNull(null)        //-> true
isNull(undefined)   //-> false

import { isNumber } from "@commonly/reflect"

isNumber(0)           //-> true
isNumber(NaN)         //-> true
isNumber(null)        //-> false

import { isObject } from "@commonly/reflect"

isObject(new Object())      //-> true
isObject({})                //-> true
isObject(null)              //-> false
isObject(undefined)         //-> false

import { isPrimitive } from "@commonly/reflect"

isPrimitive(undefined)   //-> true
isPrimitive(null)        //-> true
isPrimitive(NaN)         //-> true
isPrimitive([])          //-> false

import { isPromise } from "@commonly/reflect"

isPromise(new Promise())         //-> true
isPromise(Promise.resolve())     //-> true
isPromise(NaN)                   //-> false

import { isRegExp } from "@commonly/reflect"

isRegExp(new RegExp("ab+c"))        //-> true
isRegExp(/ab+c/)                    //-> true
isRegExp(NaN)                       //-> false

import { isSet } from "@commonly/reflect"

isSet(new Set())     //-> true
isSet(NaN)           //-> false

import { isString } from "@commonly/reflect"

isString("string")   //-> true
isString(null)       //-> false

import { isSymbol } from "@commonly/reflect"

isSymbol(Symbol())      //-> true
isSymbol(NaN)           //-> false

import { isUndefined } from "@commonly/reflect"

isUndefined(undefined)   //-> true
isUndefined(null)        //-> false