pointfree

Part of some computation I am doing in Haskell results in a list of functions that map Float to Float . I'd like to apply a single argument to all these functions, like so: -- x :: Float -- functions :: [Float -> Float] map (\f -> f x) functions Is there a way to do this without making use of a throw-away lambda function? I've searched Hoogle for what I think the signature should be ( [a -> b] -> a -> [b] ) with no luck. You can use the $ operator, which is just function application: map ($ x) functions (This presupposes that x is in scope for the expression.) Hoogle can only find functions,

Say I have functions g :: a -> b, h :: a -> c and f :: b -> c -> d. Is it possible to write the function f' :: a -> a -> d given by f' x y = f (g x) (h y) in point free style?. One can write the function f' a -> d, f' x = f (g x) (h x) in point free style by setting f' = (f <$> g) <*> h but I couldn't figure out how to do the more general case. Lynn We have: k x y = (f (g x)) (h y) and we wish to write k in point-free style. The first argument passed to k is x . What do we need to do with x ? Well, first we need to call g on it, and then f , and then do something fancy to apply this to (h y) .

I am just working through some simple exercises in haskell and was wondering if there was a point-free way of converting an if-then-else statement into a Maybe type: Nothing being returned if the condition is false, and Just the input if the condition is true. In short, given some: maybeIf :: (a -> Bool) -> a -> Maybe a maybeIf cond a = if cond a then Just a else Nothing Is there an implementation that is point-free with respect to a ? I've also been looking at a more concrete version, a -> Maybe a , and feel like there may be an answer somewhere in Control.Arrow . However, since Maybe is a

I was trying to implement the function every :: (a -> IO Bool) -> [a] -> IO Bool which was the topic for this question . I tried to do this without explicit recursion . I came up with the following code every f xs = liftM (all id) $ sequence $ map f xs My function didn't work since it wasn't lazy (which was required in the question), so no upvotes there :-). However, I did not stop there. I tried to make the function point-free so that it would be shorter (and perhaps even cooler). Since the arguments f and xs are the last ones in the expression I just dropped them: every = liftM (all id) $

According to pointfree : \x -> (x, x) is equivalent to: join (,) What is the derivation that shows this? Look at the type signatures: \x -> (x, x) :: a -> (a, a) (,) :: a -> b -> (a, b) join :: Monad m => m (m a) -> m a It should be noted that ((->) r) is an instance of the Monad typeclass. Hence, on specializing: join :: (r -> r -> a) -> (r -> a) What join does for functions is apply the given function twice to the same argument: join f x = f x x -- or join f = \x -> f x x From this, we can see trivially: join (,) = \x -> (,) x x -- or join (,) = \x -> (x, x) Qed. I like Aadits intuitive

Say I have a mean function defined like so: mean xs = sum xs / (fromIntegral $ length xs) but I want it in some tacit form, like this: mean = sum / (fromIntegral . length) Is there a built-in Haskell way to do something along these lines without having to build up my own tacit function (something like this): tacit :: (a -> b -> c) -> (d -> a) -> (d -> b) -> d -> c tacit a b c i = a (b i) (c i) In this form, the function looks like this: mean = tacit (/) sum (fromIntegral . length) but it feels like there might be a way to avoid having to use an explicit function such as this. I'm just

This question already has answers here : Defining a function by equations with different number of arguments (3 answers) Closed 2 years ago . With multiple pattern-matching, different numbers of arguments are impossible, even with point-free! foo True b = b + 2 foo _ = id doesn't work for example. But foo True = (+2) foo _ = id does. Sometimes we can use point-free only in one part of the function, so... Why? Is it too hard for GHC? :'( Why? Is it too hard for GHC? No . It is not at all too hard for GHC. Actually, this is the fault of the Haskell Report. See: Haskell Report 2010 > Declarations