Put simply, . is function composition, just like in math: f (g x) = (f . g) x In your case, you are creating a new function, sumEuler that could also be defined like this: sumEuler x = sum (map euler (mkList x)) The style in your example is called “point-free” style — the arguments … Read more
Something along these lines, perhaps (untested): template <typename F> class Composer { int n_; F f_; public: Composer(int n, F f) : n_(n), f_(f) {} template <typename T> T operator()(T x) const { int n = n_; while (n–) { x = f_(x); } return x; } }; template <int N, typename F> Composer<F> compose(F … 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
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 guess I can answer this from authority. Is there a reason for using the books way that is much better than using all ($) symbols? There’s no special reason. Bryan and I both prefer to reduce line noise. . is quieter than $. As a result, the book uses the f . g . … Read more
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
Circular type aliases are not really supported except in certain cases. (UPDATE TS 4.1, these are more supported now, but I’m still inclined to represent flow() as operating on AsChain that verifies a particular array of functions instead of trying to come up with a Chain that matches all valid arrays of functions) Instead of … 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
The $ operator is for avoiding parentheses. Anything appearing after it will take precedence over anything that comes before. For example, let’s say you’ve got a line that reads: putStrLn (show (1 + 1)) If you want to get rid of those parentheses, any of the following lines would also do the same thing: putStrLn … Read more