CPAN::Groonga

 from an iso date
multi sub date( Str $iso8601 ) returns Date::Gregorian is export {

    $iso8601 ~~ $iso8601_re_anchored
        or die "can't match '$iso8601' to available ISO-8601 formats";

    m

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

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

resents a 
        # meta-circularity issue, and it
        # loops endlessly
        unless $self ~~ ::Class;
    return bool::false;
});

## I ended here ... to be continued 

::Class.HOW.add_method

ep (MatchTest $test ;   *@values --> Lazy ) {
    gather {
	for @values -> $x {
	    take $x if $x ~~ $test;
	}
    }
}


# copied from S29draft.pod 8651.
multi  List::join (Str $delimiter ; *@values 

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;

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

my @b = $pil2 ~~ $tokens;

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

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

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

    my Automata::Cellular $ca .= new(:@state, :$rule, :$steps, :$display_width);

    is($ca ~~ ::Automata::Cellular, Bool::True, '$ca object instantiated');

    is($ca.stage,  1,            

    
    for %StatusCode.kv -> $code, $message is copy {
        $message .= uc;
        $message ~~ s:g/<[ \-]>/_/;
        
        &HTTP::Status::("RC_" ~ $message) := sub () { $code };
        &H

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

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

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

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

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

;
			$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}{\

king against modestring for $mode";
		if $perms ~~ m:perl5/\b\Q$mode\E\(([^)]*)\)/ {
#			say $ERR: "        $0";
			my $allowed = ~$0;
			if $allowed ~~ m:perl5/(?:^| )(?:any|\Q$userpath\E)\b/ {
#				

say $ERR: "        OK";
				return;
			}
			elsif $allowed ~~ m:perl5/(?:^| )-(?:any|\Q$userpath\E)\b/ {
#				say $ERR: "        Blocked";
				last;
			}
		}
	}
#	say $ERR: "    Failed--throwing excep

.
 */
var ObservableMethodProvider = {
	/**
	 * Will return an observable function on the method given (as a string)
	 * bound to the called instance and will return the same observable
	 * function e