Speaking of small functions

older
hs-plugins: dynamic linking error...

Cale Gibbard

28 Oct 2006 28 Oct '06

10:51 p.m.

Speaking of small functions, Kleisli composition should at least be in Control.Monad. It's a simple thing, and not commonly explicitly used at the moment, but rather important conceptually. (@@) :: (Monad m) => (b -> m c) -> (a -> m b) -> (a -> m c) g @@ f = \x -> f x >>= g

Show replies by date

J. Garrett Morris

29 Oct 29 Oct

12:33 a.m.

I've found myself using this quite a bit, actually; I strongly support its addition to the Prelude or Control.Monad. /g On 10/28/06, Cale Gibbard wrote:

...

Speaking of small functions, Kleisli composition should at least be in Control.Monad. It's a simple thing, and not commonly explicitly used at the moment, but rather important conceptually.

(@@) :: (Monad m) => (b -> m c) -> (a -> m b) -> (a -> m c) g @@ f = \x -> f x >>= g _______________________________________________ Libraries mailing list Libraries@haskell.org http://www.haskell.org/mailman/listinfo/libraries

-- It is myself I have never met, whose face is pasted on the underside of my mind.

dons＠cse.unsw.edu.au

12:47 a.m.

trevion:

...

I've found myself using this quite a bit, actually; I strongly support its addition to the Prelude or Control.Monad.

/g

On 10/28/06, Cale Gibbard wrote:

...
Speaking of small functions, Kleisli composition should at least be in Control.Monad. It's a simple thing, and not commonly explicitly used at the moment, but rather important conceptually.

(@@) :: (Monad m) => (b -> m c) -> (a -> m b) -> (a -> m c) g @@ f = \x -> f x >>= g

This does seem useful. However, the only way to make this actually happen is to submit a patch following this process: http://haskell.org/haskellwiki/Library_submissions otherwise, we'll just be about which colour we prefer for the bikeshed. I.e. * darcs patch * haddock comments * trac entry -- Don

kahl＠cas.mcmaster.ca

9:30 a.m.

...

Speaking of small functions, Kleisli composition should at least be in Control.Monad. It's a simple thing, and not commonly explicitly used at the moment, but rather important conceptually.

(@@) :: (Monad m) => (b -> m c) -> (a -> m b) -> (a -> m c) g @@ f = \x -> f x >>= g

I support this strongly. My notation is (=>>=), to go with (>>=). Wolfram

Jon Fairbairn

9:46 a.m.

On 2006-10-29 at 09:30EST kahl@cas.mcmaster.ca wrote:

...

...
Speaking of small functions, Kleisli composition should at least be in Control.Monad. It's a simple thing, and not commonly explicitly used at the moment, but rather important conceptually.

(@@) :: (Monad m) => (b -> m c) -> (a -> m b) -> (a -> m c) g @@ f = \x -> f x >>= g

I support this strongly.

My notation is (=>>=), to go with (>>=).

That's a better symbol for it. (@@) could be just about anything, while (=>>=) is suggestive. Though I think what it suggests might be with the arguments in a different order? -- Jón Fairbairn Jon.Fairbairn at cl.cam.ac.uk

Duncan Coutts

10:19 a.m.

On Sun, 2006-10-29 at 14:46 +0000, Jon Fairbairn wrote:

...

On 2006-10-29 at 09:30EST kahl@cas.mcmaster.ca wrote:

...
...
Speaking of small functions, Kleisli composition should at least be in Control.Monad. It's a simple thing, and not commonly explicitly used at the moment, but rather important conceptually.

(@@) :: (Monad m) => (b -> m c) -> (a -> m b) -> (a -> m c) g @@ f = \x -> f x >>= g

I support this strongly.

My notation is (=>>=), to go with (>>=).

That's a better symbol for it. (@@) could be just about anything, while (=>>=) is suggestive. Though I think what it suggests might be with the arguments in a different order?

Yes, we already have =<< for reverse >>= which is nice sometimes when you want to emphasise the similarity to (.) rather than imperative order, eg: return . foldr h z . map f . filter p =<< getContents So it'd be: (=<<=) :: (Monad m) => (b -> m c) -> (a -> m b) -> (a -> m c) (g =<<= f) x = g =<< f x (or should it really be written with a lambda?) and if there's demand for (=>>=) too then that's obviously easy to add. Duncan

