Python 3.2 documentation refers to Collin Winter's functional
module which contains function compose
:
The compose() function implements function composition. In other words, it returns a wrapper around the outer and inner callables, such that the return value from inner is fed directly to outer.
Unfortunately, this module hasn't been updated since July 2006; I wonder if there's any replacement available.
For now, I only need compose
function. Is the following original functional.compose
definition still good for Python 3?
def compose(func_1, func_2, unpack=False):
"""
compose(func_1, func_2, unpack=False) -> function
The function returned by compose is a composition of func_1 and func_2.
That is, compose(func_1, func_2)(5) == func_1(func_2(5))
"""
if not callable(func_1):
raise TypeError("First argument to compose must be callable")
if not callable(func_2):
raise TypeError("Second argument to compose must be callable")
if unpack:
def composition(*args, **kwargs):
return func_1(*func_2(*args, **kwargs))
else:
def composition(*args, **kwargs):
return func_1(func_2(*args, **kwargs))
return composition
This SO question is somewhat related; it asks whether Python should support special syntax for compose
.
Function composition is the way of combining two or more functions in such a way that the output of one function becomes the input of the second function and so on.
In computer science, function composition is an act or mechanism to combine simple functions to build more complicated ones. Like the usual composition of functions in mathematics, the result of each function is passed as the argument of the next, and the result of the last one is the result of the whole.
Composition is a concept that models a has a relationship. It enables creating complex types by combining objects of other types. This means that a class Composite can contain an object of another class Component . This relationship means that a Composite has a Component .
Composing functions is a common and useful way to create new functions in Haskell. Haskell composition is based on the idea of function composition in mathematics. In mathematics, if you have two functions f(x) and g(x), you compute their composition as f(g(x)). The expression f(g(x)) first calls g and then calls f.
Your implementation of compose
is valid for python 3.2 as discussed in the comments above.
Most of the functions of the library you gave have a python equivalent written in the documentation.
Functions such as map
and filter
are already implemented in python and can also be simply expressed as list comprehensions. Python has an id
function returning the identity of an object (as integer), but the id
function of the library can be expressed as lambda x: x
.
Another modules you might find interesting are itertools
and functools
which has partial
and reduce
(which is similar to foldl
but the argument order is not the same).
Here is a simple implementations of a few of them that I didn't find in the standard library:
from functools import reduce
def flip(f):
if not callable(f):
raise TypeError("Cannot filp a non-callable object")
def result(*args, **kw):
args = list(args)
args.reverse()
return f(*args, **kw)
return result
def ilast(i):
return reduce(lambda _, x: x, i)
def iscanl(f, v, seq):
yield v
for a in seq:
v = f(v, a)
yield v
def scanl(*args, **kw):
return list(iscanl(*args, **kw))
def foldl(*args, **kw):
return ilast(iscanl(*args, **kw))
# Or using reduce
#def foldl(f, v, seq):
# return reduce(f, seq, v)
def iscanr_reverse(f, v, seq):
return iscanl(flip(f), v, seq)
def scanr(*args, **kw):
result = list(iscanr_reverse(*args, **kw))
result.reverse()
return result
def foldr(*args, **kw):
return ilast(iscanr_reverse(*args, **kw))
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With