Whatever - a perl6ish whatever-star for perl5
Version 0.23
this module provides a whatever-star * term for perl 5. since this module is not a source filter, the name &* or $* is as close as it's going to get.
*
&*
$*
use Whatever; my $greet = 'hello, ' . &* . '!'; say $greet->('world'); # prints 'hello, world!'
what was:
my $result = $someobj->map(sub{$_ * 2});
can now be:
my $result = $someobj->map(&* * 2);
&* the whatever-star $* the whatever-star ($* is deprecated in 5.10+, so I'm taking it) &@ the gets-val-from-@_-star &_ the gets-val-from-$_-star
like all punctuation variables, the whatever terms are global across all packages after this module is loaded.
the &* and $* stars are the most generic terms, which return their expression as a coderef that will take its argument from $_[0] if it is available, or $_ otherwise. this allows the terms to dwim in most contexts. think of the whatever star as sub {@_ ? $_[0] : $_}
$_[0]
$_
sub {@_ ? $_[0] : $_}
the &@ term always uses $_[0], while the &_ always uses $_
&@
&_
beyond where they get their eventual argument from, all of the whatever terms behave the same way. each is a sticky overloaded object that will bind to the operators and variables that it interacts with. at all times the whatever star is a coderef that will perform the actions it has accumulated when passed a value to act on.
a few more examples are probably in order:
my $greet = "hello, $*!"; # the $* term interpolates in strings say $greet->('world'); # prints 'hello, world!' say "hello, $*!"->('world');
my $inc = $* + 1; say $inc->(5); # prints 6 my $inc_x2 = $inc * 2; # whatever code continues to capture operations say $inc_x2->(5); # prints 12 my $inc_inc = $inc->($inc); # and is fine with recursion say $inc_inc->(5); # prints 7 my $repeat = &* x &*; my $line = $repeat->('-'); my $hr = $line . "\n"; print $hr->(80); # prints ('-' x 80)."\n"
assuming this simple Array implementation:
Array
{package Array; sub new {shift; bless [@_]} sub map {new Array map $_[1]() => @{$_[0]}} sub grep {new Array grep $_[1]() => @{$_[0]}} sub str {join ' ' => @{$_[0]}} } my $array = new Array 1 .. 10; say $array->map(&_ * 2)->str; # '2 4 6 8 10 12 14 16 18 20' say $array->map(&_ * 2)->map(&_ + 1)->str; # '3 5 7 9 11 13 15 17 19 21' say $array->map(&_ * 2 + 1)->str; # '3 5 7 9 11 13 15 17 19 21'
my $str = &*->str; say $str->($array); # prints '1 2 3 4 5 6 7 8 9 10' my $multi_call = &*->map(&_ * 2 + 1)->grep(&_ % 5)->str; say $multi_call->($array); # prints '3 7 9 11 13 17 19 21' $some_obj->map(&*->some_method(...));
arguments of method calls are copied by alias if Array::RefElem is installed. this provides closure like behavior. otherwise, the values are fixed to whatever they were at the time of declaration.
when working with subs created by combining multiple stars, you can bind multiple values at once by passing multiple arguments.
my $join3 = &* . &* . &*; say $join3->(1)(2)(3); # prints '123' say $join3->(1 .. 3); # prints '123' my $indent = $join3->(' ', ' '); say $indent->('xyz'); # prints ' xyz'
you can dereference a whatever star as an array or hash (of course the star expects to be passed a suitable reference):
my $first = &*->[0]; my $bob = &*->{bob}; say $first->([3 .. 5]); # prints '3' say $bob->({bob => 5}); # prints '5'
the subroutine returned by the star is a valid lvalue (can be assigned to). multi-level calls and calls that would normally autovivify behave as expected.
&*->[0][0]{x}(my $array) = 4; say $$array[0][0]{x}; # prints '4'
the stars lazily bind to variables, which allows the variable to get its value after the star is defined, and to change its value between calls. this is analogous to an anonymous sub closing over a variable
my $future; my $delorean = $future . (' ' . $* . '!'); # works like: sub {$future . (' ' . $_[0] . '!')}; $future = 1.21; say $delorean->('gigawatts'); # prints "1.21 gigawatts!" $future = &*; say $delorean->('folks')->("that's all"); # prints "that's all folks!"
Eric Strom, <asg at cpan.org>
<asg at cpan.org>
this module is new, there are probably some.
please report any bugs or feature requests to bug-whatever at rt.cpan.org, or through the web interface at http://rt.cpan.org/NoAuth/ReportBug.html?Queue=Whatever. I will be notified, and then you'll automatically be notified of progress on your bug as I make changes.
bug-whatever at rt.cpan.org
those behind the perl6 whatever-star
copyright 2010 Eric Strom.
this program is free software; you can redistribute it and/or modify it under the terms of either: the GNU General Public License as published by the Free Software Foundation; or the Artistic License.
see http://dev.perl.org/licenses/ for more information.
To install Whatever, copy and paste the appropriate command in to your terminal.
cpanm
cpanm Whatever
CPAN shell
perl -MCPAN -e shell install Whatever
For more information on module installation, please visit the detailed CPAN module installation guide.