What should:

for my $item (upto(5)) {
    for my $other (upto(5)) {
        print "At $item and $other\n";
    };
};
[download]

Share-everything threads were tried in perl 5.005.

tie is slow. In either case you should already be able to implement this using PerlIO::via. If enough people use that, we might consider adding that to core.

I think that upto(...) returns an iterator/generator. The example I used is fairly trivial to reimplement in Perl5 now already:

# perl 5.10
sub ENDOFITERATION { undef }; # some magic value that signals the end 
+of all values

sub upto {
    my $start = 0;
    my $stop = shift;
    return sub {
        if ($start < $stop) {
            return $start++
        } else {
            return ENDOFITERATION
        };
    };
};
[download]

Iterators/generators allow you to conveniently program in a linear fashion without needing to maintain the state. For example this contrived example is far easier to write in a linear fashion than it is in a closure fashion, because you need to store the current point of execution:

# Read incoming commands - an infinite loop/generator
sub get_commands {
    while (<>) {
        yield $_;
    };
};

sub user_session {
    COMMAND: {
        my $command = get_commands; # read one command
        if ($command =~ /^login (\w+)/) {
            my $user = $1;
            my $pass = get_commands; # read next line
            if ($user_db{$user} ne $pass) {
                print "User $user rejected.\n";
                redo COMMAND;
            } else {
                for my $command (get_commands) {
                    if ($command =~ /^logout/) {
                        return
                    } else {
                        yield [$user, $command]
                    };
                };
            };
        } else {
            # not logged in
        };
    };
};

sub process_sessions {
    for my $line (user_session()) {
        my ($user,$command) = @$line;
        print "$user: Executing $command\n";
    };
};
[download]

I'm aware that all my wishes are possible in principle now already, but either slow or burdened with ugly syntax. Which is why I wish for them to become less burdened and faster.

If upto() indeed returned an iterator that you could then call, all would be well, but that doesn't seem to have happened. If it did then your original code would look somewhat like this:

my $iter = upto(5);
while (my $item = $iter->()) {
    print "Item: $item\n";
}
[download]

With this the intent would be clear. And you would be able to specify exactly what do you want. I'm not talking about the implementation of upto(), I'm talking about its use! In the example I gave you, with the two nested loops, are the two upto(5) things the same iterator or two separate ones? If they are separate then how come you apparently assume the get_commands() to be a single iterator? And if it's the same iterator, how do I create a separate one?

Imagine you wanted to make the get_commands() more general and allow you to read the commands from a file specified by the filename. Now am I supposed to pass the same filename to all occurences of the get_commands()? Or just the first and all following will use that file? How will I know they are not trying to access the <>? And how do I open two iterators at once?

Jenda


Support Denmark! Defend the free world!

The thing that is still missing in the Perl core for me is more flow control resp. non-linear flow:

One thing that I miss both in Perl 5, 6 and most languages I know of is some form of addomesticated code rewriting. We're all told that goto is evil. But we have some forms of addomesticated goto: next, last and redo, which are not evil. We're all told that code rewriting is evil. But I'm sure that there could be useful and not evil forms of code rewriting. Limbic~Region speaks about that in Doing "it" only once.

START blocks provide "do once" capability in Perl 6.

START blocks provide "do once" capability in Perl 6.

Whoa! I will stop complaining like whatever the common English idiom for a recurring, annoying and insisting whiner is.

Would someone care how it would apply to the original (Perl 5) example?

while ( <FH> ) {
    next if $_ eq 'foo'; # Where foo can only appear once in the file
    print;
}
[download]