[erlang-questions] Funargs: Ruby-like blocks for Erlang

[Tim Watson]

On 22 July 2011 00:11, Richard O'Keefe <ok@REDACTED> wrote:
>
> On 22/07/2011, at 12:34 AM, Jesper Louis Andersen wrote:
>> TL;DR I don't think we need a new kind of syntax for certain kinds of
>> lambda sections (see the 'cut' proposal a couple of days ago from
>> SRFI-26 in Scheme-land). But I do agree the notation is heavier than
>> it could be. A more convenient notation would encourage people to use
>> anonymous functions more.
>
> The whole of Erlang syntax is "heavier" than it might be.
> I once devised a revised syntax which I called "hErlang".
> For example, this is a hErlang module:
>
> -module predict
> -export (predict/2)
> -import math:(pi/0 sqrt/1)
> -author "Richard A. O'Keefe"
> -date  {2002,08,14}
> -sccs  "08/16/02"
>
> predict X0 Ns =
>    let {Xs,Ys} = odds_and_evens Ns,
>        Np      = length Xs,
>        XBar    = if Np == 0 => 0.0 else sum Xs / Np fi,
>        YBar    = if Np == 0 => 0.0 else sum Ys / Np fi,
>        Beta1   = sum [(X-XBar)*(Y-YBar) for X,Y in Xs,Ys] /
>                  sum [(X-XBar)*(X-XBar) for X   in Xs],
>        Beta0   = YBar - Beta1*XBar,
>        S       = sqrt((sum [(Y-Beta1*X-Beta0)^2 for X,Y in Xs,Ys])/(Np-2)),
>        R       = sqrt((Np+1)/Np + (X-XBar)^2/sum [(X-XBar)^2 for X in Xs]),
>        T70     = S * R * tfun 0.85 (Np-2),
>        T90     = S * R * tfun 0.95 (Np-2),
>        Y0      = Beta1*X0+Beta0
>    in {Y-T90,Y-T70,Y,Y+T70,Y+T90}
>
> odds_and_evens [X,Y|XYs] = let {Xs,Ys} = odds_and_evens XYs in {[X|Xs],[Y|Ys]}
> odds_and_evens _         = {[],[]}
>
> tfun Goal N =
>    let G = (Goal-0.5) * (gam N / gam (N+1)) * sqrt (pi() * N),
>        F = \X. (1+X*X/N)^(-0.5*(N+1))
>    in bsearch F G 1.0 8.0
>
> gam 1 = sqrt (pi())
> gam 2 = 1.0
> gam (K+2) = (K/2.0) * gam K
>
> bsearch F G Lo Hi | Hi-Lo <= 0.5e-6 = (Lo+Hi)*0.5
>  = let M = (Lo + Hi) * 0.5,
>        S = simpson F 0 M 1.0e-5 10 0.0
>    in  if S < G  => bsearch F G M Hi
>        or S >= G => bsearch F G Lo M fi
>
> simpson F X0 X1 Eps N R0 = % 2 'where' lines shorter.
>    let W = (X1 - X0) / (2 * N),
>        R = ( 4.0 * sum [F(X0 + W * (2*I-1)) for I in [1..N]]
>            + 2.0 * sum [F(X0 + W * (2*I)  ) for I in [1..N-1]]
>            + F X0 + F X1 ) * (W/3.0)
>    in if abs (R-R0) <= Eps => R else simpson F X0 X1 Eps (N*2) R fi
>
> It looks a lot like Haskell, but it's Erlang semantics all the way.
> Not unlike LFE, in fact.
>
> I never bothered finishing this, so don't ask for the code.
> I just took it far enough to determine that the thing *could* be
> done and *did* produce a useful payoff (my test files were about
> 1/3rd shorter than normal Erlang).  But incorporating records and
> binary patterns and all the other things seemed too much like work.
>
> So a syntactically leaner Erlang *is* possible.  The one thing I
> found in that experiment that's really important here is that you
> CAN'T get there from here one step at a time.  To make a really
> lean Erlang, you *have* to take a great big jump to a coherently
> designed whole.
>

That actually looks really nice.