Group
Extension

Matches 1452

Perl6-Pugs ( A/AU/AUDREYT/Perl6-Pugs-6.2.13.tar.gz, AUDREYT, 2006; MetaCPAN )
Perl6-Pugs/ext/Test-Builder/lib/Test/Builder/Output.pm ( view source; MetaCPAN )
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# /;
    
Perl6-Pugs ( A/AU/AUDREYT/Perl6-Pugs-6.2.13.tar.gz, AUDREYT, 2006; MetaCPAN )
Perl6-Pugs/src/PIL/misc/S29code.pl ( view source; MetaCPAN )
 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
Perl6-Pugs ( A/AU/AUDREYT/Perl6-Pugs-6.2.13.tar.gz, AUDREYT, 2006; MetaCPAN )
Perl6-Pugs/docs/Perl6/Perl5/Differences.pod ( view source; MetaCPAN )
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
Perl6-Pugs ( A/AU/AUDREYT/Perl6-Pugs-6.2.13.tar.gz, AUDREYT, 2006; MetaCPAN )
Perl6-Pugs/ext/Module-Pluggable-Fast/lib/Module/Pluggable/Fast.pm ( view source; MetaCPAN )
             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 
Perl6-Pugs ( A/AU/AUDREYT/Perl6-Pugs-6.2.13.tar.gz, AUDREYT, 2006; MetaCPAN )
Perl6-Pugs/docs/Perl6/Overview.pod ( view source; MetaCPAN )
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
Perl6-Pugs ( A/AU/AUDREYT/Perl6-Pugs-6.2.13.tar.gz, AUDREYT, 2006; MetaCPAN )
Perl6-Pugs/ext/Set/t/overload.t ( view source; MetaCPAN )
 + 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:
Perl6-Pugs ( A/AU/AUDREYT/Perl6-Pugs-6.2.13.tar.gz, AUDREYT, 2006; MetaCPAN )
Perl6-Pugs/ext/Set/lib/Set.pm ( view source; MetaCPAN )
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>
Perl6-Pugs ( A/AU/AUDREYT/Perl6-Pugs-6.2.13.tar.gz, AUDREYT, 2006; MetaCPAN )
Perl6-Pugs/misc/old_pugs_perl5_backend/Perl6-MetaModel/ext/Test-Builder/lib/TestBuilder/Output.pm ( view source; MetaCPAN )

      $message ~~ s:perl5:g {\n(?!#)}{\n# };
      $.output.say( $message );
  }
  
  method diag ( Str $message is copy )
  {
      $message ~~ s:perl5 {^(?!#)}{# };
      $message ~~ s:perl5:g {\n(
WWW-Kontent ( B/BR/BRENTDAX/WWW-Kontent-0.02.tar.gz, BRENTDAX, 2005; MetaCPAN )
WWW-Kontent/WWW/Kontent/Skeleton.pm ( view source; MetaCPAN )
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=&quote($v)) } %.properties.kv ) ~ ")";
		for @.children {
			if $_ ~~ Str {
				take qq(    &quote($_));
			}
			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
WWW-Kontent ( B/BR/BRENTDAX/WWW-Kontent-0.02.tar.gz, BRENTDAX, 2005; MetaCPAN )
WWW-Kontent/WWW/Kontent/Renderer/HTML.pm ( view source; MetaCPAN )
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{\	}{&nbsp;&nbsp;&nbsp; };
					$str ~~ s:g{\ \
 }{&nbsp; };
					$str ~~ s:g{\015}{};
					$str ~~ s:g{\n}{<br />};
				}
				take $str;
			}
			else {
				take $self.:process_skel($_, $request);
			}
		}
	}
}
mogilefs-server ( B/BR/BRADFITZ/mogilefs-server-2.17.tar.gz, BRADFITZ, 2007; MetaCPAN )
mogilefs-server/lib/MogileFS/ProcManager.pm ( view source; MetaCPAN )
   # 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) 
Perl6-Bible ( A/AU/AUTRIJUS/Perl6-Bible-0.30.tar.gz, AUTRIJUS, 2006; MetaCPAN )
Perl6-Bible/lib/Perl6/Bible/S11.pod ( view source; MetaCPAN )
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
Perl6-Bible ( A/AU/AUTRIJUS/Perl6-Bible-0.30.tar.gz, AUTRIJUS, 2006; MetaCPAN )
Perl6-Bible/lib/Perl6/Bible/A06.pod ( view source; MetaCPAN )
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
Perl6-Bible ( A/AU/AUTRIJUS/Perl6-Bible-0.30.tar.gz, AUTRIJUS, 2006; MetaCPAN )
Perl6-Bible/lib/Perl6/Bible/S29.pod ( view source; MetaCPAN )
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 
AltaVista-BabelFish ( D/DM/DMUEY/AltaVista-BabelFish-v42.0.2.tar.gz, DMUEY, 2007; MetaCPAN )
AltaVista-BabelFish/BabelFish.pm ( view source; MetaCPAN )
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
Lingua-AlignmentSet ( P/PL/PLAMBERT/Lingua-AlignmentSet-1.1.tgz, PLAMBERT, 2007; MetaCPAN )
Lingua-AlignmentSet/AlignmentSet.pm ( view source; MetaCPAN )
   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;
Perl6-Pugs ( A/AU/AUDREYT/Perl6-Pugs-6.2.13.tar.gz, AUDREYT, 2006; MetaCPAN )
Perl6-Pugs/perl5/Pugs-Compiler-Rule/t/12-plain_regex.t ( view source; MetaCPAN )
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$' );
  
Perl6-Pugs ( A/AU/AUDREYT/Perl6-Pugs-6.2.13.tar.gz, AUDREYT, 2006; MetaCPAN )
Perl6-Pugs/ext/Automata-Cellular/t/rule.t ( view source; MetaCPAN )
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 
Perl6-Pugs ( A/AU/AUDREYT/Perl6-Pugs-6.2.13.tar.gz, AUDREYT, 2006; MetaCPAN )
Perl6-Pugs/ext/Automata-Cellular/lib/Automata/Cellular/Rule.pm ( view source; MetaCPAN )
      $rule_string ~= "{sprintf("%03b",$k)} becomes {+$v}\n";
        }
        $rule_string ~~ s:g/1/$true/;
        $rule_string ~~ s:g/0/$false/;
        return $rule_string;
    }

}
            
Perl6-Pugs ( A/AU/AUDREYT/Perl6-Pugs-6.2.13.tar.gz, AUDREYT, 2006; MetaCPAN )
Perl6-Pugs/ext/FindBin/lib/FindBin.pm ( view source; MetaCPAN )
 $?OS eq 'os2' );
    &readlink := { undef } if $dosish;

    unless ( ( $script ~~ m:P5 [/] || ( $dosish && $script ~~ m:P5 [\\] ) )
                && -f $script )
    {
        for File::Spec.path(

Powered by Groonga
Maintained by Kenichi Ishigaki <ishigaki@cpan.org>. If you find anything, submit it on GitHub.