Currying in Schleifen (gelöst) (Allgemeines zu Perl)

[thread]17886[/thread]

Currying in Schleifen [gelöst]

Tags: perl5 Ähnliche Threads

Leser: 28

Articles: hide open all | hide show old branches

+19 replies
flowdy

2012-11-06 22:47
User since
2012-08-03
45 Artikel
BenutzerIn
Hallo,

ich habe eine Funktion $node->climb_up($curry_sub), die einen Baum von unten nach oben, also aus der Tiefe zur Wurzel durchläuft und jeden Knoten an &$curry_sub übergibt. Nun kann &$curry_sub jederzeit befinden, dass kein weiterer Aufruf mehr getätigt, die Schleife abgebrochen werden soll. Auch return-Aufrufe in &$curry_sub führen zum Abbruch der Schleife und etwaige Rückgabewerte reicht climb_up bloß noch nach draußen durch.

Was ich nicht möchte:
- irgendwelche speziell subtilen Rückgabewerte von $curry_sub, die climb_up auswertet und die Schleife entsprechend lastet oder nextet.
- die kommt auch nicht in Frage. Ich unterstütze keinen Selbstmord als Mittel zu einem höheren Zweck. Würde es außerdem notwendig machen, dass climb_up die Exception abfängt, auswerten muss und dadurch mitbestimmt, wie sie aussehen darf (String, Objekt, Zahl, etc.). Ganz hässlich.
Dann muss also eine extra Variable her
Code (perl): (dl )

1 2 3 4 5 6 7 8 9 10 11 12

sub Node::climb_up { my ($self, $sub, $cont) = @_; my $p = $self; my @ret; while ( $p = $p->parent_row ) { @ret = $sub->($p,\$cont); next if $cont; } return @ret; }
Oder vielleicht besser?
Code (perl): (dl )

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

