Wie kann ich eine Perl-Subroutine erstellen, die mehr als einen Block akzeptiert?

Question

Mit Prototypen können Sie ein Unterprogramm erstellen, die einen Codeblock als erster Parameter akzeptiert:

sub example (&) { 
    my $code_ref = shift; 
    $code_ref->(); 
} 
example { print "Hello\n" }; 

Wie kann ich das gleiche tun, aber mit mehr als einem Code-Block? Ich möchte Blöcke von Codes, nicht Variablen oder sub { ... } verwenden.

funktioniert das nicht: hier

Not enough arguments for main::example2 

Answer 1

Ich hoffe, Sie erkennen, dass dies nur Code Gewürz ist, und alles, was Sie zu erreichen sind, ist ein aufgeräumter Syntax auf Kosten der Klarheit?

Perl lässt nicht zu, dass Sie mehr als einen freien Block an ein Unterprogramm übergeben, aber der zweite tatsächliche Parameter könnte ein Aufruf eines Unterprogramms sein, das auch einen einzelnen Block akzeptiert und einfach die Codereferenz zurückgibt.

Dieses Programm demonstriert. Beachten Sie, dass ich please und also als Namen für die Subroutinen gewählt habe. Aber Sie müssen etwas verwenden, das sowohl für die Funktionalität Ihres eigenen Codes geeignet ist, als auch sehr unwahrscheinlich ist, dass es mit bevorstehenden Erweiterungen der Kernsprache kollidiert.

use strict; 
use warnings; 

sub please(&$) { 
    my ($code1, $code2) = @_; 
    $code1->(); 
    $code2->(); 
} 

sub also(&) { 
    $_[0]; 
} 

please { print "aaa\n" } also { print "bbb\n" }; 

Ausgang

aaa 
bbb 

Answer 2

Arbeiten für mich ...

sub example2 { 
    my $code_ref = shift; 
    my $code_ref2 = shift; 
    $code_ref->(); 
    $code_ref2->(); 
} 
example2 (sub { print "One\n" }, sub { print "Hello\n" }); 

Nur für die Zwecke der TMTOWTDI a:

sub example2 (&&) { 
    my $code_ref = shift; 
    my $code_ref2 = shift; 
    $code_ref->(); 
    $code_ref2->(); 
} 
example2 { print "One\n" } { print "Hello\n" }; 

Es gibt diesen Fehler Methode, die in gewisser Weise funktioniert, wie das OP angefordert

zunächst eine Quellenfilter

package poop; 

use Filter::Util::Call; 

sub import { 
    my ($type) = @_; 
    my ($ref) = []; 
    filter_add(bless $ref); 
} 

sub filter { 
    my ($self) = @_; 
    my ($status); 
if (($status = filter_read()) > 0) { 
     if(!/sub/ && /example2/) { 
      s/\{/sub \{/g; 
      } 
     } 

    $status; 
} 
1; 

Zweitens muss der Filter

use poop; 

sub example2 { 
    my $code_ref = shift; 
    my $code_ref2 = shift; 
    $code_ref->(); 
    $code_ref2->(); 
} 
example2 ({ print "One\n" }, { print "Hello\n" }); 

ps verwendet werden. Das ist entsetzlich und niemand würde dies in der Produktion sehen wollen.

Answer 3

Haben Sie versucht, ein Komma zwischen den beiden Blöcken zu setzen?

You have:   example { print "One\n" } { print "Hello\n" }; 
You probably want: example { print "One\n" }, { print "Hello\n" }; 

ich war falsch ...

Aber das funktioniert für mich:

 example { print "One\n" } sub { print "Hello\n" }; 

Answer 4

Sie könnten nur eval die Blöcke

use experimental 'signatures'; 
use feature 'say'; 

sub doublethecode ($block1, $block2) { eval { $block1; }; eval { $block2;} } ; 
doublethecode \&{ print "OH " }, \&{ say for qw/HAI YOU LOLCAT :-P/ }; 

Ausgang:

OH, HAI 
YOU 
LOLCAT 
:-P 

Dann ignorieren Sie einfach die \& und Sie sind da.

Ab v5.20 Sie können Signaturen und :prototype Attribute zusammen verwenden. Die Funktion signatures bietet eine "häufigere" Syntax und eine minimalistische Art der Argumentprüfung. Vielleicht wird eines der Zukunftsperls ein "eingebautes" (optionales, hochflexibles) System irgendeiner Art dazu haben, aber Prototypen sind so etwas nicht. So etwas wie:

sub doublethecode :prototype(\&\&) ($cr1, $cr2) { $cr1 ; $cr2 ; } 

ist nicht, was es scheint. Da Prototypen, signatures und Signaturen mit :prototype(&&) du nicht sein kann geben, was denken Sie bekommen, könnte dies gut genug sein:

sub doublethecode { eval { shift }; eval{ shift } } ; 
doublethecode &{ print "perl" }, &{ print "6" } 

Ausgang:

perl6 

Um sicherzustellen, dass Perl doesn‘ t denken {} ist ein Hash, der & ist notwendig. Aber eigentlich ... was ist falsch mit anonymen Subroutinen sub { } hier verwenden?

Answer 5

FWIW, in Perl 6:

sub doublecode (&foo, &bar) { foo(), bar() } 
doublecode { print 1 }, { print 2 } # prints 12 

Aber my partial list of caveats about Perl 6 sehen.