Leser: 13
![]() |
|< 1 2 3 4 >| | ![]() |
31 Einträge, 4 Seiten |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
use 5.010; use strict; use warnings; sub foo { say 'Tail-calling bar...'; @_ = (1, 2); goto &bar; say 'This should never be reached!'; } sub bar { my ($a, $b) = @_; say "bar($a, $b) called"; } say 'Calling foo...'; foo(); say '... returned from foo';
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
use 5.010; use strict; use warnings; sub square($) { my $x = shift; return $x * $x; } sub square_and_say($) { my $x = shift; my $s = square($x); say "$x ^ 2 = $s"; } square_and_say 2;
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
use 5.010; use strict; use warnings; sub square(&$) { my ($rc, $x) = @_; @_ = ($x * $x); goto &$rc; } sub square_and_say(&$) { my ($rc, $x) = @_; my $square_rc = sub { my $s = shift; say "$x ^ 2 = $s"; @_ = (); goto &$rc; }; @_ = ($square_rc, $x); goto □ } square_and_say { } 2;
murphy+2008-02-20 14:28:52--Goto mit Parametern gibt's in Perl auch:
murphy+2008-02-20 14:28:52--. wobei eine Continuation so etwas wie der eingefrorene Zustand eines Programmes ist, das darauf wartet einen Rückgabewert zu empfangen und weiterzurechnen.
murphy+2008-02-20 14:28:52--.Man ersetzt also jede Rückgabe eines Wertes durch den Aufruf einer Funktion, die als Parameter übergeben wurde. Normaler Code:
sub1(\&sub2)
1 2 3 4 5 6 7 8 9
sub subA { $rc_contA=shift; $rc1= sub {block1; sub2( $rc2 ) } $rc2= sub {block2; sub3( $rc3 ) } $rc3= sub {block3; &$rc_contA; } $rc1->(); #aufruf }
Struppi+2008-02-20 23:09:12--Ich sprach von Lambda Closures, das sind Ketten von Funktionsaufrufen oder auf deutsch Zuständigkeitsketten, das ist doch sowas ähnliches wie ihr hier beschreibt.
1 2 3 4 5 6 7 8 9 10 11 12 13
{ @code_refs=(); sub add_cr { push @code_refs, shift ; } sub run_cr { for my $cr (@code_refs) { $cr->(@_); } } }
KurtZ+2008-02-21 15:46:20--[...]
Habe Implementierungsbeispiele für JS Rhino gesehen, AFAIS ließe sich sowas auch in einem Perl-Modul anbieten.
QuoteWas ich bisher noch nicht so gesehen habe sind aber Anwendungsbeispiele, deren Probleme in CPS einfacher und intuitiver zu modellieren sind als mit klassischen Mitteln.
Mir fallen wie gesagt nur Statemachines ein.
murphy+2008-02-21 16:06:57--KurtZ+2008-02-21 15:46:20--[...]
Habe Implementierungsbeispiele für JS Rhino gesehen, AFAIS ließe sich sowas auch in einem Perl-Modul anbieten.
In Rhino JS muss man nicht im CPS programmieren, weil es native Continuations gibt!
murphy+2008-02-21 16:06:57--In Perl müsste man entweder selbst CPS schreiben, den Compiler hacken um automatisch in CPS zu transformieren, den Interpreter hacken um Interpreterthreads zur Emulation von Continuations zu benutzen, oder auf Perl6 warten, denn Parrot soll native Unterstützung für Continuations bekommen :-)
murphy+2008-02-21 16:06:57--KurtZ+2008-02-21 15:46:20--Mir fallen wie gesagt nur Statemachines ein.
Es gibt ein paar Webframeworks, die Continuations oder Techniken mit vergleichbarem Effekt einsetzen, um die asynchrone, anfragegesteuerte Natur einer Webanwendung zu verschleiern und dem Programmierer mehr das Gefühl eines linearen, interaktiven Programmablaufes zu geben.
KurtZ+2008-02-21 16:55:51--murphy+2008-02-21 16:06:57--[...] In Rhino JS muss man nicht im CPS programmieren, weil es native Continuations gibt!
ist das entsprechender Code?
http://wiki.apache.org/cocoon/RhinoWithContinuations
QuoteKlar, für mich sind http-requests naheliegende Beispiele für Statemachines. Jeder request überführt den Zustand der angezeigten Seite in einen anderen.
QuoteMir fehlt aber noch ein kleines konkretes Beispiel, wie ich ein Konzept intuitiver in CPS umsetze.
Gerne auch in Perl6 oder Javascript (scheme, lisp udn haskell kann ich leider nicht)
![]() |
|< 1 2 3 4 >| | ![]() |
31 Einträge, 4 Seiten |