Having '<<', why to use '|>' ?

Having '<<', why to use '|>' ?

[Fabrice Marchant]

 Hello !

For f1 and f2 composable functions, writing :   

let ( << ) f g x = f (g x)

let g1 = f2 << f1

let ( |> ) x f = f x

let g2 = fun x ->
               x
            |> f1
            |> f2  

I usually use '<<' and wonder if we can always supersede '|>' by this operator ?
g1 and g2 are same functions ( not true ? ).
Does it exists a case where the use of '|>' is better ?

Thanks,

 Fabrice
-----------------------------------
Force est de constater que mon post sur Lucky et Camel n'a pas fait un tabac...

Re: [Caml-list] Having '<<', why to use '|>' ?

[Eric Cooper]

On Mon, Sep 17, 2007 at 04:36:17PM +0200, Fabrice Marchant wrote:
> let ( << ) f g x = f (g x)
> let ( |> ) x f = f x
> I usually use '<<' and wonder if we can always supersede '|>' by
> this operator ?  Does it exists a case where the use of '|>' is
> better ?

I think it's just a matter of style.  Your |> operator lets you write
"pipelines" similar to the Unix shell, in which evaluation flows
from left to right.  I've typically used this when I'm applying the
function to all its arguments.  I tend to use the traditional
composition operator (your <<), when I'm combining and passing
functional values around.

-- 
Eric Cooper             e c c @ c m u . e d u

Re: [Caml-list] Having '<<', why to use '|>' ?

[Fabrice Marchant]

> I think it's just a matter of style.  Your |> operator lets you write
> "pipelines" similar to the Unix shell, in which evaluation flows
> from left to right.  I've typically used this when I'm applying the
> function to all its arguments.  I tend to use the traditional
> composition operator (your <<), when I'm combining and passing
> functional values around.

  Thanks a lot !

So I will not add the use of "|>" to my habits. Simply using "<<" will help to keep things simple.

Only two or three operators seems very useful to me :

This one avoids some parentheses and let the code clear.
let ( @ ) f x = f x

The composition operator :
let ( << ) f g x = f @ g x

This one, written like this, is not a true operator, but is very useful to adapt parameters order :
let flip f x y = f y x

