Fazer malabarismos com a pilha funciona bem para palavras curtas. Quando uma palavra tem vários parâmetros de entrada e precisas de lhes fazer referência pelo nome, o Factor oferece locais: ligações com nome introduzidas com :: (para definições de palavras) ou [| | ] (para lambdas inline).
Substitui : por :: e os nomes dos parâmetros de entrada passam a ser variáveis locais no corpo:
USING: locals ;
:: hypotenuse ( a b -- c )
a a *
b b *
+ sqrt ;
Compara com a versão que baralha a pilha:
! DOCTEST: SKIP (shown for comparison — would re-define hypotenuse)
: hypotenuse ( a b -- c )
[ sq ] bi@ + sqrt ;
Ambas são válidas: os locais brilham quando um parâmetro de entrada é referenciado mais do que uma vez ou quando a ordem das operações não coincide naturalmente com a ordem da pilha.
Ligar valores intermédios com :>
Dentro de um corpo :: (ou de uma lambda inline [| ... |]), :> retira um valor da pilha de dados e liga-o a um novo local:
value :> name ! immutable binding
value :> name! ! mutable binding (name! is its setter)
A forma imutável é a mais comum: usa-a para dar nome a um valor intermédio, de modo a que o corpo se leia de cima para baixo:
USING: locals math ;
:: average-3 ( x y z -- avg )
x y + z + :> sum
sum 3 / ;
A variante com ! declara o local como mutável; mais à frente no corpo, value name! (sem dois pontos, sem :>) reatribui-o:
USING: kernel locals math math.order ;
:: clamped ( x lo hi -- y )
x :> v!
v lo < [ lo v! ] when
v hi > [ hi v! ] when
v ;
Os locais mutáveis brilham dentro das palavras de iteração que vais encontrar em exercícios posteriores (por exemplo, while).
[let: um âmbito a partir de qualquer sítio
O :> só funciona dentro de um âmbito lexical, que :: e [| ... |] criam automaticamente. Para introduzir locais a partir de uma palavra : simples ou no listener, envolve o código em [let ... ]:
[let code :> name code :> name ... body ]
Cada :> name liga o valor no topo da pilha da expressão anterior; as ligações ficam visíveis para o resto da forma.
USING: locals math ;
[let 3 :> x 4 :> y x x * y y * + ] . ! => 25
O [let é a ponte entre as definições : ao estilo da pilha e as ligações com nome: dá jeito quando só uma parte de uma palavra beneficia dos locais.
Lambdas: [| inputs | body ]
Dentro de uma quotation, [| inputs | body ] introduz locais a que o corpo pode fazer referência pelo nome. Isto é especialmente útil com palavras de ordem superior como assoc-map, cuja quotation recebe key e value:
USING: assocs locals ;
H{ { "a" 1 } { "b" 2 } }
[| key value | key value neg ] assoc-map .
! => H{ { "a" -1 } { "b" -2 } }
A mesma forma funciona para map-index (em [sequences][sequences]), cuja quotation recebe o elemento e o seu índice. Os nomes deixam claro qual operando desempenha cada papel:
USING: locals sequences ;
! Divide each element by its 1-based position:
{ 10 80 270 } [| elt i | elt i 1 + / ] map-index .
! => { 10 40 90 }
O efeito na pilha da lambda é determinado pela lista de parâmetros de entrada e pelo que o seu corpo produz.
Quando usar locais
Recorre aos locais quando:
- O mesmo parâmetro de entrada é usado em mais do que um sítio.
- A ordem natural das operações não corresponde à ordem da pilha e o
dup/swap/rot necessário para corrigir isso é difícil de ler.
- Estás dentro de uma lambda inline passada a uma palavra de ordem superior que te entrega vários valores de uma só vez (como em
assoc-map).
Quando o corpo é um fluxo linear simples, as definições : normais continuam mais curtas e pelo menos igualmente legíveis.
assoc-map: uma entrada de cada vez
O assoc-map (em assocs) aplica uma quotation a cada entrada de uma coleção associativa:
assoc-map ( assoc quot: ( key value -- newkey newvalue ) -- newassoc )
Uma lambda com locais é a forma mais limpa de escrever a quotation.
cond revisitado
Quando precisas de escolher o ramo com base em f ou num valor numérico, o cond é exatamente a forma certa: não é preciso case, porque não há um único valor com que comparar.
Exercício de aprendizagem
