($) is to (.) as `fmap` is to?

Question

I have a function funcM :: a -> b -> c -> IO (x, y)

I want to write a function funcM_ :: a-> b-> c-> IO x so:

funcM_ = fst `fmap` funcM -- error

I could add back all the points, but it seems like there should be something I could replace fmap with so that the above will work. Kind of like replacing ($) with (.) would make this work in a pure context.

What is the function I am looking for?

score 7 · Answer 1 · answered Jan 07 '14 at 01:07

Since you’re composing a one-argument function (fmap) with a three-argument function (funcM), you need three levels of composition:

funcM_ = ((fmap fst .) .) . funcM

This is equivalent to the pointed version by a simple expansion:

funcM_ x = (fmap fst .) . funcM x
funcM_ x y = fmap fst . funcM x y
funcM_ x y z = fmap fst (funcM x y z)

This follows from the type of fmap, really:

fmap :: (Functor f) => (a -> b) -> f a -> f b

You’re just partially applying the arguments to funcM so that you have an f a (here IO (x, y)) which you give to fmap fst to get back an f b (IO x).

As an aside, M_ usually implies returning m ().

And in fact it is returning () In order not to have to list a lot of code, I changed the Monad in question from `StateT Context (ErrorT Err STM) a` to IO. I still need the state but I don't need the value. The a and b arguments actually are used to create the state and the c value implements recoverable errors. All details that are unimportant to the question. Yes, it looks like I also need `snd` rather then `fst`. but it doesn't matter for the question asked. — John F. Miller, Jan 07 '14 at 06:01

score 4 · Answer 2 · edited May 23 '17 at 12:15

Take a look at the following answer: https://stackoverflow.com/a/20279307/783743 It explains how to convert your code into pointfree style. Let's start with a non-pointfree definition of funcM_:

funcM_ a b c = fmap fst (funcM a b c)

-- But `\x -> f (g x)` is `f . g`. Hence:

funcM_ a b = fmap fst . (funcM a b)

-- But `\x -> f (g x)` is `f . g`. Hence:

funcM_ a = (fmap fst .) . (funcM a)

-- But `\x -> f (g x)` is `f . g`. Hence:

funcM_ = ((fmap fst .) .) . funcM

Another way to do this would be to use uncurry and curry as follows:

uncurry3 :: (a -> b -> c -> d) -> (a, b, c) -> d
uncurry3 f (a, b, c) = f a b c

curry3 :: ((a, b, c) -> d) -> a -> b -> c -> d
curry3 f a b c = f (a, b, c)

(.::) :: (d -> e) -> (a -> b -> c -> d) -> a -> b -> c -> e
f .:: g = curry3 (f . (uncurry3 g))

Now you can write funcM_ as follows:

funcM_ = fmap fst .:: funcM

You could also write .:: in pointfree style as follows:

(.::) :: (d -> e) -> (a -> b -> c -> d) -> a -> b -> c -> e
(.::) = (.) . (.) . (.)

Hope that helped.

FYI `(.::)` is defined in functors: Data.Functor.Syntax http://hackage.haskell.org/package/functors-0.1/docs/Data-Functor-Syntax.html (I suppose you already know that, or else the name `(.::)` is naturally attractive.) — misterbee, Jan 07 '14 at 04:05

misterbee · Answer 3 · 2014-01-07T04:01:21.350

Add a dot for each argument to funcM

These are all equivalent:

((fmap fst . ) .) . funcM
((.)  . (.)  . (.))  (fmap fst) funcM
(fmap . fmap . fmap) (fmap fst) funcM

import Data.Functor.Syntax -- from 'functors' package
(.::) (fmap fst) funcM

Note that all I did was change the implicit ($) to (.). :-)

(.) is the implementation of fmap for the function instance of Functor :

instance Functor ((->) a) b where
  fmap f g = f . g

GHCi :t is your friend.

($) is to (.) as `fmap` is to?

3 Answers3