This other one, like "|>", doesn't appear to be essential :
let ( >> ) f g = ( << ) g f
( Can't write : let ( >> ) = flip ( << ) instead... )

Please are they other useful operators ?

Regards,

Fabrice

Re: [Caml-list] Having '<<', why to use '|>' ?

[Julien Moutinho]

Hi,

% cat f.ml4
let ( << ) f g x = f @ g x

% camlp4of -impl f.ml4
File "ghost-location", line 1, characters 0-2:
Quotation not terminated

Just to point out that << interferes with the quotations of Camlp4,
so maybe it is not really wise to use it.

> Force est de constater que mon post sur Lucky et Camel n'a pas fait un tabac...
xD

Re: [Caml-list] Having '<<', why to use '|>' ?

[Fabrice Marchant]

On Tue, 18 Sep 2007 00:24:07 +0200
Julien Moutinho <julien.moutinho@gmail.com> wrote:

> Hi,
> 
> % cat f.ml4
> let ( << ) f g x = f @ g x
> 
> % camlp4of -impl f.ml4
> File "ghost-location", line 1, characters 0-2:
> Quotation not terminated

 Thanks for this.

 I didn't knew "camlp4of", staying cowardly with a 3.09 on a debian lenny (no camlp4-extra package).

> Just to point out that << interferes with the quotations of Camlp4,
> so maybe it is not really wise to use it.

  That is actually a problem indeed. What could be safely used as a composition operator instead ?
( <<< ) ? What else ?

Regards,

Fabrice

Re: [Caml-list] Having '<<', why to use '|>' ?

[Julien Moutinho]

>   That is actually a problem indeed. What could be safely
> used as a composition operator instead ? ( <<< ) ?
Have a look at this:
	http://caml.inria.fr/pub/docs/manual-ocaml/lex.html#infix-symbol
With the keywords below.

> What else ?
I would personally double the '@':
	let (@@) f g x = f @ g x

Regards.

Re: [Caml-list] Having '<<', why to use '|>' ?

[Julien Moutinho]

On Tue, Sep 18, 2007 at 10:53:10AM +0200, Julien Moutinho wrote:
> I would personally double the '@':
> 	let (@@) f g x = f @ g x
Sorry, I have replaced [f (g x)] by [f @ g x] earlier on.

Re: [Caml-list] Having '<<', why to use '|>' ?

[Fabrice Marchant]

  Thanks Julien !

> Have a look at this:
> 	http://caml.inria.fr/pub/docs/manual-ocaml/lex.html#infix-symbol
> With the keywords below.
"Note that the following identifiers are keywords of the Camlp4 extensions and should be avoided for compatibility reasons.

    parser    <<    <:    >>    $     $$    $:
"
So no doubt, I'll edit my old programs and replace "<<".

> > ... a composition operator ... ( <<< ) ?
> > What else ?

> I would personally double the '@':
> 	let (@@) f g x = f @ g x

 ( or f (g x) : it is practically the same thing. )

A 3 chars operator (<<<) doesn't look smart. Simpler is better.
However, about (@@), I preferred to see the direction of the asymmetric composition operator.
( <| ) instead of ( << ) ? Is this a possible idea ?

  But maybe your idea is good. Maths use a kind of small 'o' : (f o g) (x) = f (g (x)).
It's symmetric like (@@), and that doesn't raise any problem.

Cheers,

Fabrice

Re: [Caml-list] Having '<<', why to use '|>' ?

[Jon Harrop]

On Tuesday 18 September 2007 15:12:46 Fabrice Marchant wrote:
> A 3 chars operator (<<<) doesn't look smart.

That is actually the F# for lsl. There are also ||| and &&& for bitwise ops.

> Simpler is better. 
> However, about (@@), I preferred to see the direction of the asymmetric
> composition operator. ( <| ) instead of ( << ) ? Is this a possible idea ?

But "<<" is the converse of ">>" (in F#) and "|>" has no converse (or you 
could say that "x |> f" is the converse of "f x").

>   But maybe your idea is good. Maths use a kind of small 'o' : (f o g) (x)
> = f (g (x)). It's symmetric like (@@), and that doesn't raise any problem.

If an OCaml front-end handled unicode with appropriate symbol settings then 
you could use an "o" symbol to mean that infix operator. I think that is a 
good solution, provided you use an editor that supports suitable unicode and 
there is an easy way to enter such things.

-- 
Dr Jon D Harrop, Flying Frog Consultancy Ltd.
OCaml for Scientists
http://www.ffconsultancy.com/products/ocaml_for_scientists/?e

Re: [Caml-list] Having '<<', why to use '|>' ?

[skaller]

On Tue, 2007-09-18 at 17:42 +0100, Jon Harrop wrote:

> If an OCaml front-end handled unicode with appropriate symbol settings then 
> you could use an "o" symbol to mean that infix operator. I think that is a 
> good solution, provided you use an editor that supports suitable unicode and 
> there is an easy way to enter such things.

Actually no, I tried this. I used gvim and ignored the difficulty
of entering the Unicode characters I wanted.

The problem I found was that the fonts were such that the
character was almost unreadable. And I think i tried,
for example, the high school division sign.. 

If you tried that with a 'small o' it would just look like a
small 'o' and not the composition operator.

I think this problem might be fixed with lexical coloring though!


-- 
John Skaller <skaller at users dot sf dot net>
Felix, successor to C++: http://felix.sf.net

Re: [Caml-list] Having '<<', why to use '|>' ?

[Fabrice Marchant]

On Tue, 18 Sep 2007 17:42:27 +0100
Jon Harrop <jon@ffconsultancy.com> wrote:

>> A 3 chars operator (<<<) doesn't look smart.  
>That is actually the F# for lsl. There are also ||| and &&& for bitwise ops.

  Thanks Jon, happy to read you,

 So, do you think that (<<<) could replace (<<) as a function composition operator ?

> > However, about (@@), I preferred to see the direction of the asymmetric
> > composition operator. ( <| ) instead of ( << ) ? Is this a possible idea ?

> But "<<" is the converse of ">>" (in F#) and "|>" has no converse (or you 
> could say that "x |> f" is the converse of "f x").

Things must keep consistent, you're right. So, ( <| ) instead of ( << )
can't be used.
Julien proposed ( @@ ).

However I saw it was used this way :

let rec ( @@ ) l1 l2 = List.rev_append l1 l2;;  ( Why rec ? )

here :
http://sourceforge.net/project/showfiles.php?group_id=178291

  It would be useful that experimented OCaml people suggest a replacement for the heavily used composition operator ( << ) that is now reserved for camlp4...

 Regards,

Fabrice

Re: [Caml-list] Having '<<', why to use '|>' ?

[Vincent Aravantinos]

Le 19 sept. 07 à 21:49, Fabrice Marchant a écrit :

> On Tue, 18 Sep 2007 17:42:27 +0100
> Jon Harrop <jon@ffconsultancy.com> wrote:
>
>>> A 3 chars operator (<<<) doesn't look smart.
>> That is actually the F# for lsl. There are also ||| and &&& for  
>> bitwise ops.
>
>   Thanks Jon, happy to read you,
>
>  So, do you think that (<<<) could replace (<<) as a function  
> composition operator ?
>
>>> However, about (@@), I preferred to see the direction of the  
>>> asymmetric
>>> composition operator. ( <| ) instead of ( << ) ? Is this a  
>>> possible idea ?
>
>> But "<<" is the converse of ">>" (in F#) and "|>" has no converse  
>> (or you
>> could say that "x |> f" is the converse of "f x").
>
> Things must keep consistent, you're right. So, ( <| ) instead of  
> ( << )
> can't be used.
> Julien proposed ( @@ ).
>
> However I saw it was used this way :
>
> let rec ( @@ ) l1 l2 = List.rev_append l1 l2;;  ( Why rec ? )
>
> here :
> http://sourceforge.net/project/showfiles.php?group_id=178291
>
>   It would be useful that experimented OCaml people suggest a  
> replacement for the heavily used composition operator ( << ) that  
> is now reserved for camlp4...

And how about (<<-) or (<--) ?

Cheers,
Vincent

Re: [Caml-list] Having '<<', why to use '|>' ?

[Ashish Agarwal]

[-- Attachment #1: Type: text/plain, Size: 370 bytes --]

>   It would be useful that experimented OCaml people suggest a replacement
for the heavily used composition operator ( << ) that is now reserved for
camlp4...

After reading all your posts and all previous posts I could find, I've
started using (<--) and (-->), but I also wish there was an agreed upon
notation for this. I have no confidence that my choices are good.

[-- Attachment #2: Type: text/html, Size: 423 bytes --]

Re: [Caml-list] Having '<<', why to use '|>' ?

[Gabriel Kerneis]

[-- Attachment #1: Type: text/plain, Size: 597 bytes --]

Le Thu, 20 Sep 2007 09:42:02 -0400, "Ashish Agarwal"
<agarwal1975@gmail.com> a écrit :
> >   It would be useful that experimented OCaml people suggest a
> > replacement
> for the heavily used composition operator ( << ) that is now reserved
> for camlp4...
> 
> After reading all your posts and all previous posts I could find, I've
> started using (<--) and (-->), but I also wish there was an agreed
> upon notation for this. I have no confidence that my choices are good.

<-- is already used in pa_monad (but it might not be a problem for you).

Regards,
-- 
Gabriel Kerneis


[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 189 bytes --]

RE: [Caml-list] Having '<<', why to use '|>' ?

[Harrison, John R]

[-- Attachment #1: Type: text/plain, Size: 983 bytes --]

Another possibility: I've used "f ** g" for function composition of "f"
and "g"

in some of my code. It seems quite intuitive to me, a sort of
multiplication

operation in the "monoid" of functions. Maybe people accustomed to using

"**" for the power function will find it weird, though.

 

John.

 

________________________________

From: caml-list-bounces@yquem.inria.fr
[mailto:caml-list-bounces@yquem.inria.fr] On Behalf Of Ashish Agarwal
Sent: Thursday, September 20, 2007 6:42 AM
To: caml-list@yquem.inria.fr
Subject: Re: [Caml-list] Having '<<', why to use '|>' ?

 

>   It would be useful that experimented OCaml people suggest a
replacement for the heavily used composition operator ( << ) that is now
reserved for camlp4...

After reading all your posts and all previous posts I could find, I've
started using (<--) and (-->), but I also wish there was an agreed upon
notation for this. I have no confidence that my choices are good.


[-- Attachment #2: Type: text/html, Size: 4268 bytes --]

Re: [Caml-list] Having '<<', why to use '|>' ?

[Karl Zilles]

Harrison, John R wrote:
> Another possibility: I’ve used “f ** g” for function composition of
> “f” and “g”

I tend to use that during a hard debugging session.  As in, "The f*****g 
function still doesn't work!"

Re: [Caml-list] Having '<<', why to use '|>' ?

[Aaron Bohannon]

It's too bad that $ is reserved for Camlp4.  It would be a natural
choice for infix application since that's what Haskell uses.

I have used the following notations for function composition in the past:

let ( |> ) f g x = g (f x)
let ( <| ) f g x = f (g x)

I am glad that those are natural to other people, too.  I also like to
be able to compose predicate functions.  Does anyone have better ideas
than what is below?

let ( &&& ) p q x = p x && q x
let ( ||| ) p q x = p x || q x
let ( !!! ) p x = not (p x)

One can also define "%" to do Python-esque string construction,
although using it with more than one argument requires a nice operator
for infix application.

let ( % ) f x = Format.sprintf f x

"(%c, %n, %s, %b)" % 'a' @@ 12 @@ "hello" @@ true

"@@" isn't looking so nice to me here.

And an operator that is very useful (almost essential) in certain
situations is a monadic "bind" in the list monad:

let ( >>@ ) xs f = List.flatten (List.map f xs)

I chose "@" as a reference to the list concatenation operator.

Are there any others?  Are there better ideas or warnings about the
ones I have here?

-Aaron

> ---------- Forwarded message ----------
> From: Fabrice Marchant <fabrice.marchant@orange.fr>
> To: caml-list@yquem.inria.fr
> Date: Tue, 18 Sep 2007 16:12:46 +0200
> Subject: Re: [Caml-list] Having '<<', why to use '|>' ?
>   Thanks Julien !
>
> > Have a look at this:
> >       http://caml.inria.fr/pub/docs/manual-ocaml/lex.html#infix-symbol
> > With the keywords below.
> "Note that the following identifiers are keywords of the Camlp4 extensions and should be avoided for compatibility reasons.
>
>     parser    <<    <:    >>    $     $$    $:
> "
> So no doubt, I'll edit my old programs and replace "<<".
>
> > > ... a composition operator ... ( <<< ) ?
> > > What else ?
>
> > I would personally double the '@':
> >       let (@@) f g x = f @ g x
>
>  ( or f (g x) : it is practically the same thing. )
>
> A 3 chars operator (<<<) doesn't look smart. Simpler is better.
> However, about (@@), I preferred to see the direction of the asymmetric composition operator.
> ( <| ) instead of ( << ) ? Is this a possible idea ?
>
>   But maybe your idea is good. Maths use a kind of small 'o' : (f o g) (x) = f (g (x)).
> It's symmetric like (@@), and that doesn't raise any problem.
>
> Cheers,
>
> Fabrice

Re: [Caml-list] Having '<<', why to use '|>' ?

[Nicolas Pouillard]

Excerpts from Aaron Bohannon's message of Thu Sep 20 16:39:36 +0200 2007:
> It's too bad that $ is reserved for Camlp4.  It would be a natural
> choice for infix application since that's what Haskell uses.

The  old  and  deprecated  `&' operator do perfectly the job. Indeed the OCaml
`&'  operator have the associativity and a precedence close to the Haskell `$'
than what can do the OCaml `$'.

For some more information: http://caml.inria.fr/mantis/view.php?id=2415

> I have used the following notations for function composition in the past:
> 
> let ( |> ) f g x = g (f x)
> let ( <| ) f g x = f (g x)
> 
> I am glad that those are natural to other people, too.  I also like to
> be able to compose predicate functions.  Does anyone have better ideas
> than what is below?
> 
> let ( &&& ) p q x = p x && q x
> let ( ||| ) p q x = p x || q x
> let ( !!! ) p x = not (p x)
> 
> One can also define "%" to do Python-esque string construction,
> although using it with more than one argument requires a nice operator
> for infix application.
> 
> let ( % ) f x = Format.sprintf f x
> 
> "(%c, %n, %s, %b)" % 'a' @@ 12 @@ "hello" @@ true
> 
> "@@" isn't looking so nice to me here.
> 
> And an operator that is very useful (almost essential) in certain
> situations is a monadic "bind" in the list monad:
> 
> let ( >>@ ) xs f = List.flatten (List.map f xs)
> 
> I chose "@" as a reference to the list concatenation operator.
> 
> Are there any others?  Are there better ideas or warnings about the
> ones I have here?
> 
> -Aaron
> 
> > ---------- Forwarded message ----------
> > From: Fabrice Marchant <fabrice.marchant@orange.fr>
> > To: caml-list@yquem.inria.fr
> > Date: Tue, 18 Sep 2007 16:12:46 +0200
> > Subject: Re: [Caml-list] Having '<<', why to use '|>' ?
> >   Thanks Julien !
> >
> > > Have a look at this:
> > >       http://caml.inria.fr/pub/docs/manual-ocaml/lex.html#infix-symbol
> > > With the keywords below.
> > "Note that the following identifiers are keywords of the Camlp4 extensions and should be avoided for compatibility reasons.
> >
> >     parser    <<    <:    >>    $     $$    $:
> > "
> > So no doubt, I'll edit my old programs and replace "<<".
> >
> > > > ... a composition operator ... ( <<< ) ?
> > > > What else ?
> >
> > > I would personally double the '@':
> > >       let (@@) f g x = f @ g x
> >
> >  ( or f (g x) : it is practically the same thing. )
> >
> > A 3 chars operator (<<<) doesn't look smart. Simpler is better.
> > However, about (@@), I preferred to see the direction of the asymmetric composition operator.
> > ( <| ) instead of ( << ) ? Is this a possible idea ?
> >
> >   But maybe your idea is good. Maths use a kind of small 'o' : (f o g) (x) = f (g (x)).
> > It's symmetric like (@@), and that doesn't raise any problem.
> >
> > Cheers,
> >
> > Fabrice
> 

-- 
Nicolas Pouillard aka Ertai

Re: [Caml-list] Having '<<', why to use '|>' ?

[Daniel Bünzli]

Le 22 sept. 07 à 17:22, Nicolas Pouillard a écrit :

> The  old  and  deprecated  `&' operator do perfectly the job.  
> Indeed the OCaml
> `&'  operator have the associativity and a precedence close to the  
> Haskell `$'
> than what can do the OCaml `$'.

The problem is that jocaml recycles it.

Daniel

Re: [Caml-list] Having '<<', why to use '|>' ?

[Christian Stork]

On Sat, Sep 22, 2007 at 05:43:54PM +0200, Daniel Bünzli wrote:
> 
> Le 22 sept. 07 à 17:22, Nicolas Pouillard a écrit :
> 
> >The  old  and  deprecated  `&' operator do perfectly the job.  
> >Indeed the OCaml
> >`&'  operator have the associativity and a precedence close to the  
> >Haskell `$'
> >than what can do the OCaml `$'.
> 
> The problem is that jocaml recycles it.

Not only that, but why not strive for compatibility with F#'s operators?
The F# developers thought this through and made reasonable choices,
afaict.  Indeed is there any reason why one couldn't come up with a
camlp4 extension that emulates all of the operators that F# offers by
default?

-- 
Chris Stork   <>  Support eff.org!  <>   http://www.ics.uci.edu/~cstork/
OpenPGP fingerprint:  B08B 602C C806 C492 D069  021E 41F3 8C8D 50F9 CA2F