CPAN::Groonga

unction $test ; *@values) returns List {
   gather {
     for @values -> $x {
       take $x if $x ~~ $test;
     }
   }
 }

 multi sub join (Str $delimiter ; *@values) returns List {
   my $str = ~@v

{ }
    
    method parse (Str $str is copy) {
        my $request_line;
        
        if ($str ~~ s/^(.*)\n//) {
            $request_line = $0;
        } else {
            $request_line = $str;

      $str = "";
        }
        
        my $self = self.SUPER::parse($str);
        
        given ($self) {
            my ($method, $uri, $protocol) = $request_line.split(' ');
            .meth

use v6-alpha;

say "1..1";

my $str = 'abcbcaddd';

$str ~~ s:P5:g/bc/oz/;

if $str eq 'aozozaddd' { say "ok 1" } else { say "not ok 1" }

1;

uoted string
          \, | \= | \{ | \( | \[ | \} | \) | \] | \w+
        )
    };

my @b = $pil2 ~~ $tokens;

my $tabs = 1;
my $tab = '  ';
for @b {
    if $_ eq ',' { 
        print $_, "\n", $tab 

IL::Util::Pad $.parent;
    has Str @.names;

    method lookup_pad($name) {
        if (grep { $_ ~~ $name }, @.names) {
            self;
        }
        else {
            $.parent ?? $.parent.lo

int STDERR "# $jsfile\n";
    my $cmd = '../../pugs -I . -e \'use Grammar; if slurp("'.$jsfile.'") ~~ /^<JavaScript::ECMAScript3::Grammar::Spec::Program>$/ {say "ok"}else{say "not ok"}\' 2>&1';
    pr

my $src = "";
while $_ = =<> {$src ~= $_;}

my $m = $src ~~ rx/oo/;
say "(mapcar 'delete-overlay (overlays-in (point-min) (point-max)))";
say "(overlay-put (make-overlay {$m.from +1} {$m.to +1} nil 

er indicates language pref as command line argument
    my Str @user_lang_prefs = @*ARGS.grep:{ $_ ~~ m/^<[a-zA-Z]>+$/ };
    @user_lang_prefs = 'Eng'
        if @user_lang_prefs == 0;

    my Locale:

 $ret;
}

my @pil2 = =<>;
my $pil2 = @pil2.join('');

# my $pil2 = =<>.slurp;   ???

my @b = $pil2 ~~ $tokens;
# say "Tokens: ", @b.join('><');
my $ast = parse( << { >>, 'hash', << } >>, @b );
say $as

Kiss;

=cut

my $RAND = Math::Random::Kiss.new();

ok($RAND, 'new() Math::Random::Kiss');
ok($RAND ~~ Rand, 'Math::Random::Kiss does Rand');

ok($RAND.rand() >= 0, 'rand() returns numbers greater than

 WTemplate

=cut

#use_ok('WTemplate');
skip_rest "unreliable test results"; exit;

if eval('!("a" ~~ /a/)') { skip_rest "skipped tests - rules support appears to be missing"; exit }

my $template;
my

hTest $test ;   *@values) returns Lazy {
   gather {
     for @values -> $x {
       take $x if $x ~~ $test;
     }
   }
 }
 multi sub Array::join (@values,   Str $delimiter) returns Str
 multi sub  P

;
#my $pil2 = @pil2.join('');

# slurp stdin - xinming++ 
my $pil2 = ** $*IN.slurp;

my @b = $pil2 ~~ $tokens;
# say "Tokens: ", @b.join('><');
my $ast = parse( << { >>, 'hash', << } >>, @b );
# say $

d	y	$&	ab
a(?{"{"}})b	-	c	-	Unmatched right curly bracket
a(?{$bl="\{"}).b	caxbd	y	$bl	{
x(~~)*(?:(?:F)?)?	x~~	y	-	-
^a(?#xxx){3}c	aaac	y	$&	aaac
'^a (?#xxx) (?#yyy) {3}c'x	aaac	y	$&	aaac
(?<![cd])b	d

#=Beispielverknüpfungen
$a != $b;
$a ~~ $b;    # smart-match, mehr dazu gleich
#=Verknüpfungen in Perl 5:
$a < $b && $b <= $c;
$a > $b && $b >= $c;
#=Perl 6: Verkettung ist möglich:
$a < $b <= $c;

 rules, Captures are superclasses of Match. So in the example of:
    
    my $rv = ("x-y-z-moose" ~~ /(.)-(.)-(.)-<animal> :{ return give_birth(|$/) })

C<give_birth()> gets called with 'x', 'y', and

 "This should never happen"}
 		default {
		  my @index = split('',$didget);
		  @index = grep {$_ ~~ /^<[A..Za..z0..9+\/=]>+$/},@index;
		  [~] map {chr ($_)}, decode(@index)}
  }
}

#        1716151

t';
@INC = '../lib';

# Don't interfere with the taintedness of %ENV, this could perturbate tests
%ENV<PERL_CORE> = 1 unless $*TAINT;

$0 ~~ s/\.dp$//; # for the test.deparse make target
1;

$var_name, $var_value {
        my Str $var_value_as_str = $var_value // $EMPTY_STR;
        $text ~~ s:g/\<$var_name\>/$var_value_as_str/;
    }

    return $text;
}

################################

item) returns Str {
    my $str_item = ~$item;
    $str_item ~= $item.WHICH()
        if $str_item ~~ rx:perl5/^\<obj\:/; #/#cperl-mode--
    return $str_item;
}

method insert($self: *@items) returns

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