Assignment

Naming values, changing parts of arrays, and destructuring

← assigns the value to its right to the target, the run just before it. Besides plain names, a target can be a selection, a dot path, a subscript or a list of names. With a function just before ←, as in x+←1, the assignment is modified. For the exact rules, see Assign and Syntax.

Plain assignment

x←Y binds x to Y and returns Y without displaying it:

x←3
x+2

A value can be a function, such as +/:

sum←+/
sum 1 2 3

Assignments chain:

a←b←3
a+b

Put independent assignments on separate lines or between ⋄, because ← takes everything to its right:

p←1 q←2
p

1 2

The name _ discards a value. _←Y evaluates Y and keeps nothing.

Modified assignment

x f←Y sets x to x f Y:

x+←3
x

Any function works, such as , to append:

s←"abc"
s,←"d"
s

abcd

A named function goes in parentheses, as x(f)←Y. In x f←Y, the target would be f:

f←×
x(f)←4
x

With nothing after the arrow, modified assignment applies the function to the target alone. x⌽← sets x to ⌽x:

x←1 2 3
x⌽←
x

3 2 1

Assigning to part of an array

A subscript target replaces one literal position:

v←1 2 3
v₁←9
v

1 9 3

Dot brackets name any positions, in plain or modified assignment:

v.[[0 2]]+←10
v

11 9 13

Any other selection goes in parentheses, with a function that only selects or rearranges, as for structural Under:

(2↑v)←8 9
v

8 9 13

The selection can apply a function with rank. 0⌷⍤1 selects the first item of each row:

M←[1 2
   3 4]
(0⌷⍤1 M)←9
M

9 2
9 4

A dot path writes a field of a record:

T←["n":1]
T.n+←1
T.n

A plain assignment to a dot path creates any missing records along the path:

T.addr.city←"SF"
T

["n":2 "addr":["city":"SF"]]

A subscript can follow a dot path:

T.a←1 2
T.a₁←7
T.a

1 7

Inverses and derivatives

A function’s name followed by ⁻¹ is a target for its inverse. f⁻¹←g attaches g as the inverse of the function f names. f⁻¹, negative powers and Under then call g:

inc←{⍵+1}
inc⁻¹←{⍵-1}
inc⍣¯2⊢5

f∂←g attaches g as the derivative, which ∂ and ⇄ call. g is a JVP rule: t g x gives the derivative of f at x along the direction t, and must be linear in t. ∂ calls g wherever it differentiates a call of f:

sq←{⍵×⍵}
sq∂←{⍺×2×⍵}
sq∂3

The function itself still runs when you call it, and each rule stays when you assign the other:

sq⁻¹←{⍵*0.5}
[sq 3;sq∂ 3;sq⁻¹ 9]

9 6 3

Destructuring

A list of names in brackets destructures a value by position:

[a b]←10 20
a+b

Each name takes one major cell of a higher-rank value, such as one row of a matrix:

[top bottom]←2 3⍴⍳6
bottom

3 4 5

A single value goes to every name:

[c d]←5
c d

5 5

A nested list of names destructures a nested value:

[e [g h]]←[1 [2 3]]
h

Modified assignment works on a list of names too:

[a b]+←10
a b

20 30

Inside brackets, every name is a target, even one that holds a function, such as f:

[f n]←1 2
f

A list of names destructures by position even when the value has keys. A pattern takes items by key instead. Each cell of a pattern gives a key, then the name that takes the key’s item, as in [a:x]. A cell with only a key, as in [a:], gives the item to the name spelled like the key. A key is never a value: the a in [a:x] stands for the key "a", whatever a holds. A string key, as in ["first name":n], serves a key that isn’t a name. The cells can come in any order:

[b: a:x]←["a":1 "b":2 "c":3]
x b

1 2

A program takes names from a module this way, as in [disp:]←•load "lib/array.bpl".

Names inside dfns

Inside a dfn, plain assignment makes a local name:

total←0
set←{total←⍵ ⋄ total}
_←set 5
total

Modified and selective assignment, including assigning an inverse or derivative, update the nearest existing binding, even outside the dfn:

add←{total+←⍵ ⋄ total}
_←add 5
total

Arrays have value semantics, as numbers do:

u←1 2
w←u
u₀←9
w

1 2