How can I do function partial application in Perl?

Question

Is there any way to achieve partial application in Perl?

Suppose, I want to do something like:

sub each_file($arr, $op) {
    $op->($_) for @{$arr};
    ...
} 

sub each_line($op, $file) {
    ... 
}

each_file($arr, each_line($op));

I want to partially apply each_line() to only $op, so it'll become a new function can be passed to $each_file, how do I express this in idiomatic Perl?

Are you talking about passing functions as arguments? If so maybe [this](http://stackoverflow.com/questions/10523566/in-perl-how-do-i-pass-a-function-as-argument-of-another-function) will answer your question. — John C, May 28 '14 at 06:03
@JohnC not just pass function, I want to pass curried function. — Sawyer, May 28 '14 at 06:05
I was going to ask where the second param had gone . . . but you have answered that in the above comment. I think that is worth adding to the question. You can do this in Perl. Note that currying a function is more than just resolving the param, it usually involves pre-calculating the effects of that param and generating a *new* function, which you cannot do with a pre-existing function. — Neil Slater, May 28 '14 at 06:08

Neil Slater · Accepted Answer · 2014-05-28T09:45:13.480

You can do this in Perl with two approaches combined:

A function which returns a function reference
Closures

Example:

sub each_file {
    my ($arr, $line_fn) = @_;
    $line_fn->($_) for @{$arr};
    ...
} 

sub each_line {
    my ($op, $file) = @_;
    ... 
}

sub make_line_processor {
  my ( $op ) = @_;

  # This is closed over $op, which effectively becomes 
  # a constant for the returned function
  my $fn = sub {
     return each_line( $op, @_ );
  };
  return $fn;
}


# To call it:
each_file( $arr, make_line_processor($op) );

This can be an even more useful technique in cases where you don't want $op directly, but some expensive-to-fetch derivation of it. In which case you would calculate the derived value just once (in the make_line_processor function) and close over that instead.

Not bad, I've seen this in Modern Perl, probably the furthest Perl can reach, I've just started using Perl, maybe my guess is not accurate. — Sawyer, May 28 '14 at 06:41

Lumi · Answer 2 · 2014-05-28T07:08:48.733

1

# given some $op as implied by your code snippet
each_file($arr, sub { each_line($op, shift) });
# shift op will be applied when anonymous sub { … } is called

(Your code snippet doesn't make it entirely clear what you intend $op to be when you make the call to each_line. It's usually better to present small working programs.)

edited May 28 '14 at 07:08

answered May 28 '14 at 07:03

Lumi

14,775
8
59
92

score 0 · Answer 3 · answered Oct 07 '16 at 04:45

You can roll this functionality up into a class. Then you can overload the subroutine dereference operator to make it look like your class is really a code reference.

package Partial;

use overload '&{}' => \&call;

sub new {
    my $class = shift;
    my $code = shift;
    bless {code => $code, args => \@_}, $class;
}

sub call {
    my ($self) = @_;
    return sub{ $self->{code}->(@{$self->{args}}, @_) }
}

You can then use it like this:

sub printArgs {
    print join ", ", @_;
    print "\n";
}

my $partial = Partial->new(\&printArgs, 'foo', 'bar');
$partial->('baz', 'bat');
# prints foo, bar, baz, bat

How can I do function partial application in Perl?

3 Answers3