Specifiche di chiamata / cc

Question

Questo è legato a Che cosa è call / cc? , ma non volevo a dirottare questa domanda per i miei scopi, e alcuni dei suoi argomenti, come l'analogia a setjmp / longjmp mi eludere.

Credo di avere un'idea sufficiente su ciò che una continuazione è, ci penso come un'istantanea dello stack di chiamate corrente. Non voglio andare in discussione perché questo potrebbe essere interessante o che cosa si può fare con continuazioni. La mia domanda è più specificamente, perché devo fornire un argomento di funzione da chiamare / cc? Perché non chiamare / cc appena tornare la continuazione corrente, così ho potuto fare quello che mi pare con esso (conservarlo, lo chiamano, è il nome)? In un collegamento da quest'altra domanda ( http: // comunità .schemewiki.org /? call-with-current-continuation per-C-programmatori ), si parla di "Essenzialmente è solo un modo pulito per ottenere la continuazione a voi e tenere fuori del modo di salti successivi ritorna al punto memorizzato. ", ma io non sto ricevendo. Sembra inutilmente complicato.

Answer 1

In comune SO netiquette sto rispondendo alla mia domanda, ma più come l'editor che il fornitore della risposta.

Dopo un po 'ho iniziato una domanda simile sopra a LTU . Dopo tutto, questi sono i ragazzi che meditano il design lingua tutto il giorno, non è vero, e uno dei risposte finalmente calci con me. Ora le cose qui menzionati, per esempio da Eli o nella domanda iniziale, fare molto più senso per me. E 'tutta una questione di ciò che viene incluso nella continuità, e dove la continuazione applicata regola dentro.

Una delle manifesti alla LTU ha scritto:

  

"Si può vedere esattamente come chiamare / cc consente di 'tenere fuori dai piedi'. Con em o ottenere / cc è necessario fare una specie di test per determinare se si dispone di un back-jump o solo l'iniziale chiamare. in sostanza, chiamata / cc mantiene l'uso della continuazione fuori della continuazione, mentre con get / cc o em, la continuazione contiene il suo uso e così (di solito) è necessario aggiungere un test per l'inizio della continuazione (vale a dire subito dopo get / cc / em) per separare il "tramite i particolari continuazione" dal "resto della continuazione" parti ".

che ha spinto a casa per me.

voi ragazzi Grazie comunque!

Answer 2

Se si utilizza un costrutto come Jay mostra, allora si può afferrare la continuazione, ma in un certo senso, il valore che viene afferrato è già rovinato perché sei già dentro che la continuazione. Al contrario, call/cc può essere usato per afferrare la continuazione che è ancora attesa fuori dell'espressione corrente. Per esempio, uno degli usi più semplici di continuazioni è quello di implementare una sorta di abort:

(call/cc (lambda (abort)
           (+ 1 2 (abort 9))))

Non si può fare che con l'operazione che descrivi. Se lo provate:

(define (get-cc) (call/cc values))
(let ([abort (get-cc)]) (+ 1 2 (abort 9)))

allora si ottiene un errore di applicare 9 come una procedura. Questo accade perché abort ritorna al let con il nuovo valore di 9 - il che significa che si sta ora facendo un secondo round della stessa espressione, inoltre, solo che adesso abort è destinato a 9 ...

Due ulteriori note relative:

1. Per una bella un'introduzione pratica per continuazioni, vedere PLAI .
2. call/cc è un po 'complessa in quanto prende in una funzione - un concettualmente più facile da usare costrutto è let/cc che potete trovare in alcune implementazioni, come PLT Scheme. L'esempio di cui sopra diventa (let/cc abort (+ 1 2 (abort 9))).

Answer 3

Questo sarebbe meno versatili. Se si vuole che il comportamento, solo si può fare:

(call/cc (lambda (x) x))

Si potrebbe dare un'occhiata all'esempio usi di continuazioni di "Darrell Ferguson e Dwight Deugo. 'Chiama con attuali modelli continuazione'. 8 ° Conferenza sul modello Lingue dei programmi. Settembre 2001." ( http://library.readscheme.org/page6.html ) e provare a riscrivere la loro utilizzando una chiamata / cc-ritorno, definito come sopra.

Answer 4

Suggerisco a partire da chiederti: che cosa vuol dire essere una continuazione di prima classe

?

La continuazione di espressione è costituito essenzialmente da due parti di dati: in primo luogo, la chiusura (cioè, ambiente) di tale espressione; e in secondo luogo, una rappresentazione di ciò che dovrebbe essere fatto con il risultato dell'espressione. Un linguaggio con continuazioni di prima classe, poi, è uno che ha strutture di dati incapsulamento queste parti, e che tratta queste strutture di dati proprio come farebbe qualsiasi altro.

chiamata / cc è un modo particolarmente elegante per realizzare questa idea, il proseguimento corrente è confezionato come una procedura che incapsula what-is-a-essere-fatto-con-la-espressione come quello che la procedura non quando applicata a l'espressione; per rappresentare la continuazione questo modo significa semplicemente che la chiusura di questa procedura contiene l'ambiente al sito è stato invocato.

Si potrebbe immaginare realizzare l'idea di continuazioni di prima classe in altri modi. Essi non sarebbero chiamano / cc, ed è difficile per me immaginare come una tale rappresentazione potrebbe essere più semplice.

In una nota d'addio, prendere in considerazione la realizzazione di Let / cc che Eli detto, che io preferisco chiamare bind / cc:

(define-syntax bind/cc
    (syntax-rules ()
        ((bind/cc var . body)
             (call/cc (lambda (var) . body)))))

E come un esercizio, come si dovrebbe implementare call / cc sulla base di bind / cc?