Per le word brevi va bene destreggiarsi con lo stack. Quando una word ha diversi input e devi riferirti a ciascuno per nome, Factor offre i locals: binding con nome introdotti con :: (per le definizioni di word) o [| | ] (per le lambda inline).
Sostituisci : con :: e i nomi degli input diventano variabili locali nel corpo:
USING: locals ;
:: hypotenuse ( a b -- c )
a a *
b b *
+ sqrt ;
Confronta con la versione che destreggia lo stack:
! DOCTEST: SKIP (shown for comparison — would re-define hypotenuse)
: hypotenuse ( a b -- c )
[ sq ] bi@ + sqrt ;
Entrambe sono valide: i locals danno il meglio quando a un input si fa riferimento più di una volta o quando l'ordine delle operazioni non coincide naturalmente con l'ordine dello stack.
Associare valori intermedi con :>
All'interno di un corpo :: (o di una lambda inline [| ... |]), :> estrae un valore dallo stack dati e lo associa a un nuovo local:
value :> name ! immutable binding
value :> name! ! mutable binding (name! is its setter)
La forma immutabile è quella più comune: usala per dare un nome a un valore intermedio, così il corpo si legge dall'alto verso il basso:
USING: locals math ;
:: average-3 ( x y z -- avg )
x y + z + :> sum
sum 3 / ;
La variante con ! dichiara il local come mutabile; più avanti nel corpo, value name! (senza i due punti, senza :>) lo riassegna:
USING: kernel locals math math.order ;
:: clamped ( x lo hi -- y )
x :> v!
v lo < [ lo v! ] when
v hi > [ hi v! ] when
v ;
I locals mutabili danno il meglio all'interno delle word di iterazione che incontrerai negli esercizi successivi (ad esempio while).
[let: uno scope da qualsiasi punto
:> funziona solo all'interno di uno scope lessicale, che :: e [| ... |] creano automaticamente. Per introdurre locals da una word : semplice o dal listener, avvolgi il codice in [let ... ]:
[let code :> name code :> name ... body ]
Ogni :> name associa il valore in cima allo stack dell'espressione precedente; i binding sono visibili al resto della forma.
USING: locals math ;
[let 3 :> x 4 :> y x x * y y * + ] . ! => 25
[let è il ponte tra le definizioni : in stile stack e i binding con nome: torna utile quando solo una parte di una word trae vantaggio dai locals.
Lambda: [| inputs | body ]
All'interno di una quotation, [| inputs | body ] introduce dei locals a cui il corpo può riferirsi per nome. È particolarmente utile con le word di ordine superiore come assoc-map, la cui quotation riceve sia key sia value:
USING: assocs locals ;
H{ { "a" 1 } { "b" 2 } }
[| key value | key value neg ] assoc-map .
! => H{ { "a" -1 } { "b" -2 } }
La stessa forma funziona con map-index (in [sequences][sequences]), la cui quotation riceve sia l'elemento sia il suo indice. I nomi chiariscono quale operando svolge quale ruolo:
USING: locals sequences ;
! Divide each element by its 1-based position:
{ 10 80 270 } [| elt i | elt i 1 + / ] map-index .
! => { 10 40 90 }
L'effetto stack della lambda è determinato dalla lista degli input e da ciò che produce il suo corpo.
Quando usare i locals
Ricorri ai locals quando:
- Lo stesso input viene usato in più di un punto.
- L'ordine naturale delle operazioni non coincide con l'ordine dello stack, e il
dup/swap/rot necessario per sistemarlo è difficile da leggere.
- Ti trovi dentro una lambda inline passata a una word di ordine superiore che ti fornisce più valori in una volta sola (come in
assoc-map).
Quando il corpo è un flusso lineare e pulito, le definizioni : semplici restano più brevi e almeno altrettanto leggibili.
assoc-map: una voce alla volta
assoc-map (in assocs) applica una quotation a ogni voce di una collezione associativa:
assoc-map ( assoc quot: ( key value -- newkey newvalue ) -- newassoc )
Una lambda con locals è il modo più pulito per scrivere la quotation.
Torniamo su cond
Quando devi distinguere in base a f o a un valore numerico, cond è esattamente la forma giusta: non serve case, perché non c'è un singolo valore con cui confrontarsi.
Esercizio di apprendimento
