R.__ (占位符): 用于在柯里化函数中表示“间隙”，允许部分应用任何组合的参数。
R.add (加法): 接受两个数值，返回它们的和。
R.addIndex (添加索引): 接受一个列表迭代函数，返回一个新的函数，该函数在迭代时会传递当前索引和整个列表给回调函数。
R.addIndexRight (添加索引-右): 与
addIndex类似，但迭代方向是从右到左。R.adjust (调整列表): 接受一个索引和一个函数，以及一个数组，返回一个新数组，其中指定索引的元素被函数处理后的值替换。
R.all (全部满足): 接受一个谓词函数和一个数组，如果数组中的所有元素都满足谓词函数，则返回
true。R.allPass (全部通过): 接受一个谓词数组，返回一个新的谓词，只有当所有谓词都满足时才返回
true。R.always (始终返回): 接受一个值，返回一个函数，该函数总是返回这个值。
R.and (逻辑与): 如果第一个参数是 falsy 值，则返回第二个参数，否则返回第一个参数。
R.andThen (然后): 接受一个函数和一个成功解决的承诺，返回一个新承诺，该承诺的结果是通过
onSuccess函数应用内部值得到的结果。R.any (任意满足): 接受一个谓词函数和一个数组，如果数组中至少有一个元素满足谓词函数，则返回
true。R.anyPass (任意通过): 接受一个谓词数组，返回一个新的谓词，只要至少有一个谓词满足就返回
true。R.ap (应用函数列表): 接受一个函数列表和一个值列表，将函数应用于值。
R.aperture (孔径): 接受一个数字和一个列表，返回一个新的列表，由原列表中的连续元素组成的 n 元组。
R.append (追加): 接受一个元素和一个列表，返回一个新列表，其中包含原列表的元素后跟给定的元素。
R.apply (应用): 接受一个函数和一个参数列表，返回函数应用这些参数后的结果。
R.applySpec (应用规范): 接受一个规范对象，创建一个函数，该函数返回与规范相同结构的对象。
R.applyTo (应用到): 接受一个值和一个函数，返回应用该函数到值后的结果。
R.ascend (升序): 接受一个返回可比较值的函数，返回一个新的比较器函数。
R.ascendNatural (自然升序): 与
ascend类似，但使用自然排序。R.assoc (关联对象): 创建一个新对象，设置或覆盖指定属性。
R.assocPath (关联路径): 创建一个新对象，设置或覆盖指定路径上的值。
R.binary (二元函数): 接受一个函数，返回一个新的函数，该函数只接受两个参数。
R.bind (绑定): 接受一个函数和一个上下文对象，返回一个新的函数。
R.both (两者都): 接受两个谓词，返回一个新的谓词，只有当两个谓词都满足时才返回
true。R.call (调用): 接受一个函数和一系列参数，返回调用该函数后的结果。
R.chain (链式操作): 接受一个函数和一个列表，返回一个新列表，其中包含通过函数映射原始列表后的结果。
R.clamp (限制范围): 接受最小值、最大值和一个值，返回限制在指定范围内的值。
R.clone (克隆): 创建一个对象或数组的深拷贝。
R.collectBy (收集): 接受一个函数和一个列表，返回一个数组，其中包含根据函数返回值分组的子数组。
R.comparator (比较器): 接受一个谓词函数，返回一个新的比较器函数。
R.complement (补充): 接受一个函数，返回一个新的函数，当原函数返回 falsy 值时返回
true。R.compose (组合函数): 接受多个函数作为参数，返回一个新的函数，它是这些函数的组合。
R.composeWith (组合函数): 接受一个转换函数和一系列函数，返回一个新的函数。
R.concat (连接): 接受两个列表或字符串，返回连接后的新列表或字符串。
R.cond (条件): 接受一个谓词和转换器对的数组，返回一个新的函数。
R.construct (构造函数): 接受一个构造函数，返回一个新的柯里化函数。
R.constructN (构造函数N): 接受一个数字和一个构造函数，返回一个新的柯里化函数。
R.converge (汇聚): 接受一个汇聚函数和一系列分支函数，返回一个新的函数。
R.count (计数): 接受一个谓词函数和一个列表，返回满足谓词函数的元素数量。
R.countBy (计数): 接受一个函数和一个列表，返回一个对象，映射键到列表中匹配元素的数量。
R.curry (柯里化): 接受一个函数，返回一个新的柯里化函数。
R.curryN (柯里化N): 接受一个数字和一个函数，返回一个新的柯里化函数。
R.dec (递减): 接受一个数字，返回减一后的值。
R.defaultTo (默认): 接受一个默认值和一个值，返回非
null、undefined或NaN的值。R.descend (降序): 与
ascend类似，但返回相反的顺序。R.descendNatural (自然降序): 与
descend类似，但使用自然排序。R.difference (差集): 接受两个列表，返回第一个列表中不在第二个列表中的元素。
R.differenceWith (差集): 接受一个谓词函数和两个列表，返回第一个列表中不在第二个列表中的元素。
R.differenceWith (差集): 接受一个谓词函数和两个列表，返回第一个列表中不在第二个列表中的元素。
R.dissoc (解构对象): 接受一个属性名和一个对象，返回一个新的对象，省略了指定的属性。
R.dissocPath (解构路径): 接受一个路径和一个对象，返回一个新的对象，省略了指定路径上的属性。
R.divide (除法): 接受两个数字，返回它们的商。
R.drop (删除): 接受一个数字和一个列表或字符串，返回删除前
n个元素后的新列表或字符串。R.dropLast (删除尾部): 接受一个数字和一个列表，返回删除最后
n个元素后的新列表。R.dropLastWhile (删除尾部满足条件的元素): 接受一个谓词函数和一个列表，返回删除尾部满足谓词函数的元素后的新列表。
R.dropRepeats (删除重复): 接受一个列表，返回一个新列表，其中删除了所有连续重复的元素。
R.dropRepeatsWith (删除重复): 接受一个谓词函数和一个列表，返回一个新列表，其中删除了所有连续满足谓词函数的元素。
R.dropRepeatsWith (删除重复): 接受一个谓词函数和一个列表，返回一个新列表，其中删除了所有连续满足谓词函数的元素。
R.dropWhile (删除满足条件的元素): 接受一个谓词函数和一个列表，返回删除头部满足谓词函数的元素后的新列表。
R.either (逻辑或): 接受两个谓词，返回一个新的谓词，只要至少有一个谓词满足就返回
true。R.empty (空): 接受一个值，返回其类型的空值。
R.endsWith (以...结尾): 接受一个子列表或字符串和一个列表或字符串，返回一个布尔值，指示是否以子列表或字符串结尾。
R.eqBy (通过函数比较相等): 接受一个函数和两个值，返回这两个值在函数的返回值上是否相等。
R.eqProps (属性相等): 接受一个属性名和两个对象，返回一个布尔值，指示两个对象在指定属性上是否相等。
R.equals (相等): 接受两个值，返回它们是否相等。
R.evolve (演变): 接受一个转换对象和一个对象，返回一个新的对象，其中每个属性都通过转换函数进行了演变。
R.F (永远返回 false): 接受任意参数，总是返回
false。R.filter (过滤): 接受一个谓词函数和一个可过滤对象，返回一个新的可过滤对象，只包含满足谓词函数的元素。
R.find (查找): 接受一个谓词函数和一个列表，返回第一个满足谓词函数的元素。
R.findIndex (查找索引): 接受一个谓词函数和一个列表，返回第一个满足谓词函数的元素的索引。
R.findLast (查找最后一个): 接受一个谓词函数和一个列表，返回最后一个满足谓词函数的元素。
R.findLastIndex (查找最后一个索引): 接受一个谓词函数和一个列表，返回最后一个满足谓词函数的元素的索引。
R.flatten (展平): 接受一个列表，返回一个新列表，其中包含所有子列表的元素。
R.flip (翻转参数): 接受一个函数，返回一个新的函数，其前两个参数的位置被交换。
R.flow (流程): 接受一个初始值和一系列函数，返回应用这些函数后的结果。
R.forEach (遍历): 接受一个函数和一个列表，对列表中的每个元素调用该函数。
R.forEachObjIndexed (遍历对象索引): 接受一个函数和一个对象，对对象中的每个键值对调用该函数。
R.fromPairs (从键值对创建对象): 接受一个键值对数组，返回一个对象。
R.groupBy (分组): 接受一个函数和一个列表，返回一个对象，其中包含根据函数返回值分组的子列表。
R.groupWith (分组): 接受一个谓词函数和一个列表，返回一个新列表，其中包含根据谓词函数分组的子列表。
R.gt (大于): 接受两个值，返回第一个值是否大于第二个值。
R.gte (大于等于): 接受两个值，返回第一个值是否大于或等于第二个值。
R.has (检查属性): 接受一个属性名和一个对象，返回一个布尔值，指示对象是否具有指定的属性。
R.hasIn (检查属性): 接受一个属性名和一个对象，返回一个布尔值，指示对象或其原型链是否具有指定的属性。
R.hasPath (检查路径): 接受一个路径和一个对象，返回一个布尔值，指示对象是否具有指定路径的属性。
R.head (头部): 接受一个列表或字符串，返回第一个元素。
R.identical (完全相同): 接受两个值，返回它们是否完全相同。
R.identity (恒等): 接受一个值，返回该值。
R.ifElse (条件语句): 接受一个条件函数、一个真值函数和一个假值函数，返回一个新的函数。
R.inc (递增): 接受一个数字，返回加一后的值。
R.includes (包含): 接受一个值和一个列表，返回一个布尔值，指示列表是否包含该值。
R.indexBy (索引): 接受一个函数和一个数组，返回一个对象，其中包含根据函数返回值索引的元素。
R.indexOf (索引): 接受一个值和一个列表，返回该值在列表中的第一个索引。
R.init (初始化): 接受一个列表或字符串，返回除最后一个元素之外的所有元素。
R.innerJoin (内连接): 接受一个谓词函数和两个列表，返回一个新列表，包含满足谓词函数的元素。
R.insert (插入): 接受一个索引、一个元素和一个列表，返回一个新列表，其中元素被插入到指定索引。
R.insertAll (插入所有): 接受一个索引、一个子列表和一个列表，返回一个新列表，其中子列表被插入到指定索引。
R.intersection (交集): 接受两个列表，返回两个列表的公共元素。
R.intersperse (交错): 接受一个分隔符和一个列表，返回一个新列表，其中分隔符被交错插入。
R.into (转换): 接受一个初始值、一个转换器函数和一个列表，返回应用转换器后的累积值。
R.invert (反转): 接受一个对象或数组，返回一个新的对象，其键值对被反转。
R.invertObj (反转对象): 接受一个对象或数组，返回一个新的对象，其键值对被反转。
R.invoker (调用器): 接受一个数字和一个方法名，返回一个新的柯里化函数。
R.is (类型检查): 接受一个构造函数和一个值，返回值是否是该构造函数的实例。
R.isEmpty (为空): 接受一个值，返回它是否是其类型的空值。
R.isNil (为空): 接受一个值，返回它是否是
null或undefined。R.join (连接): 接受一个分隔符和一个列表，返回一个由分隔符连接的字符串。
R.juxt (并置): 接受一个函数数组，返回一个新的函数。
R.keys (键): 接受一个对象，返回一个包含对象所有自有属性键的数组。
R.keysIn (键): 接受一个对象，返回一个包含对象所有属性键的数组。
R.last (最后一个): 接受一个列表或字符串，返回最后一个元素。
R.lastIndexOf (最后一个索引): 接受一个值和一个列表，返回该值在列表中的最后一个索引。
R.length (长度): 接受一个列表，返回其长度。
R.lens (透镜): 接受一个 getter 函数和一个 setter 函数，返回一个新的透镜。
R.lensIndex (透镜索引): 接受一个索引，返回一个新的透镜。
R.lensPath (透镜路径): 接受一个路径，返回一个新的透镜。
R.lensProp (透镜属性): 接受一个属性名，返回一个新的透镜。
R.lift (提升): 接受一个函数，返回一个新的函数。
R.liftN (提升N): 接受一个数字和一个函数，返回一个新的函数。
R.lt (小于): 接受两个值，返回第一个值是否小于第二个值。
R.lte (小于等于): 接受两个值，返回第一个值是否小于或等于第二个值。
R.map (映射): 接受一个函数和一个可映射对象，返回一个新的可映射对象，其中每个元素都应用了给定函数。
R.mapAccum (映射累积): 接受一个函数、一个初始值和一个列表，返回累积值和新列表。
R.mapAccumRight (映射累积右): 接受一个函数、一个初始值和一个列表，返回累积值和新列表。
R.mapObjIndexed (映射对象索引): 接受一个函数和一个对象，返回一个新的对象，其中每个键值对都应用了给定函数。
R.match (匹配): 接受一个正则表达式和一个字符串，返回匹配的数组。
R.mathMod (数学模): 接受两个数字，返回除法的余数。
R.max (最大值): 接受两个值，返回较大的值。
R.maxBy (最大值): 接受一个函数和两个值，返回根据函数返回值较大的值。
R.mean (均值): 接受一个数字数组，返回均值。
R.median (中位数): 接受一个数字数组，返回中位数。
R.memoizeWith (记忆化): 接受一个键生成函数和一个函数，返回一个新的记忆化函数。
R.mergeAll (合并所有): 接受一个对象数组，返回一个合并了所有对象的新对象。
R.mergeDeepLeft (深度合并左): 接受两个对象，返回一个深度合并的新对象。
R.mergeDeepRight (深度合并右): 接受两个对象，返回一个深度合并的新对象。
R.mergeDeepWith (深度合并): 接受一个函数和两个对象，返回一个深度合并的新对象。
R.mergeDeepWithKey (深度合并键): 接受一个函数和两个对象，返回一个深度合并的新对象。
R.mergeLeft (合并左): 接受两个对象，返回一个合并的新对象。
R.mergeRight (合并右): 接受两个对象，返回一个合并的新对象。
R.mergeWith (合并): 接受一个函数和两个对象，返回一个合并的新对象。
R.mergeWithKey (合并键): 接受一个函数和两个对象，返回一个合并的新对象。
R.min (最小值): 接受两个值，返回较小的值。
R.minBy (最小值): 接受一个函数和两个值，返回根据函数返回值较小的值。
R.modify (修改): 接受一个属性名、一个函数和一个对象，返回一个新的对象。
R.modifyPath (修改路径): 接受一个路径、一个函数和一个对象，返回一个新的对象。
R.modulo (模): 接受两个数字，返回除法的余数。
R.multiply (乘法): 接受两个数字，返回它们的乘积。
R.nAry (N元函数): 接受一个数字和一个函数，返回一个新的函数。
R.negate (取反): 接受一个数字，返回其相反数。
R.none (无一满足): 接受一个谓词函数和一个列表，返回一个布尔值。
R.not (逻辑非): 接受一个值，返回其逻辑非值。
R.nth (第N个): 接受一个索引和一个列表或字符串，返回索引处的元素。
R.nthArg (第N个参数): 接受一个索引和一系列参数，返回索引处的参数。
R.o (组合): 接受两个函数，返回一个新的函数。
R.objOf (对象): 接受一个属性名和一个值，返回一个新的对象。
R.of (函数): 接受一个构造函数和一个值，返回一个新的实例。
R.omit (省略): 接受一个属性名数组和一个对象，返回一个新的对象。
R.on (函数): 接受一个二元函数、一个一元函数和一个值，返回一个新的函数。
R.once (一次): 接受一个函数，返回一个新的函数。
R.or (逻辑或): 接受两个值，返回第一个真值。
Rotherwise (否则): 接受一个函数和一个失败的承诺，返回一个新承诺。
R.over (覆盖): 接受一个透镜、一个函数和一个对象，返回一个新的对象。
R.pair (对): 接受两个值，返回一个数组。
R.partial (部分应用): 接受一个函数和一系列参数，返回一个新的函数。
R.partialObject (部分应用对象): 接受一个函数和一个对象，返回一个新的函数。
R.partition (分区): 接受一个谓词函数和一个可过滤对象，返回两个新对象。
R.path (路径): 接受一个路径和一个对象，返回路径处的值。
R.pathEq (路径相等): 接受一个值、一个路径和一个对象，返回路径处的值是否等于给定值。
R.pathOr (路径或): 接受一个默认值、一个路径和一个对象，返回路径处的值或默认值。
R.paths (路径): 接受一个路径数组和一个对象，返回一个包含路径处值的数组。
R.pathSatisfies (路径满足): 接受一个谓词函数、一个路径和一个对象，返回路径处的值是否满足谓词函数。
R.pick (选择): 接受一个属性名数组和一个对象，返回一个新的对象。
R.pickAll (选择所有): 接受一个属性名数组和一个对象，返回一个新的对象。
R.pickBy (选择满足条件的): 接受一个谓词函数和一个对象，返回一个新的对象。
R.pipe (管道): 接受一系列函数，返回一个新的函数。
R.pipeWith (管道): 接受一个转换函数和一系列函数，返回一个新的函数。
R.pluck (选取): 接受一个属性名和一个可过滤对象，返回一个新的可过滤对象。
R.prepend (前置): 接受一个元素和一个列表，返回一个新的列表。
R.product (乘积): 接受一个数字数组，返回所有数字的乘积。
R.project (投影): 接受一个属性名数组和一个对象数组，返回一个新的对象数组。
R.promap (提升映射): 接受两个函数和一个 profunctor，返回一个新的 profunctor。
R.prop (属性): 接受一个属性名和一个对象，返回对象上该属性的值。
R.propEq (属性相等): 接受一个值、一个属性名和一个对象，返回对象上该属性的值是否等于给定值。
R.propIs (属性是): 接受一个类型、一个属性名和一个对象，返回对象上该属性的值是否是给定类型。
R.propOr (属性或): 接受一个默认值、一个属性名和一个对象，返回对象上该属性的值或默认值。
R.props (属性): 接受一个属性名数组和一个对象，返回一个包含属性值的数组。
R.propSatisfies (属性满足): 接受一个谓词函数、一个属性名和一个对象，返回对象上该属性的值是否满足谓词函数。
R.range (范围): 接受两个数字，返回一个包含从第一个数字到第二个数字（不包括）的新数组。
R.reduce (归约): 接受一个归约函数、一个初始值和一个列表，返回归约后的结果。
R.reduceBy (归约): 接受一个归约函数、一个初始值、一个键函数和一个列表，返回一个根据键函数分组归约后的对象。
R.reduced (已归约): 接受一个值，返回一个表示已归约的值。
R.reduceRight (归约右): 接受一个归约函数、一个初始值和一个列表，返回归约后的结果。
R.reduceWhile (归约条件): 接受一个谓词函数、一个归约函数、一个初始值和一个列表，返回归约后的结果。
R.reject (拒绝): 接受一个谓词函数和一个可过滤对象，返回一个新的可过滤对象。
R.remove (移除): 接受一个开始索引、一个数量和一个列表，返回一个新列表。
R.repeat (重复): 接受一个值和一个数量，返回一个包含重复值的新数组。
R.replace (替换): 接受一个正则表达式或字符串、一个替换字符串和一个字符串，返回替换后的新字符串。
R.reverse (反转): 接受一个列表或字符串，返回反转后的新列表或字符串。
R.scan (扫描): 接受一个归约函数、一个初始值和一个列表，返回一个包含所有中间归约值的数组。
R.sequence (序列): 接受一个构造函数和一个可过滤对象，返回一个新的构造函数。
R.set (设置): 接受一个透镜、一个值和一个对象，返回一个新的对象。
R.slice (切片): 接受一个开始索引、一个结束索引和一个列表或字符串，返回切片后的新列表或字符串。
R.sort (排序): 接受一个比较函数和一个列表，返回排序后的新列表。
R.sortBy (排序): 接受一个函数和一个列表，返回排序后的新列表。
R.sortWith (排序): 接受一个比较函数数组和一个列表，返回排序后的新列表。
R.split (分割): 接受一个正则表达式或字符串和一个字符串，返回分割后的数组。
R.splitAt (分割): 接受一个索引和一个列表或字符串，返回分割后的两部分。
R.splitEvery (分割): 接受一个数量和一个列表，返回分割后的新列表。
R.splitWhen (分割): 接受一个谓词函数和一个列表，返回分割后的两部分。
R.splitWhenever (分割): 接受一个谓词函数和一个列表，返回分割后的新列表。
R.startsWith (开始): 接受一个子列表或字符串和一个列表或字符串，返回一个布尔值，指示是否以子列表或字符串开始。
R.subtract (减法): 接受两个数字，返回它们的差。
R.sum (求和): 接受一个数字数组，返回所有数字的和。
R.swap (交换): 接受两个索引和一个列表或对象，返回一个新的列表或对象。
R.symmetricDifference (对称差集): 接受两个列表，返回两个列表的对称差集。
R.symmetricDifferenceWith (对称差集): 接受一个谓词函数和两个列表，返回两个列表的对称差集。
R.T (永远返回 true): 接受任意参数，总是返回
true。R.tail (尾部): 接受一个列表或字符串，返回除第一个元素之外的所有元素。
R.take (取): 接受一个数量和一个列表或字符串，返回前
n个元素的新列表或字符串。R.takeLast (取最后): 接受一个数量和一个列表，返回最后
n个元素的新列表。R.takeLastWhile (取最后满足条件的元素): 接受一个谓词函数和一个列表，返回最后满足谓词函数的元素的新列表。
R.takeWhile (取满足条件的元素): 接受一个谓词函数和一个列表，返回满足谓词函数的元素的新列表。
R.tap (轻拍): 接受一个函数和一个值，调用函数并返回值。
R.test (测试): 接受一个正则表达式和一个字符串，返回一个布尔值，指示字符串是否匹配正则表达式。
R.thunkify (函数化): 接受一个函数，返回一个新的函数。
R.times (次数): 接受一个函数和一个数量，返回一个包含函数调用结果的数组。
R.toLower (转小写): 接受一个字符串，返回小写字符串。
R.toPairs (转键值对): 接受一个对象，返回一个包含键值对的数组。
R.toPairsIn (转键值对): 接受一个对象，返回一个包含键值对的数组。
R.toString (转字符串): 接受一个值，返回其字符串表示。
R.toUpper (转大写): 接受一个字符串，返回大写字符串。
R.transduce (归约): 接受一个转换器函数、一个归约函数、一个初始值和一个列表，返回归约后的结果。
R.transpose (转置): 接受一个二维列表，返回一个转置后的二维列表。
R.traverse (遍历): 接受一个构造函数、一个函数和一个可遍历对象，返回一个新的构造函数。
R.trim (修剪): 接受一个字符串，返回修剪后的字符串。
R.tryCatch (尝试捕获): 接受一个尝试函数和一个捕获函数，返回一个新的函数。
R.type (类型): 接受一个值，返回其类型的字符串表示。
R.unapply (应用): 接受一个函数，返回一个新的函数。
R.unary (一元函数): 接受一个函数，返回一个新的一元函数。
R.uncurryN (取消柯里化N): 接受一个数字和一个函数，返回一个新的函数。
R.unfold (展开): 接受一个函数和一个种子值，返回一个展开后的列表。
R.union (并集): 接受两个列表，返回两个列表的并集。
R.unionWith (并集): 接受一个谓词函数和两个列表，返回两个列表的并集。
R.uniq (唯一): 接受一个列表，返回一个新列表，其中包含唯一的元素。
R.uniqBy (唯一): 接受一个函数和一个列表，返回一个新列表，其中包含唯一的元素。
R.uniqWith (唯一): 接受一个谓词函数和一个列表，返回一个新列表，其中包含唯一的元素。
R.unless (除非): 接受一个谓词函数、一个函数和一个值，返回一个新的函数。
R.unnest (解包): 接受一个嵌套列表，返回一个解包后的列表。
R.until (直到): 接受一个谓词函数、一个函数和一个初始值，返回一个新的函数。
R.unwind (展开): 接受一个属性名和一个对象，返回一个展开后的对象列表。
R.update (更新): 接受一个索引、一个值和一个列表，返回一个新列表。
R.useWith (使用): 接受一个汇聚函数和一系列函数，返回一个新的函数。
R.values (值): 接受一个对象，返回一个包含对象所有自有属性值的数组。
R.valuesIn (值): 接受一个对象，返回一个包含对象所有属性值的数组。
R.view (视图): 接受一个透镜和一个对象，返回透镜聚焦的值。
R.when (当): 接受一个谓词函数、一个函数和一个值，返回一个新的函数。
R.where (条件): 接受一个规范对象和一个测试对象，返回一个布尔值。
R.whereAny (条件): 接受一个规范对象和一个测试对象，返回一个布尔值。
R.whereEq (条件相等): 接受一个规范对象和一个测试对象，返回一个布尔值。
R.without (无): 接受两个列表，返回一个新列表，其中删除了第一个列表中的元素。
R.xor (异或): 接受两个值，返回一个布尔值，指示它们是否不同。
R.xprod (交叉乘积): 接受两个列表，返回一个新列表，其中包含所有可能的元素对。
R.zip (合并): 接受两个列表，返回一个新列表，其中包含元素对。
R.zipObj (合并对象): 接受两个列表，返回一个新对象。
R.zipWith (合并): 接受一个函数和两个列表，返回一个新列表。