CPAN::Groonga

                                                             ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< ~~ 
                                                               $db_xref_str,
.		
		write STDOUT;

 ($value ~~ s:P5/^\s*(=*[^\s=;,]+)//) {
                push @current, ~$0;  # 'token' or parameter 'attribute'
                
                # a quoted value
                if ($value ~~ s:P5/^\s

 = ~$0;
                    $val ~~ s:P5:g/\\(.)/$0/;
                    push @current, $val;
                # some unquoted value
                } elsif ($value ~~ s:P5/^\s*=\s*([^;,\s]*)//) {
   

                 my $val = ~$0;
                    $val ~~ s:P5/\s+$//;
                    push @current, $val;
                # no value, a lone token
                } else {
                    

 if $proto ~~ JSX::null;
    return $proto.<[[Get]]>($P);
}
# 8.6.2.2
method <[[Put]]> ($O: JSX::String $P, JSX::Value $V) {
    my $Result1 = $O.<[[CanPut]]>($P);
    return if $Result1 ~~ JSX::false

        return JSX::true;
    }
    my $proto = $O.<[[Prototype]]>;
    return JSX::true if $proto ~~ JSX::null;
    return $proto.<[[CanPut]]>($P);
}
# 8.6.2.4
method <[[HasProperty]]> ($O: JSX::Stri

 $O.property_value.exists($P);
    my $proto = $O.<[[Prototype]]>;
    return JSX::false if $proto ~~ JSX::null;
    return $proto.<[[CanPut]]>($P);
}
# 8.6.2.5
method <[[Delete]]> ($O: JSX::String $P

meters) that 
the C<Build.PL> or C<Build> script is to process according to the specifications
given (the specification hashrefs are documented in the 
L<Module::Build::API documentation|Module::Bu

::Livedoor::Wiki::Plugin::Inline::Break - Inline Break Plugin

=head1 DESCRIPTION

break text line.

=head1 SYNOPSIS

 I have a ~~ dream

=head1 FUNCTION

=head2 process

=head1 AUTHOR

polocky

=cut

 1;
	}
    } else {
	$options{'Indexes'} = 1;
    }
    my @aliases = '  ScriptAlias ~~apache-virtualserver-cgidir~~';

    if ($vserver->{'apache-virtualserver-enable-ssi'}) {
	unshift(@index, 'welco

lHost ~~apache-virtualserver-name~~~~apache-server-port~~>
  ServerName ~~apache-virtualserver-name~~
  ServerAdmin ~~apache-virtualserver-admin~~
  DocumentRoot ~~apache-virtualserver-pagedir~~
  Cus

mLog ~~apache-virtualserver-logdir~~ combined
  ~~apache-virtualserver-index~~
~~apache-virtualserver-aliases~~
  <Directory ~~apache-virtualserver-pagedir~~>
    ~~apache-virtualserver-options~~
  </

Str $msg) is export {
  state $is_fresh;
  $is_fresh //= 1;

  print "» " if $is_fresh;
  if $msg ~~ / $/ {
    print "$msg";
    $is_fresh = 0;
  } else {
    say $msg;
    $is_fresh++;
  }
}
sub de

s) = $event<rest> ~~ m:P5/^. ([^ ]+) :?(.*)$/;
      return unless defined $chan;
      $chan = normalize $chan;

      my @nicks = split(" ", $nicks)\
                 .map:{ ($_ ~~ m:P5/^[@+%]?(.+)/

e from the server and process it
  method readline() {
    my $line = readline $!socket;
    $line ~~ s:P5/[\015\012]*$//; # Hack to remove all "\r\n"s
    debug_recv $line if $.debug_raw;
    # We re

$s ~~ @a        # $s Element in @a
123 ~~ @a       # ?@a[123]
123 ~~ *@a      # 123 Element in @a
@a ~~ /regex/   # irgendein Element
@a ~~ @b        # alle Elemente
$s ~~ %h        # ?%h{$s}
%h ~~ /r

egex/   # ein passender Hash-Key
%a ~~ %b        # gleiche Hashes
any($a,'b',/regex/) ~~ any(@a, 'c', 'd') # cool, nicht?

Str $msg) is export {
  state $is_fresh;
  $is_fresh //= 1;

  print "» " if $is_fresh;
  if $msg ~~ rx:P5/ $/ {
    print "$msg";
    $is_fresh = 0;
  } else {
    say $msg;
    $is_fresh++;
  }
}
s

nicks) = $event<rest> ~~ m:P5/^. ([^ ]+) :?(.*)$/;
    return unless defined $chan;
    $chan = normalize $chan;

    my @nicks = split(" ", $nicks)\
               .map:{ ($_ ~~ m:P5/^[@+%]?(.+)/)[0]

 line from the server and process it
    readline => {
      my $line = readline $hdl;
      $line ~~ s:P5/[\015\012]*$//; # Hack to remove all "\r\n"s
      debug_recv $line if $debug_raw;
      # We

####################################
1;

__END__

HEY YOU!  You need some FOOD!


  ~~ Tangy Moroccan Carrot Salad ~~

* 6 to 8 medium carrots, peeled and then sliced in 1/4-inch rounds
* 1/4 teaspoon

ve caught it
earlier.

=item Repeated format line will never terminate (~~ and @# incompatible)

(F) Your format contains the ~~ repeat-until-blank sequence and a
numeric field that will never go blan

really a dirhandle.  Check your control flow.

=item Runaway format

(F) Your format contained the ~~ repeat-until-blank sequence, but it
produced 200 lines at once, and the 200th line looked exactly 

e;
 supe	  Superset or equal				⊇
 -=	  Equivalent					≡
 ~=	  Congruent to					≅
 ~~	  Asymptotically equal to			≈
 prop	  Proportional to				∝

=head3 Logical symbols

 Ty

equiv", ttype=>"CONST" },
"~=" => { tag=>"mo", output=>"≅", tex=>"cong", ttype=>"CONST" },
"~~" => { tag=>"mo", output=>"≈", tex=>"approx", ttype=>"CONST" },
"prop" => { tag=>"mo", outpu

um where { $^n % 2 == 0 }

    my Str_not2b $hamlet;
    $hamlet = 'isnt';   # Okay because 'isnt' ~~ /^[isnt|arent|amnot|aint]$/
    $hamlet = 'amnt';   # Bzzzzzzzt!   'amnt' !~ /^[isnt|arent|amnot|a

use Rules::Common :profanity;

    multi sub mesg (Str where /<profanity>/ $mesg is copy) {
	$mesg ~~ s:g/<profanity>/[expletive deleted]/;
	print $MESG_LOG: $mesg;
    }

    multi sub mesg (Str $mes

sures too.  These means the same thing:

    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

" ~~ /<nam>/;
say "match name"  if "abc" ~~ /<nam>/;
say "match block" if '{ xxx = a123 }' ~~ /<block>/;
say "match parenthesis"  if '(a b c)' ~~ /<parenthesis>/;
say "match square"  if '[a b c]' ~~ /

<square>/;
say "match str"     if '"abc"'  ~~ /<str>/;

my $pil2 = q/
 PIL_Environment
    { pilMain = (PStmts {pStmt = PNoop, pStmts = PStmts {pStmt = PPos
 {pPos = (MkPos "-e" 1 1 1 12), pExp = App 

bPrim,
 pSubParams = [], pSubLValue = False, pSubIsMulti = False, pSubBody =
 PNil}])
    }
/;

say $pil2;

my $b = $pil2 ~~ m/<pil2>/;
say $b.perl;

my $c = $pil2 ~~ / <nam> <spc> \{ /;
say $c.perl;

      if @params[$i+1] ~~ m:perl5 {:$} {
                @params[$i] ~~ s:perl5 {:$}{,};
            }
        }
    }
    my $param_list = @params.join(" ");
    $param_list ~~ s:perl5 {,$}{};  # rem

ote '&main::zz'
    $s ~~ s:perl5/^"(.*)"$/$0/;
    $s ~~ s:perl5 {\&(.+fix:)([^:].*)}{&$0:<$1>}; 

    # XXX fix corner cases like 'infix:<:>' and '&main::infix:<aaa>'
    $s ~~ s:perl5 {(fix::<)(.*?

)>$}{fix:<$1>};   
    $s ~~ s:perl5 {fix::$}{fix:<:>};   

    $s
}
sub emit_Int ( $s ) { $s }
sub emit_Str ( $s ) { $s }
sub emit_Rat ( $a, $b ) { "$a $b / " } 
sub emit_parameter( 
    $name, $is_i

      if @params[$i+1] ~~ m:perl5 {:$} {
                @params[$i] ~~ s:perl5 {:$}{,};
            }
        }
    }
    my $param_list = @params.join(" ");
    $param_list ~~ s:perl5 {,$}{};  # rem

te '&main::zz'
    $s ~~ s:perl5 /^"(.*)"$/$0/;
    $s ~~ s:perl5 {\&(.+fix:)([^:].*)}{&$0:<$1>}; 

    # XXX fix corner cases like 'infix:<:>' and '&main::infix:<aaa>'
    $s ~~ s:perl5 {(fix::<)(.*?

)>$}{fix:<$1>};   
    $s ~~ s:perl5 {fix::$}{fix:<:>};   

    $s
}
sub emit_Int ( $s ) { $s }
sub emit_Str ( $s ) { $s }
sub emit_Rat ( $a, $b ) { "$a $b / " } 
sub emit_parameter( 
    $name, $is_i

      if @params[$i+1] ~~ m:perl5 {:$} {
                @params[$i] ~~ s:perl5 {:$}{,};
            }
        }
    }
    my $param_list = @params.join(" ");
    $param_list ~~ s:perl5 {,$}{};  # rem

te '&main::zz'
    $s ~~ s:perl5 /^"(.*)"$/$0/;
    $s ~~ s:perl5 {\&(.+fix:)([^:].*)}{&$0:<$1>}; 

    # XXX fix corner cases like 'infix:<:>' and '&main::infix:<aaa>'
    $s ~~ s:perl5 {(fix::<)(.*?

)>$}{fix:<$1>};   
    $s ~~ s:perl5 {fix::$}{fix:<:>};   

    $s
}
sub emit_Int ( $s ) { $s }
sub emit_Str ( $s ) { $s }
sub emit_Rat ( $a, $b ) { "($a / $b)" }
sub emit_parameter( 
    $name, $is_i

 my $file      = '';
    if ($nofile) {
        $directory = $path;
    }
    else {
        $path ~~ m:P5"^((?:.*/(?:\.\.?\Z(?!\n))?)?)([^/]*)";
        $directory = ~$0;
        $file      = ~$1;
  

f before it can descend to $path_directory.  So,
    # replace all names with $parentDir
    $base ~~ s:P5:g"[^/]+"..";

    # Glue the two together, using a separator if necessary, and preventing an

ath = $_path;
    $path ~~ s:P5:g"/+"/";                            # xx////xx  -> xx/xx
    $path ~~ s:P5:g"(/\.)+(/|\Z(?!\n))"/";            # xx/././xx -> xx/xx
    $path ~~ s:P5:g"^(\./)+"" unless

ssoc	named unary operators
    nonassoc	+< +> +<= +>= lt gt le ge
    nonassoc	== != <+> eq ne cmp ~~
    left	^&^
    left	^|^ ^^^
    left	&&
    left	|| //
    nonassoc	..
    right	?:
    left	, =

han the right
argument.
X<cmp>

Binary "~~" does a smart match between its arguments. Smart matching
is described in L<perlsyn/"Smart matching in detail">.
X<~~>

"lt", "le", "ge", "gt" and "cmp" use 

t
constructions involving state variables.

=head2 Implement $value ~~ 0 .. $range

It would be nice to extend the syntax of the C<~~> operator to also
understand numeric (and maybe alphanumeric) rang