Of course, that's just asking for it.

my $biup = compose map curry( \&wrap_with_html, $_ ), qw( p u i b );
[download]

Now that actually looks like a construct you're likely to see in some flavour of functional programming language.

Why recurse when you can iterate instead? :)

use List::Util qw(reduce);
sub compose {
    reduce { sub { $b->($a->(@_)) } } @_;
}
[download]

Of course, that doesn't actually work because Perl's reduce uses global variables ($a,$b). But, we can roll our own:

sub compose {
    my $c = shift;
    foreach my $s (@_) {
        my $o = $c;
        $c = sub { $s->($o->(@_)) }
    }
    $c
}
[download]

Why recurse when you can iterate instead? :)

*gasp* .... thats not very functional! (I wont even bring up the fact you are using variable assignment, tssk tssk)

If we really want to be "efficient" about it, we would avoid the overhead of the wrapper subroutine, and just use straight perl's closures.

sub compose {
    my (@funcs) = @_;
    return sub {
        my (@args) = @_;
        foreach my $func (@funcs) {
            @args = $func->(@args);
        }
        return @args;
    };
}
[download]

But really, that takes all the fun out of it ;-)
-stvn

Why be functional when you can be efficient? Recursion might be elegant, but computers don't really understand elegance. :) Functional programming has a lot of great and useful concepts in it, and luckily we use a language that doesn't *force* us to be purists about it.

P.S.: The variable assignment is very necessary in my second example, because otherwise you're going to get a circularly referenced subroutine, which will make perl hit a infinite recursion warning pretty damned quick.

P.P.S: And, you're right, your last version is even better!

For full equivalence you need to not spoil the aliasing of @_ for the first call. Replace all @args with @_ and you're home safe. (The @_ assignment later breaks the aliasing as it should.)

Cheers,
ihb

Read argumentation in its context!