kahl＠cas.mcmaster.ca

2:57 p.m.

...

On 2006-10-29 at 09:30EST kahl@cas.mcmaster.ca wrote:

...
...
Speaking of small functions, Kleisli composition should at least be in Control.Monad. It's a simple thing, and not commonly explicitly used at the moment, but rather important conceptually.

(@@) :: (Monad m) => (b -> m c) -> (a -> m b) -> (a -> m c) g @@ f = \x -> f x >>= g

I support this strongly.

My notation is (=>>=), to go with (>>=).

That's a better symbol for it. (@@) could be just about anything, while (=>>=) is suggestive. Though I think what it suggests might be with the arguments in a different order?

Yes, indeed! Thanks for pointing this out! And I definitely prefer that order: (=>>=) :: (a -> m b) -> (b -> m c) -> (a -> m c) Wolfram

Duncan Coutts

5:49 p.m.

On Sun, 2006-10-29 at 14:57 -0500, kahl@cas.mcmaster.ca wrote:

...

...
On 2006-10-29 at 09:30EST kahl@cas.mcmaster.ca wrote:

...
...
Speaking of small functions, Kleisli composition should at least be in Control.Monad. It's a simple thing, and not commonly explicitly used at the moment, but rather important conceptually.

(@@) :: (Monad m) => (b -> m c) -> (a -> m b) -> (a -> m c) g @@ f = \x -> f x >>= g

I support this strongly.

My notation is (=>>=), to go with (>>=).

That's a better symbol for it. (@@) could be just about anything, while (=>>=) is suggestive. Though I think what it suggests might be with the arguments in a different order?

Yes, indeed! Thanks for pointing this out! And I definitely prefer that order:

(=>>=) :: (a -> m b) -> (b -> m c) -> (a -> m c)

Ok. Let's have both (=>>=) and (=<<=). If that's a consensus, then someone make a darcs patch with haddock documentation and a trac bug etc. http://haskell.org/haskellwiki/Library_submissions Duncan

dons＠cse.unsw.edu.au

11:13 p.m.

duncan.coutts:

...

On Sun, 2006-10-29 at 14:57 -0500, kahl@cas.mcmaster.ca wrote:

...
...
On 2006-10-29 at 09:30EST kahl@cas.mcmaster.ca wrote:

...
...
Speaking of small functions, Kleisli composition should at least be in Control.Monad. It's a simple thing, and not commonly explicitly used at the moment, but rather important conceptually.

(@@) :: (Monad m) => (b -> m c) -> (a -> m b) -> (a -> m c) g @@ f = \x -> f x >>= g

I support this strongly.

My notation is (=>>=), to go with (>>=).

That's a better symbol for it. (@@) could be just about anything, while (=>>=) is suggestive. Though I think what it suggests might be with the arguments in a different order?

Yes, indeed! Thanks for pointing this out! And I definitely prefer that order:

(=>>=) :: (a -> m b) -> (b -> m c) -> (a -> m c)

Ok. Let's have both (=>>=) and (=<<=).

If that's a consensus, then someone make a darcs patch with haddock documentation and a trac bug etc.

http://haskell.org/haskellwiki/Library_submissions

Before I or someone else rolls a patch for this, are there any other similar functions that fit? I'm reminded of some of the things from the old Gofer CC prelude, http://www.cse.unsw.edu.au/~dons/data/cc.prelude (@@) :: Monad m => (a -> m b) -> (c -> m a) -> (c -> m b) f @@ g = join . map f . g Do we have some references in the literature (a Mark Jones paper perhaps?) -- Don

Iavor Diatchki

30 Oct 30 Oct

1:56 a.m.

hi, i also think that we should have kleisli composition, it is just as important as the ordinary composition. i do prefer the shorter (@@) notation though.

...

Before I or someone else rolls a patch for this, are there any other similar functions that fit?

I'm reminded of some of the things from the old Gofer CC prelude,

http://www.cse.unsw.edu.au/~dons/data/cc.prelude

