集合并运算，合并两个列表为新列表（新列表中无重复元素）
R.union([1, 2, 3], [2, 3, 4]); //=> [1, 2, 3, 4]
集合并运算，合并两个列表为新列表（新列表中无重复元素）。由 predicate 的返回值决定两元素是否重复
const l1 = [{a: 1}, {a: 2}];
const l2 = [{a: 1}, {a: 4}];
R.unionWith(R.eqBy(R.prop('a')), l1, l2); //=> [{a: 1}, {a: 2}, {a: 4}]
接受一个测试规范对象和一个待检测对象，如果测试满足规范，则返回 true，否则返回 false。测试规范对象的每个属性值都必须是 predicate 。每个 predicate 作用于待检测对象对应的属性值，如果所有 predicate 都返回 true，则 where 返回 true，否则返回 false 。
where 非常适合于需要声明式表示约束的函数，比如 filter 和 find 。
const pred = R.where({
a: R.equals('foo'),
b: R.complement(R.equals('bar')),
x: R.gt(R.__, 10),
y: R.lt(R.__, 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
接受一个测试规范对象和一个待检测对象，测试规范对象的每个属性值都必须是 predicate 。 每个 predicate 作用于待检测对象对应的属性值，只要有一个 predicate 返回 true，则 whereAny 返回 true，否则返回 false 。
whereAny 非常适合于需要声明式表示约束的函数比如 filter and find。
const pred = R.whereAny({
a: R.equals('foo'),
b: R.complement(R.equals('xxx')),
x: R.gt(R.__, 10),
异或操作。
如果其中一个参数为真，另一个参数为假，则返回true ；否则返回false。
R.xor(true, true); //=> false
R.xor(true, false); //=> true
R.xor(false, true); //=> true
R.xor(false, false); //=> false
y: R.lt(R.__, 20)
});
pred({a: 'foo', b: 'xxx', x: 8, y: 34}); //=> true
pred({a: 'xxx', b: 'xxx', x: 9, y: 21}); //=> false
pred({a: 'bar', b: 'xxx', x: 10, y: 20}); //=> false
pred({a: 'foo', b: 'bar', x: 10, y: 20}); //=> true
pred({a: 'foo', b: 'xxx', x: 11, y: 20}); //=> true
接受一个测试规范对象和一个待检测对象，如果测试满足规范，则返回 true，否则返回 false。如果对于每一个测试规范对象的属性值，待检测对象中都有一个对应的相同属性值，则 where 返回 true，否则返回 false 。
whereEq 是 where 的一种特殊形式。
const 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
列表中的所有元素相乘。
R.product([2,4,6,8,100,1]); //=> 38400
对数组中所有元素求和
R.sum([2,4,6,8,100,1]); //=> 121
求对称差集。所有不属于两列表交集元素的集合，其元素在且仅在给定列表中的一个里面出现。
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]
求对称差集。所有不属于两列表交集元素的集合。交集的元素由条件函数的返回值决定
const eqA = R.eqBy(R.prop('a'));
const l1 = [{a: 1}, {a: 2}, {a: 3}, {a: 4}];
const l2 = [{a: 3}, {a: 4}, {a: 5}, {a: 6}];
R.symmetricDifferenceWith(eqA, l1, l2); //=> [{a: 1}, {a: 2}, {a: 5}, {a: 6}]
将一个对象的属性转换成键、值二元组类型的数组，只处理对象自身的属性。注意：不同 JS 运行环境输出数组的顺序可能不一致
R.toPairs({a: 1, b: 2, c: 3}); //=> [['a', 1], ['b', 2], ['c', 3]]
npm install ramda
import * as R from 'ramda'
R.and(true, true); //=> true
R.and(true, false); //=> false
R.and(false, true); //=> false
R.and(false, false); //=> false
R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests']
R.append('tests', []); //=> ['tests']
R.append(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']]
const nums = [1, 2, 3, -99, 42, 6, 7];
R.apply(Math.max, nums); //=> 42
由返回值可与 < 和 > 比较的函数，创建一个升序比较函数
const byAge = R.ascend(R.prop('age'));
const people = [
{ name: 'Emma', age: 70 },
{ name: 'Peter', age: 78 },
{ name: 'Mikhail', age: 62 },
];
const peopleByYoungestFirst = R.sort(byAge, people);
//=> [{ name: 'Mikhail', age: 62 },{ name: 'Emma', age: 70 }, { name: 'Peter', age: 78 }]
由首个参数是否小于第二个参数的判断函数，生成一个比较函数
const byAge = R.comparator((a, b) => a.age < b.age);
const people = [
{ name: 'Emma', age: 70 },
{ name: 'Peter', age: 78 },
{ name: 'Mikhail', age: 62 },
];
const peopleByIncreasingAge = R.sort(byAge, people);
//=> [{ name: 'Mikhail', age: 62 },{ name: 'Emma', age: 70 }, { name: 'Peter', age: 78 }]
R.concat('ABC', 'DEF'); // 'ABCDEF'
R.concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]
R.concat([], []); //=> []
由返回值可与 < 和 > 比较的函数，创建一个降序比较函数。
const byAge = R.descend(R.prop('age'));
const people = [
{ name: 'Emma', age: 70 },
{ name: 'Peter', age: 78 },
{ name: 'Mikhail', age: 62 },
];
const peopleByOldestFirst = R.sort(byAge, people);
//=> [{ name: 'Peter', age: 78 }, { name: 'Emma', age: 70 }, { name: 'Mikhail', age: 62 }]
求差集。求第一个列表中，未包含在第二个列表中的任一元素的集合。对象和数组比较数值相等，而非引用相等。
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]
R.difference([{a: 1}, {b: 2}], [{a: 1}, {c: 3}]) //=> [{b: 2}]
删除对象中指定 prop 属性。
R.dissoc('b', {a: 1, b: 2, c: 3}); //=> {a: 1, c: 3}
两数相除。等价于 a / b
R.divide(71, 100); //=> 0.71
const half = R.divide(R.__, 2);
half(42); //=> 21
const reciprocal = R.divide(1);
reciprocal(4); //=> 0.25
R.includes(3, [1, 2, 3]); //=> true
R.includes(4, [1, 2, 3]); //=> false
R.includes({ name: 'Fred' }, [{ name: 'Fred' }]); //=> true
R.includes([42], [[42]]); //=> true
R.includes('ba', 'banana'); //=>true
R.indexOf(3, [1,2,3,4]); //=> 2
R.indexOf(10, [1,2,3,4]); //=> -1
R.innerJoin(
(record, id) => record.id === id,
[{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'}],
[177, 456, 999]
);
//=> [{id: 456, name: 'Stephen Stills'}, {id: 177, name: 'Neil Young'}]
