Re: [Caml-list] pipe input short syntax idea

["Petter A. Urkedal" <paurkedal@gmail.com>]

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

2015-10-11 3:31 GMT+02:00 Yotam Barnoy <yotambarnoy@gmail.com>:
> Interesting, but seems like overkill to me personally. I'm ok with @@ and |>
> (which already breaks F#'s convention, since @@ would be <| in F#. What's
> the reason we went with @@ instead again?).

I think it's really useful that @@ is right associative.  There was a
post [1] arguing the opposite for Haskell's $, but that presumes we
have a composition operator at a higher precedence level, and that
OCaml transforms it into a plain application, for efficiency.

> Function composition is
> potentially more confusing, and I think keeping it with a consistent
> associativity direction (that being the direction of normal function
> application from right to left) has value. So I'm personally sort-of ok with
> <<, but once you suggest something as beautifully concise as o, I'm
> overwhelmed by the convenience factor.

For composition, associativity wouldn't matter as the operation itself
is associative.  Except from performance.  According to the attached
benchmark, the normal composition operator should be right
associative, at least on my computer.  Then reversed composition
should be left associative.  But it's not a big difference (esp.
considering that most uses are binary or ternary) and I'm not sure
whether it applies across compiler versions.  I expected the opposite
result.

I'm not thrilled about using a single letter o as an operator.  If we
want ∘, we should use that, though some might not like to deal with
input methods.  I've use *< and *> for some time, thinking of * as the
closest cousin of ∘.

[1] https://mail.haskell.org/pipermail/haskell-cafe/2006-February/014237.html

[-- Attachment #2: composition_associativity.ml --]
[-- Type: text/x-ocaml, Size: 572 bytes --]

open Printf
(* open Infix *)

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

let test1 f g =
  f *< g *< f *< g *< f *< g *< f *< g *< f *< g

let test2 f g =
  f **< g **< f **< g **< f **< g **< f **< g **< f **< g

let clock () = Unix.((times ()).tms_utime)

let () =
  let t0 = clock () in
  let x = ref 0 in
  for i = 0 to 1000000 do
    x := test1 succ pred !x
  done;
  let t1 = clock () in
  for i = 0 to 1000000 do
    x := test2 succ pred !x
  done;
  let t2 = clock () in
  printf "Left associative:  %g\nRight associative: %g\n" (t1 -. t0) (t2 -. t1)