Others have already posted how you can do this using the Reader monad, but that’s not the only way. It turns out that your second function is pretty close. I think you meant to post foobar’ x = (`map` [id, reverse]) ($ x) Since the x is already near a rightmost position, you’re almost there. … Read more
Current State of JavaScript Functional Programming Libraries [closed]
Coming up with (.) . (.) is actually pretty straightforward, it’s the intuition behind what it does that is quite tricky to understand. (.) gets you very far when rewriting expression into the “pipe” style computations (think of | in shell). However, it becomes awkward to use once you try to compose a function that … 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
One simplification, f_and = liftM2 (&&) f_or = liftM2 (||) or = liftA2 (&&) = liftA2 (||) in the ((->) r) applicative functor. Applicative version Why? We have: instance Applicative ((->) a) where (<*>) f g x = f x (g x) liftA2 f a b = f <$> a <*> b (<$>) = fmap … 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
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 point-free style is considered by some author as the ultimate functional programming style. To put things simply, a function of type t1 -> t2 describes a transformation from one element of type t1 into another element of type t2. The idea is that “pointful” functions (written using variables) emphasize elements (when you write \x … 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
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