Each Operator (∘.) on Empty Arrays: Undefined Behavior?

Answer

In APL the each operator (∘.) is a *reduction‑like* operator that applies a function to every element of an array. When the input array is empty (⍬), the language itself does not prescribe a single result. The ISO/IEC 13751 standard only specifies that *reduction* operators on empty arrays should use an identity element, but it does not extend that rule to the each operator. Consequently, the outcome is implementation‑defined.

Common Implementation Behaviors

• Dyalog APL 18/19: ∘.f¨ ⍬ returns an empty array with the prototype of the function’s output. The shape is ⍴⍬ (0 elements) and the type matches the function’s return type. No error is raised.
• GNU APL 5.x: Behaves like Dyalog in that it produces an empty result. The prototype is the same as the function’s output, but the fill element (if the function uses one) may default to the interpreter’s generic fill value.
• APL2 (IBM): If the function f expects at least one argument, APL2 raises a DOMAIN ERROR when applied to ⍬. If f can be invoked with zero arguments (e.g., an identity function), it returns an empty array of the expected shape.
• NARS2000 & other nested‑array dialects: The result may be a nested empty array whose depth is determined by the function’s output signature. For a simple scalar function it will be ⍬, but for a function returning a vector it may be ⍬⍬.
• ISO/IEC 13751: Provides no explicit rule for each on empty arrays, so each implementation may choose its own convention. The standard does, however, require that the result be an array of the same rank as the input.

Why the Difference Matters

When porting code that uses ∘. across dialects, assuming a consistent scalar, vector, or error result can lead to subtle bugs. For example, a function that relies on the identity element of a numeric array will work in Dyalog but fail in APL2 if the empty case is not handled explicitly.

Practical Verification Steps

1. Choose the function you want to apply. For a simple test use f←{⍵+1}.
2. Run the expression in your interpreter:

   ⍝ Dyalog or GNU APL
   ∘.f¨ ⍬
   

3. Inspect the result’s shape, prototype, and value with:

   ⍴⍬   ⍝ should be 0
   ⎕PW   ⍝ prototype (type)
   ⎕FMT   ⍝ format string for debugging
   

4. If you get an error, check whether the function requires a non‑empty argument (e.g., {⍵⍵} will error on ⍬).
5. Document the behavior for the target dialect and guard against it in ported code, e.g.:

   empty←⍬
   result←∘.f¨ empty
   ⍝ If result is empty, use a default value
   

Missing Diagnostic Detail

To give a more precise recommendation, it would help to know the function being applied (e.g., does it have side effects, does it require a non‑empty argument, does it return a scalar or vector?). If you can provide that, we can refine the guidance for your specific case.