add method converge, fix arity related issue

README.md

@@ -125,7 +125,7 @@ isinstance(clone, Obj) # True
 - [ ] cond
 - [ ] construct
 - [ ] constructN
-- [ ] converge
+- [x] converge
 - [ ] count
 - [x] 0.1.2 countBy
 - [x] 0.1.2 curry
@@ -236,7 +236,7 @@ R.isEmpty(None) # False
 
 - [ ] isNil
 - [x] 0.1.2 join
-- [ ] juxt
+- [x] juxt
 - [x] 0.1.2 keys
 
 ```python
@@ -373,7 +373,7 @@ R.omit(['v1', 'v3'], obj) # {'v2': 2}
 - [ ] partial
 - [ ] partialObject
 - [ ] partialRight
-- [ ] partition
+- [x] partition
 - [x] 0.1.2 path
 - [ ] pathEq
 - [ ] pathOr

ramda/__init__.py

@@ -10,6 +10,7 @@
 from .comparator import comparator
 from .compose import compose
 from .concat import concat
+from .converge import converge
 from .countBy import countBy
 from .curry import curry
 from .curryN import curryN
@@ -40,6 +41,7 @@
 from .invoker import invoker
 from .isEmpty import isEmpty
 from .join import join
+from .juxt import juxt
 from .keys import keys
 from .last import last
 from .lastIndexOf import lastIndexOf
@@ -57,6 +59,7 @@
 from .omit import omit
 from .once import once
 from .Or import Or
+from .partition import partition
 from .path import path
 from .paths import paths
 from .pick import pick

ramda/converge.py

@@ -0,0 +1,17 @@
+from .curryN import curryN
+from .Max import Max
+from .private._curry2 import _curry2
+from .private._inspect import funcArgsLength, getArgsToUse
+from .private._map import _map
+from .reduce import reduce
+
+
+def inner_converge(after, fns):
+  def wrapper(*args):
+    return after(*_map(lambda fn: fn(*getArgsToUse(fn, args)), fns))
+  arity = reduce(Max, 0, _map(funcArgsLength, fns))
+  return curryN(arity, wrapper)
+
+
+converge = _curry2(inner_converge)
+converge.__name__ = 'converge'

ramda/curry.py

@@ -1,6 +1,6 @@
 
 from .curryN import curryN
 from .private._curry1 import _curry1
-from .private._helper import funcArgsLength
+from .private._inspect import funcArgsLength
 
 curry = _curry1(lambda fn: curryN(funcArgsLength(fn), fn))

ramda/curryN.py

@@ -1,6 +1,5 @@
 from .private._arity import _arity
-from .private._curry1 import _curry1
 from .private._curry2 import _curry2
 from .private._curryN import _curryN
 
-curryN = _curry2(lambda n, fn: _curry1(fn) if n == 1 else _arity(n, _curryN(n, [], fn)))
+curryN = _curry2(lambda n, fn: _arity(n, _curryN(n, [], fn)))

ramda/filter.py

@@ -13,6 +13,7 @@
 def inner_filter(pred, filterable):
   if _isArrayLike(filterable):
     return _filter(pred, filterable)
+
   def inner_reduce(acc, key):
     """
     There are 2 cases of filterable
@@ -33,3 +34,4 @@ def inner_reduce(acc, key):
 
 # pylint: disable=redefined-builtin
 filter = _curry2(_dispatchable(['fantasy-land/filter', 'filter'], _xfilter, inner_filter))
+filter.__name__ = 'filter'

ramda/flip.py

@@ -1,6 +1,6 @@
 from .curryN import curryN
 from .private._curry1 import _curry1
-from .private._helper import funcArgsLength
+from .private._inspect import funcArgsLength
 
 
 def inner_flip(fn):

ramda/isEmpty.py

@@ -8,3 +8,4 @@ def inner_isEmpty(x):
 
 
 isEmpty = _curry1(inner_isEmpty)
+isEmpty.__name__ = 'isEmpty'

ramda/juxt.py

@@ -0,0 +1,5 @@
+from .converge import converge
+from .private._curry1 import _curry1
+
+juxt = _curry1(lambda fns: converge(lambda *args: list(args), fns))
+juxt.__name__ = 'juxt'

ramda/map.py

@@ -5,7 +5,7 @@
 from .private._curry2 import _curry2
 from .private._dispatchable import _dispatchable
 from .private._has import _has
-from .private._helper import funcArgsLength
+from .private._inspect import funcArgsLength
 from .private._isFunction import _isFunction
 from .private._map import _map
 from .private._reduce import _reduce

ramda/once.py

@@ -1,6 +1,6 @@
 from .private._arity import _arity
 from .private._curry1 import _curry1
-from .private._helper import funcArgsLength
+from .private._inspect import funcArgsLength
 
 
 def inner_once(fn):

ramda/partition.py

@@ -0,0 +1,6 @@
+from .filter import filter
+from .juxt import juxt
+from .reject import reject
+
+partition = juxt([filter, reject])
+partition.__name__ = 'partition'

ramda/pipe.py

@@ -1,5 +1,5 @@
 from .private._arity import _arity
-from .private._helper import funcArgsLength
+from .private._inspect import funcArgsLength
 from .private._pipe import _pipe
 from .reduce import reduce
 from .tail import tail

ramda/private/_curry1.py

@@ -8,5 +8,5 @@ def _curry1(fn):
   def f1(a=__, *_):
     if _isPlaceholder(a):
       return f1
-    return fn(a, *_)
+    return fn(a)
   return f1

ramda/private/_curry2.py

@@ -7,11 +7,13 @@ def _curry2(fn):
   # pylint: disable=dangerous-default-value
   # pylint: disable=keyword-arg-before-vararg
   def f2(a=__, b=__, *_):
-    def f_b(_b): return fn(a, _b)
+    def f_b(_b):
+      return fn(a, _b)
     if _isPlaceholder(a) and _isPlaceholder(b):
       return f2
     if _isPlaceholder(a):
-      def f_a(_a): return fn(_a, b)
+      def f_a(_a):
+        return fn(_a, b)
       return _curry1(f_a)
     if _isPlaceholder(b):
       return _curry1(f_b)

ramda/private/_curryN.py

@@ -1,4 +1,5 @@
 from ._arity import _arity
+from ._inspect import getArgsToUse
 from ._isPlaceholder import _isPlaceholder
 
 
@@ -20,6 +21,6 @@ def f1(*arguments):
         left -= 1
       combinedIdx += 1
     if left <= 0:
-      return fn(*combined)
+      return fn(*getArgsToUse(fn, combined))
     return _arity(left, _curryN(n, combined, fn))
   return f1

ramda/private/_helper.py

@@ -1,15 +1,8 @@
+
 from ._has import _has
 from ._isArrayLike import _isArrayLike
 
 
-def funcArgsLength(fn):
-  """
-  Get the number of args for function fn
-  Not count *args and **kwargs
-  """
-  return fn.__code__.co_argcount
-
-
 def toNumber(a):
   """
   Convert any input a to a number type

ramda/private/_inspect.py

@@ -0,0 +1,26 @@
+
+from inspect import getfullargspec
+
+from ._isPlaceholder import _isPlaceholder
+
+
+def funcArgsLength(fn):
+  """
+  Get the number of args for function fn
+  Not count *args and **kwargs
+  """
+  return fn.__code__.co_argcount
+
+
+def getArgsToUse(fn, args):
+  """
+  Get args to use for fn
+  """
+  if getfullargspec(fn).varargs:
+    # we can not determine the number of args if varargs exists
+    return args
+  argsToUse = []
+  for i in range(funcArgsLength(fn)):
+    if not _isPlaceholder(args[i]):
+      argsToUse.append(args[i])
+  return argsToUse

ramda/reject.py

@@ -3,3 +3,4 @@
 from .private._curry2 import _curry2
 
 reject = _curry2(lambda pred, filterable: filter(_complement(pred), filterable))
+reject.__name__ = 'reject'

test/private/test__curry1.py

@@ -2,7 +2,7 @@
 
 import ramda as R
 from ramda.private._curry1 import _curry1
-from ramda.private._helper import funcArgsLength
+from ramda.private._inspect import funcArgsLength
 
 
 def f(a): return [a]
@@ -22,6 +22,9 @@ def test_supports_placeholder(self):
   def test_has_1_arity(self):
     self.assertEqual(1, funcArgsLength(g))
 
+  def test_works_even_more_args_provided(self):
+    self.assertEqual([1], g(1, 2, 3))
+
 
 if __name__ == '__main__':
   unittest.main()

test/private/test__curry2.py

@@ -2,7 +2,7 @@
 
 import ramda as R
 from ramda.private._curry2 import _curry2
-from ramda.private._helper import funcArgsLength
+from ramda.private._inspect import funcArgsLength
 
 """
 https://github.com/ramda/ramda/blob/master/test/internal/_curry2.js
@@ -33,6 +33,9 @@ def test_supports_placeholder(self):
   def test_has_2_arity(self):
     self.assertEqual(2, funcArgsLength(g))
 
+  def test_works_even_more_args_provided(self):
+    self.assertEqual([1, 2], g(1, 2, 3))
+
 
 if __name__ == '__main__':
   unittest.main()

test/private/test__curry3.py

@@ -3,15 +3,19 @@
 
 import ramda as R
 from ramda.private._curry3 import _curry3
-from ramda.private._helper import funcArgsLength
+from ramda.private._inspect import funcArgsLength
 
 """
 https://github.com/ramda/ramda/blob/master/test/internal/_curry3.js
 """
 
+
 def f(a, b, c): return [a, b, c]
+
+
 g = _curry3(f)
 
+
 class Test_Curry3(unittest.TestCase):
   def test_supports_placeholder(self):
     _ = R.__
@@ -43,6 +47,9 @@ def test_supports_placeholder(self):
   def test_has_3_arity(self):
     self.assertEqual(3, funcArgsLength(g))
 
+  def test_works_even_more_args_provided(self):
+    self.assertEqual([1, 2, 3], g(1, 2, 3, 4))
+
 
 if __name__ == '__main__':
   unittest.main()

test/test_compose.py

@@ -2,7 +2,7 @@
 import unittest
 
 import ramda as R
-from ramda.private._helper import funcArgsLength
+from ramda.private._inspect import funcArgsLength
 
 """
 https://github.com/ramda/ramda/blob/master/test/compose.js

test/test_converge.py

@@ -0,0 +1,46 @@
+
+import unittest
+
+import ramda as R
+from ramda.private._inspect import funcArgsLength
+
+"""
+https://github.com/ramda/ramda/blob/master/test/converge.js
+"""
+
+f1 = R.converge(R.multiply, [R.identity, R.identity])
+f2 = R.converge(R.multiply, [R.identity, lambda a, b: b])
+f3 = R.converge(R.multiply, [R.identity, lambda a, b, c: c])
+
+
+class TestConverge(unittest.TestCase):
+  def test_passes_the_results_of_applying_the_arguments_individually_to_two_separate_functions_into_a_single_one(self):
+    self.assertEqual(15, R.converge(R.multiply, [R.add(1), R.add(3)])(2))
+
+  def test_returns_a_function_with_the_length_of_the_longest_argument(self):
+    self.assertEqual(1, funcArgsLength(f1))
+    self.assertEqual(2, funcArgsLength(f2))
+    self.assertEqual(3, funcArgsLength(f3))
+
+  def test_returns_a_curried_function(self):
+    self.assertEqual(42, f2(6)(7))
+    self.assertEqual(3, funcArgsLength(f3(R.__)))
+
+  def test_works_with_empty_functions_list(self):
+    fn = R.converge(lambda *args: len(args), [])
+    self.assertEqual(0, funcArgsLength(fn))
+    self.assertEqual(0, fn())
+
+  def test_works_with_functions_with_different_number_of_arguments(self):
+    fn = R.converge(R.multiply, [R.add, R.add(1)])
+    self.assertEqual(6, fn(1)(2))  # curried
+    self.assertEqual(6, fn(1, 2))
+    self.assertEqual(6, fn(1)(R.__)(2))
+    self.assertEqual(9, fn(R.__, 1)(2))
+    self.assertEqual(6, fn(R.__, R.__)(1, 2))
+    self.assertEqual(6, fn(1, R.__)(2))
+    self.assertEqual(6, fn(1, 2, 3))  # works even more arguments provided
+
+
+if __name__ == '__main__':
+  unittest.main()

test/test_curry.py

@@ -113,6 +113,12 @@ def f(a, b, c, *args):
     self.assertEqual([1, 2, 3, 4], g(1)(2, 3, 4))
     self.assertEqual([1, 2, 3, 4], g(1)(2)(3, 4))
 
+  def test_works_even_more_args_provided(self):
+    def f(a, b):
+      return [a, b]
+    g = R.curry(f)
+    self.assertEqual([1, 2], g(1, 2, 3))
+
 
 if __name__ == '__main__':
   unittest.main()