ge is copy )
{
$message ~~ s:P5:g/\n(?!#)/\n# /;
$.output.say( $message );
}
method diag ( Str $message is copy )
{
$message ~~ s:P5/^(?!#)/# /;
$message ~~ s:P5:g/\n(?!#)/\n# /;
C<@array>, in order.
If C<@indextests> are provided, only elements whose indices match
C<$index ~~ any(@indextests)> are iterated.
What is returned at each element of the iteration varies with fun
atchTest $test ; *@values --> Lazy ) {
gather {
for @values -> $x {
take $x if $x ~~ $test;
}
}
}
=item join
multi Array::join (@values, Str $delimiter --> Str )
multi
C<%hash> doesn't change.
If C<@keytests> are provided, only elements whose keys evaluate
C<$key ~~ any(@keytests)> as true are iterated.
What is returned at each element of the iteration varies wi
ation of a Perl5 regular expression to Perl6:
Was: $str =~ m/^\d{2,5}\s/i
Now: $str ~~ m:P5:i/^\d{2,5}\s/
The C<:P5> modifier is there because the standard Perl6 syntax is rather
diffe
erl5 compatibility syntax. For a substitution:
Was: $str =~ s/(a)/$1/e;
Now: $str ~~ s:P5/(a)/{$0}/;
Notice that C<$1> starts at C<$0> now, and C</e> is gone
in favor of the embedded
of C<Capture>
when you want to refer only to a single item.
Was: ref $foo eq 'HASH'
Now: $foo ~~ Hash
Was: @new = (ref $old eq 'ARRAY' ) ? @$old : ($old);
Now: @new = @$old;
Was: %h = ( k
my $class = splitdir($rel).join('::');
$class ~~ s:P5/\.pm$//;
next unless $class ~~ m:P5/^$search(\:\:|$){1}/;
try {
$clas
f.dirs = ($path);
$f.wanted_file = sub ( $file, $path, $pathfile ) {
return 1 if $file ~~ m:P5/\.pm$/;
return 0;
};
return $f.find;
}
=head1 NAME
Module::Pluggable::Fast
n 100) or alphabetically (where 100 comes
before 99).
Smart comparison
~~ smart match (see smartmatch)
!~~ negated smart match
Boolean logic
&& and
|| or
! no
if $a ~~ /foo/ { ... } # true if $a contains "foo"
The C<//> matching operator is documented in L<XXX>. It operates on
C<$_> by default, or can be bound to another variable using the C<~~>
smart
from 0 not 1;
# a cheap and nasty way to break an email address up into parts
if ($email ~~ /(<-[@]>+)@(.+)/) {
print "Username is $0\n";
print "Hostname is $1\n";
}
=it
+ set(4,5,6);
isa_ok($union, Set, "set() - infix:<+>");
my $stringified = ~$set;
ok($stringified ~~ rx:P5/^set\(.*Person.*\)$/, "prefix:<~>", :todo<bug>);
ok($union == set(0..6, $bob), "set() - inf
∋ 1), "infix:<∋>");
# Smartmatch operator
ok 42 ~~ set(23, 42, 63), "infix:<~~> works (1)";
ok not(42 ~~ set(23, 43, 63)), "infix:<~~> works (2)";
# Rubyish set operations on arrays
# Note:
b *infix:<~~> (Set $one, $member) returns Bool {
$one.includes($member);
}
# XXX -- IIRC, there's a "is commutative" or such, so duplicating shouldn't be
# necessary.
multi sub *infix:<~~> ($membe
ns_11 = $set2 ∌ 11; # or 11 ∉ $set2
# smartmatch may also be used
$contains_7 = $set2 ~~ 7;
# Set arithmetic with arrays
say ~([1,2,3] +# [1,2,6]) # 1 2 3 6 (in no particular ord
rue if all given items are in the set. C<has> is an alias for
C<includes>.
=head2 C<$set ~~ $item>, C<$item ~~ $set>
Operator version of C<.includes()>.
=head2 C<$set ∋ $item>, C<$item ∈ $set>
$message ~~ s:perl5:g {\n(?!#)}{\n# };
$.output.say( $message );
}
method diag ( Str $message is copy )
{
$message ~~ s:perl5 {^(?!#)}{# };
$message ~~ s:perl5:g {\n(
t ];
}
return *@content;
}
my sub quote($str is copy) {
$str ~~ s:g{\\}{\\\\};
$str ~~ s:g{"}{\\"};
$str ~~ s:g{\n}{\\n};
$str ~~ s:g{\015}{\\r};
return qq("$str");
}
=item C<dump>()
Returns
me (" ~ ( map -> $k, $v { qq($k="e($v)) } %.properties.kv ) ~ ")";
for @.children {
if $_ ~~ Str {
take qq( "e($_));
}
else {
take map { " $_" } $_.dump;
}
}
};
de,
concatenated together.
=cut
method text() {
return [~] gather {
for .children {
if $_ ~~ Str {
take $_;
}
else {
take $_.text();
}
}
}
}
=back 4
=head1 SEE ALSO
L<W
de { $path ~= "\{$mode}" }
my($title, $class)=("(page does not exist)", " broken");
if $path ~~ /\:/ {
$title="External link: $path";
$class=" external";
}
else {
try {
#warn "attempt
if $_ ~~ Str {
my $str=HTML::Entities::encode_entities($_);
our $skip_whitespace_escape;
unless $skip_whitespace_escape {
$str ~~ s:g{\ }{ };
$str ~~ s:g{\ \
}{ };
$str ~~ s:g{\015}{};
$str ~~ s:g{\n}{<br />};
}
take $str;
}
else {
take $self.:process_skel($_, $request);
}
}
}
}
# now try to get it processing again
MogileFS::ProcManager->ProcessQueues;
}
}
# given (job, pid), record that this worker is about to die
sub note_pending_death {
my ($job, $pid)
er. The preceding may
also be written:
use Dog-{$^ver ~~ 1.2.1 | 1.3.4}-{$^auth ~~ /:i jrandom/};
use Dog-{$^ver ~~ Any}-{$^auth ~~ /^cpan\:/}
In any event, however you select the module, i
2 { ... }
when want.List { ... }
The C<want> function can be used with smart matching:
if want ~~ List & 2 & Lvalue { ... }
Which means it can also be used in a switch:
given want {
when Li
ctation count is C<Inf>. You shouldn't
actually return an infinite list, however, unless C<< want ~~ Lazy >>.
The opposite of C<Lazy> context is C<Eager> context (the Perl 5 list
context, which alway
ve where => Parametric, value => (1,2,3);
leave Loop, label => 'LINE', $retval;
leave { $_ ~~ Block and $_ !~ Sub } 1,2,3;
leave () <== 1,2,3;
As it currently stands, the parens aren't op
MatchTest
subset MatchTest of Item | Junction;
Used to supply a test to match against. Assume C<~~> will be used against it.
=back
=head1 Function Packages
=head2 Math::Basic
=over
=item a
C<@array>, in order.
If C<@indextests> are provided, only elements whose indices match
C<$index ~~ any(@indextests)> are iterated.
What is returned at each element of the iteration varies with fun
t::grep ( MatchTest $test : *@values )
gather {
for @values -> $x {
take $x if $x ~~ $test;
}
}
}
=item join
our Str multi Array::join ( @values : Str $delimiter )
our
sh()
It returns a string that is the English version of the given language or if nothing is given (or an invalid langauage) then it returns the current source language's name.
my $source
if ($format eq "latex"){print $outputFH $latex->endFile};
}
#only work if the text files are given (not only the alignment files).
sub getSize {
my $alSet = shift;
my ($file,$factor);
my $size;
er($match)};
is( $match?1:0, 0, 'booleanify' );
}
}
# <TimToady> ?eval "a\nb" ~~ /^a$$.^^b$/
# "a\nb" ~~ m:P5/(?smx) \A a $ . ^ b \z/
{
my $rule = __PACKAGE__->compile( '^a$$.^^b$' );
ber<30>);
is($rule ~~ ::Automata::Cellular::Rule, Bool::True, '$rule object instantiated');
is($rule.rule_number(), 30, '$rule rule_number set correctly');
is($rule.rule ~~ Hash, 1, '$rule.rule
$rule_string ~= "{sprintf("%03b",$k)} becomes {+$v}\n";
}
$rule_string ~~ s:g/1/$true/;
$rule_string ~~ s:g/0/$false/;
return $rule_string;
}
}
$?OS eq 'os2' );
&readlink := { undef } if $dosish;
unless ( ( $script ~~ m:P5 [/] || ( $dosish && $script ~~ m:P5 [\\] ) )
&& -f $script )
{
for File::Spec.path(