diff --git a/.gitignore b/.gitignore
index e69de29..2ccbe46 100644
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1 @@
+/node_modules/
diff --git a/.jshintrc b/.jshintrc
new file mode 100644
index 0000000..e776306
--- /dev/null
+++ b/.jshintrc
@@ -0,0 +1,46 @@
+{
+ "bitwise": false,
+ "camelcase": false,
+ "curly": false,
+ "eqeqeq": true,
+ "forin": false,
+ "freeze": false,
+ "immed": true,
+ "indent": 2,
+ "latedef": false,
+ "newcap": false,
+ "noarg": true,
+ "noempty": true,
+ "nonew": true,
+ "plusplus": true,
+ "undef": true,
+ "unused": "vars",
+ "strict": false,
+ "asi": false,
+ "boss": false,
+ "debug": false,
+ "eqnull": true,
+ "esnext": true,
+ "evil": false,
+ "expr": false,
+ "funcscope": false,
+ "globalstrict": false,
+ "iterator": false,
+ "lastsemic": false,
+ "laxbreak": false,
+ "laxcomma": false,
+ "loopfunc": false,
+ "moz": false,
+ "multistr": false,
+ "notypeof": false,
+ "proto": false,
+ "scripturl": false,
+ "shadow": false,
+ "sub": false,
+ "supernew": false,
+ "validthis": false,
+ "nonstandard": true,
+ "browser": false,
+ "es3": false,
+ "node": true
+}
diff --git a/CNAME b/CNAME
new file mode 100644
index 0000000..2b5ed85
--- /dev/null
+++ b/CNAME
@@ -0,0 +1 @@
+sanctuary.js.org
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 0000000..1a9efe5
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,28 @@
+# Contributing
+
+1. Update local gh-pages branch:
+
+ $ git checkout gh-pages
+ $ git pull upstream gh-pages
+
+2. Create feature branch:
+
+ $ git checkout -b feature-x
+
+3. Make one or more atomic commits, and ensure that each commit has a
+ descriptive commit message. Commit messages should be line wrapped
+ at 72 characters.
+
+4. Run `make` to build the site. This requires a recent version of Node.
+
+5. Review the changes in a browser.
+
+6. Run `make test lint`, and address any errors. Preferably, fix commits
+ in place using `git rebase` or `git commit --amend` to make the changes
+ easier to review.
+
+7. Push:
+
+ $ git push origin feature-x
+
+8. Open a pull request. Include screenshots if applicable.
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..8494e78
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,47 @@
+JSHINT = node_modules/.bin/jshint
+NPM = npm
+
+CUSTOM = $(shell find custom -name '*.md' | sort)
+VENDOR = ramda sanctuary sanctuary-def
+VENDOR_CHECKS = $(patsubst %,check-%-version,$(VENDOR))
+FILES = index.html $(patsubst %,vendor/%.js,$(VENDOR))
+
+
+.PHONY: all
+all: $(FILES)
+
+index.html: scripts/generate node_modules/sanctuary/README.md $(CUSTOM)
+ '$<' node_modules/sanctuary
+
+vendor/ramda.js: node_modules/ramda/dist/ramda.js
+ cp '$<' '$@'
+
+vendor/%.js: node_modules/%/index.js
+ cp '$<' '$@'
+
+
+.PHONY: $(VENDOR_CHECKS)
+$(VENDOR_CHECKS): check-%-version:
+ node -e 'require("assert").strictEqual(require("$*/package.json").version, require("./package.json").dependencies["$*"])'
+
+
+.PHONY: clean
+clean: $(FILES)
+ rm -f -- $^
+
+
+.PHONY: lint
+lint: scripts/generate behaviour.js
+ $(JSHINT) -- $^
+ make clean
+ make
+ git diff --exit-code
+
+
+.PHONY: setup
+setup:
+ $(NPM) update
+
+
+.PHONY: test
+test: $(VENDOR_CHECKS)
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..bbb255c
--- /dev/null
+++ b/README.md
@@ -0,0 +1,6 @@
+# sanctuary-site
+
+Build script and files for the [Sanctuary][1] website.
+
+
+[1]: https://github.com/plaid/sanctuary
diff --git a/behaviour.js b/behaviour.js
new file mode 100644
index 0000000..cd6f941
--- /dev/null
+++ b/behaviour.js
@@ -0,0 +1,94 @@
+/* jshint browser: true */
+
+(function() {
+
+ 'use strict';
+
+ var R = window.R;
+ var S = window.S = window.sanctuary;
+
+ // evaluate :: String -> Either String Any
+ var evaluate =
+ S.encaseEither(R.prop('message'),
+ S.pipe([R.replace(/^const ([^ ]*) = (.*)/,
+ '(window.$1 = $2), undefined'),
+ R.concat('return '),
+ R.construct(Function),
+ R.call]));
+
+ // hasClass :: String -> Element -> Boolean
+ var hasClass = function(className) {
+ return function(el) {
+ return el.nodeType === 1 &&
+ S.words(el.className).indexOf(className) >= 0;
+ };
+ };
+
+ // evaluateForm :: Element -> Undefined
+ var evaluateForm = function(el) {
+ var input = el.getElementsByTagName('input')[0];
+ var output = el.getElementsByClassName('output')[0];
+
+ S.either(function(s) {
+ output.setAttribute('data-error', 'true');
+ output.textContent = '! ' + s;
+ },
+ function(x) {
+ output.setAttribute('data-error', 'false');
+ output.textContent = R.toString(x);
+ },
+ evaluate(input.value));
+ };
+
+ // evaluateForms :: Element -> Undefined
+ var evaluateForms = function(el) {
+ R.forEach(evaluateForm, el.getElementsByTagName('form'));
+ };
+
+ evaluateForms(document.body);
+
+ // The first time the user moves her mouse over the first example, select
+ // the "words" to suggest that the text is editable. Note that "mouseover"
+ // is unsuitable as the cursor may already be over the first example.
+ var firstExample = document.body.getElementsByClassName('examples')[0];
+ document.body.addEventListener('mousemove', function selectWords(event) {
+ var el = event.target;
+ while (el !== document.body) {
+ if (el === firstExample) {
+ var input = firstExample.getElementsByTagName('input')[0];
+ input.focus();
+ input.setSelectionRange(input.value.indexOf('[') + 1,
+ input.value.indexOf(']'),
+ 'forward');
+ document.body.removeEventListener('mousemove', selectWords, false);
+ }
+ el = el.parentNode;
+ }
+ }, false);
+
+ document.body.addEventListener('click', function(event) {
+ // Dragging a selection triggers a "click" event. Selecting the
+ // output text (for copying) should not focus the input element.
+ if (window.getSelection().isCollapsed) {
+ var el = event.target;
+ while (el.tagName !== 'INPUT' && el !== document.body) {
+ if (hasClass('examples')(el)) {
+ var input = el.getElementsByTagName('input')[0];
+ input.focus();
+ // Move the caret to the end of the text.
+ input.value = input.value;
+ break;
+ }
+ el = el.parentNode;
+ }
+ }
+ }, false);
+
+ document.body.addEventListener('submit', function(event) {
+ if (event.target.tagName === 'FORM') {
+ event.preventDefault();
+ evaluateForms(event.target.parentNode);
+ }
+ }, false);
+
+}());
diff --git a/circle.yml b/circle.yml
new file mode 100644
index 0000000..31373ca
--- /dev/null
+++ b/circle.yml
@@ -0,0 +1,11 @@
+dependencies:
+ override:
+ - make setup
+
+machine:
+ node:
+ version: 4.2.2
+
+test:
+ override:
+ - make test lint
diff --git a/custom/introduction.md b/custom/introduction.md
new file mode 100644
index 0000000..14ba071
--- /dev/null
+++ b/custom/introduction.md
@@ -0,0 +1,31 @@
+In JavaScript it's trivial to introduce a possible run-time type error:
+
+ words[0].toUpperCase()
+
+If `words` is `[]` we'll get a familiar error at run-time:
+
+ TypeError: Cannot read property 'toUpperCase' of undefined
+
+Sanctuary gives us a fighting chance of avoiding such errors. We might
+write:
+
+ R.map(R.toUpper, S.head(words))
+
+===============================================================================
+
+In JavaScript it's trivial to introduce a possible run-time type error.
+
+Try changing `words` to `[]` in the REPL below. Hit _return_ to re-evaluate.
+
+```javascript
+> words = ['foo', 'bar', 'baz']
+undefined
+
+> words[0].toUpperCase()
+"FOO"
+
+> R.map(S.toUpper, S.head(words))
+Nothing("FOO")
+```
+
+`R` is Ramda; `S` is Sanctuary.
diff --git a/custom/type-checking-ramda.md b/custom/type-checking-ramda.md
new file mode 100644
index 0000000..4eedc15
--- /dev/null
+++ b/custom/type-checking-ramda.md
@@ -0,0 +1,11 @@
+```javascript
+R.inc('XXX');
+// => '1XXX'
+```
+
+===============================================================================
+
+```javascript
+> R.inc('XXX')
+'1XXX'
+```
diff --git a/custom/type-checking-sanctuary.md b/custom/type-checking-sanctuary.md
new file mode 100644
index 0000000..089c93e
--- /dev/null
+++ b/custom/type-checking-sanctuary.md
@@ -0,0 +1,11 @@
+```javascript
+S.inc('XXX');
+// ! TypeError: ‘inc’ expected a value of type FiniteNumber as its first argument; received "XXX"
+```
+
+===============================================================================
+
+```javascript
+> S.inc('XXX')
+! ‘inc’ expected a value of type FiniteNumber as its first argument; received "XXX"
+```
diff --git a/index.html b/index.html
new file mode 100644
index 0000000..6058fa8
--- /dev/null
+++ b/index.html
@@ -0,0 +1,2222 @@
+
+
+
+ Sanctuary
+
+
+
Sanctuary v0.9.1
+
Sanctuary is a functional programming library inspired by Haskell and
+PureScript. It depends on and works nicely with Ramda . Sanctuary
+makes it possible to write safe code without null checks.
+
In JavaScript it's trivial to introduce a possible run-time type error.
+
Try changing words to [] in the REPL below. Hit return to re-evaluate.
+
+
+
R is Ramda; S is Sanctuary.
+
¶
+
Types
+
Sanctuary uses Haskell-like type signatures to describe the types of
+values, including functions. 'foo', for example, has type String;
+[1, 2, 3] has type [Number]. The arrow (- >Math.abs, for example, has type Number - >.
+That is, it takes an argument of type Number and returns a value of
+type Number.
+
R.map(a - >- >- >. That is, it takes
+an argument of type a - > and returns a value of type [a] - >.
+a and b are type variables: applying R.map to a value of type
+String - > will give a value of type [String] - >.
+
Sanctuary embraces types. JavaScript doesn't support algebraic data types,
+but these can be simulated by providing a group of constructor functions
+whose prototypes provide the same set of methods. A value of the Maybe
+type, for example, is created via the Nothing constructor or the Just
+constructor.
+
It's necessary to extend Haskell's notation to describe implicit arguments
+to the methods provided by Sanctuary's types. In x.map(y), for example,
+the map method takes an implicit argument x in addition to the explicit
+argument y. The type of the value upon which a method is invoked appears
+at the beginning of the signature, separated from the arguments and return
+value by a squiggly arrow (~> map method of the Maybe
+type is written Maybe a ~> (a - >- >. One could read this as:
+
When the map method is invoked on a value of type Maybe a
+(for any type a) with an argument of type a - > (for any type b),
+it returns a value of type Maybe b.
+
Sanctuary supports type classes: constraints on type variables. Whereas
+a - > implicitly supports every type, Functor f => (a - >- >- > requires that f be a type which satisfies the requirements of the
+Functor type class. Type-class constraints appear at the beginning of a
+type signature, separated from the rest of the signature by a fat arrow
+(=>
+
¶
+
Accessible pseudotype
+
What is the type of values which support property access? In other words,
+what is the type of which every value except null and undefined is a
+member? Object is close, but Object.create(null) produces a value which
+supports property access but which is not a member of the Object type.
+
Sanctuary uses the Accessible pseudotype to represent the set of values
+which support property access.
+
¶
+
Integer pseudotype
+
The Integer pseudotype represents integers in the range (-2^53 .. 2^53).
+It is a pseudotype because each Integer is represented by a Number value.
+Sanctuary's run-time type checking asserts that a valid Number value is
+provided wherever an Integer value is required.
+
¶
+
List pseudotype
+
The List pseudotype represents non-Function values with numeric length
+properties greater than or equal to zero, such as [1, 2, 3] and 'foo'.
+
¶
+
Type representatives
+
What is the type of Number? One answer is a - >, since it's a
+function which takes an argument of any type and returns a Number value.
+When provided as the first argument to isNumber is
+really the value-level representative of the Number type.
+
Sanctuary uses the TypeRep pseudotype to describe type representatives.
+For example:
+
Number :: TypeRep Number
+Number is the sole inhabitant of the TypeRep Number type.
+
¶
+
Type checking
+
Sanctuary functions are defined via sanctuary-def to provide run-time
+type checking. This is tremendously useful during development: type errors
+are reported immediately, avoiding circuitous stack traces (at best) and
+silent failures due to type coercion (at worst). For example:
+
+
+
Compare this to the behaviour of Ramda's unchecked equivalent:
+
+
+
There is a performance cost to run-time type checking. One may wish to
+disable type checking in certain contexts to avoid paying this cost.
+There are actually two versions of the Sanctuary module: one with type
+checking; one without. The latter is accessible via the unchecked
+property of the former.
+
When application of S.unchecked.<name> honours the function's type
+signature the result will be the same as if S.<name> had been used
+instead. Otherwise, the behaviour is unspecified.
+
In Node, one could use an environment variable to determine which version
+of the Sanctuary module to use:
+
const S = process.env.NODE_ENV === 'production' ?
+ require('sanctuary').unchecked :
+ require('sanctuary');
+
+
¶
+
API
+
¶
+
Classify
+
¶
+
+
+
Takes a value, x, of any type and returns its type identifier. If
+x has a '@@type' property whose value is a string, x['@@type']
+is the type identifier. Otherwise, the type identifier is the result
+of applying R.typex.
+
'@@type' properties should use the form '<package-name>/<type-name>',
+where <package-name> is the name of the npm package in which the type
+is defined.
+
+
+
¶
+
+
+
Takes a type representative and a value of
+any type and returns true if the given value is of the specified
+type; false otherwise. Subtyping is not respected.
+
+
+
¶
+
Combinator
+
¶
+
+
+
The I combinator. Returns its argument. Equivalent to Haskell's id
+function.
+
+
+
¶
+
+
+
The K combinator. Takes two values and returns the first. Equivalent to
+Haskell's const function.
+
+
+
¶
+
+
+
The A combinator. Takes a function and a value, and returns the result of
+applying the function to the value. Equivalent to Haskell's ($) function.
+
+
+
¶
+
+
+
The C combinator. Takes a curried binary function and two values, and
+returns the result of applying the function to the values in reverse.
+Equivalent to Haskell's flip function.
+
This function is very similar to flip
+
+
+
¶
+
+
+
The B combinator. Takes two functions and a value, and returns the result
+of applying the first function to the result of applying the second to the
+value. Equivalent to compose(.) function.
+
+
+
¶
+
+
+
The S combinator. Takes a curried binary function, a unary function,
+and a value, and returns the result of applying the binary function to:
+
+the value; and
+the result of applying the unary function to the value.
+
+
+
+
¶
+
Function
+
¶
+
+
+
Takes a binary function and two values and returns the result of
+applying the function - with its argument order reversed - to the
+values. flip may also be applied to a Ramda-style curried
+function with arity greater than two.
+
See also C
+
+
+
¶
+
+
+
Promotes a unary function to a function which operates on a Functor .
+
+
+
¶
+
+
+
Promotes a binary function to a function which operates on two
+Apply s.
+
+
+
¶
+
+
+
Promotes a ternary function to a function which operates on three
+Apply s.
+
+
+
¶
+
Composition
+
¶
+
+
+
Takes two functions assumed to be unary and a value of any type,
+and returns the result of applying the first function to the result
+of applying the second function to the given value.
+
In general terms, compose performs right-to-left composition of two
+unary functions.
+
See also Bpipe
+
+
+
¶
+
+
+
Takes a list of functions assumed to be unary and a value of any type,
+and returns the result of applying the sequence of transformations to
+the initial value.
+
In general terms, pipe performs left-to-right composition of a list
+of functions. pipe([f, g, h], x) is equivalent to h(g(f(x))).
+
See also meld
+
+
+
¶
+
+
+
Takes a list of non-nullary functions and returns a curried function
+whose arity is one greater than the sum of the arities of the given
+functions less the number of functions.
+
The behaviour of meld is best conveyed diagrammatically. The following
+diagram depicts the "melding" of binary functions f and g:
+
+-------+
+--- a --->| |
+ | f | +-------+
+--- b --->| |--- f(a, b) --->| |
+ +-------+ | g |
+--- c ---------------------------->| |--- g(f(a, b), c) --->
+ +-------+
+See also pipe
+
+
+
¶
+
Maybe type
+
The Maybe type represents optional values: a value of type Maybe a is
+either a Just whose value is of type a or a Nothing (with no value).
+
The Maybe type satisfies the Monoid , Monad , Traversable ,
+and Extend specifications.
+
¶
+
+
+
A UnaryTypesanctuary-def .
+
¶
+
+
+
The type representative for the Maybe type.
+
¶
+
+
+
Returns a Nothing.
+
+
+
¶
+
+
+
Takes a value of any type and returns a Just with the given value.
+
+
+
¶
+
+
+
Maybe type identifier, 'sanctuary/Maybe'.
+
¶
+
+
+
true if this is a Nothing; false if this is a Just.
+
+
+
¶
+
+
+
true if this is a Just; false if this is a Nothing.
+
+
+
¶
+
+
+
Takes a value of type Maybe a and returns a Nothing unless this
+is a Just and the argument is a Just, in which case it returns a
+Just whose value is the result of of applying this Just's value to
+the given Just's value.
+
+
+
¶
+
+
+
Takes a function and returns this if this is a Nothing; otherwise
+it returns the result of applying the function to this Just's value.
+
+
+
¶
+
+
+
Returns the result of concatenating two Maybe values of the same type.
+a must have a Semigroup (indicated by the presence of a concat
+method).
+
If this is a Nothing and the argument is a Nothing, this method returns
+a Nothing.
+
If this is a Just and the argument is a Just, this method returns a
+Just whose value is the result of concatenating this Just's value and
+the given Just's value.
+
Otherwise, this method returns the Just.
+
+
+
¶
+
+
+
Returns a Nothing.
+
+
+
¶
+
+
+
Takes a value of any type and returns true if:
+
+it is a Nothing and this is a Nothing; or
+it is a Just and this is a Just, and their values are equal
+according to R.equals
+
+
+
+
¶
+
+
+
Takes a function and returns this if this is a Nothing; otherwise
+it returns a Just whose value is the result of applying the function to
+this.
+
+
+
¶
+
+
+
Takes a predicate and returns this if this is a Just whose value
+satisfies the predicate; Nothing otherwise.
+
+
+
¶
+
+
+
Takes a function and returns this if this is a Nothing; otherwise
+it returns a Just whose value is the result of applying the function to
+this Just's value.
+
+
+
¶
+
+
+
Takes a value of any type and returns a Just with the given value.
+
+
+
¶
+
+
+
Takes a function and an initial value of any type, and returns:
+
+
+
+
¶
+
+
+
Evaluates an applicative action contained within the Maybe, resulting in:
+
+
+
+
¶
+
+
+
Returns false if this is a Nothing; true if this is a Just.
+
+
+
¶
+
+
+
Returns the string representation of the Maybe.
+
+
+
¶
+
+
+
Returns the string representation of the Maybe. This method is used by
+util.inspect and the REPL to format a Maybe for display.
+
See also Maybe#toString
+
+
+
¶
+
+
+
Returns a Nothing. Though this is a constructor function the new
+keyword needn't be used.
+
+
+
¶
+
+
+
Takes a value of any type and returns a Just with the given value.
+Though this is a constructor function the new keyword needn't be
+used.
+
+
+
¶
+
+
+
Returns true if the given Maybe is a Nothing; false if it is a Just.
+
+
+
¶
+
+
+
Returns true if the given Maybe is a Just; false if it is a Nothing.
+
+
+
¶
+
+
+
Takes a default value and a Maybe, and returns the Maybe's value
+if the Maybe is a Just; the default value otherwise.
+
+
+
¶
+
+
+
Takes a value and returns Nothing if the value is null or undefined;
+Just the value otherwise.
+
+
+
¶
+
+
+
Takes a value of any type, a function, and a Maybe. If the Maybe is
+a Just, the return value is the result of applying the function to
+the Just's value. Otherwise, the first argument is returned.
+
+
+
¶
+
+
+
Takes a list of Maybes and returns a list containing each Just's value.
+
+
+
¶
+
+
+
Takes a function and a list, applies the function to each element of
+the list, and returns a list of "successful" results. If the result of
+applying the function to an element of the list is a Nothing, the result
+is discarded; if the result is a Just, the Just's value is included in
+the output list.
+
In general terms, mapMaybe filters a list while mapping over it.
+
+
+
¶
+
+
+
Takes a unary function f which may throw and a value x of any type,
+and applies f to x inside a try block. If an exception is caught,
+the return value is a Nothing; otherwise the return value is Just the
+result of applying f to x.
+
See also encaseEither
+
+
+
¶
+
+
+
Binary version of encase
+
¶
+
+
+
Ternary version of encase
+
¶
+
Either type
+
The Either type represents values with two possibilities: a value of type
+Either a b is either a Left whose value is of type a or a Right whose
+value is of type b.
+
The Either type satisfies the Semigroup , Monad , and Extend
+specifications.
+
¶
+
+
+
A BinaryTypesanctuary-def .
+
¶
+
+
+
The type representative for the Either type.
+
¶
+
+
+
Takes a value of any type and returns a Right with the given value.
+
+
+
¶
+
+
+
Either type identifier, 'sanctuary/Either'.
+
¶
+
+
+
true if this is a Left; false if this is a Right.
+
+
+
¶
+
+
+
true if this is a Right; false if this is a Left.
+
+
+
¶
+
+
+
Takes a value of type Either a b and returns a Left unless this
+is a Right and the argument is a Right, in which case it returns
+a Right whose value is the result of applying this Right's value to
+the given Right's value.
+
+
+
¶
+
+
+
Takes a function and returns this if this is a Left; otherwise
+it returns the result of applying the function to this Right's value.
+
+
+
¶
+
+
+
Returns the result of concatenating two Either values of the same type.
+a must have a Semigroup (indicated by the presence of a concat
+method), as must b.
+
If this is a Left and the argument is a Left, this method returns a
+Left whose value is the result of concatenating this Left's value and
+the given Left's value.
+
If this is a Right and the argument is a Right, this method returns a
+Right whose value is the result of concatenating this Right's value and
+the given Right's value.
+
Otherwise, this method returns the Right.
+
+
+
¶
+
+
+
Takes a value of any type and returns true if:
+
+it is a Left and this is a Left, and their values are equal
+according to R.equals
+it is a Right and this is a Right, and their values are equal
+according to R.equals
+
+
+
+
¶
+
+
+
Takes a function and returns this if this is a Left; otherwise it
+returns a Right whose value is the result of applying the function to
+this.
+
+
+
¶
+
+
+
Takes a function and returns this if this is a Left; otherwise it
+returns a Right whose value is the result of applying the function to
+this Right's value.
+
+
+
¶
+
+
+
Takes a value of any type and returns a Right with the given value.
+
+
+
¶
+
+
+
Returns false if this is a Left; true if this is a Right.
+
+
+
¶
+
+
+
Returns the string representation of the Either.
+
+
+
¶
+
+
+
Returns the string representation of the Either. This method is used by
+util.inspect and the REPL to format a Either for display.
+
See also Either#toString
+
+
+
¶
+
+
+
Takes a value of any type and returns a Left with the given value.
+Though this is a constructor function the new keyword needn't be
+used.
+
+
+
¶
+
+
+
Takes a value of any type and returns a Right with the given value.
+Though this is a constructor function the new keyword needn't be
+used.
+
+
+
¶
+
+
+
Returns true if the given Either is a Left; false if it is a Right.
+
+
+
¶
+
+
+
Returns true if the given Either is a Right; false if it is a Left.
+
+
+
¶
+
+
+
Takes two functions and an Either, and returns the result of
+applying the first function to the Left's value, if the Either
+is a Left, or the result of applying the second function to the
+Right's value, if the Either is a Right.
+
+
+
¶
+
+
+
Takes a list of Eithers and returns a list containing each Left's value.
+
See also rights
+
+
+
¶
+
+
+
Takes a list of Eithers and returns a list containing each Right's value.
+
See also lefts
+
+
+
¶
+
+
+
Takes two unary functions, f and g, the second of which may throw,
+and a value x of any type. Applies g to x inside a try block.
+If an exception is caught, the return value is a Left containing the
+result of applying f to the caught Error object; otherwise the return
+value is a Right containing the result of applying g to x.
+
See also encase
+
+
+
¶
+
+
+
Binary version of encaseEither
+
¶
+
+
+
Ternary version of encaseEither
+
¶
+
+
+
Takes a value of any type and a Maybe, and returns an Either.
+If the second argument is a Nothing, a Left containing the first
+argument is returned. If the second argument is a Just, a Right
+containing the Just's value is returned.
+
+
+
¶
+
Alternative
+
¶
+
+
+
Takes two values of the same type and returns the second value
+if the first is "true"; the first value otherwise. An array is
+considered "true" if its length is greater than zero. The Boolean
+value true is also considered "true". Other types must provide
+a toBoolean method.
+
+
+
¶
+
+
+
Takes two values of the same type and returns the first value if it
+is "true"; the second value otherwise. An array is considered "true"
+if its length is greater than zero. The Boolean value true is also
+considered "true". Other types must provide a toBoolean method.
+
+
+
¶
+
+
+
Takes two values of the same type and returns the "true" value
+if one value is "true" and the other is "false"; otherwise it
+returns the type's "false" value. An array is considered "true"
+if its length is greater than zero. The Boolean value true is
+also considered "true". Other types must provide toBoolean and
+empty methods.
+
+
+
¶
+
Logic
+
¶
+
+
+
Takes a Boolean and returns the negation of that value
+(false for true; true for false).
+
+
+
¶
+
+
+
Takes a unary predicate, a unary "if" function, a unary "else"
+function, and a value of any type, and returns the result of
+applying the "if" function to the value if the value satisfies
+the predicate; the result of applying the "else" function to the
+value otherwise.
+
+
+
¶
+
+
+
Takes an array of unary predicates and a value of any type
+and returns true if all the predicates pass; false otherwise.
+None of the subsequent predicates will be evaluated after the
+first failed predicate.
+
+
+
¶
+
+
+
Takes an array of unary predicates and a value of any type
+and returns true if any of the predicates pass; false otherwise.
+None of the subsequent predicates will be evaluated after the
+first passed predicate.
+
+
+
¶
+
List
+
¶
+
+
+
Returns Just a list containing the elements from the supplied list
+from a beginning index (inclusive) to an end index (exclusive).
+Returns Nothing unless the start interval is less than or equal to
+the end interval, and the list contains both (half-open) intervals.
+Accepts negative indices, which indicate an offset from the end of
+the list.
+
Dispatches to its third argument's slice method if present. As a
+result, one may replace [a] with String in the type signature.
+
+
+
¶
+
+
+
Takes an index and a list and returns Just the element of the list at
+the index if the index is within the list's bounds; Nothing otherwise.
+A negative index represents an offset from the length of the list.
+
+
+
¶
+
+
+
Takes a list and returns Just the first element of the list if the
+list contains at least one element; Nothing if the list is empty.
+
+
+
¶
+
+
+
Takes a list and returns Just the last element of the list if the
+list contains at least one element; Nothing if the list is empty.
+
+
+
¶
+
+
+
Takes a list and returns Just a list containing all but the first
+of the list's elements if the list contains at least one element;
+Nothing if the list is empty.
+
+
+
¶
+
+
+
Takes a list and returns Just a list containing all but the last
+of the list's elements if the list contains at least one element;
+Nothing if the list is empty.
+
+
+
¶
+
+
+
Returns Just the first N elements of the given collection if N is
+greater than or equal to zero and less than or equal to the length
+of the collection; Nothing otherwise. Supports Array, String, and
+any other collection type which provides a slice method.
+
+
+
¶
+
+
+
Returns Just the last N elements of the given collection if N is
+greater than or equal to zero and less than or equal to the length
+of the collection; Nothing otherwise. Supports Array, String, and
+any other collection type which provides a slice method.
+
+
+
¶
+
+
+
Returns Just all but the first N elements of the given collection
+if N is greater than or equal to zero and less than or equal to the
+length of the collection; Nothing otherwise. Supports Array, String,
+and any other collection type which provides a slice method.
+
+
+
¶
+
+
+
Returns Just all but the last N elements of the given collection
+if N is greater than or equal to zero and less than or equal to the
+length of the collection; Nothing otherwise. Supports Array, String,
+and any other collection type which provides a slice method.
+
+
+
¶
+
+
+
Takes a predicate and a list and returns Just the leftmost element of
+the list which satisfies the predicate; Nothing if none of the list's
+elements satisfies the predicate.
+
+
+
¶
+
+
+
Takes a value of any type and a list, and returns Just the index
+of the first occurrence of the value in the list, if applicable;
+Nothing otherwise.
+
Dispatches to its second argument's indexOf method if present.
+As a result, String - >- > is an alternative
+type signature.
+
+
+
¶
+
+
+
Takes a value of any type and a list, and returns Just the index
+of the last occurrence of the value in the list, if applicable;
+Nothing otherwise.
+
Dispatches to its second argument's lastIndexOf method if present.
+As a result, String - >- > is an alternative
+type signature.
+
+
+
¶
+
+
+
Takes a type representative , a property name,
+and a list of objects and returns a list of equal length. Each element
+of the output list is Just the value of the specified property of the
+corresponding object if the value is of the specified type (according
+to is
+
See also get
+
+
+
¶
+
+
+
Takes a binary function, an initial value, and a Foldable , and
+applies the function to the initial value and the Foldable's first
+value, then applies the function to the result of the previous
+application and the Foldable's second value. Repeats this process
+until each of the Foldable's values has been used. Returns the initial
+value if the Foldable is empty; the result of the final application
+otherwise.
+
+
+
¶
+
+
+
Takes a function and a seed value, and returns a list generated by
+applying the function repeatedly. The list is initially empty. The
+function is initially applied to the seed value. Each application
+of the function should result in either:
+
+a Nothing, in which case the list is returned; or
+Just a pair, in which case the first element is appended to
+the list and the function is applied to the second element.
+
+
+
+
¶
+
Object
+
¶
+
+
+
Takes a type representative , a property
+name, and an object and returns Just the value of the specified object
+property if it is of the specified type (according to is
+
The Object type representative may be used as a catch-all since most
+values have Object.prototype in their prototype chains.
+
See also gets
+
+
+
¶
+
+
+
Takes a type representative , a list of property
+names, and an object and returns Just the value at the path specified by
+the list of property names if such a path exists and the value is of the
+specified type; Nothing otherwise.
+
See also get
+
+
+
¶
+
Number
+
¶
+
+
+
Negates its argument.
+
+
+
¶
+
+
+
Returns the sum of two (finite) numbers.
+
+
+
¶
+
+
+
Returns the difference between two (finite) numbers.
+
+
+
¶
+
+
+
Increments a (finite) number by one.
+
+
+
¶
+
+
+
Decrements a (finite) number by one.
+
+
+
¶
+
+
+
Returns the product of two (finite) numbers.
+
+
+
¶
+
+
+
Returns the result of dividing its first argument (a finite number) by
+its second argument (a non-zero finite number).
+
+
+
¶
+
+
+
Returns the smaller of its two arguments.
+
Strings are compared lexicographically. Specifically, the Unicode
+code point value of each character in the first string is compared
+to the value of the corresponding character in the second string.
+
See also max
+
+
+
¶
+
+
+
Returns the larger of its two arguments.
+
Strings are compared lexicographically. Specifically, the Unicode
+code point value of each character in the first string is compared
+to the value of the corresponding character in the second string.
+
See also min
+
+
+
¶
+
Integer
+
¶
+
+
+
Returns true if the given integer is even; false if it is odd.
+
+
+
¶
+
+
+
Returns true if the given integer is odd; false if it is even.
+
+
+
¶
+
Parse
+
¶
+
+
+
Takes a string and returns Just the date represented by the string
+if it does in fact represent a date; Nothing otherwise.
+
+
+
¶
+
+
+
Takes a string and returns Just the number represented by the string
+if it does in fact represent a number; Nothing otherwise.
+
+
+
¶
+
+
+
Takes a radix (an integer between 2 and 36 inclusive) and a string,
+and returns Just the number represented by the string if it does in
+fact represent a number in the base specified by the radix; Nothing
+otherwise.
+
This function is stricter than parseInt
+
+
+
¶
+
+
+
Takes a string which may or may not be valid JSON, and returns Just
+the result of applying JSON.parse to the string if valid; Nothing
+otherwise.
+
+
+
¶
+
RegExp
+
¶
+
+
+
Takes a RegexFlags and a pattern, and returns a RegExp.
+
+
+
¶
+
+
+
Takes a string which may contain regular expression metacharacters,
+and returns a string with those metacharacters escaped.
+
Properties:
+
+forall s : : String. S.test(S.regex('', S.regexEscape(s)), s) = true
+
+
+
¶
+
+
+
Takes a pattern and a string, and returns true if the pattern
+matches the string; false otherwise.
+
+
+
¶
+
+
+
Takes a pattern and a string, and returns Just a list of matches
+if the pattern matches the string; Nothing otherwise. Each match
+has type Maybe String, where a Nothing represents an unmatched
+optional capturing group.
+
+
+
¶
+
String
+
¶
+
+
+
Returns the upper-case equivalent of its argument.
+
See also toLower
+
+
+
¶
+
+
+
Returns the lower-case equivalent of its argument.
+
See also toUpper
+
+
+
¶
+
+
+
Takes a string and returns the list of words the string contains
+(words are delimited by whitespace characters).
+
See also unwords
+
+
+
¶
+
+
+
Takes a list of words and returns the result of joining the words
+with separating spaces.
+
See also words
+
+
+
¶
+
+
+
Takes a string and returns the list of lines the string contains
+(lines are delimited by newlines: '\n' or '\r\n' or '\r').
+The resulting strings do not contain newlines.
+
See also unlines
+
+
+
¶
+
+
+
Takes a list of lines and returns the result of joining the lines
+after appending a terminating line feed ('\n') to each.
+
See also lines
+
+
+
',
+ '
')]),
+ pipe([toString,
+ htmlEncode,
+ wrap('',
+ '
')]))]));
+
+// doctestsToMarkup :: String -> String
+const doctestsToMarkup =
+def('doctestsToMarkup',
+ {},
+ [$.String, $.String],
+ pipe([match_(/^(> .*(?:\n[.] .*)*)/gm),
+ map(lines),
+ map(map(drop_(2))),
+ map(map(trim)),
+ map(lift2(prepend, head_, compose(map(concat(' ')), tail_))),
+ map(join('')),
+ map(replace(/^global[.]/, 'const ')),
+ map(lift2(pair, toInputMarkup, toOutputMarkup)),
+ map(map(concat(' '))),
+ map(unlines),
+ map(wrap(' \n')),
+ join(''),
+ wrap('\n', '
\n')]));
+
+// substitutionPattern :: RegExp
+const substitutionPattern =
+/([\s\S]*?<[/]pre>|[\s\S]*?^<[/]div>| :: |[=~-](?:>|>)|[.][.][.])/gm;
+
+// substitutions :: String -> String
+const substitutions =
+def('substitutions',
+ {},
+ [$.String, $.String],
+ replace_(substitutionPattern,
+ apply(cond([[equals(' :: '),
+ K(' ' +
+ el('span', 'tight', ':') +
+ el('span', 'tight', ':') +
+ ' ')],
+ [contains(_, ap([I, htmlEncode], ['=>'])),
+ K(el('span', 'arrow', htmlEncode('=>')))],
+ [contains(_, ap([I, htmlEncode], ['~>'])),
+ K(el('span', 'arrow', htmlEncode('~>')))],
+ [contains(_, ap([I, htmlEncode], ['->'])),
+ K(el('span', 'arrow',
+ el('span', 'arrow-hyphen', htmlEncode('-')) +
+ htmlEncode('>')))],
+ [equals('...'),
+ K(el('span', 'tight', '.') +
+ el('span', 'tight', '.') +
+ el('span', 'tight', '.'))],
+ [K(true),
+ I]]))));
+
+// generate :: String -> String
+const generate =
+def('generate',
+ {},
+ [$.String, $.String],
+ pipe([replace(/
<[/]pre>)/g, ''),
+ replace(/(?=<(h[2-6]) id="([^"]*)")/g,
+ '\u00B6 \n'),
+ substitutions]));
+
+// readFile :: String -> Either String String
+const readFile =
+def('readFile',
+ {},
+ [$.String, Either($.String, $.String)],
+ encaseEither(prop('message'), compose(String, fs.readFileSync)));
+
+// writeFile :: String -> String -> Either String String
+const writeFile =
+def('writeFile',
+ {},
+ [$.String, $.String, Either($.String, $.String)],
+ encaseEither2(prop('message'), lift2(K, K, binary(fs.writeFileSync))));
+
+// version :: String -> Either String String
+const version =
+def('version',
+ {},
+ [$.String, Either($.String, $.String)],
+ pipe([flip(path.join)('package.json'),
+ readFile,
+ chain(encaseEither(prop('message'), JSON.parse)),
+ map(get(String, 'version')),
+ chain(maybeToEither('Invalid "version"'))]));
+
+// customize :: String -> Either String (String -> Either String String)
+const customize =
+def('customize',
+ {},
+ [$.String, Either($.String, $.Function)],
+ pipe([readFile,
+ map(split(/\n={79}\n\n/)),
+ chain(ifElse(propEq('length', 2),
+ Right,
+ K(Left('Expected exactly one separator')))),
+ map(apply((existing, replacement) =>
+ ifElse(contains(existing),
+ compose(Right, replace(existing, replacement)),
+ K(Left('Substring not found')))))]));
+
+// readme :: String -> Either String String
+const readme =
+def('readme',
+ {},
+ [$.String, Either($.String, $.String)],
+ pipe([flip(path.join)('README.md'),
+ readFile,
+ ap(customize('custom/introduction.md')),
+ unnest,
+ ap(customize('custom/type-checking-sanctuary.md')),
+ unnest,
+ ap(customize('custom/type-checking-ramda.md')),
+ unnest,
+ map(generate),
+ map(concat('\n')),
+ map(replace(/\n$/, ''))]));
+
+const toDocument =
+def('toDocument',
+ {},
+ [$.String, $.String],
+ content => `
+
+
+ Sanctuary
+
+${content}
+
+
+
+
+
+
+
+`);
+
+// failure :: String -> Undefined
+const failure = s => {
+ process.stderr.write(`${red}${s}${reset}\n`);
+ process.exit(1);
+};
+
+// success :: String -> Undefined
+const success = s => {
+ process.stdout.write(`${green}Successfully created ${s}${reset}\n`);
+ process.exit(0);
+};
+
+pipe([at(2),
+ maybeToEither('Missing command-line argument'),
+ map(lift2(pair, I, I)),
+ map(over(lensIndex(0), version)),
+ map(over(lensIndex(1), readme)),
+ chain(ifElse(all(isRight),
+ pipe([rights, Right]),
+ pipe([lefts, join('\n'), Left]))),
+ map(over(lensIndex(0), wrap(' v', ' '))),
+ map(apply(replace(/(?=<[/]h1>)/))),
+ map(toDocument),
+ chain(writeFile('index.html')),
+ either(failure, success)],
+ process.argv);
diff --git a/style.css b/style.css
new file mode 100644
index 0000000..37b7c17
--- /dev/null
+++ b/style.css
@@ -0,0 +1,195 @@
+body {
+ margin: 0;
+ padding: 0 40px;
+ font: 24px/1.4 "Avenir Next", "Avenir", sans-serif;
+ overflow-x: hidden;
+}
+
+code {
+ font-family: "Courier", monospace;
+ color: #369;
+}
+
+a {
+ text-decoration: none;
+ color: #080;
+}
+
+a:focus {
+ background: #080;
+ color: #fff;
+ outline: none;
+}
+
+a:hover {
+ background: #080;
+ color: #fff;
+}
+
+a code {
+ color: inherit;
+}
+
+#css-header {
+ margin: 0 -9999px 0 -40px;
+ border-width: 1px 0;
+ border-style: solid;
+ border-color: #c36;
+ background: rgb(250, 230, 245);
+ padding: 0 40px;
+ font-size: 75%;
+ color: #c36;
+}
+
+#css-header ::-moz-selection {
+ background: #c36;
+ color: #fff;
+}
+
+#css-header ::selection {
+ background: #c36;
+ color: #fff;
+}
+
+#css-header a {
+ border-bottom: 1px dotted #c36;
+ color: #c36;
+}
+
+#css-header a:visited {
+ border-bottom-color: #a25;
+ color: #a25;
+}
+
+#css-header a:focus {
+ background: #c36;
+ color: #fff;
+}
+
+#css-header a:hover {
+ border-bottom-style: solid;
+ background: #c36;
+ color: #fff;
+}
+
+#css-main {
+ max-width: 36em;
+ padding: 0 0 4em;
+}
+
+pre {
+ margin: 1.334em 0;
+ padding: 0;
+ font-size: 75%;
+ line-height: 1.334;
+}
+
+.examples {
+ margin: 0 -9999px 0 -40px;
+ border-width: 1px 0;
+ border-style: solid;
+ border-color: #ada;
+ background: #efe;
+ padding: 0 40px;
+ font-size: 75%;
+ line-height: 1.334;
+ font-family: "Courier", monospace;
+ color: #666;
+}
+
+.examples:hover {
+ border-color: #080;
+ cursor: text;
+}
+
+.examples ::-moz-selection {
+ background: #080;
+ color: #fff;
+}
+
+.examples ::selection {
+ background: #080;
+ color: #fff;
+}
+
+.examples form {
+ margin: 1.334em 0;
+}
+
+.examples input {
+ display: inline;
+ width: 8888px;
+ border: none;
+ background: none;
+ padding: 0;
+ font: inherit;
+ color: #080;
+ outline: none;
+}
+
+.examples .output {
+ white-space: pre;
+ color: #666;
+}
+
+.examples .output[data-error="true"] {
+ color: #c20;
+}
+
+.tight + .tight {
+ margin-left: -0.2em;
+}
+
+.arrow {
+ position: relative;
+ top: 0.1em;
+}
+
+.arrow-hyphen {
+ position: relative;
+ top: -0.1em;
+}
+
+h1,
+h2, .h2,
+h3, .h3,
+h4, .h4 {
+ margin: 0;
+ padding: 1em 0 0;
+ line-height: 1.5;
+}
+
+h1 {
+ font-size: 2em;
+ font-weight: normal;
+}
+
+h2, .h2 {
+ font-size: 1.5em;
+}
+
+h3, .h3 {
+ font-size: 1.167em;
+}
+
+h4, .h4 {
+ font-size: 1em;
+}
+
+h1 small {
+ font-size: 66.667%;
+ font-weight: normal;
+}
+
+p {
+ margin: 1em 0;
+}
+
+.pilcrow {
+ position: absolute;
+ display: block;
+ margin: 0 0 0 -40px;
+ width: 40px;
+ text-align: center;
+ color: #eee;
+}
diff --git a/vendor/ramda.js b/vendor/ramda.js
new file mode 100644
index 0000000..227fd16
--- /dev/null
+++ b/vendor/ramda.js
@@ -0,0 +1,8446 @@
+// Ramda v0.19.1
+// https://github.com/ramda/ramda
+// (c) 2013-2016 Scott Sauyet, Michael Hurley, and David Chambers
+// Ramda may be freely distributed under the MIT license.
+
+;(function() {
+
+ 'use strict';
+
+ /**
+ * A special placeholder value used to specify "gaps" within curried functions,
+ * allowing partial application of any combination of arguments, regardless of
+ * their positions.
+ *
+ * If `g` is a curried ternary function and `_` is `R.__`, the following are
+ * equivalent:
+ *
+ * - `g(1, 2, 3)`
+ * - `g(_, 2, 3)(1)`
+ * - `g(_, _, 3)(1)(2)`
+ * - `g(_, _, 3)(1, 2)`
+ * - `g(_, 2, _)(1, 3)`
+ * - `g(_, 2)(1)(3)`
+ * - `g(_, 2)(1, 3)`
+ * - `g(_, 2)(_, 3)(1)`
+ *
+ * @constant
+ * @memberOf R
+ * @since v0.6.0
+ * @category Function
+ * @example
+ *
+ * var greet = R.replace('{name}', R.__, 'Hello, {name}!');
+ * greet('Alice'); //=> 'Hello, Alice!'
+ */
+ var __ = { '@@functional/placeholder': true };
+
+ /* eslint-disable no-unused-vars */
+ var _arity = function _arity(n, fn) {
+ /* eslint-disable no-unused-vars */
+ switch (n) {
+ case 0:
+ return function () {
+ return fn.apply(this, arguments);
+ };
+ case 1:
+ return function (a0) {
+ return fn.apply(this, arguments);
+ };
+ case 2:
+ return function (a0, a1) {
+ return fn.apply(this, arguments);
+ };
+ case 3:
+ return function (a0, a1, a2) {
+ return fn.apply(this, arguments);
+ };
+ case 4:
+ return function (a0, a1, a2, a3) {
+ return fn.apply(this, arguments);
+ };
+ case 5:
+ return function (a0, a1, a2, a3, a4) {
+ return fn.apply(this, arguments);
+ };
+ case 6:
+ return function (a0, a1, a2, a3, a4, a5) {
+ return fn.apply(this, arguments);
+ };
+ case 7:
+ return function (a0, a1, a2, a3, a4, a5, a6) {
+ return fn.apply(this, arguments);
+ };
+ case 8:
+ return function (a0, a1, a2, a3, a4, a5, a6, a7) {
+ return fn.apply(this, arguments);
+ };
+ case 9:
+ return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {
+ return fn.apply(this, arguments);
+ };
+ case 10:
+ return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
+ return fn.apply(this, arguments);
+ };
+ default:
+ throw new Error('First argument to _arity must be a non-negative integer no greater than ten');
+ }
+ };
+
+ var _arrayFromIterator = function _arrayFromIterator(iter) {
+ var list = [];
+ var next;
+ while (!(next = iter.next()).done) {
+ list.push(next.value);
+ }
+ return list;
+ };
+
+ var _cloneRegExp = function _cloneRegExp(pattern) {
+ return new RegExp(pattern.source, (pattern.global ? 'g' : '') + (pattern.ignoreCase ? 'i' : '') + (pattern.multiline ? 'm' : '') + (pattern.sticky ? 'y' : '') + (pattern.unicode ? 'u' : ''));
+ };
+
+ var _complement = function _complement(f) {
+ return function () {
+ return !f.apply(this, arguments);
+ };
+ };
+
+ /**
+ * Private `concat` function to merge two array-like objects.
+ *
+ * @private
+ * @param {Array|Arguments} [set1=[]] An array-like object.
+ * @param {Array|Arguments} [set2=[]] An array-like object.
+ * @return {Array} A new, merged array.
+ * @example
+ *
+ * _concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]
+ */
+ var _concat = function _concat(set1, set2) {
+ set1 = set1 || [];
+ set2 = set2 || [];
+ var idx;
+ var len1 = set1.length;
+ var len2 = set2.length;
+ var result = [];
+ idx = 0;
+ while (idx < len1) {
+ result[result.length] = set1[idx];
+ idx += 1;
+ }
+ idx = 0;
+ while (idx < len2) {
+ result[result.length] = set2[idx];
+ idx += 1;
+ }
+ return result;
+ };
+
+ var _containsWith = function _containsWith(pred, x, list) {
+ var idx = 0;
+ var len = list.length;
+ while (idx < len) {
+ if (pred(x, list[idx])) {
+ return true;
+ }
+ idx += 1;
+ }
+ return false;
+ };
+
+ var _filter = function _filter(fn, list) {
+ var idx = 0;
+ var len = list.length;
+ var result = [];
+ while (idx < len) {
+ if (fn(list[idx])) {
+ result[result.length] = list[idx];
+ }
+ idx += 1;
+ }
+ return result;
+ };
+
+ var _forceReduced = function _forceReduced(x) {
+ return {
+ '@@transducer/value': x,
+ '@@transducer/reduced': true
+ };
+ };
+
+ var _has = function _has(prop, obj) {
+ return Object.prototype.hasOwnProperty.call(obj, prop);
+ };
+
+ var _identity = function _identity(x) {
+ return x;
+ };
+
+ var _isArguments = function () {
+ var toString = Object.prototype.toString;
+ return toString.call(arguments) === '[object Arguments]' ? function _isArguments(x) {
+ return toString.call(x) === '[object Arguments]';
+ } : function _isArguments(x) {
+ return _has('callee', x);
+ };
+ }();
+
+ /**
+ * Tests whether or not an object is an array.
+ *
+ * @private
+ * @param {*} val The object to test.
+ * @return {Boolean} `true` if `val` is an array, `false` otherwise.
+ * @example
+ *
+ * _isArray([]); //=> true
+ * _isArray(null); //=> false
+ * _isArray({}); //=> false
+ */
+ var _isArray = Array.isArray || function _isArray(val) {
+ return val != null && val.length >= 0 && Object.prototype.toString.call(val) === '[object Array]';
+ };
+
+ /**
+ * Determine if the passed argument is an integer.
+ *
+ * @private
+ * @param {*} n
+ * @category Type
+ * @return {Boolean}
+ */
+ var _isInteger = Number.isInteger || function _isInteger(n) {
+ return n << 0 === n;
+ };
+
+ var _isNumber = function _isNumber(x) {
+ return Object.prototype.toString.call(x) === '[object Number]';
+ };
+
+ var _isObject = function _isObject(x) {
+ return Object.prototype.toString.call(x) === '[object Object]';
+ };
+
+ var _isPlaceholder = function _isPlaceholder(a) {
+ return a != null && typeof a === 'object' && a['@@functional/placeholder'] === true;
+ };
+
+ var _isRegExp = function _isRegExp(x) {
+ return Object.prototype.toString.call(x) === '[object RegExp]';
+ };
+
+ var _isString = function _isString(x) {
+ return Object.prototype.toString.call(x) === '[object String]';
+ };
+
+ var _isTransformer = function _isTransformer(obj) {
+ return typeof obj['@@transducer/step'] === 'function';
+ };
+
+ var _map = function _map(fn, functor) {
+ var idx = 0;
+ var len = functor.length;
+ var result = Array(len);
+ while (idx < len) {
+ result[idx] = fn(functor[idx]);
+ idx += 1;
+ }
+ return result;
+ };
+
+ var _of = function _of(x) {
+ return [x];
+ };
+
+ var _pipe = function _pipe(f, g) {
+ return function () {
+ return g.call(this, f.apply(this, arguments));
+ };
+ };
+
+ var _pipeP = function _pipeP(f, g) {
+ return function () {
+ var ctx = this;
+ return f.apply(ctx, arguments).then(function (x) {
+ return g.call(ctx, x);
+ });
+ };
+ };
+
+ // \b matches word boundary; [\b] matches backspace
+ var _quote = function _quote(s) {
+ var escaped = s.replace(/\\/g, '\\\\').replace(/[\b]/g, '\\b') // \b matches word boundary; [\b] matches backspace
+ .replace(/\f/g, '\\f').replace(/\n/g, '\\n').replace(/\r/g, '\\r').replace(/\t/g, '\\t').replace(/\v/g, '\\v').replace(/\0/g, '\\0');
+ return '"' + escaped.replace(/"/g, '\\"') + '"';
+ };
+
+ var _reduced = function _reduced(x) {
+ return x && x['@@transducer/reduced'] ? x : {
+ '@@transducer/value': x,
+ '@@transducer/reduced': true
+ };
+ };
+
+ /**
+ * An optimized, private array `slice` implementation.
+ *
+ * @private
+ * @param {Arguments|Array} args The array or arguments object to consider.
+ * @param {Number} [from=0] The array index to slice from, inclusive.
+ * @param {Number} [to=args.length] The array index to slice to, exclusive.
+ * @return {Array} A new, sliced array.
+ * @example
+ *
+ * _slice([1, 2, 3, 4, 5], 1, 3); //=> [2, 3]
+ *
+ * var firstThreeArgs = function(a, b, c, d) {
+ * return _slice(arguments, 0, 3);
+ * };
+ * firstThreeArgs(1, 2, 3, 4); //=> [1, 2, 3]
+ */
+ var _slice = function _slice(args, from, to) {
+ switch (arguments.length) {
+ case 1:
+ return _slice(args, 0, args.length);
+ case 2:
+ return _slice(args, from, args.length);
+ default:
+ var list = [];
+ var idx = 0;
+ var len = Math.max(0, Math.min(args.length, to) - from);
+ while (idx < len) {
+ list[idx] = args[from + idx];
+ idx += 1;
+ }
+ return list;
+ }
+ };
+
+ /**
+ * Polyfill from .
+ */
+ var _toISOString = function () {
+ var pad = function pad(n) {
+ return (n < 10 ? '0' : '') + n;
+ };
+ return typeof Date.prototype.toISOString === 'function' ? function _toISOString(d) {
+ return d.toISOString();
+ } : function _toISOString(d) {
+ return d.getUTCFullYear() + '-' + pad(d.getUTCMonth() + 1) + '-' + pad(d.getUTCDate()) + 'T' + pad(d.getUTCHours()) + ':' + pad(d.getUTCMinutes()) + ':' + pad(d.getUTCSeconds()) + '.' + (d.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z';
+ };
+ }();
+
+ var _xfBase = {
+ init: function () {
+ return this.xf['@@transducer/init']();
+ },
+ result: function (result) {
+ return this.xf['@@transducer/result'](result);
+ }
+ };
+
+ var _xwrap = function () {
+ function XWrap(fn) {
+ this.f = fn;
+ }
+ XWrap.prototype['@@transducer/init'] = function () {
+ throw new Error('init not implemented on XWrap');
+ };
+ XWrap.prototype['@@transducer/result'] = function (acc) {
+ return acc;
+ };
+ XWrap.prototype['@@transducer/step'] = function (acc, x) {
+ return this.f(acc, x);
+ };
+ return function _xwrap(fn) {
+ return new XWrap(fn);
+ };
+ }();
+
+ var _aperture = function _aperture(n, list) {
+ var idx = 0;
+ var limit = list.length - (n - 1);
+ var acc = new Array(limit >= 0 ? limit : 0);
+ while (idx < limit) {
+ acc[idx] = _slice(list, idx, idx + n);
+ idx += 1;
+ }
+ return acc;
+ };
+
+ /**
+ * Similar to hasMethod, this checks whether a function has a [methodname]
+ * function. If it isn't an array it will execute that function otherwise it
+ * will default to the ramda implementation.
+ *
+ * @private
+ * @param {Function} fn ramda implemtation
+ * @param {String} methodname property to check for a custom implementation
+ * @return {Object} Whatever the return value of the method is.
+ */
+ var _checkForMethod = function _checkForMethod(methodname, fn) {
+ return function () {
+ var length = arguments.length;
+ if (length === 0) {
+ return fn();
+ }
+ var obj = arguments[length - 1];
+ return _isArray(obj) || typeof obj[methodname] !== 'function' ? fn.apply(this, arguments) : obj[methodname].apply(obj, _slice(arguments, 0, length - 1));
+ };
+ };
+
+ /**
+ * Optimized internal one-arity curry function.
+ *
+ * @private
+ * @category Function
+ * @param {Function} fn The function to curry.
+ * @return {Function} The curried function.
+ */
+ var _curry1 = function _curry1(fn) {
+ return function f1(a) {
+ if (arguments.length === 0 || _isPlaceholder(a)) {
+ return f1;
+ } else {
+ return fn.apply(this, arguments);
+ }
+ };
+ };
+
+ /**
+ * Optimized internal two-arity curry function.
+ *
+ * @private
+ * @category Function
+ * @param {Function} fn The function to curry.
+ * @return {Function} The curried function.
+ */
+ var _curry2 = function _curry2(fn) {
+ return function f2(a, b) {
+ switch (arguments.length) {
+ case 0:
+ return f2;
+ case 1:
+ return _isPlaceholder(a) ? f2 : _curry1(function (_b) {
+ return fn(a, _b);
+ });
+ default:
+ return _isPlaceholder(a) && _isPlaceholder(b) ? f2 : _isPlaceholder(a) ? _curry1(function (_a) {
+ return fn(_a, b);
+ }) : _isPlaceholder(b) ? _curry1(function (_b) {
+ return fn(a, _b);
+ }) : fn(a, b);
+ }
+ };
+ };
+
+ /**
+ * Optimized internal three-arity curry function.
+ *
+ * @private
+ * @category Function
+ * @param {Function} fn The function to curry.
+ * @return {Function} The curried function.
+ */
+ var _curry3 = function _curry3(fn) {
+ return function f3(a, b, c) {
+ switch (arguments.length) {
+ case 0:
+ return f3;
+ case 1:
+ return _isPlaceholder(a) ? f3 : _curry2(function (_b, _c) {
+ return fn(a, _b, _c);
+ });
+ case 2:
+ return _isPlaceholder(a) && _isPlaceholder(b) ? f3 : _isPlaceholder(a) ? _curry2(function (_a, _c) {
+ return fn(_a, b, _c);
+ }) : _isPlaceholder(b) ? _curry2(function (_b, _c) {
+ return fn(a, _b, _c);
+ }) : _curry1(function (_c) {
+ return fn(a, b, _c);
+ });
+ default:
+ return _isPlaceholder(a) && _isPlaceholder(b) && _isPlaceholder(c) ? f3 : _isPlaceholder(a) && _isPlaceholder(b) ? _curry2(function (_a, _b) {
+ return fn(_a, _b, c);
+ }) : _isPlaceholder(a) && _isPlaceholder(c) ? _curry2(function (_a, _c) {
+ return fn(_a, b, _c);
+ }) : _isPlaceholder(b) && _isPlaceholder(c) ? _curry2(function (_b, _c) {
+ return fn(a, _b, _c);
+ }) : _isPlaceholder(a) ? _curry1(function (_a) {
+ return fn(_a, b, c);
+ }) : _isPlaceholder(b) ? _curry1(function (_b) {
+ return fn(a, _b, c);
+ }) : _isPlaceholder(c) ? _curry1(function (_c) {
+ return fn(a, b, _c);
+ }) : fn(a, b, c);
+ }
+ };
+ };
+
+ /**
+ * Internal curryN function.
+ *
+ * @private
+ * @category Function
+ * @param {Number} length The arity of the curried function.
+ * @param {Array} received An array of arguments received thus far.
+ * @param {Function} fn The function to curry.
+ * @return {Function} The curried function.
+ */
+ var _curryN = function _curryN(length, received, fn) {
+ return function () {
+ var combined = [];
+ var argsIdx = 0;
+ var left = length;
+ var combinedIdx = 0;
+ while (combinedIdx < received.length || argsIdx < arguments.length) {
+ var result;
+ if (combinedIdx < received.length && (!_isPlaceholder(received[combinedIdx]) || argsIdx >= arguments.length)) {
+ result = received[combinedIdx];
+ } else {
+ result = arguments[argsIdx];
+ argsIdx += 1;
+ }
+ combined[combinedIdx] = result;
+ if (!_isPlaceholder(result)) {
+ left -= 1;
+ }
+ combinedIdx += 1;
+ }
+ return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn));
+ };
+ };
+
+ /**
+ * Returns a function that dispatches with different strategies based on the
+ * object in list position (last argument). If it is an array, executes [fn].
+ * Otherwise, if it has a function with [methodname], it will execute that
+ * function (functor case). Otherwise, if it is a transformer, uses transducer
+ * [xf] to return a new transformer (transducer case). Otherwise, it will
+ * default to executing [fn].
+ *
+ * @private
+ * @param {String} methodname property to check for a custom implementation
+ * @param {Function} xf transducer to initialize if object is transformer
+ * @param {Function} fn default ramda implementation
+ * @return {Function} A function that dispatches on object in list position
+ */
+ var _dispatchable = function _dispatchable(methodname, xf, fn) {
+ return function () {
+ var length = arguments.length;
+ if (length === 0) {
+ return fn();
+ }
+ var obj = arguments[length - 1];
+ if (!_isArray(obj)) {
+ var args = _slice(arguments, 0, length - 1);
+ if (typeof obj[methodname] === 'function') {
+ return obj[methodname].apply(obj, args);
+ }
+ if (_isTransformer(obj)) {
+ var transducer = xf.apply(null, args);
+ return transducer(obj);
+ }
+ }
+ return fn.apply(this, arguments);
+ };
+ };
+
+ var _dropLastWhile = function dropLastWhile(pred, list) {
+ var idx = list.length - 1;
+ while (idx >= 0 && pred(list[idx])) {
+ idx -= 1;
+ }
+ return _slice(list, 0, idx + 1);
+ };
+
+ var _xall = function () {
+ function XAll(f, xf) {
+ this.xf = xf;
+ this.f = f;
+ this.all = true;
+ }
+ XAll.prototype['@@transducer/init'] = _xfBase.init;
+ XAll.prototype['@@transducer/result'] = function (result) {
+ if (this.all) {
+ result = this.xf['@@transducer/step'](result, true);
+ }
+ return this.xf['@@transducer/result'](result);
+ };
+ XAll.prototype['@@transducer/step'] = function (result, input) {
+ if (!this.f(input)) {
+ this.all = false;
+ result = _reduced(this.xf['@@transducer/step'](result, false));
+ }
+ return result;
+ };
+ return _curry2(function _xall(f, xf) {
+ return new XAll(f, xf);
+ });
+ }();
+
+ var _xany = function () {
+ function XAny(f, xf) {
+ this.xf = xf;
+ this.f = f;
+ this.any = false;
+ }
+ XAny.prototype['@@transducer/init'] = _xfBase.init;
+ XAny.prototype['@@transducer/result'] = function (result) {
+ if (!this.any) {
+ result = this.xf['@@transducer/step'](result, false);
+ }
+ return this.xf['@@transducer/result'](result);
+ };
+ XAny.prototype['@@transducer/step'] = function (result, input) {
+ if (this.f(input)) {
+ this.any = true;
+ result = _reduced(this.xf['@@transducer/step'](result, true));
+ }
+ return result;
+ };
+ return _curry2(function _xany(f, xf) {
+ return new XAny(f, xf);
+ });
+ }();
+
+ var _xaperture = function () {
+ function XAperture(n, xf) {
+ this.xf = xf;
+ this.pos = 0;
+ this.full = false;
+ this.acc = new Array(n);
+ }
+ XAperture.prototype['@@transducer/init'] = _xfBase.init;
+ XAperture.prototype['@@transducer/result'] = function (result) {
+ this.acc = null;
+ return this.xf['@@transducer/result'](result);
+ };
+ XAperture.prototype['@@transducer/step'] = function (result, input) {
+ this.store(input);
+ return this.full ? this.xf['@@transducer/step'](result, this.getCopy()) : result;
+ };
+ XAperture.prototype.store = function (input) {
+ this.acc[this.pos] = input;
+ this.pos += 1;
+ if (this.pos === this.acc.length) {
+ this.pos = 0;
+ this.full = true;
+ }
+ };
+ XAperture.prototype.getCopy = function () {
+ return _concat(_slice(this.acc, this.pos), _slice(this.acc, 0, this.pos));
+ };
+ return _curry2(function _xaperture(n, xf) {
+ return new XAperture(n, xf);
+ });
+ }();
+
+ var _xdrop = function () {
+ function XDrop(n, xf) {
+ this.xf = xf;
+ this.n = n;
+ }
+ XDrop.prototype['@@transducer/init'] = _xfBase.init;
+ XDrop.prototype['@@transducer/result'] = _xfBase.result;
+ XDrop.prototype['@@transducer/step'] = function (result, input) {
+ if (this.n > 0) {
+ this.n -= 1;
+ return result;
+ }
+ return this.xf['@@transducer/step'](result, input);
+ };
+ return _curry2(function _xdrop(n, xf) {
+ return new XDrop(n, xf);
+ });
+ }();
+
+ var _xdropLast = function () {
+ function XDropLast(n, xf) {
+ this.xf = xf;
+ this.pos = 0;
+ this.full = false;
+ this.acc = new Array(n);
+ }
+ XDropLast.prototype['@@transducer/init'] = _xfBase.init;
+ XDropLast.prototype['@@transducer/result'] = function (result) {
+ this.acc = null;
+ return this.xf['@@transducer/result'](result);
+ };
+ XDropLast.prototype['@@transducer/step'] = function (result, input) {
+ if (this.full) {
+ result = this.xf['@@transducer/step'](result, this.acc[this.pos]);
+ }
+ this.store(input);
+ return result;
+ };
+ XDropLast.prototype.store = function (input) {
+ this.acc[this.pos] = input;
+ this.pos += 1;
+ if (this.pos === this.acc.length) {
+ this.pos = 0;
+ this.full = true;
+ }
+ };
+ return _curry2(function _xdropLast(n, xf) {
+ return new XDropLast(n, xf);
+ });
+ }();
+
+ var _xdropRepeatsWith = function () {
+ function XDropRepeatsWith(pred, xf) {
+ this.xf = xf;
+ this.pred = pred;
+ this.lastValue = undefined;
+ this.seenFirstValue = false;
+ }
+ XDropRepeatsWith.prototype['@@transducer/init'] = function () {
+ return this.xf['@@transducer/init']();
+ };
+ XDropRepeatsWith.prototype['@@transducer/result'] = function (result) {
+ return this.xf['@@transducer/result'](result);
+ };
+ XDropRepeatsWith.prototype['@@transducer/step'] = function (result, input) {
+ var sameAsLast = false;
+ if (!this.seenFirstValue) {
+ this.seenFirstValue = true;
+ } else if (this.pred(this.lastValue, input)) {
+ sameAsLast = true;
+ }
+ this.lastValue = input;
+ return sameAsLast ? result : this.xf['@@transducer/step'](result, input);
+ };
+ return _curry2(function _xdropRepeatsWith(pred, xf) {
+ return new XDropRepeatsWith(pred, xf);
+ });
+ }();
+
+ var _xdropWhile = function () {
+ function XDropWhile(f, xf) {
+ this.xf = xf;
+ this.f = f;
+ }
+ XDropWhile.prototype['@@transducer/init'] = _xfBase.init;
+ XDropWhile.prototype['@@transducer/result'] = _xfBase.result;
+ XDropWhile.prototype['@@transducer/step'] = function (result, input) {
+ if (this.f) {
+ if (this.f(input)) {
+ return result;
+ }
+ this.f = null;
+ }
+ return this.xf['@@transducer/step'](result, input);
+ };
+ return _curry2(function _xdropWhile(f, xf) {
+ return new XDropWhile(f, xf);
+ });
+ }();
+
+ var _xfilter = function () {
+ function XFilter(f, xf) {
+ this.xf = xf;
+ this.f = f;
+ }
+ XFilter.prototype['@@transducer/init'] = _xfBase.init;
+ XFilter.prototype['@@transducer/result'] = _xfBase.result;
+ XFilter.prototype['@@transducer/step'] = function (result, input) {
+ return this.f(input) ? this.xf['@@transducer/step'](result, input) : result;
+ };
+ return _curry2(function _xfilter(f, xf) {
+ return new XFilter(f, xf);
+ });
+ }();
+
+ var _xfind = function () {
+ function XFind(f, xf) {
+ this.xf = xf;
+ this.f = f;
+ this.found = false;
+ }
+ XFind.prototype['@@transducer/init'] = _xfBase.init;
+ XFind.prototype['@@transducer/result'] = function (result) {
+ if (!this.found) {
+ result = this.xf['@@transducer/step'](result, void 0);
+ }
+ return this.xf['@@transducer/result'](result);
+ };
+ XFind.prototype['@@transducer/step'] = function (result, input) {
+ if (this.f(input)) {
+ this.found = true;
+ result = _reduced(this.xf['@@transducer/step'](result, input));
+ }
+ return result;
+ };
+ return _curry2(function _xfind(f, xf) {
+ return new XFind(f, xf);
+ });
+ }();
+
+ var _xfindIndex = function () {
+ function XFindIndex(f, xf) {
+ this.xf = xf;
+ this.f = f;
+ this.idx = -1;
+ this.found = false;
+ }
+ XFindIndex.prototype['@@transducer/init'] = _xfBase.init;
+ XFindIndex.prototype['@@transducer/result'] = function (result) {
+ if (!this.found) {
+ result = this.xf['@@transducer/step'](result, -1);
+ }
+ return this.xf['@@transducer/result'](result);
+ };
+ XFindIndex.prototype['@@transducer/step'] = function (result, input) {
+ this.idx += 1;
+ if (this.f(input)) {
+ this.found = true;
+ result = _reduced(this.xf['@@transducer/step'](result, this.idx));
+ }
+ return result;
+ };
+ return _curry2(function _xfindIndex(f, xf) {
+ return new XFindIndex(f, xf);
+ });
+ }();
+
+ var _xfindLast = function () {
+ function XFindLast(f, xf) {
+ this.xf = xf;
+ this.f = f;
+ }
+ XFindLast.prototype['@@transducer/init'] = _xfBase.init;
+ XFindLast.prototype['@@transducer/result'] = function (result) {
+ return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.last));
+ };
+ XFindLast.prototype['@@transducer/step'] = function (result, input) {
+ if (this.f(input)) {
+ this.last = input;
+ }
+ return result;
+ };
+ return _curry2(function _xfindLast(f, xf) {
+ return new XFindLast(f, xf);
+ });
+ }();
+
+ var _xfindLastIndex = function () {
+ function XFindLastIndex(f, xf) {
+ this.xf = xf;
+ this.f = f;
+ this.idx = -1;
+ this.lastIdx = -1;
+ }
+ XFindLastIndex.prototype['@@transducer/init'] = _xfBase.init;
+ XFindLastIndex.prototype['@@transducer/result'] = function (result) {
+ return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.lastIdx));
+ };
+ XFindLastIndex.prototype['@@transducer/step'] = function (result, input) {
+ this.idx += 1;
+ if (this.f(input)) {
+ this.lastIdx = this.idx;
+ }
+ return result;
+ };
+ return _curry2(function _xfindLastIndex(f, xf) {
+ return new XFindLastIndex(f, xf);
+ });
+ }();
+
+ var _xmap = function () {
+ function XMap(f, xf) {
+ this.xf = xf;
+ this.f = f;
+ }
+ XMap.prototype['@@transducer/init'] = _xfBase.init;
+ XMap.prototype['@@transducer/result'] = _xfBase.result;
+ XMap.prototype['@@transducer/step'] = function (result, input) {
+ return this.xf['@@transducer/step'](result, this.f(input));
+ };
+ return _curry2(function _xmap(f, xf) {
+ return new XMap(f, xf);
+ });
+ }();
+
+ var _xtake = function () {
+ function XTake(n, xf) {
+ this.xf = xf;
+ this.n = n;
+ }
+ XTake.prototype['@@transducer/init'] = _xfBase.init;
+ XTake.prototype['@@transducer/result'] = _xfBase.result;
+ XTake.prototype['@@transducer/step'] = function (result, input) {
+ if (this.n === 0) {
+ return _reduced(result);
+ } else {
+ this.n -= 1;
+ return this.xf['@@transducer/step'](result, input);
+ }
+ };
+ return _curry2(function _xtake(n, xf) {
+ return new XTake(n, xf);
+ });
+ }();
+
+ var _xtakeWhile = function () {
+ function XTakeWhile(f, xf) {
+ this.xf = xf;
+ this.f = f;
+ }
+ XTakeWhile.prototype['@@transducer/init'] = _xfBase.init;
+ XTakeWhile.prototype['@@transducer/result'] = _xfBase.result;
+ XTakeWhile.prototype['@@transducer/step'] = function (result, input) {
+ return this.f(input) ? this.xf['@@transducer/step'](result, input) : _reduced(result);
+ };
+ return _curry2(function _xtakeWhile(f, xf) {
+ return new XTakeWhile(f, xf);
+ });
+ }();
+
+ /**
+ * Adds two numbers. Equivalent to `a + b` but curried.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Math
+ * @sig Number -> Number -> Number
+ * @param {Number} a
+ * @param {Number} b
+ * @return {Number}
+ * @see R.subtract
+ * @example
+ *
+ * R.add(2, 3); //=> 5
+ * R.add(7)(10); //=> 17
+ */
+ var add = _curry2(function add(a, b) {
+ return a + b;
+ });
+
+ /**
+ * Applies a function to the value at the given index of an array, returning a
+ * new copy of the array with the element at the given index replaced with the
+ * result of the function application.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.14.0
+ * @category List
+ * @sig (a -> a) -> Number -> [a] -> [a]
+ * @param {Function} fn The function to apply.
+ * @param {Number} idx The index.
+ * @param {Array|Arguments} list An array-like object whose value
+ * at the supplied index will be replaced.
+ * @return {Array} A copy of the supplied array-like object with
+ * the element at index `idx` replaced with the value
+ * returned by applying `fn` to the existing element.
+ * @see R.update
+ * @example
+ *
+ * R.adjust(R.add(10), 1, [0, 1, 2]); //=> [0, 11, 2]
+ * R.adjust(R.add(10))(1)([0, 1, 2]); //=> [0, 11, 2]
+ */
+ var adjust = _curry3(function adjust(fn, idx, list) {
+ if (idx >= list.length || idx < -list.length) {
+ return list;
+ }
+ var start = idx < 0 ? list.length : 0;
+ var _idx = start + idx;
+ var _list = _concat(list);
+ _list[_idx] = fn(list[_idx]);
+ return _list;
+ });
+
+ /**
+ * Returns `true` if all elements of the list match the predicate, `false` if
+ * there are any that don't.
+ *
+ * Dispatches to the `all` method of the second argument, if present.
+ *
+ * Acts as a transducer if a transformer is given in list position.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category List
+ * @sig (a -> Boolean) -> [a] -> Boolean
+ * @param {Function} fn The predicate function.
+ * @param {Array} list The array to consider.
+ * @return {Boolean} `true` if the predicate is satisfied by every element, `false`
+ * otherwise.
+ * @see R.any, R.none, R.transduce
+ * @example
+ *
+ * var lessThan2 = R.flip(R.lt)(2);
+ * var lessThan3 = R.flip(R.lt)(3);
+ * R.all(lessThan2)([1, 2]); //=> false
+ * R.all(lessThan3)([1, 2]); //=> true
+ */
+ var all = _curry2(_dispatchable('all', _xall, function all(fn, list) {
+ var idx = 0;
+ while (idx < list.length) {
+ if (!fn(list[idx])) {
+ return false;
+ }
+ idx += 1;
+ }
+ return true;
+ }));
+
+ /**
+ * Returns a function that always returns the given value. Note that for
+ * non-primitives the value returned is a reference to the original value.
+ *
+ * This function is known as `const`, `constant`, or `K` (for K combinator) in
+ * other languages and libraries.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Function
+ * @sig a -> (* -> a)
+ * @param {*} val The value to wrap in a function
+ * @return {Function} A Function :: * -> val.
+ * @example
+ *
+ * var t = R.always('Tee');
+ * t(); //=> 'Tee'
+ */
+ var always = _curry1(function always(val) {
+ return function () {
+ return val;
+ };
+ });
+
+ /**
+ * Returns `true` if both arguments are `true`; `false` otherwise.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Logic
+ * @sig * -> * -> *
+ * @param {Boolean} a A boolean value
+ * @param {Boolean} b A boolean value
+ * @return {Boolean} `true` if both arguments are `true`, `false` otherwise
+ * @see R.both
+ * @example
+ *
+ * R.and(true, true); //=> true
+ * R.and(true, false); //=> false
+ * R.and(false, true); //=> false
+ * R.and(false, false); //=> false
+ */
+ var and = _curry2(function and(a, b) {
+ return a && b;
+ });
+
+ /**
+ * Returns `true` if at least one of elements of the list match the predicate,
+ * `false` otherwise.
+ *
+ * Dispatches to the `any` method of the second argument, if present.
+ *
+ * Acts as a transducer if a transformer is given in list position.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category List
+ * @sig (a -> Boolean) -> [a] -> Boolean
+ * @param {Function} fn The predicate function.
+ * @param {Array} list The array to consider.
+ * @return {Boolean} `true` if the predicate is satisfied by at least one element, `false`
+ * otherwise.
+ * @see R.all, R.none, R.transduce
+ * @example
+ *
+ * var lessThan0 = R.flip(R.lt)(0);
+ * var lessThan2 = R.flip(R.lt)(2);
+ * R.any(lessThan0)([1, 2]); //=> false
+ * R.any(lessThan2)([1, 2]); //=> true
+ */
+ var any = _curry2(_dispatchable('any', _xany, function any(fn, list) {
+ var idx = 0;
+ while (idx < list.length) {
+ if (fn(list[idx])) {
+ return true;
+ }
+ idx += 1;
+ }
+ return false;
+ }));
+
+ /**
+ * Returns a new list, composed of n-tuples of consecutive elements If `n` is
+ * greater than the length of the list, an empty list is returned.
+ *
+ * Dispatches to the `aperture` method of the second argument, if present.
+ *
+ * Acts as a transducer if a transformer is given in list position.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.12.0
+ * @category List
+ * @sig Number -> [a] -> [[a]]
+ * @param {Number} n The size of the tuples to create
+ * @param {Array} list The list to split into `n`-tuples
+ * @return {Array} The new list.
+ * @see R.transduce
+ * @example
+ *
+ * R.aperture(2, [1, 2, 3, 4, 5]); //=> [[1, 2], [2, 3], [3, 4], [4, 5]]
+ * R.aperture(3, [1, 2, 3, 4, 5]); //=> [[1, 2, 3], [2, 3, 4], [3, 4, 5]]
+ * R.aperture(7, [1, 2, 3, 4, 5]); //=> []
+ */
+ var aperture = _curry2(_dispatchable('aperture', _xaperture, _aperture));
+
+ /**
+ * Returns a new list containing the contents of the given list, followed by
+ * the given element.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category List
+ * @sig a -> [a] -> [a]
+ * @param {*} el The element to add to the end of the new list.
+ * @param {Array} list The list whose contents will be added to the beginning of the output
+ * list.
+ * @return {Array} A new list containing the contents of the old list followed by `el`.
+ * @see R.prepend
+ * @example
+ *
+ * R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests']
+ * R.append('tests', []); //=> ['tests']
+ * R.append(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']]
+ */
+ var append = _curry2(function append(el, list) {
+ return _concat(list, [el]);
+ });
+
+ /**
+ * Applies function `fn` to the argument list `args`. This is useful for
+ * creating a fixed-arity function from a variadic function. `fn` should be a
+ * bound function if context is significant.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.7.0
+ * @category Function
+ * @sig (*... -> a) -> [*] -> a
+ * @param {Function} fn
+ * @param {Array} args
+ * @return {*}
+ * @see R.call, R.unapply
+ * @example
+ *
+ * var nums = [1, 2, 3, -99, 42, 6, 7];
+ * R.apply(Math.max, nums); //=> 42
+ */
+ var apply = _curry2(function apply(fn, args) {
+ return fn.apply(this, args);
+ });
+
+ /**
+ * Makes a shallow clone of an object, setting or overriding the specified
+ * property with the given value. Note that this copies and flattens prototype
+ * properties onto the new object as well. All non-primitive properties are
+ * copied by reference.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.8.0
+ * @category Object
+ * @sig String -> a -> {k: v} -> {k: v}
+ * @param {String} prop the property name to set
+ * @param {*} val the new value
+ * @param {Object} obj the object to clone
+ * @return {Object} a new object similar to the original except for the specified property.
+ * @see R.dissoc
+ * @example
+ *
+ * R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3}
+ */
+ var assoc = _curry3(function assoc(prop, val, obj) {
+ var result = {};
+ for (var p in obj) {
+ result[p] = obj[p];
+ }
+ result[prop] = val;
+ return result;
+ });
+
+ /**
+ * Makes a shallow clone of an object, setting or overriding the nodes required
+ * to create the given path, and placing the specific value at the tail end of
+ * that path. Note that this copies and flattens prototype properties onto the
+ * new object as well. All non-primitive properties are copied by reference.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.8.0
+ * @category Object
+ * @sig [String] -> a -> {k: v} -> {k: v}
+ * @param {Array} path the path to set
+ * @param {*} val the new value
+ * @param {Object} obj the object to clone
+ * @return {Object} a new object similar to the original except along the specified path.
+ * @see R.dissocPath
+ * @example
+ *
+ * R.assocPath(['a', 'b', 'c'], 42, {a: {b: {c: 0}}}); //=> {a: {b: {c: 42}}}
+ */
+ var assocPath = _curry3(function assocPath(path, val, obj) {
+ switch (path.length) {
+ case 0:
+ return val;
+ case 1:
+ return assoc(path[0], val, obj);
+ default:
+ return assoc(path[0], assocPath(_slice(path, 1), val, Object(obj[path[0]])), obj);
+ }
+ });
+
+ /**
+ * Creates a function that is bound to a context.
+ * Note: `R.bind` does not provide the additional argument-binding capabilities of
+ * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).
+ *
+ * @func
+ * @memberOf R
+ * @since v0.6.0
+ * @category Function
+ * @category Object
+ * @sig (* -> *) -> {*} -> (* -> *)
+ * @param {Function} fn The function to bind to context
+ * @param {Object} thisObj The context to bind `fn` to
+ * @return {Function} A function that will execute in the context of `thisObj`.
+ * @see R.partial
+ */
+ var bind = _curry2(function bind(fn, thisObj) {
+ return _arity(fn.length, function () {
+ return fn.apply(thisObj, arguments);
+ });
+ });
+
+ /**
+ * A function wrapping calls to the two functions in an `&&` operation,
+ * returning the result of the first function if it is false-y and the result
+ * of the second function otherwise. Note that this is short-circuited,
+ * meaning that the second function will not be invoked if the first returns a
+ * false-y value.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.12.0
+ * @category Logic
+ * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)
+ * @param {Function} f a predicate
+ * @param {Function} g another predicate
+ * @return {Function} a function that applies its arguments to `f` and `g` and `&&`s their outputs together.
+ * @see R.and
+ * @example
+ *
+ * var gt10 = x => x > 10;
+ * var even = x => x % 2 === 0;
+ * var f = R.both(gt10, even);
+ * f(100); //=> true
+ * f(101); //=> false
+ */
+ var both = _curry2(function both(f, g) {
+ return function _both() {
+ return f.apply(this, arguments) && g.apply(this, arguments);
+ };
+ });
+
+ /**
+ * Makes a comparator function out of a function that reports whether the first
+ * element is less than the second.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Function
+ * @sig (a, b -> Boolean) -> (a, b -> Number)
+ * @param {Function} pred A predicate function of arity two.
+ * @return {Function} A Function :: a -> b -> Int that returns `-1` if a < b, `1` if b < a, otherwise `0`.
+ * @example
+ *
+ * var cmp = R.comparator((a, b) => a.age < b.age);
+ * var people = [
+ * // ...
+ * ];
+ * R.sort(cmp, people);
+ */
+ var comparator = _curry1(function comparator(pred) {
+ return function (a, b) {
+ return pred(a, b) ? -1 : pred(b, a) ? 1 : 0;
+ };
+ });
+
+ /**
+ * Returns a function, `fn`, which encapsulates if/else-if/else logic.
+ * `R.cond` takes a list of [predicate, transform] pairs. All of the arguments
+ * to `fn` are applied to each of the predicates in turn until one returns a
+ * "truthy" value, at which point `fn` returns the result of applying its
+ * arguments to the corresponding transformer. If none of the predicates
+ * matches, `fn` returns undefined.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.6.0
+ * @category Logic
+ * @sig [[(*... -> Boolean),(*... -> *)]] -> (*... -> *)
+ * @param {Array} pairs
+ * @return {Function}
+ * @example
+ *
+ * var fn = R.cond([
+ * [R.equals(0), R.always('water freezes at 0°C')],
+ * [R.equals(100), R.always('water boils at 100°C')],
+ * [R.T, temp => 'nothing special happens at ' + temp + '°C']
+ * ]);
+ * fn(0); //=> 'water freezes at 0°C'
+ * fn(50); //=> 'nothing special happens at 50°C'
+ * fn(100); //=> 'water boils at 100°C'
+ */
+ var cond = _curry1(function cond(pairs) {
+ return function () {
+ var idx = 0;
+ while (idx < pairs.length) {
+ if (pairs[idx][0].apply(this, arguments)) {
+ return pairs[idx][1].apply(this, arguments);
+ }
+ idx += 1;
+ }
+ };
+ });
+
+ /**
+ * Counts the elements of a list according to how many match each value of a
+ * key generated by the supplied function. Returns an object mapping the keys
+ * produced by `fn` to the number of occurrences in the list. Note that all
+ * keys are coerced to strings because of how JavaScript objects work.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Relation
+ * @sig (a -> String) -> [a] -> {*}
+ * @param {Function} fn The function used to map values to keys.
+ * @param {Array} list The list to count elements from.
+ * @return {Object} An object mapping keys to number of occurrences in the list.
+ * @example
+ *
+ * var numbers = [1.0, 1.1, 1.2, 2.0, 3.0, 2.2];
+ * var letters = R.split('', 'abcABCaaaBBc');
+ * R.countBy(Math.floor)(numbers); //=> {'1': 3, '2': 2, '3': 1}
+ * R.countBy(R.toLower)(letters); //=> {'a': 5, 'b': 4, 'c': 3}
+ */
+ var countBy = _curry2(function countBy(fn, list) {
+ var counts = {};
+ var len = list.length;
+ var idx = 0;
+ while (idx < len) {
+ var key = fn(list[idx]);
+ counts[key] = (_has(key, counts) ? counts[key] : 0) + 1;
+ idx += 1;
+ }
+ return counts;
+ });
+
+ /**
+ * Returns a curried equivalent of the provided function, with the specified
+ * arity. The curried function has two unusual capabilities. First, its
+ * arguments needn't be provided one at a time. If `g` is `R.curryN(3, f)`, the
+ * following are equivalent:
+ *
+ * - `g(1)(2)(3)`
+ * - `g(1)(2, 3)`
+ * - `g(1, 2)(3)`
+ * - `g(1, 2, 3)`
+ *
+ * Secondly, the special placeholder value `R.__` may be used to specify
+ * "gaps", allowing partial application of any combination of arguments,
+ * regardless of their positions. If `g` is as above and `_` is `R.__`, the
+ * following are equivalent:
+ *
+ * - `g(1, 2, 3)`
+ * - `g(_, 2, 3)(1)`
+ * - `g(_, _, 3)(1)(2)`
+ * - `g(_, _, 3)(1, 2)`
+ * - `g(_, 2)(1)(3)`
+ * - `g(_, 2)(1, 3)`
+ * - `g(_, 2)(_, 3)(1)`
+ *
+ * @func
+ * @memberOf R
+ * @since v0.5.0
+ * @category Function
+ * @sig Number -> (* -> a) -> (* -> a)
+ * @param {Number} length The arity for the returned function.
+ * @param {Function} fn The function to curry.
+ * @return {Function} A new, curried function.
+ * @see R.curry
+ * @example
+ *
+ * var sumArgs = (...args) => R.sum(args);
+ *
+ * var curriedAddFourNumbers = R.curryN(4, sumArgs);
+ * var f = curriedAddFourNumbers(1, 2);
+ * var g = f(3);
+ * g(4); //=> 10
+ */
+ var curryN = _curry2(function curryN(length, fn) {
+ if (length === 1) {
+ return _curry1(fn);
+ }
+ return _arity(length, _curryN(length, [], fn));
+ });
+
+ /**
+ * Decrements its argument.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.9.0
+ * @category Math
+ * @sig Number -> Number
+ * @param {Number} n
+ * @return {Number}
+ * @see R.inc
+ * @example
+ *
+ * R.dec(42); //=> 41
+ */
+ var dec = add(-1);
+
+ /**
+ * Returns the second argument if it is not `null`, `undefined` or `NaN`
+ * otherwise the first argument is returned.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.10.0
+ * @category Logic
+ * @sig a -> b -> a | b
+ * @param {a} val The default value.
+ * @param {b} val The value to return if it is not null or undefined
+ * @return {*} The the second value or the default value
+ * @example
+ *
+ * var defaultTo42 = R.defaultTo(42);
+ *
+ * defaultTo42(null); //=> 42
+ * defaultTo42(undefined); //=> 42
+ * defaultTo42('Ramda'); //=> 'Ramda'
+ * defaultTo42(parseInt('string')); //=> 42
+ */
+ var defaultTo = _curry2(function defaultTo(d, v) {
+ return v == null || v !== v ? d : v;
+ });
+
+ /**
+ * Finds the set (i.e. no duplicates) of all elements in the first list not
+ * contained in the second list. Duplication is determined according to the
+ * value returned by applying the supplied predicate to two list elements.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Relation
+ * @sig (a -> a -> Boolean) -> [*] -> [*] -> [*]
+ * @param {Function} pred A predicate used to test whether two items are equal.
+ * @param {Array} list1 The first list.
+ * @param {Array} list2 The second list.
+ * @return {Array} The elements in `list1` that are not in `list2`.
+ * @see R.difference
+ * @example
+ *
+ * function cmp(x, y) => x.a === y.a;
+ * var l1 = [{a: 1}, {a: 2}, {a: 3}];
+ * var l2 = [{a: 3}, {a: 4}];
+ * R.differenceWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}]
+ */
+ var differenceWith = _curry3(function differenceWith(pred, first, second) {
+ var out = [];
+ var idx = 0;
+ var firstLen = first.length;
+ while (idx < firstLen) {
+ if (!_containsWith(pred, first[idx], second) && !_containsWith(pred, first[idx], out)) {
+ out.push(first[idx]);
+ }
+ idx += 1;
+ }
+ return out;
+ });
+
+ /**
+ * Returns a new object that does not contain a `prop` property.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.10.0
+ * @category Object
+ * @sig String -> {k: v} -> {k: v}
+ * @param {String} prop the name of the property to dissociate
+ * @param {Object} obj the object to clone
+ * @return {Object} a new object similar to the original but without the specified property
+ * @see R.assoc
+ * @example
+ *
+ * R.dissoc('b', {a: 1, b: 2, c: 3}); //=> {a: 1, c: 3}
+ */
+ var dissoc = _curry2(function dissoc(prop, obj) {
+ var result = {};
+ for (var p in obj) {
+ if (p !== prop) {
+ result[p] = obj[p];
+ }
+ }
+ return result;
+ });
+
+ /**
+ * Makes a shallow clone of an object, omitting the property at the given path.
+ * Note that this copies and flattens prototype properties onto the new object
+ * as well. All non-primitive properties are copied by reference.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.11.0
+ * @category Object
+ * @sig [String] -> {k: v} -> {k: v}
+ * @param {Array} path the path to set
+ * @param {Object} obj the object to clone
+ * @return {Object} a new object without the property at path
+ * @see R.assocPath
+ * @example
+ *
+ * R.dissocPath(['a', 'b', 'c'], {a: {b: {c: 42}}}); //=> {a: {b: {}}}
+ */
+ var dissocPath = _curry2(function dissocPath(path, obj) {
+ switch (path.length) {
+ case 0:
+ return obj;
+ case 1:
+ return dissoc(path[0], obj);
+ default:
+ var head = path[0];
+ var tail = _slice(path, 1);
+ return obj[head] == null ? obj : assoc(head, dissocPath(tail, obj[head]), obj);
+ }
+ });
+
+ /**
+ * Divides two numbers. Equivalent to `a / b`.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Math
+ * @sig Number -> Number -> Number
+ * @param {Number} a The first value.
+ * @param {Number} b The second value.
+ * @return {Number} The result of `a / b`.
+ * @see R.multiply
+ * @example
+ *
+ * R.divide(71, 100); //=> 0.71
+ *
+ * var half = R.divide(R.__, 2);
+ * half(42); //=> 21
+ *
+ * var reciprocal = R.divide(1);
+ * reciprocal(4); //=> 0.25
+ */
+ var divide = _curry2(function divide(a, b) {
+ return a / b;
+ });
+
+ /**
+ * Returns a new list containing the last `n` elements of a given list, passing
+ * each value to the supplied predicate function, skipping elements while the
+ * predicate function returns `true`. The predicate function is passed one
+ * argument: *(value)*.
+ *
+ * Dispatches to the `dropWhile` method of the second argument, if present.
+ *
+ * Acts as a transducer if a transformer is given in list position.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.9.0
+ * @category List
+ * @sig (a -> Boolean) -> [a] -> [a]
+ * @param {Function} fn The function called per iteration.
+ * @param {Array} list The collection to iterate over.
+ * @return {Array} A new array.
+ * @see R.takeWhile, R.transduce, R.addIndex
+ * @example
+ *
+ * var lteTwo = x => x <= 2;
+ *
+ * R.dropWhile(lteTwo, [1, 2, 3, 4, 3, 2, 1]); //=> [3, 4, 3, 2, 1]
+ */
+ var dropWhile = _curry2(_dispatchable('dropWhile', _xdropWhile, function dropWhile(pred, list) {
+ var idx = 0;
+ var len = list.length;
+ while (idx < len && pred(list[idx])) {
+ idx += 1;
+ }
+ return _slice(list, idx);
+ }));
+
+ /**
+ * A function wrapping calls to the two functions in an `||` operation,
+ * returning the result of the first function if it is truth-y and the result
+ * of the second function otherwise. Note that this is short-circuited,
+ * meaning that the second function will not be invoked if the first returns a
+ * truth-y value.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.12.0
+ * @category Logic
+ * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)
+ * @param {Function} f a predicate
+ * @param {Function} g another predicate
+ * @return {Function} a function that applies its arguments to `f` and `g` and `||`s their outputs together.
+ * @see R.or
+ * @example
+ *
+ * var gt10 = x => x > 10;
+ * var even = x => x % 2 === 0;
+ * var f = R.either(gt10, even);
+ * f(101); //=> true
+ * f(8); //=> true
+ */
+ var either = _curry2(function either(f, g) {
+ return function _either() {
+ return f.apply(this, arguments) || g.apply(this, arguments);
+ };
+ });
+
+ /**
+ * Returns the empty value of its argument's type. Ramda defines the empty
+ * value of Array (`[]`), Object (`{}`), String (`''`), and Arguments. Other
+ * types are supported if they define `.empty` and/or
+ * `.prototype.empty`.
+ *
+ * Dispatches to the `empty` method of the first argument, if present.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.3.0
+ * @category Function
+ * @sig a -> a
+ * @param {*} x
+ * @return {*}
+ * @example
+ *
+ * R.empty(Just(42)); //=> Nothing()
+ * R.empty([1, 2, 3]); //=> []
+ * R.empty('unicorns'); //=> ''
+ * R.empty({x: 1, y: 2}); //=> {}
+ */
+ // else
+ var empty = _curry1(function empty(x) {
+ return x != null && typeof x.empty === 'function' ? x.empty() : x != null && x.constructor != null && typeof x.constructor.empty === 'function' ? x.constructor.empty() : _isArray(x) ? [] : _isString(x) ? '' : _isObject(x) ? {} : _isArguments(x) ? function () {
+ return arguments;
+ }() : // else
+ void 0;
+ });
+
+ /**
+ * Creates a new object by recursively evolving a shallow copy of `object`,
+ * according to the `transformation` functions. All non-primitive properties
+ * are copied by reference.
+ *
+ * A `transformation` function will not be invoked if its corresponding key
+ * does not exist in the evolved object.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.9.0
+ * @category Object
+ * @sig {k: (v -> v)} -> {k: v} -> {k: v}
+ * @param {Object} transformations The object specifying transformation functions to apply
+ * to the object.
+ * @param {Object} object The object to be transformed.
+ * @return {Object} The transformed object.
+ * @example
+ *
+ * var tomato = {firstName: ' Tomato ', data: {elapsed: 100, remaining: 1400}, id:123};
+ * var transformations = {
+ * firstName: R.trim,
+ * lastName: R.trim, // Will not get invoked.
+ * data: {elapsed: R.add(1), remaining: R.add(-1)}
+ * };
+ * R.evolve(transformations, tomato); //=> {firstName: 'Tomato', data: {elapsed: 101, remaining: 1399}, id:123}
+ */
+ var evolve = _curry2(function evolve(transformations, object) {
+ var result = {};
+ var transformation, key, type;
+ for (key in object) {
+ transformation = transformations[key];
+ type = typeof transformation;
+ result[key] = type === 'function' ? transformation(object[key]) : type === 'object' ? evolve(transformations[key], object[key]) : object[key];
+ }
+ return result;
+ });
+
+ /**
+ * Returns the first element of the list which matches the predicate, or
+ * `undefined` if no element matches.
+ *
+ * Dispatches to the `find` method of the second argument, if present.
+ *
+ * Acts as a transducer if a transformer is given in list position.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category List
+ * @sig (a -> Boolean) -> [a] -> a | undefined
+ * @param {Function} fn The predicate function used to determine if the element is the
+ * desired one.
+ * @param {Array} list The array to consider.
+ * @return {Object} The element found, or `undefined`.
+ * @see R.transduce
+ * @example
+ *
+ * var xs = [{a: 1}, {a: 2}, {a: 3}];
+ * R.find(R.propEq('a', 2))(xs); //=> {a: 2}
+ * R.find(R.propEq('a', 4))(xs); //=> undefined
+ */
+ var find = _curry2(_dispatchable('find', _xfind, function find(fn, list) {
+ var idx = 0;
+ var len = list.length;
+ while (idx < len) {
+ if (fn(list[idx])) {
+ return list[idx];
+ }
+ idx += 1;
+ }
+ }));
+
+ /**
+ * Returns the index of the first element of the list which matches the
+ * predicate, or `-1` if no element matches.
+ *
+ * Dispatches to the `findIndex` method of the second argument, if present.
+ *
+ * Acts as a transducer if a transformer is given in list position.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.1
+ * @category List
+ * @sig (a -> Boolean) -> [a] -> Number
+ * @param {Function} fn The predicate function used to determine if the element is the
+ * desired one.
+ * @param {Array} list The array to consider.
+ * @return {Number} The index of the element found, or `-1`.
+ * @see R.transduce
+ * @example
+ *
+ * var xs = [{a: 1}, {a: 2}, {a: 3}];
+ * R.findIndex(R.propEq('a', 2))(xs); //=> 1
+ * R.findIndex(R.propEq('a', 4))(xs); //=> -1
+ */
+ var findIndex = _curry2(_dispatchable('findIndex', _xfindIndex, function findIndex(fn, list) {
+ var idx = 0;
+ var len = list.length;
+ while (idx < len) {
+ if (fn(list[idx])) {
+ return idx;
+ }
+ idx += 1;
+ }
+ return -1;
+ }));
+
+ /**
+ * Returns the last element of the list which matches the predicate, or
+ * `undefined` if no element matches.
+ *
+ * Dispatches to the `findLast` method of the second argument, if present.
+ *
+ * Acts as a transducer if a transformer is given in list position.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.1
+ * @category List
+ * @sig (a -> Boolean) -> [a] -> a | undefined
+ * @param {Function} fn The predicate function used to determine if the element is the
+ * desired one.
+ * @param {Array} list The array to consider.
+ * @return {Object} The element found, or `undefined`.
+ * @see R.transduce
+ * @example
+ *
+ * var xs = [{a: 1, b: 0}, {a:1, b: 1}];
+ * R.findLast(R.propEq('a', 1))(xs); //=> {a: 1, b: 1}
+ * R.findLast(R.propEq('a', 4))(xs); //=> undefined
+ */
+ var findLast = _curry2(_dispatchable('findLast', _xfindLast, function findLast(fn, list) {
+ var idx = list.length - 1;
+ while (idx >= 0) {
+ if (fn(list[idx])) {
+ return list[idx];
+ }
+ idx -= 1;
+ }
+ }));
+
+ /**
+ * Returns the index of the last element of the list which matches the
+ * predicate, or `-1` if no element matches.
+ *
+ * Dispatches to the `findLastIndex` method of the second argument, if present.
+ *
+ * Acts as a transducer if a transformer is given in list position.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.1
+ * @category List
+ * @sig (a -> Boolean) -> [a] -> Number
+ * @param {Function} fn The predicate function used to determine if the element is the
+ * desired one.
+ * @param {Array} list The array to consider.
+ * @return {Number} The index of the element found, or `-1`.
+ * @see R.transduce
+ * @example
+ *
+ * var xs = [{a: 1, b: 0}, {a:1, b: 1}];
+ * R.findLastIndex(R.propEq('a', 1))(xs); //=> 1
+ * R.findLastIndex(R.propEq('a', 4))(xs); //=> -1
+ */
+ var findLastIndex = _curry2(_dispatchable('findLastIndex', _xfindLastIndex, function findLastIndex(fn, list) {
+ var idx = list.length - 1;
+ while (idx >= 0) {
+ if (fn(list[idx])) {
+ return idx;
+ }
+ idx -= 1;
+ }
+ return -1;
+ }));
+
+ /**
+ * Iterate over an input `list`, calling a provided function `fn` for each
+ * element in the list.
+ *
+ * `fn` receives one argument: *(value)*.
+ *
+ * Note: `R.forEach` does not skip deleted or unassigned indices (sparse
+ * arrays), unlike the native `Array.prototype.forEach` method. For more
+ * details on this behavior, see:
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach#Description
+ *
+ * Also note that, unlike `Array.prototype.forEach`, Ramda's `forEach` returns
+ * the original array. In some libraries this function is named `each`.
+ *
+ * Dispatches to the `forEach` method of the second argument, if present.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.1
+ * @category List
+ * @sig (a -> *) -> [a] -> [a]
+ * @param {Function} fn The function to invoke. Receives one argument, `value`.
+ * @param {Array} list The list to iterate over.
+ * @return {Array} The original list.
+ * @see R.addIndex
+ * @example
+ *
+ * var printXPlusFive = x => console.log(x + 5);
+ * R.forEach(printXPlusFive, [1, 2, 3]); //=> [1, 2, 3]
+ * //-> 6
+ * //-> 7
+ * //-> 8
+ */
+ var forEach = _curry2(_checkForMethod('forEach', function forEach(fn, list) {
+ var len = list.length;
+ var idx = 0;
+ while (idx < len) {
+ fn(list[idx]);
+ idx += 1;
+ }
+ return list;
+ }));
+
+ /**
+ * Creates a new object out of a list key-value pairs.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.3.0
+ * @category List
+ * @sig [[k,v]] -> {k: v}
+ * @param {Array} pairs An array of two-element arrays that will be the keys and values of the output object.
+ * @return {Object} The object made by pairing up `keys` and `values`.
+ * @see R.toPairs, R.pair
+ * @example
+ *
+ * R.fromPairs([['a', 1], ['b', 2], ['c', 3]]); //=> {a: 1, b: 2, c: 3}
+ */
+ var fromPairs = _curry1(function fromPairs(pairs) {
+ var idx = 0;
+ var len = pairs.length;
+ var out = {};
+ while (idx < len) {
+ if (_isArray(pairs[idx]) && pairs[idx].length) {
+ out[pairs[idx][0]] = pairs[idx][1];
+ }
+ idx += 1;
+ }
+ return out;
+ });
+
+ /**
+ * Returns `true` if the first argument is greater than the second; `false`
+ * otherwise.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Relation
+ * @sig Ord a => a -> a -> Boolean
+ * @param {*} a
+ * @param {*} b
+ * @return {Boolean}
+ * @see R.lt
+ * @example
+ *
+ * R.gt(2, 1); //=> true
+ * R.gt(2, 2); //=> false
+ * R.gt(2, 3); //=> false
+ * R.gt('a', 'z'); //=> false
+ * R.gt('z', 'a'); //=> true
+ */
+ var gt = _curry2(function gt(a, b) {
+ return a > b;
+ });
+
+ /**
+ * Returns `true` if the first argument is greater than or equal to the second;
+ * `false` otherwise.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Relation
+ * @sig Ord a => a -> a -> Boolean
+ * @param {Number} a
+ * @param {Number} b
+ * @return {Boolean}
+ * @see R.lte
+ * @example
+ *
+ * R.gte(2, 1); //=> true
+ * R.gte(2, 2); //=> true
+ * R.gte(2, 3); //=> false
+ * R.gte('a', 'z'); //=> false
+ * R.gte('z', 'a'); //=> true
+ */
+ var gte = _curry2(function gte(a, b) {
+ return a >= b;
+ });
+
+ /**
+ * Returns whether or not an object has an own property with the specified name
+ *
+ * @func
+ * @memberOf R
+ * @since v0.7.0
+ * @category Object
+ * @sig s -> {s: x} -> Boolean
+ * @param {String} prop The name of the property to check for.
+ * @param {Object} obj The object to query.
+ * @return {Boolean} Whether the property exists.
+ * @example
+ *
+ * var hasName = R.has('name');
+ * hasName({name: 'alice'}); //=> true
+ * hasName({name: 'bob'}); //=> true
+ * hasName({}); //=> false
+ *
+ * var point = {x: 0, y: 0};
+ * var pointHas = R.has(R.__, point);
+ * pointHas('x'); //=> true
+ * pointHas('y'); //=> true
+ * pointHas('z'); //=> false
+ */
+ var has = _curry2(_has);
+
+ /**
+ * Returns whether or not an object or its prototype chain has a property with
+ * the specified name
+ *
+ * @func
+ * @memberOf R
+ * @since v0.7.0
+ * @category Object
+ * @sig s -> {s: x} -> Boolean
+ * @param {String} prop The name of the property to check for.
+ * @param {Object} obj The object to query.
+ * @return {Boolean} Whether the property exists.
+ * @example
+ *
+ * function Rectangle(width, height) {
+ * this.width = width;
+ * this.height = height;
+ * }
+ * Rectangle.prototype.area = function() {
+ * return this.width * this.height;
+ * };
+ *
+ * var square = new Rectangle(2, 2);
+ * R.hasIn('width', square); //=> true
+ * R.hasIn('area', square); //=> true
+ */
+ var hasIn = _curry2(function hasIn(prop, obj) {
+ return prop in obj;
+ });
+
+ /**
+ * Returns true if its arguments are identical, false otherwise. Values are
+ * identical if they reference the same memory. `NaN` is identical to `NaN`;
+ * `0` and `-0` are not identical.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.15.0
+ * @category Relation
+ * @sig a -> a -> Boolean
+ * @param {*} a
+ * @param {*} b
+ * @return {Boolean}
+ * @example
+ *
+ * var o = {};
+ * R.identical(o, o); //=> true
+ * R.identical(1, 1); //=> true
+ * R.identical(1, '1'); //=> false
+ * R.identical([], []); //=> false
+ * R.identical(0, -0); //=> false
+ * R.identical(NaN, NaN); //=> true
+ */
+ // SameValue algorithm
+ // Steps 1-5, 7-10
+ // Steps 6.b-6.e: +0 != -0
+ // Step 6.a: NaN == NaN
+ var identical = _curry2(function identical(a, b) {
+ // SameValue algorithm
+ if (a === b) {
+ // Steps 1-5, 7-10
+ // Steps 6.b-6.e: +0 != -0
+ return a !== 0 || 1 / a === 1 / b;
+ } else {
+ // Step 6.a: NaN == NaN
+ return a !== a && b !== b;
+ }
+ });
+
+ /**
+ * A function that does nothing but return the parameter supplied to it. Good
+ * as a default or placeholder function.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Function
+ * @sig a -> a
+ * @param {*} x The value to return.
+ * @return {*} The input value, `x`.
+ * @example
+ *
+ * R.identity(1); //=> 1
+ *
+ * var obj = {};
+ * R.identity(obj) === obj; //=> true
+ */
+ var identity = _curry1(_identity);
+
+ /**
+ * Creates a function that will process either the `onTrue` or the `onFalse`
+ * function depending upon the result of the `condition` predicate.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.8.0
+ * @category Logic
+ * @sig (*... -> Boolean) -> (*... -> *) -> (*... -> *) -> (*... -> *)
+ * @param {Function} condition A predicate function
+ * @param {Function} onTrue A function to invoke when the `condition` evaluates to a truthy value.
+ * @param {Function} onFalse A function to invoke when the `condition` evaluates to a falsy value.
+ * @return {Function} A new unary function that will process either the `onTrue` or the `onFalse`
+ * function depending upon the result of the `condition` predicate.
+ * @see R.unless, R.when
+ * @example
+ *
+ * var incCount = R.ifElse(
+ * R.has('count'),
+ * R.over(R.lensProp('count'), R.inc),
+ * R.assoc('count', 1)
+ * );
+ * incCount({}); //=> { count: 1 }
+ * incCount({ count: 1 }); //=> { count: 2 }
+ */
+ var ifElse = _curry3(function ifElse(condition, onTrue, onFalse) {
+ return curryN(Math.max(condition.length, onTrue.length, onFalse.length), function _ifElse() {
+ return condition.apply(this, arguments) ? onTrue.apply(this, arguments) : onFalse.apply(this, arguments);
+ });
+ });
+
+ /**
+ * Increments its argument.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.9.0
+ * @category Math
+ * @sig Number -> Number
+ * @param {Number} n
+ * @return {Number}
+ * @see R.dec
+ * @example
+ *
+ * R.inc(42); //=> 43
+ */
+ var inc = add(1);
+
+ /**
+ * Inserts the supplied element into the list, at index `index`. _Note that
+ * this is not destructive_: it returns a copy of the list with the changes.
+ * No lists have been harmed in the application of this function.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.2.2
+ * @category List
+ * @sig Number -> a -> [a] -> [a]
+ * @param {Number} index The position to insert the element
+ * @param {*} elt The element to insert into the Array
+ * @param {Array} list The list to insert into
+ * @return {Array} A new Array with `elt` inserted at `index`.
+ * @example
+ *
+ * R.insert(2, 'x', [1,2,3,4]); //=> [1,2,'x',3,4]
+ */
+ var insert = _curry3(function insert(idx, elt, list) {
+ idx = idx < list.length && idx >= 0 ? idx : list.length;
+ var result = _slice(list);
+ result.splice(idx, 0, elt);
+ return result;
+ });
+
+ /**
+ * Inserts the sub-list into the list, at index `index`. _Note that this is not
+ * destructive_: it returns a copy of the list with the changes.
+ * No lists have been harmed in the application of this function.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.9.0
+ * @category List
+ * @sig Number -> [a] -> [a] -> [a]
+ * @param {Number} index The position to insert the sub-list
+ * @param {Array} elts The sub-list to insert into the Array
+ * @param {Array} list The list to insert the sub-list into
+ * @return {Array} A new Array with `elts` inserted starting at `index`.
+ * @example
+ *
+ * R.insertAll(2, ['x','y','z'], [1,2,3,4]); //=> [1,2,'x','y','z',3,4]
+ */
+ var insertAll = _curry3(function insertAll(idx, elts, list) {
+ idx = idx < list.length && idx >= 0 ? idx : list.length;
+ return _concat(_concat(_slice(list, 0, idx), elts), _slice(list, idx));
+ });
+
+ /**
+ * Creates a new list with the separator interposed between elements.
+ *
+ * Dispatches to the `intersperse` method of the second argument, if present.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.14.0
+ * @category List
+ * @sig a -> [a] -> [a]
+ * @param {*} separator The element to add to the list.
+ * @param {Array} list The list to be interposed.
+ * @return {Array} The new list.
+ * @example
+ *
+ * R.intersperse('n', ['ba', 'a', 'a']); //=> ['ba', 'n', 'a', 'n', 'a']
+ */
+ var intersperse = _curry2(_checkForMethod('intersperse', function intersperse(separator, list) {
+ var out = [];
+ var idx = 0;
+ var length = list.length;
+ while (idx < length) {
+ if (idx === length - 1) {
+ out.push(list[idx]);
+ } else {
+ out.push(list[idx], separator);
+ }
+ idx += 1;
+ }
+ return out;
+ }));
+
+ /**
+ * See if an object (`val`) is an instance of the supplied constructor. This
+ * function will check up the inheritance chain, if any.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.3.0
+ * @category Type
+ * @sig (* -> {*}) -> a -> Boolean
+ * @param {Object} ctor A constructor
+ * @param {*} val The value to test
+ * @return {Boolean}
+ * @example
+ *
+ * R.is(Object, {}); //=> true
+ * R.is(Number, 1); //=> true
+ * R.is(Object, 1); //=> false
+ * R.is(String, 's'); //=> true
+ * R.is(String, new String('')); //=> true
+ * R.is(Object, new String('')); //=> true
+ * R.is(Object, 's'); //=> false
+ * R.is(Number, {}); //=> false
+ */
+ var is = _curry2(function is(Ctor, val) {
+ return val != null && val.constructor === Ctor || val instanceof Ctor;
+ });
+
+ /**
+ * Tests whether or not an object is similar to an array.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.5.0
+ * @category Type
+ * @category List
+ * @sig * -> Boolean
+ * @param {*} x The object to test.
+ * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise.
+ * @example
+ *
+ * R.isArrayLike([]); //=> true
+ * R.isArrayLike(true); //=> false
+ * R.isArrayLike({}); //=> false
+ * R.isArrayLike({length: 10}); //=> false
+ * R.isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true
+ */
+ var isArrayLike = _curry1(function isArrayLike(x) {
+ if (_isArray(x)) {
+ return true;
+ }
+ if (!x) {
+ return false;
+ }
+ if (typeof x !== 'object') {
+ return false;
+ }
+ if (x instanceof String) {
+ return false;
+ }
+ if (x.nodeType === 1) {
+ return !!x.length;
+ }
+ if (x.length === 0) {
+ return true;
+ }
+ if (x.length > 0) {
+ return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);
+ }
+ return false;
+ });
+
+ /**
+ * Checks if the input value is `null` or `undefined`.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.9.0
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} x The value to test.
+ * @return {Boolean} `true` if `x` is `undefined` or `null`, otherwise `false`.
+ * @example
+ *
+ * R.isNil(null); //=> true
+ * R.isNil(undefined); //=> true
+ * R.isNil(0); //=> false
+ * R.isNil([]); //=> false
+ */
+ var isNil = _curry1(function isNil(x) {
+ return x == null;
+ });
+
+ /**
+ * Returns a list containing the names of all the enumerable own properties of
+ * the supplied object.
+ * Note that the order of the output array is not guaranteed to be consistent
+ * across different JS platforms.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Object
+ * @sig {k: v} -> [k]
+ * @param {Object} obj The object to extract properties from
+ * @return {Array} An array of the object's own properties.
+ * @example
+ *
+ * R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c']
+ */
+ // cover IE < 9 keys issues
+ // Safari bug
+ var keys = function () {
+ // cover IE < 9 keys issues
+ var hasEnumBug = !{ toString: null }.propertyIsEnumerable('toString');
+ var nonEnumerableProps = [
+ 'constructor',
+ 'valueOf',
+ 'isPrototypeOf',
+ 'toString',
+ 'propertyIsEnumerable',
+ 'hasOwnProperty',
+ 'toLocaleString'
+ ];
+ // Safari bug
+ var hasArgsEnumBug = function () {
+ 'use strict';
+ return arguments.propertyIsEnumerable('length');
+ }();
+ var contains = function contains(list, item) {
+ var idx = 0;
+ while (idx < list.length) {
+ if (list[idx] === item) {
+ return true;
+ }
+ idx += 1;
+ }
+ return false;
+ };
+ return typeof Object.keys === 'function' && !hasArgsEnumBug ? _curry1(function keys(obj) {
+ return Object(obj) !== obj ? [] : Object.keys(obj);
+ }) : _curry1(function keys(obj) {
+ if (Object(obj) !== obj) {
+ return [];
+ }
+ var prop, nIdx;
+ var ks = [];
+ var checkArgsLength = hasArgsEnumBug && _isArguments(obj);
+ for (prop in obj) {
+ if (_has(prop, obj) && (!checkArgsLength || prop !== 'length')) {
+ ks[ks.length] = prop;
+ }
+ }
+ if (hasEnumBug) {
+ nIdx = nonEnumerableProps.length - 1;
+ while (nIdx >= 0) {
+ prop = nonEnumerableProps[nIdx];
+ if (_has(prop, obj) && !contains(ks, prop)) {
+ ks[ks.length] = prop;
+ }
+ nIdx -= 1;
+ }
+ }
+ return ks;
+ });
+ }();
+
+ /**
+ * Returns a list containing the names of all the properties of the supplied
+ * object, including prototype properties.
+ * Note that the order of the output array is not guaranteed to be consistent
+ * across different JS platforms.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.2.0
+ * @category Object
+ * @sig {k: v} -> [k]
+ * @param {Object} obj The object to extract properties from
+ * @return {Array} An array of the object's own and prototype properties.
+ * @example
+ *
+ * var F = function() { this.x = 'X'; };
+ * F.prototype.y = 'Y';
+ * var f = new F();
+ * R.keysIn(f); //=> ['x', 'y']
+ */
+ var keysIn = _curry1(function keysIn(obj) {
+ var prop;
+ var ks = [];
+ for (prop in obj) {
+ ks[ks.length] = prop;
+ }
+ return ks;
+ });
+
+ /**
+ * Returns the number of elements in the array by returning `list.length`.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.3.0
+ * @category List
+ * @sig [a] -> Number
+ * @param {Array} list The array to inspect.
+ * @return {Number} The length of the array.
+ * @example
+ *
+ * R.length([]); //=> 0
+ * R.length([1, 2, 3]); //=> 3
+ */
+ var length = _curry1(function length(list) {
+ return list != null && is(Number, list.length) ? list.length : NaN;
+ });
+
+ /**
+ * Returns `true` if the first argument is less than the second; `false`
+ * otherwise.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Relation
+ * @sig Ord a => a -> a -> Boolean
+ * @param {*} a
+ * @param {*} b
+ * @return {Boolean}
+ * @see R.gt
+ * @example
+ *
+ * R.lt(2, 1); //=> false
+ * R.lt(2, 2); //=> false
+ * R.lt(2, 3); //=> true
+ * R.lt('a', 'z'); //=> true
+ * R.lt('z', 'a'); //=> false
+ */
+ var lt = _curry2(function lt(a, b) {
+ return a < b;
+ });
+
+ /**
+ * Returns `true` if the first argument is less than or equal to the second;
+ * `false` otherwise.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Relation
+ * @sig Ord a => a -> a -> Boolean
+ * @param {Number} a
+ * @param {Number} b
+ * @return {Boolean}
+ * @see R.gte
+ * @example
+ *
+ * R.lte(2, 1); //=> false
+ * R.lte(2, 2); //=> true
+ * R.lte(2, 3); //=> true
+ * R.lte('a', 'z'); //=> true
+ * R.lte('z', 'a'); //=> false
+ */
+ var lte = _curry2(function lte(a, b) {
+ return a <= b;
+ });
+
+ /**
+ * The mapAccum function behaves like a combination of map and reduce; it
+ * applies a function to each element of a list, passing an accumulating
+ * parameter from left to right, and returning a final value of this
+ * accumulator together with the new list.
+ *
+ * The iterator function receives two arguments, *acc* and *value*, and should
+ * return a tuple *[acc, value]*.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.10.0
+ * @category List
+ * @sig (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])
+ * @param {Function} fn The function to be called on every element of the input `list`.
+ * @param {*} acc The accumulator value.
+ * @param {Array} list The list to iterate over.
+ * @return {*} The final, accumulated value.
+ * @see R.addIndex
+ * @example
+ *
+ * var digits = ['1', '2', '3', '4'];
+ * var append = (a, b) => [a + b, a + b];
+ *
+ * R.mapAccum(append, 0, digits); //=> ['01234', ['01', '012', '0123', '01234']]
+ */
+ var mapAccum = _curry3(function mapAccum(fn, acc, list) {
+ var idx = 0;
+ var len = list.length;
+ var result = [];
+ var tuple = [acc];
+ while (idx < len) {
+ tuple = fn(tuple[0], list[idx]);
+ result[idx] = tuple[1];
+ idx += 1;
+ }
+ return [
+ tuple[0],
+ result
+ ];
+ });
+
+ /**
+ * The mapAccumRight function behaves like a combination of map and reduce; it
+ * applies a function to each element of a list, passing an accumulating
+ * parameter from right to left, and returning a final value of this
+ * accumulator together with the new list.
+ *
+ * Similar to `mapAccum`, except moves through the input list from the right to
+ * the left.
+ *
+ * The iterator function receives two arguments, *acc* and *value*, and should
+ * return a tuple *[acc, value]*.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.10.0
+ * @category List
+ * @sig (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])
+ * @param {Function} fn The function to be called on every element of the input `list`.
+ * @param {*} acc The accumulator value.
+ * @param {Array} list The list to iterate over.
+ * @return {*} The final, accumulated value.
+ * @see R.addIndex
+ * @example
+ *
+ * var digits = ['1', '2', '3', '4'];
+ * var append = (a, b) => [a + b, a + b];
+ *
+ * R.mapAccumRight(append, 0, digits); //=> ['04321', ['04321', '0432', '043', '04']]
+ */
+ var mapAccumRight = _curry3(function mapAccumRight(fn, acc, list) {
+ var idx = list.length - 1;
+ var result = [];
+ var tuple = [acc];
+ while (idx >= 0) {
+ tuple = fn(tuple[0], list[idx]);
+ result[idx] = tuple[1];
+ idx -= 1;
+ }
+ return [
+ tuple[0],
+ result
+ ];
+ });
+
+ /**
+ * Tests a regular expression against a String. Note that this function will
+ * return an empty array when there are no matches. This differs from
+ * [`String.prototype.match`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match)
+ * which returns `null` when there are no matches.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category String
+ * @sig RegExp -> String -> [String | Undefined]
+ * @param {RegExp} rx A regular expression.
+ * @param {String} str The string to match against
+ * @return {Array} The list of matches or empty array.
+ * @see R.test
+ * @example
+ *
+ * R.match(/([a-z]a)/g, 'bananas'); //=> ['ba', 'na', 'na']
+ * R.match(/a/, 'b'); //=> []
+ * R.match(/a/, null); //=> TypeError: null does not have a method named "match"
+ */
+ var match = _curry2(function match(rx, str) {
+ return str.match(rx) || [];
+ });
+
+ /**
+ * mathMod behaves like the modulo operator should mathematically, unlike the
+ * `%` operator (and by extension, R.modulo). So while "-17 % 5" is -2,
+ * mathMod(-17, 5) is 3. mathMod requires Integer arguments, and returns NaN
+ * when the modulus is zero or negative.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.3.0
+ * @category Math
+ * @sig Number -> Number -> Number
+ * @param {Number} m The dividend.
+ * @param {Number} p the modulus.
+ * @return {Number} The result of `b mod a`.
+ * @example
+ *
+ * R.mathMod(-17, 5); //=> 3
+ * R.mathMod(17, 5); //=> 2
+ * R.mathMod(17, -5); //=> NaN
+ * R.mathMod(17, 0); //=> NaN
+ * R.mathMod(17.2, 5); //=> NaN
+ * R.mathMod(17, 5.3); //=> NaN
+ *
+ * var clock = R.mathMod(R.__, 12);
+ * clock(15); //=> 3
+ * clock(24); //=> 0
+ *
+ * var seventeenMod = R.mathMod(17);
+ * seventeenMod(3); //=> 2
+ * seventeenMod(4); //=> 1
+ * seventeenMod(10); //=> 7
+ */
+ var mathMod = _curry2(function mathMod(m, p) {
+ if (!_isInteger(m)) {
+ return NaN;
+ }
+ if (!_isInteger(p) || p < 1) {
+ return NaN;
+ }
+ return (m % p + p) % p;
+ });
+
+ /**
+ * Returns the larger of its two arguments.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Relation
+ * @sig Ord a => a -> a -> a
+ * @param {*} a
+ * @param {*} b
+ * @return {*}
+ * @see R.maxBy, R.min
+ * @example
+ *
+ * R.max(789, 123); //=> 789
+ * R.max('a', 'b'); //=> 'b'
+ */
+ var max = _curry2(function max(a, b) {
+ return b > a ? b : a;
+ });
+
+ /**
+ * Takes a function and two values, and returns whichever value produces the
+ * larger result when passed to the provided function.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.8.0
+ * @category Relation
+ * @sig Ord b => (a -> b) -> a -> a -> a
+ * @param {Function} f
+ * @param {*} a
+ * @param {*} b
+ * @return {*}
+ * @see R.max, R.minBy
+ * @example
+ *
+ * // square :: Number -> Number
+ * var square = n => n * n;
+ *
+ * R.maxBy(square, -3, 2); //=> -3
+ *
+ * R.reduce(R.maxBy(square), 0, [3, -5, 4, 1, -2]); //=> -5
+ * R.reduce(R.maxBy(square), 0, []); //=> 0
+ */
+ var maxBy = _curry3(function maxBy(f, a, b) {
+ return f(b) > f(a) ? b : a;
+ });
+
+ /**
+ * Creates a new object with the own properties of the two provided objects. If
+ * a key exists in both objects, the provided function is applied to the key
+ * and the values associated with the key in each object, with the result being
+ * used as the value associated with the key in the returned object. The key
+ * will be excluded from the returned object if the resulting value is
+ * `undefined`.
+ *
+ * @func
+ * @memberOf R
+ * @since 0.19.1
+ * @since 0.19.0
+ * @category Object
+ * @sig (String -> a -> a -> a) -> {a} -> {a} -> {a}
+ * @param {Function} fn
+ * @param {Object} l
+ * @param {Object} r
+ * @return {Object}
+ * @see R.merge, R.mergeWith
+ * @example
+ *
+ * let concatValues = (k, l, r) => k == 'values' ? R.concat(l, r) : r
+ * R.mergeWithKey(concatValues,
+ * { a: true, thing: 'foo', values: [10, 20] },
+ * { b: true, thing: 'bar', values: [15, 35] });
+ * //=> { a: true, b: true, thing: 'bar', values: [10, 20, 15, 35] }
+ */
+ var mergeWithKey = _curry3(function mergeWithKey(fn, l, r) {
+ var result = {};
+ var k;
+ for (k in l) {
+ if (_has(k, l)) {
+ result[k] = _has(k, r) ? fn(k, l[k], r[k]) : l[k];
+ }
+ }
+ for (k in r) {
+ if (_has(k, r) && !_has(k, result)) {
+ result[k] = r[k];
+ }
+ }
+ return result;
+ });
+
+ /**
+ * Returns the smaller of its two arguments.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Relation
+ * @sig Ord a => a -> a -> a
+ * @param {*} a
+ * @param {*} b
+ * @return {*}
+ * @see R.minBy, R.max
+ * @example
+ *
+ * R.min(789, 123); //=> 123
+ * R.min('a', 'b'); //=> 'a'
+ */
+ var min = _curry2(function min(a, b) {
+ return b < a ? b : a;
+ });
+
+ /**
+ * Takes a function and two values, and returns whichever value produces the
+ * smaller result when passed to the provided function.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.8.0
+ * @category Relation
+ * @sig Ord b => (a -> b) -> a -> a -> a
+ * @param {Function} f
+ * @param {*} a
+ * @param {*} b
+ * @return {*}
+ * @see R.min, R.maxBy
+ * @example
+ *
+ * // square :: Number -> Number
+ * var square = n => n * n;
+ *
+ * R.minBy(square, -3, 2); //=> 2
+ *
+ * R.reduce(R.minBy(square), Infinity, [3, -5, 4, 1, -2]); //=> 1
+ * R.reduce(R.minBy(square), Infinity, []); //=> Infinity
+ */
+ var minBy = _curry3(function minBy(f, a, b) {
+ return f(b) < f(a) ? b : a;
+ });
+
+ /**
+ * Divides the second parameter by the first and returns the remainder. Note
+ * that this function preserves the JavaScript-style behavior for modulo. For
+ * mathematical modulo see `mathMod`.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.1
+ * @category Math
+ * @sig Number -> Number -> Number
+ * @param {Number} a The value to the divide.
+ * @param {Number} b The pseudo-modulus
+ * @return {Number} The result of `b % a`.
+ * @see R.mathMod
+ * @example
+ *
+ * R.modulo(17, 3); //=> 2
+ * // JS behavior:
+ * R.modulo(-17, 3); //=> -2
+ * R.modulo(17, -3); //=> 2
+ *
+ * var isOdd = R.modulo(R.__, 2);
+ * isOdd(42); //=> 0
+ * isOdd(21); //=> 1
+ */
+ var modulo = _curry2(function modulo(a, b) {
+ return a % b;
+ });
+
+ /**
+ * Multiplies two numbers. Equivalent to `a * b` but curried.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Math
+ * @sig Number -> Number -> Number
+ * @param {Number} a The first value.
+ * @param {Number} b The second value.
+ * @return {Number} The result of `a * b`.
+ * @see R.divide
+ * @example
+ *
+ * var double = R.multiply(2);
+ * var triple = R.multiply(3);
+ * double(3); //=> 6
+ * triple(4); //=> 12
+ * R.multiply(2, 5); //=> 10
+ */
+ var multiply = _curry2(function multiply(a, b) {
+ return a * b;
+ });
+
+ /**
+ * Wraps a function of any arity (including nullary) in a function that accepts
+ * exactly `n` parameters. Any extraneous parameters will not be passed to the
+ * supplied function.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Function
+ * @sig Number -> (* -> a) -> (* -> a)
+ * @param {Number} n The desired arity of the new function.
+ * @param {Function} fn The function to wrap.
+ * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of
+ * arity `n`.
+ * @example
+ *
+ * var takesTwoArgs = (a, b) => [a, b];
+ *
+ * takesTwoArgs.length; //=> 2
+ * takesTwoArgs(1, 2); //=> [1, 2]
+ *
+ * var takesOneArg = R.nAry(1, takesTwoArgs);
+ * takesOneArg.length; //=> 1
+ * // Only `n` arguments are passed to the wrapped function
+ * takesOneArg(1, 2); //=> [1, undefined]
+ */
+ var nAry = _curry2(function nAry(n, fn) {
+ switch (n) {
+ case 0:
+ return function () {
+ return fn.call(this);
+ };
+ case 1:
+ return function (a0) {
+ return fn.call(this, a0);
+ };
+ case 2:
+ return function (a0, a1) {
+ return fn.call(this, a0, a1);
+ };
+ case 3:
+ return function (a0, a1, a2) {
+ return fn.call(this, a0, a1, a2);
+ };
+ case 4:
+ return function (a0, a1, a2, a3) {
+ return fn.call(this, a0, a1, a2, a3);
+ };
+ case 5:
+ return function (a0, a1, a2, a3, a4) {
+ return fn.call(this, a0, a1, a2, a3, a4);
+ };
+ case 6:
+ return function (a0, a1, a2, a3, a4, a5) {
+ return fn.call(this, a0, a1, a2, a3, a4, a5);
+ };
+ case 7:
+ return function (a0, a1, a2, a3, a4, a5, a6) {
+ return fn.call(this, a0, a1, a2, a3, a4, a5, a6);
+ };
+ case 8:
+ return function (a0, a1, a2, a3, a4, a5, a6, a7) {
+ return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7);
+ };
+ case 9:
+ return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {
+ return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8);
+ };
+ case 10:
+ return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
+ return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
+ };
+ default:
+ throw new Error('First argument to nAry must be a non-negative integer no greater than ten');
+ }
+ });
+
+ /**
+ * Negates its argument.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.9.0
+ * @category Math
+ * @sig Number -> Number
+ * @param {Number} n
+ * @return {Number}
+ * @example
+ *
+ * R.negate(42); //=> -42
+ */
+ var negate = _curry1(function negate(n) {
+ return -n;
+ });
+
+ /**
+ * Returns `true` if no elements of the list match the predicate, `false`
+ * otherwise.
+ *
+ * Dispatches to the `any` method of the second argument, if present.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.12.0
+ * @category List
+ * @sig (a -> Boolean) -> [a] -> Boolean
+ * @param {Function} fn The predicate function.
+ * @param {Array} list The array to consider.
+ * @return {Boolean} `true` if the predicate is not satisfied by every element, `false` otherwise.
+ * @see R.all, R.any
+ * @example
+ *
+ * var isEven = n => n % 2 === 0;
+ *
+ * R.none(isEven, [1, 3, 5, 7, 9, 11]); //=> true
+ * R.none(isEven, [1, 3, 5, 7, 8, 11]); //=> false
+ */
+ var none = _curry2(_complement(_dispatchable('any', _xany, any)));
+
+ /**
+ * A function that returns the `!` of its argument. It will return `true` when
+ * passed false-y value, and `false` when passed a truth-y one.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Logic
+ * @sig * -> Boolean
+ * @param {*} a any value
+ * @return {Boolean} the logical inverse of passed argument.
+ * @see R.complement
+ * @example
+ *
+ * R.not(true); //=> false
+ * R.not(false); //=> true
+ * R.not(0); => true
+ * R.not(1); => false
+ */
+ var not = _curry1(function not(a) {
+ return !a;
+ });
+
+ /**
+ * Returns the nth element of the given list or string. If n is negative the
+ * element at index length + n is returned.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category List
+ * @sig Number -> [a] -> a | Undefined
+ * @sig Number -> String -> String
+ * @param {Number} offset
+ * @param {*} list
+ * @return {*}
+ * @example
+ *
+ * var list = ['foo', 'bar', 'baz', 'quux'];
+ * R.nth(1, list); //=> 'bar'
+ * R.nth(-1, list); //=> 'quux'
+ * R.nth(-99, list); //=> undefined
+ *
+ * R.nth('abc', 2); //=> 'c'
+ * R.nth('abc', 3); //=> ''
+ */
+ var nth = _curry2(function nth(offset, list) {
+ var idx = offset < 0 ? list.length + offset : offset;
+ return _isString(list) ? list.charAt(idx) : list[idx];
+ });
+
+ /**
+ * Returns a function which returns its nth argument.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.9.0
+ * @category Function
+ * @sig Number -> *... -> *
+ * @param {Number} n
+ * @return {Function}
+ * @example
+ *
+ * R.nthArg(1)('a', 'b', 'c'); //=> 'b'
+ * R.nthArg(-1)('a', 'b', 'c'); //=> 'c'
+ */
+ var nthArg = _curry1(function nthArg(n) {
+ return function () {
+ return nth(n, arguments);
+ };
+ });
+
+ /**
+ * Creates an object containing a single key:value pair.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.18.0
+ * @category Object
+ * @sig String -> a -> {String:a}
+ * @param {String} key
+ * @param {*} val
+ * @return {Object}
+ * @see R.pair
+ * @example
+ *
+ * var matchPhrases = R.compose(
+ * R.objOf('must'),
+ * R.map(R.objOf('match_phrase'))
+ * );
+ * matchPhrases(['foo', 'bar', 'baz']); //=> {must: [{match_phrase: 'foo'}, {match_phrase: 'bar'}, {match_phrase: 'baz'}]}
+ */
+ var objOf = _curry2(function objOf(key, val) {
+ var obj = {};
+ obj[key] = val;
+ return obj;
+ });
+
+ /**
+ * Returns a singleton array containing the value provided.
+ *
+ * Note this `of` is different from the ES6 `of`; See
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/of
+ *
+ * @func
+ * @memberOf R
+ * @since v0.3.0
+ * @category Function
+ * @sig a -> [a]
+ * @param {*} x any value
+ * @return {Array} An array wrapping `x`.
+ * @example
+ *
+ * R.of(null); //=> [null]
+ * R.of([42]); //=> [[42]]
+ */
+ var of = _curry1(_of);
+
+ /**
+ * Accepts a function `fn` and returns a function that guards invocation of
+ * `fn` such that `fn` can only ever be called once, no matter how many times
+ * the returned function is invoked. The first value calculated is returned in
+ * subsequent invocations.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Function
+ * @sig (a... -> b) -> (a... -> b)
+ * @param {Function} fn The function to wrap in a call-only-once wrapper.
+ * @return {Function} The wrapped function.
+ * @example
+ *
+ * var addOneOnce = R.once(x => x + 1);
+ * addOneOnce(10); //=> 11
+ * addOneOnce(addOneOnce(50)); //=> 11
+ */
+ var once = _curry1(function once(fn) {
+ var called = false;
+ var result;
+ return _arity(fn.length, function () {
+ if (called) {
+ return result;
+ }
+ called = true;
+ result = fn.apply(this, arguments);
+ return result;
+ });
+ });
+
+ /**
+ * Returns `true` if one or both of its arguments are `true`. Returns `false`
+ * if both arguments are `false`.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Logic
+ * @sig * -> * -> *
+ * @param {Boolean} a A boolean value
+ * @param {Boolean} b A boolean value
+ * @return {Boolean} `true` if one or both arguments are `true`, `false` otherwise
+ * @see R.either
+ * @example
+ *
+ * R.or(true, true); //=> true
+ * R.or(true, false); //=> true
+ * R.or(false, true); //=> true
+ * R.or(false, false); //=> false
+ */
+ var or = _curry2(function or(a, b) {
+ return a || b;
+ });
+
+ /**
+ * Returns the result of "setting" the portion of the given data structure
+ * focused by the given lens to the result of applying the given function to
+ * the focused value.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.16.0
+ * @category Object
+ * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s
+ * @sig Lens s a -> (a -> a) -> s -> s
+ * @param {Lens} lens
+ * @param {*} v
+ * @param {*} x
+ * @return {*}
+ * @see R.prop, R.lensIndex, R.lensProp
+ * @example
+ *
+ * var headLens = R.lensIndex(0);
+ *
+ * R.over(headLens, R.toUpper, ['foo', 'bar', 'baz']); //=> ['FOO', 'bar', 'baz']
+ */
+ var over = function () {
+ var Identity = function (x) {
+ return {
+ value: x,
+ map: function (f) {
+ return Identity(f(x));
+ }
+ };
+ };
+ return _curry3(function over(lens, f, x) {
+ return lens(function (y) {
+ return Identity(f(y));
+ })(x).value;
+ });
+ }();
+
+ /**
+ * Takes two arguments, `fst` and `snd`, and returns `[fst, snd]`.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.18.0
+ * @category List
+ * @sig a -> b -> (a,b)
+ * @param {*} fst
+ * @param {*} snd
+ * @return {Array}
+ * @see R.createMapEntry, R.of
+ * @example
+ *
+ * R.pair('foo', 'bar'); //=> ['foo', 'bar']
+ */
+ var pair = _curry2(function pair(fst, snd) {
+ return [
+ fst,
+ snd
+ ];
+ });
+
+ /**
+ * Retrieve the value at a given path.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.2.0
+ * @category Object
+ * @sig [String] -> {k: v} -> v | Undefined
+ * @param {Array} path The path to use.
+ * @param {Object} obj The object to retrieve the nested property from.
+ * @return {*} The data at `path`.
+ * @example
+ *
+ * R.path(['a', 'b'], {a: {b: 2}}); //=> 2
+ * R.path(['a', 'b'], {c: {b: 2}}); //=> undefined
+ */
+ var path = _curry2(function path(paths, obj) {
+ var val = obj;
+ var idx = 0;
+ while (idx < paths.length) {
+ if (val == null) {
+ return;
+ }
+ val = val[paths[idx]];
+ idx += 1;
+ }
+ return val;
+ });
+
+ /**
+ * If the given, non-null object has a value at the given path, returns the
+ * value at that path. Otherwise returns the provided default value.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.18.0
+ * @category Object
+ * @sig a -> [String] -> Object -> a
+ * @param {*} d The default value.
+ * @param {Array} p The path to use.
+ * @param {Object} obj The object to retrieve the nested property from.
+ * @return {*} The data at `path` of the supplied object or the default value.
+ * @example
+ *
+ * R.pathOr('N/A', ['a', 'b'], {a: {b: 2}}); //=> 2
+ * R.pathOr('N/A', ['a', 'b'], {c: {b: 2}}); //=> "N/A"
+ */
+ var pathOr = _curry3(function pathOr(d, p, obj) {
+ return defaultTo(d, path(p, obj));
+ });
+
+ /**
+ * Returns `true` if the specified object property at given path satisfies the
+ * given predicate; `false` otherwise.
+ *
+ * @func
+ * @memberOf R
+ * @since 0.19.1
+ * @since 0.19.0
+ * @category Logic
+ * @sig (a -> Boolean) -> [String] -> Object -> Boolean
+ * @param {Function} pred
+ * @param {Array} propPath
+ * @param {*} obj
+ * @return {Boolean}
+ * @see R.propSatisfies, R.path
+ * @example
+ *
+ * R.pathSatisfies(y => y > 0, ['x', 'y'], {x: {y: 2}}); //=> true
+ */
+ var pathSatisfies = _curry3(function pathSatisfies(pred, propPath, obj) {
+ return propPath.length > 0 && pred(path(propPath, obj));
+ });
+
+ /**
+ * Returns a partial copy of an object containing only the keys specified. If
+ * the key does not exist, the property is ignored.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Object
+ * @sig [k] -> {k: v} -> {k: v}
+ * @param {Array} names an array of String property names to copy onto a new object
+ * @param {Object} obj The object to copy from
+ * @return {Object} A new object with only properties from `names` on it.
+ * @see R.omit, R.props
+ * @example
+ *
+ * R.pick(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}
+ * R.pick(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1}
+ */
+ var pick = _curry2(function pick(names, obj) {
+ var result = {};
+ var idx = 0;
+ while (idx < names.length) {
+ if (names[idx] in obj) {
+ result[names[idx]] = obj[names[idx]];
+ }
+ idx += 1;
+ }
+ return result;
+ });
+
+ /**
+ * Similar to `pick` except that this one includes a `key: undefined` pair for
+ * properties that don't exist.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Object
+ * @sig [k] -> {k: v} -> {k: v}
+ * @param {Array} names an array of String property names to copy onto a new object
+ * @param {Object} obj The object to copy from
+ * @return {Object} A new object with only properties from `names` on it.
+ * @see R.pick
+ * @example
+ *
+ * R.pickAll(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}
+ * R.pickAll(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, e: undefined, f: undefined}
+ */
+ var pickAll = _curry2(function pickAll(names, obj) {
+ var result = {};
+ var idx = 0;
+ var len = names.length;
+ while (idx < len) {
+ var name = names[idx];
+ result[name] = obj[name];
+ idx += 1;
+ }
+ return result;
+ });
+
+ /**
+ * Returns a partial copy of an object containing only the keys that satisfy
+ * the supplied predicate.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.8.0
+ * @category Object
+ * @sig (v, k -> Boolean) -> {k: v} -> {k: v}
+ * @param {Function} pred A predicate to determine whether or not a key
+ * should be included on the output object.
+ * @param {Object} obj The object to copy from
+ * @return {Object} A new object with only properties that satisfy `pred`
+ * on it.
+ * @see R.pick, R.filter
+ * @example
+ *
+ * var isUpperCase = (val, key) => key.toUpperCase() === key;
+ * R.pickBy(isUpperCase, {a: 1, b: 2, A: 3, B: 4}); //=> {A: 3, B: 4}
+ */
+ var pickBy = _curry2(function pickBy(test, obj) {
+ var result = {};
+ for (var prop in obj) {
+ if (test(obj[prop], prop, obj)) {
+ result[prop] = obj[prop];
+ }
+ }
+ return result;
+ });
+
+ /**
+ * Returns a new list with the given element at the front, followed by the
+ * contents of the list.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category List
+ * @sig a -> [a] -> [a]
+ * @param {*} el The item to add to the head of the output list.
+ * @param {Array} list The array to add to the tail of the output list.
+ * @return {Array} A new array.
+ * @see R.append
+ * @example
+ *
+ * R.prepend('fee', ['fi', 'fo', 'fum']); //=> ['fee', 'fi', 'fo', 'fum']
+ */
+ var prepend = _curry2(function prepend(el, list) {
+ return _concat([el], list);
+ });
+
+ /**
+ * Returns a function that when supplied an object returns the indicated
+ * property of that object, if it exists.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Object
+ * @sig s -> {s: a} -> a | Undefined
+ * @param {String} p The property name
+ * @param {Object} obj The object to query
+ * @return {*} The value at `obj.p`.
+ * @example
+ *
+ * R.prop('x', {x: 100}); //=> 100
+ * R.prop('x', {}); //=> undefined
+ */
+ var prop = _curry2(function prop(p, obj) {
+ return obj[p];
+ });
+
+ /**
+ * If the given, non-null object has an own property with the specified name,
+ * returns the value of that property. Otherwise returns the provided default
+ * value.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.6.0
+ * @category Object
+ * @sig a -> String -> Object -> a
+ * @param {*} val The default value.
+ * @param {String} p The name of the property to return.
+ * @param {Object} obj The object to query.
+ * @return {*} The value of given property of the supplied object or the default value.
+ * @example
+ *
+ * var alice = {
+ * name: 'ALICE',
+ * age: 101
+ * };
+ * var favorite = R.prop('favoriteLibrary');
+ * var favoriteWithDefault = R.propOr('Ramda', 'favoriteLibrary');
+ *
+ * favorite(alice); //=> undefined
+ * favoriteWithDefault(alice); //=> 'Ramda'
+ */
+ var propOr = _curry3(function propOr(val, p, obj) {
+ return obj != null && _has(p, obj) ? obj[p] : val;
+ });
+
+ /**
+ * Returns `true` if the specified object property satisfies the given
+ * predicate; `false` otherwise.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.16.0
+ * @category Logic
+ * @sig (a -> Boolean) -> String -> {String: a} -> Boolean
+ * @param {Function} pred
+ * @param {String} name
+ * @param {*} obj
+ * @return {Boolean}
+ * @see R.propEq, R.propIs
+ * @example
+ *
+ * R.propSatisfies(x => x > 0, 'x', {x: 1, y: 2}); //=> true
+ */
+ var propSatisfies = _curry3(function propSatisfies(pred, name, obj) {
+ return pred(obj[name]);
+ });
+
+ /**
+ * Acts as multiple `prop`: array of keys in, array of values out. Preserves
+ * order.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Object
+ * @sig [k] -> {k: v} -> [v]
+ * @param {Array} ps The property names to fetch
+ * @param {Object} obj The object to query
+ * @return {Array} The corresponding values or partially applied function.
+ * @example
+ *
+ * R.props(['x', 'y'], {x: 1, y: 2}); //=> [1, 2]
+ * R.props(['c', 'a', 'b'], {b: 2, a: 1}); //=> [undefined, 1, 2]
+ *
+ * var fullName = R.compose(R.join(' '), R.props(['first', 'last']));
+ * fullName({last: 'Bullet-Tooth', age: 33, first: 'Tony'}); //=> 'Tony Bullet-Tooth'
+ */
+ var props = _curry2(function props(ps, obj) {
+ var len = ps.length;
+ var out = [];
+ var idx = 0;
+ while (idx < len) {
+ out[idx] = obj[ps[idx]];
+ idx += 1;
+ }
+ return out;
+ });
+
+ /**
+ * Returns a list of numbers from `from` (inclusive) to `to` (exclusive).
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category List
+ * @sig Number -> Number -> [Number]
+ * @param {Number} from The first number in the list.
+ * @param {Number} to One more than the last number in the list.
+ * @return {Array} The list of numbers in tthe set `[a, b)`.
+ * @example
+ *
+ * R.range(1, 5); //=> [1, 2, 3, 4]
+ * R.range(50, 53); //=> [50, 51, 52]
+ */
+ var range = _curry2(function range(from, to) {
+ if (!(_isNumber(from) && _isNumber(to))) {
+ throw new TypeError('Both arguments to range must be numbers');
+ }
+ var result = [];
+ var n = from;
+ while (n < to) {
+ result.push(n);
+ n += 1;
+ }
+ return result;
+ });
+
+ /**
+ * Returns a single item by iterating through the list, successively calling
+ * the iterator function and passing it an accumulator value and the current
+ * value from the array, and then passing the result to the next call.
+ *
+ * Similar to `reduce`, except moves through the input list from the right to
+ * the left.
+ *
+ * The iterator function receives two values: *(acc, value)*
+ *
+ * Note: `R.reduceRight` does not skip deleted or unassigned indices (sparse
+ * arrays), unlike the native `Array.prototype.reduce` method. For more details
+ * on this behavior, see:
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight#Description
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category List
+ * @sig (a,b -> a) -> a -> [b] -> a
+ * @param {Function} fn The iterator function. Receives two values, the accumulator and the
+ * current element from the array.
+ * @param {*} acc The accumulator value.
+ * @param {Array} list The list to iterate over.
+ * @return {*} The final, accumulated value.
+ * @see R.addIndex
+ * @example
+ *
+ * var pairs = [ ['a', 1], ['b', 2], ['c', 3] ];
+ * var flattenPairs = (acc, pair) => acc.concat(pair);
+ *
+ * R.reduceRight(flattenPairs, [], pairs); //=> [ 'c', 3, 'b', 2, 'a', 1 ]
+ */
+ var reduceRight = _curry3(function reduceRight(fn, acc, list) {
+ var idx = list.length - 1;
+ while (idx >= 0) {
+ acc = fn(acc, list[idx]);
+ idx -= 1;
+ }
+ return acc;
+ });
+
+ /**
+ * Returns a value wrapped to indicate that it is the final value of the reduce
+ * and transduce functions. The returned value should be considered a black
+ * box: the internal structure is not guaranteed to be stable.
+ *
+ * Note: this optimization is unavailable to functions not explicitly listed
+ * above. For instance, it is not currently supported by reduceRight.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.15.0
+ * @category List
+ * @sig a -> *
+ * @param {*} x The final value of the reduce.
+ * @return {*} The wrapped value.
+ * @see R.reduce, R.transduce
+ * @example
+ *
+ * R.reduce(
+ * R.pipe(R.add, R.when(R.gte(R.__, 10), R.reduced)),
+ * 0,
+ * [1, 2, 3, 4, 5]) // 10
+ */
+ var reduced = _curry1(_reduced);
+
+ /**
+ * Removes the sub-list of `list` starting at index `start` and containing
+ * `count` elements. _Note that this is not destructive_: it returns a copy of
+ * the list with the changes.
+ * No lists have been harmed in the application of this function.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.2.2
+ * @category List
+ * @sig Number -> Number -> [a] -> [a]
+ * @param {Number} start The position to start removing elements
+ * @param {Number} count The number of elements to remove
+ * @param {Array} list The list to remove from
+ * @return {Array} A new Array with `count` elements from `start` removed.
+ * @example
+ *
+ * R.remove(2, 3, [1,2,3,4,5,6,7,8]); //=> [1,2,6,7,8]
+ */
+ var remove = _curry3(function remove(start, count, list) {
+ return _concat(_slice(list, 0, Math.min(start, list.length)), _slice(list, Math.min(list.length, start + count)));
+ });
+
+ /**
+ * Replace a substring or regex match in a string with a replacement.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.7.0
+ * @category String
+ * @sig RegExp|String -> String -> String -> String
+ * @param {RegExp|String} pattern A regular expression or a substring to match.
+ * @param {String} replacement The string to replace the matches with.
+ * @param {String} str The String to do the search and replacement in.
+ * @return {String} The result.
+ * @example
+ *
+ * R.replace('foo', 'bar', 'foo foo foo'); //=> 'bar foo foo'
+ * R.replace(/foo/, 'bar', 'foo foo foo'); //=> 'bar foo foo'
+ *
+ * // Use the "g" (global) flag to replace all occurrences:
+ * R.replace(/foo/g, 'bar', 'foo foo foo'); //=> 'bar bar bar'
+ */
+ var replace = _curry3(function replace(regex, replacement, str) {
+ return str.replace(regex, replacement);
+ });
+
+ /**
+ * Returns a new list or string with the elements or characters in reverse
+ * order.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category List
+ * @sig [a] -> [a]
+ * @sig String -> String
+ * @param {Array|String} list
+ * @return {Array|String}
+ * @example
+ *
+ * R.reverse([1, 2, 3]); //=> [3, 2, 1]
+ * R.reverse([1, 2]); //=> [2, 1]
+ * R.reverse([1]); //=> [1]
+ * R.reverse([]); //=> []
+ *
+ * R.reverse('abc'); //=> 'cba'
+ * R.reverse('ab'); //=> 'ba'
+ * R.reverse('a'); //=> 'a'
+ * R.reverse(''); //=> ''
+ */
+ var reverse = _curry1(function reverse(list) {
+ return _isString(list) ? list.split('').reverse().join('') : _slice(list).reverse();
+ });
+
+ /**
+ * Scan is similar to reduce, but returns a list of successively reduced values
+ * from the left
+ *
+ * @func
+ * @memberOf R
+ * @since v0.10.0
+ * @category List
+ * @sig (a,b -> a) -> a -> [b] -> [a]
+ * @param {Function} fn The iterator function. Receives two values, the accumulator and the
+ * current element from the array
+ * @param {*} acc The accumulator value.
+ * @param {Array} list The list to iterate over.
+ * @return {Array} A list of all intermediately reduced values.
+ * @example
+ *
+ * var numbers = [1, 2, 3, 4];
+ * var factorials = R.scan(R.multiply, 1, numbers); //=> [1, 1, 2, 6, 24]
+ */
+ var scan = _curry3(function scan(fn, acc, list) {
+ var idx = 0;
+ var len = list.length;
+ var result = [acc];
+ while (idx < len) {
+ acc = fn(acc, list[idx]);
+ result[idx + 1] = acc;
+ idx += 1;
+ }
+ return result;
+ });
+
+ /**
+ * Returns the result of "setting" the portion of the given data structure
+ * focused by the given lens to the given value.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.16.0
+ * @category Object
+ * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s
+ * @sig Lens s a -> a -> s -> s
+ * @param {Lens} lens
+ * @param {*} v
+ * @param {*} x
+ * @return {*}
+ * @see R.prop, R.lensIndex, R.lensProp
+ * @example
+ *
+ * var xLens = R.lensProp('x');
+ *
+ * R.set(xLens, 4, {x: 1, y: 2}); //=> {x: 4, y: 2}
+ * R.set(xLens, 8, {x: 1, y: 2}); //=> {x: 8, y: 2}
+ */
+ var set = _curry3(function set(lens, v, x) {
+ return over(lens, always(v), x);
+ });
+
+ /**
+ * Returns the elements of the given list or string (or object with a `slice`
+ * method) from `fromIndex` (inclusive) to `toIndex` (exclusive).
+ *
+ * Dispatches to the `slice` method of the third argument, if present.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.4
+ * @category List
+ * @sig Number -> Number -> [a] -> [a]
+ * @sig Number -> Number -> String -> String
+ * @param {Number} fromIndex The start index (inclusive).
+ * @param {Number} toIndex The end index (exclusive).
+ * @param {*} list
+ * @return {*}
+ * @example
+ *
+ * R.slice(1, 3, ['a', 'b', 'c', 'd']); //=> ['b', 'c']
+ * R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd']
+ * R.slice(0, -1, ['a', 'b', 'c', 'd']); //=> ['a', 'b', 'c']
+ * R.slice(-3, -1, ['a', 'b', 'c', 'd']); //=> ['b', 'c']
+ * R.slice(0, 3, 'ramda'); //=> 'ram'
+ */
+ var slice = _curry3(_checkForMethod('slice', function slice(fromIndex, toIndex, list) {
+ return Array.prototype.slice.call(list, fromIndex, toIndex);
+ }));
+
+ /**
+ * Returns a copy of the list, sorted according to the comparator function,
+ * which should accept two values at a time and return a negative number if the
+ * first value is smaller, a positive number if it's larger, and zero if they
+ * are equal. Please note that this is a **copy** of the list. It does not
+ * modify the original.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category List
+ * @sig (a,a -> Number) -> [a] -> [a]
+ * @param {Function} comparator A sorting function :: a -> b -> Int
+ * @param {Array} list The list to sort
+ * @return {Array} a new array with its elements sorted by the comparator function.
+ * @example
+ *
+ * var diff = function(a, b) { return a - b; };
+ * R.sort(diff, [4,2,7,5]); //=> [2, 4, 5, 7]
+ */
+ var sort = _curry2(function sort(comparator, list) {
+ return _slice(list).sort(comparator);
+ });
+
+ /**
+ * Sorts the list according to the supplied function.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Relation
+ * @sig Ord b => (a -> b) -> [a] -> [a]
+ * @param {Function} fn
+ * @param {Array} list The list to sort.
+ * @return {Array} A new list sorted by the keys generated by `fn`.
+ * @example
+ *
+ * var sortByFirstItem = R.sortBy(R.prop(0));
+ * var sortByNameCaseInsensitive = R.sortBy(R.compose(R.toLower, R.prop('name')));
+ * var pairs = [[-1, 1], [-2, 2], [-3, 3]];
+ * sortByFirstItem(pairs); //=> [[-3, 3], [-2, 2], [-1, 1]]
+ * var alice = {
+ * name: 'ALICE',
+ * age: 101
+ * };
+ * var bob = {
+ * name: 'Bob',
+ * age: -10
+ * };
+ * var clara = {
+ * name: 'clara',
+ * age: 314.159
+ * };
+ * var people = [clara, bob, alice];
+ * sortByNameCaseInsensitive(people); //=> [alice, bob, clara]
+ */
+ var sortBy = _curry2(function sortBy(fn, list) {
+ return _slice(list).sort(function (a, b) {
+ var aa = fn(a);
+ var bb = fn(b);
+ return aa < bb ? -1 : aa > bb ? 1 : 0;
+ });
+ });
+
+ /**
+ * Splits a given list or string at a given index.
+ *
+ * @func
+ * @memberOf R
+ * @since 0.19.1
+ * @since 0.19.0
+ * @category List
+ * @sig Number -> [a] -> [[a], [a]]
+ * @sig Number -> String -> [String, String]
+ * @param {Number} index The index where the array/string is split.
+ * @param {Array|String} array The array/string to be split.
+ * @return {Array}
+ * @example
+ *
+ * R.splitAt(1, [1, 2, 3]); //=> [[1], [2, 3]]
+ * R.splitAt(5, 'hello world'); //=> ['hello', ' world']
+ * R.splitAt(-1, 'foobar'); //=> ['fooba', 'r']
+ */
+ var splitAt = _curry2(function splitAt(index, array) {
+ return [
+ slice(0, index, array),
+ slice(index, length(array), array)
+ ];
+ });
+
+ /**
+ * Splits a collection into slices of the specified length.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.16.0
+ * @category List
+ * @sig Number -> [a] -> [[a]]
+ * @sig Number -> String -> [String]
+ * @param {Number} n
+ * @param {Array} list
+ * @return {Array}
+ * @example
+ *
+ * R.splitEvery(3, [1, 2, 3, 4, 5, 6, 7]); //=> [[1, 2, 3], [4, 5, 6], [7]]
+ * R.splitEvery(3, 'foobarbaz'); //=> ['foo', 'bar', 'baz']
+ */
+ var splitEvery = _curry2(function splitEvery(n, list) {
+ if (n <= 0) {
+ throw new Error('First argument to splitEvery must be a positive integer');
+ }
+ var result = [];
+ var idx = 0;
+ while (idx < list.length) {
+ result.push(slice(idx, idx += n, list));
+ }
+ return result;
+ });
+
+ /**
+ * Takes a list and a predicate and returns a pair of lists with the following properties:
+ *
+ * - the result of concatenating the two output lists is equivalent to the input list;
+ * - none of the elements of the first output list satisfies the predicate; and
+ * - if the second output list is non-empty, its first element satisfies the predicate.
+ *
+ * @func
+ * @memberOf R
+ * @since 0.19.1
+ * @since 0.19.0
+ * @category List
+ * @sig (a -> Boolean) -> [a] -> [[a], [a]]
+ * @param {Function} pred The predicate that determines where the array is split.
+ * @param {Array} list The array to be split.
+ * @return {Array}
+ * @example
+ *
+ * R.splitWhen(R.equals(2), [1, 2, 3, 1, 2, 3]); //=> [[1], [2, 3, 1, 2, 3]]
+ */
+ var splitWhen = _curry2(function splitWhen(pred, list) {
+ var idx = 0;
+ var len = list.length;
+ var prefix = [];
+ while (idx < len && !pred(list[idx])) {
+ prefix.push(list[idx]);
+ idx += 1;
+ }
+ return [
+ prefix,
+ _slice(list, idx)
+ ];
+ });
+
+ /**
+ * Subtracts two numbers. Equivalent to `a - b` but curried.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Math
+ * @sig Number -> Number -> Number
+ * @param {Number} a The first value.
+ * @param {Number} b The second value.
+ * @return {Number} The result of `a - b`.
+ * @see R.add
+ * @example
+ *
+ * R.subtract(10, 8); //=> 2
+ *
+ * var minus5 = R.subtract(R.__, 5);
+ * minus5(17); //=> 12
+ *
+ * var complementaryAngle = R.subtract(90);
+ * complementaryAngle(30); //=> 60
+ * complementaryAngle(72); //=> 18
+ */
+ var subtract = _curry2(function subtract(a, b) {
+ return a - b;
+ });
+
+ /**
+ * Returns all but the first element of the given list or string (or object
+ * with a `tail` method).
+ *
+ * Dispatches to the `slice` method of the first argument, if present.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category List
+ * @sig [a] -> [a]
+ * @sig String -> String
+ * @param {*} list
+ * @return {*}
+ * @see R.head, R.init, R.last
+ * @example
+ *
+ * R.tail([1, 2, 3]); //=> [2, 3]
+ * R.tail([1, 2]); //=> [2]
+ * R.tail([1]); //=> []
+ * R.tail([]); //=> []
+ *
+ * R.tail('abc'); //=> 'bc'
+ * R.tail('ab'); //=> 'b'
+ * R.tail('a'); //=> ''
+ * R.tail(''); //=> ''
+ */
+ var tail = _checkForMethod('tail', slice(1, Infinity));
+
+ /**
+ * Returns the first `n` elements of the given list, string, or
+ * transducer/transformer (or object with a `take` method).
+ *
+ * Dispatches to the `take` method of the second argument, if present.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category List
+ * @sig Number -> [a] -> [a]
+ * @sig Number -> String -> String
+ * @param {Number} n
+ * @param {*} list
+ * @return {*}
+ * @see R.drop
+ * @example
+ *
+ * R.take(1, ['foo', 'bar', 'baz']); //=> ['foo']
+ * R.take(2, ['foo', 'bar', 'baz']); //=> ['foo', 'bar']
+ * R.take(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']
+ * R.take(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']
+ * R.take(3, 'ramda'); //=> 'ram'
+ *
+ * var personnel = [
+ * 'Dave Brubeck',
+ * 'Paul Desmond',
+ * 'Eugene Wright',
+ * 'Joe Morello',
+ * 'Gerry Mulligan',
+ * 'Bob Bates',
+ * 'Joe Dodge',
+ * 'Ron Crotty'
+ * ];
+ *
+ * var takeFive = R.take(5);
+ * takeFive(personnel);
+ * //=> ['Dave Brubeck', 'Paul Desmond', 'Eugene Wright', 'Joe Morello', 'Gerry Mulligan']
+ */
+ var take = _curry2(_dispatchable('take', _xtake, function take(n, xs) {
+ return slice(0, n < 0 ? Infinity : n, xs);
+ }));
+
+ /**
+ * Returns a new list containing the last `n` elements of a given list, passing
+ * each value to the supplied predicate function, and terminating when the
+ * predicate function returns `false`. Excludes the element that caused the
+ * predicate function to fail. The predicate function is passed one argument:
+ * *(value)*.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.16.0
+ * @category List
+ * @sig (a -> Boolean) -> [a] -> [a]
+ * @param {Function} fn The function called per iteration.
+ * @param {Array} list The collection to iterate over.
+ * @return {Array} A new array.
+ * @see R.dropLastWhile, R.addIndex
+ * @example
+ *
+ * var isNotOne = x => x !== 1;
+ *
+ * R.takeLastWhile(isNotOne, [1, 2, 3, 4]); //=> [2, 3, 4]
+ */
+ var takeLastWhile = _curry2(function takeLastWhile(fn, list) {
+ var idx = list.length - 1;
+ while (idx >= 0 && fn(list[idx])) {
+ idx -= 1;
+ }
+ return _slice(list, idx + 1, Infinity);
+ });
+
+ /**
+ * Returns a new list containing the first `n` elements of a given list,
+ * passing each value to the supplied predicate function, and terminating when
+ * the predicate function returns `false`. Excludes the element that caused the
+ * predicate function to fail. The predicate function is passed one argument:
+ * *(value)*.
+ *
+ * Dispatches to the `takeWhile` method of the second argument, if present.
+ *
+ * Acts as a transducer if a transformer is given in list position.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category List
+ * @sig (a -> Boolean) -> [a] -> [a]
+ * @param {Function} fn The function called per iteration.
+ * @param {Array} list The collection to iterate over.
+ * @return {Array} A new array.
+ * @see R.dropWhile, R.transduce, R.addIndex
+ * @example
+ *
+ * var isNotFour = x => x !== 4;
+ *
+ * R.takeWhile(isNotFour, [1, 2, 3, 4, 3, 2, 1]); //=> [1, 2, 3]
+ */
+ var takeWhile = _curry2(_dispatchable('takeWhile', _xtakeWhile, function takeWhile(fn, list) {
+ var idx = 0;
+ var len = list.length;
+ while (idx < len && fn(list[idx])) {
+ idx += 1;
+ }
+ return _slice(list, 0, idx);
+ }));
+
+ /**
+ * Runs the given function with the supplied object, then returns the object.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Function
+ * @sig (a -> *) -> a -> a
+ * @param {Function} fn The function to call with `x`. The return value of `fn` will be thrown away.
+ * @param {*} x
+ * @return {*} `x`.
+ * @example
+ *
+ * var sayX = x => console.log('x is ' + x);
+ * R.tap(sayX, 100); //=> 100
+ * //-> 'x is 100'
+ */
+ var tap = _curry2(function tap(fn, x) {
+ fn(x);
+ return x;
+ });
+
+ /**
+ * Calls an input function `n` times, returning an array containing the results
+ * of those function calls.
+ *
+ * `fn` is passed one argument: The current value of `n`, which begins at `0`
+ * and is gradually incremented to `n - 1`.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.2.3
+ * @category List
+ * @sig (Number -> a) -> Number -> [a]
+ * @param {Function} fn The function to invoke. Passed one argument, the current value of `n`.
+ * @param {Number} n A value between `0` and `n - 1`. Increments after each function call.
+ * @return {Array} An array containing the return values of all calls to `fn`.
+ * @example
+ *
+ * R.times(R.identity, 5); //=> [0, 1, 2, 3, 4]
+ */
+ var times = _curry2(function times(fn, n) {
+ var len = Number(n);
+ var idx = 0;
+ var list;
+ if (len < 0 || isNaN(len)) {
+ throw new RangeError('n must be a non-negative number');
+ }
+ list = new Array(len);
+ while (idx < len) {
+ list[idx] = fn(idx);
+ idx += 1;
+ }
+ return list;
+ });
+
+ /**
+ * Converts an object into an array of key, value arrays. Only the object's
+ * own properties are used.
+ * Note that the order of the output array is not guaranteed to be consistent
+ * across different JS platforms.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.4.0
+ * @category Object
+ * @sig {String: *} -> [[String,*]]
+ * @param {Object} obj The object to extract from
+ * @return {Array} An array of key, value arrays from the object's own properties.
+ * @see R.fromPairs
+ * @example
+ *
+ * R.toPairs({a: 1, b: 2, c: 3}); //=> [['a', 1], ['b', 2], ['c', 3]]
+ */
+ var toPairs = _curry1(function toPairs(obj) {
+ var pairs = [];
+ for (var prop in obj) {
+ if (_has(prop, obj)) {
+ pairs[pairs.length] = [
+ prop,
+ obj[prop]
+ ];
+ }
+ }
+ return pairs;
+ });
+
+ /**
+ * Converts an object into an array of key, value arrays. The object's own
+ * properties and prototype properties are used. Note that the order of the
+ * output array is not guaranteed to be consistent across different JS
+ * platforms.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.4.0
+ * @category Object
+ * @sig {String: *} -> [[String,*]]
+ * @param {Object} obj The object to extract from
+ * @return {Array} An array of key, value arrays from the object's own
+ * and prototype properties.
+ * @example
+ *
+ * var F = function() { this.x = 'X'; };
+ * F.prototype.y = 'Y';
+ * var f = new F();
+ * R.toPairsIn(f); //=> [['x','X'], ['y','Y']]
+ */
+ var toPairsIn = _curry1(function toPairsIn(obj) {
+ var pairs = [];
+ for (var prop in obj) {
+ pairs[pairs.length] = [
+ prop,
+ obj[prop]
+ ];
+ }
+ return pairs;
+ });
+
+ /**
+ * Transposes the rows and columns of a 2D list.
+ * When passed a list of `n` lists of length `x`,
+ * returns a list of `x` lists of length `n`.
+ *
+ *
+ * @func
+ * @memberOf R
+ * @since 0.19.1
+ * @since 0.19.0
+ * @category List
+ * @sig [[a]] -> [[a]]
+ * @param {Array} list A 2D list
+ * @return {Array} A 2D list
+ * @example
+ *
+ * R.transpose([[1, 'a'], [2, 'b'], [3, 'c']]) //=> [[1, 2, 3], ['a', 'b', 'c']]
+ * R.transpose([[1, 2, 3], ['a', 'b', 'c']]) //=> [[1, 'a'], [2, 'b'], [3, 'c']]
+ *
+ * If some of the rows are shorter than the following rows, their elements are skipped:
+ *
+ * R.transpose([[10, 11], [20], [], [30, 31, 32]]) //=> [[10, 20, 30], [11, 31], [32]]
+ */
+ var transpose = _curry1(function transpose(outerlist) {
+ var i = 0;
+ var result = [];
+ while (i < outerlist.length) {
+ var innerlist = outerlist[i];
+ var j = 0;
+ while (j < innerlist.length) {
+ if (typeof result[j] === 'undefined') {
+ result[j] = [];
+ }
+ result[j].push(innerlist[j]);
+ j += 1;
+ }
+ i += 1;
+ }
+ return result;
+ });
+
+ /**
+ * Removes (strips) whitespace from both ends of the string.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.6.0
+ * @category String
+ * @sig String -> String
+ * @param {String} str The string to trim.
+ * @return {String} Trimmed version of `str`.
+ * @example
+ *
+ * R.trim(' xyz '); //=> 'xyz'
+ * R.map(R.trim, R.split(',', 'x, y, z')); //=> ['x', 'y', 'z']
+ */
+ var trim = function () {
+ var ws = '\t\n\x0B\f\r \xA0\u1680\u180E\u2000\u2001\u2002\u2003' + '\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028' + '\u2029\uFEFF';
+ var zeroWidth = '\u200B';
+ var hasProtoTrim = typeof String.prototype.trim === 'function';
+ if (!hasProtoTrim || (ws.trim() || !zeroWidth.trim())) {
+ return _curry1(function trim(str) {
+ var beginRx = new RegExp('^[' + ws + '][' + ws + ']*');
+ var endRx = new RegExp('[' + ws + '][' + ws + ']*$');
+ return str.replace(beginRx, '').replace(endRx, '');
+ });
+ } else {
+ return _curry1(function trim(str) {
+ return str.trim();
+ });
+ }
+ }();
+
+ /**
+ * Gives a single-word string description of the (native) type of a value,
+ * returning such answers as 'Object', 'Number', 'Array', or 'Null'. Does not
+ * attempt to distinguish user Object types any further, reporting them all as
+ * 'Object'.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.8.0
+ * @category Type
+ * @sig (* -> {*}) -> String
+ * @param {*} val The value to test
+ * @return {String}
+ * @example
+ *
+ * R.type({}); //=> "Object"
+ * R.type(1); //=> "Number"
+ * R.type(false); //=> "Boolean"
+ * R.type('s'); //=> "String"
+ * R.type(null); //=> "Null"
+ * R.type([]); //=> "Array"
+ * R.type(/[A-z]/); //=> "RegExp"
+ */
+ var type = _curry1(function type(val) {
+ return val === null ? 'Null' : val === undefined ? 'Undefined' : Object.prototype.toString.call(val).slice(8, -1);
+ });
+
+ /**
+ * Takes a function `fn`, which takes a single array argument, and returns a
+ * function which:
+ *
+ * - takes any number of positional arguments;
+ * - passes these arguments to `fn` as an array; and
+ * - returns the result.
+ *
+ * In other words, R.unapply derives a variadic function from a function which
+ * takes an array. R.unapply is the inverse of R.apply.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.8.0
+ * @category Function
+ * @sig ([*...] -> a) -> (*... -> a)
+ * @param {Function} fn
+ * @return {Function}
+ * @see R.apply
+ * @example
+ *
+ * R.unapply(JSON.stringify)(1, 2, 3); //=> '[1,2,3]'
+ */
+ var unapply = _curry1(function unapply(fn) {
+ return function () {
+ return fn(_slice(arguments));
+ };
+ });
+
+ /**
+ * Wraps a function of any arity (including nullary) in a function that accepts
+ * exactly 1 parameter. Any extraneous parameters will not be passed to the
+ * supplied function.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.2.0
+ * @category Function
+ * @sig (* -> b) -> (a -> b)
+ * @param {Function} fn The function to wrap.
+ * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of
+ * arity 1.
+ * @example
+ *
+ * var takesTwoArgs = function(a, b) {
+ * return [a, b];
+ * };
+ * takesTwoArgs.length; //=> 2
+ * takesTwoArgs(1, 2); //=> [1, 2]
+ *
+ * var takesOneArg = R.unary(takesTwoArgs);
+ * takesOneArg.length; //=> 1
+ * // Only 1 argument is passed to the wrapped function
+ * takesOneArg(1, 2); //=> [1, undefined]
+ */
+ var unary = _curry1(function unary(fn) {
+ return nAry(1, fn);
+ });
+
+ /**
+ * Returns a function of arity `n` from a (manually) curried function.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.14.0
+ * @category Function
+ * @sig Number -> (a -> b) -> (a -> c)
+ * @param {Number} length The arity for the returned function.
+ * @param {Function} fn The function to uncurry.
+ * @return {Function} A new function.
+ * @see R.curry
+ * @example
+ *
+ * var addFour = a => b => c => d => a + b + c + d;
+ *
+ * var uncurriedAddFour = R.uncurryN(4, addFour);
+ * uncurriedAddFour(1, 2, 3, 4); //=> 10
+ */
+ var uncurryN = _curry2(function uncurryN(depth, fn) {
+ return curryN(depth, function () {
+ var currentDepth = 1;
+ var value = fn;
+ var idx = 0;
+ var endIdx;
+ while (currentDepth <= depth && typeof value === 'function') {
+ endIdx = currentDepth === depth ? arguments.length : idx + value.length;
+ value = value.apply(this, _slice(arguments, idx, endIdx));
+ currentDepth += 1;
+ idx = endIdx;
+ }
+ return value;
+ });
+ });
+
+ /**
+ * Builds a list from a seed value. Accepts an iterator function, which returns
+ * either false to stop iteration or an array of length 2 containing the value
+ * to add to the resulting list and the seed to be used in the next call to the
+ * iterator function.
+ *
+ * The iterator function receives one argument: *(seed)*.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.10.0
+ * @category List
+ * @sig (a -> [b]) -> * -> [b]
+ * @param {Function} fn The iterator function. receives one argument, `seed`, and returns
+ * either false to quit iteration or an array of length two to proceed. The element
+ * at index 0 of this array will be added to the resulting array, and the element
+ * at index 1 will be passed to the next call to `fn`.
+ * @param {*} seed The seed value.
+ * @return {Array} The final list.
+ * @example
+ *
+ * var f = n => n > 50 ? false : [-n, n + 10];
+ * R.unfold(f, 10); //=> [-10, -20, -30, -40, -50]
+ */
+ var unfold = _curry2(function unfold(fn, seed) {
+ var pair = fn(seed);
+ var result = [];
+ while (pair && pair.length) {
+ result[result.length] = pair[0];
+ pair = fn(pair[1]);
+ }
+ return result;
+ });
+
+ /**
+ * Returns a new list containing only one copy of each element in the original
+ * list, based upon the value returned by applying the supplied predicate to
+ * two list elements. Prefers the first item if two items compare equal based
+ * on the predicate.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.2.0
+ * @category List
+ * @sig (a, a -> Boolean) -> [a] -> [a]
+ * @param {Function} pred A predicate used to test whether two items are equal.
+ * @param {Array} list The array to consider.
+ * @return {Array} The list of unique items.
+ * @example
+ *
+ * var strEq = R.eqBy(String);
+ * R.uniqWith(strEq)([1, '1', 2, 1]); //=> [1, 2]
+ * R.uniqWith(strEq)([{}, {}]); //=> [{}]
+ * R.uniqWith(strEq)([1, '1', 1]); //=> [1]
+ * R.uniqWith(strEq)(['1', 1, 1]); //=> ['1']
+ */
+ var uniqWith = _curry2(function uniqWith(pred, list) {
+ var idx = 0;
+ var len = list.length;
+ var result = [];
+ var item;
+ while (idx < len) {
+ item = list[idx];
+ if (!_containsWith(pred, item, result)) {
+ result[result.length] = item;
+ }
+ idx += 1;
+ }
+ return result;
+ });
+
+ /**
+ * Tests the final argument by passing it to the given predicate function. If
+ * the predicate is not satisfied, the function will return the result of
+ * calling the `whenFalseFn` function with the same argument. If the predicate
+ * is satisfied, the argument is returned as is.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.18.0
+ * @category Logic
+ * @sig (a -> Boolean) -> (a -> a) -> a -> a
+ * @param {Function} pred A predicate function
+ * @param {Function} whenFalseFn A function to invoke when the `pred` evaluates
+ * to a falsy value.
+ * @param {*} x An object to test with the `pred` function and
+ * pass to `whenFalseFn` if necessary.
+ * @return {*} Either `x` or the result of applying `x` to `whenFalseFn`.
+ * @see R.ifElse, R.when
+ * @example
+ *
+ * // coerceArray :: (a|[a]) -> [a]
+ * var coerceArray = R.unless(R.isArrayLike, R.of);
+ * coerceArray([1, 2, 3]); //=> [1, 2, 3]
+ * coerceArray(1); //=> [1]
+ */
+ var unless = _curry3(function unless(pred, whenFalseFn, x) {
+ return pred(x) ? x : whenFalseFn(x);
+ });
+
+ /**
+ * Returns a new copy of the array with the element at the provided index
+ * replaced with the given value.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.14.0
+ * @category List
+ * @sig Number -> a -> [a] -> [a]
+ * @param {Number} idx The index to update.
+ * @param {*} x The value to exist at the given index of the returned array.
+ * @param {Array|Arguments} list The source array-like object to be updated.
+ * @return {Array} A copy of `list` with the value at index `idx` replaced with `x`.
+ * @see R.adjust
+ * @example
+ *
+ * R.update(1, 11, [0, 1, 2]); //=> [0, 11, 2]
+ * R.update(1)(11)([0, 1, 2]); //=> [0, 11, 2]
+ */
+ var update = _curry3(function update(idx, x, list) {
+ return adjust(always(x), idx, list);
+ });
+
+ /**
+ * Accepts a function `fn` and a list of transformer functions and returns a
+ * new curried function. When the new function is invoked, it calls the
+ * function `fn` with parameters consisting of the result of calling each
+ * supplied handler on successive arguments to the new function.
+ *
+ * If more arguments are passed to the returned function than transformer
+ * functions, those arguments are passed directly to `fn` as additional
+ * parameters. If you expect additional arguments that don't need to be
+ * transformed, although you can ignore them, it's best to pass an identity
+ * function so that the new function reports the correct arity.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Function
+ * @sig (x1 -> x2 -> ... -> z) -> [(a -> x1), (b -> x2), ...] -> (a -> b -> ... -> z)
+ * @param {Function} fn The function to wrap.
+ * @param {Array} transformers A list of transformer functions
+ * @return {Function} The wrapped function.
+ * @example
+ *
+ * R.useWith(Math.pow, [R.identity, R.identity])(3, 4); //=> 81
+ * R.useWith(Math.pow, [R.identity, R.identity])(3)(4); //=> 81
+ * R.useWith(Math.pow, [R.dec, R.inc])(3, 4); //=> 32
+ * R.useWith(Math.pow, [R.dec, R.inc])(3)(4); //=> 32
+ */
+ var useWith = _curry2(function useWith(fn, transformers) {
+ return curryN(transformers.length, function () {
+ var args = [];
+ var idx = 0;
+ while (idx < transformers.length) {
+ args.push(transformers[idx].call(this, arguments[idx]));
+ idx += 1;
+ }
+ return fn.apply(this, args.concat(_slice(arguments, transformers.length)));
+ });
+ });
+
+ /**
+ * Returns a list of all the enumerable own properties of the supplied object.
+ * Note that the order of the output array is not guaranteed across different
+ * JS platforms.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Object
+ * @sig {k: v} -> [v]
+ * @param {Object} obj The object to extract values from
+ * @return {Array} An array of the values of the object's own properties.
+ * @example
+ *
+ * R.values({a: 1, b: 2, c: 3}); //=> [1, 2, 3]
+ */
+ var values = _curry1(function values(obj) {
+ var props = keys(obj);
+ var len = props.length;
+ var vals = [];
+ var idx = 0;
+ while (idx < len) {
+ vals[idx] = obj[props[idx]];
+ idx += 1;
+ }
+ return vals;
+ });
+
+ /**
+ * Returns a list of all the properties, including prototype properties, of the
+ * supplied object.
+ * Note that the order of the output array is not guaranteed to be consistent
+ * across different JS platforms.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.2.0
+ * @category Object
+ * @sig {k: v} -> [v]
+ * @param {Object} obj The object to extract values from
+ * @return {Array} An array of the values of the object's own and prototype properties.
+ * @example
+ *
+ * var F = function() { this.x = 'X'; };
+ * F.prototype.y = 'Y';
+ * var f = new F();
+ * R.valuesIn(f); //=> ['X', 'Y']
+ */
+ var valuesIn = _curry1(function valuesIn(obj) {
+ var prop;
+ var vs = [];
+ for (prop in obj) {
+ vs[vs.length] = obj[prop];
+ }
+ return vs;
+ });
+
+ /**
+ * Returns a "view" of the given data structure, determined by the given lens.
+ * The lens's focus determines which portion of the data structure is visible.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.16.0
+ * @category Object
+ * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s
+ * @sig Lens s a -> s -> a
+ * @param {Lens} lens
+ * @param {*} x
+ * @return {*}
+ * @see R.prop, R.lensIndex, R.lensProp
+ * @example
+ *
+ * var xLens = R.lensProp('x');
+ *
+ * R.view(xLens, {x: 1, y: 2}); //=> 1
+ * R.view(xLens, {x: 4, y: 2}); //=> 4
+ */
+ var view = function () {
+ var Const = function (x) {
+ return {
+ value: x,
+ map: function () {
+ return this;
+ }
+ };
+ };
+ return _curry2(function view(lens, x) {
+ return lens(Const)(x).value;
+ });
+ }();
+
+ /**
+ * Tests the final argument by passing it to the given predicate function. If
+ * the predicate is satisfied, the function will return the result of calling
+ * the `whenTrueFn` function with the same argument. If the predicate is not
+ * satisfied, the argument is returned as is.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.18.0
+ * @category Logic
+ * @sig (a -> Boolean) -> (a -> a) -> a -> a
+ * @param {Function} pred A predicate function
+ * @param {Function} whenTrueFn A function to invoke when the `condition`
+ * evaluates to a truthy value.
+ * @param {*} x An object to test with the `pred` function and
+ * pass to `whenTrueFn` if necessary.
+ * @return {*} Either `x` or the result of applying `x` to `whenTrueFn`.
+ * @see R.ifElse, R.unless
+ * @example
+ *
+ * // truncate :: String -> String
+ * var truncate = R.when(
+ * R.propSatisfies(R.gt(R.__, 10), 'length'),
+ * R.pipe(R.take(10), R.append('…'), R.join(''))
+ * );
+ * truncate('12345'); //=> '12345'
+ * truncate('0123456789ABC'); //=> '0123456789…'
+ */
+ var when = _curry3(function when(pred, whenTrueFn, x) {
+ return pred(x) ? whenTrueFn(x) : x;
+ });
+
+ /**
+ * Takes a spec object and a test object; returns true if the test satisfies
+ * the spec. Each of the spec's own properties must be a predicate function.
+ * Each predicate is applied to the value of the corresponding property of the
+ * test object. `where` returns true if all the predicates return true, false
+ * otherwise.
+ *
+ * `where` is well suited to declaratively expressing constraints for other
+ * functions such as `filter` and `find`.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.1
+ * @category Object
+ * @sig {String: (* -> Boolean)} -> {String: *} -> Boolean
+ * @param {Object} spec
+ * @param {Object} testObj
+ * @return {Boolean}
+ * @example
+ *
+ * // pred :: Object -> Boolean
+ * var pred = R.where({
+ * a: R.equals('foo'),
+ * b: R.complement(R.equals('bar')),
+ * x: R.gt(_, 10),
+ * y: R.lt(_, 20)
+ * });
+ *
+ * pred({a: 'foo', b: 'xxx', x: 11, y: 19}); //=> true
+ * pred({a: 'xxx', b: 'xxx', x: 11, y: 19}); //=> false
+ * pred({a: 'foo', b: 'bar', x: 11, y: 19}); //=> false
+ * pred({a: 'foo', b: 'xxx', x: 10, y: 19}); //=> false
+ * pred({a: 'foo', b: 'xxx', x: 11, y: 20}); //=> false
+ */
+ var where = _curry2(function where(spec, testObj) {
+ for (var prop in spec) {
+ if (_has(prop, spec) && !spec[prop](testObj[prop])) {
+ return false;
+ }
+ }
+ return true;
+ });
+
+ /**
+ * Wrap a function inside another to allow you to make adjustments to the
+ * parameters, or do other processing either before the internal function is
+ * called or with its results.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Function
+ * @sig (a... -> b) -> ((a... -> b) -> a... -> c) -> (a... -> c)
+ * @param {Function} fn The function to wrap.
+ * @param {Function} wrapper The wrapper function.
+ * @return {Function} The wrapped function.
+ * @example
+ *
+ * var greet = name => 'Hello ' + name;
+ *
+ * var shoutedGreet = R.wrap(greet, (gr, name) => gr(name).toUpperCase());
+ *
+ * shoutedGreet("Kathy"); //=> "HELLO KATHY"
+ *
+ * var shortenedGreet = R.wrap(greet, function(gr, name) {
+ * return gr(name.substring(0, 3));
+ * });
+ * shortenedGreet("Robert"); //=> "Hello Rob"
+ */
+ var wrap = _curry2(function wrap(fn, wrapper) {
+ return curryN(fn.length, function () {
+ return wrapper.apply(this, _concat([fn], arguments));
+ });
+ });
+
+ /**
+ * Creates a new list out of the two supplied by creating each possible pair
+ * from the lists.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category List
+ * @sig [a] -> [b] -> [[a,b]]
+ * @param {Array} as The first list.
+ * @param {Array} bs The second list.
+ * @return {Array} The list made by combining each possible pair from
+ * `as` and `bs` into pairs (`[a, b]`).
+ * @example
+ *
+ * R.xprod([1, 2], ['a', 'b']); //=> [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]
+ */
+ // = xprodWith(prepend); (takes about 3 times as long...)
+ var xprod = _curry2(function xprod(a, b) {
+ // = xprodWith(prepend); (takes about 3 times as long...)
+ var idx = 0;
+ var ilen = a.length;
+ var j;
+ var jlen = b.length;
+ var result = [];
+ while (idx < ilen) {
+ j = 0;
+ while (j < jlen) {
+ result[result.length] = [
+ a[idx],
+ b[j]
+ ];
+ j += 1;
+ }
+ idx += 1;
+ }
+ return result;
+ });
+
+ /**
+ * Creates a new list out of the two supplied by pairing up equally-positioned
+ * items from both lists. The returned list is truncated to the length of the
+ * shorter of the two input lists.
+ * Note: `zip` is equivalent to `zipWith(function(a, b) { return [a, b] })`.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category List
+ * @sig [a] -> [b] -> [[a,b]]
+ * @param {Array} list1 The first array to consider.
+ * @param {Array} list2 The second array to consider.
+ * @return {Array} The list made by pairing up same-indexed elements of `list1` and `list2`.
+ * @example
+ *
+ * R.zip([1, 2, 3], ['a', 'b', 'c']); //=> [[1, 'a'], [2, 'b'], [3, 'c']]
+ */
+ var zip = _curry2(function zip(a, b) {
+ var rv = [];
+ var idx = 0;
+ var len = Math.min(a.length, b.length);
+ while (idx < len) {
+ rv[idx] = [
+ a[idx],
+ b[idx]
+ ];
+ idx += 1;
+ }
+ return rv;
+ });
+
+ /**
+ * Creates a new object out of a list of keys and a list of values.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.3.0
+ * @category List
+ * @sig [String] -> [*] -> {String: *}
+ * @param {Array} keys The array that will be properties on the output object.
+ * @param {Array} values The list of values on the output object.
+ * @return {Object} The object made by pairing up same-indexed elements of `keys` and `values`.
+ * @example
+ *
+ * R.zipObj(['a', 'b', 'c'], [1, 2, 3]); //=> {a: 1, b: 2, c: 3}
+ */
+ var zipObj = _curry2(function zipObj(keys, values) {
+ var idx = 0;
+ var len = keys.length;
+ var out = {};
+ while (idx < len) {
+ out[keys[idx]] = values[idx];
+ idx += 1;
+ }
+ return out;
+ });
+
+ /**
+ * Creates a new list out of the two supplied by applying the function to each
+ * equally-positioned pair in the lists. The returned list is truncated to the
+ * length of the shorter of the two input lists.
+ *
+ * @function
+ * @memberOf R
+ * @since v0.1.0
+ * @category List
+ * @sig (a,b -> c) -> [a] -> [b] -> [c]
+ * @param {Function} fn The function used to combine the two elements into one value.
+ * @param {Array} list1 The first array to consider.
+ * @param {Array} list2 The second array to consider.
+ * @return {Array} The list made by combining same-indexed elements of `list1` and `list2`
+ * using `fn`.
+ * @example
+ *
+ * var f = (x, y) => {
+ * // ...
+ * };
+ * R.zipWith(f, [1, 2, 3], ['a', 'b', 'c']);
+ * //=> [f(1, 'a'), f(2, 'b'), f(3, 'c')]
+ */
+ var zipWith = _curry3(function zipWith(fn, a, b) {
+ var rv = [];
+ var idx = 0;
+ var len = Math.min(a.length, b.length);
+ while (idx < len) {
+ rv[idx] = fn(a[idx], b[idx]);
+ idx += 1;
+ }
+ return rv;
+ });
+
+ /**
+ * A function that always returns `false`. Any passed in parameters are ignored.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.9.0
+ * @category Function
+ * @sig * -> Boolean
+ * @param {*}
+ * @return {Boolean}
+ * @see R.always, R.T
+ * @example
+ *
+ * R.F(); //=> false
+ */
+ var F = always(false);
+
+ /**
+ * A function that always returns `true`. Any passed in parameters are ignored.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.9.0
+ * @category Function
+ * @sig * -> Boolean
+ * @param {*}
+ * @return {Boolean}
+ * @see R.always, R.F
+ * @example
+ *
+ * R.T(); //=> true
+ */
+ var T = always(true);
+
+ /**
+ * Copies an object.
+ *
+ * @private
+ * @param {*} value The value to be copied
+ * @param {Array} refFrom Array containing the source references
+ * @param {Array} refTo Array containing the copied source references
+ * @return {*} The copied value.
+ */
+ var _clone = function _clone(value, refFrom, refTo) {
+ var copy = function copy(copiedValue) {
+ var len = refFrom.length;
+ var idx = 0;
+ while (idx < len) {
+ if (value === refFrom[idx]) {
+ return refTo[idx];
+ }
+ idx += 1;
+ }
+ refFrom[idx + 1] = value;
+ refTo[idx + 1] = copiedValue;
+ for (var key in value) {
+ copiedValue[key] = _clone(value[key], refFrom, refTo);
+ }
+ return copiedValue;
+ };
+ switch (type(value)) {
+ case 'Object':
+ return copy({});
+ case 'Array':
+ return copy([]);
+ case 'Date':
+ return new Date(value.valueOf());
+ case 'RegExp':
+ return _cloneRegExp(value);
+ default:
+ return value;
+ }
+ };
+
+ var _createPartialApplicator = function _createPartialApplicator(concat) {
+ return _curry2(function (fn, args) {
+ return _arity(Math.max(0, fn.length - args.length), function () {
+ return fn.apply(this, concat(args, arguments));
+ });
+ });
+ };
+
+ var _dropLast = function dropLast(n, xs) {
+ return take(n < xs.length ? xs.length - n : 0, xs);
+ };
+
+ // Values of other types are only equal if identical.
+ var _equals = function _equals(a, b, stackA, stackB) {
+ if (identical(a, b)) {
+ return true;
+ }
+ if (type(a) !== type(b)) {
+ return false;
+ }
+ if (a == null || b == null) {
+ return false;
+ }
+ if (typeof a.equals === 'function' || typeof b.equals === 'function') {
+ return typeof a.equals === 'function' && a.equals(b) && typeof b.equals === 'function' && b.equals(a);
+ }
+ switch (type(a)) {
+ case 'Arguments':
+ case 'Array':
+ case 'Object':
+ break;
+ case 'Boolean':
+ case 'Number':
+ case 'String':
+ if (!(typeof a === typeof b && identical(a.valueOf(), b.valueOf()))) {
+ return false;
+ }
+ break;
+ case 'Date':
+ if (!identical(a.valueOf(), b.valueOf())) {
+ return false;
+ }
+ break;
+ case 'Error':
+ return a.name === b.name && a.message === b.message;
+ case 'RegExp':
+ if (!(a.source === b.source && a.global === b.global && a.ignoreCase === b.ignoreCase && a.multiline === b.multiline && a.sticky === b.sticky && a.unicode === b.unicode)) {
+ return false;
+ }
+ break;
+ case 'Map':
+ case 'Set':
+ if (!_equals(_arrayFromIterator(a.entries()), _arrayFromIterator(b.entries()), stackA, stackB)) {
+ return false;
+ }
+ break;
+ case 'Int8Array':
+ case 'Uint8Array':
+ case 'Uint8ClampedArray':
+ case 'Int16Array':
+ case 'Uint16Array':
+ case 'Int32Array':
+ case 'Uint32Array':
+ case 'Float32Array':
+ case 'Float64Array':
+ break;
+ case 'ArrayBuffer':
+ break;
+ default:
+ // Values of other types are only equal if identical.
+ return false;
+ }
+ var keysA = keys(a);
+ if (keysA.length !== keys(b).length) {
+ return false;
+ }
+ var idx = stackA.length - 1;
+ while (idx >= 0) {
+ if (stackA[idx] === a) {
+ return stackB[idx] === b;
+ }
+ idx -= 1;
+ }
+ stackA.push(a);
+ stackB.push(b);
+ idx = keysA.length - 1;
+ while (idx >= 0) {
+ var key = keysA[idx];
+ if (!(_has(key, b) && _equals(b[key], a[key], stackA, stackB))) {
+ return false;
+ }
+ idx -= 1;
+ }
+ stackA.pop();
+ stackB.pop();
+ return true;
+ };
+
+ /**
+ * `_makeFlat` is a helper function that returns a one-level or fully recursive
+ * function based on the flag passed in.
+ *
+ * @private
+ */
+ var _makeFlat = function _makeFlat(recursive) {
+ return function flatt(list) {
+ var value, jlen, j;
+ var result = [];
+ var idx = 0;
+ var ilen = list.length;
+ while (idx < ilen) {
+ if (isArrayLike(list[idx])) {
+ value = recursive ? flatt(list[idx]) : list[idx];
+ j = 0;
+ jlen = value.length;
+ while (j < jlen) {
+ result[result.length] = value[j];
+ j += 1;
+ }
+ } else {
+ result[result.length] = list[idx];
+ }
+ idx += 1;
+ }
+ return result;
+ };
+ };
+
+ var _reduce = function () {
+ function _arrayReduce(xf, acc, list) {
+ var idx = 0;
+ var len = list.length;
+ while (idx < len) {
+ acc = xf['@@transducer/step'](acc, list[idx]);
+ if (acc && acc['@@transducer/reduced']) {
+ acc = acc['@@transducer/value'];
+ break;
+ }
+ idx += 1;
+ }
+ return xf['@@transducer/result'](acc);
+ }
+ function _iterableReduce(xf, acc, iter) {
+ var step = iter.next();
+ while (!step.done) {
+ acc = xf['@@transducer/step'](acc, step.value);
+ if (acc && acc['@@transducer/reduced']) {
+ acc = acc['@@transducer/value'];
+ break;
+ }
+ step = iter.next();
+ }
+ return xf['@@transducer/result'](acc);
+ }
+ function _methodReduce(xf, acc, obj) {
+ return xf['@@transducer/result'](obj.reduce(bind(xf['@@transducer/step'], xf), acc));
+ }
+ var symIterator = typeof Symbol !== 'undefined' ? Symbol.iterator : '@@iterator';
+ return function _reduce(fn, acc, list) {
+ if (typeof fn === 'function') {
+ fn = _xwrap(fn);
+ }
+ if (isArrayLike(list)) {
+ return _arrayReduce(fn, acc, list);
+ }
+ if (typeof list.reduce === 'function') {
+ return _methodReduce(fn, acc, list);
+ }
+ if (list[symIterator] != null) {
+ return _iterableReduce(fn, acc, list[symIterator]());
+ }
+ if (typeof list.next === 'function') {
+ return _iterableReduce(fn, acc, list);
+ }
+ throw new TypeError('reduce: list must be array or iterable');
+ };
+ }();
+
+ var _xdropLastWhile = function () {
+ function XDropLastWhile(fn, xf) {
+ this.f = fn;
+ this.retained = [];
+ this.xf = xf;
+ }
+ XDropLastWhile.prototype['@@transducer/init'] = _xfBase.init;
+ XDropLastWhile.prototype['@@transducer/result'] = function (result) {
+ this.retained = null;
+ return this.xf['@@transducer/result'](result);
+ };
+ XDropLastWhile.prototype['@@transducer/step'] = function (result, input) {
+ return this.f(input) ? this.retain(result, input) : this.flush(result, input);
+ };
+ XDropLastWhile.prototype.flush = function (result, input) {
+ result = _reduce(this.xf['@@transducer/step'], result, this.retained);
+ this.retained = [];
+ return this.xf['@@transducer/step'](result, input);
+ };
+ XDropLastWhile.prototype.retain = function (result, input) {
+ this.retained.push(input);
+ return result;
+ };
+ return _curry2(function _xdropLastWhile(fn, xf) {
+ return new XDropLastWhile(fn, xf);
+ });
+ }();
+
+ var _xgroupBy = function () {
+ function XGroupBy(f, xf) {
+ this.xf = xf;
+ this.f = f;
+ this.inputs = {};
+ }
+ XGroupBy.prototype['@@transducer/init'] = _xfBase.init;
+ XGroupBy.prototype['@@transducer/result'] = function (result) {
+ var key;
+ for (key in this.inputs) {
+ if (_has(key, this.inputs)) {
+ result = this.xf['@@transducer/step'](result, this.inputs[key]);
+ if (result['@@transducer/reduced']) {
+ result = result['@@transducer/value'];
+ break;
+ }
+ }
+ }
+ this.inputs = null;
+ return this.xf['@@transducer/result'](result);
+ };
+ XGroupBy.prototype['@@transducer/step'] = function (result, input) {
+ var key = this.f(input);
+ this.inputs[key] = this.inputs[key] || [
+ key,
+ []
+ ];
+ this.inputs[key][1] = append(input, this.inputs[key][1]);
+ return result;
+ };
+ return _curry2(function _xgroupBy(f, xf) {
+ return new XGroupBy(f, xf);
+ });
+ }();
+
+ /**
+ * Creates a new list iteration function from an existing one by adding two new
+ * parameters to its callback function: the current index, and the entire list.
+ *
+ * This would turn, for instance, Ramda's simple `map` function into one that
+ * more closely resembles `Array.prototype.map`. Note that this will only work
+ * for functions in which the iteration callback function is the first
+ * parameter, and where the list is the last parameter. (This latter might be
+ * unimportant if the list parameter is not used.)
+ *
+ * @func
+ * @memberOf R
+ * @since v0.15.0
+ * @category Function
+ * @category List
+ * @sig ((a ... -> b) ... -> [a] -> *) -> (a ..., Int, [a] -> b) ... -> [a] -> *)
+ * @param {Function} fn A list iteration function that does not pass index or list to its callback
+ * @return {Function} An altered list iteration function that passes (item, index, list) to its callback
+ * @example
+ *
+ * var mapIndexed = R.addIndex(R.map);
+ * mapIndexed((val, idx) => idx + '-' + val, ['f', 'o', 'o', 'b', 'a', 'r']);
+ * //=> ['0-f', '1-o', '2-o', '3-b', '4-a', '5-r']
+ */
+ var addIndex = _curry1(function addIndex(fn) {
+ return curryN(fn.length, function () {
+ var idx = 0;
+ var origFn = arguments[0];
+ var list = arguments[arguments.length - 1];
+ var args = _slice(arguments);
+ args[0] = function () {
+ var result = origFn.apply(this, _concat(arguments, [
+ idx,
+ list
+ ]));
+ idx += 1;
+ return result;
+ };
+ return fn.apply(this, args);
+ });
+ });
+
+ /**
+ * Wraps a function of any arity (including nullary) in a function that accepts
+ * exactly 2 parameters. Any extraneous parameters will not be passed to the
+ * supplied function.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.2.0
+ * @category Function
+ * @sig (* -> c) -> (a, b -> c)
+ * @param {Function} fn The function to wrap.
+ * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of
+ * arity 2.
+ * @example
+ *
+ * var takesThreeArgs = function(a, b, c) {
+ * return [a, b, c];
+ * };
+ * takesThreeArgs.length; //=> 3
+ * takesThreeArgs(1, 2, 3); //=> [1, 2, 3]
+ *
+ * var takesTwoArgs = R.binary(takesThreeArgs);
+ * takesTwoArgs.length; //=> 2
+ * // Only 2 arguments are passed to the wrapped function
+ * takesTwoArgs(1, 2, 3); //=> [1, 2, undefined]
+ */
+ var binary = _curry1(function binary(fn) {
+ return nAry(2, fn);
+ });
+
+ /**
+ * Creates a deep copy of the value which may contain (nested) `Array`s and
+ * `Object`s, `Number`s, `String`s, `Boolean`s and `Date`s. `Function`s are not
+ * copied, but assigned by their reference.
+ *
+ * Dispatches to a `clone` method if present.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Object
+ * @sig {*} -> {*}
+ * @param {*} value The object or array to clone
+ * @return {*} A new object or array.
+ * @example
+ *
+ * var objects = [{}, {}, {}];
+ * var objectsClone = R.clone(objects);
+ * objects[0] === objectsClone[0]; //=> false
+ */
+ var clone = _curry1(function clone(value) {
+ return value != null && typeof value.clone === 'function' ? value.clone() : _clone(value, [], []);
+ });
+
+ /**
+ * Returns a curried equivalent of the provided function. The curried function
+ * has two unusual capabilities. First, its arguments needn't be provided one
+ * at a time. If `f` is a ternary function and `g` is `R.curry(f)`, the
+ * following are equivalent:
+ *
+ * - `g(1)(2)(3)`
+ * - `g(1)(2, 3)`
+ * - `g(1, 2)(3)`
+ * - `g(1, 2, 3)`
+ *
+ * Secondly, the special placeholder value `R.__` may be used to specify
+ * "gaps", allowing partial application of any combination of arguments,
+ * regardless of their positions. If `g` is as above and `_` is `R.__`, the
+ * following are equivalent:
+ *
+ * - `g(1, 2, 3)`
+ * - `g(_, 2, 3)(1)`
+ * - `g(_, _, 3)(1)(2)`
+ * - `g(_, _, 3)(1, 2)`
+ * - `g(_, 2)(1)(3)`
+ * - `g(_, 2)(1, 3)`
+ * - `g(_, 2)(_, 3)(1)`
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Function
+ * @sig (* -> a) -> (* -> a)
+ * @param {Function} fn The function to curry.
+ * @return {Function} A new, curried function.
+ * @see R.curryN
+ * @example
+ *
+ * var addFourNumbers = (a, b, c, d) => a + b + c + d;
+ *
+ * var curriedAddFourNumbers = R.curry(addFourNumbers);
+ * var f = curriedAddFourNumbers(1, 2);
+ * var g = f(3);
+ * g(4); //=> 10
+ */
+ var curry = _curry1(function curry(fn) {
+ return curryN(fn.length, fn);
+ });
+
+ /**
+ * Returns all but the first `n` elements of the given list, string, or
+ * transducer/transformer (or object with a `drop` method).
+ *
+ * Dispatches to the `drop` method of the second argument, if present.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category List
+ * @sig Number -> [a] -> [a]
+ * @sig Number -> String -> String
+ * @param {Number} n
+ * @param {*} list
+ * @return {*}
+ * @see R.take, R.transduce
+ * @example
+ *
+ * R.drop(1, ['foo', 'bar', 'baz']); //=> ['bar', 'baz']
+ * R.drop(2, ['foo', 'bar', 'baz']); //=> ['baz']
+ * R.drop(3, ['foo', 'bar', 'baz']); //=> []
+ * R.drop(4, ['foo', 'bar', 'baz']); //=> []
+ * R.drop(3, 'ramda'); //=> 'da'
+ */
+ var drop = _curry2(_dispatchable('drop', _xdrop, function drop(n, xs) {
+ return slice(Math.max(0, n), Infinity, xs);
+ }));
+
+ /**
+ * Returns a list containing all but the last `n` elements of the given `list`.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.16.0
+ * @category List
+ * @sig Number -> [a] -> [a]
+ * @sig Number -> String -> String
+ * @param {Number} n The number of elements of `xs` to skip.
+ * @param {Array} xs The collection to consider.
+ * @return {Array}
+ * @see R.takeLast
+ * @example
+ *
+ * R.dropLast(1, ['foo', 'bar', 'baz']); //=> ['foo', 'bar']
+ * R.dropLast(2, ['foo', 'bar', 'baz']); //=> ['foo']
+ * R.dropLast(3, ['foo', 'bar', 'baz']); //=> []
+ * R.dropLast(4, ['foo', 'bar', 'baz']); //=> []
+ * R.dropLast(3, 'ramda'); //=> 'ra'
+ */
+ var dropLast = _curry2(_dispatchable('dropLast', _xdropLast, _dropLast));
+
+ /**
+ * Returns a new list containing all but last the`n` elements of a given list,
+ * passing each value from the right to the supplied predicate function,
+ * skipping elements while the predicate function returns `true`. The predicate
+ * function is passed one argument: (value)*.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.16.0
+ * @category List
+ * @sig (a -> Boolean) -> [a] -> [a]
+ * @param {Function} fn The function called per iteration.
+ * @param {Array} list The collection to iterate over.
+ * @return {Array} A new array.
+ * @see R.takeLastWhile, R.addIndex
+ * @example
+ *
+ * var lteThree = x => x <= 3;
+ *
+ * R.dropLastWhile(lteThree, [1, 2, 3, 4, 3, 2, 1]); //=> [1, 2, 3, 4]
+ */
+ var dropLastWhile = _curry2(_dispatchable('dropLastWhile', _xdropLastWhile, _dropLastWhile));
+
+ /**
+ * Returns `true` if its arguments are equivalent, `false` otherwise. Handles
+ * cyclical data structures.
+ *
+ * Dispatches symmetrically to the `equals` methods of both arguments, if
+ * present.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.15.0
+ * @category Relation
+ * @sig a -> b -> Boolean
+ * @param {*} a
+ * @param {*} b
+ * @return {Boolean}
+ * @example
+ *
+ * R.equals(1, 1); //=> true
+ * R.equals(1, '1'); //=> false
+ * R.equals([1, 2, 3], [1, 2, 3]); //=> true
+ *
+ * var a = {}; a.v = a;
+ * var b = {}; b.v = b;
+ * R.equals(a, b); //=> true
+ */
+ var equals = _curry2(function equals(a, b) {
+ return _equals(a, b, [], []);
+ });
+
+ /**
+ * Takes a predicate and a "filterable", and returns a new filterable of the
+ * same type containing the members of the given filterable which satisfy the
+ * given predicate.
+ *
+ * Dispatches to the `filter` method of the second argument, if present.
+ *
+ * Acts as a transducer if a transformer is given in list position.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category List
+ * @sig Filterable f => (a -> Boolean) -> f a -> f a
+ * @param {Function} pred
+ * @param {Array} filterable
+ * @return {Array}
+ * @see R.reject, R.transduce, R.addIndex
+ * @example
+ *
+ * var isEven = n => n % 2 === 0;
+ *
+ * R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4]
+ *
+ * R.filter(isEven, {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, d: 4}
+ */
+ // else
+ var filter = _curry2(_dispatchable('filter', _xfilter, function (pred, filterable) {
+ return _isObject(filterable) ? _reduce(function (acc, key) {
+ if (pred(filterable[key])) {
+ acc[key] = filterable[key];
+ }
+ return acc;
+ }, {}, keys(filterable)) : // else
+ _filter(pred, filterable);
+ }));
+
+ /**
+ * Returns a new list by pulling every item out of it (and all its sub-arrays)
+ * and putting them in a new array, depth-first.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category List
+ * @sig [a] -> [b]
+ * @param {Array} list The array to consider.
+ * @return {Array} The flattened list.
+ * @see R.unnest
+ * @example
+ *
+ * R.flatten([1, 2, [3, 4], 5, [6, [7, 8, [9, [10, 11], 12]]]]);
+ * //=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+ */
+ var flatten = _curry1(_makeFlat(true));
+
+ /**
+ * Returns a new function much like the supplied one, except that the first two
+ * arguments' order is reversed.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Function
+ * @sig (a -> b -> c -> ... -> z) -> (b -> a -> c -> ... -> z)
+ * @param {Function} fn The function to invoke with its first two parameters reversed.
+ * @return {*} The result of invoking `fn` with its first two parameters' order reversed.
+ * @example
+ *
+ * var mergeThree = (a, b, c) => [].concat(a, b, c);
+ *
+ * mergeThree(1, 2, 3); //=> [1, 2, 3]
+ *
+ * R.flip(mergeThree)(1, 2, 3); //=> [2, 1, 3]
+ */
+ var flip = _curry1(function flip(fn) {
+ return curry(function (a, b) {
+ var args = _slice(arguments);
+ args[0] = b;
+ args[1] = a;
+ return fn.apply(this, args);
+ });
+ });
+
+ /**
+ * Splits a list into sub-lists stored in an object, based on the result of
+ * calling a String-returning function on each element, and grouping the
+ * results according to values returned.
+ *
+ * Dispatches to the `groupBy` method of the second argument, if present.
+ *
+ * Acts as a transducer if a transformer is given in list position.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category List
+ * @sig (a -> String) -> [a] -> {String: [a]}
+ * @param {Function} fn Function :: a -> String
+ * @param {Array} list The array to group
+ * @return {Object} An object with the output of `fn` for keys, mapped to arrays of elements
+ * that produced that key when passed to `fn`.
+ * @see R.transduce
+ * @example
+ *
+ * var byGrade = R.groupBy(function(student) {
+ * var score = student.score;
+ * return score < 65 ? 'F' :
+ * score < 70 ? 'D' :
+ * score < 80 ? 'C' :
+ * score < 90 ? 'B' : 'A';
+ * });
+ * var students = [{name: 'Abby', score: 84},
+ * {name: 'Eddy', score: 58},
+ * // ...
+ * {name: 'Jack', score: 69}];
+ * byGrade(students);
+ * // {
+ * // 'A': [{name: 'Dianne', score: 99}],
+ * // 'B': [{name: 'Abby', score: 84}]
+ * // // ...,
+ * // 'F': [{name: 'Eddy', score: 58}]
+ * // }
+ */
+ var groupBy = _curry2(_dispatchable('groupBy', _xgroupBy, function groupBy(fn, list) {
+ return _reduce(function (acc, elt) {
+ var key = fn(elt);
+ acc[key] = append(elt, acc[key] || (acc[key] = []));
+ return acc;
+ }, {}, list);
+ }));
+
+ /**
+ * Returns the first element of the given list or string. In some libraries
+ * this function is named `first`.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category List
+ * @sig [a] -> a | Undefined
+ * @sig String -> String
+ * @param {Array|String} list
+ * @return {*}
+ * @see R.tail, R.init, R.last
+ * @example
+ *
+ * R.head(['fi', 'fo', 'fum']); //=> 'fi'
+ * R.head([]); //=> undefined
+ *
+ * R.head('abc'); //=> 'a'
+ * R.head(''); //=> ''
+ */
+ var head = nth(0);
+
+ /**
+ * Given a function that generates a key, turns a list of objects into an
+ * object indexing the objects by the given key. Note that if multiple
+ * objects generate the same value for the indexing key only the last value
+ * will be included in the generated object.
+ *
+ * @func
+ * @memberOf R
+ * @since 0.19.1
+ * @since 0.19.0
+ * @category List
+ * @sig (a -> String) -> [{k: v}] -> {k: {k: v}}
+ * @param {Function} fn Function :: a -> String
+ * @param {Array} array The array of objects to index
+ * @return {Object} An object indexing each array element by the given property.
+ * @example
+ *
+ * var list = [{id: 'xyz', title: 'A'}, {id: 'abc', title: 'B'}];
+ * R.indexBy(R.prop('id'), list);
+ * //=> {abc: {id: 'abc', title: 'B'}, xyz: {id: 'xyz', title: 'A'}}
+ */
+ var indexBy = _curry2(function indexBy(fn, list) {
+ return _reduce(function (acc, elem) {
+ var key = fn(elem);
+ acc[key] = elem;
+ return acc;
+ }, {}, list);
+ });
+
+ /**
+ * Returns all but the last element of the given list or string.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.9.0
+ * @category List
+ * @sig [a] -> [a]
+ * @sig String -> String
+ * @param {*} list
+ * @return {*}
+ * @see R.last, R.head, R.tail
+ * @example
+ *
+ * R.init([1, 2, 3]); //=> [1, 2]
+ * R.init([1, 2]); //=> [1]
+ * R.init([1]); //=> []
+ * R.init([]); //=> []
+ *
+ * R.init('abc'); //=> 'ab'
+ * R.init('ab'); //=> 'a'
+ * R.init('a'); //=> ''
+ * R.init(''); //=> ''
+ */
+ var init = slice(0, -1);
+
+ /**
+ * Combines two lists into a set (i.e. no duplicates) composed of those
+ * elements common to both lists. Duplication is determined according to the
+ * value returned by applying the supplied predicate to two list elements.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Relation
+ * @sig (a -> a -> Boolean) -> [*] -> [*] -> [*]
+ * @param {Function} pred A predicate function that determines whether
+ * the two supplied elements are equal.
+ * @param {Array} list1 One list of items to compare
+ * @param {Array} list2 A second list of items to compare
+ * @return {Array} A new list containing those elements common to both lists.
+ * @see R.intersection
+ * @example
+ *
+ * var buffaloSpringfield = [
+ * {id: 824, name: 'Richie Furay'},
+ * {id: 956, name: 'Dewey Martin'},
+ * {id: 313, name: 'Bruce Palmer'},
+ * {id: 456, name: 'Stephen Stills'},
+ * {id: 177, name: 'Neil Young'}
+ * ];
+ * var csny = [
+ * {id: 204, name: 'David Crosby'},
+ * {id: 456, name: 'Stephen Stills'},
+ * {id: 539, name: 'Graham Nash'},
+ * {id: 177, name: 'Neil Young'}
+ * ];
+ *
+ * R.intersectionWith(R.eqBy(R.prop('id')), buffaloSpringfield, csny);
+ * //=> [{id: 456, name: 'Stephen Stills'}, {id: 177, name: 'Neil Young'}]
+ */
+ var intersectionWith = _curry3(function intersectionWith(pred, list1, list2) {
+ var results = [];
+ var idx = 0;
+ while (idx < list1.length) {
+ if (_containsWith(pred, list1[idx], list2)) {
+ results[results.length] = list1[idx];
+ }
+ idx += 1;
+ }
+ return uniqWith(pred, results);
+ });
+
+ /**
+ * Same as R.invertObj, however this accounts for objects with duplicate values
+ * by putting the values into an array.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.9.0
+ * @category Object
+ * @sig {s: x} -> {x: [ s, ... ]}
+ * @param {Object} obj The object or array to invert
+ * @return {Object} out A new object with keys
+ * in an array.
+ * @example
+ *
+ * var raceResultsByFirstName = {
+ * first: 'alice',
+ * second: 'jake',
+ * third: 'alice',
+ * };
+ * R.invert(raceResultsByFirstName);
+ * //=> { 'alice': ['first', 'third'], 'jake':['second'] }
+ */
+ var invert = _curry1(function invert(obj) {
+ var props = keys(obj);
+ var len = props.length;
+ var idx = 0;
+ var out = {};
+ while (idx < len) {
+ var key = props[idx];
+ var val = obj[key];
+ var list = _has(val, out) ? out[val] : out[val] = [];
+ list[list.length] = key;
+ idx += 1;
+ }
+ return out;
+ });
+
+ /**
+ * Returns a new object with the keys of the given object as values, and the
+ * values of the given object, which are coerced to strings, as keys. Note
+ * that the last key found is preferred when handling the same value.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.9.0
+ * @category Object
+ * @sig {s: x} -> {x: s}
+ * @param {Object} obj The object or array to invert
+ * @return {Object} out A new object
+ * @example
+ *
+ * var raceResults = {
+ * first: 'alice',
+ * second: 'jake'
+ * };
+ * R.invertObj(raceResults);
+ * //=> { 'alice': 'first', 'jake':'second' }
+ *
+ * // Alternatively:
+ * var raceResults = ['alice', 'jake'];
+ * R.invertObj(raceResults);
+ * //=> { 'alice': '0', 'jake':'1' }
+ */
+ var invertObj = _curry1(function invertObj(obj) {
+ var props = keys(obj);
+ var len = props.length;
+ var idx = 0;
+ var out = {};
+ while (idx < len) {
+ var key = props[idx];
+ out[obj[key]] = key;
+ idx += 1;
+ }
+ return out;
+ });
+
+ /**
+ * Returns `true` if the given value is its type's empty value; `false`
+ * otherwise.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Logic
+ * @sig a -> Boolean
+ * @param {*} x
+ * @return {Boolean}
+ * @see R.empty
+ * @example
+ *
+ * R.isEmpty([1, 2, 3]); //=> false
+ * R.isEmpty([]); //=> true
+ * R.isEmpty(''); //=> true
+ * R.isEmpty(null); //=> false
+ * R.isEmpty({}); //=> true
+ * R.isEmpty({length: 0}); //=> false
+ */
+ var isEmpty = _curry1(function isEmpty(x) {
+ return x != null && equals(x, empty(x));
+ });
+
+ /**
+ * Returns the last element of the given list or string.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.4
+ * @category List
+ * @sig [a] -> a | Undefined
+ * @sig String -> String
+ * @param {*} list
+ * @return {*}
+ * @see R.init, R.head, R.tail
+ * @example
+ *
+ * R.last(['fi', 'fo', 'fum']); //=> 'fum'
+ * R.last([]); //=> undefined
+ *
+ * R.last('abc'); //=> 'c'
+ * R.last(''); //=> ''
+ */
+ var last = nth(-1);
+
+ /**
+ * Returns the position of the last occurrence of an item in an array, or -1 if
+ * the item is not included in the array. `R.equals` is used to determine
+ * equality.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category List
+ * @sig a -> [a] -> Number
+ * @param {*} target The item to find.
+ * @param {Array} xs The array to search in.
+ * @return {Number} the index of the target, or -1 if the target is not found.
+ * @see R.indexOf
+ * @example
+ *
+ * R.lastIndexOf(3, [-1,3,3,0,1,2,3,4]); //=> 6
+ * R.lastIndexOf(10, [1,2,3,4]); //=> -1
+ */
+ var lastIndexOf = _curry2(function lastIndexOf(target, xs) {
+ if (typeof xs.lastIndexOf === 'function' && !_isArray(xs)) {
+ return xs.lastIndexOf(target);
+ } else {
+ var idx = xs.length - 1;
+ while (idx >= 0) {
+ if (equals(xs[idx], target)) {
+ return idx;
+ }
+ idx -= 1;
+ }
+ return -1;
+ }
+ });
+
+ /**
+ * Takes a function and
+ * a [functor](https://github.com/fantasyland/fantasy-land#functor),
+ * applies the function to each of the functor's values, and returns
+ * a functor of the same shape.
+ *
+ * Ramda provides suitable `map` implementations for `Array` and `Object`,
+ * so this function may be applied to `[1, 2, 3]` or `{x: 1, y: 2, z: 3}`.
+ *
+ * Dispatches to the `map` method of the second argument, if present.
+ *
+ * Acts as a transducer if a transformer is given in list position.
+ *
+ * Also treats functions as functors and will compose them together.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category List
+ * @sig Functor f => (a -> b) -> f a -> f b
+ * @param {Function} fn The function to be called on every element of the input `list`.
+ * @param {Array} list The list to be iterated over.
+ * @return {Array} The new list.
+ * @see R.transduce, R.addIndex
+ * @example
+ *
+ * var double = x => x * 2;
+ *
+ * R.map(double, [1, 2, 3]); //=> [2, 4, 6]
+ *
+ * R.map(double, {x: 1, y: 2, z: 3}); //=> {x: 2, y: 4, z: 6}
+ */
+ var map = _curry2(_dispatchable('map', _xmap, function map(fn, functor) {
+ switch (Object.prototype.toString.call(functor)) {
+ case '[object Function]':
+ return curryN(functor.length, function () {
+ return fn.call(this, functor.apply(this, arguments));
+ });
+ case '[object Object]':
+ return _reduce(function (acc, key) {
+ acc[key] = fn(functor[key]);
+ return acc;
+ }, {}, keys(functor));
+ default:
+ return _map(fn, functor);
+ }
+ }));
+
+ /**
+ * An Object-specific version of `map`. The function is applied to three
+ * arguments: *(value, key, obj)*. If only the value is significant, use
+ * `map` instead.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.9.0
+ * @category Object
+ * @sig ((*, String, Object) -> *) -> Object -> Object
+ * @param {Function} fn
+ * @param {Object} obj
+ * @return {Object}
+ * @see R.map
+ * @example
+ *
+ * var values = { x: 1, y: 2, z: 3 };
+ * var prependKeyAndDouble = (num, key, obj) => key + (num * 2);
+ *
+ * R.mapObjIndexed(prependKeyAndDouble, values); //=> { x: 'x2', y: 'y4', z: 'z6' }
+ */
+ var mapObjIndexed = _curry2(function mapObjIndexed(fn, obj) {
+ return _reduce(function (acc, key) {
+ acc[key] = fn(obj[key], key, obj);
+ return acc;
+ }, {}, keys(obj));
+ });
+
+ /**
+ * Creates a new object with the own properties of the two provided objects. If
+ * a key exists in both objects, the provided function is applied to the values
+ * associated with the key in each object, with the result being used as the
+ * value associated with the key in the returned object. The key will be
+ * excluded from the returned object if the resulting value is `undefined`.
+ *
+ * @func
+ * @memberOf R
+ * @since 0.19.1
+ * @since 0.19.0
+ * @category Object
+ * @sig (a -> a -> a) -> {a} -> {a} -> {a}
+ * @param {Function} fn
+ * @param {Object} l
+ * @param {Object} r
+ * @return {Object}
+ * @see R.merge, R.mergeWithKey
+ * @example
+ *
+ * R.mergeWith(R.concat,
+ * { a: true, values: [10, 20] },
+ * { b: true, values: [15, 35] });
+ * //=> { a: true, b: true, values: [10, 20, 15, 35] }
+ */
+ var mergeWith = _curry3(function mergeWith(fn, l, r) {
+ return mergeWithKey(function (_, _l, _r) {
+ return fn(_l, _r);
+ }, l, r);
+ });
+
+ /**
+ * Takes a function `f` and a list of arguments, and returns a function `g`.
+ * When applied, `g` returns the result of applying `f` to the arguments
+ * provided initially followed by the arguments provided to `g`.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.10.0
+ * @category Function
+ * @sig ((a, b, c, ..., n) -> x) -> [a, b, c, ...] -> ((d, e, f, ..., n) -> x)
+ * @param {Function} f
+ * @param {Array} args
+ * @return {Function}
+ * @see R.partialRight
+ * @example
+ *
+ * var multiply = (a, b) => a * b;
+ * var double = R.partial(multiply, [2]);
+ * double(2); //=> 4
+ *
+ * var greet = (salutation, title, firstName, lastName) =>
+ * salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';
+ *
+ * var sayHello = R.partial(greet, ['Hello']);
+ * var sayHelloToMs = R.partial(sayHello, ['Ms.']);
+ * sayHelloToMs('Jane', 'Jones'); //=> 'Hello, Ms. Jane Jones!'
+ */
+ var partial = _createPartialApplicator(_concat);
+
+ /**
+ * Takes a function `f` and a list of arguments, and returns a function `g`.
+ * When applied, `g` returns the result of applying `f` to the arguments
+ * provided to `g` followed by the arguments provided initially.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.10.0
+ * @category Function
+ * @sig ((a, b, c, ..., n) -> x) -> [d, e, f, ..., n] -> ((a, b, c, ...) -> x)
+ * @param {Function} f
+ * @param {Array} args
+ * @return {Function}
+ * @see R.partial
+ * @example
+ *
+ * var greet = (salutation, title, firstName, lastName) =>
+ * salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';
+ *
+ * var greetMsJaneJones = R.partialRight(greet, ['Ms.', 'Jane', 'Jones']);
+ *
+ * greetMsJaneJones('Hello'); //=> 'Hello, Ms. Jane Jones!'
+ */
+ var partialRight = _createPartialApplicator(flip(_concat));
+
+ /**
+ * Takes a predicate and a list and returns the pair of lists of elements which
+ * do and do not satisfy the predicate, respectively.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.4
+ * @category List
+ * @sig (a -> Boolean) -> [a] -> [[a],[a]]
+ * @param {Function} pred A predicate to determine which array the element belongs to.
+ * @param {Array} list The array to partition.
+ * @return {Array} A nested array, containing first an array of elements that satisfied the predicate,
+ * and second an array of elements that did not satisfy.
+ * @see R.filter, R.reject
+ * @example
+ *
+ * R.partition(R.contains('s'), ['sss', 'ttt', 'foo', 'bars']);
+ * //=> [ [ 'sss', 'bars' ], [ 'ttt', 'foo' ] ]
+ */
+ var partition = _curry2(function partition(pred, list) {
+ return _reduce(function (acc, elt) {
+ var xs = acc[pred(elt) ? 0 : 1];
+ xs[xs.length] = elt;
+ return acc;
+ }, [
+ [],
+ []
+ ], list);
+ });
+
+ /**
+ * Determines whether a nested path on an object has a specific value, in
+ * `R.equals` terms. Most likely used to filter a list.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.7.0
+ * @category Relation
+ * @sig [String] -> * -> {String: *} -> Boolean
+ * @param {Array} path The path of the nested property to use
+ * @param {*} val The value to compare the nested property with
+ * @param {Object} obj The object to check the nested property in
+ * @return {Boolean} `true` if the value equals the nested object property,
+ * `false` otherwise.
+ * @example
+ *
+ * var user1 = { address: { zipCode: 90210 } };
+ * var user2 = { address: { zipCode: 55555 } };
+ * var user3 = { name: 'Bob' };
+ * var users = [ user1, user2, user3 ];
+ * var isFamous = R.pathEq(['address', 'zipCode'], 90210);
+ * R.filter(isFamous, users); //=> [ user1 ]
+ */
+ var pathEq = _curry3(function pathEq(_path, val, obj) {
+ return equals(path(_path, obj), val);
+ });
+
+ /**
+ * Returns a new list by plucking the same named property off all objects in
+ * the list supplied.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category List
+ * @sig k -> [{k: v}] -> [v]
+ * @param {Number|String} key The key name to pluck off of each object.
+ * @param {Array} list The array to consider.
+ * @return {Array} The list of values for the given key.
+ * @see R.props
+ * @example
+ *
+ * R.pluck('a')([{a: 1}, {a: 2}]); //=> [1, 2]
+ * R.pluck(0)([[1, 2], [3, 4]]); //=> [1, 3]
+ */
+ var pluck = _curry2(function pluck(p, list) {
+ return map(prop(p), list);
+ });
+
+ /**
+ * Reasonable analog to SQL `select` statement.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Object
+ * @category Relation
+ * @sig [k] -> [{k: v}] -> [{k: v}]
+ * @param {Array} props The property names to project
+ * @param {Array} objs The objects to query
+ * @return {Array} An array of objects with just the `props` properties.
+ * @example
+ *
+ * var abby = {name: 'Abby', age: 7, hair: 'blond', grade: 2};
+ * var fred = {name: 'Fred', age: 12, hair: 'brown', grade: 7};
+ * var kids = [abby, fred];
+ * R.project(['name', 'grade'], kids); //=> [{name: 'Abby', grade: 2}, {name: 'Fred', grade: 7}]
+ */
+ // passing `identity` gives correct arity
+ var project = useWith(_map, [
+ pickAll,
+ identity
+ ]);
+
+ /**
+ * Returns `true` if the specified object property is equal, in `R.equals`
+ * terms, to the given value; `false` otherwise.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Relation
+ * @sig String -> a -> Object -> Boolean
+ * @param {String} name
+ * @param {*} val
+ * @param {*} obj
+ * @return {Boolean}
+ * @see R.equals, R.propSatisfies
+ * @example
+ *
+ * var abby = {name: 'Abby', age: 7, hair: 'blond'};
+ * var fred = {name: 'Fred', age: 12, hair: 'brown'};
+ * var rusty = {name: 'Rusty', age: 10, hair: 'brown'};
+ * var alois = {name: 'Alois', age: 15, disposition: 'surly'};
+ * var kids = [abby, fred, rusty, alois];
+ * var hasBrownHair = R.propEq('hair', 'brown');
+ * R.filter(hasBrownHair, kids); //=> [fred, rusty]
+ */
+ var propEq = _curry3(function propEq(name, val, obj) {
+ return propSatisfies(equals(val), name, obj);
+ });
+
+ /**
+ * Returns `true` if the specified object property is of the given type;
+ * `false` otherwise.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.16.0
+ * @category Type
+ * @sig Type -> String -> Object -> Boolean
+ * @param {Function} type
+ * @param {String} name
+ * @param {*} obj
+ * @return {Boolean}
+ * @see R.is, R.propSatisfies
+ * @example
+ *
+ * R.propIs(Number, 'x', {x: 1, y: 2}); //=> true
+ * R.propIs(Number, 'x', {x: 'foo'}); //=> false
+ * R.propIs(Number, 'x', {}); //=> false
+ */
+ var propIs = _curry3(function propIs(type, name, obj) {
+ return propSatisfies(is(type), name, obj);
+ });
+
+ /**
+ * Returns a single item by iterating through the list, successively calling
+ * the iterator function and passing it an accumulator value and the current
+ * value from the array, and then passing the result to the next call.
+ *
+ * The iterator function receives two values: *(acc, value)*. It may use
+ * `R.reduced` to shortcut the iteration.
+ *
+ * Note: `R.reduce` does not skip deleted or unassigned indices (sparse
+ * arrays), unlike the native `Array.prototype.reduce` method. For more details
+ * on this behavior, see:
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description
+ *
+ * Dispatches to the `reduce` method of the third argument, if present.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category List
+ * @sig ((a, b) -> a) -> a -> [b] -> a
+ * @param {Function} fn The iterator function. Receives two values, the accumulator and the
+ * current element from the array.
+ * @param {*} acc The accumulator value.
+ * @param {Array} list The list to iterate over.
+ * @return {*} The final, accumulated value.
+ * @see R.reduced, R.addIndex
+ * @example
+ *
+ * var numbers = [1, 2, 3];
+ * var add = (a, b) => a + b;
+ *
+ * R.reduce(add, 10, numbers); //=> 16
+ */
+ var reduce = _curry3(_reduce);
+
+ /**
+ * The complement of `filter`.
+ *
+ * Acts as a transducer if a transformer is given in list position.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category List
+ * @sig Filterable f => (a -> Boolean) -> f a -> f a
+ * @param {Function} pred
+ * @param {Array} filterable
+ * @return {Array}
+ * @see R.filter, R.transduce, R.addIndex
+ * @example
+ *
+ * var isOdd = (n) => n % 2 === 1;
+ *
+ * R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4]
+ *
+ * R.reject(isOdd, {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, d: 4}
+ */
+ var reject = _curry2(function reject(pred, filterable) {
+ return filter(_complement(pred), filterable);
+ });
+
+ /**
+ * Returns a fixed list of size `n` containing a specified identical value.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.1
+ * @category List
+ * @sig a -> n -> [a]
+ * @param {*} value The value to repeat.
+ * @param {Number} n The desired size of the output list.
+ * @return {Array} A new array containing `n` `value`s.
+ * @example
+ *
+ * R.repeat('hi', 5); //=> ['hi', 'hi', 'hi', 'hi', 'hi']
+ *
+ * var obj = {};
+ * var repeatedObjs = R.repeat(obj, 5); //=> [{}, {}, {}, {}, {}]
+ * repeatedObjs[0] === repeatedObjs[1]; //=> true
+ */
+ var repeat = _curry2(function repeat(value, n) {
+ return times(always(value), n);
+ });
+
+ /**
+ * Adds together all the elements of a list.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Math
+ * @sig [Number] -> Number
+ * @param {Array} list An array of numbers
+ * @return {Number} The sum of all the numbers in the list.
+ * @see R.reduce
+ * @example
+ *
+ * R.sum([2,4,6,8,100,1]); //=> 121
+ */
+ var sum = reduce(add, 0);
+
+ /**
+ * Returns a new list containing the last `n` elements of the given list.
+ * If `n > list.length`, returns a list of `list.length` elements.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.16.0
+ * @category List
+ * @sig Number -> [a] -> [a]
+ * @sig Number -> String -> String
+ * @param {Number} n The number of elements to return.
+ * @param {Array} xs The collection to consider.
+ * @return {Array}
+ * @see R.dropLast
+ * @example
+ *
+ * R.takeLast(1, ['foo', 'bar', 'baz']); //=> ['baz']
+ * R.takeLast(2, ['foo', 'bar', 'baz']); //=> ['bar', 'baz']
+ * R.takeLast(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']
+ * R.takeLast(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']
+ * R.takeLast(3, 'ramda'); //=> 'mda'
+ */
+ var takeLast = _curry2(function takeLast(n, xs) {
+ return drop(n >= 0 ? xs.length - n : 0, xs);
+ });
+
+ /**
+ * Initializes a transducer using supplied iterator function. Returns a single
+ * item by iterating through the list, successively calling the transformed
+ * iterator function and passing it an accumulator value and the current value
+ * from the array, and then passing the result to the next call.
+ *
+ * The iterator function receives two values: *(acc, value)*. It will be
+ * wrapped as a transformer to initialize the transducer. A transformer can be
+ * passed directly in place of an iterator function. In both cases, iteration
+ * may be stopped early with the `R.reduced` function.
+ *
+ * A transducer is a function that accepts a transformer and returns a
+ * transformer and can be composed directly.
+ *
+ * A transformer is an an object that provides a 2-arity reducing iterator
+ * function, step, 0-arity initial value function, init, and 1-arity result
+ * extraction function, result. The step function is used as the iterator
+ * function in reduce. The result function is used to convert the final
+ * accumulator into the return type and in most cases is R.identity. The init
+ * function can be used to provide an initial accumulator, but is ignored by
+ * transduce.
+ *
+ * The iteration is performed with R.reduce after initializing the transducer.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.12.0
+ * @category List
+ * @sig (c -> c) -> (a,b -> a) -> a -> [b] -> a
+ * @param {Function} xf The transducer function. Receives a transformer and returns a transformer.
+ * @param {Function} fn The iterator function. Receives two values, the accumulator and the
+ * current element from the array. Wrapped as transformer, if necessary, and used to
+ * initialize the transducer
+ * @param {*} acc The initial accumulator value.
+ * @param {Array} list The list to iterate over.
+ * @return {*} The final, accumulated value.
+ * @see R.reduce, R.reduced, R.into
+ * @example
+ *
+ * var numbers = [1, 2, 3, 4];
+ * var transducer = R.compose(R.map(R.add(1)), R.take(2));
+ *
+ * R.transduce(transducer, R.flip(R.append), [], numbers); //=> [2, 3]
+ */
+ var transduce = curryN(4, function transduce(xf, fn, acc, list) {
+ return _reduce(xf(typeof fn === 'function' ? _xwrap(fn) : fn), acc, list);
+ });
+
+ /**
+ * Combines two lists into a set (i.e. no duplicates) composed of the elements
+ * of each list. Duplication is determined according to the value returned by
+ * applying the supplied predicate to two list elements.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Relation
+ * @sig (a -> a -> Boolean) -> [*] -> [*] -> [*]
+ * @param {Function} pred A predicate used to test whether two items are equal.
+ * @param {Array} list1 The first list.
+ * @param {Array} list2 The second list.
+ * @return {Array} The first and second lists concatenated, with
+ * duplicates removed.
+ * @see R.union
+ * @example
+ *
+ * var l1 = [{a: 1}, {a: 2}];
+ * var l2 = [{a: 1}, {a: 4}];
+ * R.unionWith(R.eqBy(R.prop('a')), l1, l2); //=> [{a: 1}, {a: 2}, {a: 4}]
+ */
+ var unionWith = _curry3(function unionWith(pred, list1, list2) {
+ return uniqWith(pred, _concat(list1, list2));
+ });
+
+ /**
+ * Takes a spec object and a test object; returns true if the test satisfies
+ * the spec, false otherwise. An object satisfies the spec if, for each of the
+ * spec's own properties, accessing that property of the object gives the same
+ * value (in `R.equals` terms) as accessing that property of the spec.
+ *
+ * `whereEq` is a specialization of [`where`](#where).
+ *
+ * @func
+ * @memberOf R
+ * @since v0.14.0
+ * @category Object
+ * @sig {String: *} -> {String: *} -> Boolean
+ * @param {Object} spec
+ * @param {Object} testObj
+ * @return {Boolean}
+ * @see R.where
+ * @example
+ *
+ * // pred :: Object -> Boolean
+ * var pred = R.whereEq({a: 1, b: 2});
+ *
+ * pred({a: 1}); //=> false
+ * pred({a: 1, b: 2}); //=> true
+ * pred({a: 1, b: 2, c: 3}); //=> true
+ * pred({a: 1, b: 1}); //=> false
+ */
+ var whereEq = _curry2(function whereEq(spec, testObj) {
+ return where(map(equals, spec), testObj);
+ });
+
+ var _flatCat = function () {
+ var preservingReduced = function (xf) {
+ return {
+ '@@transducer/init': _xfBase.init,
+ '@@transducer/result': function (result) {
+ return xf['@@transducer/result'](result);
+ },
+ '@@transducer/step': function (result, input) {
+ var ret = xf['@@transducer/step'](result, input);
+ return ret['@@transducer/reduced'] ? _forceReduced(ret) : ret;
+ }
+ };
+ };
+ return function _xcat(xf) {
+ var rxf = preservingReduced(xf);
+ return {
+ '@@transducer/init': _xfBase.init,
+ '@@transducer/result': function (result) {
+ return rxf['@@transducer/result'](result);
+ },
+ '@@transducer/step': function (result, input) {
+ return !isArrayLike(input) ? _reduce(rxf, result, [input]) : _reduce(rxf, result, input);
+ }
+ };
+ };
+ }();
+
+ // Array.prototype.indexOf doesn't exist below IE9
+ // manually crawl the list to distinguish between +0 and -0
+ // NaN
+ // non-zero numbers can utilise Set
+ // all these types can utilise Set
+ // null can utilise Set
+ // anything else not covered above, defer to R.equals
+ var _indexOf = function _indexOf(list, a, idx) {
+ var inf, item;
+ // Array.prototype.indexOf doesn't exist below IE9
+ if (typeof list.indexOf === 'function') {
+ switch (typeof a) {
+ case 'number':
+ if (a === 0) {
+ // manually crawl the list to distinguish between +0 and -0
+ inf = 1 / a;
+ while (idx < list.length) {
+ item = list[idx];
+ if (item === 0 && 1 / item === inf) {
+ return idx;
+ }
+ idx += 1;
+ }
+ return -1;
+ } else if (a !== a) {
+ // NaN
+ while (idx < list.length) {
+ item = list[idx];
+ if (typeof item === 'number' && item !== item) {
+ return idx;
+ }
+ idx += 1;
+ }
+ return -1;
+ }
+ // non-zero numbers can utilise Set
+ return list.indexOf(a, idx);
+ // all these types can utilise Set
+ case 'string':
+ case 'boolean':
+ case 'function':
+ case 'undefined':
+ return list.indexOf(a, idx);
+ case 'object':
+ if (a === null) {
+ // null can utilise Set
+ return list.indexOf(a, idx);
+ }
+ }
+ }
+ // anything else not covered above, defer to R.equals
+ while (idx < list.length) {
+ if (equals(list[idx], a)) {
+ return idx;
+ }
+ idx += 1;
+ }
+ return -1;
+ };
+
+ var _xchain = _curry2(function _xchain(f, xf) {
+ return map(f, _flatCat(xf));
+ });
+
+ /**
+ * Takes a list of predicates and returns a predicate that returns true for a
+ * given list of arguments if every one of the provided predicates is satisfied
+ * by those arguments.
+ *
+ * The function returned is a curried function whose arity matches that of the
+ * highest-arity predicate.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.9.0
+ * @category Logic
+ * @sig [(*... -> Boolean)] -> (*... -> Boolean)
+ * @param {Array} preds
+ * @return {Function}
+ * @see R.anyPass
+ * @example
+ *
+ * var isQueen = R.propEq('rank', 'Q');
+ * var isSpade = R.propEq('suit', '♠︎');
+ * var isQueenOfSpades = R.allPass([isQueen, isSpade]);
+ *
+ * isQueenOfSpades({rank: 'Q', suit: '♣︎'}); //=> false
+ * isQueenOfSpades({rank: 'Q', suit: '♠︎'}); //=> true
+ */
+ var allPass = _curry1(function allPass(preds) {
+ return curryN(reduce(max, 0, pluck('length', preds)), function () {
+ var idx = 0;
+ var len = preds.length;
+ while (idx < len) {
+ if (!preds[idx].apply(this, arguments)) {
+ return false;
+ }
+ idx += 1;
+ }
+ return true;
+ });
+ });
+
+ /**
+ * Returns `true` if all elements are unique, in `R.equals` terms, otherwise
+ * `false`.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.18.0
+ * @category List
+ * @sig [a] -> Boolean
+ * @param {Array} list The array to consider.
+ * @return {Boolean} `true` if all elements are unique, else `false`.
+ * @example
+ *
+ * R.allUniq(['1', 1]); //=> true
+ * R.allUniq([1, 1]); //=> false
+ * R.allUniq([[42], [42]]); //=> false
+ */
+ var allUniq = _curry1(function allUniq(list) {
+ var len = list.length;
+ var idx = 0;
+ while (idx < len) {
+ if (_indexOf(list, list[idx], idx + 1) >= 0) {
+ return false;
+ }
+ idx += 1;
+ }
+ return true;
+ });
+
+ /**
+ * Takes a list of predicates and returns a predicate that returns true for a
+ * given list of arguments if at least one of the provided predicates is
+ * satisfied by those arguments.
+ *
+ * The function returned is a curried function whose arity matches that of the
+ * highest-arity predicate.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.9.0
+ * @category Logic
+ * @sig [(*... -> Boolean)] -> (*... -> Boolean)
+ * @param {Array} preds
+ * @return {Function}
+ * @see R.allPass
+ * @example
+ *
+ * var gte = R.anyPass([R.gt, R.equals]);
+ *
+ * gte(3, 2); //=> true
+ * gte(2, 2); //=> true
+ * gte(2, 3); //=> false
+ */
+ var anyPass = _curry1(function anyPass(preds) {
+ return curryN(reduce(max, 0, pluck('length', preds)), function () {
+ var idx = 0;
+ var len = preds.length;
+ while (idx < len) {
+ if (preds[idx].apply(this, arguments)) {
+ return true;
+ }
+ idx += 1;
+ }
+ return false;
+ });
+ });
+
+ /**
+ * ap applies a list of functions to a list of values.
+ *
+ * Dispatches to the `ap` method of the second argument, if present. Also
+ * treats functions as applicatives.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.3.0
+ * @category Function
+ * @sig [f] -> [a] -> [f a]
+ * @param {Array} fns An array of functions
+ * @param {Array} vs An array of values
+ * @return {Array} An array of results of applying each of `fns` to all of `vs` in turn.
+ * @example
+ *
+ * R.ap([R.multiply(2), R.add(3)], [1,2,3]); //=> [2, 4, 6, 4, 5, 6]
+ */
+ // else
+ var ap = _curry2(function ap(applicative, fn) {
+ return typeof applicative.ap === 'function' ? applicative.ap(fn) : typeof applicative === 'function' ? curryN(Math.max(applicative.length, fn.length), function () {
+ return applicative.apply(this, arguments)(fn.apply(this, arguments));
+ }) : // else
+ _reduce(function (acc, f) {
+ return _concat(acc, map(f, fn));
+ }, [], applicative);
+ });
+
+ /**
+ * Returns the result of calling its first argument with the remaining
+ * arguments. This is occasionally useful as a converging function for
+ * `R.converge`: the left branch can produce a function while the right branch
+ * produces a value to be passed to that function as an argument.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.9.0
+ * @category Function
+ * @sig (*... -> a),*... -> a
+ * @param {Function} fn The function to apply to the remaining arguments.
+ * @param {...*} args Any number of positional arguments.
+ * @return {*}
+ * @see R.apply
+ * @example
+ *
+ * var indentN = R.pipe(R.times(R.always(' ')),
+ * R.join(''),
+ * R.replace(/^(?!$)/gm));
+ *
+ * var format = R.converge(R.call, [
+ * R.pipe(R.prop('indent'), indentN),
+ * R.prop('value')
+ * ]);
+ *
+ * format({indent: 2, value: 'foo\nbar\nbaz\n'}); //=> ' foo\n bar\n baz\n'
+ */
+ var call = curry(function call(fn) {
+ return fn.apply(this, _slice(arguments, 1));
+ });
+
+ /**
+ * `chain` maps a function over a list and concatenates the results. `chain`
+ * is also known as `flatMap` in some libraries
+ *
+ * Dispatches to the `chain` method of the second argument, if present.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.3.0
+ * @category List
+ * @sig (a -> [b]) -> [a] -> [b]
+ * @param {Function} fn
+ * @param {Array} list
+ * @return {Array}
+ * @example
+ *
+ * var duplicate = n => [n, n];
+ * R.chain(duplicate, [1, 2, 3]); //=> [1, 1, 2, 2, 3, 3]
+ */
+ var chain = _curry2(_dispatchable('chain', _xchain, function chain(fn, monad) {
+ if (typeof monad === 'function') {
+ return function () {
+ return monad.call(this, fn.apply(this, arguments)).apply(this, arguments);
+ };
+ }
+ return _makeFlat(false)(map(fn, monad));
+ }));
+
+ /**
+ * Turns a list of Functors into a Functor of a list, applying a mapping
+ * function to the elements of the list along the way.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.8.0
+ * @category List
+ * @sig Functor f => (a -> f b) -> (x -> f x) -> [a] -> f [b]
+ * @param {Function} fn The transformation function
+ * @param {Function} of A function that returns the data type to return
+ * @param {Array} list An array of functors of the same type
+ * @return {*}
+ * @see R.traverse
+ * @deprecated since v0.19.0
+ * @example
+ *
+ * var add10 = R.map(R.add(10));
+ * R.commuteMap(add10, R.of, [[1], [2, 3]]); //=> [[11, 12], [11, 13]]
+ * R.commuteMap(add10, R.of, [[1, 2], [3]]); //=> [[11, 13], [12, 13]]
+ * R.commuteMap(add10, R.of, [[1], [2], [3]]); //=> [[11, 12, 13]]
+ * R.commuteMap(add10, Maybe.of, [Just(1), Just(2), Just(3)]); //=> Just([11, 12, 13])
+ * R.commuteMap(add10, Maybe.of, [Just(1), Just(2), Nothing()]); //=> Nothing()
+ *
+ * var fetch = url => Future((rej, res) => http.get(url, res).on('error', rej));
+ * R.commuteMap(fetch, Future.of, [
+ * 'http://ramdajs.com',
+ * 'http://github.com/ramda'
+ * ]); //=> Future([IncomingMessage, IncomingMessage])
+ */
+ var commuteMap = _curry3(function commuteMap(fn, of, list) {
+ function consF(acc, x) {
+ return ap(map(prepend, fn(x)), acc);
+ }
+ return reduceRight(consF, of([]), list);
+ });
+
+ /**
+ * Wraps a constructor function inside a curried function that can be called
+ * with the same arguments and returns the same type. The arity of the function
+ * returned is specified to allow using variadic constructor functions.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.4.0
+ * @category Function
+ * @sig Number -> (* -> {*}) -> (* -> {*})
+ * @param {Number} n The arity of the constructor function.
+ * @param {Function} Fn The constructor function to wrap.
+ * @return {Function} A wrapped, curried constructor function.
+ * @example
+ *
+ * // Variadic constructor function
+ * var Widget = () => {
+ * this.children = Array.prototype.slice.call(arguments);
+ * // ...
+ * };
+ * Widget.prototype = {
+ * // ...
+ * };
+ * var allConfigs = [
+ * // ...
+ * ];
+ * R.map(R.constructN(1, Widget), allConfigs); // a list of Widgets
+ */
+ var constructN = _curry2(function constructN(n, Fn) {
+ if (n > 10) {
+ throw new Error('Constructor with greater than ten arguments');
+ }
+ if (n === 0) {
+ return function () {
+ return new Fn();
+ };
+ }
+ return curry(nAry(n, function ($0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+ switch (arguments.length) {
+ case 1:
+ return new Fn($0);
+ case 2:
+ return new Fn($0, $1);
+ case 3:
+ return new Fn($0, $1, $2);
+ case 4:
+ return new Fn($0, $1, $2, $3);
+ case 5:
+ return new Fn($0, $1, $2, $3, $4);
+ case 6:
+ return new Fn($0, $1, $2, $3, $4, $5);
+ case 7:
+ return new Fn($0, $1, $2, $3, $4, $5, $6);
+ case 8:
+ return new Fn($0, $1, $2, $3, $4, $5, $6, $7);
+ case 9:
+ return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8);
+ case 10:
+ return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8, $9);
+ }
+ }));
+ });
+
+ /**
+ * Accepts a converging function and a list of branching functions and returns
+ * a new function. When invoked, this new function is applied to some
+ * arguments, each branching function is applied to those same arguments. The
+ * results of each branching function are passed as arguments to the converging
+ * function to produce the return value.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.4.2
+ * @category Function
+ * @sig (x1 -> x2 -> ... -> z) -> [(a -> b -> ... -> x1), (a -> b -> ... -> x2), ...] -> (a -> b -> ... -> z)
+ * @param {Function} after A function. `after` will be invoked with the return values of
+ * `fn1` and `fn2` as its arguments.
+ * @param {Array} functions A list of functions.
+ * @return {Function} A new function.
+ * @example
+ *
+ * var add = (a, b) => a + b;
+ * var multiply = (a, b) => a * b;
+ * var subtract = (a, b) => a - b;
+ *
+ * //≅ multiply( add(1, 2), subtract(1, 2) );
+ * R.converge(multiply, [add, subtract])(1, 2); //=> -3
+ *
+ * var add3 = (a, b, c) => a + b + c;
+ * R.converge(add3, [multiply, add, subtract])(1, 2); //=> 4
+ */
+ var converge = _curry2(function converge(after, fns) {
+ return curryN(Math.max.apply(Math, pluck('length', fns)), function () {
+ var args = arguments;
+ var context = this;
+ return after.apply(context, _map(function (fn) {
+ return fn.apply(context, args);
+ }, fns));
+ });
+ });
+
+ /**
+ * Returns a new list without any consecutively repeating elements. Equality is
+ * determined by applying the supplied predicate two consecutive elements. The
+ * first element in a series of equal element is the one being preserved.
+ *
+ * Dispatches to the `dropRepeatsWith` method of the second argument, if present.
+ *
+ * Acts as a transducer if a transformer is given in list position.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.14.0
+ * @category List
+ * @sig (a, a -> Boolean) -> [a] -> [a]
+ * @param {Function} pred A predicate used to test whether two items are equal.
+ * @param {Array} list The array to consider.
+ * @return {Array} `list` without repeating elements.
+ * @see R.transduce
+ * @example
+ *
+ * var lengthEq = (x, y) => Math.abs(x) === Math.abs(y);
+ * var l = [1, -1, 1, 3, 4, -4, -4, -5, 5, 3, 3];
+ * R.dropRepeatsWith(R.eqBy(Math.abs), l); //=> [1, 3, 4, -5, 3]
+ */
+ var dropRepeatsWith = _curry2(_dispatchable('dropRepeatsWith', _xdropRepeatsWith, function dropRepeatsWith(pred, list) {
+ var result = [];
+ var idx = 1;
+ var len = list.length;
+ if (len !== 0) {
+ result[0] = list[0];
+ while (idx < len) {
+ if (!pred(last(result), list[idx])) {
+ result[result.length] = list[idx];
+ }
+ idx += 1;
+ }
+ }
+ return result;
+ }));
+
+ /**
+ * Takes a function and two values in its domain and returns `true` if the
+ * values map to the same value in the codomain; `false` otherwise.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.18.0
+ * @category Relation
+ * @sig (a -> b) -> a -> a -> Boolean
+ * @param {Function} f
+ * @param {*} x
+ * @param {*} y
+ * @return {Boolean}
+ * @example
+ *
+ * R.eqBy(Math.abs, 5, -5); //=> true
+ */
+ var eqBy = _curry3(function eqBy(f, x, y) {
+ return equals(f(x), f(y));
+ });
+
+ /**
+ * Reports whether two objects have the same value, in `R.equals` terms, for
+ * the specified property. Useful as a curried predicate.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Object
+ * @sig k -> {k: v} -> {k: v} -> Boolean
+ * @param {String} prop The name of the property to compare
+ * @param {Object} obj1
+ * @param {Object} obj2
+ * @return {Boolean}
+ *
+ * @example
+ *
+ * var o1 = { a: 1, b: 2, c: 3, d: 4 };
+ * var o2 = { a: 10, b: 20, c: 3, d: 40 };
+ * R.eqProps('a', o1, o2); //=> false
+ * R.eqProps('c', o1, o2); //=> true
+ */
+ var eqProps = _curry3(function eqProps(prop, obj1, obj2) {
+ return equals(obj1[prop], obj2[prop]);
+ });
+
+ /**
+ * Returns the position of the first occurrence of an item in an array, or -1
+ * if the item is not included in the array. `R.equals` is used to determine
+ * equality.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category List
+ * @sig a -> [a] -> Number
+ * @param {*} target The item to find.
+ * @param {Array} xs The array to search in.
+ * @return {Number} the index of the target, or -1 if the target is not found.
+ * @see R.lastIndexOf
+ * @example
+ *
+ * R.indexOf(3, [1,2,3,4]); //=> 2
+ * R.indexOf(10, [1,2,3,4]); //=> -1
+ */
+ var indexOf = _curry2(function indexOf(target, xs) {
+ return typeof xs.indexOf === 'function' && !_isArray(xs) ? xs.indexOf(target) : _indexOf(xs, target, 0);
+ });
+
+ /**
+ * juxt applies a list of functions to a list of values.
+ *
+ * @func
+ * @memberOf R
+ * @since 0.19.1
+ * @since 0.19.0
+ * @category Function
+ * @sig [(a, b, ..., m) -> n] -> ((a, b, ..., m) -> [n])
+ * @param {Array} fns An array of functions
+ * @return {Function} A function that returns a list of values after applying each of the original `fns` to its parameters.
+ * @example
+ *
+ * var range = R.juxt([Math.min, Math.max]);
+ * range(3, 4, 9, -3); //=> [-3, 9]
+ */
+ var juxt = _curry1(function juxt(fns) {
+ return function () {
+ return map(apply(__, arguments), fns);
+ };
+ });
+
+ /**
+ * Returns a lens for the given getter and setter functions. The getter "gets"
+ * the value of the focus; the setter "sets" the value of the focus. The setter
+ * should not mutate the data structure.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.8.0
+ * @category Object
+ * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s
+ * @sig (s -> a) -> ((a, s) -> s) -> Lens s a
+ * @param {Function} getter
+ * @param {Function} setter
+ * @return {Lens}
+ * @see R.view, R.set, R.over, R.lensIndex, R.lensProp
+ * @example
+ *
+ * var xLens = R.lens(R.prop('x'), R.assoc('x'));
+ *
+ * R.view(xLens, {x: 1, y: 2}); //=> 1
+ * R.set(xLens, 4, {x: 1, y: 2}); //=> {x: 4, y: 2}
+ * R.over(xLens, R.negate, {x: 1, y: 2}); //=> {x: -1, y: 2}
+ */
+ var lens = _curry2(function lens(getter, setter) {
+ return function (f) {
+ return function (s) {
+ return map(function (v) {
+ return setter(v, s);
+ }, f(getter(s)));
+ };
+ };
+ });
+
+ /**
+ * Returns a lens whose focus is the specified index.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.14.0
+ * @category Object
+ * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s
+ * @sig Number -> Lens s a
+ * @param {Number} n
+ * @return {Lens}
+ * @see R.view, R.set, R.over
+ * @example
+ *
+ * var headLens = R.lensIndex(0);
+ *
+ * R.view(headLens, ['a', 'b', 'c']); //=> 'a'
+ * R.set(headLens, 'x', ['a', 'b', 'c']); //=> ['x', 'b', 'c']
+ * R.over(headLens, R.toUpper, ['a', 'b', 'c']); //=> ['A', 'b', 'c']
+ */
+ var lensIndex = _curry1(function lensIndex(n) {
+ return lens(nth(n), update(n));
+ });
+
+ /**
+ * Returns a lens whose focus is the specified path.
+ *
+ * @func
+ * @memberOf R
+ * @since 0.19.1
+ * @since 0.19.0
+ * @category Object
+ * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s
+ * @sig [String] -> Lens s a
+ * @param {Array} path The path to use.
+ * @return {Lens}
+ * @see R.view, R.set, R.over
+ * @example
+ *
+ * var xyLens = R.lensPath(['x', 'y']);
+ *
+ * R.view(xyLens, {x: {y: 2, z: 3}}); //=> 2
+ * R.set(xyLens, 4, {x: {y: 2, z: 3}}); //=> {x: {y: 4, z: 3}}
+ * R.over(xyLens, R.negate, {x: {y: 2, z: 3}}); //=> {x: {y: -2, z: 3}}
+ */
+ var lensPath = _curry1(function lensPath(p) {
+ return lens(path(p), assocPath(p));
+ });
+
+ /**
+ * Returns a lens whose focus is the specified property.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.14.0
+ * @category Object
+ * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s
+ * @sig String -> Lens s a
+ * @param {String} k
+ * @return {Lens}
+ * @see R.view, R.set, R.over
+ * @example
+ *
+ * var xLens = R.lensProp('x');
+ *
+ * R.view(xLens, {x: 1, y: 2}); //=> 1
+ * R.set(xLens, 4, {x: 1, y: 2}); //=> {x: 4, y: 2}
+ * R.over(xLens, R.negate, {x: 1, y: 2}); //=> {x: -1, y: 2}
+ */
+ var lensProp = _curry1(function lensProp(k) {
+ return lens(prop(k), assoc(k));
+ });
+
+ /**
+ * "lifts" a function to be the specified arity, so that it may "map over" that
+ * many lists (or other objects that satisfies the [FantasyLand Apply spec](https://github.com/fantasyland/fantasy-land#apply)).
+ *
+ * @func
+ * @memberOf R
+ * @since v0.7.0
+ * @category Function
+ * @sig Number -> (*... -> *) -> ([*]... -> [*])
+ * @param {Function} fn The function to lift into higher context
+ * @return {Function} The lifted function.
+ * @see R.lift
+ * @example
+ *
+ * var madd3 = R.liftN(3, R.curryN(3, (...args) => R.sum(args)));
+ * madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]
+ */
+ var liftN = _curry2(function liftN(arity, fn) {
+ var lifted = curryN(arity, fn);
+ return curryN(arity, function () {
+ return _reduce(ap, map(lifted, arguments[0]), _slice(arguments, 1));
+ });
+ });
+
+ /**
+ * Returns the mean of the given list of numbers.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.14.0
+ * @category Math
+ * @sig [Number] -> Number
+ * @param {Array} list
+ * @return {Number}
+ * @example
+ *
+ * R.mean([2, 7, 9]); //=> 6
+ * R.mean([]); //=> NaN
+ */
+ var mean = _curry1(function mean(list) {
+ return sum(list) / list.length;
+ });
+
+ /**
+ * Returns the median of the given list of numbers.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.14.0
+ * @category Math
+ * @sig [Number] -> Number
+ * @param {Array} list
+ * @return {Number}
+ * @example
+ *
+ * R.median([2, 9, 7]); //=> 7
+ * R.median([7, 2, 10, 9]); //=> 8
+ * R.median([]); //=> NaN
+ */
+ var median = _curry1(function median(list) {
+ var len = list.length;
+ if (len === 0) {
+ return NaN;
+ }
+ var width = 2 - len % 2;
+ var idx = (len - width) / 2;
+ return mean(_slice(list).sort(function (a, b) {
+ return a < b ? -1 : a > b ? 1 : 0;
+ }).slice(idx, idx + width));
+ });
+
+ /**
+ * Create a new object with the own properties of the first object merged with
+ * the own properties of the second object. If a key exists in both objects,
+ * the value from the second object will be used.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Object
+ * @sig {k: v} -> {k: v} -> {k: v}
+ * @param {Object} l
+ * @param {Object} r
+ * @return {Object}
+ * @see R.mergeWith, R.mergeWithKey
+ * @example
+ *
+ * R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 });
+ * //=> { 'name': 'fred', 'age': 40 }
+ *
+ * var resetToDefault = R.merge(R.__, {x: 0});
+ * resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2}
+ */
+ var merge = mergeWith(function (l, r) {
+ return r;
+ });
+
+ /**
+ * Merges a list of objects together into one object.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.10.0
+ * @category List
+ * @sig [{k: v}] -> {k: v}
+ * @param {Array} list An array of objects
+ * @return {Object} A merged object.
+ * @see R.reduce
+ * @example
+ *
+ * R.mergeAll([{foo:1},{bar:2},{baz:3}]); //=> {foo:1,bar:2,baz:3}
+ * R.mergeAll([{foo:1},{foo:2},{bar:2}]); //=> {foo:2,bar:2}
+ */
+ var mergeAll = _curry1(function mergeAll(list) {
+ return reduce(merge, {}, list);
+ });
+
+ /**
+ * Performs left-to-right function composition. The leftmost function may have
+ * any arity; the remaining functions must be unary.
+ *
+ * In some libraries this function is named `sequence`.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Function
+ * @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> ((a, b, ..., n) -> z)
+ * @param {...Function} functions
+ * @return {Function}
+ * @see R.compose
+ * @example
+ *
+ * var f = R.pipe(Math.pow, R.negate, R.inc);
+ *
+ * f(3, 4); // -(3^4) + 1
+ */
+ var pipe = function pipe() {
+ if (arguments.length === 0) {
+ throw new Error('pipe requires at least one argument');
+ }
+ return _arity(arguments[0].length, reduce(_pipe, arguments[0], tail(arguments)));
+ };
+
+ /**
+ * Performs left-to-right composition of one or more Promise-returning
+ * functions. The leftmost function may have any arity; the remaining functions
+ * must be unary.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.10.0
+ * @category Function
+ * @sig ((a -> Promise b), (b -> Promise c), ..., (y -> Promise z)) -> (a -> Promise z)
+ * @param {...Function} functions
+ * @return {Function}
+ * @see R.composeP
+ * @example
+ *
+ * // followersForUser :: String -> Promise [User]
+ * var followersForUser = R.pipeP(db.getUserById, db.getFollowers);
+ */
+ var pipeP = function pipeP() {
+ if (arguments.length === 0) {
+ throw new Error('pipeP requires at least one argument');
+ }
+ return _arity(arguments[0].length, reduce(_pipeP, arguments[0], tail(arguments)));
+ };
+
+ /**
+ * Multiplies together all the elements of a list.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Math
+ * @sig [Number] -> Number
+ * @param {Array} list An array of numbers
+ * @return {Number} The product of all the numbers in the list.
+ * @see R.reduce
+ * @example
+ *
+ * R.product([2,4,6,8,100,1]); //=> 38400
+ */
+ var product = reduce(multiply, 1);
+
+ /**
+ * Transforms a [Traversable](https://github.com/fantasyland/fantasy-land#traversable)
+ * of [Applicative](https://github.com/fantasyland/fantasy-land#applicative) into an
+ * Applicative of Traversable.
+ *
+ * Dispatches to the `sequence` method of the second argument, if present.
+ *
+ * @func
+ * @memberOf R
+ * @since 0.19.1
+ * @since 0.19.0
+ * @category List
+ * @sig (Applicative f, Traversable t) => (a -> f a) -> t (f a) -> f (t a)
+ * @param {Function} of
+ * @param {*} traversable
+ * @return {*}
+ * @see R.traverse
+ * @example
+ *
+ * R.sequence(Maybe.of, [Just(1), Just(2), Just(3)]); //=> Just([1, 2, 3])
+ * R.sequence(Maybe.of, [Just(1), Just(2), Nothing()]); //=> Nothing()
+ *
+ * R.sequence(R.of, Just([1, 2, 3])); //=> [Just(1), Just(2), Just(3)]
+ * R.sequence(R.of, Nothing()); //=> [Nothing()]
+ */
+ var sequence = _curry2(function sequence(of, traversable) {
+ return typeof traversable.sequence === 'function' ? traversable.sequence(of) : reduceRight(function (acc, x) {
+ return ap(map(prepend, x), acc);
+ }, of([]), traversable);
+ });
+
+ /**
+ * Maps an [Applicative](https://github.com/fantasyland/fantasy-land#applicative)-returning
+ * function over a [Traversable](https://github.com/fantasyland/fantasy-land#traversable),
+ * then uses [`sequence`](#sequence) to transform the resulting Traversable of Applicative
+ * into an Applicative of Traversable.
+ *
+ * Dispatches to the `sequence` method of the third argument, if present.
+ *
+ * @func
+ * @memberOf R
+ * @since 0.19.1
+ * @since 0.19.0
+ * @category List
+ * @sig (Applicative f, Traversable t) => (a -> f a) -> (a -> f b) -> t a -> f (t b)
+ * @param {Function} of
+ * @param {Function} f
+ * @param {*} traversable
+ * @return {*}
+ * @see R.sequence
+ * @example
+ *
+ * R.traverse(Maybe.of, R.negate, [Just(1), Just(2), Just(3)]); //=> Just([-1, -2, -3])
+ * R.traverse(Maybe.of, R.negate, [Just(1), Just(2), Nothing()]); //=> Nothing()
+ *
+ * R.traverse(R.of, R.negate, Just([1, 2, 3])); //=> [Just(-1), Just(-2), Just(-3)]
+ * R.traverse(R.of, R.negate, Nothing()); //=> [Nothing()]
+ */
+ var traverse = _curry3(function traverse(of, f, traversable) {
+ return sequence(of, map(f, traversable));
+ });
+
+ /**
+ * Shorthand for `R.chain(R.identity)`, which removes one level of nesting from
+ * any [Chain](https://github.com/fantasyland/fantasy-land#chain).
+ *
+ * @func
+ * @memberOf R
+ * @since v0.3.0
+ * @category List
+ * @sig Chain c => c (c a) -> c a
+ * @param {*} list
+ * @return {*}
+ * @see R.flatten, R.chain
+ * @example
+ *
+ * R.unnest([1, [2], [[3]]]); //=> [1, 2, [3]]
+ * R.unnest([[1, 2], [3, 4], [5, 6]]); //=> [1, 2, 3, 4, 5, 6]
+ */
+ var unnest = chain(_identity);
+
+ var _contains = function _contains(a, list) {
+ return _indexOf(list, a, 0) >= 0;
+ };
+
+ var _stepCat = function () {
+ var _stepCatArray = {
+ '@@transducer/init': Array,
+ '@@transducer/step': function (xs, x) {
+ return _concat(xs, [x]);
+ },
+ '@@transducer/result': _identity
+ };
+ var _stepCatString = {
+ '@@transducer/init': String,
+ '@@transducer/step': function (a, b) {
+ return a + b;
+ },
+ '@@transducer/result': _identity
+ };
+ var _stepCatObject = {
+ '@@transducer/init': Object,
+ '@@transducer/step': function (result, input) {
+ return merge(result, isArrayLike(input) ? objOf(input[0], input[1]) : input);
+ },
+ '@@transducer/result': _identity
+ };
+ return function _stepCat(obj) {
+ if (_isTransformer(obj)) {
+ return obj;
+ }
+ if (isArrayLike(obj)) {
+ return _stepCatArray;
+ }
+ if (typeof obj === 'string') {
+ return _stepCatString;
+ }
+ if (typeof obj === 'object') {
+ return _stepCatObject;
+ }
+ throw new Error('Cannot create transformer for ' + obj);
+ };
+ }();
+
+ // mapPairs :: (Object, [String]) -> [String]
+ var _toString = function _toString(x, seen) {
+ var recur = function recur(y) {
+ var xs = seen.concat([x]);
+ return _contains(y, xs) ? '' : _toString(y, xs);
+ };
+ // mapPairs :: (Object, [String]) -> [String]
+ var mapPairs = function (obj, keys) {
+ return _map(function (k) {
+ return _quote(k) + ': ' + recur(obj[k]);
+ }, keys.slice().sort());
+ };
+ switch (Object.prototype.toString.call(x)) {
+ case '[object Arguments]':
+ return '(function() { return arguments; }(' + _map(recur, x).join(', ') + '))';
+ case '[object Array]':
+ return '[' + _map(recur, x).concat(mapPairs(x, reject(function (k) {
+ return /^\d+$/.test(k);
+ }, keys(x)))).join(', ') + ']';
+ case '[object Boolean]':
+ return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString();
+ case '[object Date]':
+ return 'new Date(' + (isNaN(x.valueOf()) ? recur(NaN) : _quote(_toISOString(x))) + ')';
+ case '[object Null]':
+ return 'null';
+ case '[object Number]':
+ return typeof x === 'object' ? 'new Number(' + recur(x.valueOf()) + ')' : 1 / x === -Infinity ? '-0' : x.toString(10);
+ case '[object String]':
+ return typeof x === 'object' ? 'new String(' + recur(x.valueOf()) + ')' : _quote(x);
+ case '[object Undefined]':
+ return 'undefined';
+ default:
+ if (typeof x.toString === 'function') {
+ var repr = x.toString();
+ if (repr !== '[object Object]') {
+ return repr;
+ }
+ }
+ return '{' + mapPairs(x, keys(x)).join(', ') + '}';
+ }
+ };
+
+ /**
+ * Turns a list of Functors into a Functor of a list.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.8.0
+ * @category List
+ * @sig Functor f => (x -> f x) -> [f a] -> f [a]
+ * @param {Function} of A function that returns the data type to return
+ * @param {Array} list An array of functors of the same type
+ * @return {*}
+ * @see R.sequence
+ * @deprecated since v0.19.0
+ * @example
+ *
+ * R.commute(R.of, [[1], [2, 3]]); //=> [[1, 2], [1, 3]]
+ * R.commute(R.of, [[1, 2], [3]]); //=> [[1, 3], [2, 3]]
+ * R.commute(R.of, [[1], [2], [3]]); //=> [[1, 2, 3]]
+ * R.commute(Maybe.of, [Just(1), Just(2), Just(3)]); //=> Just([1, 2, 3])
+ * R.commute(Maybe.of, [Just(1), Just(2), Nothing()]); //=> Nothing()
+ */
+ var commute = commuteMap(identity);
+
+ /**
+ * Performs right-to-left function composition. The rightmost function may have
+ * any arity; the remaining functions must be unary.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Function
+ * @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> ((a, b, ..., n) -> z)
+ * @param {...Function} functions
+ * @return {Function}
+ * @see R.pipe
+ * @example
+ *
+ * var f = R.compose(R.inc, R.negate, Math.pow);
+ *
+ * f(3, 4); // -(3^4) + 1
+ */
+ var compose = function compose() {
+ if (arguments.length === 0) {
+ throw new Error('compose requires at least one argument');
+ }
+ return pipe.apply(this, reverse(arguments));
+ };
+
+ /**
+ * Returns the right-to-left Kleisli composition of the provided functions,
+ * each of which must return a value of a type supported by [`chain`](#chain).
+ *
+ * `R.composeK(h, g, f)` is equivalent to `R.compose(R.chain(h), R.chain(g), R.chain(f))`.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.16.0
+ * @category Function
+ * @sig Chain m => ((y -> m z), (x -> m y), ..., (a -> m b)) -> (m a -> m z)
+ * @param {...Function}
+ * @return {Function}
+ * @see R.pipeK
+ * @example
+ *
+ * // parseJson :: String -> Maybe *
+ * // get :: String -> Object -> Maybe *
+ *
+ * // getStateCode :: Maybe String -> Maybe String
+ * var getStateCode = R.composeK(
+ * R.compose(Maybe.of, R.toUpper),
+ * get('state'),
+ * get('address'),
+ * get('user'),
+ * parseJson
+ * );
+ *
+ * getStateCode(Maybe.of('{"user":{"address":{"state":"ny"}}}'));
+ * //=> Just('NY')
+ * getStateCode(Maybe.of('[Invalid JSON]'));
+ * //=> Nothing()
+ */
+ var composeK = function composeK() {
+ return compose.apply(this, prepend(identity, map(chain, arguments)));
+ };
+
+ /**
+ * Performs right-to-left composition of one or more Promise-returning
+ * functions. The rightmost function may have any arity; the remaining
+ * functions must be unary.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.10.0
+ * @category Function
+ * @sig ((y -> Promise z), (x -> Promise y), ..., (a -> Promise b)) -> (a -> Promise z)
+ * @param {...Function} functions
+ * @return {Function}
+ * @see R.pipeP
+ * @example
+ *
+ * // followersForUser :: String -> Promise [User]
+ * var followersForUser = R.composeP(db.getFollowers, db.getUserById);
+ */
+ var composeP = function composeP() {
+ if (arguments.length === 0) {
+ throw new Error('composeP requires at least one argument');
+ }
+ return pipeP.apply(this, reverse(arguments));
+ };
+
+ /**
+ * Wraps a constructor function inside a curried function that can be called
+ * with the same arguments and returns the same type.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Function
+ * @sig (* -> {*}) -> (* -> {*})
+ * @param {Function} Fn The constructor function to wrap.
+ * @return {Function} A wrapped, curried constructor function.
+ * @example
+ *
+ * // Constructor function
+ * var Widget = config => {
+ * // ...
+ * };
+ * Widget.prototype = {
+ * // ...
+ * };
+ * var allConfigs = [
+ * // ...
+ * ];
+ * R.map(R.construct(Widget), allConfigs); // a list of Widgets
+ */
+ var construct = _curry1(function construct(Fn) {
+ return constructN(Fn.length, Fn);
+ });
+
+ /**
+ * Returns `true` if the specified value is equal, in `R.equals` terms, to at
+ * least one element of the given list; `false` otherwise.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category List
+ * @sig a -> [a] -> Boolean
+ * @param {Object} a The item to compare against.
+ * @param {Array} list The array to consider.
+ * @return {Boolean} `true` if the item is in the list, `false` otherwise.
+ * @see R.any
+ * @example
+ *
+ * R.contains(3, [1, 2, 3]); //=> true
+ * R.contains(4, [1, 2, 3]); //=> false
+ * R.contains([42], [[42]]); //=> true
+ */
+ var contains = _curry2(_contains);
+
+ /**
+ * Finds the set (i.e. no duplicates) of all elements in the first list not
+ * contained in the second list.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Relation
+ * @sig [*] -> [*] -> [*]
+ * @param {Array} list1 The first list.
+ * @param {Array} list2 The second list.
+ * @return {Array} The elements in `list1` that are not in `list2`.
+ * @see R.differenceWith
+ * @example
+ *
+ * R.difference([1,2,3,4], [7,6,5,4,3]); //=> [1,2]
+ * R.difference([7,6,5,4,3], [1,2,3,4]); //=> [7,6,5]
+ */
+ var difference = _curry2(function difference(first, second) {
+ var out = [];
+ var idx = 0;
+ var firstLen = first.length;
+ while (idx < firstLen) {
+ if (!_contains(first[idx], second) && !_contains(first[idx], out)) {
+ out[out.length] = first[idx];
+ }
+ idx += 1;
+ }
+ return out;
+ });
+
+ /**
+ * Returns a new list without any consecutively repeating elements. `R.equals`
+ * is used to determine equality.
+ *
+ * Dispatches to the `dropRepeats` method of the first argument, if present.
+ *
+ * Acts as a transducer if a transformer is given in list position.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.14.0
+ * @category List
+ * @sig [a] -> [a]
+ * @param {Array} list The array to consider.
+ * @return {Array} `list` without repeating elements.
+ * @see R.transduce
+ * @example
+ *
+ * R.dropRepeats([1, 1, 1, 2, 3, 4, 4, 2, 2]); //=> [1, 2, 3, 4, 2]
+ */
+ var dropRepeats = _curry1(_dispatchable('dropRepeats', _xdropRepeatsWith(equals), dropRepeatsWith(equals)));
+
+ /**
+ * Transforms the items of the list with the transducer and appends the
+ * transformed items to the accumulator using an appropriate iterator function
+ * based on the accumulator type.
+ *
+ * The accumulator can be an array, string, object or a transformer. Iterated
+ * items will be appended to arrays and concatenated to strings. Objects will
+ * be merged directly or 2-item arrays will be merged as key, value pairs.
+ *
+ * The accumulator can also be a transformer object that provides a 2-arity
+ * reducing iterator function, step, 0-arity initial value function, init, and
+ * 1-arity result extraction function result. The step function is used as the
+ * iterator function in reduce. The result function is used to convert the
+ * final accumulator into the return type and in most cases is R.identity. The
+ * init function is used to provide the initial accumulator.
+ *
+ * The iteration is performed with R.reduce after initializing the transducer.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.12.0
+ * @category List
+ * @sig a -> (b -> b) -> [c] -> a
+ * @param {*} acc The initial accumulator value.
+ * @param {Function} xf The transducer function. Receives a transformer and returns a transformer.
+ * @param {Array} list The list to iterate over.
+ * @return {*} The final, accumulated value.
+ * @example
+ *
+ * var numbers = [1, 2, 3, 4];
+ * var transducer = R.compose(R.map(R.add(1)), R.take(2));
+ *
+ * R.into([], transducer, numbers); //=> [2, 3]
+ *
+ * var intoArray = R.into([]);
+ * intoArray(transducer, numbers); //=> [2, 3]
+ */
+ var into = _curry3(function into(acc, xf, list) {
+ return _isTransformer(acc) ? _reduce(xf(acc), acc['@@transducer/init'](), list) : _reduce(xf(_stepCat(acc)), acc, list);
+ });
+
+ /**
+ * "lifts" a function of arity > 1 so that it may "map over" an Array or other
+ * object that satisfies the [FantasyLand Apply spec](https://github.com/fantasyland/fantasy-land#apply).
+ *
+ * @func
+ * @memberOf R
+ * @since v0.7.0
+ * @category Function
+ * @sig (*... -> *) -> ([*]... -> [*])
+ * @param {Function} fn The function to lift into higher context
+ * @return {Function} The lifted function.
+ * @see R.liftN
+ * @example
+ *
+ * var madd3 = R.lift(R.curry((a, b, c) => a + b + c));
+ *
+ * madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]
+ *
+ * var madd5 = R.lift(R.curry((a, b, c, d, e) => a + b + c + d + e));
+ *
+ * madd5([1,2], [3], [4, 5], [6], [7, 8]); //=> [21, 22, 22, 23, 22, 23, 23, 24]
+ */
+ var lift = _curry1(function lift(fn) {
+ return liftN(fn.length, fn);
+ });
+
+ /**
+ * Returns a partial copy of an object omitting the keys specified.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Object
+ * @sig [String] -> {String: *} -> {String: *}
+ * @param {Array} names an array of String property names to omit from the new object
+ * @param {Object} obj The object to copy from
+ * @return {Object} A new object with properties from `names` not on it.
+ * @see R.pick
+ * @example
+ *
+ * R.omit(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, c: 3}
+ */
+ var omit = _curry2(function omit(names, obj) {
+ var result = {};
+ for (var prop in obj) {
+ if (!_contains(prop, names)) {
+ result[prop] = obj[prop];
+ }
+ }
+ return result;
+ });
+
+ /**
+ * Returns the left-to-right Kleisli composition of the provided functions,
+ * each of which must return a value of a type supported by [`chain`](#chain).
+ *
+ * `R.pipeK(f, g, h)` is equivalent to `R.pipe(R.chain(f), R.chain(g), R.chain(h))`.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.16.0
+ * @category Function
+ * @sig Chain m => ((a -> m b), (b -> m c), ..., (y -> m z)) -> (m a -> m z)
+ * @param {...Function}
+ * @return {Function}
+ * @see R.composeK
+ * @example
+ *
+ * // parseJson :: String -> Maybe *
+ * // get :: String -> Object -> Maybe *
+ *
+ * // getStateCode :: Maybe String -> Maybe String
+ * var getStateCode = R.pipeK(
+ * parseJson,
+ * get('user'),
+ * get('address'),
+ * get('state'),
+ * R.compose(Maybe.of, R.toUpper)
+ * );
+ *
+ * getStateCode(Maybe.of('{"user":{"address":{"state":"ny"}}}'));
+ * //=> Just('NY')
+ * getStateCode(Maybe.of('[Invalid JSON]'));
+ * //=> Nothing()
+ */
+ var pipeK = function pipeK() {
+ return composeK.apply(this, reverse(arguments));
+ };
+
+ /**
+ * Returns the string representation of the given value. `eval`'ing the output
+ * should result in a value equivalent to the input value. Many of the built-in
+ * `toString` methods do not satisfy this requirement.
+ *
+ * If the given value is an `[object Object]` with a `toString` method other
+ * than `Object.prototype.toString`, this method is invoked with no arguments
+ * to produce the return value. This means user-defined constructor functions
+ * can provide a suitable `toString` method. For example:
+ *
+ * function Point(x, y) {
+ * this.x = x;
+ * this.y = y;
+ * }
+ *
+ * Point.prototype.toString = function() {
+ * return 'new Point(' + this.x + ', ' + this.y + ')';
+ * };
+ *
+ * R.toString(new Point(1, 2)); //=> 'new Point(1, 2)'
+ *
+ * @func
+ * @memberOf R
+ * @since v0.14.0
+ * @category String
+ * @sig * -> String
+ * @param {*} val
+ * @return {String}
+ * @example
+ *
+ * R.toString(42); //=> '42'
+ * R.toString('abc'); //=> '"abc"'
+ * R.toString([1, 2, 3]); //=> '[1, 2, 3]'
+ * R.toString({foo: 1, bar: 2, baz: 3}); //=> '{"bar": 2, "baz": 3, "foo": 1}'
+ * R.toString(new Date('2001-02-03T04:05:06Z')); //=> 'new Date("2001-02-03T04:05:06.000Z")'
+ */
+ var toString = _curry1(function toString(val) {
+ return _toString(val, []);
+ });
+
+ /**
+ * Returns a new list containing only one copy of each element in the original
+ * list, based upon the value returned by applying the supplied function to
+ * each list element. Prefers the first item if the supplied function produces
+ * the same value on two items. `R.equals` is used for comparison.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.16.0
+ * @category List
+ * @sig (a -> b) -> [a] -> [a]
+ * @param {Function} fn A function used to produce a value to use during comparisons.
+ * @param {Array} list The array to consider.
+ * @return {Array} The list of unique items.
+ * @example
+ *
+ * R.uniqBy(Math.abs, [-1, -5, 2, 10, 1, 2]); //=> [-1, -5, 2, 10]
+ */
+ /* globals Set */
+ // distinguishing between +0 and -0 is not supported by Set
+ /* falls through */
+ // these types can all utilise Set
+ // prevent scan for null by tracking as a boolean
+ /* falls through */
+ // scan through all previously applied items
+ var uniqBy = _curry2(/* globals Set */
+ typeof Set === 'undefined' ? function uniqBy(fn, list) {
+ var idx = 0;
+ var applied = [];
+ var result = [];
+ var appliedItem, item;
+ while (idx < list.length) {
+ item = list[idx];
+ appliedItem = fn(item);
+ if (!_contains(appliedItem, applied)) {
+ result.push(item);
+ applied.push(appliedItem);
+ }
+ idx += 1;
+ }
+ return result;
+ } : function uniqBySet(fn, list) {
+ var set = new Set();
+ var applied = [];
+ var prevSetSize = 0;
+ var result = [];
+ var nullExists = false;
+ var negZeroExists = false;
+ var idx = 0;
+ var appliedItem, item, newSetSize;
+ while (idx < list.length) {
+ item = list[idx];
+ appliedItem = fn(item);
+ switch (typeof appliedItem) {
+ case 'number':
+ // distinguishing between +0 and -0 is not supported by Set
+ if (appliedItem === 0 && !negZeroExists && 1 / appliedItem === -Infinity) {
+ negZeroExists = true;
+ result.push(item);
+ break;
+ }
+ /* falls through */
+ case 'string':
+ case 'boolean':
+ case 'function':
+ case 'undefined':
+ // these types can all utilise Set
+ set.add(appliedItem);
+ newSetSize = set.size;
+ if (newSetSize > prevSetSize) {
+ result.push(item);
+ prevSetSize = newSetSize;
+ }
+ break;
+ case 'object':
+ if (appliedItem === null) {
+ if (!nullExists) {
+ // prevent scan for null by tracking as a boolean
+ nullExists = true;
+ result.push(null);
+ }
+ break;
+ }
+ /* falls through */
+ default:
+ // scan through all previously applied items
+ if (!_contains(appliedItem, applied)) {
+ applied.push(appliedItem);
+ result.push(item);
+ }
+ }
+ idx += 1;
+ }
+ return result;
+ });
+
+ /**
+ * Returns a new list without values in the first argument.
+ * `R.equals` is used to determine equality.
+ *
+ * Acts as a transducer if a transformer is given in list position.
+ *
+ * @func
+ * @memberOf R
+ * @since 0.19.1
+ * @since 0.19.0
+ * @category List
+ * @sig [a] -> [a] -> [a]
+ * @param {Array} list1 The values to be removed from `list2`.
+ * @param {Array} list2 The array to remove values from.
+ * @return {Array} The new array without values in `list1`.
+ * @see R.transduce
+ * @example
+ *
+ * R.without([1, 2], [1, 2, 1, 3, 4]); //=> [3, 4]
+ */
+ var without = _curry2(function (xs, list) {
+ return reject(flip(_contains)(xs), list);
+ });
+
+ /**
+ * Takes a function `f` and returns a function `g` such that:
+ *
+ * - applying `g` to zero or more arguments will give __true__ if applying
+ * the same arguments to `f` gives a logical __false__ value; and
+ *
+ * - applying `g` to zero or more arguments will give __false__ if applying
+ * the same arguments to `f` gives a logical __true__ value.
+ *
+ * `R.complement` will work on all other functors as well.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.12.0
+ * @category Logic
+ * @sig (*... -> *) -> (*... -> Boolean)
+ * @param {Function} f
+ * @return {Function}
+ * @see R.not
+ * @example
+ *
+ * var isEven = n => n % 2 === 0;
+ * var isOdd = R.complement(isEven);
+ * isOdd(21); //=> true
+ * isOdd(42); //=> false
+ */
+ var complement = lift(not);
+
+ /**
+ * Turns a named method with a specified arity into a function that can be
+ * called directly supplied with arguments and a target object.
+ *
+ * The returned function is curried and accepts `arity + 1` parameters where
+ * the final parameter is the target object.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Function
+ * @sig Number -> String -> (a -> b -> ... -> n -> Object -> *)
+ * @param {Number} arity Number of arguments the returned function should take
+ * before the target object.
+ * @param {String} method Name of the method to call.
+ * @return {Function} A new curried function.
+ * @example
+ *
+ * var sliceFrom = R.invoker(1, 'slice');
+ * sliceFrom(6, 'abcdefghijklm'); //=> 'ghijklm'
+ * var sliceFrom6 = R.invoker(2, 'slice')(6);
+ * sliceFrom6(8, 'abcdefghijklm'); //=> 'gh'
+ */
+ var invoker = _curry2(function invoker(arity, method) {
+ return curryN(arity + 1, function () {
+ var target = arguments[arity];
+ if (target != null && is(Function, target[method])) {
+ return target[method].apply(target, _slice(arguments, 0, arity));
+ }
+ throw new TypeError(toString(target) + ' does not have a method named "' + method + '"');
+ });
+ });
+
+ /**
+ * Returns a string made by inserting the `separator` between each element and
+ * concatenating all the elements into a single string.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category List
+ * @sig String -> [a] -> String
+ * @param {Number|String} separator The string used to separate the elements.
+ * @param {Array} xs The elements to join into a string.
+ * @return {String} str The string made by concatenating `xs` with `separator`.
+ * @see R.split
+ * @example
+ *
+ * var spacer = R.join(' ');
+ * spacer(['a', 2, 3.4]); //=> 'a 2 3.4'
+ * R.join('|', [1, 2, 3]); //=> '1|2|3'
+ */
+ var join = invoker(1, 'join');
+
+ /**
+ * Creates a new function that, when invoked, caches the result of calling `fn`
+ * for a given argument set and returns the result. Subsequent calls to the
+ * memoized `fn` with the same argument set will not result in an additional
+ * call to `fn`; instead, the cached result for that set of arguments will be
+ * returned.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Function
+ * @sig (*... -> a) -> (*... -> a)
+ * @param {Function} fn The function to memoize.
+ * @return {Function} Memoized version of `fn`.
+ * @example
+ *
+ * var count = 0;
+ * var factorial = R.memoize(n => {
+ * count += 1;
+ * return R.product(R.range(1, n + 1));
+ * });
+ * factorial(5); //=> 120
+ * factorial(5); //=> 120
+ * factorial(5); //=> 120
+ * count; //=> 1
+ */
+ var memoize = _curry1(function memoize(fn) {
+ var cache = {};
+ return _arity(fn.length, function () {
+ var key = toString(arguments);
+ if (!_has(key, cache)) {
+ cache[key] = fn.apply(this, arguments);
+ }
+ return cache[key];
+ });
+ });
+
+ /**
+ * Splits a string into an array of strings based on the given
+ * separator.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category String
+ * @sig (String | RegExp) -> String -> [String]
+ * @param {String|RegExp} sep The pattern.
+ * @param {String} str The string to separate into an array.
+ * @return {Array} The array of strings from `str` separated by `str`.
+ * @see R.join
+ * @example
+ *
+ * var pathComponents = R.split('/');
+ * R.tail(pathComponents('/usr/local/bin/node')); //=> ['usr', 'local', 'bin', 'node']
+ *
+ * R.split('.', 'a.b.c.xyz.d'); //=> ['a', 'b', 'c', 'xyz', 'd']
+ */
+ var split = invoker(1, 'split');
+
+ /**
+ * Determines whether a given string matches a given regular expression.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.12.0
+ * @category String
+ * @sig RegExp -> String -> Boolean
+ * @param {RegExp} pattern
+ * @param {String} str
+ * @return {Boolean}
+ * @see R.match
+ * @example
+ *
+ * R.test(/^x/, 'xyz'); //=> true
+ * R.test(/^y/, 'xyz'); //=> false
+ */
+ var test = _curry2(function test(pattern, str) {
+ if (!_isRegExp(pattern)) {
+ throw new TypeError('\u2018test\u2019 requires a value of type RegExp as its first argument; received ' + toString(pattern));
+ }
+ return _cloneRegExp(pattern).test(str);
+ });
+
+ /**
+ * The lower case version of a string.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.9.0
+ * @category String
+ * @sig String -> String
+ * @param {String} str The string to lower case.
+ * @return {String} The lower case version of `str`.
+ * @see R.toUpper
+ * @example
+ *
+ * R.toLower('XYZ'); //=> 'xyz'
+ */
+ var toLower = invoker(0, 'toLowerCase');
+
+ /**
+ * The upper case version of a string.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.9.0
+ * @category String
+ * @sig String -> String
+ * @param {String} str The string to upper case.
+ * @return {String} The upper case version of `str`.
+ * @see R.toLower
+ * @example
+ *
+ * R.toUpper('abc'); //=> 'ABC'
+ */
+ var toUpper = invoker(0, 'toUpperCase');
+
+ /**
+ * Returns a new list containing only one copy of each element in the original
+ * list. `R.equals` is used to determine equality.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category List
+ * @sig [a] -> [a]
+ * @param {Array} list The array to consider.
+ * @return {Array} The list of unique items.
+ * @example
+ *
+ * R.uniq([1, 1, 2, 1]); //=> [1, 2]
+ * R.uniq([1, '1']); //=> [1, '1']
+ * R.uniq([[42], [42]]); //=> [[42]]
+ */
+ var uniq = uniqBy(identity);
+
+ /**
+ * Returns the result of concatenating the given lists or strings.
+ *
+ * Dispatches to the `concat` method of the second argument, if present.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category List
+ * @sig [a] -> [a] -> [a]
+ * @sig String -> String -> String
+ * @param {Array|String} a
+ * @param {Array|String} b
+ * @return {Array|String}
+ *
+ * @example
+ *
+ * R.concat([], []); //=> []
+ * R.concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]
+ * R.concat('ABC', 'DEF'); // 'ABCDEF'
+ */
+ var concat = flip(invoker(1, 'concat'));
+
+ /**
+ * Combines two lists into a set (i.e. no duplicates) composed of those
+ * elements common to both lists.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Relation
+ * @sig [*] -> [*] -> [*]
+ * @param {Array} list1 The first list.
+ * @param {Array} list2 The second list.
+ * @return {Array} The list of elements found in both `list1` and `list2`.
+ * @see R.intersectionWith
+ * @example
+ *
+ * R.intersection([1,2,3,4], [7,6,5,4,3]); //=> [4, 3]
+ */
+ var intersection = _curry2(function intersection(list1, list2) {
+ return uniq(_filter(flip(_contains)(list1), list2));
+ });
+
+ /**
+ * Finds the set (i.e. no duplicates) of all elements contained in the first or
+ * second list, but not both.
+ *
+ * @func
+ * @memberOf R
+ * @since 0.19.1
+ * @since 0.19.0
+ * @category Relation
+ * @sig [*] -> [*] -> [*]
+ * @param {Array} list1 The first list.
+ * @param {Array} list2 The second list.
+ * @return {Array} The elements in `list1` or `list2`, but not both.
+ * @see R.symmetricDifferenceWith
+ * @example
+ *
+ * R.symmetricDifference([1,2,3,4], [7,6,5,4,3]); //=> [1,2,7,6,5]
+ * R.symmetricDifference([7,6,5,4,3], [1,2,3,4]); //=> [7,6,5,1,2]
+ */
+ var symmetricDifference = _curry2(function symmetricDifference(list1, list2) {
+ return concat(difference(list1, list2), difference(list2, list1));
+ });
+
+ /**
+ * Finds the set (i.e. no duplicates) of all elements contained in the first or
+ * second list, but not both. Duplication is determined according to the value
+ * returned by applying the supplied predicate to two list elements.
+ *
+ * @func
+ * @memberOf R
+ * @since 0.19.1
+ * @since 0.19.0
+ * @category Relation
+ * @sig (a -> a -> Boolean) -> [a] -> [a] -> [a]
+ * @param {Function} pred A predicate used to test whether two items are equal.
+ * @param {Array} list1 The first list.
+ * @param {Array} list2 The second list.
+ * @return {Array} The elements in `list1` or `list2`, but not both.
+ * @see R.symmetricDifference
+ * @example
+ *
+ * var eqA = R.eqBy(R.prop('a'));
+ * var l1 = [{a: 1}, {a: 2}, {a: 3}, {a: 4}];
+ * var l2 = [{a: 3}, {a: 4}, {a: 5}, {a: 6}];
+ * R.symmetricDifferenceWith(eqA, l1, l2); //=> [{a: 1}, {a: 2}, {a: 5}, {a: 6}]
+ */
+ var symmetricDifferenceWith = _curry3(function symmetricDifferenceWith(pred, list1, list2) {
+ return concat(differenceWith(pred, list1, list2), differenceWith(pred, list2, list1));
+ });
+
+ /**
+ * Combines two lists into a set (i.e. no duplicates) composed of the elements
+ * of each list.
+ *
+ * @func
+ * @memberOf R
+ * @since v0.1.0
+ * @category Relation
+ * @sig [*] -> [*] -> [*]
+ * @param {Array} as The first list.
+ * @param {Array} bs The second list.
+ * @return {Array} The first and second lists concatenated, with
+ * duplicates removed.
+ * @example
+ *
+ * R.union([1, 2, 3], [2, 3, 4]); //=> [1, 2, 3, 4]
+ */
+ var union = _curry2(compose(uniq, _concat));
+
+ var R = {
+ F: F,
+ T: T,
+ __: __,
+ add: add,
+ addIndex: addIndex,
+ adjust: adjust,
+ all: all,
+ allPass: allPass,
+ allUniq: allUniq,
+ always: always,
+ and: and,
+ any: any,
+ anyPass: anyPass,
+ ap: ap,
+ aperture: aperture,
+ append: append,
+ apply: apply,
+ assoc: assoc,
+ assocPath: assocPath,
+ binary: binary,
+ bind: bind,
+ both: both,
+ call: call,
+ chain: chain,
+ clone: clone,
+ commute: commute,
+ commuteMap: commuteMap,
+ comparator: comparator,
+ complement: complement,
+ compose: compose,
+ composeK: composeK,
+ composeP: composeP,
+ concat: concat,
+ cond: cond,
+ construct: construct,
+ constructN: constructN,
+ contains: contains,
+ converge: converge,
+ countBy: countBy,
+ curry: curry,
+ curryN: curryN,
+ dec: dec,
+ defaultTo: defaultTo,
+ difference: difference,
+ differenceWith: differenceWith,
+ dissoc: dissoc,
+ dissocPath: dissocPath,
+ divide: divide,
+ drop: drop,
+ dropLast: dropLast,
+ dropLastWhile: dropLastWhile,
+ dropRepeats: dropRepeats,
+ dropRepeatsWith: dropRepeatsWith,
+ dropWhile: dropWhile,
+ either: either,
+ empty: empty,
+ eqBy: eqBy,
+ eqProps: eqProps,
+ equals: equals,
+ evolve: evolve,
+ filter: filter,
+ find: find,
+ findIndex: findIndex,
+ findLast: findLast,
+ findLastIndex: findLastIndex,
+ flatten: flatten,
+ flip: flip,
+ forEach: forEach,
+ fromPairs: fromPairs,
+ groupBy: groupBy,
+ gt: gt,
+ gte: gte,
+ has: has,
+ hasIn: hasIn,
+ head: head,
+ identical: identical,
+ identity: identity,
+ ifElse: ifElse,
+ inc: inc,
+ indexBy: indexBy,
+ indexOf: indexOf,
+ init: init,
+ insert: insert,
+ insertAll: insertAll,
+ intersection: intersection,
+ intersectionWith: intersectionWith,
+ intersperse: intersperse,
+ into: into,
+ invert: invert,
+ invertObj: invertObj,
+ invoker: invoker,
+ is: is,
+ isArrayLike: isArrayLike,
+ isEmpty: isEmpty,
+ isNil: isNil,
+ join: join,
+ juxt: juxt,
+ keys: keys,
+ keysIn: keysIn,
+ last: last,
+ lastIndexOf: lastIndexOf,
+ length: length,
+ lens: lens,
+ lensIndex: lensIndex,
+ lensPath: lensPath,
+ lensProp: lensProp,
+ lift: lift,
+ liftN: liftN,
+ lt: lt,
+ lte: lte,
+ map: map,
+ mapAccum: mapAccum,
+ mapAccumRight: mapAccumRight,
+ mapObjIndexed: mapObjIndexed,
+ match: match,
+ mathMod: mathMod,
+ max: max,
+ maxBy: maxBy,
+ mean: mean,
+ median: median,
+ memoize: memoize,
+ merge: merge,
+ mergeAll: mergeAll,
+ mergeWith: mergeWith,
+ mergeWithKey: mergeWithKey,
+ min: min,
+ minBy: minBy,
+ modulo: modulo,
+ multiply: multiply,
+ nAry: nAry,
+ negate: negate,
+ none: none,
+ not: not,
+ nth: nth,
+ nthArg: nthArg,
+ objOf: objOf,
+ of: of,
+ omit: omit,
+ once: once,
+ or: or,
+ over: over,
+ pair: pair,
+ partial: partial,
+ partialRight: partialRight,
+ partition: partition,
+ path: path,
+ pathEq: pathEq,
+ pathOr: pathOr,
+ pathSatisfies: pathSatisfies,
+ pick: pick,
+ pickAll: pickAll,
+ pickBy: pickBy,
+ pipe: pipe,
+ pipeK: pipeK,
+ pipeP: pipeP,
+ pluck: pluck,
+ prepend: prepend,
+ product: product,
+ project: project,
+ prop: prop,
+ propEq: propEq,
+ propIs: propIs,
+ propOr: propOr,
+ propSatisfies: propSatisfies,
+ props: props,
+ range: range,
+ reduce: reduce,
+ reduceRight: reduceRight,
+ reduced: reduced,
+ reject: reject,
+ remove: remove,
+ repeat: repeat,
+ replace: replace,
+ reverse: reverse,
+ scan: scan,
+ sequence: sequence,
+ set: set,
+ slice: slice,
+ sort: sort,
+ sortBy: sortBy,
+ split: split,
+ splitAt: splitAt,
+ splitEvery: splitEvery,
+ splitWhen: splitWhen,
+ subtract: subtract,
+ sum: sum,
+ symmetricDifference: symmetricDifference,
+ symmetricDifferenceWith: symmetricDifferenceWith,
+ tail: tail,
+ take: take,
+ takeLast: takeLast,
+ takeLastWhile: takeLastWhile,
+ takeWhile: takeWhile,
+ tap: tap,
+ test: test,
+ times: times,
+ toLower: toLower,
+ toPairs: toPairs,
+ toPairsIn: toPairsIn,
+ toString: toString,
+ toUpper: toUpper,
+ transduce: transduce,
+ transpose: transpose,
+ traverse: traverse,
+ trim: trim,
+ type: type,
+ unapply: unapply,
+ unary: unary,
+ uncurryN: uncurryN,
+ unfold: unfold,
+ union: union,
+ unionWith: unionWith,
+ uniq: uniq,
+ uniqBy: uniqBy,
+ uniqWith: uniqWith,
+ unless: unless,
+ unnest: unnest,
+ update: update,
+ useWith: useWith,
+ values: values,
+ valuesIn: valuesIn,
+ view: view,
+ when: when,
+ where: where,
+ whereEq: whereEq,
+ without: without,
+ wrap: wrap,
+ xprod: xprod,
+ zip: zip,
+ zipObj: zipObj,
+ zipWith: zipWith
+ };
+ /* eslint-env amd */
+
+ /* TEST_ENTRY_POINT */
+
+ if (typeof exports === 'object') {
+ module.exports = R;
+ } else if (typeof define === 'function' && define.amd) {
+ define(function() { return R; });
+ } else {
+ this.R = R;
+ }
+
+}.call(this));
diff --git a/vendor/sanctuary-def.js b/vendor/sanctuary-def.js
new file mode 100644
index 0000000..ae0f6db
--- /dev/null
+++ b/vendor/sanctuary-def.js
@@ -0,0 +1,923 @@
+/* global define, self */
+
+;(function(f) {
+
+ 'use strict';
+
+ /* istanbul ignore else */
+ if (typeof module !== 'undefined') {
+ module.exports = f();
+ } else if (typeof define === 'function' && define.amd != null) {
+ define([], f);
+ } else {
+ self.sanctuaryDef = f();
+ }
+
+}(function() {
+
+ 'use strict';
+
+ var $ = {};
+
+ var MAX_SAFE_INTEGER = Math.pow(2, 53) - 1;
+ var MIN_SAFE_INTEGER = -MAX_SAFE_INTEGER;
+
+ var LEFT_SINGLE_QUOTATION_MARK = '\u2018';
+ var RIGHT_SINGLE_QUOTATION_MARK = '\u2019';
+
+ var push = Array.prototype.push;
+ var hasOwnProperty = Object.prototype.hasOwnProperty;
+ var toString = Object.prototype.toString;
+
+ // K :: a -> b -> a
+ var K = function(x) { return function(y) { return x; }; };
+
+ // all :: ([a], (a -> Boolean)) -> Boolean
+ var all = function(xs, pred) {
+ for (var idx = 0; idx < xs.length; idx += 1) {
+ if (!pred(xs[idx])) return false;
+ }
+ return true;
+ };
+
+ // always :: a -> (-> a)
+ var always = function(x) { return function() { return x; }; };
+
+ // any :: ([a], (a -> Boolean)) -> Boolean
+ var any = function(xs, pred) {
+ for (var idx = 0; idx < xs.length; idx += 1) {
+ if (pred(xs[idx])) return true;
+ }
+ return false;
+ };
+
+ // chain :: ([a], (a -> [b])) -> [b]
+ var chain = function(xs, f) {
+ var result = [];
+ for (var idx = 0; idx < xs.length; idx += 1) {
+ push.apply(result, f(xs[idx]));
+ }
+ return result;
+ };
+
+ // eqProps :: String -> Object -> Object -> Boolean
+ var eqProps = function(key) {
+ return function(o1) {
+ return function(o2) {
+ return o1[key] === o2[key];
+ };
+ };
+ };
+
+ // has :: (String, Object) -> Boolean
+ var has = function(key, obj) { return hasOwnProperty.call(obj, key); };
+
+ // id :: a -> a
+ var id = function(x) { return x; };
+
+ // isEmpty :: [a] -> Boolean
+ var isEmpty = function(xs) { return xs.length === 0; };
+
+ // keys :: Object -> [String]
+ var keys = function(obj) {
+ var result = [];
+ for (var key in obj) if (has(key, obj)) result.push(key);
+ return result.sort();
+ };
+
+ // map :: ([a], (a -> b)) -> [b]
+ var map = function(xs, f) {
+ var result = [];
+ for (var idx = 0; idx < xs.length; idx += 1) result.push(f(xs[idx]));
+ return result;
+ };
+
+ // or :: ([a], [a]) -> [a]
+ var or = function(xs, ys) { return isEmpty(xs) ? ys : xs; };
+
+ // prefix :: String -> String -> String
+ var prefix = function(x) {
+ return function(y) {
+ return x + y;
+ };
+ };
+
+ // quote :: String -> String
+ var quote = function(s) {
+ var escaped = s
+ .replace(/\\/g, '\\\\')
+ // \b matches word boundary; [\b] matches backspace
+ .replace(/[\b]/g, '\\b')
+ .replace(/\f/g, '\\f')
+ .replace(/\n/g, '\\n')
+ .replace(/\r/g, '\\r')
+ .replace(/\t/g, '\\t')
+ .replace(/\v/g, '\\v')
+ .replace(/\0/g, '\\0');
+
+ return '"' + escaped.replace(/"/g, '\\"') + '"';
+ };
+
+ // range :: (Number, Number) -> [Number]
+ var range = function(start, stop) {
+ var result = [];
+ for (var n = start; n < stop; n += 1) result.push(n);
+ return result;
+ };
+
+ // stripNamespace :: String -> String
+ var stripNamespace = function(s) { return s.slice(s.indexOf('/') + 1); };
+
+ // typeOf :: a -> String
+ var typeOf = function(x) {
+ return toString.call(x).slice('[object '.length, -']'.length);
+ };
+
+ var _show = function show(x, seen) {
+ var recur = function(y) {
+ var xs = seen.concat([x]);
+ return xs.indexOf(y) >= 0 ? '' : show(y, xs);
+ };
+
+ // formatKeyVal :: Object -> String -> String
+ var formatKeyVal = function(obj) {
+ return function(key) {
+ return quote(key) + ': ' + recur(obj[key]);
+ };
+ };
+
+ switch (typeOf(x)) {
+ case 'Arguments':
+ return '(function() { return arguments; }(' +
+ map(x, recur).join(', ') + '))';
+ case 'Array':
+ var reprs = map(x, recur).concat(chain(keys(x), function(k) {
+ return /^\d+$/.test(k) ? [] : [formatKeyVal(x)(k)];
+ }));
+ return '[' + reprs.join(', ') + ']';
+ case 'Boolean':
+ return typeof x === 'object' ?
+ 'new Boolean(' + recur(x.valueOf()) + ')' :
+ x.toString();
+ case 'Date':
+ return 'new Date(' +
+ (isNaN(x.valueOf()) ? recur(NaN) : quote(x.toISOString())) +
+ ')';
+ case 'Null':
+ return 'null';
+ case 'Number':
+ return typeof x === 'object' ?
+ 'new Number(' + recur(x.valueOf()) + ')' :
+ 1 / x === -Infinity ? '-0' : x.toString(10);
+ case 'String':
+ return typeof x === 'object' ?
+ 'new String(' + recur(x.valueOf()) + ')' :
+ quote(x);
+ case 'Undefined':
+ return 'undefined';
+ default:
+ if (typeof x.toString === 'function') {
+ var repr = x.toString();
+ if (repr !== '[object Object]') return repr;
+ }
+ return '{' + map(keys(x), formatKeyVal(x)).join(', ') + '}';
+ }
+ };
+
+ // show :: a -> String
+ var show = function(x) { return _show(x, []); };
+
+ // TypeClass :: (String, (a -> Boolean)) -> TypeClass
+ $.TypeClass = function(name, test) {
+ return {
+ name: name,
+ test: test,
+ toString: always(stripNamespace(name))
+ };
+ };
+
+ // Any :: Type
+ var Any = {
+ '@@type': 'sanctuary-def/Type',
+ type: 'ANY',
+ test: K(true),
+ toString: always('Any')
+ };
+
+ // Unknown :: Type
+ var Unknown = {
+ '@@type': 'sanctuary-def/Type',
+ type: 'UNKNOWN',
+ test: K(true),
+ toString: always('???')
+ };
+
+ // TypeVariable :: String -> Type
+ $.TypeVariable = function(name) {
+ return {
+ '@@type': 'sanctuary-def/Type',
+ type: 'VARIABLE',
+ name: name,
+ test: K(true),
+ toString: always(name)
+ };
+ };
+
+ // NullaryType :: (String, (x -> Boolean)) -> Type
+ var NullaryType = $.NullaryType = function(name, test) {
+ return {
+ '@@type': 'sanctuary-def/Type',
+ type: 'NULLARY',
+ name: name,
+ test: test,
+ toString: always(stripNamespace(name))
+ };
+ };
+
+ // UnaryType :: (String, (x -> Boolean), (t a -> [a])) -> Type -> Type
+ var UnaryType = $.UnaryType = function(name, test, _1) {
+ return function($1) {
+ return {
+ '@@type': 'sanctuary-def/Type',
+ type: 'UNARY',
+ name: name,
+ test: function(x) { return test(x) && all(_1(x), $1.test); },
+ toString: always('(' + stripNamespace(name) + ' ' + $1 + ')'),
+ _1: _1,
+ $1: $1
+ };
+ };
+ };
+
+ // UnaryType.from :: Type -> Type
+ UnaryType.from = function(t) {
+ return UnaryType(t.name, t.test, t._1);
+ };
+
+ // BinaryType :: (String, (x -> Boolean), (t a b -> [a]), (t a b -> [b])) ->
+ // (Type, Type) -> Type
+ var BinaryType = $.BinaryType = function(name, test, _1, _2) {
+ return function($1, $2) {
+ return {
+ '@@type': 'sanctuary-def/Type',
+ type: 'BINARY',
+ name: name,
+ test: function(x) { return test(x) && all(_1(x), $1.test) &&
+ all(_2(x), $2.test); },
+ toString:
+ always('(' + stripNamespace(name) + ' ' + $1 + ' ' + $2 + ')'),
+ _1: _1,
+ _2: _2,
+ $1: $1,
+ $2: $2
+ };
+ };
+ };
+
+ // BinaryType.from :: Type -> Type
+ BinaryType.from = function(t) {
+ return BinaryType(t.name, t.test, t._1, t._2);
+ };
+
+ // BinaryType.xprod :: (Type, [Type], [Type]) -> [Type]
+ BinaryType.xprod = function(t, $1s, $2s) {
+ var specialize = BinaryType.from(t);
+ return chain($1s, function($1) {
+ return map($2s, function($2) {
+ return specialize($1, $2);
+ });
+ });
+ };
+
+ // EnumType :: [Any] -> Type
+ var EnumType = $.EnumType = function(members) {
+ var types = map(members, $$type);
+ var reprs = map(members, show);
+ return {
+ '@@type': 'sanctuary-def/Type',
+ type: 'ENUM',
+ test: function(x) {
+ // We use `show` to perform value-based equality checks (since we
+ // don't have access to `R.equals` and don't want to implement it).
+ // We avoid a lot of unnecessary work by checking the type of `x`
+ // before determining its string representation. Only if `x` is of
+ // the same type as one or more of the `members` do we incur the
+ // cost of determining its string representation.
+ return types.indexOf($$type(x)) >= 0 && reprs.indexOf(show(x)) >= 0;
+ },
+ toString: always('(' + reprs.join(' | ') + ')')
+ };
+ };
+
+ // RecordType :: {Type} -> Type
+ var RecordType = $.RecordType = function(fields) {
+ var names = keys(fields);
+
+ // invalidMappings :: [String]
+ var invalidMappings = chain(names, function(name) {
+ return $$type(fields[name]) === 'sanctuary-def/Type' ?
+ [] :
+ [show(name) + ': ' + show(fields[name])];
+ });
+
+ if (!isEmpty(invalidMappings)) {
+ throw new TypeError(
+ 'Invalid values\n\n' +
+ 'The argument to ‘RecordType’ must be an object mapping field name ' +
+ 'to type.\n\n' +
+ 'The following mappings are invalid:\n\n' +
+ map(invalidMappings, prefix(' - ')).join('\n')
+ );
+ }
+
+ return {
+ '@@type': 'sanctuary-def/Type',
+ type: 'RECORD',
+ test: function(x) {
+ if (x == null) return false;
+ for (var idx = 0; idx < names.length; idx += 1) {
+ var name = names[idx];
+ if (!has(name, x) || !fields[name].test(x[name])) return false;
+ }
+ return true;
+ },
+ toString: function() {
+ var s = '{';
+ for (var idx = 0; idx < names.length; idx += 1) {
+ var name = names[idx];
+ s += idx === 0 ? ' ' : ', ';
+ s += name + ' :: ' + fields[name];
+ if (idx === names.length - 1) s += ' ';
+ }
+ return s + '}';
+ },
+ fields: fields
+ };
+ };
+
+ // Nullable :: Type -> Type
+ $.Nullable = UnaryType(
+ 'sanctuary-def/Nullable',
+ K(true),
+ function(nullable) { return nullable === null ? [] : [nullable]; }
+ );
+
+ // $$type :: a -> String
+ var $$type = function(x) {
+ return x != null && typeOf(x['@@type']) === 'String' ?
+ x['@@type'] :
+ typeOf(x);
+ };
+
+ // $$typeEq :: String -> a -> Boolean
+ var $$typeEq = function(name) {
+ return function(x) {
+ return $$type(x) === name;
+ };
+ };
+
+ // type0 :: String -> Type
+ var type0 = function(name) {
+ return NullaryType(name, $$typeEq(name));
+ };
+
+ // type1 :: (String, (t a -> [a])) -> Type -> Type
+ var type1 = function(name, _1) {
+ return UnaryType(name, $$typeEq(name), _1);
+ };
+
+ // $.env :: [Type]
+ $.env = [
+ ($.Any = Any),
+ ($.Array = type1('Array', id)),
+ ($.Boolean = type0('Boolean')),
+ ($.Date = type0('Date')),
+ ($.Error = type0('Error')),
+ ($.Function = type0('Function')),
+ ($.Null = type0('Null')),
+ ($.Number = type0('Number')),
+ ($.Object = type0('Object')),
+ ($.RegExp = type0('RegExp')),
+ ($.String = type0('String')),
+ ($.Undefined = type0('Undefined'))
+ ];
+
+ // ValidDate :: Type
+ $.ValidDate = NullaryType(
+ 'sanctuary-def/ValidDate',
+ function(x) { return $.Date.test(x) && !isNaN(x.valueOf()); }
+ );
+
+ // PositiveNumber :: Type
+ $.PositiveNumber = NullaryType(
+ 'sanctuary-def/PositiveNumber',
+ function(x) { return $.Number.test(x) && x > 0; }
+ );
+
+ // NegativeNumber :: Type
+ $.NegativeNumber = NullaryType(
+ 'sanctuary-def/NegativeNumber',
+ function(x) { return $.Number.test(x) && x < 0; }
+ );
+
+ // ValidNumber :: Type
+ var ValidNumber = $.ValidNumber = NullaryType(
+ 'sanctuary-def/ValidNumber',
+ function(x) { return $.Number.test(x) && !isNaN(x); }
+ );
+
+ // NonZeroValidNumber :: Type
+ $.NonZeroValidNumber = NullaryType(
+ 'sanctuary-def/NonZeroValidNumber',
+ function(x) { return ValidNumber.test(x) && x != 0; }
+ );
+
+ // FiniteNumber :: Type
+ var FiniteNumber = $.FiniteNumber = NullaryType(
+ 'sanctuary-def/FiniteNumber',
+ function(x) { return ValidNumber.test(x) && isFinite(x); }
+ );
+
+ // PositiveFiniteNumber :: Type
+ $.PositiveFiniteNumber = NullaryType(
+ 'sanctuary-def/PositiveFiniteNumber',
+ function(x) { return FiniteNumber.test(x) && x > 0; }
+ );
+
+ // NegativeFiniteNumber :: Type
+ $.NegativeFiniteNumber = NullaryType(
+ 'sanctuary-def/NegativeFiniteNumber',
+ function(x) { return FiniteNumber.test(x) && x < 0; }
+ );
+
+ // NonZeroFiniteNumber :: Type
+ $.NonZeroFiniteNumber = NullaryType(
+ 'sanctuary-def/NonZeroFiniteNumber',
+ function(x) { return FiniteNumber.test(x) && x != 0; }
+ );
+
+ // Integer :: Type
+ var Integer = $.Integer = NullaryType(
+ 'sanctuary-def/Integer',
+ function(x) {
+ return ValidNumber.test(x) &&
+ Math.floor(x) == x &&
+ x >= MIN_SAFE_INTEGER &&
+ x <= MAX_SAFE_INTEGER;
+ }
+ );
+
+ // PositiveInteger :: Type
+ $.PositiveInteger = NullaryType(
+ 'sanctuary-def/PositiveInteger',
+ function(x) { return Integer.test(x) && x > 0; }
+ );
+
+ // NegativeInteger :: Type
+ $.NegativeInteger = NullaryType(
+ 'sanctuary-def/NegativeInteger',
+ function(x) { return Integer.test(x) && x < 0; }
+ );
+
+ // NonZeroInteger :: Type
+ $.NonZeroInteger = NullaryType(
+ 'sanctuary-def/NonZeroInteger',
+ function(x) { return Integer.test(x) && x != 0; }
+ );
+
+ // RegexFlags :: Type
+ $.RegexFlags = EnumType(['', 'g', 'i', 'm', 'gi', 'gm', 'im', 'gim']);
+
+ // arity :: (Number, Function) -> Function
+ var arity = function(n, f) {
+ return (
+ n === 0 ?
+ function() {
+ return f.apply(this, arguments);
+ } :
+ n === 1 ?
+ function($1) {
+ return f.apply(this, arguments);
+ } :
+ n === 2 ?
+ function($1, $2) {
+ return f.apply(this, arguments);
+ } :
+ n === 3 ?
+ function($1, $2, $3) {
+ return f.apply(this, arguments);
+ } :
+ n === 4 ?
+ function($1, $2, $3, $4) {
+ return f.apply(this, arguments);
+ } :
+ n === 5 ?
+ function($1, $2, $3, $4, $5) {
+ return f.apply(this, arguments);
+ } :
+ n === 6 ?
+ function($1, $2, $3, $4, $5, $6) {
+ return f.apply(this, arguments);
+ } :
+ n === 7 ?
+ function($1, $2, $3, $4, $5, $6, $7) {
+ return f.apply(this, arguments);
+ } :
+ n === 8 ?
+ function($1, $2, $3, $4, $5, $6, $7, $8) {
+ return f.apply(this, arguments);
+ } :
+ // else
+ function($1, $2, $3, $4, $5, $6, $7, $8, $9) {
+ return f.apply(this, arguments);
+ }
+ );
+ };
+
+ // numArgs :: Number -> String
+ var numArgs = function(n) {
+ switch (n) {
+ case 0: return 'zero arguments';
+ case 1: return 'one argument' ;
+ case 2: return 'two arguments';
+ case 3: return 'three arguments';
+ case 4: return 'four arguments';
+ case 5: return 'five arguments';
+ case 6: return 'six arguments';
+ case 7: return 'seven arguments';
+ case 8: return 'eight arguments';
+ case 9: return 'nine arguments';
+ default: return n + ' arguments';
+ }
+ };
+
+ // replaceTypeVars :: {[Type]} -> Type -> [Type]
+ var replaceTypeVars = function(typeVarMap) {
+ return function recur(t) {
+ switch (t.type) {
+ case 'VARIABLE':
+ return has(t.name, typeVarMap) ? typeVarMap[t.name] : [t];
+ case 'UNARY':
+ return map(recur(t.$1), UnaryType.from(t));
+ case 'BINARY':
+ return BinaryType.xprod(t, recur(t.$1), recur(t.$2));
+ default:
+ return [t];
+ }
+ };
+ };
+
+ // rejectInconsistent :: Type -> [Type]
+ var rejectInconsistent = function recur(t) {
+ switch (t.type) {
+ case 'ANY':
+ return [];
+ case 'UNARY':
+ return map(recur(t.$1), UnaryType.from(t));
+ case 'BINARY':
+ return BinaryType.xprod(t, recur(t.$1), recur(t.$2));
+ default:
+ return [t];
+ }
+ };
+
+ // equalTypes :: (Type, Type) -> Boolean
+ var equalTypes = function equalTypes(t1, t2) {
+ if (t1.type === 'UNKNOWN' || t2.type === 'UNKNOWN') return true;
+ switch (t1.type) {
+ case 'ANY':
+ return t1.type === t2.type && t1.name === t2.name;
+ case 'NULLARY':
+ return t1.type === t2.type && t1.name === t2.name;
+ case 'UNARY':
+ return t1.type === t2.type && t1.name === t2.name &&
+ equalTypes(t1.$1, t2.$1);
+ case 'BINARY':
+ return t1.type === t2.type && t1.name === t2.name &&
+ equalTypes(t1.$1, t2.$1) &&
+ equalTypes(t1.$2, t2.$2);
+ case 'ENUM':
+ return t1.type === t2.type && show(t1) === show(t2);
+ case 'RECORD':
+ return t1.type === t2.type && show(t1) === show(t2);
+ /* istanbul ignore next */
+ default:
+ throw new TypeError(
+ 'Unexpected type ' +
+ LEFT_SINGLE_QUOTATION_MARK + t1.type + RIGHT_SINGLE_QUOTATION_MARK
+ );
+ }
+ };
+
+ // commonTypes :: [[Type]] -> [Type]
+ var commonTypes = function(typeses) {
+ if (isEmpty(typeses)) return [];
+
+ return chain(typeses[0], function(t) {
+ var common = true;
+ for (var idx = 1; idx < typeses.length; idx += 1) {
+ common = false;
+ for (var idx2 = 0; idx2 < typeses[idx].length; idx2 += 1) {
+ if (equalTypes(t, typeses[idx][idx2])) {
+ common = true;
+ break;
+ }
+ }
+ }
+ return common ? [t] : [];
+ });
+ };
+
+ // ordinals :: [String]
+ var ordinals = [
+ 'first',
+ 'second',
+ 'third',
+ 'fourth',
+ 'fifth',
+ 'sixth',
+ 'seventh',
+ 'eighth',
+ 'ninth'
+ ];
+
+ var invalidArgumentsLength = function(name, expectedLength, actualLength) {
+ return new TypeError(
+ LEFT_SINGLE_QUOTATION_MARK + name + RIGHT_SINGLE_QUOTATION_MARK +
+ ' requires ' + numArgs(expectedLength) + ';' +
+ ' received ' + numArgs(actualLength)
+ );
+ };
+
+ var typeNotInEnvironment = function(env, name, type) {
+ return new TypeError(
+ 'Definition of ' + LEFT_SINGLE_QUOTATION_MARK + name +
+ RIGHT_SINGLE_QUOTATION_MARK + ' references ' + type.name +
+ ' which is not in the environment:\n\n' +
+ map(chain(env, rejectInconsistent), prefix(' - ')).join('\n')
+ );
+ };
+
+ var invalidArgument = function(name, types, value, index) {
+ return new TypeError(
+ LEFT_SINGLE_QUOTATION_MARK + name + RIGHT_SINGLE_QUOTATION_MARK +
+ ' expected a value of type ' + types.join(' or ') + ' as its ' +
+ ordinals[index] + ' argument; received ' + show(value)
+ );
+ };
+
+ var orphanArgument = function(env, name, value, index) {
+ return new TypeError(
+ LEFT_SINGLE_QUOTATION_MARK + name + RIGHT_SINGLE_QUOTATION_MARK +
+ ' received ' + show(value) + ' as its ' + ordinals[index] +
+ ' argument, but this value is not a member of any of the types ' +
+ 'in the environment:\n\n' +
+ map(chain(env, rejectInconsistent), prefix(' - ')).join('\n')
+ );
+ };
+
+ var invalidReturnValue = function(name, types, value) {
+ return new TypeError(
+ LEFT_SINGLE_QUOTATION_MARK + name + RIGHT_SINGLE_QUOTATION_MARK +
+ ' is expected to return a value of type ' + types.join(' or ') +
+ '; returned ' + show(value)
+ );
+ };
+
+ var invalidValue = function(name, types, value, index) {
+ return isNaN(index) ?
+ invalidReturnValue(name, types, value) :
+ invalidArgument(name, types, value, index);
+ };
+
+ var constraintViolation = function(name, typeVarName, typeClasses, _types) {
+ var types = chain(_types, rejectInconsistent);
+ return new TypeError(
+ LEFT_SINGLE_QUOTATION_MARK + name + RIGHT_SINGLE_QUOTATION_MARK +
+ ' requires ' + LEFT_SINGLE_QUOTATION_MARK + typeVarName +
+ RIGHT_SINGLE_QUOTATION_MARK + ' to implement ' +
+ typeClasses.join(' and ') + '; ' + types.join(' and ') + ' ' +
+ (types.length === 1 ? 'does' : 'do') + ' not'
+ );
+ };
+
+ // create :: (Boolean, [Type]) -> Function
+ $.create = function(checkTypes, _env) {
+ // env :: [Type]
+ var env = map(_env, function(x) {
+ return typeof x === 'function' ?
+ x.apply(null, map(range(0, x.length), K(Unknown))) :
+ x;
+ });
+
+ // assertExpectedTypesInEnvironment :: String -> [Type] -> Undefined
+ var assertExpectedTypesInEnvironment = function(name) {
+ return function recur(expTypes) {
+ for (var idx = 0; idx < expTypes.length; idx += 1) {
+ var expType = expTypes[idx];
+ if (expType.type !== 'VARIABLE') {
+ if (!any(env, eqProps('name')(expType))) {
+ throw typeNotInEnvironment(env, name, expType);
+ }
+ if (expType.type === 'UNARY') {
+ recur([expType.$1]);
+ } else if (expType.type === 'BINARY') {
+ recur([expType.$1, expType.$2]);
+ }
+ }
+ }
+ };
+ };
+
+ // determineActualTypes :: a -> [Type]
+ var determineActualTypes = function recur(value) {
+ return chain(env, function(t) {
+ return (
+ t.name === 'sanctuary-def/Nullable' || !t.test(value) ?
+ [] :
+ t.type === 'UNARY' ?
+ map(commonTypes(or(map(t._1(value), recur), [[Unknown]])),
+ UnaryType.from(t)) :
+ t.type === 'BINARY' ?
+ BinaryType.xprod(
+ t,
+ commonTypes(or(map(t._1(value), recur), [[Unknown]])),
+ commonTypes(or(map(t._2(value), recur), [[Unknown]]))
+ ) :
+ // else
+ [t]
+ );
+ });
+ };
+
+ var _satisfactoryTypes =
+ function(name, constraints, $typeVarMap, _value, index) {
+ return function recur(expType, values, nest) {
+ var $1s, $2s, idx, okTypes;
+
+ switch (expType.type) {
+
+ case 'VARIABLE':
+ var typeVarName = expType.name;
+ if (has(typeVarName, constraints)) {
+ var typeClasses = constraints[typeVarName];
+ for (idx = 0; idx < values.length; idx += 1) {
+ for (var idx2 = 0; idx2 < typeClasses.length; idx2 += 1) {
+ if (!typeClasses[idx2].test(values[idx])) {
+ throw constraintViolation(
+ name,
+ typeVarName,
+ typeClasses,
+ commonTypes(map(values, determineActualTypes))
+ );
+ }
+ }
+ }
+ }
+ if (has(typeVarName, $typeVarMap)) {
+ var types = $typeVarMap[typeVarName];
+ okTypes = chain(types, function(t) {
+ return all(values, t.test) ? [t] : [];
+ });
+ if (isEmpty(okTypes)) {
+ throw invalidValue(name, map(types, nest), _value, index);
+ }
+ } else {
+ okTypes = chain(commonTypes(map(values, determineActualTypes)),
+ rejectInconsistent);
+ if (isEmpty(okTypes) && !isEmpty(values)) {
+ throw orphanArgument(env, name, _value, index);
+ }
+ }
+ if (!isEmpty(okTypes)) $typeVarMap[typeVarName] = okTypes;
+ return okTypes;
+
+ case 'UNARY':
+ $1s = recur(expType.$1,
+ chain(values, expType._1),
+ UnaryType.from(expType));
+ return map(or($1s, [expType.$1]), UnaryType.from(expType));
+
+ case 'BINARY':
+ var specialize = BinaryType.from(expType);
+ $1s = recur(expType.$1,
+ chain(values, expType._1),
+ function($1) { return specialize($1, expType.$2); });
+ $2s = recur(expType.$2,
+ chain(values, expType._2),
+ function($2) { return specialize(expType.$1, $2); });
+ return BinaryType.xprod(expType,
+ or($1s, [expType.$1]),
+ or($2s, [expType.$2]));
+
+ default:
+ return commonTypes(map(values, determineActualTypes));
+ }
+ };
+ };
+
+ var satisfactoryTypes =
+ function(name, constraints, $typeVarMap, expType, value, index) {
+ return _satisfactoryTypes(name, constraints, $typeVarMap, value, index)
+ (expType, [value], id);
+ };
+
+ var curry = function(name, constraints, expArgTypes, expRetType,
+ _typeVarMap, _values, _indexes, impl) {
+ return arity(_indexes.length, function() {
+ if (checkTypes) {
+ var delta = _indexes.length - arguments.length;
+ if (delta < 0) {
+ throw invalidArgumentsLength(name,
+ expArgTypes.length,
+ expArgTypes.length - delta);
+ }
+ }
+ var $typeVarMap = {};
+ for (var typeVarName in _typeVarMap) {
+ $typeVarMap[typeVarName] = _typeVarMap[typeVarName].slice();
+ }
+ var values = _values.slice();
+ var indexes = [];
+ for (var idx = 0; idx < _indexes.length; idx += 1) {
+ var index = _indexes[idx];
+
+ if (idx < arguments.length &&
+ !(typeof arguments[idx] === 'object' &&
+ arguments[idx] != null &&
+ arguments[idx]['@@functional/placeholder'] === true)) {
+
+ var value = arguments[idx];
+ if (checkTypes) {
+ var expType = expArgTypes[index];
+ if (!expType.test(value) ||
+ isEmpty(satisfactoryTypes(name, constraints, $typeVarMap,
+ expType, value, index))) {
+ throw invalidValue(name,
+ replaceTypeVars($typeVarMap)(expType),
+ value,
+ index);
+ }
+ }
+ values[index] = value;
+ } else {
+ indexes.push(index);
+ }
+ }
+ if (isEmpty(indexes)) {
+ var returnValue = impl.apply(this, values);
+ if (checkTypes) {
+ if (!expRetType.test(returnValue)) {
+ throw invalidReturnValue(name, [expRetType], returnValue);
+ }
+ satisfactoryTypes(name, constraints, $typeVarMap,
+ expRetType, returnValue, NaN);
+ }
+ return returnValue;
+ } else {
+ return curry(name, constraints, expArgTypes, expRetType,
+ $typeVarMap, values, indexes, impl);
+ }
+ });
+ };
+
+ return function def(name, constraints, expTypes, impl) {
+ if (checkTypes) {
+ if (arguments.length !== def.length) {
+ throw invalidArgumentsLength('def', def.length, arguments.length);
+ }
+
+ var Type = RecordType({test: $.Function});
+ var types = [$.String, $.Object, $.Array(Type), $.Function];
+ for (var idx = 0; idx < types.length; idx += 1) {
+ if (!types[idx].test(arguments[idx])) {
+ throw invalidArgument('def', [types[idx]], arguments[idx], idx);
+ }
+ }
+ }
+
+ var expArgTypes = expTypes.slice(0, -1);
+ var arity = expArgTypes.length;
+ if (arity > 9) {
+ throw new RangeError(
+ LEFT_SINGLE_QUOTATION_MARK + 'def' + RIGHT_SINGLE_QUOTATION_MARK +
+ ' cannot define a function with arity greater than nine'
+ );
+ }
+
+ if (checkTypes) assertExpectedTypesInEnvironment(name)(expTypes);
+
+ return curry(name,
+ constraints,
+ expArgTypes,
+ expTypes[expTypes.length - 1],
+ {},
+ new Array(arity),
+ range(0, arity),
+ impl);
+ };
+ };
+
+ return $;
+
+}));
diff --git a/vendor/sanctuary.js b/vendor/sanctuary.js
new file mode 100644
index 0000000..4dea627
--- /dev/null
+++ b/vendor/sanctuary.js
@@ -0,0 +1,2977 @@
+/* #######
+ #### ####
+ #### ### ####
+##### ########### sanctuary
+######## ######## noun
+########### ##### 1 [ mass noun ] refuge from unsafe JavaScript
+ #### ### ####
+ #### ####
+ ####### */
+
+//. # Sanctuary
+//.
+//. Sanctuary is a functional programming library inspired by Haskell and
+//. PureScript. It depends on and works nicely with [Ramda][]. Sanctuary
+//. makes it possible to write safe code without null checks.
+//.
+//. In JavaScript it's trivial to introduce a possible run-time type error:
+//.
+//. words[0].toUpperCase()
+//.
+//. If `words` is `[]` we'll get a familiar error at run-time:
+//.
+//. TypeError: Cannot read property 'toUpperCase' of undefined
+//.
+//. Sanctuary gives us a fighting chance of avoiding such errors. We might
+//. write:
+//.
+//. R.map(R.toUpper, S.head(words))
+//.
+//. ## Types
+//.
+//. Sanctuary uses Haskell-like type signatures to describe the types of
+//. values, including functions. `'foo'`, for example, has type `String`;
+//. `[1, 2, 3]` has type `[Number]`. The arrow (`->`) is used to express a
+//. function's type. `Math.abs`, for example, has type `Number -> Number`.
+//. That is, it takes an argument of type `Number` and returns a value of
+//. type `Number`.
+//.
+//. [`R.map`][R.map] has type `(a -> b) -> [a] -> [b]`. That is, it takes
+//. an argument of type `a -> b` and returns a value of type `[a] -> [b]`.
+//. `a` and `b` are type variables: applying `R.map` to a value of type
+//. `String -> Number` will give a value of type `[String] -> [Number]`.
+//.
+//. Sanctuary embraces types. JavaScript doesn't support algebraic data types,
+//. but these can be simulated by providing a group of constructor functions
+//. whose prototypes provide the same set of methods. A value of the Maybe
+//. type, for example, is created via the Nothing constructor or the Just
+//. constructor.
+//.
+//. It's necessary to extend Haskell's notation to describe implicit arguments
+//. to the *methods* provided by Sanctuary's types. In `x.map(y)`, for example,
+//. the `map` method takes an implicit argument `x` in addition to the explicit
+//. argument `y`. The type of the value upon which a method is invoked appears
+//. at the beginning of the signature, separated from the arguments and return
+//. value by a squiggly arrow (`~>`). The type of the `map` method of the Maybe
+//. type is written `Maybe a ~> (a -> b) -> Maybe b`. One could read this as:
+//.
+//. _When the `map` method is invoked on a value of type `Maybe a`
+//. (for any type `a`) with an argument of type `a -> b` (for any type `b`),
+//. it returns a value of type `Maybe b`._
+//.
+//. Sanctuary supports type classes: constraints on type variables. Whereas
+//. `a -> a` implicitly supports every type, `Functor f => (a -> b) -> f a ->
+//. f b` requires that `f` be a type which satisfies the requirements of the
+//. Functor type class. Type-class constraints appear at the beginning of a
+//. type signature, separated from the rest of the signature by a fat arrow
+//. (`=>`).
+//.
+//. ### Accessible pseudotype
+//.
+//. What is the type of values which support property access? In other words,
+//. what is the type of which every value except `null` and `undefined` is a
+//. member? Object is close, but `Object.create(null)` produces a value which
+//. supports property access but which is not a member of the Object type.
+//.
+//. Sanctuary uses the Accessible pseudotype to represent the set of values
+//. which support property access.
+//.
+//. ### Integer pseudotype
+//.
+//. The Integer pseudotype represents integers in the range (-2^53 .. 2^53).
+//. It is a pseudotype because each Integer is represented by a Number value.
+//. Sanctuary's run-time type checking asserts that a valid Number value is
+//. provided wherever an Integer value is required.
+//.
+//. ### List pseudotype
+//.
+//. The List pseudotype represents non-Function values with numeric `length`
+//. properties greater than or equal to zero, such as `[1, 2, 3]` and `'foo'`.
+//.
+//. ### Type representatives
+//.
+//. What is the type of `Number`? One answer is `a -> Number`, since it's a
+//. function which takes an argument of any type and returns a Number value.
+//. When provided as the first argument to [`is`](#is), though, `Number` is
+//. really the value-level representative of the Number type.
+//.
+//. Sanctuary uses the TypeRep pseudotype to describe type representatives.
+//. For example:
+//.
+//. Number :: TypeRep Number
+//.
+//. `Number` is the sole inhabitant of the TypeRep Number type.
+//.
+//. ## Type checking
+//.
+//. Sanctuary functions are defined via [sanctuary-def][] to provide run-time
+//. type checking. This is tremendously useful during development: type errors
+//. are reported immediately, avoiding circuitous stack traces (at best) and
+//. silent failures due to type coercion (at worst). For example:
+//.
+//. ```javascript
+//. S.inc('XXX');
+//. // ! TypeError: ‘inc’ expected a value of type FiniteNumber as its first argument; received "XXX"
+//. ```
+//.
+//. Compare this to the behaviour of Ramda's unchecked equivalent:
+//.
+//. ```javascript
+//. R.inc('XXX');
+//. // => '1XXX'
+//. ```
+//.
+//. There is a performance cost to run-time type checking. One may wish to
+//. disable type checking in certain contexts to avoid paying this cost.
+//. There are actually two versions of the Sanctuary module: one with type
+//. checking; one without. The latter is accessible via the `unchecked`
+//. property of the former.
+//.
+//. When application of `S.unchecked.` honours the function's type
+//. signature the result will be the same as if `S.` had been used
+//. instead. Otherwise, the behaviour is unspecified.
+//.
+//. In Node, one could use an environment variable to determine which version
+//. of the Sanctuary module to use:
+//.
+//. ```javascript
+//. const S = process.env.NODE_ENV === 'production' ?
+//. require('sanctuary').unchecked :
+//. require('sanctuary');
+//. ```
+//.
+//. ## API
+
+/* global define, self */
+
+;(function(f) {
+
+ 'use strict';
+
+ /* istanbul ignore else */
+ if (typeof module !== 'undefined') {
+ module.exports = f(require('ramda'), require('sanctuary-def'));
+ } else if (typeof define === 'function' && define.amd != null) {
+ define(['ramda', 'sanctuary-def'], f);
+ } else {
+ self.sanctuary = f(self.R, self.sanctuaryDef);
+ }
+
+}(function(R, $) {
+
+ 'use strict';
+
+ var _ = R.__;
+
+ var sentinel = {};
+
+ // _type :: a -> String
+ var _type = function(x) {
+ return x != null && R.type(x['@@type']) === 'String' ? x['@@type']
+ : R.type(x);
+ };
+
+ // compose2 :: ((b -> c), (a -> b)) -> a -> c
+ var compose2 = function(f, g) {
+ return function(x) {
+ return f(g(x));
+ };
+ };
+
+ // compose3 :: ((b -> c), (a -> b), a) -> c
+ var compose3 = function(f, g, x) {
+ return f(g(x));
+ };
+
+ // filter :: (Monad m, Monoid m) => ((a -> Boolean), m a) -> m a
+ var filter = function(pred, m) {
+ return m.chain(function(x) {
+ return pred(x) ? m.of(x) : m.empty();
+ });
+ };
+
+ // hasMethod :: String -> Any -> Boolean
+ var hasMethod = function(name) {
+ return function(x) {
+ return x != null && typeof x[name] === 'function';
+ };
+ };
+
+ // inspect :: -> String
+ var inspect = /* istanbul ignore next */ function() {
+ return this.toString();
+ };
+
+ // negativeZero :: a -> Boolean
+ var negativeZero = R.either(R.equals(-0),
+ R.equals(new Number(-0))); // jshint ignore:line
+
+ // Accessible :: TypeClass
+ var Accessible = $.TypeClass(
+ 'sanctuary/Accessible',
+ function(x) { return x != null; }
+ );
+
+ // Apply :: TypeClass
+ var Apply = $.TypeClass(
+ 'sanctuary/Apply',
+ function(x) {
+ return R.contains(_type(x), ['Array', 'Function']) ||
+ Functor.test(x) && hasMethod('ap')(x);
+ }
+ );
+
+ // Foldable :: TypeClass
+ var Foldable = $.TypeClass(
+ 'sanctuary/Foldable',
+ function(x) {
+ return _type(x) === 'Array' || hasMethod('reduce');
+ }
+ );
+
+ // Functor :: TypeClass
+ var Functor = $.TypeClass(
+ 'sanctuary/Functor',
+ function(x) {
+ return R.contains(_type(x), ['Array', 'Function']) ||
+ hasMethod('map')(x);
+ }
+ );
+
+ // Monoid :: TypeClass
+ var Monoid = $.TypeClass(
+ 'sanctuary/Monoid',
+ function(x) {
+ return R.contains(_type(x), ['Array', 'Boolean', 'Object', 'String']) ||
+ hasMethod('empty')(x);
+ }
+ );
+
+ // Ord :: TypeClass
+ var Ord = $.TypeClass(
+ 'sanctuary/Ord',
+ R.anyPass([$.String.test, $.ValidDate.test, $.ValidNumber.test])
+ );
+
+ // Semigroup :: TypeClass
+ var Semigroup = $.TypeClass(
+ 'sanctuary/Semigroup',
+ hasMethod('concat')
+ );
+
+ var a = $.TypeVariable('a');
+ var b = $.TypeVariable('b');
+ var c = $.TypeVariable('c');
+ var d = $.TypeVariable('d');
+ var l = $.TypeVariable('l');
+ var r = $.TypeVariable('r');
+
+ // $Either :: Type -> Type -> Type
+ var $Either = $.BinaryType(
+ 'sanctuary/Either',
+ function(x) { return x != null && x['@@type'] === 'sanctuary/Either'; },
+ function(either) { return either.isLeft ? [either.value] : []; },
+ function(either) { return either.isRight ? [either.value] : []; }
+ );
+
+ // List :: Type -> Type
+ var List = $.UnaryType(
+ 'sanctuary/List',
+ function(x) {
+ return x != null &&
+ R.type(x) !== 'Function' &&
+ $.Integer.test(x.length) &&
+ x.length >= 0;
+ },
+ function(list) {
+ return list.length > 0 && R.type(list) !== 'String' ? [list[0]] : [];
+ }
+ );
+
+ // $Maybe :: Type -> Type
+ var $Maybe = $.UnaryType(
+ 'sanctuary/Maybe',
+ function(x) { return x != null && x['@@type'] === 'sanctuary/Maybe'; },
+ function(maybe) { return maybe.isJust ? [maybe.value] : []; }
+ );
+
+ // TypeRep :: Type
+ var TypeRep = $.NullaryType(
+ 'sanctuary/TypeRep',
+ function(x) {
+ return R.type(x) === 'Function' ||
+ (x != null &&
+ R.type(x.name) === 'String' &&
+ R.type(x.test) === 'Function');
+ }
+ );
+
+ // env :: [Type]
+ var env = $.env.concat([
+ $.FiniteNumber,
+ $.NonZeroFiniteNumber,
+ $Either,
+ $.Integer,
+ List,
+ $Maybe,
+ $.RegexFlags,
+ TypeRep,
+ $.ValidDate,
+ $.ValidNumber
+ ]);
+
+ // createSanctuary :: Boolean -> Module
+ var createSanctuary = function(checkTypes) {
+
+ // To avoid excessive indentation this function's body is not indented.
+
+ var S = {EitherType: $Either, MaybeType: $Maybe};
+
+ var def = $.create(checkTypes, env);
+
+ var method = function(name, constraints, types, _f) {
+ var f = def(name, constraints, types, _f);
+ return def(name, constraints, R.tail(types), function() {
+ return R.apply(f, R.prepend(this, arguments));
+ });
+ };
+
+ //. ### Classify
+
+ //# type :: a -> String
+ //.
+ //. Takes a value, `x`, of any type and returns its type identifier. If
+ //. `x` has a `'@@type'` property whose value is a string, `x['@@type']`
+ //. is the type identifier. Otherwise, the type identifier is the result
+ //. of applying [`R.type`][R.type] to `x`.
+ //.
+ //. `'@@type'` properties should use the form `'/'`,
+ //. where `` is the name of the npm package in which the type
+ //. is defined.
+ //.
+ //. ```javascript
+ //. > S.type(S.Just(42))
+ //. 'sanctuary/Maybe'
+ //.
+ //. > S.type([1, 2, 3])
+ //. 'Array'
+ //. ```
+ S.type =
+ def('type',
+ {},
+ [$.Any, $.String],
+ _type);
+
+ //# is :: TypeRep a -> b -> Boolean
+ //.
+ //. Takes a [type representative](#type-representatives) and a value of
+ //. any type and returns `true` if the given value is of the specified
+ //. type; `false` otherwise. Subtyping is not respected.
+ //.
+ //. ```javascript
+ //. > S.is(Number, 42)
+ //. true
+ //.
+ //. > S.is(Object, 42)
+ //. false
+ //.
+ //. > S.is(String, 42)
+ //. false
+ //. ```
+ var is = S.is =
+ def('is',
+ {},
+ [TypeRep, $.Any, $.Boolean],
+ function(type, x) {
+ return x != null && (
+ R.type(type.prototype['@@type']) === 'String' ?
+ x['@@type'] === type.prototype['@@type'] :
+ R.type(x) === R.nth(1, R.match(/^function (\w*)/, String(type)))
+ );
+ });
+
+ //. ### Combinator
+
+ //# I :: a -> a
+ //.
+ //. The I combinator. Returns its argument. Equivalent to Haskell's `id`
+ //. function.
+ //.
+ //. ```javascript
+ //. > S.I('foo')
+ //. 'foo'
+ //. ```
+ var I = S.I =
+ def('I',
+ {},
+ [a, a],
+ function(x) { return x; });
+
+ //# K :: a -> b -> a
+ //.
+ //. The K combinator. Takes two values and returns the first. Equivalent to
+ //. Haskell's `const` function.
+ //.
+ //. ```javascript
+ //. > S.K('foo', 'bar')
+ //. 'foo'
+ //.
+ //. > R.map(S.K(42), R.range(0, 5))
+ //. [42, 42, 42, 42, 42]
+ //. ```
+ S.K =
+ def('K',
+ {},
+ [a, b, a],
+ function(x, y) { return x; });
+
+ //# A :: (a -> b) -> a -> b
+ //.
+ //. The A combinator. Takes a function and a value, and returns the result of
+ //. applying the function to the value. Equivalent to Haskell's `($)` function.
+ //.
+ //. ```javascript
+ //. > S.A(R.inc, 1)
+ //. 2
+ //.
+ //. > R.map(S.A(R.__, 100), [R.inc, Math.sqrt])
+ //. [101, 10]
+ //. ```
+ S.A =
+ def('A',
+ {},
+ [$.Function, a, b],
+ function(f, x) { return f(x); });
+
+ //# C :: (a -> b -> c) -> b -> a -> c
+ //.
+ //. The C combinator. Takes a curried binary function and two values, and
+ //. returns the result of applying the function to the values in reverse.
+ //. Equivalent to Haskell's `flip` function.
+ //.
+ //. This function is very similar to [`flip`](#flip), except that its first
+ //. argument must be curried. This allows it to work with manually curried
+ //. functions.
+ //.
+ //. ```javascript
+ //. > S.C(R.concat, 'foo', 'bar')
+ //. 'barfoo'
+ //.
+ //. > R.filter(S.C(R.gt, 0), [-1, -2, 3, -4, 4, 2])
+ //. [3, 4, 2]
+ //. ```
+ S.C =
+ def('C',
+ {},
+ [$.Function, b, a, c],
+ function(f, x, y) { return f(y)(x); });
+
+ //# B :: (b -> c) -> (a -> b) -> a -> c
+ //.
+ //. The B combinator. Takes two functions and a value, and returns the result
+ //. of applying the first function to the result of applying the second to the
+ //. value. Equivalent to [`compose`](#compose) and Haskell's `(.)` function.
+ //.
+ //. ```javascript
+ //. > S.B(Math.sqrt, S.inc, 99)
+ //. 10
+ //. ```
+ S.B =
+ def('B',
+ {},
+ [$.Function, $.Function, a, c],
+ compose3);
+
+ //# S :: (a -> b -> c) -> (a -> b) -> a -> c
+ //.
+ //. The S combinator. Takes a curried binary function, a unary function,
+ //. and a value, and returns the result of applying the binary function to:
+ //.
+ //. - the value; and
+ //. - the result of applying the unary function to the value.
+ //.
+ //. ```javascript
+ //. > S.S(R.add, Math.sqrt, 100)
+ //. 110
+ //. ```
+ S.S =
+ def('S',
+ {},
+ [$.Function, $.Function, a, c],
+ function(f, g, x) { return f(x)(g(x)); });
+
+ //. ### Function
+
+ //# flip :: (a -> b -> c) -> b -> a -> c
+ //.
+ //. Takes a binary function and two values and returns the result of
+ //. applying the function - with its argument order reversed - to the
+ //. values. `flip` may also be applied to a Ramda-style curried
+ //. function with arity greater than two.
+ //.
+ //. See also [`C`](#C).
+ //.
+ //. ```javascript
+ //. > R.map(S.flip(Math.pow)(2), [1, 2, 3, 4, 5])
+ //. [1, 4, 9, 16, 25]
+ //. ```
+ S.flip =
+ def('flip',
+ {},
+ [$.Function, b, a, c],
+ function(f, x, y) { return f(y, x); });
+
+ //# lift :: Functor f => (a -> b) -> f a -> f b
+ //.
+ //. Promotes a unary function to a function which operates on a [Functor][].
+ //.
+ //. ```javascript
+ //. > S.lift(S.inc, S.Just(2))
+ //. Just(3)
+ //.
+ //. > S.lift(S.inc, S.Nothing())
+ //. Nothing()
+ //. ```
+ S.lift =
+ def('lift',
+ {a: [Functor], b: [Functor]},
+ [$.Function, a, b],
+ R.map);
+
+ //# lift2 :: Apply f => (a -> b -> c) -> f a -> f b -> f c
+ //.
+ //. Promotes a binary function to a function which operates on two
+ //. [Apply][]s.
+ //.
+ //. ```javascript
+ //. > S.lift2(R.add, S.Just(2), S.Just(3))
+ //. Just(5)
+ //.
+ //. > S.lift2(R.add, S.Just(2), S.Nothing())
+ //. Nothing()
+ //.
+ //. > S.lift2(S.and, S.Just(true), S.Just(true))
+ //. Just(true)
+ //.
+ //. > S.lift2(S.and, S.Just(true), S.Just(false))
+ //. Just(false)
+ //. ```
+ S.lift2 =
+ def('lift2',
+ {a: [Apply], b: [Apply], c: [Apply]},
+ [$.Function, a, b, c],
+ function(f, x, y) { return R.ap(R.map(f, x), y); });
+
+ //# lift3 :: Apply f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
+ //.
+ //. Promotes a ternary function to a function which operates on three
+ //. [Apply][]s.
+ //.
+ //. ```javascript
+ //. > S.lift3(S.reduce, S.Just(S.add), S.Just(0), S.Just([1, 2, 3]))
+ //. Just(6)
+ //.
+ //. > S.lift3(S.reduce, S.Just(S.add), S.Just(0), S.Nothing())
+ //. Nothing()
+ //. ```
+ S.lift3 =
+ def('lift3',
+ {a: [Apply], b: [Apply], c: [Apply], d: [Apply]},
+ [$.Function, a, b, c, d],
+ function(f, x, y, z) { return R.ap(R.ap(R.map(f, x), y), z); });
+
+ //. ### Composition
+
+ //# compose :: (b -> c) -> (a -> b) -> a -> c
+ //.
+ //. Takes two functions assumed to be unary and a value of any type,
+ //. and returns the result of applying the first function to the result
+ //. of applying the second function to the given value.
+ //.
+ //. In general terms, `compose` performs right-to-left composition of two
+ //. unary functions.
+ //.
+ //. See also [`B`](#B) and [`pipe`](#pipe).
+ //.
+ //. ```javascript
+ //. > S.compose(Math.sqrt, S.inc)(99)
+ //. 10
+ //. ```
+ var compose = S.compose =
+ def('compose',
+ {},
+ [$.Function, $.Function, a, c],
+ compose3);
+
+ //# pipe :: [(a -> b), (b -> c), ..., (m -> n)] -> a -> n
+ //.
+ //. Takes a list of functions assumed to be unary and a value of any type,
+ //. and returns the result of applying the sequence of transformations to
+ //. the initial value.
+ //.
+ //. In general terms, `pipe` performs left-to-right composition of a list
+ //. of functions. `pipe([f, g, h], x)` is equivalent to `h(g(f(x)))`.
+ //.
+ //. See also [`meld`](#meld).
+ //.
+ //. ```javascript
+ //. > S.pipe([S.inc, Math.sqrt, S.dec])(99)
+ //. 9
+ //. ```
+ S.pipe =
+ def('pipe',
+ {},
+ [$.Array($.Function), a, b],
+ function(fs, x) { return R.reduceRight(compose2, I, fs)(x); });
+
+ //# meld :: [** -> *] -> (* -> * -> ... -> *)
+ //.
+ //. Takes a list of non-nullary functions and returns a curried function
+ //. whose arity is one greater than the sum of the arities of the given
+ //. functions less the number of functions.
+ //.
+ //. The behaviour of `meld` is best conveyed diagrammatically. The following
+ //. diagram depicts the "melding" of binary functions `f` and `g`:
+ //.
+ //. +-------+
+ //. --- a --->| |
+ //. | f | +-------+
+ //. --- b --->| |--- f(a, b) --->| |
+ //. +-------+ | g |
+ //. --- c ---------------------------->| |--- g(f(a, b), c) --->
+ //. +-------+
+ //.
+ //. See also [`pipe`](#pipe).
+ //.
+ //. ```javascript
+ //. > S.meld([Math.pow, S.sub])(3, 4, 5)
+ //. 76
+ //.
+ //. > S.meld([Math.pow, S.sub])(3)(4)(5)
+ //. 76
+ //. ```
+ S.meld =
+ def('meld',
+ {},
+ [$.Array($.Function), $.Function],
+ function(fs) {
+ var n = 1 + R.sum(R.map(R.length, fs)) - fs.length;
+ return R.curryN(n, function() {
+ var args = Array.prototype.slice.call(arguments);
+ for (var idx = 0; idx < fs.length; idx += 1) {
+ args.unshift(fs[idx].apply(this, args.splice(0, fs[idx].length)));
+ }
+ return args[0];
+ });
+ });
+
+ //. ### Maybe type
+ //.
+ //. The Maybe type represents optional values: a value of type `Maybe a` is
+ //. either a Just whose value is of type `a` or a Nothing (with no value).
+ //.
+ //. The Maybe type satisfies the [Monoid][], [Monad][], [Traversable][],
+ //. and [Extend][] specifications.
+
+ //# MaybeType :: Type -> Type
+ //.
+ //. A [`UnaryType`][UnaryType] for use with [sanctuary-def][].
+
+ //# Maybe :: TypeRep Maybe
+ //.
+ //. The [type representative](#type-representatives) for the Maybe type.
+ var Maybe = S.Maybe = function Maybe() {
+ if (arguments[0] !== sentinel) {
+ throw new Error('Cannot instantiate Maybe');
+ }
+ };
+
+ //# Maybe.empty :: -> Maybe a
+ //.
+ //. Returns a Nothing.
+ //.
+ //. ```javascript
+ //. > S.Maybe.empty()
+ //. Nothing()
+ //. ```
+ Maybe.empty =
+ def('Maybe.empty',
+ {},
+ [$Maybe(a)],
+ function() { return Nothing(); });
+
+ //# Maybe.of :: a -> Maybe a
+ //.
+ //. Takes a value of any type and returns a Just with the given value.
+ //.
+ //. ```javascript
+ //. > S.Maybe.of(42)
+ //. Just(42)
+ //. ```
+ Maybe.of =
+ def('Maybe.of',
+ {},
+ [a, $Maybe(a)],
+ function(x) { return Just(x); });
+
+ //# Maybe#@@type :: String
+ //.
+ //. Maybe type identifier, `'sanctuary/Maybe'`.
+ Maybe.prototype['@@type'] = 'sanctuary/Maybe';
+
+ //# Maybe#isNothing :: Boolean
+ //.
+ //. `true` if `this` is a Nothing; `false` if `this` is a Just.
+ //.
+ //. ```javascript
+ //. > S.Nothing().isNothing
+ //. true
+ //.
+ //. > S.Just(42).isNothing
+ //. false
+ //. ```
+
+ //# Maybe#isJust :: Boolean
+ //.
+ //. `true` if `this` is a Just; `false` if `this` is a Nothing.
+ //.
+ //. ```javascript
+ //. > S.Just(42).isJust
+ //. true
+ //.
+ //. > S.Nothing().isJust
+ //. false
+ //. ```
+
+ //# Maybe#ap :: Maybe (a -> b) ~> Maybe a -> Maybe b
+ //.
+ //. Takes a value of type `Maybe a` and returns a Nothing unless `this`
+ //. is a Just *and* the argument is a Just, in which case it returns a
+ //. Just whose value is the result of of applying this Just's value to
+ //. the given Just's value.
+ //.
+ //. ```javascript
+ //. > S.Nothing().ap(S.Just(42))
+ //. Nothing()
+ //.
+ //. > S.Just(S.inc).ap(S.Nothing())
+ //. Nothing()
+ //.
+ //. > S.Just(S.inc).ap(S.Just(42))
+ //. Just(43)
+ //. ```
+ Maybe.prototype.ap =
+ method('Maybe#ap',
+ {},
+ [$Maybe($.Function), $Maybe(a), $Maybe(b)],
+ function(mf, mx) { return mf.isJust ? mx.map(mf.value) : mf; });
+
+ //# Maybe#chain :: Maybe a ~> (a -> Maybe b) -> Maybe b
+ //.
+ //. Takes a function and returns `this` if `this` is a Nothing; otherwise
+ //. it returns the result of applying the function to this Just's value.
+ //.
+ //. ```javascript
+ //. > S.Nothing().chain(S.parseFloat)
+ //. Nothing()
+ //.
+ //. > S.Just('xxx').chain(S.parseFloat)
+ //. Nothing()
+ //.
+ //. > S.Just('12.34').chain(S.parseFloat)
+ //. Just(12.34)
+ //. ```
+ Maybe.prototype.chain =
+ method('Maybe#chain',
+ {},
+ [$Maybe(a), $.Function, $Maybe(b)],
+ function(maybe, f) { return maybe.isJust ? f(maybe.value) : maybe; });
+
+ //# Maybe#concat :: Semigroup a => Maybe a ~> Maybe a -> Maybe a
+ //.
+ //. Returns the result of concatenating two Maybe values of the same type.
+ //. `a` must have a [Semigroup][] (indicated by the presence of a `concat`
+ //. method).
+ //.
+ //. If `this` is a Nothing and the argument is a Nothing, this method returns
+ //. a Nothing.
+ //.
+ //. If `this` is a Just and the argument is a Just, this method returns a
+ //. Just whose value is the result of concatenating this Just's value and
+ //. the given Just's value.
+ //.
+ //. Otherwise, this method returns the Just.
+ //.
+ //. ```javascript
+ //. > S.Nothing().concat(S.Nothing())
+ //. Nothing()
+ //.
+ //. > S.Just([1, 2, 3]).concat(S.Just([4, 5, 6]))
+ //. Just([1, 2, 3, 4, 5, 6])
+ //.
+ //. > S.Nothing().concat(S.Just([1, 2, 3]))
+ //. Just([1, 2, 3])
+ //.
+ //. > S.Just([1, 2, 3]).concat(S.Nothing())
+ //. Just([1, 2, 3])
+ //. ```
+ Maybe.prototype.concat =
+ method('Maybe#concat',
+ {a: [Semigroup]},
+ [$Maybe(a), $Maybe(a), $Maybe(a)],
+ function(mx, my) {
+ return mx.isNothing ? my :
+ my.isNothing ? mx : Just(mx.value.concat(my.value));
+ });
+
+ //# Maybe#empty :: Maybe a ~> Maybe a
+ //.
+ //. Returns a Nothing.
+ //.
+ //. ```javascript
+ //. > S.Just(42).empty()
+ //. Nothing()
+ //. ```
+ Maybe.prototype.empty =
+ def('Maybe#empty',
+ {},
+ [$Maybe(a)],
+ Maybe.empty);
+
+ //# Maybe#equals :: Maybe a ~> b -> Boolean
+ //.
+ //. Takes a value of any type and returns `true` if:
+ //.
+ //. - it is a Nothing and `this` is a Nothing; or
+ //.
+ //. - it is a Just and `this` is a Just, and their values are equal
+ //. according to [`R.equals`][R.equals].
+ //.
+ //. ```javascript
+ //. > S.Nothing().equals(S.Nothing())
+ //. true
+ //.
+ //. > S.Nothing().equals(null)
+ //. false
+ //.
+ //. > S.Just([1, 2, 3]).equals(S.Just([1, 2, 3]))
+ //. true
+ //.
+ //. > S.Just([1, 2, 3]).equals(S.Just([3, 2, 1]))
+ //. false
+ //.
+ //. > S.Just([1, 2, 3]).equals(S.Nothing())
+ //. false
+ //. ```
+ Maybe.prototype.equals =
+ method('Maybe#equals',
+ {},
+ [$Maybe(a), b, $.Boolean],
+ function(maybe, x) {
+ return _type(x) === 'sanctuary/Maybe' &&
+ (maybe.isNothing && x.isNothing ||
+ maybe.isJust && x.isJust && R.eqProps('value', maybe, x));
+ });
+
+ //# Maybe#extend :: Maybe a ~> (Maybe a -> a) -> Maybe a
+ //.
+ //. Takes a function and returns `this` if `this` is a Nothing; otherwise
+ //. it returns a Just whose value is the result of applying the function to
+ //. `this`.
+ //.
+ //. ```javascript
+ //. > S.Nothing().extend(x => x.value + 1)
+ //. Nothing()
+ //.
+ //. > S.Just(42).extend(x => x.value + 1)
+ //. Just(43)
+ //. ```
+ Maybe.prototype.extend =
+ method('Maybe#extend',
+ {},
+ [$Maybe(a), $.Function, $Maybe(a)],
+ function(maybe, f) { return maybe.isJust ? Just(f(maybe)) : maybe; });
+
+ //# Maybe#filter :: Maybe a ~> (a -> Boolean) -> Maybe a
+ //.
+ //. Takes a predicate and returns `this` if `this` is a Just whose value
+ //. satisfies the predicate; Nothing otherwise.
+ //.
+ //. ```javascript
+ //. > S.Just(42).filter(n => n % 2 === 0)
+ //. Just(42)
+ //.
+ //. > S.Just(43).filter(n => n % 2 === 0)
+ //. Nothing()
+ //. ```
+ Maybe.prototype.filter =
+ method('Maybe#filter',
+ {},
+ [$Maybe(a), $.Function, $Maybe(a)],
+ function(maybe, pred) { return filter(pred, maybe); });
+
+ //# Maybe#map :: Maybe a ~> (a -> b) -> Maybe b
+ //.
+ //. Takes a function and returns `this` if `this` is a Nothing; otherwise
+ //. it returns a Just whose value is the result of applying the function to
+ //. this Just's value.
+ //.
+ //. ```javascript
+ //. > S.Nothing().map(S.inc)
+ //. Nothing()
+ //.
+ //. > S.Just([1, 2, 3]).map(R.sum)
+ //. Just(6)
+ //. ```
+ Maybe.prototype.map =
+ method('Maybe#map',
+ {},
+ [$Maybe(a), $.Function, $Maybe(b)],
+ function(maybe, f) {
+ return maybe.isJust ? Just(f(maybe.value)) : maybe;
+ });
+
+ //# Maybe#of :: Maybe a ~> b -> Maybe b
+ //.
+ //. Takes a value of any type and returns a Just with the given value.
+ //.
+ //. ```javascript
+ //. > S.Nothing().of(42)
+ //. Just(42)
+ //. ```
+ Maybe.prototype.of =
+ def('Maybe#of',
+ {},
+ [b, $Maybe(b)],
+ Maybe.of);
+
+ //# Maybe#reduce :: Maybe a ~> (b -> a -> b) -> b -> b
+ //.
+ //. Takes a function and an initial value of any type, and returns:
+ //.
+ //. - the initial value if `this` is a Nothing; otherwise
+ //.
+ //. - the result of applying the function to the initial value and this
+ //. Just's value.
+ //.
+ //. ```javascript
+ //. > S.Nothing().reduce(S.add, 10)
+ //. 10
+ //.
+ //. > S.Just(5).reduce(S.add, 10)
+ //. 15
+ //. ```
+ Maybe.prototype.reduce =
+ method('Maybe#reduce',
+ {},
+ [$Maybe(a), $.Function, b, b],
+ function(maybe, f, x) {
+ return maybe.isJust ? f(x, maybe.value) : x;
+ });
+
+ //# Maybe#sequence :: Applicative f => Maybe (f a) ~> (a -> f a) -> f (Maybe a)
+ //.
+ //. Evaluates an applicative action contained within the Maybe, resulting in:
+ //.
+ //. - a pure applicative of a Nothing if `this` is a Nothing; otherwise
+ //.
+ //. - an applicative of Just the value of the evaluated action.
+ //.
+ //. ```javascript
+ //. > S.Nothing().sequence(S.Either.of)
+ //. Right(Nothing())
+ //.
+ //. > S.Just(S.Right(42)).sequence(S.Either.of)
+ //. Right(Just(42))
+ //. ```
+ Maybe.prototype.sequence =
+ method('Maybe#sequence',
+ {a: [Apply], b: [Apply]},
+ [$Maybe(a), $.Function, b],
+ function(maybe, of) {
+ return maybe.isJust ? R.map(Just, maybe.value) : of(maybe);
+ });
+
+ //# Maybe#toBoolean :: Maybe a ~> Boolean
+ //.
+ //. Returns `false` if `this` is a Nothing; `true` if `this` is a Just.
+ //.
+ //. ```javascript
+ //. > S.Nothing().toBoolean()
+ //. false
+ //.
+ //. > S.Just(42).toBoolean()
+ //. true
+ //. ```
+ Maybe.prototype.toBoolean =
+ method('Maybe#toBoolean',
+ {},
+ [$Maybe(a), $.Boolean],
+ R.prop('isJust'));
+
+ //# Maybe#toString :: Maybe a ~> String
+ //.
+ //. Returns the string representation of the Maybe.
+ //.
+ //. ```javascript
+ //. > S.Nothing().toString()
+ //. 'Nothing()'
+ //.
+ //. > S.Just([1, 2, 3]).toString()
+ //. 'Just([1, 2, 3])'
+ //. ```
+ Maybe.prototype.toString =
+ method('Maybe#toString',
+ {},
+ [$Maybe(a), $.String],
+ function(maybe) {
+ return maybe.isJust ? 'Just(' + R.toString(maybe.value) + ')'
+ : 'Nothing()';
+ });
+
+ //# Maybe#inspect :: Maybe a ~> String
+ //.
+ //. Returns the string representation of the Maybe. This method is used by
+ //. `util.inspect` and the REPL to format a Maybe for display.
+ //.
+ //. See also [`Maybe#toString`](#Maybe.prototype.toString).
+ //.
+ //. ```javascript
+ //. > S.Nothing().inspect()
+ //. 'Nothing()'
+ //.
+ //. > S.Just([1, 2, 3]).inspect()
+ //. 'Just([1, 2, 3])'
+ //. ```
+ Maybe.prototype.inspect = inspect;
+
+ //# Nothing :: -> Maybe a
+ //.
+ //. Returns a Nothing. Though this is a constructor function the `new`
+ //. keyword needn't be used.
+ //.
+ //. ```javascript
+ //. > S.Nothing()
+ //. Nothing()
+ //. ```
+ var Nothing = S.Nothing = function() {
+ var nothing = new Maybe(sentinel);
+ nothing.isNothing = true;
+ nothing.isJust = false;
+ return nothing;
+ };
+
+ //# Just :: a -> Maybe a
+ //.
+ //. Takes a value of any type and returns a Just with the given value.
+ //. Though this is a constructor function the `new` keyword needn't be
+ //. used.
+ //.
+ //. ```javascript
+ //. > S.Just(42)
+ //. Just(42)
+ //. ```
+ var Just = S.Just = function(value) {
+ var just = new Maybe(sentinel);
+ just.isNothing = false;
+ just.isJust = true;
+ just.value = value;
+ return just;
+ };
+
+ //# isNothing :: Maybe a -> Boolean
+ //.
+ //. Returns `true` if the given Maybe is a Nothing; `false` if it is a Just.
+ //.
+ //. ```javascript
+ //. > S.isNothing(S.Nothing())
+ //. true
+ //.
+ //. > S.isNothing(S.Just(42))
+ //. false
+ //. ```
+ S.isNothing =
+ def('isNothing',
+ {},
+ [$Maybe(a), $.Boolean],
+ R.prop('isNothing'));
+
+ //# isJust :: Maybe a -> Boolean
+ //.
+ //. Returns `true` if the given Maybe is a Just; `false` if it is a Nothing.
+ //.
+ //. ```javascript
+ //. > S.isJust(S.Just(42))
+ //. true
+ //.
+ //. > S.isJust(S.Nothing())
+ //. false
+ //. ```
+ S.isJust =
+ def('isJust',
+ {},
+ [$Maybe(a), $.Boolean],
+ R.prop('isJust'));
+
+ //# fromMaybe :: a -> Maybe a -> a
+ //.
+ //. Takes a default value and a Maybe, and returns the Maybe's value
+ //. if the Maybe is a Just; the default value otherwise.
+ //.
+ //. ```javascript
+ //. > S.fromMaybe(0, S.Just(42))
+ //. 42
+ //.
+ //. > S.fromMaybe(0, S.Nothing())
+ //. 0
+ //. ```
+ var fromMaybe = S.fromMaybe =
+ def('fromMaybe',
+ {},
+ [a, $Maybe(a), a],
+ function(x, maybe) { return maybe.isJust ? maybe.value : x; });
+
+ //# toMaybe :: a? -> Maybe a
+ //.
+ //. Takes a value and returns Nothing if the value is null or undefined;
+ //. Just the value otherwise.
+ //.
+ //. ```javascript
+ //. > S.toMaybe(null)
+ //. Nothing()
+ //.
+ //. > S.toMaybe(42)
+ //. Just(42)
+ //. ```
+ var toMaybe = S.toMaybe =
+ def('toMaybe',
+ {},
+ [$.Any, $Maybe(a)],
+ function(x) { return x == null ? Nothing() : Just(x); });
+
+ //# maybe :: b -> (a -> b) -> Maybe a -> b
+ //.
+ //. Takes a value of any type, a function, and a Maybe. If the Maybe is
+ //. a Just, the return value is the result of applying the function to
+ //. the Just's value. Otherwise, the first argument is returned.
+ //.
+ //. ```javascript
+ //. > S.maybe(0, R.length, S.Just('refuge'))
+ //. 6
+ //.
+ //. > S.maybe(0, R.length, S.Nothing())
+ //. 0
+ //. ```
+ var maybe = S.maybe =
+ def('maybe',
+ {},
+ [b, $.Function, $Maybe(a), b],
+ function(x, f, maybe) { return fromMaybe(x, maybe.map(f)); });
+
+ //# catMaybes :: [Maybe a] -> [a]
+ //.
+ //. Takes a list of Maybes and returns a list containing each Just's value.
+ //.
+ //. ```javascript
+ //. > S.catMaybes([S.Just('foo'), S.Nothing(), S.Just('baz')])
+ //. ['foo', 'baz']
+ //. ```
+ var catMaybes = S.catMaybes =
+ def('catMaybes',
+ {},
+ [$.Array($Maybe(a)), $.Array(a)],
+ R.chain(maybe([], R.of)));
+
+ //# mapMaybe :: (a -> Maybe b) -> [a] -> [b]
+ //.
+ //. Takes a function and a list, applies the function to each element of
+ //. the list, and returns a list of "successful" results. If the result of
+ //. applying the function to an element of the list is a Nothing, the result
+ //. is discarded; if the result is a Just, the Just's value is included in
+ //. the output list.
+ //.
+ //. In general terms, `mapMaybe` filters a list while mapping over it.
+ //.
+ //. ```javascript
+ //. > S.mapMaybe(S.head, [[], [1, 2, 3], [], [4, 5, 6], []])
+ //. [1, 4]
+ //. ```
+ S.mapMaybe =
+ def('mapMaybe',
+ {},
+ [$.Function, $.Array(a), $.Array(b)],
+ R.compose(catMaybes, R.map));
+
+ //# encase :: (a -> b) -> a -> Maybe b
+ //.
+ //. Takes a unary function `f` which may throw and a value `x` of any type,
+ //. and applies `f` to `x` inside a `try` block. If an exception is caught,
+ //. the return value is a Nothing; otherwise the return value is Just the
+ //. result of applying `f` to `x`.
+ //.
+ //. See also [`encaseEither`](#encaseEither).
+ //.
+ //. ```javascript
+ //. > S.encase(eval, '1 + 1')
+ //. Just(2)
+ //.
+ //. > S.encase(eval, '1 +')
+ //. Nothing()
+ //. ```
+ var encase = S.encase =
+ def('encase',
+ {},
+ [$.Function, a, $Maybe(b)],
+ function(f, x) {
+ try {
+ return Just(f(x));
+ } catch (err) {
+ return Nothing();
+ }
+ });
+
+ //# encase2 :: (a -> b -> c) -> a -> b -> Maybe c
+ //.
+ //. Binary version of [`encase`](#encase).
+ S.encase2 =
+ def('encase2',
+ {},
+ [$.Function, a, b, $Maybe(c)],
+ function(f, x, y) {
+ try {
+ return Just(f(x, y));
+ } catch (err) {
+ return Nothing();
+ }
+ });
+
+ //# encase3 :: (a -> b -> c -> d) -> a -> b -> c -> Maybe d
+ //.
+ //. Ternary version of [`encase`](#encase).
+ S.encase3 =
+ def('encase3',
+ {},
+ [$.Function, a, b, c, $Maybe(d)],
+ function(f, x, y, z) {
+ try {
+ return Just(f(x, y, z));
+ } catch (err) {
+ return Nothing();
+ }
+ });
+
+ //. ### Either type
+ //.
+ //. The Either type represents values with two possibilities: a value of type
+ //. `Either a b` is either a Left whose value is of type `a` or a Right whose
+ //. value is of type `b`.
+ //.
+ //. The Either type satisfies the [Semigroup][], [Monad][], and [Extend][]
+ //. specifications.
+
+ //# EitherType :: Type -> Type -> Type
+ //.
+ //. A [`BinaryType`][BinaryType] for use with [sanctuary-def][].
+
+ //# Either :: TypeRep Either
+ //.
+ //. The [type representative](#type-representatives) for the Either type.
+ var Either = S.Either = function Either() {
+ if (arguments[0] !== sentinel) {
+ throw new Error('Cannot instantiate Either');
+ }
+ };
+
+ //# Either.of :: b -> Either a b
+ //.
+ //. Takes a value of any type and returns a Right with the given value.
+ //.
+ //. ```javascript
+ //. > S.Either.of(42)
+ //. Right(42)
+ //. ```
+ Either.of =
+ def('Either.of',
+ {},
+ [b, $Either(a, b)],
+ function(x) { return Right(x); });
+
+ //# Either#@@type :: String
+ //.
+ //. Either type identifier, `'sanctuary/Either'`.
+ Either.prototype['@@type'] = 'sanctuary/Either';
+
+ //# Either#isLeft :: Boolean
+ //.
+ //. `true` if `this` is a Left; `false` if `this` is a Right.
+ //.
+ //. ```javascript
+ //. > S.Left('Cannot divide by zero').isLeft
+ //. true
+ //.
+ //. > S.Right(42).isLeft
+ //. false
+ //. ```
+
+ //# Either#isRight :: Boolean
+ //.
+ //. `true` if `this` is a Right; `false` if `this` is a Left.
+ //.
+ //. ```javascript
+ //. > S.Right(42).isRight
+ //. true
+ //.
+ //. > S.Left('Cannot divide by zero').isRight
+ //. false
+ //. ```
+
+ //# Either#ap :: Either a (b -> c) ~> Either a b -> Either a c
+ //.
+ //. Takes a value of type `Either a b` and returns a Left unless `this`
+ //. is a Right *and* the argument is a Right, in which case it returns
+ //. a Right whose value is the result of applying this Right's value to
+ //. the given Right's value.
+ //.
+ //. ```javascript
+ //. > S.Left('Cannot divide by zero').ap(S.Right(42))
+ //. Left('Cannot divide by zero')
+ //.
+ //. > S.Right(S.inc).ap(S.Left('Cannot divide by zero'))
+ //. Left('Cannot divide by zero')
+ //.
+ //. > S.Right(S.inc).ap(S.Right(42))
+ //. Right(43)
+ //. ```
+ Either.prototype.ap =
+ method('Either#ap',
+ {},
+ [$Either(a, $.Function), $Either(a, b), $Either(a, c)],
+ function(ef, ex) { return ef.isRight ? ex.map(ef.value) : ef; });
+
+ //# Either#chain :: Either a b ~> (b -> Either a c) -> Either a c
+ //.
+ //. Takes a function and returns `this` if `this` is a Left; otherwise
+ //. it returns the result of applying the function to this Right's value.
+ //.
+ //. ```javascript
+ //. > global.sqrt = n =>
+ //. . n < 0 ? S.Left('Cannot represent square root of negative number')
+ //. . : S.Right(Math.sqrt(n))
+ //. sqrt
+ //.
+ //. > S.Left('Cannot divide by zero').chain(sqrt)
+ //. Left('Cannot divide by zero')
+ //.
+ //. > S.Right(-1).chain(sqrt)
+ //. Left('Cannot represent square root of negative number')
+ //.
+ //. > S.Right(25).chain(sqrt)
+ //. Right(5)
+ //. ```
+ Either.prototype.chain =
+ method('Either#chain',
+ {},
+ [$Either(a, b), $.Function, $Either(a, c)],
+ function(either, f) {
+ return either.isRight ? f(either.value) : either;
+ });
+
+ //# Either#concat :: (Semigroup a, Semigroup b) => Either a b ~> Either a b -> Either a b
+ //.
+ //. Returns the result of concatenating two Either values of the same type.
+ //. `a` must have a [Semigroup][] (indicated by the presence of a `concat`
+ //. method), as must `b`.
+ //.
+ //. If `this` is a Left and the argument is a Left, this method returns a
+ //. Left whose value is the result of concatenating this Left's value and
+ //. the given Left's value.
+ //.
+ //. If `this` is a Right and the argument is a Right, this method returns a
+ //. Right whose value is the result of concatenating this Right's value and
+ //. the given Right's value.
+ //.
+ //. Otherwise, this method returns the Right.
+ //.
+ //. ```javascript
+ //. > S.Left('abc').concat(S.Left('def'))
+ //. Left('abcdef')
+ //.
+ //. > S.Right([1, 2, 3]).concat(S.Right([4, 5, 6]))
+ //. Right([1, 2, 3, 4, 5, 6])
+ //.
+ //. > S.Left('abc').concat(S.Right([1, 2, 3]))
+ //. Right([1, 2, 3])
+ //.
+ //. > S.Right([1, 2, 3]).concat(S.Left('abc'))
+ //. Right([1, 2, 3])
+ //. ```
+ Either.prototype.concat =
+ method('Either#concat',
+ {a: [Semigroup], b: [Semigroup]},
+ [$Either(a, b), $Either(a, b), $Either(a, b)],
+ function(ex, ey) {
+ return ex.isLeft && ey.isLeft ? Left(ex.value.concat(ey.value)) :
+ ex.isRight && ey.isRight ? Right(ex.value.concat(ey.value)) :
+ ex.isRight ? ex : ey;
+ });
+
+ //# Either#equals :: Either a b ~> c -> Boolean
+ //.
+ //. Takes a value of any type and returns `true` if:
+ //.
+ //. - it is a Left and `this` is a Left, and their values are equal
+ //. according to [`R.equals`][R.equals]; or
+ //.
+ //. - it is a Right and `this` is a Right, and their values are equal
+ //. according to [`R.equals`][R.equals].
+ //.
+ //. ```javascript
+ //. > S.Right([1, 2, 3]).equals(S.Right([1, 2, 3]))
+ //. true
+ //.
+ //. > S.Right([1, 2, 3]).equals(S.Left([1, 2, 3]))
+ //. false
+ //.
+ //. > S.Right(42).equals(42)
+ //. false
+ //. ```
+ Either.prototype.equals =
+ method('Either#equals',
+ {},
+ [$Either(a, b), c, $.Boolean],
+ function(either, x) {
+ return _type(x) === 'sanctuary/Either' &&
+ either.isLeft === x.isLeft && R.eqProps('value', either, x);
+ });
+
+ //# Either#extend :: Either a b ~> (Either a b -> b) -> Either a b
+ //.
+ //. Takes a function and returns `this` if `this` is a Left; otherwise it
+ //. returns a Right whose value is the result of applying the function to
+ //. `this`.
+ //.
+ //. ```javascript
+ //. > S.Left('Cannot divide by zero').extend(x => x.value + 1)
+ //. Left('Cannot divide by zero')
+ //.
+ //. > S.Right(42).extend(x => x.value + 1)
+ //. Right(43)
+ //. ```
+ Either.prototype.extend =
+ method('Either#extend',
+ {},
+ [$Either(a, b), $.Function, $Either(a, b)],
+ function(either, f) {
+ return either.isLeft ? either : Right(f(either));
+ });
+
+ //# Either#map :: Either a b ~> (b -> c) -> Either a c
+ //.
+ //. Takes a function and returns `this` if `this` is a Left; otherwise it
+ //. returns a Right whose value is the result of applying the function to
+ //. this Right's value.
+ //.
+ //. ```javascript
+ //. > S.Left('Cannot divide by zero').map(S.inc)
+ //. Left('Cannot divide by zero')
+ //.
+ //. > S.Right([1, 2, 3]).map(R.sum)
+ //. Right(6)
+ //. ```
+ Either.prototype.map =
+ method('Either#map',
+ {},
+ [$Either(a, b), $.Function, $Either(a, c)],
+ function(either, f) {
+ return either.isRight ? Right(f(either.value)) : either;
+ });
+
+ //# Either#of :: Either a b ~> c -> Either a c
+ //.
+ //. Takes a value of any type and returns a Right with the given value.
+ //.
+ //. ```javascript
+ //. > S.Left('Cannot divide by zero').of(42)
+ //. Right(42)
+ //. ```
+ Either.prototype.of =
+ def('Either#of',
+ {},
+ [c, $Either(a, c)],
+ Either.of);
+
+ //# Either#toBoolean :: Either a b ~> Boolean
+ //.
+ //. Returns `false` if `this` is a Left; `true` if `this` is a Right.
+ //.
+ //. ```javascript
+ //. > S.Left(42).toBoolean()
+ //. false
+ //.
+ //. > S.Right(42).toBoolean()
+ //. true
+ //. ```
+ Either.prototype.toBoolean =
+ method('Either#toBoolean',
+ {},
+ [$Either(a, b), $.Boolean],
+ R.prop('isRight'));
+
+ //# Either#toString :: Either a b ~> String
+ //.
+ //. Returns the string representation of the Either.
+ //.
+ //. ```javascript
+ //. > S.Left('Cannot divide by zero').toString()
+ //. 'Left("Cannot divide by zero")'
+ //.
+ //. > S.Right([1, 2, 3]).toString()
+ //. 'Right([1, 2, 3])'
+ //. ```
+ Either.prototype.toString =
+ method('Either#toString',
+ {},
+ [$Either(a, b), $.String],
+ function(either) {
+ return (either.isLeft ? 'Left' : 'Right') +
+ '(' + R.toString(either.value) + ')';
+ });
+
+ //# Either#inspect :: Either a b ~> String
+ //.
+ //. Returns the string representation of the Either. This method is used by
+ //. `util.inspect` and the REPL to format a Either for display.
+ //.
+ //. See also [`Either#toString`](#Either.prototype.toString).
+ //.
+ //. ```javascript
+ //. > S.Left('Cannot divide by zero').inspect()
+ //. 'Left("Cannot divide by zero")'
+ //.
+ //. > S.Right([1, 2, 3]).inspect()
+ //. 'Right([1, 2, 3])'
+ //. ```
+ Either.prototype.inspect = inspect;
+
+ //# Left :: a -> Either a b
+ //.
+ //. Takes a value of any type and returns a Left with the given value.
+ //. Though this is a constructor function the `new` keyword needn't be
+ //. used.
+ //.
+ //. ```javascript
+ //. > S.Left('Cannot divide by zero')
+ //. Left('Cannot divide by zero')
+ //. ```
+ var Left = S.Left = function(value) {
+ var left = new Either(sentinel);
+ left.isLeft = true;
+ left.isRight = false;
+ left.value = value;
+ return left;
+ };
+
+ //# Right :: b -> Either a b
+ //.
+ //. Takes a value of any type and returns a Right with the given value.
+ //. Though this is a constructor function the `new` keyword needn't be
+ //. used.
+ //.
+ //. ```javascript
+ //. > S.Right(42)
+ //. Right(42)
+ //. ```
+ var Right = S.Right = function(value) {
+ var right = new Either(sentinel);
+ right.isLeft = false;
+ right.isRight = true;
+ right.value = value;
+ return right;
+ };
+
+ //# isLeft :: Either a b -> Boolean
+ //.
+ //. Returns `true` if the given Either is a Left; `false` if it is a Right.
+ //.
+ //. ```javascript
+ //. > S.isLeft(S.Left('Cannot divide by zero'))
+ //. true
+ //.
+ //. > S.isLeft(S.Right(42))
+ //. false
+ //. ```
+ S.isLeft =
+ def('isLeft',
+ {},
+ [$Either(a, b), $.Boolean],
+ R.prop('isLeft'));
+
+ //# isRight :: Either a b -> Boolean
+ //.
+ //. Returns `true` if the given Either is a Right; `false` if it is a Left.
+ //.
+ //. ```javascript
+ //. > S.isRight(S.Right(42))
+ //. true
+ //.
+ //. > S.isRight(S.Left('Cannot divide by zero'))
+ //. false
+ //. ```
+ S.isRight =
+ def('isRight',
+ {},
+ [$Either(a, b), $.Boolean],
+ R.prop('isRight'));
+
+ //# either :: (a -> c) -> (b -> c) -> Either a b -> c
+ //.
+ //. Takes two functions and an Either, and returns the result of
+ //. applying the first function to the Left's value, if the Either
+ //. is a Left, or the result of applying the second function to the
+ //. Right's value, if the Either is a Right.
+ //.
+ //. ```javascript
+ //. > S.either(S.toUpper, R.toString, S.Left('Cannot divide by zero'))
+ //. 'CANNOT DIVIDE BY ZERO'
+ //.
+ //. > S.either(S.toUpper, R.toString, S.Right(42))
+ //. '42'
+ //. ```
+ S.either =
+ def('either',
+ {},
+ [$.Function, $.Function, $Either(a, b), c],
+ function(l, r, either) {
+ return either.isLeft ? l(either.value) : r(either.value);
+ });
+
+ //# lefts :: [Either a b] -> [a]
+ //.
+ //. Takes a list of Eithers and returns a list containing each Left's value.
+ //.
+ //. See also [`rights`](#rights).
+ //.
+ //. ```javascript
+ //. > S.lefts([S.Right(20), S.Left('foo'), S.Right(10), S.Left('bar')])
+ //. ['foo', 'bar']
+ //. ```
+ S.lefts =
+ def('lefts',
+ {},
+ [$.Array($Either(a, b)), $.Array(a)],
+ R.chain(function(either) {
+ return either.isLeft ? [either.value] : [];
+ }));
+
+ //# rights :: [Either a b] -> [b]
+ //.
+ //. Takes a list of Eithers and returns a list containing each Right's value.
+ //.
+ //. See also [`lefts`](#lefts).
+ //.
+ //. ```javascript
+ //. > S.rights([S.Right(20), S.Left('foo'), S.Right(10), S.Left('bar')])
+ //. [20, 10]
+ //. ```
+ S.rights =
+ def('rights',
+ {},
+ [$.Array($Either(a, b)), $.Array(b)],
+ R.chain(function(either) {
+ return either.isRight ? [either.value] : [];
+ }));
+
+ //# encaseEither :: (Error -> l) -> (a -> r) -> a -> Either l r
+ //.
+ //. Takes two unary functions, `f` and `g`, the second of which may throw,
+ //. and a value `x` of any type. Applies `g` to `x` inside a `try` block.
+ //. If an exception is caught, the return value is a Left containing the
+ //. result of applying `f` to the caught Error object; otherwise the return
+ //. value is a Right containing the result of applying `g` to `x`.
+ //.
+ //. See also [`encase`](#encase).
+ //.
+ //. ```javascript
+ //. > S.encaseEither(S.I, JSON.parse, '["foo","bar","baz"]')
+ //. Right(['foo', 'bar', 'baz'])
+ //.
+ //. > S.encaseEither(S.I, JSON.parse, '[')
+ //. Left(new SyntaxError('Unexpected end of input'))
+ //.
+ //. > S.encaseEither(R.prop('message'), JSON.parse, '[')
+ //. Left('Unexpected end of input')
+ //. ```
+ S.encaseEither =
+ def('encaseEither',
+ {},
+ [$.Function, $.Function, a, $Either(l, r)],
+ function(f, g, x) {
+ try {
+ return Right(g(x));
+ } catch (err) {
+ return Left(f(err));
+ }
+ });
+
+ //# encaseEither2 :: (Error -> l) -> (a -> b -> r) -> a -> b -> Either l r
+ //.
+ //. Binary version of [`encaseEither`](#encaseEither).
+ S.encaseEither2 =
+ def('encaseEither2',
+ {},
+ [$.Function, $.Function, a, b, $Either(l, r)],
+ function(f, g, x, y) {
+ try {
+ return Right(g(x, y));
+ } catch (err) {
+ return Left(f(err));
+ }
+ });
+
+ //# encaseEither3 :: (Error -> l) -> (a -> b -> c -> r) -> a -> b -> c -> Either l r
+ //.
+ //. Ternary version of [`encaseEither`](#encaseEither).
+ S.encaseEither3 =
+ def('encaseEither3',
+ {},
+ [$.Function, $.Function, a, b, c, $Either(l, r)],
+ function(f, g, x, y, z) {
+ try {
+ return Right(g(x, y, z));
+ } catch (err) {
+ return Left(f(err));
+ }
+ });
+
+ //# maybeToEither :: a -> Maybe b -> Either a b
+ //.
+ //. Takes a value of any type and a Maybe, and returns an Either.
+ //. If the second argument is a Nothing, a Left containing the first
+ //. argument is returned. If the second argument is a Just, a Right
+ //. containing the Just's value is returned.
+ //.
+ //. ```javascript
+ //. > S.maybeToEither('Expecting an integer', S.parseInt(10, 'xyz'))
+ //. Left('Expecting an integer')
+ //.
+ //. > S.maybeToEither('Expecting an integer', S.parseInt(10, '42'))
+ //. Right(42)
+ //. ```
+ S.maybeToEither =
+ def('maybeToEither',
+ {},
+ [a, $Maybe(b), $Either(a, b)],
+ function(x, maybe) {
+ return maybe.isNothing ? Left(x) : Right(maybe.value);
+ });
+
+ //. ### Alternative
+
+ var Alternative = $.TypeClass(
+ 'Alternative',
+ function(x) {
+ return R.contains(R.type(x), ['Array', 'Boolean']) ||
+ hasMethod('toBoolean')(x);
+ }
+ );
+
+ // toBoolean :: Alternative a => a -> Boolean
+ var toBoolean = function(x) {
+ switch (R.type(x)) {
+ case 'Array': return x.length > 0;
+ case 'Boolean': return x.valueOf();
+ default: return x.toBoolean();
+ }
+ };
+
+ // empty :: Monoid a => a -> a
+ var empty = function(x) {
+ switch (R.type(x)) {
+ case 'Array': return [];
+ case 'Boolean': return false;
+ default: return x.empty();
+ }
+ };
+
+ //# and :: Alternative a => a -> a -> a
+ //.
+ //. Takes two values of the same type and returns the second value
+ //. if the first is "true"; the first value otherwise. An array is
+ //. considered "true" if its length is greater than zero. The Boolean
+ //. value `true` is also considered "true". Other types must provide
+ //. a `toBoolean` method.
+ //.
+ //. ```javascript
+ //. > S.and(S.Just(1), S.Just(2))
+ //. Just(2)
+ //.
+ //. > S.and(S.Nothing(), S.Just(3))
+ //. Nothing()
+ //. ```
+ S.and =
+ def('and',
+ {a: [Alternative]},
+ [a, a, a],
+ function(x, y) { return toBoolean(x) ? y : x; });
+
+ //# or :: Alternative a => a -> a -> a
+ //.
+ //. Takes two values of the same type and returns the first value if it
+ //. is "true"; the second value otherwise. An array is considered "true"
+ //. if its length is greater than zero. The Boolean value `true` is also
+ //. considered "true". Other types must provide a `toBoolean` method.
+ //.
+ //. ```javascript
+ //. > S.or(S.Just(1), S.Just(2))
+ //. Just(1)
+ //.
+ //. > S.or(S.Nothing(), S.Just(3))
+ //. Just(3)
+ //. ```
+ var or = S.or =
+ def('or',
+ {a: [Alternative]},
+ [a, a, a],
+ function(x, y) { return toBoolean(x) ? x : y; });
+
+ //# xor :: (Alternative a, Monoid a) => a -> a -> a
+ //.
+ //. Takes two values of the same type and returns the "true" value
+ //. if one value is "true" and the other is "false"; otherwise it
+ //. returns the type's "false" value. An array is considered "true"
+ //. if its length is greater than zero. The Boolean value `true` is
+ //. also considered "true". Other types must provide `toBoolean` and
+ //. `empty` methods.
+ //.
+ //. ```javascript
+ //. > S.xor(S.Nothing(), S.Just(1))
+ //. Just(1)
+ //.
+ //. > S.xor(S.Just(2), S.Just(3))
+ //. Nothing()
+ //. ```
+ S.xor =
+ def('xor',
+ {a: [Alternative, Monoid]},
+ [a, a, a],
+ function(x, y) {
+ return toBoolean(x) !== toBoolean(y) ? or(x, y) : empty(x);
+ });
+
+ //. ### Logic
+
+ //# not :: Boolean -> Boolean
+ //.
+ //. Takes a Boolean and returns the negation of that value
+ //. (`false` for `true`; `true` for `false`).
+ //.
+ //. ```javascript
+ //. > S.not(true)
+ //. false
+ //.
+ //. > S.not(false)
+ //. true
+ //. ```
+ S.not =
+ def('not',
+ {},
+ [$.Boolean, $.Boolean],
+ function(x) { return !x.valueOf(); });
+
+ //# ifElse :: (a -> Boolean) -> (a -> b) -> (a -> b) -> a -> b
+ //.
+ //. Takes a unary predicate, a unary "if" function, a unary "else"
+ //. function, and a value of any type, and returns the result of
+ //. applying the "if" function to the value if the value satisfies
+ //. the predicate; the result of applying the "else" function to the
+ //. value otherwise.
+ //.
+ //. ```javascript
+ //. > S.ifElse(x => x < 0, Math.abs, Math.sqrt, -1)
+ //. 1
+ //.
+ //. > S.ifElse(x => x < 0, Math.abs, Math.sqrt, 16)
+ //. 4
+ //. ```
+ S.ifElse =
+ def('ifElse',
+ {},
+ [$.Function, $.Function, $.Function, a, b],
+ function(pred, f, g, x) { return pred(x) ? f(x) : g(x); });
+
+ //# allPass :: [a -> Boolean] -> a -> Boolean
+ //.
+ //. Takes an array of unary predicates and a value of any type
+ //. and returns `true` if all the predicates pass; `false` otherwise.
+ //. None of the subsequent predicates will be evaluated after the
+ //. first failed predicate.
+ //.
+ //. ```javascript
+ //. > S.allPass([S.test(/q/), S.test(/u/), S.test(/i/)], 'quiessence')
+ //. true
+ //.
+ //. > S.allPass([S.test(/q/), S.test(/u/), S.test(/i/)], 'fissiparous')
+ //. false
+ //. ```
+ S.allPass =
+ def('allPass',
+ {},
+ [$.Array($.Function), a, $.Boolean],
+ function(preds, x) {
+ for (var idx = 0; idx < preds.length; idx += 1) {
+ if (!preds[idx](x)) return false;
+ }
+ return true;
+ });
+
+ //# anyPass :: [a -> Boolean] -> a -> Boolean
+ //.
+ //. Takes an array of unary predicates and a value of any type
+ //. and returns `true` if any of the predicates pass; `false` otherwise.
+ //. None of the subsequent predicates will be evaluated after the
+ //. first passed predicate.
+ //.
+ //. ```javascript
+ //. > S.anyPass([S.test(/q/), S.test(/u/), S.test(/i/)], 'incandescent')
+ //. true
+ //.
+ //. > S.anyPass([S.test(/q/), S.test(/u/), S.test(/i/)], 'empathy')
+ //. false
+ //. ```
+ S.anyPass =
+ def('anyPass',
+ {},
+ [$.Array($.Function), a, $.Boolean],
+ function(preds, x) {
+ for (var idx = 0; idx < preds.length; idx += 1) {
+ if (preds[idx](x)) return true;
+ }
+ return false;
+ });
+
+ //. ### List
+
+ //# slice :: Integer -> Integer -> [a] -> Maybe [a]
+ //.
+ //. Returns Just a list containing the elements from the supplied list
+ //. from a beginning index (inclusive) to an end index (exclusive).
+ //. Returns Nothing unless the start interval is less than or equal to
+ //. the end interval, and the list contains both (half-open) intervals.
+ //. Accepts negative indices, which indicate an offset from the end of
+ //. the list.
+ //.
+ //. Dispatches to its third argument's `slice` method if present. As a
+ //. result, one may replace `[a]` with `String` in the type signature.
+ //.
+ //. ```javascript
+ //. > S.slice(1, 3, ['a', 'b', 'c', 'd', 'e'])
+ //. Just(['b', 'c'])
+ //.
+ //. > S.slice(-2, -0, ['a', 'b', 'c', 'd', 'e'])
+ //. Just(['d', 'e'])
+ //.
+ //. > S.slice(2, -0, ['a', 'b', 'c', 'd', 'e'])
+ //. Just(['c', 'd', 'e'])
+ //.
+ //. > S.slice(1, 6, ['a', 'b', 'c', 'd', 'e'])
+ //. Nothing()
+ //.
+ //. > S.slice(2, 6, 'banana')
+ //. Just('nana')
+ //. ```
+ var slice = S.slice =
+ def('slice',
+ {},
+ [$.Integer, $.Integer, List(a), $Maybe(List(a))],
+ function(start, end, xs) {
+ var len = xs.length;
+ var A = negativeZero(start) ? len : start < 0 ? start + len : start;
+ var Z = negativeZero(end) ? len : end < 0 ? end + len : end;
+
+ return (Math.abs(start) <= len && Math.abs(end) <= len && A <= Z) ?
+ Just(R.slice(A, Z, xs)) :
+ Nothing();
+ });
+
+ //# at :: Integer -> [a] -> Maybe a
+ //.
+ //. Takes an index and a list and returns Just the element of the list at
+ //. the index if the index is within the list's bounds; Nothing otherwise.
+ //. A negative index represents an offset from the length of the list.
+ //.
+ //. ```javascript
+ //. > S.at(2, ['a', 'b', 'c', 'd', 'e'])
+ //. Just('c')
+ //.
+ //. > S.at(5, ['a', 'b', 'c', 'd', 'e'])
+ //. Nothing()
+ //.
+ //. > S.at(-2, ['a', 'b', 'c', 'd', 'e'])
+ //. Just('d')
+ //. ```
+ var at = S.at =
+ def('at',
+ {},
+ [$.Integer, List(a), $Maybe(a)],
+ function(n, xs) {
+ return R.map(R.head, slice(n, n === -1 ? -0 : n + 1, xs));
+ });
+
+ //# head :: [a] -> Maybe a
+ //.
+ //. Takes a list and returns Just the first element of the list if the
+ //. list contains at least one element; Nothing if the list is empty.
+ //.
+ //. ```javascript
+ //. > S.head([1, 2, 3])
+ //. Just(1)
+ //.
+ //. > S.head([])
+ //. Nothing()
+ //. ```
+ S.head =
+ def('head',
+ {},
+ [List(a), $Maybe(a)],
+ at(0));
+
+ //# last :: [a] -> Maybe a
+ //.
+ //. Takes a list and returns Just the last element of the list if the
+ //. list contains at least one element; Nothing if the list is empty.
+ //.
+ //. ```javascript
+ //. > S.last([1, 2, 3])
+ //. Just(3)
+ //.
+ //. > S.last([])
+ //. Nothing()
+ //. ```
+ S.last =
+ def('last',
+ {},
+ [List(a), $Maybe(a)],
+ at(-1));
+
+ //# tail :: [a] -> Maybe [a]
+ //.
+ //. Takes a list and returns Just a list containing all but the first
+ //. of the list's elements if the list contains at least one element;
+ //. Nothing if the list is empty.
+ //.
+ //. ```javascript
+ //. > S.tail([1, 2, 3])
+ //. Just([2, 3])
+ //.
+ //. > S.tail([])
+ //. Nothing()
+ //. ```
+ S.tail =
+ def('tail',
+ {},
+ [List(a), $Maybe(List(a))],
+ slice(1, -0));
+
+ //# init :: [a] -> Maybe [a]
+ //.
+ //. Takes a list and returns Just a list containing all but the last
+ //. of the list's elements if the list contains at least one element;
+ //. Nothing if the list is empty.
+ //.
+ //. ```javascript
+ //. > S.init([1, 2, 3])
+ //. Just([1, 2])
+ //.
+ //. > S.init([])
+ //. Nothing()
+ //. ```
+ S.init =
+ def('init',
+ {},
+ [List(a), $Maybe(List(a))],
+ slice(0, -1));
+
+ //# take :: Integer -> [a] -> Maybe [a]
+ //.
+ //. Returns Just the first N elements of the given collection if N is
+ //. greater than or equal to zero and less than or equal to the length
+ //. of the collection; Nothing otherwise. Supports Array, String, and
+ //. any other collection type which provides a `slice` method.
+ //.
+ //. ```javascript
+ //. > S.take(2, ['a', 'b', 'c', 'd', 'e'])
+ //. Just(['a', 'b'])
+ //.
+ //. > S.take(4, 'abcdefg')
+ //. Just('abcd')
+ //.
+ //. > S.take(4, ['a', 'b', 'c'])
+ //. Nothing()
+ //. ```
+ S.take =
+ def('take',
+ {},
+ [$.Integer, List(a), $Maybe(List(a))],
+ function(n, xs) {
+ return n < 0 || negativeZero(n) ? Nothing() : slice(0, n, xs);
+ });
+
+ //# takeLast :: Integer -> [a] -> Maybe [a]
+ //.
+ //. Returns Just the last N elements of the given collection if N is
+ //. greater than or equal to zero and less than or equal to the length
+ //. of the collection; Nothing otherwise. Supports Array, String, and
+ //. any other collection type which provides a `slice` method.
+ //.
+ //. ```javascript
+ //. > S.takeLast(2, ['a', 'b', 'c', 'd', 'e'])
+ //. Just(['d', 'e'])
+ //.
+ //. > S.takeLast(4, 'abcdefg')
+ //. Just('defg')
+ //.
+ //. > S.takeLast(4, ['a', 'b', 'c'])
+ //. Nothing()
+ //. ```
+ S.takeLast =
+ def('takeLast',
+ {},
+ [$.Integer, List(a), $Maybe(List(a))],
+ function(n, xs) {
+ return n < 0 || negativeZero(n) ? Nothing() : slice(-n, -0, xs);
+ });
+
+ //# drop :: Integer -> [a] -> Maybe [a]
+ //.
+ //. Returns Just all but the first N elements of the given collection
+ //. if N is greater than or equal to zero and less than or equal to the
+ //. length of the collection; Nothing otherwise. Supports Array, String,
+ //. and any other collection type which provides a `slice` method.
+ //.
+ //. ```javascript
+ //. > S.drop(2, ['a', 'b', 'c', 'd', 'e'])
+ //. Just(['c', 'd', 'e'])
+ //.
+ //. > S.drop(4, 'abcdefg')
+ //. Just('efg')
+ //.
+ //. > S.drop(4, 'abc')
+ //. Nothing()
+ //. ```
+ S.drop =
+ def('drop',
+ {},
+ [$.Integer, List(a), $Maybe(List(a))],
+ function(n, xs) {
+ return n < 0 || negativeZero(n) ? Nothing() : slice(n, -0, xs);
+ });
+
+ //# dropLast :: Integer -> [a] -> Maybe [a]
+ //.
+ //. Returns Just all but the last N elements of the given collection
+ //. if N is greater than or equal to zero and less than or equal to the
+ //. length of the collection; Nothing otherwise. Supports Array, String,
+ //. and any other collection type which provides a `slice` method.
+ //.
+ //. ```javascript
+ //. > S.dropLast(2, ['a', 'b', 'c', 'd', 'e'])
+ //. Just(['a', 'b', 'c'])
+ //.
+ //. > S.dropLast(4, 'abcdefg')
+ //. Just('abc')
+ //.
+ //. > S.dropLast(4, 'abc')
+ //. Nothing()
+ //. ```
+ S.dropLast =
+ def('dropLast',
+ {},
+ [$.Integer, List(a), $Maybe(List(a))],
+ function(n, xs) {
+ return n < 0 || negativeZero(n) ? Nothing() : slice(0, -n, xs);
+ });
+
+ //# find :: (a -> Boolean) -> [a] -> Maybe a
+ //.
+ //. Takes a predicate and a list and returns Just the leftmost element of
+ //. the list which satisfies the predicate; Nothing if none of the list's
+ //. elements satisfies the predicate.
+ //.
+ //. ```javascript
+ //. > S.find(n => n < 0, [1, -2, 3, -4, 5])
+ //. Just(-2)
+ //.
+ //. > S.find(n => n < 0, [1, 2, 3, 4, 5])
+ //. Nothing()
+ //. ```
+ S.find =
+ def('find',
+ {},
+ [$.Function, $.Array(a), $Maybe(a)],
+ function(pred, xs) {
+ for (var idx = 0, len = xs.length; idx < len; idx += 1) {
+ if (pred(xs[idx])) {
+ return Just(xs[idx]);
+ }
+ }
+ return Nothing();
+ });
+
+ var ArrayLike = $.TypeClass(
+ 'ArrayLike',
+ function(x) {
+ return x != null &&
+ typeof x !== 'function' &&
+ $.Integer.test(x.length) &&
+ x.length >= 0;
+ }
+ );
+
+ var sanctifyIndexOf = function(name) {
+ return def(name,
+ {b: [ArrayLike]},
+ [a, b, $Maybe($.Integer)],
+ R.pipe(R[name], Just, R.filter(R.gte(_, 0))));
+ };
+
+ //# indexOf :: a -> [a] -> Maybe Integer
+ //.
+ //. Takes a value of any type and a list, and returns Just the index
+ //. of the first occurrence of the value in the list, if applicable;
+ //. Nothing otherwise.
+ //.
+ //. Dispatches to its second argument's `indexOf` method if present.
+ //. As a result, `String -> String -> Maybe Integer` is an alternative
+ //. type signature.
+ //.
+ //. ```javascript
+ //. > S.indexOf('a', ['b', 'a', 'n', 'a', 'n', 'a'])
+ //. Just(1)
+ //.
+ //. > S.indexOf('x', ['b', 'a', 'n', 'a', 'n', 'a'])
+ //. Nothing()
+ //.
+ //. > S.indexOf('an', 'banana')
+ //. Just(1)
+ //.
+ //. > S.indexOf('ax', 'banana')
+ //. Nothing()
+ //. ```
+ S.indexOf = sanctifyIndexOf('indexOf');
+
+ //# lastIndexOf :: a -> [a] -> Maybe Integer
+ //.
+ //. Takes a value of any type and a list, and returns Just the index
+ //. of the last occurrence of the value in the list, if applicable;
+ //. Nothing otherwise.
+ //.
+ //. Dispatches to its second argument's `lastIndexOf` method if present.
+ //. As a result, `String -> String -> Maybe Integer` is an alternative
+ //. type signature.
+ //.
+ //. ```javascript
+ //. > S.lastIndexOf('a', ['b', 'a', 'n', 'a', 'n', 'a'])
+ //. Just(5)
+ //.
+ //. > S.lastIndexOf('x', ['b', 'a', 'n', 'a', 'n', 'a'])
+ //. Nothing()
+ //.
+ //. > S.lastIndexOf('an', 'banana')
+ //. Just(3)
+ //.
+ //. > S.lastIndexOf('ax', 'banana')
+ //. Nothing()
+ //. ```
+ S.lastIndexOf = sanctifyIndexOf('lastIndexOf');
+
+ //# pluck :: Accessible a => TypeRep b -> String -> [a] -> [Maybe b]
+ //.
+ //. Takes a [type representative](#type-representatives), a property name,
+ //. and a list of objects and returns a list of equal length. Each element
+ //. of the output list is Just the value of the specified property of the
+ //. corresponding object if the value is of the specified type (according
+ //. to [`is`](#is)); Nothing otherwise.
+ //.
+ //. See also [`get`](#get).
+ //.
+ //. ```javascript
+ //. > S.pluck(Number, 'x', [{x: 1}, {x: 2}, {x: '3'}, {x: null}, {}])
+ //. [Just(1), Just(2), Nothing(), Nothing(), Nothing()]
+ //. ```
+ S.pluck =
+ def('pluck',
+ {a: [Accessible]},
+ [TypeRep, $.String, $.Array(a), $.Array($Maybe(b))],
+ function(type, key, xs) { return R.map(get(type, key), xs); });
+
+ //# reduce :: Foldable f => (a -> b -> a) -> a -> f b -> a
+ //.
+ //. Takes a binary function, an initial value, and a [Foldable][], and
+ //. applies the function to the initial value and the Foldable's first
+ //. value, then applies the function to the result of the previous
+ //. application and the Foldable's second value. Repeats this process
+ //. until each of the Foldable's values has been used. Returns the initial
+ //. value if the Foldable is empty; the result of the final application
+ //. otherwise.
+ //.
+ //. ```javascript
+ //. > S.reduce(S.add, 0, [1, 2, 3, 4, 5])
+ //. 15
+ //.
+ //. > S.reduce((xs, x) => [x].concat(xs), [], [1, 2, 3, 4, 5])
+ //. [5, 4, 3, 2, 1]
+ //. ```
+ S.reduce =
+ def('reduce',
+ {b: [Foldable]},
+ [$.Function, a, b, a],
+ function(f, initial, foldable) {
+ if (_type(foldable) === 'Array') {
+ var acc = initial;
+ for (var idx = 0; idx < foldable.length; idx += 1) {
+ acc = f(acc, foldable[idx]);
+ }
+ return acc;
+ } else {
+ return foldable.reduce(f, initial);
+ }
+ });
+
+ //# unfoldr :: (b -> Maybe (a, b)) -> b -> [a]
+ //.
+ //. Takes a function and a seed value, and returns a list generated by
+ //. applying the function repeatedly. The list is initially empty. The
+ //. function is initially applied to the seed value. Each application
+ //. of the function should result in either:
+ //.
+ //. - a Nothing, in which case the list is returned; or
+ //.
+ //. - Just a pair, in which case the first element is appended to
+ //. the list and the function is applied to the second element.
+ //.
+ //. ```javascript
+ //. > S.unfoldr(n => n < 5 ? S.Just([n, n + 1]) : S.Nothing(), 1)
+ //. [1, 2, 3, 4]
+ //. ```
+ S.unfoldr =
+ def('unfoldr',
+ {},
+ [$.Function, b, $.Array(a)],
+ function(f, x) {
+ var result = [];
+ var m = f(x);
+ while (m.isJust) {
+ result.push(m.value[0]);
+ m = f(m.value[1]);
+ }
+ return result;
+ });
+
+ //. ### Object
+
+ //# get :: Accessible a => TypeRep b -> String -> a -> Maybe b
+ //.
+ //. Takes a [type representative](#type-representatives), a property
+ //. name, and an object and returns Just the value of the specified object
+ //. property if it is of the specified type (according to [`is`](#is));
+ //. Nothing otherwise.
+ //.
+ //. The `Object` type representative may be used as a catch-all since most
+ //. values have `Object.prototype` in their prototype chains.
+ //.
+ //. See also [`gets`](#gets).
+ //.
+ //. ```javascript
+ //. > S.get(Number, 'x', {x: 1, y: 2})
+ //. Just(1)
+ //.
+ //. > S.get(Number, 'x', {x: '1', y: '2'})
+ //. Nothing()
+ //.
+ //. > S.get(Number, 'x', {})
+ //. Nothing()
+ //. ```
+ var get = S.get =
+ def('get',
+ {a: [Accessible]},
+ [TypeRep, $.String, a, $Maybe(b)],
+ function(type, key, obj) { return filter(is(type), Just(obj[key])); });
+
+ //# gets :: Accessible a => TypeRep b -> [String] -> a -> Maybe b
+ //.
+ //. Takes a [type representative](#type-representatives), a list of property
+ //. names, and an object and returns Just the value at the path specified by
+ //. the list of property names if such a path exists and the value is of the
+ //. specified type; Nothing otherwise.
+ //.
+ //. See also [`get`](#get).
+ //.
+ //. ```javascript
+ //. > S.gets(Number, ['a', 'b', 'c'], {a: {b: {c: 42}}})
+ //. Just(42)
+ //.
+ //. > S.gets(Number, ['a', 'b', 'c'], {a: {b: {c: '42'}}})
+ //. Nothing()
+ //.
+ //. > S.gets(Number, ['a', 'b', 'c'], {})
+ //. Nothing()
+ //. ```
+ S.gets =
+ def('gets',
+ {a: [Accessible]},
+ [TypeRep, $.Array($.String), a, $Maybe(b)],
+ function(type, keys, obj) {
+ var x = obj;
+ for (var idx = 0; idx < keys.length; idx += 1) {
+ if (x == null) {
+ return Nothing();
+ }
+ x = x[keys[idx]];
+ }
+ return filter(is(type), Just(x));
+ });
+
+ //. ### Number
+
+ //# negate :: ValidNumber -> ValidNumber
+ //.
+ //. Negates its argument.
+ //.
+ //. ```javascript
+ //. > S.negate(12.5)
+ //. -12.5
+ //.
+ //. > S.negate(-42)
+ //. 42
+ //. ```
+ S.negate =
+ def('negate',
+ {},
+ [$.ValidNumber, $.ValidNumber],
+ function(n) { return -n; });
+
+ //# add :: FiniteNumber -> FiniteNumber -> FiniteNumber
+ //.
+ //. Returns the sum of two (finite) numbers.
+ //.
+ //. ```javascript
+ //. > S.add(1, 1)
+ //. 2
+ //. ```
+ S.add =
+ def('add',
+ {},
+ [$.FiniteNumber, $.FiniteNumber, $.FiniteNumber],
+ function(a, b) { return a + b; });
+
+ //# sub :: FiniteNumber -> FiniteNumber -> FiniteNumber
+ //.
+ //. Returns the difference between two (finite) numbers.
+ //.
+ //. ```javascript
+ //. > S.sub(4, 2)
+ //. 2
+ //. ```
+ S.sub =
+ def('sub',
+ {},
+ [$.FiniteNumber, $.FiniteNumber, $.FiniteNumber],
+ function(a, b) { return a - b; });
+
+ //# inc :: FiniteNumber -> FiniteNumber
+ //.
+ //. Increments a (finite) number by one.
+ //.
+ //. ```javascript
+ //. > S.inc(1)
+ //. 2
+ //. ```
+ S.inc =
+ def('inc',
+ {},
+ [$.FiniteNumber, $.FiniteNumber],
+ function(a) { return a + 1; });
+
+ //# dec :: FiniteNumber -> FiniteNumber
+ //.
+ //. Decrements a (finite) number by one.
+ //.
+ //. ```javascript
+ //. > S.dec(2)
+ //. 1
+ //. ```
+ S.dec =
+ def('dec',
+ {},
+ [$.FiniteNumber, $.FiniteNumber],
+ function(a) { return a - 1; });
+
+ //# mult :: FiniteNumber -> FiniteNumber -> FiniteNumber
+ //.
+ //. Returns the product of two (finite) numbers.
+ //.
+ //. ```javascript
+ //. > S.mult(4, 2)
+ //. 8
+ //. ```
+ S.mult =
+ def('mult',
+ {},
+ [$.FiniteNumber, $.FiniteNumber, $.FiniteNumber],
+ function(a, b) { return a * b; });
+
+ //# div :: FiniteNumber -> NonZeroFiniteNumber -> FiniteNumber
+ //.
+ //. Returns the result of dividing its first argument (a finite number) by
+ //. its second argument (a non-zero finite number).
+ //.
+ //. ```javascript
+ //. > S.div(7, 2)
+ //. 3.5
+ //. ```
+ S.div =
+ def('div',
+ {},
+ [$.FiniteNumber, $.NonZeroFiniteNumber, $.FiniteNumber],
+ function(a, b) { return a / b; });
+
+ //# min :: Ord a => a -> a -> a
+ //.
+ //. Returns the smaller of its two arguments.
+ //.
+ //. Strings are compared lexicographically. Specifically, the Unicode
+ //. code point value of each character in the first string is compared
+ //. to the value of the corresponding character in the second string.
+ //.
+ //. See also [`max`](#max).
+ //.
+ //. ```javascript
+ //. > S.min(10, 2)
+ //. 2
+ //.
+ //. > S.min(new Date('1999-12-31'), new Date('2000-01-01'))
+ //. new Date('1999-12-31')
+ //.
+ //. > S.min('10', '2')
+ //. '10'
+ //. ```
+ S.min =
+ def('min',
+ {a: [Ord]},
+ [a, a, a],
+ function(x, y) { return x < y ? x : y; });
+
+ //# max :: Ord a => a -> a -> a
+ //.
+ //. Returns the larger of its two arguments.
+ //.
+ //. Strings are compared lexicographically. Specifically, the Unicode
+ //. code point value of each character in the first string is compared
+ //. to the value of the corresponding character in the second string.
+ //.
+ //. See also [`min`](#min).
+ //.
+ //. ```javascript
+ //. > S.max(10, 2)
+ //. 10
+ //.
+ //. > S.max(new Date('1999-12-31'), new Date('2000-01-01'))
+ //. new Date('2000-01-01')
+ //.
+ //. > S.max('10', '2')
+ //. '2'
+ //. ```
+ S.max =
+ def('max',
+ {a: [Ord]},
+ [a, a, a],
+ function(x, y) { return x > y ? x : y; });
+
+ //. ### Integer
+
+ //# even :: Integer -> Boolean
+ //.
+ //. Returns `true` if the given integer is even; `false` if it is odd.
+ //.
+ //. ```javascript
+ //. > S.even(42)
+ //. true
+ //.
+ //. > S.even(99)
+ //. false
+ //. ```
+ S.even =
+ def('even',
+ {},
+ [$.Integer, $.Boolean],
+ function(n) { return n % 2 === 0; });
+
+ //# odd :: Integer -> Boolean
+ //.
+ //. Returns `true` if the given integer is odd; `false` if it is even.
+ //.
+ //. ```javascript
+ //. > S.odd(99)
+ //. true
+ //.
+ //. > S.odd(42)
+ //. false
+ //. ```
+ S.odd =
+ def('odd',
+ {},
+ [$.Integer, $.Boolean],
+ function(n) { return n % 2 !== 0; });
+
+ //. ### Parse
+
+ //# parseDate :: String -> Maybe Date
+ //.
+ //. Takes a string and returns Just the date represented by the string
+ //. if it does in fact represent a date; Nothing otherwise.
+ //.
+ //. ```javascript
+ //. > S.parseDate('2011-01-19T17:40:00Z')
+ //. Just(new Date('2011-01-19T17:40:00.000Z'))
+ //.
+ //. > S.parseDate('today')
+ //. Nothing()
+ //. ```
+ S.parseDate =
+ def('parseDate',
+ {},
+ [$.String, $Maybe($.Date)],
+ function(s) {
+ var d = new Date(s);
+ return d.valueOf() === d.valueOf() ? Just(d) : Nothing();
+ });
+
+ // requiredNonCapturingGroup :: [String] -> String
+ var requiredNonCapturingGroup = function(xs) {
+ return '(?:' + xs.join('|') + ')';
+ };
+
+ // optionalNonCapturingGroup :: [String] -> String
+ var optionalNonCapturingGroup = function(xs) {
+ return requiredNonCapturingGroup(xs) + '?';
+ };
+
+ // validFloatRepr :: String -> Boolean
+ var validFloatRepr = R.test(new RegExp(
+ '^' + // start-of-string anchor
+ '\\s*' + // any number of leading whitespace characters
+ '[+-]?' + // optional sign
+ requiredNonCapturingGroup([
+ 'Infinity', // "Infinity"
+ 'NaN', // "NaN"
+ requiredNonCapturingGroup([
+ '[0-9]+', // number
+ '[0-9]+[.][0-9]+', // number with interior decimal point
+ '[0-9]+[.]', // number with trailing decimal point
+ '[.][0-9]+' // number with leading decimal point
+ ]) +
+ optionalNonCapturingGroup([
+ '[Ee]' + // "E" or "e"
+ '[+-]?' + // optional sign
+ '[0-9]+' // exponent
+ ])
+ ]) +
+ '\\s*' + // any number of trailing whitespace characters
+ '$' // end-of-string anchor
+ ));
+
+ //# parseFloat :: String -> Maybe Number
+ //.
+ //. Takes a string and returns Just the number represented by the string
+ //. if it does in fact represent a number; Nothing otherwise.
+ //.
+ //. ```javascript
+ //. > S.parseFloat('-123.45')
+ //. Just(-123.45)
+ //.
+ //. > S.parseFloat('foo.bar')
+ //. Nothing()
+ //. ```
+ S.parseFloat =
+ def('parseFloat',
+ {},
+ [$.String, $Maybe($.Number)],
+ R.pipe(Just, R.filter(validFloatRepr), R.map(parseFloat)));
+
+ //# parseInt :: Integer -> String -> Maybe Integer
+ //.
+ //. Takes a radix (an integer between 2 and 36 inclusive) and a string,
+ //. and returns Just the number represented by the string if it does in
+ //. fact represent a number in the base specified by the radix; Nothing
+ //. otherwise.
+ //.
+ //. This function is stricter than [`parseInt`][parseInt]: a string
+ //. is considered to represent an integer only if all its non-prefix
+ //. characters are members of the character set specified by the radix.
+ //.
+ //. ```javascript
+ //. > S.parseInt(10, '-42')
+ //. Just(-42)
+ //.
+ //. > S.parseInt(16, '0xFF')
+ //. Just(255)
+ //.
+ //. > S.parseInt(16, '0xGG')
+ //. Nothing()
+ //. ```
+ S.parseInt =
+ def('parseInt',
+ {},
+ [$.Integer, $.String, $Maybe($.Integer)],
+ function(radix, s) {
+ if (radix < 2 || radix > 36) {
+ throw new RangeError('Radix not in [2 .. 36]');
+ }
+
+ var charset = R.take(radix, '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ');
+
+ return R.pipe(
+ Just,
+ R.filter(R.pipe(R.replace(/^[+-]/, ''),
+ radix === 16 ? R.replace(/^0x/i, '') : I,
+ R.split(''),
+ R.all(R.pipe(R.toUpper,
+ R.indexOf(_, charset),
+ R.gte(_, 0))))),
+ R.map(R.partialRight(parseInt, [radix])),
+ R.filter($.Integer.test)
+ )(s);
+ });
+
+ //# parseJson :: String -> Maybe Any
+ //.
+ //. Takes a string which may or may not be valid JSON, and returns Just
+ //. the result of applying `JSON.parse` to the string if valid; Nothing
+ //. otherwise.
+ //.
+ //. ```javascript
+ //. > S.parseJson('["foo","bar","baz"]')
+ //. Just(['foo', 'bar', 'baz'])
+ //.
+ //. > S.parseJson('[')
+ //. Nothing()
+ //. ```
+ S.parseJson =
+ def('parseJson',
+ {},
+ [$.String, $Maybe($.Any)],
+ encase(JSON.parse));
+
+ //. ### RegExp
+
+ //# regex :: RegexFlags -> String -> RegExp
+ //.
+ //. Takes a [RegexFlags][] and a pattern, and returns a RegExp.
+ //.
+ //. ```javascript
+ //. > S.regex('g', ':\\d+:')
+ //. /:\d+:/g
+ //. ```
+ S.regex =
+ def('regex',
+ {},
+ [$.RegexFlags, $.String, $.RegExp],
+ function(flags, source) { return new RegExp(source, flags); });
+
+ //# regexEscape :: String -> String
+ //.
+ //. Takes a string which may contain regular expression metacharacters,
+ //. and returns a string with those metacharacters escaped.
+ //.
+ //. Properties:
+ //.
+ //. - `forall s :: String. S.test(S.regex('', S.regexEscape(s)), s) = true`
+ //.
+ //. ```javascript
+ //. > S.regexEscape('-=*{XYZ}*=-')
+ //. '\\-=\\*\\{XYZ\\}\\*=\\-'
+ //. ```
+ S.regexEscape =
+ def('regexEscape',
+ {},
+ [$.String, $.String],
+ function(s) { return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&'); });
+
+ //# test :: RegExp -> String -> Boolean
+ //.
+ //. Takes a pattern and a string, and returns `true` if the pattern
+ //. matches the string; `false` otherwise.
+ //.
+ //. ```javascript
+ //. > S.test(/^a/, 'abacus')
+ //. true
+ //.
+ //. > S.test(/^a/, 'banana')
+ //. false
+ //. ```
+ S.test =
+ def('test',
+ {},
+ [$.RegExp, $.String, $.Boolean],
+ function(pattern, s) {
+ var lastIndex = pattern.lastIndex;
+ var result = pattern.test(s);
+ pattern.lastIndex = lastIndex;
+ return result;
+ });
+
+ //# match :: RegExp -> String -> Maybe [Maybe String]
+ //.
+ //. Takes a pattern and a string, and returns Just a list of matches
+ //. if the pattern matches the string; Nothing otherwise. Each match
+ //. has type `Maybe String`, where a Nothing represents an unmatched
+ //. optional capturing group.
+ //.
+ //. ```javascript
+ //. > S.match(/(good)?bye/, 'goodbye')
+ //. Just([Just('goodbye'), Just('good')])
+ //.
+ //. > S.match(/(good)?bye/, 'bye')
+ //. Just([Just('bye'), Nothing()])
+ //. ```
+ S.match =
+ def('match',
+ {},
+ [$.RegExp, $.String, $Maybe($.Array($Maybe($.String)))],
+ function(pattern, s) {
+ return R.map(R.map(toMaybe), toMaybe(s.match(pattern)));
+ });
+
+ //. ### String
+
+ //# toUpper :: String -> String
+ //.
+ //. Returns the upper-case equivalent of its argument.
+ //.
+ //. See also [`toLower`](#toLower).
+ //.
+ //. ```javascript
+ //. > S.toUpper('ABC def 123')
+ //. 'ABC DEF 123'
+ //. ```
+ S.toUpper =
+ def('toUpper',
+ {},
+ [$.String, $.String],
+ function(s) { return s.toUpperCase(); });
+
+ //# toLower :: String -> String
+ //.
+ //. Returns the lower-case equivalent of its argument.
+ //.
+ //. See also [`toUpper`](#toUpper).
+ //.
+ //. ```javascript
+ //. > S.toLower('ABC def 123')
+ //. 'abc def 123'
+ //. ```
+ S.toLower =
+ def('toLower',
+ {},
+ [$.String, $.String],
+ function(s) { return s.toLowerCase(); });
+
+ //# words :: String -> [String]
+ //.
+ //. Takes a string and returns the list of words the string contains
+ //. (words are delimited by whitespace characters).
+ //.
+ //. See also [`unwords`](#unwords).
+ //.
+ //. ```javascript
+ //. > S.words(' foo bar baz ')
+ //. ['foo', 'bar', 'baz']
+ //. ```
+ S.words =
+ def('words',
+ {},
+ [$.String, $.Array($.String)],
+ compose(R.reject(R.isEmpty), R.split(/\s+/)));
+
+ //# unwords :: [String] -> String
+ //.
+ //. Takes a list of words and returns the result of joining the words
+ //. with separating spaces.
+ //.
+ //. See also [`words`](#words).
+ //.
+ //. ```javascript
+ //. > S.unwords(['foo', 'bar', 'baz'])
+ //. 'foo bar baz'
+ //. ```
+ S.unwords =
+ def('unwords',
+ {},
+ [$.Array($.String), $.String],
+ function(xs) { return xs.join(' '); });
+
+ //# lines :: String -> [String]
+ //.
+ //. Takes a string and returns the list of lines the string contains
+ //. (lines are delimited by newlines: `'\n'` or `'\r\n'` or `'\r'`).
+ //. The resulting strings do not contain newlines.
+ //.
+ //. See also [`unlines`](#unlines).
+ //.
+ //. ```javascript
+ //. > S.lines('foo\nbar\nbaz\n')
+ //. ['foo', 'bar', 'baz']
+ //. ```
+ S.lines =
+ def('lines',
+ {},
+ [$.String, $.Array($.String)],
+ compose(R.match(/^(?=[\s\S]).*/gm), R.replace(/\r\n?/g, '\n')));
+
+ //# unlines :: [String] -> String
+ //.
+ //. Takes a list of lines and returns the result of joining the lines
+ //. after appending a terminating line feed (`'\n'`) to each.
+ //.
+ //. See also [`lines`](#lines).
+ //.
+ //. ```javascript
+ //. > S.unlines(['foo', 'bar', 'baz'])
+ //. 'foo\nbar\nbaz\n'
+ //. ```
+ S.unlines =
+ def('unlines',
+ {},
+ [$.Array($.String), $.String],
+ compose(R.join(''), R.map(R.concat(_, '\n'))));
+
+ return S;
+
+ };
+
+ // Export two versions of the Sanctuary module: one with type checking;
+ // one without.
+ var S = createSanctuary(true);
+ S.unchecked = createSanctuary(false);
+ return S;
+
+}));
+
+//. [Apply]: https://github.com/fantasyland/fantasy-land#apply
+//. [BinaryType]: https://github.com/plaid/sanctuary-def#binarytype
+//. [Extend]: https://github.com/fantasyland/fantasy-land#extend
+//. [Foldable]: https://github.com/fantasyland/fantasy-land#foldable
+//. [Functor]: https://github.com/fantasyland/fantasy-land#functor
+//. [Monad]: https://github.com/fantasyland/fantasy-land#monad
+//. [Monoid]: https://github.com/fantasyland/fantasy-land#monoid
+//. [R.equals]: http://ramdajs.com/docs/#equals
+//. [R.map]: http://ramdajs.com/docs/#map
+//. [R.type]: http://ramdajs.com/docs/#type
+//. [Ramda]: http://ramdajs.com/
+//. [RegExp]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp
+//. [RegexFlags]: https://github.com/plaid/sanctuary-def#regexflags
+//. [Semigroup]: https://github.com/fantasyland/fantasy-land#semigroup
+//. [Traversable]: https://github.com/fantasyland/fantasy-land#traversable
+//. [UnaryType]: https://github.com/plaid/sanctuary-def#unarytype
+//. [parseInt]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/parseInt
+//. [sanctuary-def]: https://github.com/plaid/sanctuary-def