CPAN::Groonga

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

#        1716151

 $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

Pipe::open("$PIL $optional_args $tempfilename");
  my $pilresult = $pilfh.readline();
  $pilresult ~~ s:P5/\r//;
  $pilfh.close();
  unlink($tempfilename);
  return $pilresult;
}

$Test::Pil::Descript

use v6-alpha;

#package PIL2;

my $debug_traverse = 0;

# tokenizer

sub tokenize ( $s ) {
    $s ~~ m:g:perl5 {(\"(?:\\\\|\\"|.)*?\"|[\:\,\=\{\(\[\}\)\]]|\w+)};   #" 
}

# JSON parser - creates an A

% 26];
            @.table[@lower[$_]] = @lower[($_ + $shift) % 26];
        }
    }

    if $mode ~~ m:P5:i/^de/ {
        my @tt;
        for @.table.kv { @tt[$^value] = $^key }
        @.table = @t

er .= chomp;
    },
    string  => -> ($str)  { $buffer ~= $str  }   
);

my $file = $?FILE;
$file ~~ s:P5/basic.t/sample.kwid/;

lives_ok {
    parse($file, %events);
}, '... we parsed the sample fil

use v6-alpha;
use Test;

plan 1;

use Text::Glob;

my $regex = Text::Glob.new.glob_to_regex('*.pm');
ok 'Glob.pm' ~~ $regex, 'glob_to_regex works';

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;

{ }
    
    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

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 

l elements

    given $x { ... }   # $x is now topic for block
    when EXPR { ... }  # perform $_ ~~ EXPR execute block and break
    default { ... }    # same as when true { ... }    

=head2 Closur

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

= %*ENV<QUERY_STRING> // %*ENV<REDIRECT_QUERY_STRING>;
            
            if ($.query_string ~~ /<[;&=]>/) {
                $.query.parse_params($.query_string);
            } else {
          

it's all just "perl 6" regardless of the runtime they are going to use on the system.


[foo.pl]
given (use (perl5:DBI | java:JDBC)) {
    when /perl5/ { ... }
    when /java/ { ... }
};

[foo.p6o]
- 

readme.txt'   => 'README',
);

my @Tempfiles = qw(
    pod2htmd.tmp
    pod2htmd.x~~
    pod2htmi.tmp
    pod2htmi.x~~
);

use strict;
use File::Copy;
local $/;

foreach my $target (keys %TEXT) {
    

ion. Required. 

=item sense

    $obj->sense;

Internal method. Iterates over all senses of the given (via init) term and returns a reference to a list of the best senses. Takes no arguments.

=item 

onyms

    $obj->hyponyms($synset);

Internal method. Returns a list of hyponyms (synsets) for a given (as argument) word. If the synset argument is not provided, undefined or an empty string, the met

yms

    $obj->hypernyms($synset);

Internal method. Returns a list of hypernyms (synsets) for a given (as argument) word. If the synset argument is not provided, undefined or an empty string, the met

ater on.

It is possible to specify more than one field/value pair, but then the mode 
should be given (but it will default to 'and' otherwise). Use as many
field/value-pairs as required. The mode can

28"

By the way, there is also a high precedence logical xor operator in
Perl 6. You guessed it: C<~~>. This finally fills the strange gap in
Perl's logical operator set:

        Binary (low) | Binar

any> Perl 6 subroutine. For
example:

    sub mean (*@values : $type //= 'arithmetic') {
        given ($type) {
            when 'arithmetic': { return sum(@values) / @values; }
            when 'geo

 operators:

=over

=item *

unary C<_> is the explicit string context enforcer

=item *

binary C<~~> is high-precedence logical xor

=item * 

unary C<*> is a list context specifier for parameters a

nite strings in
parallel, though that seems a bit scary.

[Update: The C<=~> operator is renamed C<~~>, and it doesn't automatically
"any-fy" an array anymore, so we could pretty easily make it work o

 backtrack over C<< <cut> >>, the entire match
will fail.)

[Update: Now we can just say C<<@lines ~~ s/^.*? \n**{2...} //>>.]

=head2 RFC 110: counting matches

I think we can avoid using any options

tingly, that can also be written:

    / <( _/\d+/ =~ 1..10 )> /

[Update: That'd be C<< <( ~/\d+/ ~~ 1..10 )> >> these days.]

=head2 RFC 198: Boolean Regexes

Again, I'm not much in favor of inventi

;
			$name ~~ s:g/<[ _]>+/_/;
			$name ~~ s:g/\W//;
			$page.name = $name;
		}
		
		if $request.mode eq 'create' | 'edit' and $p<action> eq 'save' {
			$.revision.attributes<kiki:content> ~~ s:g{\n}{\