Let’s first play typechecker for the mechanical proof. I’ll describe an intuitive way of thinking about it afterward. I want to apply (.) to (.) and then I’ll apply (.) to the result. The first application helps us to define some equivalences of variables. ((.) :: (b -> c) -> (a -> b) -> a … Read more
Just look at the Wikipedia article to get your definition: Tacit programming (point-free programming) is a programming paradigm in which a function definition does not include information regarding its arguments, using combinators and function composition […] instead of variables. Haskell example: Conventional (you specify the arguments explicitly): sum (x:xs) = x + (sum xs) sum … Read more
For a given type r, the function of type r -> a can be thought of as a computation delivering an a using an environment typed r. Given two functions r -> a and a -> (r -> b), it’s easy to imagine that one can compose these when given an environment (again, of type … Read more
All you need here is the following three “laws” of operator sections: (a `op` b) = (a `op`) b = (`op` b) a = op a b (1) (2) (3) so that the operand goes into the free slot near the operator. For (.) this means that: (a . b) = (a .) b = … 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 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 evaluation mechanism in Haskell is by-need: when a value is needed, it is calculated, and kept ready in case it is asked for again. If we define some list, xs=[0..] and later ask for its 100th element, xs!!99, the 100th slot in the list gets “fleshed out”, holding the number 99 now, ready for … Read more