NAME

Sub::Curried - automatically curried subroutines

SYNOPSIS

curry add_n_to ($n, $val) {
   return $n+$val;
}

my $add_10_to = add_n_to( 10 );

say $add_10_to->(4);  # 14

# but you can also
say add_n_to(10,4);  # also 14

# or more traditionally
say add_n_to(10)->(4);

DESCRIPTION

Currying and Partial Application come from the heady world of functional programming, but are actually useful techniques. Partial Application is used to progressively specialise a subroutine, by pre-binding some of the arguments.

Partial application is the generic term, that also encompasses the concept of plugging in "holes" in arguments at arbitrary positions. Currying is more specifically the application of arguments progressively from left to right until you have enough of them.

DEPENDENCIES

Beyond those listed in META.yml/META.json, there is an optional dependency on PPR: if you have it installed, then your curry definitions can include POD syntax anywhere whitespace can occur between curry and {. Without PPR, that will trigger a syntax error.

If your Perl is older than 5.16, you'll also need Sub::Current.

USAGE

Define a curried subroutine using the curry keyword. You should list the arguments to the subroutine in parentheses. This isn't a sophisticated signature parser, just a common separated list of scalars (or @array or %hash arguments, which will be returned as a reference).

curry greet ($greeting, $greetee) {
    return "$greeting $greetee";
}

my $hello = greet("Hello");
say $hello->("World"); # Hello World

Currying

Currying applies the arguments from left to right, returning a more specialised function as it goes until all the arguments are ready, at which point the sub returns its value.

curry three ($one,$two,$three) {
    return $one + $two * $three
}

three(1,2,3)  # normal call - returns 7

three(1)      # a new subroutine, with $one bound to the number 1
    ->(2,3)   # call the new sub with these arguments

three(1)->(2)->(3) # You could call the curried sub like this,
                   # instead of commas (1,2,3)

What about calling with no arguments? By extension that would return a function exactly like the original one... but with no arguments prebound (i.e. it's an alias!)

my $fn = three;   # same as my $fn = \&three;

Anonymous curries

Just like you can have anonymous subs, you can have anonymous curried subs:

my $greet = curry ($greeting, $greetee) { ... }

Composition

Curried subroutines are composable. This means that we can create a new subroutine that takes the result of the second subroutine as the input of the first.

Let's say we wanted to expand our greeting to add some punctuation at the end:

curry append  ($r, $l) { $l . $r }
curry prepend ($l, $r) { $l . $r }

my $ciao = append('!') << prepend('Ciao ');
say $ciao->('Bella'); # Ciao Bella!

How does this work? Follow the pipeline in the direction of the <<... First we prepend 'Ciao ' to get 'Ciao Bella', then we pass that to the curry that appends '!'. We can also write them in the opposite order, to match evaluation order, by reversing the operator:

my $ciao = prepend('Ciao ') >> append('!');
say $ciao->('Bella'); # Ciao Bella!

Finally, we can create a shell-like pipeline:

say 'Bella' | prepend('Ciao ') | append('!'); # Ciao Bella!

The overloaded syntax is provided by Sub::Composable which is distributed with this module as a base class.

Argument aliasing

When all the arguments are supplied and the function body is executed, the arguments values are available in both the named parameters and the @_ array. Just as in a normal subroutine call, the elements of @_ (but not the named parameters) are aliased to the variables supplied by the caller, so you can use pass-by-reference semantics.

curry set ($a, $b) {
  foreach my $arg (@_) { $arg = 1; } # affects the caller
  $a = $b = 2;                       # doesn't affect the caller
}
my ($x, $y) = (0, 0);
set($x)->($y); # $x == 1, $y == 1

Stack traces

The innermost stack frame has the function name you defined, with all the accumulated arguments. Any intermediate stack frames have the same or similar function names; currently there is a __curried suffix, but that may change in the future. Currently there is only one intermediate stack frame, showing just the arguments that were passed in the final call that reached the required number of arguments, but that may change in the future. If you supply all the arguments in one call, there are no intermediate stack frames.

use Carp 'confess';
curry func ($a, $b, $c, $d) {
  confess('ERROR MESSAGE');
}
sub call {
  func(1)->(2)->(3, 4);
}
call();

ERROR MESSAGE at script.pl line 3
       main::func(1, 2, 3, 4) called at .../Sub/Curried.pm line 202
       main::func__curried(3, 4) called at script.pl line 6
       main::call() called at script.pl line 8

BUGS

No major bugs currently open. Please report any bugs via RT or email.

SEE ALSO

Keyword::Pluggable provides the syntactic magic.

There are several modules on CPAN that already do currying or partial evaluation:

• Perl6::Currying - Filter based module prototyping the Perl 6 system

• Sub::Curry - seems rather complex, with concepts like blackholes and antispices. Odd.

• AutoCurry - creates a currying variant of all existing subs automatically. Very odd.

• Sub::DeferredPartial - partial evaluation with named arguments (as hash keys). Has some great debugging hooks (the function is a blessed object which displays what the current bound keys are).

• Attribute::Curried - exactly what we want minus the sugar. (The attribute has to declare how many arguments it's expecting)

AUTHOR

(c)2008-2013 osfameron@cpan.org
(c)2024 Paul Jarc <purge@cpan.org>

CONTRIBUTORS

• Florian (rafl) Ragwitz

LICENSE

This module is distributed under the same terms and conditions as Perl itself.

CONTRIBUTING

Please submit bugs to RT or email.

A git repo is available at https://github.com/pauljarc/Sub--Curried

cpanm Sub::Curried

perl -MCPAN -e shell
install Sub::Curried