Re: Near-free function currying in Perl

Very nice meditation, Tom. Being a fan of functional programming myself, I really enjoy reading your meditations. However, being a user of OOP programming too, I despise namespace pollution. I like your idea, but I would like to see it be done without the need for creating new functions in the namespaces. This alone would make me not use this module desipte the fact I can see a number places something like this would be handy.

I suggested above (in response to dragonchild's thought on prototypes) the possibility of using attributes to defined the curry-ability of a function. I think this would be a nicer way to do things (assuming it is possible of course), since it would provide the transparent currying you are after (ala Haskell, Std ML, etc). For me, I would rather have the transparency, in fact I think I would even choose curry(\&func ...) over adding the '_c' to a function as well. Naming conventions are a very sensitive issue for many people and I would think even with having all the suffix and prefix options would still not be enough for some, me in particular ;-)

Again, excellent meditation, I really enjoy these.

[dragonchild]

package AutoCurry;
require v5.6.1;
use Attribute::Handlers::Prospective;

sub UNIVERSAL::curry : ATTR(CODE,RAWDATA) {
    my ($package, $symbol, $referent, $attr, $data, $phase) = @_;

    my $num = () = $data =~ /(\$)/g;
    *{"$package".'::'.*{$symbol}{NAME}} = sub {
        if (@_ < $num) {
            my @x = @_;
            return sub { $referent->(@x, @_ ) };
        }
        $referent->(@_);
    };
}

1;
__END__

#############
demo.pl
#############

#!perl

use strict;
use warnings;

use AutoCurry;

sub foo : curry($$$) {
    print "Hello @_\n";
};

foo( 'a', 'b', 'c' );
my $ref = foo('d','e');

$ref->('f');
$ref->('g');

Obviously, improvements can be made, but I think this does what is desired. There is a slight performance penalty, but it's not bad at all.

[stvn]

LOL, you beat me by only a few minutes, I was just going to posts this.

Read more... (1438 Bytes)

Although to be honest, neither of our implementations, nor Tom's do what Haskell and Standard ML do, which is too keep currying until all the functions arguments are satisfied.

my $curried_foo = foo(1);
my $even_more_curried_foo = $curried_foo->(2);
print $even_more_curried_foo->(3); # now we execute the function

And from my (limited) understanding of prototypes, it seems that this may not be possible since seems it is difficult to assign an attribute to a closure.

[dragonchild]

Easily fixed.

package Demo;
require v5.6.1;
use Attribute::Handlers::Prospective;

sub UNIVERSAL::curry : ATTR(CODE,RAWDATA) {
    my ($package, $symbol, $referent, $attr, $data, $phase) = @_;

    my $num = () = $data =~ /(\$)/g;
    my $subname = "$package".'::'.*{$symbol}{NAME};
    *$subname = sub {
        if (@_ < $num) {
            my @x = @_;
            return sub { $subname->(@x, @_ ) };
        }
        $referent->(@_);
    };
}

1;
__END__