CPAN::Groonga

# Test Funclib.

# int8
# Should extract a byte from a binary string, at a given (optional) offset

my $buf = pack 'a8', 'a';

print "buf = $buf\n";

foreach ( unpack( "(a1)*", $buf ) ) {
    print s

 a I<z>-value I<greater> than or equal to that observed. So the inverse phi function is actually given (1 - I<p>-value) to work on. So .055 comes back as 1.598 (speaking of the top-end of the distribu

gin Pugscode

-- | Single parameter for a function or method, e.g.:
--   Elk $m where { $m.antlers ~~ Velvet }
{-|
A formal parameter of a sub (or other callable).

These represent declared parameters

directly C<Play()> it.

The second (and third) form opens the
wave output device with the format given
(or if none given, defaults to 44.1kHz,
16 bits, stereo); to produce something
audible you can ei

t($file)->mtime;
    if ( ( !$force ) and $mtime ~~ $mtimes{$file}->{mtime} ) {
        next;
    }

    if ( ( !$force ) and get_digest($file) ~~ $mtimes{$file}->{digest} ) {
        next;
   

01):   say "large";
   }

This is all thanks to L<match::simple> which respects the overloaded
C<< ~~ >> operator.

=head1 CAVEATS

Internally a lot of parts of code are passed around as coderefs, so

a;    # ( c )    ~~ after       {/b/} (a, b, c)
        @gots = after_incl  {$_} @a;    # ( b, c ) ~~ after_incl  {/b/} (a, b, c)
        @gots = before      {$_} @a;    # ( a )    ~~ before      {/b/

 b, c)
        @gots = before_incl {$_} @a;    # ( a, b ) ~~ before_incl {/b/} (a, b, c)
        @gots = indexes     {$_} @a;    # ( 1 )    ~~ indexes     {/b/} (a, b, c)
        $got  = firstval    {

ts)
    #         Seen-hash: Use hashrefs instead of arrayrefs:
    #   [ 11, 12, 14, 14, 14, 15 ] ~~ { 11 => 1, 12 => 1, 14 => 3, 15 => 1 }
    #
        # Construct a work-object
        my $lc = Li

 preorder traversal
sub pass_three {
	my ($node, $parent, $parent_value) = @_;

	if ($parent_value ~~ $node->[VALUE]) {
		# parent value is member of node's potential values
		undef $node->[VALUE];
	}

value (prefixes from children will be used)
				undef $node->[VALUE];
			} elsif ($node->[OLD_VAL] ~~ $node->[VALUE]) {
				# use old value if it found in set of potential new values
				$node->[VALUE

arch parameter: '$_[0]' is not one of the columns: @{$self->columns}";
        #    unless ( $_[0] ~~ @{$self->columns} );
    #}
);

has first_row_is_headers => (
    is => 'rw',
    required => 1,
 

ne =~ /(^#|^\n)/;

    my ($key, $value) = split /\s+/, $line;
    $self->{$key} = ( 
        $key ~~ @has_scope ? 
        [split /\?/, $value] :
        $value
    );
}

1;

=pod

=head1 NAME

App::

 %attrs = map {
        my $asref = $self->meta->find_attribute_by_name($_)->type_constraint->name ~~ /Ref/;
        $_, $entry->get_value($_, asref => $asref);
    } $entry->attributes;

    return (

proferred\n";

        next if defined $mopt{include} && !( $pkg ~~ $mopt{include} );
        next if defined $mopt{exclude} && $pkg ~~ $mopt{exclude};

        # print STDERR "package $pkg accepted\n

cification>

Check the package name against the I<specification> using the smart match
operator (C<~~>) and ignore it if it does not match.  If C<-inner> or
C<-only_inner> are specified, inner package

cification>

Check the package name against the I<specification> using the smart
match operator (C<~~>) and ignore it if it matches.  The C<-exclude> match is
processed after C<-include> if both are s

 sh{
    my $p = shift;
    given($_[0]){
      when('employer'){...}
      when('employee'){...}
      when('date'){...}
    }
  }

  sub eh{
    my $p = shift;
    given($_[0]){
      when('employer

e>

Will be called when a start-tag is encountered that matches I<tagname>.
If I<tagname> is not given (when your sub is called C<Start> or C<Start_>), it works like a default-handler for start tags.

ame>

Will be called when a end-tag is encountered that matches I<tagname>.
If I<tagname> is not given (when your sub is called C<End> or C<End_>), it works like a default-handler for end tags.

=head

    my @v = map { $modem_api->get_modem_property( $mob, $_ ) } @match_keys;
                    @v ~~ @match_values;
                },
                $modem_api->get_modems()
                       

  $rrlp_resp_pdu->{referenceNumber} = $rrlp_pdu->{referenceNumber};
    my $rrlp_resp_type;

    given ( $rrlp_pdu->{component}->{present} )
    {
        when ($Net::Radio::Location::SUPL::XSc::RRLP_

 $log->debugf( "pdu: %s", $supl_pdu->xml_dump() );

    # decode_ulp_pdu croaks on error ...
    given ( $supl_pdu->{message}->{present} )
    {
        when ($Net::Radio::Location::SUPL::XSc::UlpMess

$code", $event);
		push @{$self->{event_handler}->{$event}}, $code;
		++$self->{pending} if $event ~~ [qw(item done)];
	}
	return $self;
}

=head2 has_event_handlers_for

Returns how many event handle

return 'null' unless defined $v && $v ne 'undef';
	return $v if $self->field && $self->field->type ~~ [qw/int bigint serial bigserial numeric/];
	$v =~ s/'/''/g;
	$v =~ s!\\!\\\\!g;
	return "E'$v'";
}

_CALL, /* $foo.^methods */
    PVIP_NODE_REGEXP,
    PVIP_NODE_SMART_MATCH, /* ~~ */
    PVIP_NODE_NOT_SMART_MATCH, /* !~~ */
    PVIP_NODE_PERL5_REGEXP, /* m:P5/./ */
    PVIP_NODE_TRUE,
    PVIP_NOD

dst->name;
	return 0 if $self->field->count != $dst->field->count;
	return 0 unless $self->primary ~~ $dst->primary;

	my @srcF = sort { $a->name cmp $b->name } $self->field->list;
	my @dstF = sort { 

f = shift;
	my $in = shift;
	my $out;
	my $type = ref $in;
	given($type) {
		when('SCALAR') {
			$out = $$in;
			if(defined($out) && $out ~~ /^-?\d+(?:\.\d+)?$/) {
				$out = $out+0;
			}
		}
		defaul

cut

sub decantQuotedValue {
	my $self = shift;
	my $in = shift;
	my $out;
	my $type = ref $in;
	given($type) {
		when('SCALAR') {
			$out = $$in;
			if(!defined($out)) {
				$out = 'NULL';
			} elsif

%read = %$data;
		$fail->("wrong keys returned: " . join ',', keys %read) unless [sort keys %read] ~~ [qw(id name)];
		$fail->("wrong data for name -  returned: " . $read{name}) unless $read{name} eq