Defaulting left arguments in ambivalent trad-fns

[norbertjurkiewicz84]

It may be useful to have a cleaner way of defaulting ambivalent trad-fn left arguments...


The ability to default a Dfns argument is a very powerful feature.

      root←{      ⍝ ⍺th root
          ⍺←2     ⍝ default to sqrt
          ⍵*÷⍺
      }

Traditional functions need a bit of :if logic to accomplish the same result, unless there's a feature I'm not aware of...

      Z←{lArg}TestFoo rArg
 :If 0=⎕NC'lArg'
     lArg←1
 :EndIf
 Z←lArg+rArg

It would be nice to have dfn like syntax or maybe an I-Beam to get the same functionality.

An I-beam can to accomplish this. Here the I-Beam passes the value of lArg, if available, or it's right argument.

      lArg←(10⌶'lAarg')123

Even better, the I-Beam can be aware of its scope and default to the left argument.

      lArg←10⌶123

The cleanest would be a quad function along these lines...

      lArg←⎕DEFAULT 123

or

      Z←{lArg}TestFoo rArg 
 lArg←⎕DEFAULT 123
 Z←lArg+rArg

The new 900 I-beam is useful to determine if the value was an argument or defaulted.

      Z←{lArg}TestFoo rArg
 lArg←⎕DEFAULT 123             
 Z←'Default: ',(900⌶⍬)⊃'No' 'Yes'

[Phil Last]

Lots of tried and tested methods without if-then-else or conditional execute but not necessarily more elegant or less clumsy.

      r←{a} f00 w
  a←'a'{6::⍵ ⋄ ⍎⍺}'this'

after which a is as supplied or 'this'.

      r←{a} f01 w
  z←⎕FX'r←a w' 'r←w'

after which a is as supplied or equiv to ⊢
so to use a we do

      larg←a⊣'this'

after which larg is a as supplied or 'this'
or to pass on its ambivalence to a called function we do

      res←a f02 ...

after which f02 has the same problem.

After my response to a post in an early Vector similar to the ⎕FX solution above Maurice Jordan suggested:

      r←[a] f03 w

after which a is as supplied or is ⊢

Some have suggested

      r←[a←expr...] f04 w

after which a is as supplied or the result of executing the expression in brackets.

Others have pointed out how dangerous and/or impossible this would be to implement.

Any more for any more?

[JohnS|Dyalog]

I like Maurice's:

      r←[a] f03 w

Where a missing [a] is assigned ⊢.

For example:

      ∇ z←[nth] root m
[1]   z←m*÷nth⊣2
    ∇
      root 64  ⍝ default: square root
8
    3 root 64  ⍝ cube root
4

      monadic←2≠⎕nc'larg'  ⍝ explicit test for monadic call 
      monadic←⊃0 larg⊣1    ⍝ alternative idiom for monadic call

One problem with the more complicated syntax:

      r←[a←expr...] f04 w

is that it makes it difficult to do any preamble, such as computing values to be used in expr. Imposing the restriction that expr may only be a "constant" doesn't quite fly because you often want a 1-item vector or a 0-row matrix, etc. Plus, if there's an error in expr, suspending on line[0] might be a bit strange.

[Phil Last]

      monadic←2≠⎕nc'larg'  ⍝ explicit test for monadic call 
      monadic←⊃0 larg⊣1    ⍝ alternative idiom for monadic call

      monadic←1≡larg 1       ⍝ alternative⍣2

[petermsiegel]

APL has a long tradition of preprocessors (mostly leading to implementation of new "core" features). I wrote one a while back that I use in tradfns and dfns. One feature uses double-dot notation for a number of manipulations with names on the left, including this:

name..⍺←new_value ⍝ new_value is everything to the right that's in scope

which for any name returns its value if set, and sets it to and returns new_value otherwise. It doesn't work quite like the dfns ⍺ (insofar as new_value is always executed), but it could and SHOULD (I just didn't need it, mea culpa).

When the surrounding function is FiXed, the preprocessor simply replaces the pattern above by the requisite APL code to test ⎕NC 'name'. Similarly name..⍺ new_value returns the value of name or new_value, without setting name. Some folks may dislike preprocessors (they create and solve problems); that's ok: I built the preprocessor to test out new features, including things like "cut", before they enter the standard releases, along with things from other languages, like Python or C: continuation lines, simple macros, static objects, etc.

[Adam|Dyalog]

My idea is to use a special numeric label, where execution begins if called dyadically:

      r←{nth} root x
      nth←2
      2: r←x*÷nth

[petermsiegel]

Very concise.

NARS 2000 uses (used?) special labels in Trad Fns to handle special entry points:

..... User-defined function/operator prototype entry point (⎕PRO:)
..... User-defined function/operator identity element entry point (⎕ID:)

but for some reason didn't think to do this for ambivalence.

[Adam|Dyalog]

The reason for using a numerical label is that the apparent syntax can be used in dfns too, albeit with a slightly different meaning:

      root←{
          2:⍵*÷⍺
          ⍵*÷2
      }

where the 2 evaluates to true if called dyadically.