(@@) :: Monad m => (a -> m b) -> (c -> m a) -> (c -> m b) f @@ g = join . map f . g

Do we have some references in the literature (a Mark Jones paper perhaps?)

are you think of a reference for kleisli composition? if so, it is a fairly standard operation and is described in many books and there is also a wikipedia entry for the kleisli category of a monad. kleisli composition should satisfy the usual properties of composition---associativity and left and right identity (using 'return')---and with the above definition these properties follow from the monad laws. -iavor

Josef Svenningsson

7:50 a.m.

On 10/30/06, Donald Bruce Stewart wrote:

...

I'm reminded of some of the things from the old Gofer CC prelude,

http://www.cse.unsw.edu.au/~dons/data/cc.prelude

(@@) :: Monad m => (a -> m b) -> (c -> m a) -> (c -> m b) f @@ g = join . map f . g

Do we have some references in the literature (a Mark Jones paper perhaps?)

Indeed. "Functional Programming with Overloading and Higher-Order Polymorphism": http://web.cecs.pdx.edu/~mpj/pubs/springschool.html Page 31. Josef Svenningsson

Johannes Waldmann

8:04 a.m.

kahl@cas.mcmaster.ca wrote:

...

... And I definitely prefer that order:

(=>>=) :: (a -> m b) -> (b -> m c) -> (a -> m c)

cultural note: it is one big problem to get the argument ordering for composition (of relations, including functions) "right". See any undergraduate textbook on how they confuse this. In fact, the root of the problem quite possibly is the idea that the function stands before its argument, which is contrary to the flow of information (and reading). There is one textbook http://www.infres.enst.fr/~jsaka/ETA/eta.html that takes the radical approach of writing not f(x) but x f. Then x(f.g) = (xf)g looks only natural. -- -- Johannes Waldmann -- Tel/Fax (0341) 3076 6479/80 -- ---- http://www.imn.htwk-leipzig.de/~waldmann/ -------

Ashley Yakeley

3 Nov 3 Nov

9:02 p.m.

Johannes Waldmann wrote:

...

There is one textbook http://www.infres.enst.fr/~jsaka/ETA/eta.html that takes the radical approach of writing not f(x) but x f. Then x(f.g) = (xf)g looks only natural.

Those folks probably also put adjectives after their nouns. -- Ashley Yakeley Seattle WA

Bulat Ziganshin

29 Oct 29 Oct

1:13 p.m.

New subject: Re[2]: Speaking of small functions

Hello kahl, Sunday, October 29, 2006, 5:30:41 PM, you wrote:

...

My notation is (=>>=), to go with (>>=).

and my is .>>= to reflect that it is like (.) i've used for years the following definitions: infixl 1 >>==, ==<<, =<<., .>>=, .>>, .>>==, ==<<. a>>==b = a >>= return.b a==<>=b) c = a c >>= b (a.>>b) c = a c >> b (a==<<.b) c = return.a =<< b c (a.>>==b) c = a c >>= return.b -- Best regards, Bulat mailto:Bulat.Ziganshin@gmail.com

0 0

Reply
Sign in to reply online Use email software

Henning Thielemann

30 Oct 30 Oct
2:47 a.m.

New subject: Re[2]: Speaking of small functions

On Sun, 29 Oct 2006, Bulat Ziganshin wrote:

...
Hello kahl,

Sunday, October 29, 2006, 5:30:41 PM, you wrote:

...
My notation is (=>>=), to go with (>>=).

and my is .>>= to reflect that it is like (.)

I have used this symbol for this purpose privately, too. However I also support (=>>=) and (=<<=).

0 0

Reply
Sign in to reply online Use email software

6772
Age (days ago)

6778
Last active (days ago)

List overview
Download

14 comments

12 participants

Add to favorites Remove from favorites

tags

participants (12)

Ashley Yakeley

Bulat Ziganshin

Cale Gibbard

dons＠cse.unsw.edu.au

Duncan Coutts

Henning Thielemann

Iavor Diatchki

J. Garrett Morris

Johannes Waldmann

Jon Fairbairn

Josef Svenningsson

kahl＠cas.mcmaster.ca