(<.>) operator (generalizing (.) to Functor)

[uzytkownik]

Currently there are following operators:

(<$>) :: (a -> b) -> f a -> f b
($) :: (a -> b) -> a -> b
(.) :: (b -> c) -> (a -> b) -> a -> c

However defining the operator that is to <$> as . is to $ is trivial:

(<.>) :: (b -> c) -> (a -> f b) -> a -> f c
f <.> g = fmap f . g

It would help writing in pointless style using Functors (as well as Applicatives/Monads etc.)

[malcolm.wallace@…]

The type you have chosen for <.> is far from obvious. Why not

(<.>) :: (b->c) -> (a->b) -> f a -> f c
f <.> g = ((f . g) <$>)

for instance?

[uzytkownik]

1. Because it follows simple correspondence:

(a . b . c) d = a $ b $ c $ d
(a <.> b <.> c) d = a <$> b <$> c  <$> d

2. Because your definition does not allow chaining (well - the whiole point of such operator is chaining) [I know it is 'for example']:

\a b c -> a <.> b <.> c :: (Functor f, Functor f1) => (f c1 -> c) -> (b -> c1) -> (a -> b) -> f1 (f a) -> f1 c

or

\a b c -> a <.> b <.> c :: (Functor f, Functor f1) => (b -> c) -> (a -> b) -> (a1 -> f a) -> f1 a1 -> f1 (f c)

3. I decided to post it when I found  others find it useful as well - with the same definition.

4. It allows to chain even if first function parameter is not functor:

read <.> readFile :: (Read a) => FilePath -> IO a
print <=< (read :: String -> Int) <.> readFile :: FilePath -> IO ()
const 1 <.> print <=< (read :: String -> Int) <.> readFile :: (Num t) => FilePath -> IO t

[igloo]

I suggest making a  library proposal for this.

[uzytkownik]

Replying to malcolm.wallace@…:

The type you have chosen for <.> is far from obvious. Why not {{{ (<.>) :: (b->c) -> (a->b) -> f a -> f c f <.> g = ((f . g) <$>) }}} for instance?

I thought about more Cathegorical explanation. Functor F from A to B is suppose to map category into other category. I.e. if category A = (O, M, id, .) and B = (F(O), F(M), F(id), F(.)) then F(O) is solved on type level, F(M) is done by fmap, F(id) is fmap id and F(.) is <.>

Replying to igloo:

I suggest making a  library proposal for this.

I'll do it

[uzytkownik]

Replying to uzytkownik:

Replying to malcolm.wallace@…:

The type you have chosen for <.> is far from obvious. Why not {{{ (<.>) :: (b->c) -> (a->b) -> f a -> f c f <.> g = ((f . g) <$>) }}} for instance?

I thought about more Cathegorical explanation. Functor F from A to B is suppose to map category into other category. I.e. if category A = (O, M, id, .) and B = (F(O), F(M), F(id), F(.)) then F(O) is solved on type level, F(M) is done by fmap, F(id) is fmap id and F(.) is <.>

Please ignore this explanation.

[uzytkownik]

Patch for composition of function in functors

[uzytkownik]

Summary of  discussion.

There were the following counterpoints to (<.>):

- Lack of symmetry (contrary to (.)) - Operators usually have more then 2 parameters in unexpanded form (however (>=>) (<=<) (^{<<) etc. are in base) - f <.> g is not much shorter then fmap f . g}

Generally it seems to depend on style preference

[igloo]

From a quick skim of the thread, I count 4 or 5 against the proposal, and 2 (including the proposer) in favour of it. I'm therefore closing it as wontfix; please reopen if you think I've reached the wrong conclusion.