Was ist mit call/cc?

Schauen, ich habe festgestellt, das Continuation-Passing-Style beste Beschreibung zu diesem Thema.

Hier beraubt details Kopie von diesem Artikel:

Autor: Marijn Haverbeke
Datum: 24. Juli 2007

Scheme call-with-current-continuation-Funktion macht es möglich zu erfassen, eine Berechnung, ein Zustand der Aufrufliste, wie Sie waren, und wieder, der gleiche Zustand zu einem späteren Zeitpunkt. Auf der Oberseite von solchen primitiven, die verschiedene form des exception Handlings-und C-wie longjmp tricks umgesetzt werden können.

function traverseDocument(node, func) {
  func(node);
  var children = node.childNodes;
  for (var i = 0; i < children.length; i++)
    traverseDocument(children[i], func);
}   

function capitaliseText(node) {
  if (node.nodeType == 3) // A text node
    node.nodeValue = node.nodeValue.toUpperCase();
}

traverseDocument(document.body, capitaliseText);

Diese kann umgeformt werden wie folgt: fügen Wir ein zusätzliches argument, um jede Funktion, die verwendet werden, um pass-Funktion ist die Fortsetzung. Diese Fortsetzung ist eine Funktion, die den Wert repräsentiert die Aktionen, die passieren muss, nachdem die Funktion 'zurück'. Die (call -) stack veraltet continuation-passing-style ― wenn eine Funktion ruft eine andere Funktion, das ist das Letzte, was er tut. Anstatt zu warten, für den aufgerufenen Funktion zurück, es stellt jede Arbeit, die Sie tun will, um danach in eine Fortsetzung, die es geht um die Funktion.

function traverseDocument(node, func, c) {
  var children = node.childNodes;
  function handleChildren(i, c) {
    if (i < children.length)
      traverseDocument(children[i], func,
                       function(){handleChildren(i + 1, c);});
    else
      c();
  }
  return func(node, function(){handleChildren(0, c);});
}

function capitaliseText(node, c) {
  if (node.nodeType == 3)
    node.nodeValue = node.nodeValue.toUpperCase();
  c();
}

traverseDocument(document.body, capitaliseText, function(){});

