CPAN::Groonga

down_markers
{
   "**" => "bold",
   "*"  => "italic",
   "__" => "bold",
   "_"  => "italic",
   "~~" => "strike",
   "`"  => "fixed",
}

sub __cache_per_class ( $code )
{
   my %cache;
   return sub

d above.

Recognises the following kinds of inline text markers:

   **bold**

   *italic*

   ~~strike~~

   `fixed`

   [link](target)

   backslashes escape any special characters as \*

In additio

nst void *buffer, png_int_32 row_stride,
   const void *colormap));
   /* Write the image to the given (FILE*). */
#endif /* SIMPLIFIED_WRITE_STDIO */

/* With all write APIs if image is in one of the

nst void *buffer, png_int_32 row_stride,
   const void *colormap));
   /* Write the image to the given (FILE*). */
#endif /* SIMPLIFIED_WRITE_STDIO */

/* With all write APIs if image is in one of the

range of actions, each of
which is specified by keying a unique letter, like so:

    INPUT:
    given (prompt '[S]ave, (R)evert, or (D)iscard:', -default=>'S') {
        when (/R/i) { revert_file()  

     { goto INPUT;    }
    }

This can be cleaned up (very slightly) by using a guarantee:

    given (prompt '[S]ave, (R)evert, or (D)iscard:', -default=>'S',
                  -guarantee=>qr/[SRD]/

Prompter provides an option that extracts this
information directly from the prompt itself:

    given (prompt '[S]ave, (R)evert, or (D)iscard:', -keyletters) {
        when (/R/i) { revert_file()  }

nst void *buffer, png_int_32 row_stride,
   const void *colormap));
   /* Write the image to the given (FILE*). */
#endif /* SIMPLIFIED_WRITE_STDIO */

/* With all write APIs if image is in one of the

       gzFile fp() { return m_fp; }

    private:
        gzFile m_fp;
};

/*
 * Binary read the given (array of) object(s) from the compressed file.
 * If the input file was not in gzip format, read(

       }

    private:
        gzFile m_fp;
        ostrstream* m_os;
};

/*
 * Binary write the given (array of) object(s) into the compressed file.
 * returns the number of uncompressed bytes actual

s no warning or errors of it’s own. If any function or method returns false then the arguments given (or not given) were invalid/not found.

Deviations from this are documented per function/method.

IF ALSO THE THIRD AXIS HAS TO BE CHECKED FOR NON-REPETITIONS, PUT 1 OTHERWISE.
						if (@cutelms ~~ @cutelems)
						{

							$counthit++;
							print "COUNTGROUP: $countgroup, HIT! $counthit\

            alert "Grouping not allowed"; return FALSE;
                }
        my $tag = ($type ~~ ['column', 'row']) ?
                        'table:table-' . $type . '-group'       :
           

                     {
                        $min //= $v; $max //= $v;
                        given ($type)
                                {
                                when (['string', 'all']

        my $self        = shift;
        my $value       = shift // 'true';
        unless ($value ~~ ['true', 'none', 'condition'])
                {
                if ($value == TRUE)
             

 {
        my $self        = shift;
        my $value = $self->get_attribute('display');
        given ($value)
                {
                when (undef)        { return TRUE   }
                

elf        = shift;
        my $type        = shift         or return undef;
        unless ($type ~~ [ 'standard', 'lines', 'line', 'curve' ])
                {
                alert "Not allowed con

             my $v;
# Originally this code used the being-discontinued given/when construct 
#   given ($opt{$k}) {
#     when(TRUE)   { $v = 'true' }    # TRUE is 1
#     when(FALSE)  { $v = 'none' }

 }

sub is_numeric_family
		{
		my $self	= shift;
		my $f		= shift		or return undef;
		#return ($f ~~ @NUMERIC_FAMILIES) ? TRUE : FALSE;
		return fake_smartmatch($f, \@NUMERIC_FAMILIES) ? TRUE : FALSE

                   {
                        my $family = $1;
                        #if ($family ~~ [@FAMILIES])
                        if (fake_smartmatch($family, [@FAMILIES]))
                  

ype=>"perl_code"}],summary=>"Benchmark searching string in array-of-string using smartmatch: \$str ~~ \@ary_of_str"}},"func.bencher_version"=>undef,"func.code_startup"=>undef,"func.cpu_info"=>[{L2_cac

samples"]}]];

1;
# ABSTRACT: Benchmark searching string in array-of-string using smartmatch: $str ~~ @ary_of_str

=head1 DESCRIPTION

This module is automatically generated by Pod::Weaver::Plugin::Be

and the ~~ operator, and 5.40 will
# supposedly remove them entirely.  To preserve existing semantics of
# existing code including user-visible functions, I'm emulating (a subset of) 
# the ~~ operato

{
                    my $cell = $table->get_cell($i, $j);
                    if ($cell->get_type ~~ $filter) {
                        $count++;
                        $amount += $cell->get_value;

               my $cell = $row->get_cell($j) or last CELL;
                    if ($cell->get_type ~~ $filter) {
                        $count++;
                        $amount += $cell->get_value;

                        {
                                my $v;
                                given ($opt{$k})
                                        {
                                        when

ype} || 'number';
        $e = ODF::lpOD::ListLevelStyle->create($type) or return FALSE;
        given ($type)
                {
                when (['number', 'outline'])
                        {

    {
        my $caller      = shift;
        my $type        = shift;
        my $tag;
        given ($type)
                {
                when (undef)
                        {
                

    set_type
        {
        my $self        = shift;
        my $type        = shift;
        given ($type)
                {
                when (undef)
                        {
                

my $self        = shift;
        my $type        = $self->get_type();
        my $value;
        given ($type)
                {
                when ('string')
                        {
             

   my $type        = $self->get_type();

        my $v = check_odf_value($value, $type);
        given ($type)
                {
                when ('string')
                        {
             

       my $param       = shift // "";
        $param          = shift if $param eq lpod;
        given ($param)
                {
                when (undef)            {}
                when (TRUE 

     my $arg = shift;
        return FALSE unless $arg;
        my $v = lc $arg;
        return $v ~~ ["false", "off", "no"] ? FALSE : TRUE;
        }

sub     is_false
        {
        return is_tru

   = shift;
        return undef unless defined $value;
        my $type        = shift;
        given ($type)
                {
                when (['float', 'currency', 'percentage'])
            

erhaps you wanted: "
                                                    . ":where({ $param->{var} ~~ $match{where_expr} })"
                                                )
                    : $ma

    multi factorial ($n == 0)    { 1 }

    multi alert ($msg eq "")     {}
    multi alert ($msg ~~ undef)  {}

    multimethod add_client ($data, $ID =~ /X\w{4}\d{6}/) {
        die "Can't add an X

s the only parallel processed reponse method (the other ones are
pure CPU-only bound) that sleep given (or random) number of seconds and
only then returns the request response with when it started and

s SUDOC dont on ne veut pas dans le catalogue
    # Koha
    $record->fields( [ grep { not $_->tag ~~ @todelete } @{$record->fields} ] );

    $record->append( MARC::Moose::Field::Std->new(
        ta