sub Node::climb_up { my ($self, undef, $sub) = @_; my $cont = \$_[1]; # Referenz auf urspr. Wert (Pass-by-Reference) my $p = $self; my @ret; while ( $p = $p->parent_row ) { @ret = $sub->($p); next if $$cont; } return @ret; } my $continue; my $curry_return = $node->climb_up($continue = 1, sub { my $node = shift; ... $continue = ...; return $in_spe; });
Gibt es noch bessere Ideen? Ich suche nach einem guten Kompromiss zwischen Klarheit und Kürze im Aufrufkontext von &climb_up.

Danke,
flowdy
Last edited: 2012-11-06 22:48:57 +0100 (CET)
package MyClass; sub new {\b\b\b\b\b\b\b\b\buse Moose;
- flowdy
  
  2012-11-06 23:23
  User since
  2012-08-03
  45 Artikel
  BenutzerIn
  Um mir mal selbst zu antworten: Der inverse Ansatz mit
  
  Code (perl): (dl )
  
  1 2 3 4 5 6 7 8 9 10 11 12
  
  sub Node::climber { my $p = shift; return sub { return $p = $p->parent_row }; } # dann ... my $climber = $node->climber; while ( my $node = $climber->() ) { # ... }
  
  geht natürlich auch. Ist das klarer bzw. gibt es noch was besseres, etwas, das ganz ohne zusätzliche Variable auskommt? Das man mit beiden Ansätzen auf sie verzichten kann, ist mir klar, damit verzichtet man aber auch auf den bedingten Abbruch der Traversierung.
  
  Viele Grüße,
  flowdy
  package MyClass; sub new {\b\b\b\b\b\b\b\b\buse Moose;
- sirius
  
  2012-11-06 23:23
  
  User since
  2012-01-06
  25 Artikel
  BenutzerIn
  
  Wenn ich Deinen Code richtig verstehe, dann überschreibst du @ret bei jedem Schleifendurchlauf mit dem Ergebnis von deiner anonymen Funktion. Also ist das Ergebnis der Funktion erst beim letzten Schleifendurchlauf relevant. Dann kannst du ja vorher immer false zurückliefern.
  
  Wenn dem nicht so ist, dann kenne ich es bisher (Microsoft macht es z.B. so), dass der Fehlercode (aka dein continue) im Return steht und ein Ergebnis der Funktion im call by reference übergeben wird. (Also deine Variante 1 nur umgekehrt)
  
  Und warum keine Exception? Ist das so ungeliebt. Es ist ja deswegen kein Fehler oder so etwas. Eine Exception tritt ganz normal auf, wenn die Fortführung des Codes an dieser Stelle (weil zumeist etwas - Datei, Variableninhalt - fehlt) nicht sinnvoll ist und zu einem safe place gesprungen werden soll.
  
  Im Gegensatz zu der Exception-Variante finde ich deine Variante zwei abenteuerlich. Aber da fehlt mir die Erfahrung mit solchen anonymen Funktionen. Ich würde es gefühlsmäßig vermeiden, Variablen über Funktionsgrenzen (aka quasi-global) zu verwenden.
  
  (Das sind nur Hinweise von jemandem, der schon länger programmiert, aber nicht in perl)
- +2 replies
- moritz
  
  2012-11-07 10:54
  
  User since
  2007-05-11
  923 Artikel
  HausmeisterIn
  
  2012-11-06T21:47:48 flowdy
  Gibt es noch bessere Ideen? Ich suche nach einem guten Kompromiss zwischen Klarheit und Kürze im Aufrufkontext von &climb_up.
  
  Weitere Moeglichkeiten: goto, last LABEL.
  
  Ob die dir besser gefallen, kann ich nicht erraten :-)
  Perl 6 - Perls Zukunft
  - flowdy
    
    2012-11-08 12:47
    
    User since
    2012-08-03
    45 Artikel
    BenutzerIn
    
    Hi Moritz,
    
    Label funktionieren ja nur innerhalb desselben dynamischen Geltungsbereichs, wenn ich perldoc -f goto richtig verstehe. Node::climb_up() wird realiter natürlich in Node.pm definiert. Davon abgesehen möchte ich schon, dass ich Aufrufe von Node::climb_up() inkl. der Curry-Sub von mir später oder späteren Mitgliedern im Entwicklungsteam verstanden werden, ohne erst nachschlagen zu müssen, wie clever climb_up zusammengehackt wurde. Würde man sich zurecht fragen, warum nicht gleich ne Closure und while. Die gesuchte Lösung muss also mindestens so gut verständlich sein wie das Verfahren in meinem Posting #2.
    
    Vielen Dank trotzdem :-),
    flowdy
    package MyClass; sub new {\b\b\b\b\b\b\b\b\buse Moose;
- +4 replies
- murphy
  
  2012-11-07 13:58
  
  User since
  2004-07-19
  1776 Artikel
  HausmeisterIn
  
  2012-11-06T21:47:48 flowdy
  [...]
  Gibt es noch bessere Ideen? Ich suche nach einem guten Kompromiss zwischen Klarheit und Kürze im Aufrufkontext von &climb_up.
  [...]
  
  Nun ja, das ganze Problem klingt prädestiniert für die Verwendung von Continuations, die es in Perl aber nicht gibt.
  
  Man könnte zur Holzhammermethode greifen und mit goto &SUB und CPS-Transformation arbeiten, ich bezweifle allerdings, dass das besonders hübsch ist.
  more (5.6kb)
  
  Oder man könnte in diesem Fall Continuations über Exceptions emulieren, wobei man das sauber kapseln kann, so dass der Aufrufer von climb_up nichts davon sieht.
  more (7.1kb)
  
  An der Variante, eine Referenz auf ein Stopflag an das Callback zu übergeben finde ich auch nicht unbedingt etwas auszusetzen, wenngleich es mir wesentlich einfacher erscheint schlicht mehrere Rückgabewerte aus dem Callback zu verwenden.
  more (5.2kb)
  When C++ is your hammer, every problem looks like your thumb.
  - +3 replies
  - flowdy
    
    2012-11-08 13:49
    User since
    2012-08-03
    45 Artikel
    BenutzerIn
    
    Danke murphy, deine zweite Idee gefällt mir schon gut. Einer hypothetische Dokumentation wäre dann aber auch darauf hinzuweisen, dass return sich nur auf den Aufruf von climb_up() bezieht, wenn die TopNode erreicht ist, es also keinen weiteren Durchlauf der internen Schleife gibt. Interna in der Schnittstellendoku sind für mich nun grundsätzlich suboptimal.
    
    Habe mir gedacht, dass das auch umgekehrt gehen müsste:
    
    Code (perl): (dl )
    
    1 2 3 4 5 6 7 8 9 10 11 12 13
    
    sub Node::climb_up { my ($self, $proc) = @_; my ($magic, @return); my $return_onTop = sub { @return = @_; die \$magic; }; COND_CLIMB: while ( $self = $self->parent_row ) { eval { @return = $proc->($self, $return_onTop) }; if ( $@ ) { $@ == \$magic ? next : die $@; } else { last COND_CLIMB; } } return @return; }
    
    Das Problem, aber vielleicht ist es auch kein Problem, sondern würde auch der Verständlichkeit und Wartbarkeit des Codes durchaus dienen, veranschauliche ich an einem möglichen Beispielcode zu &Node::climb_up() in der Doku:
    
    Code (perl): (dl )
    
    1 2 3 4 5 6 7 8 9 10 11 12 13
    
    =head2 SYNOPSIS ... $node->climb_up(sub { my ($ancestor, $onTop_return) = @_; my $ret = $ancestor->doSomething(); return if $ret->smells(); # climb_up immediately returns () return do_whatever_with($ret); # i.e. any return values untouched $onTop_return->(@ignore_if_not); # Don't forget at the end! # otherwise ancestors' line processed ends by the parent # (blame perl it'd enforce an implied C<return @last_expr_val;> ) }
    
    Ist das gutes Design? Weiß nicht. Ich glaube, my $closure = $node->climb_up(); have_fun($_) while $_ = $closure->() ist dann doch einen Deut besser. Ich kann es ja so machen, das climb_up() bei !@_ eine Closure zurückgibt, andernfalls eben so verfährt wie dargestellt.
    EDIT: Das ist dann aber auch nicht kürzer als while ( $node = $node->parent_row ) {...}, ergo kann ich auf die Aufrufalternative ganz verzichten, ehrlich gesagt auch auf Node::climb_up überhaupt. Insofern eignet sich das Closure-while-Verfahren wie auch das mit $onTop_return (bzw. $return_ifLast oder irgendwas) nur, wo die Auswahl des jeweils nächsten zu bearbeitenden Knotens komplizierter ist, also sich eine Auslagerung lohnt.
    
    Danke!
    flowdy
    Last edited: 2012-11-08 14:17:34 +0100 (CET)
    package MyClass; sub new {\b\b\b\b\b\b\b\b\buse Moose;
    - +2 replies
    - murphy
      
      2012-11-08 21:58
      
      User since
      2004-07-19
      1776 Artikel
      HausmeisterIn
      
      2012-11-08T12:49:53 flowdy
      [...]
      Habe mir gedacht, dass das auch umgekehrt gehen müsste:
      
      Code (perl): (dl )
      
      1 2 3 4 5 6 7 8 9 10 11 12 13
      
      sub Node::climb_up { my ($self, $proc) = @_; my ($magic, @return); my $return_onTop = sub { @return = @_; die \$magic; }; COND_CLIMB: while ( $self = $self->parent_row ) { eval { @return = $proc->($self, $return_onTop) }; if ( $@ ) { $@ == \$magic ? next : die $@; } else { last COND_CLIMB; } } return @return; }
      
      [...]
      
      Hmm, also ich finde es nicht sehr intuitiv, wenn eine Iterationsmethode standardmäßig die Iteration sofort abbricht und mit einem Callbackaufruf zur Fortsetzung ihrer Arbeit bewegt werden muss. Abgesehen davon ist die Exceptionbehandlung nicht unbedingt besonders schnell und könnte die Schleife ausbremsen, wenn sie in jedem Schritt durchlaufen wird.
      
      Quote
      [...]
      Ich glaube, my $closure = $node->climb_up(); have_fun($_) while $_ = $closure->() ist dann doch einen Deut besser. Ich kann es ja so machen, das climb_up() bei !@_ eine Closure zurückgibt, andernfalls eben so verfährt wie dargestellt.
      EDIT: Das ist dann aber auch nicht kürzer als while ( $node = $node->parent_row ) {...}, ergo kann ich auf die Aufrufalternative ganz verzichten
      [...]
      
      Einen Iterator zurückzugeben ist auch nicht dumm.
      
      Ein Grund so eine Schnittstelle bereitzustellen selbst wenn eine explizite Schleife nicht schwieriger zu verwenden ist, könnte die Normalisierung der Schnittstelle über verschiedene Containertypen hinweg sein.
      When C++ is your hammer, every problem looks like your thumb.
      - flowdy
        
        2012-11-09 22:25
        
        User since
        2012-08-03
        45 Artikel
        BenutzerIn
        
        Quote
        Abgesehen davon ist die Exceptionbehandlung nicht unbedingt besonders schnell und könnte die Schleife ausbremsen, wenn sie in jedem Schritt durchlaufen wird.
        
        Stimmt, kann mir auch nicht vorstellen, dass die Perlentwickler auch nur im Traum daran denken, die Generierung und Behandlung von $@ auf Geschwindigkeit zu optimieren. Wenn das sinnvoll wäre, dann auch, Schaufensterpuppen Grimassen beizubringen. Nein, schnell dürfte diese Lösung wirklich nicht sein.
        
        Allerdings ging es mir eher um Intuitivität im Aufrufkontext. Die zu erhöhen geht eben gern auf Kosten der Verständlichkeit des Modulcodes (ohne damit sagen zu wollen, dass man in Modulcode alle guten Sitten über Bord werfen könne).
        
        Einerlei, ich habe mich von climb_up() ganz verabschiedet. Currying lohnt hier nicht. Refaktorisieren heißt nicht, den cleveren Coder zu geben.
        
        [edit=15.11.]Trotzdem ist mir heute eine (theoretische) Alternative zu den langsamen Exceptions eingefallen: Zwei Integervariablen, die eine wird über die Closure inkrementiert, die andere regulär in der Schleife. Die Abbruchbedingung testet dann nicht, ob eine Exception geworfen wurde oder nicht, sondern ob die beiden Variablen gleich sind.
        
        Code (perl): (dl )
        
        1 2 3 4 5 6 7 8 9 10 11 12 13 14
        
        sub Node::climb_up { my ($self, $proc) = @_; my ($i, $j, @return); my $return_onTop = sub { $j++; @_ }; while ( $self = $self->parent_row ) { @return = $proc->($self, $return_onTop); last if ++$i > $j; } continue { $j = $i; # falls $return_onTop mehrmals aufgerufen wurde } return @return; }
        
        [/edit]
        Last edited: 2012-11-15 16:00:16 +0100 (CET)
        package MyClass; sub new {\b\b\b\b\b\b\b\b\buse Moose;
- +10 replies
- Muffi
  
  2012-11-09 21:22
  
  User since
  2012-07-18
  1465 Artikel
  BenutzerIn
  
  was spricht denn gegen ejnen ganz normalen 2. Rückgabewert?
  1 + 1 = 10
  - +9 replies
  - flowdy
    
    2012-11-09 22:00
    User since
    2012-08-03
    45 Artikel
    BenutzerIn
    
    Dass $curry_sub ja auch eine Liste von Werten zurückgeben könnte. Die müsste sie in einer anonymen Array-Referenz zurückgeben, die dann den ersten Rückgabewert bildet, damit der zweite Wert angeben kann, ob die Schleife fortgesetzt werden soll oder nicht.
    
    Zwei Probleme:
    
    Code (perl): (dl )
    
    1 2 3 4
    
    my @ret = $node->climb_up(sub { ... return [$val1, $val2, ...], $cont; })
    
    Und du fragst 3 Leser deines Codes, was @ret nach dem Aufruf von climb_up() wohl enthält und wirst mindestens 4 verschiedene Antworten erhalten. Dann sagst du ihnen, lest doch die Doku, und vielleicht tun sie's, vielleicht nicht, beidenfalls krausen sie die Stirn.
    
    Und selbst wenn du auf die anonyme Referenz verzichtest, $cont einfach als letzten Wert zurück gibst und dann climb_up-intern mit $cont = pop @ret arbeitest, das macht obigen Code auch nicht intuitiver.
    
    Nene, da vergess ich das mit climb_up und arbeite direkt mit while $p = $p->parent_row. Werde ich dann zwar an tausenden von Stellen tun. Aber, was Refaktorisierung betrifft, sollte man die Kirche schon noch im Dorf lassen: Nicht nur die Wiederholungsrate von Code macht aus ihm einen Refaktorisierungskandidaten, sondern auch seine Länge und seine Opazität (= die Notwendigkeit, die Doku zur Hilfe zu nehmen, um diesen Code zu verstehen).
    
    Aber hätte sich ja auch zu einer guten Idee entwickeln können. ;-)
    package MyClass; sub new {\b\b\b\b\b\b\b\b\buse Moose;
    - murphy
      
      2012-11-10 03:04
      
      User since
      2004-07-19
      1776 Artikel
      HausmeisterIn
      
      2012-11-09T21:00:27 flowdy
      Dass $curry_sub ja auch eine Liste von Werten zurückgeben könnte. Die müsste sie in einer anonymen Array-Referenz zurückgeben, die dann den ersten Rückgabewert bildet, damit der zweite Wert angeben kann, ob die Schleife fortgesetzt werden soll oder nicht.
      [...]
      
      Aber warum sollte man sich an diese Reihenfolge von Rückgabewerten klammern? In meinem Beitrag msg #163114 habe ich auch ein Beispiel, wie man den ersten Rückgabewert zur Schleifenkontrolle nutzen und alle weiteren Rückgabewerte durchreichen kann.
      When C++ is your hammer, every problem looks like your thumb.
    - +7 replies
    - Muffi
      
      2012-11-10 06:29
      
      User since
      2012-07-18
      1465 Artikel
      BenutzerIn
      
      Ja gut. Aber dass man sich anschaun muss welche Parameter bei Funktionen rein und rausgehn wird man nicht verhindern können.
      Zumindest find ichs irgendwie komisch nach komplizierten Konstrukten zu suchen, nur um dem Benutzer zu ersparen nachzuschaun wie er eine Funktion zu benutzen hat.
      
      Und wenn man an der Stelle wirklich grosse Sicherheit haben will läufts wohl auf eine Art Objekt und Erben von etwas, das als Interface fungiert raus.
      1 + 1 = 10
      - +6 replies
      - flowdy
        
        2012-11-13 14:24
        
        User since
        2012-08-03
        45 Artikel
        BenutzerIn
        
        Meiner Meinung nach sollte Code auch ohne Doku der verwendeten Module verständlich sein und das bedeutet, er darf keine Missverständnisse provozieren. Denn wenn es mal daran geht, dass ich mein Projekt "bloody alpha" veröffentliche und nach Teammembern suche, bringt mir die Doku erst mal rein gar nichts: Das Programm muss nicht nur zumindest erkennen lassen, wozu es dient, welche Probleme es wie zu lösen versucht, sondern der Code muss sich auch sehen lassen können, zur Mitarbeit einladen (ja, ich kenne perltidy und perlcritic, aber kein perldetectpitfallsindesign). Und dazu gehört für mich auch die Frage, welche Anstrengungen sich lohnen um die Logik zum Traversierung von Baumstrukturen zu verbergen, damit der eigentliche Zweck eines bestimmten Stück Codes idealerweise ohne Umweg ins Auge springt.
        
        -- flowdy
        package MyClass; sub new {\b\b\b\b\b\b\b\b\buse Moose;
        
        +5 replies
        
        Muffi
        
        2012-11-13 14:41
        
        User since
        2012-07-18
        1465 Artikel
        BenutzerIn
        
        Du willst mir aber jetzt nicht ernsthaft erzählen, dass sowas wie
        (als Beispiel aus einer ganzen Latte an Magiezeilen)
        
        Code (perl): (dl )
        
        1 2 3
        
        ... my $return_onTop = sub { @return = @_; die \$magic; }; ...
        
        irgendwie lesbarer ist als
        
        Code (perl): (dl )
        
        return \@whatever, $exit_loop;
        
        1 + 1 = 10
        
        +4 replies
        
        flowdy
        
        2012-11-14 14:08
        
        User since
        2012-08-03
        45 Artikel
        BenutzerIn
        
        Wie ich schon schrieb, habe ich die Idee, die Traversierung meines Baums aus der Tiefe hin zur Wurzel zu kapseln, verworfen. Ich bin leider nicht nur ein Perfektionist, ich muss mich diesbezüglich sogar hin und wieder zügeln, dass ich es damit nicht zum Exzess treibe: Die letzte Fassung von climb_up hätte dazu gedient, Code auf höherer Ebene (client code sagt man wohl?) lesbarer zu machen, allerdings - richtig erkannt - kostet es viel zu viel Lesbarkeit auf eigener Seite.
        package MyClass; sub new {\b\b\b\b\b\b\b\b\buse Moose;
        
        Muffi
        
        2012-11-14 14:38
        
        User since
        2012-07-18
        1465 Artikel
        BenutzerIn
        
        Ah ok, kapiert.
        1 + 1 = 10
        
        +2 replies
        
        topeg
        
        2012-11-14 17:30
        
        User since
        2006-07-10
        2611 Artikel
        BenutzerIn
        
        "undef" ist auch ein Wert der zurück geben werden kann.
        
        Code (perl): (dl )
        
        1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
        
        sub climb_up { my $self=shift; # nur gerade Anzahl von Werten pop(@_) if(@_%2); my %options=@_; unless($options{code_find} and ref($options{code_find}) eq 'CODE') { croak(qq(in method "climb_up" "code_find" had to be defined! )); } $options{return_found}=1 unless(exists $options{return_found}); $options{break_on_undef}=1 unless(exists $options{break_on_undef}); my @ret; my $now=$self; while ( $now = $now->parent_row ) { my @r=$options{code_find}->($now); last if($options{break_on_undef} and @r==1 and !defined($r_[0])); push(@ret,@r) if($options{return_found}); } return 1 unless($options{return_found}); return @ret; }
        
        Der Aufruf wäre dann:
        
        Code (perl): (dl )
        
        1 2 3 4 5 6 7 8 9 10 11
        
        $obj->climb_up(code_find=>sub{ my $obj=shift; if('was auch immer') { return qw(irgend ein array); } # kein Abbruch elsif('noch eine Auswahl') { return (); } # kein Abbruch elsif('noch eine Auswahl') { return undef,undef; } # kein Abbruch else { return undef; } # Abbruch });
        
        Oder eine alternative mit zwei Funktionen.
        
        more (13.9kb)
        
        modedit Editiert von pq: more-tag
        Last edited: 2012-11-14 17:50:04 +0100 (CET)
        
        flowdy
        
        2012-11-16 01:27
        
        User since
        2012-08-03
        45 Artikel
        BenutzerIn
        
        Hallo topeg,
        
        danke für den Tipp. Allerdings habe ich schon eingangs geschrieben, dass irgendwelche Kunststücke mit den Inhalten der Liste zurückgegebener Werte für mich keine Option ist. Bei Code wie my @whatever = $thing->some_wrapper_for(sub { ...; return @something }) muss man ständig bedenken, dass &Thing::some_wrapper_for mit den zurückgegebenen Werten alles mögliche anstellen könnte, am Ende @whatever also keineswegs @something ist. Vor allem an solchen Stellen wie hier heißt es aufpassen, weil das wie eine direkte Zuweisung aussieht, wie my @whatever = do {...}. Man könnte es sich natürlich leicht machen und auf die Doku verweisen ... ich wiederhole mich, s.o.
        
        Schön und gut, wenn ich mich als Programmierer auf den Interpreter ein Stückweit im Sinne von Do What I Mean verlassen kann. Einem dritten, einem Menschen, der den Code liest, ist mit Does What it looks like eher geholfen.
        
        -- flowdy
        package MyClass; sub new {\b\b\b\b\b\b\b\b\buse Moose;

View all threads created 2012-11-06 22:47.