Sich vorstellen, wir haben ein huuuuge Dokument, um davon zu profitieren. Einfach Durchlaufen es in einem Durchgang dauert fünf Sekunden, und das einfrieren des Browsers für fünf Sekunden, ist ziemlich schlechter Stil. Betrachten Sie diese einfache änderung von capitaliseText (don ' T achten Sie auf die hässlichen global):

var nodeCounter = 0;
function capitaliseText(node, c) {
  if (node.nodeType == 3)
    node.nodeValue = node.nodeValue.toUpperCase();

  nodeCounter++;
  if (nodeCounter % 20 == 0)
    setTimeout(c, 100);
  else
    c();
}

Nun, alle zwanzig Knoten, wird die Berechnung unterbrochen hundert Millisekunden geben die browser-Oberfläche einen moment, um auf Benutzereingaben reagieren. Eine sehr primitive form des threading ― Sie können sogar mehrere Berechnungen zur gleichen Zeit wie dieser.

Mehr allgemein nützliche Anwendung dieser Zusammenhang wird in XMLHttpRequests, oder die verschiedenen IFRAME-und SCRIPT-tag hacks verwendet zu simulieren. Diese erfordern immer eine Arbeit mit einer Art call-back-Mechanismus, der die Daten verarbeitet, die der server sendet. In einfachen Fällen, eine triviale Funktion tun, oder ein paar globals verwendet werden kann zum speichern des Status der Berechnung muss wieder aufgenommen werden, nachdem die Daten kommen zurück. Bei komplexen Fällen, beispielsweise wenn die Daten durch eine Funktion muss wieder einen Wert an seinen Aufrufer, Fortsetzungen Dinge vereinfachen sich erheblich. Sie registrieren Sie sich einfach die Fortsetzung wie der call-back, und Ihre Berechnung wird fortgesetzt, wenn die Anfrage beendet ist.

Ein triviales Beispiel für die Verwendung der Fortsetzung wäre die Implementierung einer thread - (Faser, wenn Sie es wünschen) - manager auf einem ein-Prozessor-Maschine. Der scheduler würde die Unterbrechung der Ausführung fließen in regelmäßigen Abständen (oder in dem Fall von Fasern, die aufgerufen werden, die an verschiedenen strategischen Punkten im code), speichern Sie die Fortsetzung state (entsprechend der aktuellen thread), dann wechseln Sie zu einem anderen Fortsetzung state (entsprechend einem anderen thread, dessen Zustand war vorher gespeichert haben.)

Unter Bezugnahme auf Ihre assembly hintergrund, die Fortführung Zustand erfassen würde details wie Befehlszähler, Register und stack-Kontext (Zeiger), werden gespeichert und wiederhergestellt werden.

Einen anderen Weg, mit Fortsetzung wäre denken zu ersetzen Methodenaufrufe mit mehreren thread-wie Entitäten, die co-existieren parallel (entweder ausgeführt oder angehalten), die Kontrolle über Fortsetzung Kontexten statt der 'klassischen' call Paradigma. Sie operieren würde auf Globale (shared) Daten, anstatt sich auf Parameter. Dies ist zum Teil flexibler als call in dem Sinne, dass der Stapel nicht zu wind-up, dann nach unten (calls sind verschachtelte), aber die Kontrolle übergeben können, um willkürlich.

Versucht zu visualisieren das Konzept in einer Sprache, die wie ein C, man Stelle sich vor, eine große Schleife mit einem einzigen switch(continuation_point) { case point1: ... } - Anweisung, wobei jedes case entspricht einer Fortsetzung-savepoint, und wo der code innerhalb jedes case können, ändern Sie den Wert für continuation_point und der Verzicht auf die Kontrolle zu, dass continuation_point durch breaking von der switch und die Gewinnung der nächsten iteration in der Schleife.

Was ist der Zusammenhang mit deiner Frage? Jeder bestimmte Szenarien, die Sie interessiert sind? Irgendeine bestimmte Programmiersprache? Ist der Faden/Faser-Beispiel oben ausreichend?

Wenn ich versuche zu verstehen, call/cc, fand ich diese call-with-current-continuation-für-C-Programmierer Seite war hilfreich.

Stellen Sie sich Ihr Skript ist ein video-Spiel-Bühne. Call/cc ist wie eine bonus-Bühne.

Sobald Sie es berühren, werden Sie übertragen auf die bonus-stage (d.h. die definition der Funktion als argument übergeben, um Sie call/cc [f in diesem Fall]).

Bonus-stages unterscheiden sich von herkömmlichen Stadien, denn Sie haben in der Regel ein element (D. H. das argument der Funktion übergeben call/cc), dass, wenn Sie es berühren, verlieren Sie transportiert werden und zurück auf die normale Stufe.

Also ist es egal, wenn es viele args bei erreichen einer von Ihnen seine über. Damit unsere Ausführung erreicht (arg 42) und gibt Sie an die Summe (+ 42 10).

Da gibt es auch einige Ausführungen bemerkenswert:

• Nicht alle Funktionen genutzt werden können mit call/cc. Da es erwartet, eine
  Fortsetzung (das ist eine Funktion), können Sie ein f wie dieses:
  (define f (lambda (k) (+ k 42)) , weil Sie nicht sum eine
  Funktion.
• Auch Sie können nicht (define f (lambda (k) (f 42 10)))
  da die Fortsetzung erwartet nur ein argument.
• Sie beenden kann
  ohne touching jeder Ausgang, in diesem Fall die Funktion Erlös wie
  jeder normale Funktion (z.B. (define f (lambda (k) 42) beendet und
  gibt 42).

Werfen Sie einen Blick auf die Beschreibung und Implementierung von call/cc für FScheme: http://blogs.msdn.com/b/ashleyf/archive/2010/02/11/turning-your-brain-inside-out-with-continuations.aspx