Quando utilizzare la definizione lambda con un parametro formale "nudo"?

Question

Sto imparando Guile Scheme in questo momento, e nella documentazione ho improvvisamente corse in seguito costruzione:

((lambda args (display args)) 42) 
=> (42) 

Questo mi ha buttato per un ciclo; fino a questo punto avevo parametri formali assunti erano sempre racchiuso in un elenco:

((lambda (args) (display args)) 42) 
=> 42 

Mi chiedo quando usare questa variante, e come questo si differenzia dalla notazione del punto per un numero variabile di argomenti. In particolare, qual è la differenza tra le due seguenti varianti:

((lambda args (display args)) 1 2 3)  => (1 2 3) 
((lambda (. args) (display args)) 1 2 3) => (1 2 3) 

C'è una differenza - forse per esempi più complessi - che ho bisogno di essere a conoscenza e v'è alcuna ragione per preferire uno sopra l'altro?

Answer 1

La differenza è che questa versione riceve un unico parametro chiamato args, utile per i casi in cui si conosce esattamente il numero di argomenti effettivi previsti per il lambda modulo:

(lambda (args) (display args)) 

E questa versione riceve una (possibilmente vuoto) lista di parametri, chiamato args, utile quando ci si aspetta un numero variabile di argomenti per la forma lambda:

(lambda args (display args)) 

Non ci dovrebbe essere alcuna differenza tra le seguenti due versioni, ma non tutti gli interpreti accetterà il secondo, dal momento che manca la parte prima del punto (quindi dovrebbe essere evitato):

(lambda args (display args)) 
(lambda (. args) (display args)) 

La seguente versione è utile quando si desidera specificare che un modulo lambda ha uno o più parametri obbligatori (simboli a sinistra del punto) e un elenco di zero o più parametri facoltativi (un singolo simbolo a destra del punto):

(lambda (mandadory1 mandatory2 . optional) (display mandatory1)) 

Answer 2

Questo mi ha buttato per sempre oop; fino a questo punto avevo parametri formali assunti erano sempre racchiuso in un elenco:

Nota che le cose come (a . args) e (a b . args) non sono liste realmente sia. (a . args) è una coppia in cui il car è il simbolo a e il cdr è il simbolo args. (a b . args) è una coppia in cui il car è il simbolo a e lo cdr è (una coppia in cui lo car è il simbolo e lo cdr è il simbolo args). Sembra un po 'come una lista per un po', con il a e b e che, ma come non finisce in null/la lista vuota non è davvero una lista corretta. Strutture come quella sono spesso chiamate liste improprie. Se si vuole, si può leggere un po 'la tratteggiata coppia notazione here, o da qualche altra parte ...

Con (. args) mi piacerebbe forse dire qualcosa come "si tratta di una coppia in cui il cdr è il simbolo args".O forse sarebbe venuto fuori come "un paio in cui lo car è e lo cdr è args". In ogni caso, non avrebbe molto senso e, come ha detto Chris Jester-Young, non è uno schema valido.

Così. Cose come (a b . args) sono solo normali notazioni a coppie puntate per mettere cose che non sono nulle nell'ultimo cdr. Se i parametri formali - cosa in Scheme può essere una di quelle liste improprie o una lista appropriata o solo un simbolo, allora la definizione dei parametri formali - cosa deve essere qualcosa di simile: un parametro formale - cosa deve essere nullo, un simbolo, o una coppia in cui lo car è un simbolo e lo cdr è un parametro-cosa formale.

(che penso sia una specie di cosa interessante che rende un modo piuttosto elegante di associare argomenti ai parametri. Come, si guarda la cosa-parametri formale, e se si tratta di un simbolo si associa l'elenco di argomenti a e se si tratta di una coppia si lega lo car degli argomenti allo cdr dei parametri formali-cosa e si ripresenta su cdr dei parametri parametrici-cosa/argomenti (oh e se è nullo si è come fatto o qualcosa del genere). mi sembra un po 'più carino del modo Common Lisp di "e se il simbolo in car è &rest si lega il resto degli argomenti al simbolo dopo quello".)