@7urtle/lambda
Version:
Functional programming library in JavaScript.
1 lines • 135 kB
Source Map (JSON)
{"version":3,"file":"lambda.min.cjs","mappings":"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","sources":["webpack://L/webpack/universalModuleDefinition","webpack://L/webpack/bootstrap","webpack://L/webpack/runtime/define property getters","webpack://L/webpack/runtime/hasOwnProperty shorthand","webpack://L/webpack/runtime/make namespace object","webpack://L/./src/arity.js","webpack://L/./node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js","webpack://L/./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js","webpack://L/./node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js","webpack://L/./node_modules/@babel/runtime/helpers/esm/iterableToArray.js","webpack://L/./node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js","webpack://L/./node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js","webpack://L/./node_modules/@babel/runtime/helpers/esm/typeof.js","webpack://L/./src/conditional.js","webpack://L/./node_modules/@babel/runtime/helpers/esm/defineProperty.js","webpack://L/./node_modules/@babel/runtime/helpers/esm/toPropertyKey.js","webpack://L/./node_modules/@babel/runtime/helpers/esm/toPrimitive.js","webpack://L/./src/core.js","webpack://L/./src/utils.js","webpack://L/./src/string.js","webpack://L/./src/list.js","webpack://L/./src/Case.js","webpack://L/./src/AsyncEffect.js","webpack://L/./src/SyncEffect.js","webpack://L/./src/Either.js","webpack://L/./src/Maybe.js"],"sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"L\"] = factory();\n\telse\n\t\troot[\"L\"] = factory();\n})(this, () => {\nreturn ","// The require scope\nvar __webpack_require__ = {};\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","/**\n * nary curried function and allows it to be called both as curried and n-ary.\n *\n * @HindleyMilner nary :: (a -> b) -> a -> b\n *\n * @pure\n * @param {function} fn\n * @return {function}\n *\n * @example\n * import {nary} from '@7urtle/lambda';\n *\n * const fn = nary(a => b => a + b);\n * fn('a')('b') === fn('a', 'b'); // => true\n */\nexport const nary = fn =>\n (...args) => args.length === 0\n ? fn()\n : args.reduce(\n (accumulator, current) => accumulator(current),\n fn\n );\n\n/**\n * curry takes n-ary function and allows it to be called both as curried and n-ary.\n *\n * @HindleyMilner curry :: (a -> b) -> a -> b\n *\n * @pure\n * @param {function} fn\n * @return {function}\n *\n * @example\n * import {curry} from '@7urtle/lambda';\n *\n * const fn = curry((a, b) => a + b);\n * fn('a')('b') === fn('a', 'b'); // => true\n */\nexport const curry = fn =>\n (...args) => args.length >= fn.length\n ? fn(...args)\n : (...args2) => curry(fn)(...args, ...args2);","export default function _arrayLikeToArray(arr, len) {\n if (len == null || len > arr.length) len = arr.length;\n for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];\n return arr2;\n}","import arrayWithoutHoles from \"./arrayWithoutHoles.js\";\nimport iterableToArray from \"./iterableToArray.js\";\nimport unsupportedIterableToArray from \"./unsupportedIterableToArray.js\";\nimport nonIterableSpread from \"./nonIterableSpread.js\";\nexport default function _toConsumableArray(arr) {\n return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();\n}","import arrayLikeToArray from \"./arrayLikeToArray.js\";\nexport default function _arrayWithoutHoles(arr) {\n if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}","export default function _iterableToArray(iter) {\n if (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) return Array.from(iter);\n}","import arrayLikeToArray from \"./arrayLikeToArray.js\";\nexport default function _unsupportedIterableToArray(o, minLen) {\n if (!o) return;\n if (typeof o === \"string\") return arrayLikeToArray(o, minLen);\n var n = Object.prototype.toString.call(o).slice(8, -1);\n if (n === \"Object\" && o.constructor) n = o.constructor.name;\n if (n === \"Map\" || n === \"Set\") return Array.from(o);\n if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen);\n}","export default function _nonIterableSpread() {\n throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}","export default function _typeof(o) {\n \"@babel/helpers - typeof\";\n\n return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) {\n return typeof o;\n } : function (o) {\n return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o;\n }, _typeof(o);\n}","import { typeOf, lengthOf, deepInspect } from \"./utils.js\";\nimport { everyOf, someOf } from './list.js';\nimport { nary } from \"./arity.js\";\n\n/**\n * and is a boolean-type function composition\n * where each boolean function is '&&'d together.\n * \n * The boolean functions may be entered in any order.\n * \n * and can be used together with or to encapsulate a predicate in a single function.\n * \n * @HindleyMilner and :: [(a -> boolean)] -> a -> boolean\n * \n * @pure\n * @param {function} predicates\n * @param {*} anything\n * @return {*}\n * \n * @example\n * import {and, isGreaterThan, isLessThan} from '@7urtle/lambda';\n * \n * const isEven = number => number % 2 === 0;\n * \n * const isSingleEvenDigit = and(isEven, isGreaterThan(-10), isLessThan(10));\n * isSingleEvenDigit(8)\n * // => true\n */\n export const and = (...predicates) => anything => everyOf(predicate => predicate(anything))(predicates);\n\n /**\n * or is a boolean-type function composition\n * where each boolean function is '||'d together.\n * \n * The boolean functions may be entered in any order.\n * \n * or can be used together with and to encapsulate a predicate in a single function.\n * \n * @HindleyMilner or :: [(a -> boolean)] -> a -> boolean\n * \n * @pure\n * @param {function} predicates\n * @param {*} anything\n * @return {*}\n * \n * @example\n * import {or} from '@7urtle/lambda';\n * \n * const isDivisibleBy = divisor => number => number % divisor === 0;\n * const isFizzBuzzNumber = or(isDivisibleBy(3), isDivisibleBy(5));\n * \n * isFizzBuzzNumber(15)\n * // => true\n */\n export const or = (...predicates) => anything => someOf(predicate => predicate(anything))(predicates);\n\n/**\n * isEqual output is true if strict equality between a and b is true. isEqual output is always false for comparison\n * of objects and arrays.\n *\n * isEqual can be called both as a curried unary function or as a standard binary function.\n *\n * @HindleyMilner isEqual :: a -> b -> boolean\n *\n * @pure\n * @param {*} a\n * @param {*} b\n * @return {boolean}\n *\n * @example\n * import {isEqual} from '@7urtle/lambda';\n *\n * isEqual('something')('something'); // => true\n * isEqual('something')('something else'); // => false\n * isEqual(['a'])(['a']); // => false\n * isEqual({a : 'something'})({a : 'something'}); // => false\n * isEqual([])([]); // => false\n * isEqual([])([]); // => false\n *\n * // isEqual can be called both as a curried unary function or as a standard binary function\n * isEqual('something')('something') === isEqual('something', 'something');\n */\nexport const isEqual = nary(a => b => a === b);\n\n/**\n * isNotEqual output is true if strict equality between a and b is false. isNotEqual output is always true for\n * comparison of objects and arrays.\n *\n * isEqual can be called both as a curried unary function or as a standard binary function.\n *\n * @HindleyMilner isNotEqual :: a -> b -> boolean\n *\n * @pure\n * @param {*} a\n * @param {*} b\n * @return {boolean}\n *\n * @example\n * import {isNotEqual} from '@7urtle/lambda';\n *\n * isNotEqual('something')('something'); // => false\n * isNotEqual('something')('something else'); // => true\n * isNotEqual(['a'])(['a']); // => true\n * isNotEqual({a : 'something'})({a : 'something'}); // => true\n * isNotEqual([])([]); // => true\n * isNotEqual([])([]); // => true\n *\n * // isNotEqual can be called both as a curried unary function or as a standard binary function\n * isNotEqual('something')('something else') === isNotEqual('something', 'something else');\n */\nexport const isNotEqual = nary(a => b => a !== b);\n\n/**\n * isDeepEqual output is true if strict equality between the string conversion of a and the string conversion of b\n * is true including arrays and objects.\n *\n * isDeepEqual can be called both as a curried unary function or as a standard binary function.\n *\n * @HindleyMilner isDeepEqual :: a -> b -> boolean\n *\n * @pure\n * @param {*} a\n * @param {*} b\n * @return {boolean}\n *\n * @example\n * import {isDeepEqual} from '@7urtle/lambda';\n *\n * isDeepEqual('something')('something'); // => true\n * isDeepEqual('something')('something else'); // => false\n * isDeepEqual(['a'])(['a']); // => true\n * isDeepEqual({a : 'something'})({a : 'something'}); // => true\n * isDeepEqual([])([]); // => true\n * isDeepEqual([])([]); // => true\n *\n * // isDeepEqual can be called both as a curried unary function or as a standard binary function\n * isDeepEqual('something')('something') === isDeepEqual('something', 'something');\n */\nexport const isDeepEqual = nary(a => b => isEqual(deepInspect(a))(deepInspect(b)));\n\n/**\n * isNotDeepEqual output is true if strict equality between the string conversion of a and the string conversion of b\n * is false including arrays and objects.\n *\n * isNotDeepEqual can be called both as a curried unary function or as a standard binary function.\n *\n * @HindleyMilner isNotDeepEqual :: a -> b -> boolean\n *\n * @pure\n * @param {*} a\n * @param {*} b\n * @return {boolean}\n *\n * @example\n * import {isNotDeepEqual} from '@7urtle/lambda';\n *\n * isNotDeepEqual('something')('something'); // => false\n * isNotDeepEqual('something')('something else'); // => true\n * isNotDeepEqual(['a', 'b'])(['a']); // => true\n * isNotDeepEqual({a : 'something', b: c => c})({a : 'something'}); // => true\n * isNotDeepEqual([])([]); // => false\n * isNotDeepEqual([])([]); // => false\n *\n * // isNotDeepEqual can be called both as a curried unary function or as a standard binary function\n * isNotDeepEqual('something')('something else') === isNotDeepEqual('something', 'something else');\n */\nexport const isNotDeepEqual = nary(a => b => isNotEqual(deepInspect(a))(deepInspect(b)));\n\n/**\n * isTrue output is true if input is true.\n *\n * @HindleyMilner isTrue :: a -> boolean\n *\n * @pure\n * @param {*} anything\n * @return {boolean}\n *\n * @example\n * import {isTrue} from '@7urtle/lambda';\n *\n * isTrue(true); // => true\n * isTrue(false); // => false\n */\nexport const isTrue = isEqual(true);\n\n/**\n * isFalse output is true if input is false.\n *\n * @HindleyMilner isFalse :: a -> Boolean\n *\n * @pure\n * @param {*} anything\n * @return {boolean}\n *\n * @example\n * import {isFalse} from '@7urtle/lambda';\n *\n * isFalse(true); // => false\n * isFalse(false); // => true\n */\nexport const isFalse = isEqual(false);\n\n/**\n * isGreaterThan output is true if b is greater than a.\n *\n * isGreaterThan can be called both as a curried unary function or as a standard binary function.\n *\n * @HindleyMilner isGreaterThan :: a -> b -> boolean\n *\n * @pure\n * @param {number} a\n * @param {number} b\n * @return {boolean}\n *\n * @example\n * import {isGreaterThan} from '@7urtle/lambda';\n *\n * isGreaterThan(1)(2); // => true\n * isGreaterThan(3)(2); // => false\n *\n * // isGreaterThan can be called both as a curried unary function or as a standard binary function\n * isGreaterThan(1)(2) === isGreaterThan(1, 2);\n */\nexport const isGreaterThan = nary(a => b => b > a);\n\n/**\n * isLessThan output is true if b is less than a.\n *\n * isLessThan can be called both as a curried unary function or as a standard binary function.\n *\n * @HindleyMilner isLessThan :: a -> b -> boolean\n *\n * @pure\n * @param {number} a\n * @param {number} b\n * @return {boolean}\n *\n * @example\n * import {isLessThan} from '@7urtle/lambda';\n *\n * isLessThan(1)(2); // => false\n * isLessThan(3)(2); // => true\n *\n * // isLessThan can be called both as a curried unary function or as a standard binary function\n * isLessThan(3)(2) === isLessThan(3, 2);\n */\nexport const isLessThan = nary(a => b => b < a);\n\n/**\n * isAtLeast output is true if b is greater or equal to a.\n *\n * isAtLeast can be called both as a curried unary function or as a standard binary function.\n *\n * @HindleyMilner isAtLeast :: a -> b -> boolean\n *\n * @pure\n * @param {number} a\n * @param {number} b\n * @return {boolean}\n *\n * @example\n * import {isAtLeast} from '@7urtle/lambda';\n *\n * isAtLeast(1)(2); // => true\n * isAtLeast(2)(2); // => true\n * isAtLeast(3)(2); // => false\n *\n * // isAtLeast can be called both as a curried unary function or as a standard binary function\n * isAtLeast(1)(2) === isAtLeast(1, 2);\n */\nexport const isAtLeast = nary(a => b => b >= a);\n\n/**\n * isAtMost output is true if b is less or equal to a.\n *\n * isAtMost can be called both as a curried unary function or as a standard binary function.\n *\n * @HindleyMilner isAtMost :: a -> b -> boolean\n *\n * @pure\n * @param {number} a\n * @param {number} b\n * @return {boolean}\n *\n * @example\n * import {isAtMost} from '@7urtle/lambda';\n *\n * isAtMost(1)(2); // => false\n * isAtMost(2)(2); // => true\n * isAtMost(3)(2); // => true\n *\n * // isAtLeast can be called both as a curried unary function or as a standard binary function\n * isAtMost(3)(2) === isAtMost(31, 2);\n */\nexport const isAtMost = nary(a => b => b <= a);\n\n/**\n * isBetween output is true if c is between a and b.\n *\n * isBetween can be called both as a curried unary function or as a standard ternary function.\n *\n * @HindleyMilner isBetween :: a -> b -> c -> boolean\n *\n * @pure\n * @param {number} a\n * @param {number} b\n * @param {number} c\n * @return {boolean}\n *\n * @example\n * import {isBetween} from '@7urtle/lambda';\n *\n * isBetween(1)(3)(2); // => true\n * isBetween(3)(1)(2); // => true\n * isBetween(1)(3)(3); // => false\n * isBetween(1)(3)(4); // => false\n *\n * // isBetween can be called both as a curried unary function or as a standard ternary function\n * isBetween(1)(3)(2) === isBetween(1, 3, 2);\n */\nexport const isBetween = nary(a => b => c =>\n a > b\n ? a > c && b < c\n : a < c && b > c\n);\n\n/**\n * isInRange output is true if c is in range of a and b.\n *\n * isInRange can be called both as a curried unary function or as a standard ternary function.\n *\n * @HindleyMilner isInRange :: a -> b -> c -> boolean\n *\n * @pure\n * @param {number} a\n * @param {number} b\n * @param {number} c\n * @return {boolean}\n *\n * @example\n * import {isInRange} from '@7urtle/lambda';\n *\n * isInRange(1)(3)(2); // => true\n * isInRange(3)(1)(2); // => true\n * isInRange(1)(3)(3); // => true\n * isInRange(1)(3)(4); // => false\n *\n * // isInRange can be called both as a curried unary function or as a standard ternary function\n * isInRange(1)(3)(2) === isInRange(1, 3, 2);\n */\n export const isInRange = nary(a => b => c =>\n a > b\n ? a >= c && b <= c\n : a <= c && b >= c\n);\n\n/**\n * isTypeOf output is true if b is a type of a.\n *\n * isTypeOf can be called both as a curried unary function or as a standard binary function.\n *\n * @HindleyMilner isTypeOf :: a -> b -> boolean\n *\n * @pure\n * @param {*} a\n * @param {*} b\n * @return {boolean}\n *\n * @example\n * import {isTypeOf} from '@7urtle/lambda';\n *\n * isTypeOf('number')(1); // => true\n * isTypeOf('string')(1); // => false\n *\n * // isTypeOf can be called both as a curried unary function or as a standard binary function\n * isTypeOf('number')(1) === isTypeOf('number', 1);\n */\nexport const isTypeOf = nary(a => b => isEqual(typeOf(b))(a));\n\n/**\n * isNotTypeOf output is true if b is not a type of a.\n *\n * isNotTypeOf can be called both as a curried unary function or as a standard binary function.\n *\n * @HindleyMilner isNotTypeOf :: a -> b -> boolean\n *\n * @pure\n * @param {*} a\n * @param {*} b\n * @return {boolean}\n *\n * @example\n * import {isNotTypeOf} from '@7urtle/lambda';\n *\n * isNotTypeOf('number')(1); // => false\n * isNotTypeOf('string')(1); // => true\n *\n * // isNotTypeOf can be called both as a curried unary function or as a standard binary function\n * isNotTypeOf('string')(1) === isNotTypeOf('string', 1);\n */\nexport const isNotTypeOf = nary(a => b => isNotEqual(typeOf(b))(a));\n\n/**\n * isString output is true if input is a string.\n *\n * @HindleyMilner isString :: a -> boolean\n *\n * @pure\n * @param {*} a\n * @return {boolean}\n *\n * @example\n * import {isString} from '@7urtle/lambda';\n *\n * isString('string'); // => true\n * isString(1); // => false\n */\nexport const isString = isTypeOf('string');\n\n/**\n * isNotString output is true if input is not a string.\n *\n * @HindleyMilner isNotString :: a -> boolean\n *\n * @pure\n * @param {*} a\n * @return {boolean}\n *\n * @example\n * import {isNotString} from '@7urtle/lambda';\n *\n * isNotString('string'); // => false\n * isNotString(1); // => true\n */\nexport const isNotString = isNotTypeOf('string');\n\n/**\n * isBoolean output is true if input is a boolean.\n *\n * @HindleyMilner isBoolean :: a -> boolean\n *\n * @pure\n * @param {*} a\n * @return {boolean}\n *\n * @example\n * import {isBoolean} from '@7urtle/lambda';\n *\n * isBoolean(false); // => true\n * isBoolean(1); // => false\n */\nexport const isBoolean = isTypeOf('boolean');\n\n/**\n * isNotBoolean output is true if input is not a boolean.\n *\n * @HindleyMilner isNotBoolean :: a -> boolean\n *\n * @pure\n * @param {*} a\n * @return {boolean}\n *\n * @example\n * import {isNotBoolean} from '@7urtle/lambda';\n *\n * isNotBoolean(false); // => false\n * isNotBoolean(1); // => true\n */\nexport const isNotBoolean = isNotTypeOf('boolean');\n\n/**\n * isNull output is true if input is a null.\n *\n * @HindleyMilner isNull :: a -> boolean\n *\n * @pure\n * @param {*} a\n * @return {boolean}\n *\n * @example\n * import {isNull} from '@7urtle/lambda';\n *\n * isNull(null); // => true\n * isNull(1); // => false\n */\nexport const isNull = isEqual(null);\n\n/**\n * isNotNull output is true if input is not a null.\n *\n * @HindleyMilner isNotNull :: a -> boolean\n *\n * @pure\n * @param {*} a\n * @return {boolean}\n *\n * @example\n * import {isNotNull} from '@7urtle/lambda';\n *\n * isNotNull(null); // => false\n * isNotNull(1); // => true\n */\nexport const isNotNull = isNotEqual(null);\n\n/**\n * isUndefined output is true if input is an undefined.\n *\n * @HindleyMilner isUndefined :: a -> boolean\n *\n * @pure\n * @param {*} a\n * @return {boolean}\n *\n * @example\n * import {isUndefined} from '@7urtle/lambda';\n *\n * isUndefined(undefined); // => true\n * isUndefined(1); // => false\n */\nexport const isUndefined = isTypeOf('undefined');\n\n/**\n * isNotUndefined output is true if input is not an undefined.\n *\n * @HindleyMilner isNotUndefined :: a -> boolean\n *\n * @pure\n * @param {*} a\n * @return {boolean}\n *\n * @example\n * import {isNotUndefined} from '@7urtle/lambda';\n *\n * isNotUndefined(undefined); // => false\n * isNotUndefined(1); // => true\n */\nexport const isNotUndefined = isNotTypeOf('undefined');\n\n/**\n * isNumber output is true if input is a number.\n *\n * @HindleyMilner isNumber :: a -> boolean\n *\n * @pure\n * @param {*} a\n * @return {boolean}\n *\n * @example\n * import {isNumber} from '@7urtle/lambda';\n *\n * isNumber(1); // => true\n * isNumber('string'); // => false\n */\nexport const isNumber = isTypeOf('number');\n\n/**\n * isNotNumber output is true if input is not a number.\n *\n * @HindleyMilner isNotNumber :: a -> boolean\n *\n * @pure\n * @param {*} a\n * @return {boolean}\n *\n * @example\n * import {isNotNumber} from '@7urtle/lambda';\n *\n * isNotNumber(1); // => false\n * isNotNumber('string'); // => true\n */\nexport const isNotNumber = isNotTypeOf('number');\n\n/**\n * isObject output is true if b is an object, array, or null.\n *\n * @HindleyMilner isObject :: a -> boolean\n *\n * @pure\n * @param {*} a\n * @return {boolean}\n *\n * @example\n * import {isObject} from '@7urtle/lambda';\n *\n * isObject({}); // => true\n * isObject([]); // => true\n * isObject(null); // => true\n * isObject(1); // => false\n */\nexport const isObject = isTypeOf('object');\n\n/**\n * isNotObject output is true if input is not an object, array, or null.\n *\n * @HindleyMilner isNotObject :: a -> boolean\n *\n * @pure\n * @param {*} a\n * @return {boolean}\n *\n * @example\n * import {isNotObject} from '@7urtle/lambda';\n *\n * isNotObject({}); // => false\n * isNotObject([]); // => false\n * isNotObject(null); // => false\n * isNotObject(1); // => true\n */\nexport const isNotObject = isNotTypeOf('object');\n\n/**\n * isArray output is true if input is an array.\n *\n * @HindleyMilner isArray :: a -> boolean\n *\n * @pure\n * @param {*} a\n * @return {boolean}\n *\n * @example\n * import {isArray} from '@7urtle/lambda';\n *\n * isArray([]); // => true\n * isArray({}); // => false\n */\nexport const isArray = Array.isArray;\n\n/**\n * isNotArray output is true if input is not an array.\n *\n * @HindleyMilner isNotArray :: a -> boolean\n *\n * @pure\n * @param {*} a\n * @return {boolean}\n *\n * @example\n * import {isNotArray} from '@7urtle/lambda';\n *\n * isNotArray([]); // => false\n * isNotArray({}); // => true\n */\nexport const isNotArray = a => !Array.isArray(a);\n\n/**\n * isFunction output is true if input is a function.\n *\n * @HindleyMilner isFunction :: a -> boolean\n *\n * @pure\n * @param {*} a\n * @return {boolean}\n *\n * @example\n * import {isFunction} from '@7urtle/lambda';\n *\n * isFunction(() => null); // => true\n * isFunction(1); // => false\n */\nexport const isFunction = isTypeOf('function');\n\n/**\n * isNotFunction output is true if input is not a function.\n *\n * @HindleyMilner isNotFunction :: a -> boolean\n *\n * @pure\n * @param {*} a\n * @return {boolean}\n *\n * @example\n * import {isNotFunction} from '@7urtle/lambda';\n *\n * isNotFunction(() => null); // => false\n * isNotFunction(1); // => true\n */\nexport const isNotFunction = isNotTypeOf('function');\n\n/**\n * isLength output is true if b is a length of a.\n *\n * @HindleyMilner isLength :: (string|array) -> b -> boolean\n *\n * @pure\n * @param {string|array} a\n * @param {number} b\n * @return {boolean}\n *\n * @example\n * import {isLength} from '@7urtle/lambda';\n *\n * isLength(3)('abc'); // => true\n * isLength(3)([1,2,3]); // => true\n * isLength(3)('abc'); // => false\n */\nexport const isLength = nary(a => b => isEqual(lengthOf(b))(a));\n\n/**\n * isNotLength output is true if b is not a length of a.\n * \n * The function can be called both as a unary isNotLength(a)(b) and binary isNotLength(a, b).\n *\n * @HindleyMilner isNotLength :: (string|array) -> b -> boolean\n *\n * @pure\n * @param {string|array} a\n * @param {number} b\n * @return {boolean}\n *\n * @example\n * import {isNotLength} from '@7urtle/lambda';\n *\n * isNotLength(3)('abc'); // => false\n * isNotLength(3)([1,2,3]); // => false\n * isNotLength(3)('abce'); // => true\n * \n * isNotLength(3)('abcd') === isNotLength(3, 'abcd'); // => true\n */\nexport const isNotLength = nary(a => b => !isLength(a)(b));\n\n/**\n * isElement output is true if input is an HTML or SVG Element. Otherwise it is false.\n *\n * @HindleyMilner isElement :: a -> boolean\n *\n * @pure\n * @param {*} anything\n * @return {boolean}\n *\n * @example\n * import {isElement} from '@7urtle/lambda';\n *\n * isElement(document.createElement('span')); // => true\n */\nexport const isElement = anything =>\n (typeof Element !== 'undefined' && anything instanceof Element) ||\n (typeof HTMLDocument !== 'undefined' && anything instanceof HTMLDocument);\n\n/**\n * isNotElement output is true if input is not an HTML or SVG Element. Otherwise it is false.\n *\n * @HindleyMilner isNotElement :: a -> boolean\n *\n * @pure\n * @param {*} anything\n * @return {boolean}\n *\n * @example\n * import {isNotElement} from '@7urtle/lambda';\n *\n * isNotElement(document.createElement('span')); // => false\n */\nexport const isNotElement = anything => !isElement(anything);\n\n/**\n * isEmpty output is true if input is an empty string, array, or object. Otherwise it is false.\n *\n * @HindleyMilner isEmpty :: (string|array|Element) -> boolean\n *\n * @pure\n * @param {string|array|object} anything\n * @return {boolean}\n *\n * @example\n * import {isEmpty} from '@7urtle/lambda';\n *\n * isEmpty(''); // => true\n * isEmpty([]); // => true\n * isEmpty({}); // => true\n * isEmpty('abc'); // => false\n * isEmpty(document.getElementByID('image')); // => false\n */\nexport const isEmpty = anything =>\n isLength(0)(anything) ||\n isNotElement(anything) &&\n (isObject(anything) ? isLength(0)(Object.getOwnPropertyNames(anything)) : false);\n\n/**\n * isNotEmpty output is false if input is an empty string, array, or object. Otherwise it is true.\n *\n * @HindleyMilner isNotEmpty :: (string|array|Element) -> boolean\n *\n * @pure\n * @param {string|array|object} anything\n * @return {boolean}\n *\n * @example\n * import {isNotEmpty} from '@7urtle/lambda';\n *\n * isNotEmpty(''); // => false\n * isNotEmpty([]); // => false\n * isNotEmpty('abc'); // => true\n * isNotEmpty({}); => true\n * isNotEmpty(document.getElementByID('image')); // => true\n */\nexport const isNotEmpty = anything => !isEmpty(anything);\n\n/**\n * isZero output is true if input is 0.\n *\n * @HindleyMilner isZero :: a -> boolean\n *\n * @pure\n * @param {number} a\n * @return {boolean}\n *\n * @example\n * import {isZero} from '@7urtle/lambda';\n *\n * isZero(0); // => true\n * isZero(1); // => false\n */\nexport const isZero = isEqual(0);\n\n/**\n * isNotZero output is true if input is not 0.\n *\n * @HindleyMilner isNotZero :: a -> boolean\n *\n * @pure\n * @param {number} a\n * @return {boolean}\n *\n * @example\n * import {isZero} from '@7urtle/lambda';\n *\n * isZero(0); // => false\n * isZero(1); // => true\n */\nexport const isNotZero = isNotEqual(0);\n\n/**\n * isNothing returns true if input is null, undefined or empty string or empty array or empty object or the monad Nothing.\n *\n * @HindleyMilner isNothing :: a -> boolean\n *\n * @pure\n * @param {*} anything\n * @return {boolean}\n *\n * @example\n * import { isNothing, Maybe, Just, Nothing } from '@7urtle/lambda';\n *\n * isNothing(null); // => true\n * isNothing(undefined); // => true\n * isNothing(''); // => true\n * isNothing([]); // => true\n * isNothing({}); // => true\n * isNothing(Maybe.of('')); // => true\n * isNothing(Nothing); // => true\n * isNothing('7urtle'); // => false\n * isNothing(Maybe.of('7urtle')); // => false\n * isNothing(Just('7urtle')); // => false\n */\nexport const isNothing = anything =>\n anything && anything.isNothing\n ? anything.isNothing()\n : isNull(anything) || isUndefined(anything) || isEmpty(anything);\n\n/**\n * isJust returns true if input is not null, undefined or empty string or empty array or empty object.\n *\n * @HindleyMilner isJust :: a -> boolean\n *\n * @pure\n * @param {*} anything\n * @return {boolean}\n *\n * @example\n * import { isJust, Maybe, Just, Nothing } from '@7urtle/lambda';\n *\n * isJust(null); // => false\n * isJust(undefined); // => false\n * isJust(''); // => false\n * isJust([]); // => false\n * isJust({}); // => false\n * isJust(Nothing); // => false\n * isJust('7urtle'); // => true\n * isJust(Maybe.of('7urtle')); // => true\n * isJust(Just('7urtle')); // => true\n */\nexport const isJust = anything =>\n !isNothing(anything);\n\n/**\n * when tests anything argument by passing it to predicate function. If the predicate function is true, when\n * will return the result of whenTrueFn function which receivs the same anything argument. If the predicate\n * is false, then the anything argument is returned unchanged.\n * \n * The function can be called both as a unary when(predicate)(whenTrueFn)(anything) and ternary when(predicate, whenTrueFn, anything).\n *\n * @HindleyMilner when :: (a -> Boolean) -> (a -> a) -> a -> a\n *\n * @pure\n * @param {function} predicate\n * @param {function} whenTrueFn\n * @param {*} anything\n * @return {*}\n *\n * @example\n * import {when} from '@7urtle/lambda';\n *\n * const predicate = a => a > 1;\n * const whenTrueFn = a => a * 2;\n * \n * when(predicate)(whenTrueFn)(2); // => 4\n * when(predicate)(whenTrueFn)(1); // => 1\n * \n * when(predicate)(whenTrueFn)(2) === when(predicate, whenTrueFn, 2); // => true\n */\nexport const when = nary(predicate => whenTrueFn => anything =>\n predicate(anything)\n ? whenTrueFn(anything)\n : anything\n);\n\n/**\n * unless tests anything argument by passing it to predicate function. If the predicate function is false, unless\n * will return the result of whenFalseFn function which receivs the same anything argument. If the predicate\n * is true, then the anything argument is returned unchanged.\n * \n * The function can be called both as a unary unless(predicate)(whenFalseFn)(anything) and ternary unless(predicate, whenFalseFn, anything).\n *\n * @HindleyMilner unless :: (a -> Boolean) -> (a -> a) -> a -> a\n *\n * @pure\n * @param {function} predicate\n * @param {function} whenFalseFn\n * @param {*} anything\n * @return {*}\n *\n * @example\n * import {unless} from '@7urtle/lambda';\n *\n * const predicate = a => a > 1;\n * const whenFalseFn = a => a * 2;\n * \n * when(predicate)(whenFalseFn)(4); // => 4\n * when(predicate)(whenFalseFn)(1); // => 2\n * \n * when(predicate)(whenFalseFn)(1) === when(predicate, whenFalseFn, 1); // => true\n */\nexport const unless = nary(predicate => whenFalseFn => anything =>\n predicate(anything)\n ? anything\n : whenFalseFn(anything)\n);\n\n/**\n * ifElse tests anything argument by passing it to predicate function. If the predicate function is true, ifElse\n * will return the result of whenTrueFn function which receivs the same anything argument. If the predicate\n * is false, then the anything argument is passed to the whenFalseFn function.\n * \n * The function can be called both as a unary ifElse(predicate)(whenTrueFn)(whenFalseFn)(anything) and quaternary\n * ifElse(predicate, whenTrueFn, whenFalseFn, anything).\n *\n * @HindleyMilner ifElse :: (a -> Boolean) -> (a -> a) -> (a -> a) a -> a\n *\n * @pure\n * @param {function} predicate\n * @param {function} whenTrueFn\n * @param {function} whenFalseFn\n * @param {*} anything\n * @return {*}\n *\n * @example\n * import {ifElse} from '@7urtle/lambda';\n *\n * const predicate = a => a > 1;\n * const whenTrueFn = a => a / 2;\n * const whenFalseFn = a => a * 2;\n * \n * ifElse(predicate)(whenTrueFn)(whenFalseFn)(4); // => 2\n * ifElse(predicate)(whenTrueFn)(whenFalseFn)(1); // => 2\n * \n * ifElse(predicate)(whenTrueFn)(whenFalseFn)(1) === ifElse(predicate, whenTrueFn, whenFalseFn, 1); // => true\n */\n export const ifElse = nary(predicate => whenTrueFn => whenFalseFn => anything =>\n predicate(anythin