Curry is a L<Raku|https://www.raku-lang.ir/en> module for currying functions plus partially applying them.


use v6.d;

use Curry::PreserveParams:auth<zef:CIAvash>;



Curry - a L<Raku|https://www.raku-lang.ir/en> module for currying functions.


NAME

DESCRIPTION

code

=begin code :lang<raku>

use Curry:auth<zef:CIAvash> :all;

# Curried subs
sub f ($a, $b) is curry {
    $a × $b;
}
my &pf = f 2;
say pf 3;
=output 6␤

sub f2 ($a, $b, :$c = 1) is curry {
    [×] $a, $b, $c;
}
my &pf2 = f 2, :c(4);
say pf 3;
=output 24␤

sub f3 (*@a) is curry {
    [×] @a;
}
my &pf3 = f 2, 3;
say pf;
=output 6␤
say pf(4)();
=output 24␤

# Curried method and attribute
my class C {
    has &.f is curry is rw;

    method m (Int $a, Int $b) is curry {
        $a × $b;
    }
}
my C $c .= new;
# Method
say $c.m(2, 3)()
=output 6␤
my &pm = $c.m(2, 3);
say pm;
=output 6␤
say pm(4)();
=output 24␤
# Attribute
$c.f = * + *;
say $c.f.(1, 2);
=output 3␤
my &pa = $c.f.(1);
say pa 2;
=output 3␤

# Making Curry
my &f3 = Curry[* + *];
# Or
my &f4 = make_curry * + *;

my &cgrep = Curry[&grep];
# Or better
my &cgrep2 = new_curry &grep;

# Be careful with this
make_curry &grep;
# Or
make_curryable &grep; # This changes function's signature
# Original function (before being curried)
my &lost_grep = &grep.original_function;

=end code


SYNOPSIS

You need to have L<Raku|https://www.raku-lang.ir/en> and L<zef|https://github.com/ugexe/zef>,
then run:


=begin code :lang<console>

zef install --/test Curry:auth<zef:CIAvash>

=end code


=begin code :lang<console>

zef install .

=end code


INSTALLATION

=begin code :lang<console>

prove -ve 'raku -I.' --ext rakutest

=end code


TESTING

ROLES


#| Curry role takes a function as parameter and does the C<Callable> role
role Curry:auth($?DISTRIBUTION.meta<auth>):ver($?DISTRIBUTION.meta<version>) [Code:D $function] does Callable {
    #| Calls the function if all parameters are provided or returns a partially applied function
    method CALL-ME (|c) {
        my Int:D $named_params = +$function.signature.params.grep: *.named;

        if $function.arity == c == 0 or $function.count + $named_params == c + c.hash {
            $function(|c);
        } else {
            self.curry: |c;
        }
    }

    #| Like C<assuming> but returns a Curry. And tries to preserve the parameters of the partial function.
    #| Unfortunately cannot do so for the default value of optional positional parameters.
    method curry (|c --> Curry:D) {
        my &curried_function = $function.assuming: |c;
        &curried_function does Curry::PreserveParams::InSub[&curried_function.signature, $function.signature, c];
        make_curry &curried_function;
    }

    #| Returns the original function, the function that was curried
    method original_function returns Code:D {
        $function;
    }
}

#| A role with a signature that captures all arguments
role Curry::CaptureAll {
    method signature {
        :(|);
    }
}



SUBS


proto make_curry (|) is export(:all, :subs) {*}

#| Takes a function, gives a cloned version of it to C<Curry>, then adds the role to the function
multi make_curry (Code:D $f --> Curry:D) {
    $f does Curry[$f.clone];
}

#| Takes functions, gives a cloned version of each to C<Curry>, then adds the role to the function
multi make_curry (*@f where .all ~~ Code:D --> Array[Curry:D]) {
    Array[Curry:D].new: |@f.map: { samewith $_ };
}

proto new_curry (|) is export(:all, :subs) {*}

#| Takes a function, creates a copy of it with role C<Curry> mixed in
multi new_curry (Code:D $f --> Curry:D) {
    $f but Curry[$f];
}

#| Takes functions, creates a copy of each with role C<Curry> mixed in
multi new_curry (*@f where .all ~~ Code:D --> Array[Curry:D]) {
    Array[Curry:D].new: |@f.map: { samewith $_ };
}

proto make_curryable (|) is export(:all, :subs) {*}

#| Takes a function and returns a curried function that does C<Curry::CaptureAll>
multi make_curryable (Code:D $f --> Curry:D) {
    make_curry $f;
    $f does Curry::CaptureAll;
}

#| Takes functions and returns an array of curried functions that do C<Curry::CaptureAll>
multi make_curryable (*@f where .all ~~ Code:D --> Array[Curry:D]) {
    Array[Curry:D].new: |@f.map: { samewith $_ };
}

#| C<is curry> trait for C<Sub>; Makes the function a curried function that does C<Curry::CaptureAll>
multi trait_mod:<is>(Sub:D $sub, :$curry!) is export(:all, :traits) {
    make_curryable $sub;
}

#| C<is curry> trait for C<Method>; Makes the function a curried function that does C<Curry::CaptureAll>
multi trait_mod:<is>(Method:D $method, :$curry!) is export(:all, :traits) {
    make_curryable $method;
}

#| C<is curry> trait for C<Attribute>; Makes the function a curried function that does C<Curry::CaptureAll>.
#| If you want to be able to set the function from outside of the class, you need to make the attribute writable
#| with C<is rw>. Setting the attribute with C<new> doesn't work, only assignment works.
multi trait_mod:<is>(Attribute:D $attribute, :$curry!) is export(:all, :traits) {
    $attribute.set_build: -> \SELF, | {
        my $value = $attribute.get_value: SELF;

        $attribute.set_value: SELF, Proxy.new: FETCH =>          { $value },
                                               STORE => -> $, $f { $value = make_curryable $f }
    }
}



REPOSITORY

L<https://github.com/CIAvash/Curry/issues>


Siavash Askari Nasr - L<https://www.ciavash.name>


AUTHOR

COPYRIGHT

Curry is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at yoption) any later version.


Curry is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.


You should have received a copy of the GNU Lesser General Public License
along with Curry.  If not, see <http://www.gnu.org/licenses/>.


LICENSE

root

PreserveParams

README

React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>

=item1 B<Resources>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>

=end nested
=begin nested :!nested

=item1 B<Resoures>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=end React


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


Curry - a Raku module for currying functions.

NAME

SYNOPSIS

INSTALLATION

TESTING

ROLES

SUBS

REPOSITORY

BUG

AUTHOR

COPYRIGHT

LICENSE

Curry v0.1.0

Authors

License

Dependencies

Test Dependencies

Provides

Documentation