wen ramda 函数 list
函数是那个分类下的取决于其输入的数据类型, 而非输出类型
const R = require("ramda")
// adjust
// 将数组中指定索引处的值替换为经函数变换的值。
R.adjust(1, R.toUpper, ["a", "b", "c", "d"]); //=> ["a", "B", "c", "d"]
R.adjust(-1, R.toUpper, ["a", "b", "c", "d"]); //=> ["a", "b", "c", "D"]
// all
// 如果列表中的所有元素都满足 predicate，则返回 true；否则，返回 false。
// 若第二个参数自身存在 all 方法，则调用自身的 all 方法。
// 若在列表位置中给出 transfomer，则用作 transducer 。
const equals3 = R.equals(3);
R.all(equals3)([3, 3, 3, 3]); //=> true
R.all(equals3)([3, 3, 1, 3]); //=> false
// any
// 只要列表中有一个元素满足 predicate，就返回 true，否则返回 false。
// 若第二个参数自身存在 any 方法，则调用其自身的 any。
// 若在列表位置中给出 transfomer，则用作 transducer 。
const lessThan0 = R.flip(R.lt)(0);
const lessThan2 = R.flip(R.lt)(2);
R.any(lessThan0)([1, 2]); //=> false
R.any(lessThan2)([1, 2]); //=> true
// aperture
// 返回一个新列表，列表中的元素为由原列表相邻元素组成的 n 元组。如果 n 大于列表的长度，则返回空列表。
// 若在列表位置中给出 transfomer，则用作 transducer 。
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]); //=> []
// append
// 在列表末尾拼接一个元素。
R.append("tests", ["write", "more"]); //=> ["write", "more", "tests"]
R.append("tests", []); //=> ["tests"]
R.append(["tests"], ["write", "more"]); //=> ["write", "more", ["tests"]]
// chain
// chain 将函数映射到列表中每个元素，并将结果连接起来。 chain 在一些库中也称为 flatMap（先 map 再 flatten ）。
// 若第二个参数存在 chain 方法，则调用其自身的 chain方法。该参数需符合 FantasyLand Chain 规范。
// 如果第二个参数是函数，chain(f, g)(x) 等价于 f(g(x), x)。
// 若在列表位置中给出 transfomer，则用作 transducer。
const duplicate = n => [n, n];
R.chain(duplicate, [1, 2, 3]); //=> [1, 1, 2, 2, 3, 3]
R.chain(R.append, R.head)([1, 2, 3]); //=> [1, 2, 3, 1]
// concat
// 连接列表或字符串。
// 注意：不同于 Array.prototype.concat, R.concat 要求两个参数类型相同。 如果将 Array 与非 Array 连接，将抛出错误。
// 若第一个参数自身存在 concat 方法，则调用自身的 concat。
// 也可以用于连接 符合 fantasy-land 半群 类型的两个实例。
R.concat("ABC", "DEF"); // "ABCDEF"
R.concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]
R.concat([], []); //=> []
// contains 已经废弃
// 只要列表中有一个元素等于指定值，则返回 true；否则返回 false。通过 R.equals 函数进行相等性判断。
// 也可以判断字符串中是否包含指定值。
R.contains(3, [1, 2, 3]); //=> true
R.contains(4, [1, 2, 3]); //=> false
R.contains({name: "Fred"}, [{name: "Fred"}]); //=> true
R.contains([42], [[42]]); //=> true
R.contains("ba", "banana"); //=>true
// drop
// 删除给定 list，string 或者 transducer/transformer（或者具有 drop 方法的对象）的前 n 个元素。
// 若第二个参数自身存在 drop 方法，则调用自身的 drop 方法。
// 若在 list 位置中给出 transfomer ，则用作 transducer 。
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"
// dropLast
// 删除 "list" 末尾的 n 个元素。
// 若在列表位置中给出 transfomer，则用作 transducer 。
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"
// dropLastWhile
// 对 list 从后向前一直删除满足 predicate 的尾部元素，直到遇到第一个 falsy 值，此时停止删除操作。
// predicate 需要作为第一个参数传入。
// 若在列表位置中给出 transfomer，则用作 transducer 。
const lteThree = x => x <= 3;
R.dropLastWhile(lteThree, [1, 2, 3, 4, 3, 2, 1]); //=> [1, 2, 3, 4]
R.dropLastWhile(x => x !== "d", "Ramda"); //=> "Ramd"
// dropRepeats
// 返回一个没有连续重复元素的 list。通过 R.equals 函数进行相等性判断。
// 若在 list 位置中给出 transfomer ，则用作 transducer 。
R.dropRepeats([1, 1, 1, 2, 3, 4, 4, 2, 2]); //=> [1, 2, 3, 4, 2]
// dropRepeatsWith
// 返回一个没有连续重复元素的 list。首个参数提供的 predicate 用于检测 list 中相邻的两个元素是否相等。一系列相等元素中的首个元素会被保留。
// 若在 list 位置中给出 transfomer ，则用作 transducer 。
const l = [1, -1, 1, 3, 4, -4, -4, -5, 5, 3, 3];
R.dropRepeatsWith(R.eqBy(Math.abs), l); //=> [1, 3, 4, -5, 3]
// dropWhile
// 对 list 从前向后删除满足 predicate 的头部元素，直到遇到第一个 falsy 值。
// predicate 需要作为第一个参数传入。
// 若第二个参数自身存在 dropWhile 方法，则调用自身的 dropWhile 方法。
// 若在 list 位置中给出 transfomer ，则用作 transducer 。
const lteTwo = x => x <= 2;
R.dropWhile(lteTwo, [1, 2, 3, 4, 3, 2, 1]); //=> [3, 4, 3, 2, 1]
R.dropWhile(x => x !== "d", "Ramda"); //=> "da"
// endsWith
// 检查列表是否以指定的子列表结尾。
// 同样的，检查字符串是否以指定的子字符串结尾。
R.endsWith("c", "abc") //=> true
R.endsWith("b", "abc") //=> false
R.endsWith(["c"], ["a", "b", "c"]) //=> true
R.endsWith(["b"], ["a", "b", "c"]) //=> false
// filter
// 使用 predicate 遍历传入的 Filterable，返回满足 predicate 的所有元素的新的 Filterable。新 Filterable 与原先的类型相同。Filterable 类型包括 plain object 或者任何带有 filter 方法的类型，如 Array 。
// 若第二个参数自身存在 filter 方法，则调用自身的 filter 方法。
// 若在 list 位置中给出 transfomer ，则用作 transducer 。
const 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}
// find
// 查找并返回 list 中首个满足 predicate 的元素；如果未找到满足条件的元素，则返回 undefined 。
// 若第二个参数自身存在 find 方法，则调用自身的 find 方法。
// 若在 list 位置中给出 transfomer ，则用作 transducer 。
const xs = [{a: 1}, {a: 2}, {a: 3}];
R.find(R.propEq("a", 2))(xs); //=> {a: 2}
R.find(R.propEq("a", 4))(xs); //=> undefined
// findIndex
// 查找并返回 list 中首个满足 predicate 的元素的索引；如果未找到满足条件的元素，则返回 -1 。
// 若在 list 位置中给出 transfomer ，则用作 transducer 。
const xs2 = [{a: 1}, {a: 2}, {a: 3}];
R.findIndex(R.propEq("a", 2))(xs2); //=> 1
R.findIndex(R.propEq("a", 4))(xs2); //=> -1
// findLast
// 查找并返回 list 中最后一个满足 predicate 的元素；如果未找到满足条件的元素，则返回 undefined 。
// 若在 list 位置中给出 transfomer ，则用作 transducer 。
const xs3 = [{a: 1, b: 0}, {a: 1, b: 1}];
R.findLast(R.propEq("a", 1))(xs3); //=> {a: 1, b: 1}
R.findLast(R.propEq("a", 4))(xs3); //=> undefined
// findLastIndex
// 查找并返回 list 中最后一个满足 predicate 的元素的索引；如果未找到满足条件的元素，则返回 -1 。
// 若在 list 位置中给出 transfomer ，则用作 transducer 。
const xs4 = [{a: 1, b: 0}, {a: 1, b: 1}];
R.findLastIndex(R.propEq("a", 1))(xs4); //=> 1
R.findLastIndex(R.propEq("a", 4))(xs4); //=> -1
// flatten
// 获取 list 的所有元素（包含所有子数组中的元素），然后由这些元素组成一个新的数组。深度优先。
R.flatten([1, 2, [3, 4], 5, [6, [7, 8, [9, [10, 11], 12]]]]);
// forEach
// 遍历 list，对 list 中的每个元素执行方法 fn。
// fn 接收单个参数： (value)。
// 注意: R.forEach 并不会跳过已删除的或者未赋值的索引（sparse arrays）
// 这一点和原生的 Array.prototype.forEach 方法不同. 获取更多相关信息,
// 请查阅: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach#Description
// 还要注意, 不同于 Array.prototype.forEach，
// Ramda 的 forEach 会将原数组返回。在某些库中，该方法也被称为 each.
// 若第二个参数自身存在 forEach 方法，则调用自身的 forEach 方法。
const printXPlusFive = x => console.log(x + 5);
R.forEach(printXPlusFive, [1, 2, 3]); //=> [1, 2, 3]
// logs 6
// logs 7
// logs 8
// fromPairs
// 由一系列 “键值对” 创建一个 object。如果某个键出现多次，选取最右侧的键值对。
R.fromPairs([["a", 1], ["b", 2], ["c", 3]]); //=> {a: 1, b: 2, c: 3}
// groupBy
// 将列表根据一定规则拆分成多组子列表，并存储在一个对象中。
// 对列表中的每个元素调用函数，根据函数返回结果进行分组。函数返回字符串作为相等性判断，返回的字符串作为存储对象的键，具有相同返回字符串的元素聚合为数组，作为该键的值。
// 若第二个参数自身存在 groupBy 方法，则调用自身的 groupBy 方法。
// 若在 list 位置中给出 transfomer ，则用作 transducer 。
const byGrade = R.groupBy(function (student) {
const score = student.score;
return score < 65 ? "F" :
score < 70 ? "D" :
score < 80 ? "C" :
score < 90 ? "B" : "A";
});
const 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}]
// }
// groupWith
// 通过给定的对比函数，将列表按顺序分割成多组子列表。
// 对比函数只比较相邻元素。
R.groupWith(R.equals, [0, 1, 1, 2, 3, 5, 8, 13, 21])
//=> [[0], [1, 1], [2], [3], [5], [8], [13], [21]]
R.groupWith((a, b) => a + 1 === b, [0, 1, 1, 2, 3, 5, 8, 13, 21])
//=> [[0, 1], [1, 2, 3], [5], [8], [13], [21]]
R.groupWith((a, b) => a % 2 === b % 2, [0, 1, 1, 2, 3, 5, 8, 13, 21])
//=> [[0], [1, 1], [2], [3, 5], [8], [13, 21]]
R.groupWith(R.eqBy(isVowel), "aestiou")
//=> ["ae", "st", "iou"]
// head
// 求列表或字符串的首个元素。在某些库中，该函数也被称作 first。
R.head(["fi", "fo", "fum"]); //=> "fi"
R.head([]); //=> undefined
R.head("abc"); //=> "a"
R.head(""); //=> ""
// includes
// 只要列表中有一个元素等于指定值，则返回 true；否则返回 false。通过 R.equals 函数进行相等性判断。
// 也可以判断字符串中是否包含指定值。
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
// indexBy
// 通过生成键的函数，将元素为对象的 list 转换为以生成的键为索引的新对象。
// 注意，如果 list 中多个对象元素生成相同的键，以最后一个对象元素作为该键的值。
// 若在 list 位置中给出 transfomer ，则用作 transducer 。
const 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"}}
// indexOf
// 返回给定元素在数组中首次出现时的索引值，如果数组中没有该元素，则返回 -1。通过 R.equals 函数进行相等性判断。
R.indexOf(3, [1, 2, 3, 4]); //=> 2
R.indexOf(10, [1, 2, 3, 4]); //=> -1
// init
// 返回 list 或 string 删除最后一个元素后的部分。
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(""); //=> ""
// insert
// 将元素插入到 list 指定索引处。注意，该函数是非破坏性的：返回处理后列表的拷贝。函数运行过程中不会破坏任何列表。
R.insert(2, "x", [1, 2, 3, 4]); //=> [1,2,"x",3,4]
// insertAll
// 将子 list 插入到 list 指定索引处。注意，该函数是非破坏性的：返回处理后列表的拷贝。函数运行过程中不会破坏任何列表。
R.insertAll(2, ["x", "y", "z"], [1, 2, 3, 4]); //=> [1,2,"x","y","z",3,4]
// intersperse
// 在列表的元素之间插入分割元素。
// 若第二个参数自身存在 intersperse 方法，则调用自身的 intersperse 方法。
R.intersperse("a", ["b", "n", "n", "s"]); //=> ["b", "a", "n", "a", "n", "a", "s"]
// into
// 使用 transducer 对 list 中的元素进行转换，然后使用基于 accumulator 的类型的迭代器函数将转换后的元素依次添加到 accumulator 上。
// accumulator 的类型可以是：array、string、object 或者 transformer 。
// 如果 accumulator 类型是 array 或 string，则迭代元素将被添加到数组或连接到字符串上；
// 如果是对象，迭代元素将会被直接合并；如果是二元素数组，迭代元素会以键值对形式进行合并。
// accumulator 也可作为 transformer 对象，
// 提供 transformer 所需要的二元 reducing iterator、step、零元 init 和 一元 result 函数。
// step 作为 reduce 过程中的迭代函数；result 将最终的 accumulator 转换为需要的返回类型（通常为 R.identity）；
// init 提供初始 accumulator。
// 在 transducer 初始化之后，使用 R.reduce 进行迭代操作。
const numbers = [1, 2, 3, 4];
const transducer = R.compose(R.map(R.add(1)), R.take(2));
R.into([], transducer, numbers); //=> [2, 3]
const intoArray = R.into([]);
intoArray(transducer, numbers); //=> [2, 3]
const R = require("ramda")
// join
// 将列表中所有元素通过 分隔符 串连为一个字符串。
const spacer = R.join(" ");
spacer(["a", 2, 3.4]); //=> "a 2 3.4"
R.join("|", [1, 2, 3]); //=> "1|2|3"
// last
// 返回列表或字符串的最后一个元素。
R.last(["fi", "fo", "fum"]); //=> "fum"
R.last([]); //=> undefined
R.last("abc"); //=> "c"
R.last(""); //=> ""
// lastIndexOf
// 返回数组中某元素最后一次出现的位置，如果数组中不包含该项则返回 -1 。通过 R.equals 函数进行相等性判断。
R.lastIndexOf(3, [-1, 3, 3, 0, 1, 2, 3, 4]); //=> 6
R.lastIndexOf(10, [1, 2, 3, 4]); //=> -1
// length
// 通过 list.length，返回数组的大小（数组中元素的数量）。
R.length([]); //=> 0
R.length([1, 2, 3]); //=> 3
// map
// 接收一个函数和一个 functor, 将该函数应用到 functor 的每个值上，返回一个具有相同形态的 functor。
// Ramda 为 Array 和 Object 提供了合适的 map 实现，因此 R.map 适用于 [1, 2, 3] 或 {x: 1, y: 2, z: 3}。
// 若第二个参数自身存在 map 方法，则调用自身的 map 方法。
// 若在列表位置中给出 transfomer，则用作 transducer 。
// 函数也是 functors，map 会将它们组合起来（相当于 R.compose）。
const 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}
// mapAccum
// mapAccum 的行为类似于 map 和 reduce 的组合；它将迭代函数作用于列表中的每个元素，
// 从左往右传递经迭代函数计算的累积值，并将最后的累积值和由所有中间的累积值组成的列表一起返回。
// 迭代函数接收两个参数，acc 和 value， 返回一个元组 [acc, value]。
const digits = ["1", "2", "3", "4"];
const appender = (a, b) => [a + b, a + b];
R.mapAccum(appender, 0, digits); //=> ["01234", ["01", "012", "0123", "01234"]]
// mapAccumRight
// mapAccumRight 的行为类似于 map 和 reduce 的组合
// ；它将迭代函数作用于列表中的每个元素，从右往左传递经迭代函数计算的累积值，
// 并将最后的累积值和由所有中间的累积值组成的列表一起返回。
// 和 mapAccum 类似，除了列表遍历顺序是从右往左的。
// 迭代函数接收两个参数，acc 和 value ，返回一个元组 [acc, value]。
const digits2 = ["1", "2", "3", "4"];
const appender2 = (a, b) => [b + a, b + a];
R.mapAccumRight(appender2, 5, digits2); //=> ["12345", ["12345", "2345", "345", "45"]]
// mergeAll
// 将对象类型列表合并为一个对象。
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}
// move
// 将列表中 from 索引处的元素移动到索引 to 处。
R.move(0, 2, ["a", "b", "c", "d", "e", "f"]); //=> ["b", "c", "a", "d", "e", "f"]
R.move(-1, 0, ["a", "b", "c", "d", "e", "f"]); //=> ["f", "a", "b", "c", "d", "e"] list rotation
// none
// 如果列表中的元素都不满足 predicate，返回 true；否则返回 false。
// 若第二个参数自身存在 none 方法，则调用自身的 none 方法。
const isEven = n => n % 2 === 0;
const isOdd = n => n % 2 === 1;
R.none(isEven, [1, 3, 5, 7, 9, 11]); //=> true
R.none(isOdd, [1, 3, 5, 7, 8, 11]); //=> false
// nth
// 返回列表或字符串的第 n 个元素。如果 n 为负数，则返回索引为 length + n 的元素。
const list = ["foo", "bar", "baz", "quux"];
R.nth(1, list); //=> "bar"
R.nth(-1, list); //=> "quux"
R.nth(-99, list); //=> undefined
R.nth(2, "abc"); //=> "c"
R.nth(3, "abc"); //=> ""
// pair
// 接收两个参数，fst 和 snd，返回数组 [fst, snd]。
console.log(R.pair("foo", "bar", "abc")); //=> ["foo", "bar"]
// partition
// 通过 predicate 将列表或 "Filterable" （可过滤的）对象分成两部分，
// 分别为满足 predicate 的元素和不满足 predicate 的元素。元素类型保持不变。
// Filterable 类型包括 plain object 或者任何带有 filter 方法的类型，如 Array 。
R.partition(R.includes("s"), ["sss", "ttt", "foo", "bars"]);
// => [ [ "sss", "bars" ], [ "ttt", "foo" ] ]
R.partition(R.includes("s"), {a: "sss", b: "ttt", foo: "bars"});
// => [ { a: "sss", foo: "bars" }, { b: "ttt" } ]
// pluck
// 从列表内的每个对象元素中取出特定名称的属性，组成一个新的列表。
// pluck 可以作用于任何 functor ，包括 Array，因为它等价于 R.map(R.prop(k), f)。
var getAges = R.pluck("age");
getAges([{name: "fred", age: 29}, {name: "wilma", age: 27}]); //=> [29, 27]
R.pluck(0, [[1, 2], [3, 4]]); //=> [1, 3]
R.pluck("val", {a: {val: 3}, b: {val: 5}}); //=> {a: 3, b: 5}
// prepend
// 在列表头部之前拼接一个元素。
R.prepend("fee", ["fi", "fo", "fum"]); //=> ["fee", "fi", "fo", "fum"]
// range
// 返回从 from 到 to 之间的所有数的升序列表。左闭右开（包含 from，不包含 to）。
R.range(1, 5); //=> [1, 2, 3, 4]
R.range(50, 53); //=> [50, 51, 52]
// 左折叠操作。
// 遍历列表，相继调用二元迭代函数（参数为累积值和从数组中取出的当前元素），将本次迭代结果作为下次迭代的累积值。返回最终累积值。
// 可以用 R.reduced 提前终止遍历操作。
// reduce 的迭代函数接收两个参数 (acc, value)，reduceRight 的迭代函数的参数顺序为 (value, acc)
// 注意：R.reduce 与原生 Array.prototype.reduce 方法不同，它不会跳过删除或未分配的索引项（稀疏矩阵）。更多关于原生 reduce 的行为，请参考：https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description
// 如果第三个参数自身有 reduce 方法，则调用自身的 reduce 方法。如果进行该步操作，则由用户自己来处理 R.reduced 短路操作，因为自身 reduce 方法的实现可能与 Ramda 中的 reduce 不同。
R.reduce(R.subtract, 0, [1, 2, 3, 4]) // => ((((0 - 1) - 2) - 3) - 4) = -10
// - -10
// / /
// - 4 -6 4
// / /
// - 3 ==> -3 3
// / /
// - 2 -1 2
// / /
// 0 1 0 1
// reduceBy
// 首先对列表中的每个元素调用函数 keyFn ，根据 keyFn 返回的字符串对列表元素进行分组。然后调用 reducer 函数 valueFn，对组内的元素进行折叠操作。
// 该函数相当于更通用的 groupBy 函数。
// 若在列表位置给出 transformer，则用做 transducer
const groupNames = (acc, {name}) => acc.concat(name)
const toGrade = ({score}) =>
score < 65 ? "F" :
score < 70 ? "D" :
score < 80 ? "C" :
score < 90 ? "B" : "A";
var students = [
{name: "Abby", score: 83},
{name: "Bart", score: 62},
{name: "Curt", score: 88},
{name: "Dora", score: 92},
];
R.reduceBy(groupNames, [], toGrade, students)
//=> {"A": ["Dora"], "B": ["Abby", "Curt"], "F": ["Bart"]}
// reduced
// 返回一个封装的值，该值代表 reduce 或 transduce 操作的最终结果。
// 返回值是一个黑盒：不保证其内部结构的稳定性。
// 注意：这个优化不适用于上面未明确列出的函数。例如，现在还不支持 reduceRight。
R.reduce(
(acc, item) => item > 3 ? R.reduced(acc) : acc.concat(item),
[],
[1, 2, 3, 4, 5]) // [1, 2, 3]
// reduceRight
// 右折叠操作。
// 遍历列表，相继调用二元迭代函数（参数为累积值和从数组中取出的当前元素），将本次迭代结果作为下次迭代的累积值。返回最终累积值。
// 类似于 reduce，除了遍历列表的顺序是从右向左的。
// reduceRight 的迭代函数接收两个参数 (value, acc)。与之对应的，reduce 的迭代函数的参数顺序为 (acc, value)
// 注意：R.reduceRight 与原生 Array.prototype.reduceRight 方法不同，它不会跳过删除或未分配的索引项（稀疏矩阵）。
// 更多关于原生 reduceRight 的行为，请参考：https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight#Description
R.reduceRight(R.subtract, 0, [1, 2, 3, 4]) // => (1 - (2 - (3 - (4 - 0)))) = -2
// - -2
// / /
// 1 - 1 3
// / /
// 2 - ==> 2 -1
// / /
// 3 - 3 4
// / /
// 4 0 4 0
// reduceWhile
// 与 reduce 类似， reduceWhile 会遍历列表，相继调用二元迭代函数，并返回最终累积值。
// reduceWhile 在每次调用迭代函数前，先使用 predicate 进行判断，
// 如果 predicate 返回 false ，则提前终止遍历操作，并返回当前累积值。
const isOdd2 = (acc, x) => x % 2 === 1;
const xs = [1, 3, 5, 60, 777, 800];
R.reduceWhile(isOdd2, R.add, 0, xs); //=> 9
const ys = [2, 4, 6]
R.reduceWhile(isOdd2, R.add, 111, ys); //=> 111
// reject
// filter 的补操作。返回结果为 R.filter 操作结果的补集。
// 若在列表位置给出 transformer，则用作 transducer。
// Filterable 类型包括 plain object 或者任何带有 filter 方法的类型，如 Array 。
const isOdd3 = (n) => n % 2 === 1;
R.reject(isOdd3, [1, 2, 3, 4]); //=> [2, 4]
R.reject(isOdd3, {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, d: 4}
// remove
// 删除列表中从 start 开始的 count 个元素。注意，该操作是非破坏性的：不改变原列表，返回处理后列表的拷贝。
R.remove(2, 3, [1, 2, 3, 4, 5, 6, 7, 8]); //=> [1,2,6,7,8]
// repeat
// 生成包含 n 个同一元素的数组。
R.repeat("hi", 5); //=> ["hi", "hi", "hi", "hi", "hi"]
const obj = {};
const repeatedObjs = R.repeat(obj, 5); //=> [{}, {}, {}, {}, {}]
repeatedObjs[0] === repeatedObjs[1]; //=> true
// reverse
// 对列表或字符串的排列顺序取反。
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(""); //=> ""
// Scan 与 reduce 类似，但会将每次迭代计算的累积值记录下来，组成一个列表返回。
const numbers = [1, 2, 3, 4];
const factorials = R.scan(R.multiply, 1, numbers); //=> [1, 1, 2, 6, 24]
// sequence
// 将一个 Applicative 的 Traversable 转换成一个 Traversable 类型的 Applicative。
// 如果第二个参数自身存在 sequence 方法，则调用自身的 sequence。
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()]
// slice
// 取出给定的列表或字符串（或带有 slice 方法的对象）中，从 fromIndex（包括）到 toIndex（不包括）的元素。
// 如果第三个参数自身存在 slice 方法，则调用自身的 slice 方法。
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"
// sort
// 使用比较函数对列表进行排序。比较函数每次接受两个参数，如果第一个值较小，则返回负数；
// 如果第一个值较大，则返回正数；如果两值相等，返回零。注意，返回的是列表的 拷贝 ，不会修改原列表。
const diff = function (a, b) {
return a - b;
};
R.sort(diff, [4, 2, 7, 5]); //=> [2, 4, 5, 7]
// splitAt
// 在指定的索引处拆分列表或者字符串。
R.splitAt(1, [1, 2, 3]); //=> [[1], [2, 3]]
R.splitAt(5, "hello world"); //=> ["hello", " world"]
R.splitAt(-1, "foobar"); //=> ["fooba", "r"]
// splitEvery
// 将列表拆分成指定长度的子列表集。
R.splitEvery(3, [1, 2, 3, 4, 5, 6, 7]); //=> [[1, 2, 3], [4, 5, 6], [7]]
R.splitEvery(3, "foobarbaz"); //=> ["foo", "bar", "baz"]
// splitWhen
// 查找列表中首个满足 predicate 的元素，在该处将列表拆分为两部分。首个满足 predicate 的元素包含在后一部分。
R.splitWhen(R.equals(2), [1, 2, 3, 1, 2, 3]); //=> [[1], [2, 3, 1, 2, 3]]
// startsWith
// 检查列表是否以给定的值开头。
R.startsWith("a", "abc") //=> true
R.startsWith("b", "abc") //=> false
R.startsWith(["a"], ["a", "b", "c"]) //=> true
R.startsWith(["b"], ["a", "b", "c"]) //=> false
// tail
// 删除列表中的首个元素（或者调用对象的 tail 方法）。
// 如果第一个参数自身存在 slice 方法，则调用自身的 slice 方法。
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(""); //=> ""
// take
// 返回列表的前 n 个元素、字符串的前n个字符或者用作 transducer/transform（或者调用对象的 take 方法）。
// 如果第二个参数自身存在 take 方法，则调用自身的 take 方法。
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"
const personnel = [
"Dave Brubeck",
"Paul Desmond",
"Eugene Wright",
"Joe Morello",
"Gerry Mulligan",
"Bob Bates",
"Joe Dodge",
"Ron Crotty"
];
const takeFive = R.take(5);
takeFive(personnel);
//=> ["Dave Brubeck", "Paul Desmond", "Eugene Wright", "Joe Morello", "Gerry Mulligan"]
// takeLast
// 返回列表的后 n 个元素。如果 n > list.length，则返回 list.length 个元素。
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"
// takeLastWhile
// 从后往前取出列表元素，直到遇到首个不满足 predicate 的元素为止。取出的元素中不包含首个不满足 predicate 的元素。
const isNotOne = x => x !== 1;
R.takeLastWhile(isNotOne, [1, 2, 3, 4]); //=> [2, 3, 4]
R.takeLastWhile(x => x !== "R", "Ramda"); //=> "amda"
// takeWhile
// 从前往后取出列表元素，直到遇到首个不满足 predicate 的元素为止。取出的元素中不包含首个不满足 predicate 的元素。
// 若第二个参数自身存在 takeWhile 方法，则调用自身的 takeWhile 方法
// 若在列表位置中给出 transfomer，则用作 transducer 。
const isNotFour = x => x !== 4;
R.takeWhile(isNotFour, [1, 2, 3, 4, 3, 2, 1]); //=> [1, 2, 3]
R.takeWhile(x => x !== "d", "Ramda"); //=> "Ram"
// times
// 执行输入的函数 n 次，返回由函数执行结果组成的数组。
// fn 为一元函数，n 次调用接收的参数为：从 0 递增到 n-1 。
R.times(R.identity, 5); //=> [0, 1, 2, 3, 4]
// 用 iterator function 初始化 transducer ，生成一个 transformed iterator function。然后顺次遍历列表，对每个列表元素先进行转换，然后与累积值进行归约，返回值作为下一轮迭代的累积值。最终返回与初始累积值类型相同的一个累积值。
// iterator function 接收两个参数： (acc, value) ，iterator function 会被封装为 transformer 来初始化 transducer 。可以直接传递 transformer 来代替 iterator function。这两种情况下，可以使用 R.reduced 提前终止迭代操作。
// transducer 函数接受一个 transformer ，返回一个新的 transformer ，并且 transducer 函数可以直接组合。
// transformer 是一个对象，其中包含二元 reducing iterator、step、零元 init 和 一元 result 函数。step 作为 reduce 过程中的迭代函数；result 将最终的累积值转换为需要的返回类型（通常为 R.identity ）；init 提供初始累积值，但通常会被 transduce 函数忽略。
// 在 transducer 初始化之后，使用 R.reduce 进行迭代操作。
const numbers3 = [1, 2, 3, 4];
const transducer = R.compose(R.map(R.add(1)), R.take(2));
R.transduce(transducer, R.flip(R.append), [], numbers3); //=> [2, 3]
const isOdd4 = (x) => x % 2 === 1;
const firstOddTransducer = R.compose(R.filter(isOdd4), R.take(1));
R.transduce(firstOddTransducer, R.flip(R.append), [], R.range(0, 100)); //=> [1]
// transpose
// 二维数组行列转置。输入 n 个长度为 x 的数组，输出 x 个长度为 n 的数组。
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]]
// traverse
// 将返回值为 Applicative 类型的函数映射到一个 Traversable 上。然后使用 sequence 将结果由 Traversable of Applicative 转换为 Applicative of Traversable。
// 若第三个参数自身存在 traverse 方法，则调用自身的 traverse 方法。
// Returns `Maybe.Nothing` if the given divisor is `0`
const safeDiv = n => d => d === 0 ? Maybe.Nothing() : Maybe.Just(n / d)
R.traverse(Maybe.of, safeDiv(10), [2, 4, 5]); //=> Maybe.Just([5, 2.5, 2])
R.traverse(Maybe.of, safeDiv(10), [2, 0, 5]); //=> Maybe.Nothing
// unfold
// 通过一个种子值（ seed ）创建一个列表。unfold 接受一个迭代函数：
// 该函数或者返回 false 停止迭代，或者返回一个长度为 2 的数组：
// 数组首个元素添加到结果列表，第二个元素作为种子值传给下一轮迭代使用。
// 迭代函数接受单个参数： (seed)。
const f = n => n > 50 ? false : [-n, n + 10];
R.unfold(f, 10); //=> [-10, -20, -30, -40, -50]
// uniq
// 列表去重操作。返回无重复元素的列表。通过 R.equals 函数进行相等性判断。
R.uniq([1, 1, 2, 1]); //=> [1, 2]
R.uniq([1, "1"]); //=> [1, "1"]
R.uniq([[42], [42]]); //=> [[42]]
// uniqBy
// 返回无重复元素的列表。元素通过给定的函数的返回值以及 R.equals 进行相同性判断。如果给定的函数返回值相同，保留第一个元素。
R.uniqBy(Math.abs, [-1, -5, 2, 10, 1, 2]); //=> [-1, -5, 2, 10]
// uniqWith
// 返回无重复元素的列表。元素通过 predicate 进行相同性判断。如果通过 predicate 判断两元素相同，保留第一个元素。
const 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"]
// unnest
// R.chain(R.identity) 的简写, 对 Chain 类型的数据消除一层嵌套.
R.unnest([1, [2], [[3]]]); //=> [1, 2, [3]]
R.unnest([[1, 2], [3, 4], [5, 6]]); //=> [1, 2, 3, 4, 5, 6]
// update
// 替换数组中指定索引处的值。
R.update(1, "_", ["a", "b", "c"]); //=> ["a", "_", "c"]
R.update(-1, "_", ["a", "b", "c"]); //=> ["a", "b", "_"]
// without
// 求第二个列表中，未包含在第一个列表中的任一元素的集合。通过 R.equals 函数进行相等性判断。
// 若在列表位置中给出 transfomer，则用作 transducer 。
R.without([1, 2], [1, 2, 1, 3, 4]); //=> [3, 4]
// xprod
//将两个列表的元素两两组合，生成一个新的元素对列表。
R.xprod([1, 2], ["a", "b"]); //=> [[1, "a"], [1, "b"], [2, "a"], [2, "b"]]
// zip
// 将两个列表对应位置的元素组合，生成一个新的元素对列表。生成的列表长度取决于较短的输入列表的长度。
// 注意，zip 等价于 zipWith(function(a, b) { return [a, b] }) 。
R.zip([1, 2, 3], ["a", "b", "c"]); //=> [[1, "a"], [2, "b"], [3, "c"]]
// zipObj
// 将两个列表对应位置的元素作为键值对组合，生成一个新的键值对的列表。生成的列表长度取决于较短的输入列表的长度。
// 注意，zipObj 等价于 pipe(zip, fromPairs) 。
R.zipObj(["a", "b", "c"], [1, 2, 3]); //=> {a: 1, b: 2, c: 3}
// zipWith
// 将两个列表对应位置的元素通过一个函数处理，生成一个新的元素的列表。生成的列表长度取决于较短的输入列表的长度。
const ff = (x, y) => {
// ...
};
R.zipWith(ff, [1, 2, 3], ["a", "b", "c"]);
//=> [ff(1, "a"), ff(2, "b"), ff(3, "c")]
