Re: [Caml-list] ReasonML concrete syntax

[Gerd Stolpmann <info@gerd-stolpmann.de>]

[-- Attachment #1.1: Type: text/plain, Size: 2563 bytes --]

Hi,

funnily I made similar decision in the programming language I'm
currently developing (because of the commercial background it's closed
source so far, so no pointer). The reasoning is simply that "normal"
people are so used to writing functions with the parenthesized notation
that they do not even recognize functions without. For tuples, there is
a separate notation with square brackets in my language, so no conflict
(you can still write tuplified functions). Another reason is that
notations that do not have a clear syntactical end mark are more
difficult to understand (although, with currified functions this is only
an illusion).

In short, the argument is that f(x1,g(x2,x3)) looks more familiar than f
x1 (g x2 x3).

Personally I dislike that, but I'm not normal, and my language is not
designed for myself.

Gerd


On 10.12.17 19:12, Robert Muller wrote:
> The team developing ReasonML seems to be experimenting with concrete
> syntax in an effort to make it feel as familiar and natural as
> possible to JavaScript programmers. Seems like a good idea. But the
> present version seems to hardwire parentheses awkwardly for function
> definitions and calls. Parentheses are required for both function
> definitions and calls. So one writes
>
> let incr(n) = n + 1       and   incr(5)
>
> but not
>
> let incr n = n + 1        or    incr 5
>
> Fair enough, but for multi-argument functions the parser seems to
> unroll the parenthesized items (both parameters & arguments) to leave
> curried functions. E.g.,
>
> let add(m, n) = m + n  or equivalently let add = (m, n) => m + n
>
> then add(5, 3) is 8 as one would expect. But the (m, n) in let add(m,
> n) = ... isn't a pattern matching a pair, it's the JS-style sequence
> of input parameters and the definition unrolls to let add = (m) => (n)
> => ... . So add(5) : int -> int and all three of add(5, 3), add(5)(3)
> and { let add5 = add(5);  add5(3) } are 8. There's probably a way to
> write an add function of type int * int -> int, but I don't know how
> to write it.
>
> I'm wondering what the OCaml community makes of this. I find it awkward.
> Bob Muller
>
>

-- 
------------------------------------------------------------
Gerd Stolpmann, Darmstadt, Germany    gerd@gerd-stolpmann.de
My OCaml site:          http://www.camlcity.org
Contact details:        http://www.camlcity.org/contact.html
Company homepage:       http://www.gerd-stolpmann.de
------------------------------------------------------------



[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 488 bytes --]