Re: [Bug-apl] Suggestion: Support multi-line lambda functions

[Juergen Sauermann]

Hi Elias,

there are reasons why ◊ (and multi-line lambdas) are not supported in GNU APL.

In GNU APL lambdas are implemented as user-defined functions and they follow
the same syntax and other rules as user-defined functions. For example (GNU APL):

      (A B C) ← 1 2 3
      FOO←{ A B C ⍵}
      FOO 42
1 2 3 42

At this point GNU APL and Dyalog give the same result. And in GNU APL we get:

      ⎕CR 'FOO'
λ←FOO ⍵  
λ← A B C ⍵

which shows how lambdas are turned into regular user-defined functions.

But now look at this (hypothetical example as far as GNU APL is concerned).

      (A B C) ← 1 2 3
      FOO←{ A ◊ B ◊ C ⍵}
      FOO 42

In GNU APL we would get either

      ⎕CR 'FOO'
λ←FOO ⍵      
λ←A ◊ B ◊ C ⍵

or maybe:

      ⎕CR 'FOO'
λ←FOO ⍵      
A ◊ B ◊ λ←C ⍵

Even though we cannot do

      FOO←{ A ◊ B ◊ C ⍵}

in GNU APL, we can create the corresponding user-defined functions manually:

      ⎕CR 'FOO'
λ←FOO ⍵      
λ← A ◊ B ◊ C ⍵

      FOO 42
2
3 42
1

or maybe:

      ⎕CR 'FOO'
λ←FOO ⍵      
λ← A ◊ B ◊ C ⍵
A ◊ B ◊ λ←C ⍵

      FOO 42
2
3 42
1
2
3 42

And now compare that with Dyalog (as per tryAPL):

      FOO 42
1

The reason for this is that Dyalog APL has different rules for multi-statements and multi-lines
in lambdas than for the same APL statements and lines in user-defined functions. As it looks,
a Dyalog lambda returns when the first statement has a (non-committed ?) value while a
user-defined function (with the exact same statements and lines) returns after the last line (or after  →0).

I personally believe that having two functions that look the same but behave differently depending
on how they were created is a BAD THING. It would also create problems with )LOADing and
)SAVEing workspaces because, as far as I remember, the ⎕FX of functions is stored in those files.

-----------------------------------------

I have also discussed the lambda matter with Morten Kromberg of Dyalog last year.

The starting point of the discussion was basically Morten's proposal to remove lamdas from
GNU APL completely, an my equally keen counter-proposal that Dyalog makes lambdas
compatible with user-defined functions.

Obviously, none of the proposals was feasible without breaking the backward-compatibility of the
affected APL interpreter. And of course each of us would expect the other to change his interpreter.

However, we could agree that having incompatible lambdas in GNU APL and Dyalog would be even
 worse, and since multi-statement and multi-lines were present in Dyalog lambdas, but not in GNU APL,
I promised to Morten that I will not develop lambdas in GNU APL any further.

And so be it.

/// Jürgen

On 05/09/2016 06:57 AM, Elias Mårtenson wrote:

It seems as though using the foo←{...} style of writing functions is quite popular in the Dyalog community.

An example file written in this style can be found here: https://github.com/mattcunningham/apl-bayesian-classifier/blob/master/bayes.full.apl

As we can see, functions are declared in this style:

      foo ← {

          x ← 1+⍵

          y ← 1+⍺

          x+y

      }

I'd like to see this being supported in GNU APL as well.

Related, I'd like to be able to use ◊ inside a lambda function. Whenever I port a function from Dyalog I end up having to rewrite these using ⊣ and ⊢, which is not hard but feels arbitrary. Right now ◊ doesnt work at all in lambdas, so adding support for it shouldn't cause any compatibility issues with APL2.

Regards,

Elias