You can use your hack class as a decorator pretty much as it’s written, though you’d likely want to choose a more appropriate name for the class. Like this: class Composable(object): def __init__(self, function): self.function = function def __call__(self, *args, **kwargs): return self.function(*args, **kwargs) def __mul__(self, other): @Composable def composed(*args, **kwargs): return self.function(other(*args, **kwargs)) return … Read more
What about this? import Control.Applicative (liftA2) — given f1, f2, and f3 filtered = filter (f1 <&&> f2 <&&> f3) [1..90] where (<&&>) = liftA2 (&&) Here, lifting && to Applicative gives what you marked as <?>, i.e. an operator to “and” together the results of two unary predicates. I initially used the name .&&. … Read more
In the presence of non-strict evaluation, right-associativity is useful. Let’s look at a very dumb example: foo :: Int -> Int foo = const 5 . (+3) . (`div` 10) Ok, what happens when this function is evaluated at 0 when . is infixr? foo 0 => (const 5 . ((+3) . (`div` 10))) 0 … Read more
You are not making a mistake. The key idea to understand here is currying – that a Haskell function of two arguments can be seen in two ways. The first is as simply a function of two arguments. If you have, for example, (+), this is usually seen as taking two arguments and adding them. … Read more
The easiest approach would be first to write a composition of 2 functions: def compose2(f, g): return lambda *a, **kw: f(g(*a, **kw)) And then use reduce to compose more functions: import functools def compose(*fs): return functools.reduce(compose2, fs) Or you can use some library, which already contains compose function.
I understand how you feel. I found function composition to be quite difficult to grasp at first too. What helped me grok the matter were type signatures. Consider: (*) :: Num x => x -> x -> x (+) :: Num y => y -> y -> y (.) :: (b -> c) -> (a … Read more
f >>> g from Control.Arrow.
The dot operator (i.e. (.)) is the function composition operator. It is defined as follows: infixr 9 . (.) :: (b -> c) -> (a -> b) -> a -> c f . g = \x -> f (g x) As you can see it takes a function of type b -> c and another … Read more
The short answer is that type inference doesn’t always work with higher-rank types. In this case, it is unable to infer the type of (.), but it type checks if we add an explicit type annotation: > :m + Control.Monad.ST > :set -XRankNTypes > :t (((.) :: ((forall s0. ST s0 a) -> a) -> … Read more
My preferred implementation for this is fmap . fmap :: (Functor f, Functor f1) => (a -> b) -> f (f1 a) -> f (f1 b) If only because it is fairly easy to remember. When instantiating f and f1 to (->) c and (->) d respectively you get the type (a -> b) -> … Read more