CPAN::Groonga

    push @a, "foo";
    push @a, \(1,2,3);
    push @a, "bar";
    ...
    my ($i, $j, $k);
    @a ~~ rx/
	    <,>				# match initial elem boundary
	    :(Int $i,Int $j,Int? $k)	# match tuple with 2 o

sign if $val~~Int or $val~~Str

Fancier type constraints may be expressed through a subtype:

    subset Shinola of Any where {.does(DessertWax) and .does(FloorTopping)};
    if $shimmer ~~ Shinola {.

 / x	($a op $b) op $c
    right	** =		$a op ($b op $c)
    non		cmp <=> ..	ILLEGAL
    chain	== eq ~~	($a op $b) and ($b op $c)
    list	| & ^ ¥		listop($a, $b, $c) or listop($a; $b; $c)


Note that 

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

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);
			}
		}
	}
}

 = $plugin->upper_bound($port);

Returns the maximum value for the $port, or C<undef> if none is given (assume 1).

Also L</is_sample_rate|see is_sample_rate>.

=head2 is_sample_rate

 my $max = $plug

=> 0,       
      'tmpdir'   => "$ENV{HOME}/.sdb/syntax/", 
      'command'  => 'cat %f | perl -I ~ ~/viewperl.pl'
     },

  mode = 0 (no highlight), 1 (highlight)
  tmpdir - syntax highlight requir

nes to list (a windowful).
        $incr = $window - 1;

        # Set the start to the argument given (if there was one).
        $start = $1 if $1;

        # Back up by the context amount.
        

or more arguments
are given, returns a list of table objects with those names, in the
same order given (or the number of such tables in a scalar context,
but this isn't terribly useful).

An L<C<Alzab

key of the item

=head2 $element->value

The prepared value of the item, if a prepare method was given (otherwise, this is just the original item)

=head2 $element->rank

The rank of the item in the s

 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

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# /;
    

             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 

      $message ~~ s:perl5:g {\n(?!#)}{\n# };
      $.output.say( $message );
  }
  
  method diag ( Str $message is copy )
  {
      $message ~~ s:perl5 {^(?!#)}{# };
      $message ~~ s:perl5:g {\n(

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

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>

 next
                if ( $line ~~ rx:perl5/^\s*(?:\#|\;|$)/ ) { }
                else {
                    # Handle section headers
                    if ($line ~~ rx:perl5/^\s*\[(.+?)\]\s*$/) {

$0;
                    }
                    # Handle properties
                    elsif ($line ~~ rx:perl5/^\s*([^=]+?)\s*=\s*(.*?)\s*$/) {
                        my ($key, $val) = ($0, $1);
    

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:

=head2 line

returns a row/column for the clues.

=head2 block

returns a block of the given (block) id.

=head1 AUTHOR

Kenichi Ishigaki, E<lt>ishigaki at cpan.orgE<gt>

=head1 COPYRI

 dnl
    dnl  Just an other (open)ldap feature is the usage of maill500 as mailer
    dnl  for a given (open)ldap domain (see manual page mail500).
    dnl
    dnl MAILER(`mail500', `place_here_your_o

rent user an administrator (checked against C<-uadmins>) or 
an administrator of user or group given 
(checked against L<CGI::Bus::udata|CGI/Bus/udata>)?
What names are managed by current user?

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