Rimescolamento del carico

Benvenuto in Factor! Factor è un linguaggio concatenativo: invece di chiamare funzioni come square(add(2, 3)), scrivi una sequenza di parole da sinistra a destra, 2 3 + square, che si passano i valori tra loro attraverso uno stack di dati condiviso. Immagina una pila di casse di merci su una banchina, con le più recenti in cima.

Commenti

Un ! avvia un commento di riga: Factor ignora tutto da ! fino alla fine della riga. Gli esempi qui sotto usano ! per annotare cosa fa il codice.

Lo stack di dati

Scrivere un letterale lo spinge in cima allo stack. Il codice si legge da sinistra a destra.

1 2 3    ! stack (bottom → top): 1 2 3

Ogni parola legge i suoi input dalla cima dello stack e riscrive lì i suoi output. . preleva il valore in cima e lo stampa. .s stampa lo stack intero senza consumare nulla: è utile per vedere cosa ha lasciato dietro di sé un frammento di codice.

Effetti sullo stack

Ogni parola è documentata con un effetto sullo stack nella forma ( inputs -- outputs ). È il contratto della parola: la parola preleva gli input dalla cima dello stack e lascia gli output al loro posto. I nomi all'interno sono documentazione per gli esseri umani: lo stack in sé è posizionale, non ha nomi. La cima dello stack è il nome più a destra.

Definire una parola

: avvia la definizione di una parola, poi viene l'effetto sullo stack, poi il corpo, e infine ; la chiude. Il compilatore di Factor controlla che il corpo lasci davvero quello che l'effetto sullo stack dichiara.

: restow ( a b -- b a ) swap ;

Parole di riordino

Queste parole del kernel riordinano la cima dello stack senza fare alcuna aritmetica: spostano solo le casse qua e là.

dup  ( x   -- x x   )    ! copy the top crate
drop ( x   --       )    ! remove the top crate
swap ( x y -- y x   )    ! flip the top two
over ( x y -- x y x )    ! copy the second crate onto the top
nip  ( x y -- y     )    ! remove the second crate
rot  ( x y z -- y z x )  ! roll the third crate up to the top

Ricorri a dup quando una cassa deve alimentare due parole, a drop per buttare via una cassa, a swap quando le prime due sono nell'ordine sbagliato, a over o nip per lavorare con la cassa sottostante, e a rot per portare in cima una cassa sepolta.

La famiglia più ampia (-rot, dupd, swapd, 2dup, …) segue la stessa idea. Incontrerai quelle parole più avanti.

Come si compongono le parole

Le parole scritte di seguito vengono eseguite da sinistra a destra: ogni parola agisce sullo stack lasciato dalla parola precedente. Ecco cosa fa swap nip allo stack 1 2 (dal basso verso l'alto), una parola alla volta:

1 2     ! 1 2     the starting crates
swap    ! 2 1     swap flipped the top two
nip     ! 1       nip dropped the 2nd-from-top crate (the 2)

E ora dup rot sulle stesse casse di partenza, sempre una parola alla volta:

1 2     ! 1 2     the starting crates
dup     ! 1 2 2   dup copied the top crate
rot     ! 2 2 1   rot rolled the 3rd-from-top crate up to the top

Convenzioni di denominazione

Le parole usano il lowercase-kebab-case: lettere minuscole unite da trattini.

Tour: il riordino dello stack