Higher order functions

`reduce`(fn, iterable[, initial])	Similar to python's reduce, but can be prematurely terminated with `reduced`.
`reduced`(x)	Use with `functionali.reduce` to prematurely terminate `reduce` with the value of `x`.
`flip`(fn)	returns a function that takes in a flipped order of args.
`foldr`(fn, iterable[, initial])	Fold right.
`curry`(fn)	Returns a curried version of the function.
`threadf`(arg, forms)	Thread first, passes `arg` as the first argument to the first function in `forms` and passes the result as the first argument to the second form and so on.
`threadl`(arg, forms)	Thread last, passes `arg` as the last argument to the first function in `forms` and passes the result as the last argument to the second form and so on.
`trampoline`(fn, *args)	takes a function `fn` and calls if with `*args`.
`comp`(*fns)	returns a composed function that takes a variable number of args, and applies it to `fns` passed from right to left.

functionali.reduce(fn, iterable, initial=None)

Similar to python’s reduce, but can be prematurely terminated with reduced. Works with dictionaries too.

Usage:

>>> # Reducing over dictionaries.
>>> def inc_value(result, kv_pair):
        k = kv_pair[0]
        v = kv_pair[1]
        return result[k]= v+1
>>> reduce(inc_value, {"a":1,"b":2}, {})
{'a': 2, 'b': 3}

>>> #premature termination with reduced
>>> def inc_while_odd(result, element):
        if element%2==0:
            return reduced(result)
        else:
            result.append(element+1)
            return result
>>> reduce(inc_while_odd, [1,3,5,6,7,8],[])
[2, 4, 6]
# increments uptil 5 (third element) and prematurely terminates.

functionali.reduced(x)

Use with functionali.reduce to prematurely terminate reduce with the value of x.

Usage:

>>> reduce(lambda acc, el: reduced("!"), [1,3,4])
"!"
# reduce is prematurely terminated and returns a value of "!"

functionali.flip(fn: Callable) → Callable

returns a function that takes in a flipped order of args. Usage:

>>> f = lambda a,b : a-b
>>> f(1,3)
-2
>>> f(3,1)
2
>>> flipped_f = flip(f)
>>> flipped_f(3,1)
-2
>>> flipped_f(1,3)
2

Added in version: 0.1.0

functionali.foldr(fn: Callable, iterable: Iterable, initial: Optional[Any] = None) → Any

Fold right. Stack safe implementation

Added in version: 0.1.0

functionali.curry(fn: Callable) → Callable

Returns a curried version of the function.

>>> def fn(arg1, arg2, arg3):  # test function
    return [arg1, arg2, arg3]
>>> curried_fn = curry(fn)
>>> curried_fn(1)(2)(3)
    [1, 2, 3]

Added in version: 0.1.0

functionali.threadf(arg: Any, forms: Iterable[Union[Callable, Iterable]]) → Any

Thread first, passes arg as the first argument to the first function in forms and passes the result as the first argument to the second form and so on.

see also threadf.

>>> from functionali import identity
>>> from operator import add, sub, mul
>>> threadl(5, [identity])
>>> 5

>>> threadl(5, [identity, [add, 2]])
>>> 7

>>> threadl(5, [[sub, 2]])
>>> -3 # threadl(5, [[sub, 2]]) -> sub(2, 5) -> 2-5 -> -3

>>> # combining multiple functions
>>> threadl(5, [identity, (add, 1), (sub, 1), (mul, 3)])
-15

functionali.trampoline(fn: Callable, *args: Any)

takes a function fn and calls if with *args. if fn returns a function, calls the function until a function is not returned i.e. the base case is reached. function fn must return a function in its recursive case. Useful for optimizing tail recursive functions or mutual recursions.

>>> def fact(x, curr=1, acc=1):
>>>    if curr == x:
>>>        return curr*acc
>>>    else:
>>>        return lambda: fact(x, curr+1, acc*curr)
>>> trampoline(fact, 3) == 6
>>> trampoline(fact, 100000000000) # does not raise RecursionError

functionali.comp(*fns: Callable)

returns a composed function that takes a variable number of args, and applies it to fns passed from right to left.

Added in version: 0.1.2