CPAN::Groonga

ветствие       КОНЕЦ блока для однострочного скрипта
    ~~           Дюймовыйчервь Inchworm        скалярный
    ~-           Дюйм

   ищем во входных данных и присваиваем захваченное
    ~~<>         Кайт, девочка убийца          Одиночная строка ввод

а нежного приветствия.

=head2 Дюймовый_червь (Inchworm)

    ~~

Этот оператор в основном короче C<scalar>(убирает целых 4

olean::Tiny::BASE;
	
	our $AUTHORITY = 'cpan:TOBYINK';
	our $VERSION   = '0.008';
	
	# Versions of ~~ and fc for legacy Perls...
	use if $] >= 5.016, feature => 'fc';
	BEGIN { eval q[fc("1")] or eval 

e match::simple qw(match);
		1;
	}
	or eval q
	{
		use v5.10.1;
		no warnings;
		sub match { $_[0] ~~ $_[1] };
		1;
	}
	or eval q
	{
		sub match
		{
			my ($a, $b) = @_;
			if (ref($b) eq 'ARRAY')
			

e structure of the directory tree (including symbolic
links to directories) you might traverse a given (physical) directory
more than once (only if C<follow_fast> is in effect).
Furthermore, deleting 

|----||
        ~~    ~~
  "}}

  is replaced with

  <pre class="ascii-art">
               (__)
              (oo)
       /-------\/
      / |     ||
     *  ||----||
        ~~    ~~
  </pre>

  If

            (__)
              (oo)
       /-------\/
      / |     ||
     *  ||----||
        ~~    ~~
  >>>

=back

=head2 Text::HikiDoc::Plugin::br

=over 4

{{br}}

is replaced with 

E<lt>br /E<

ill create a font object using the default font.

=head1 EXAMPLES

  perl -MText::FIGlet -e 'print ~~Text::FIGlet->new()->figify(-A=>"Hello World")'

To generate headings for webserver directory listi

< ><<<  _(_)(_)(_)  /   >>>
    | |        /** a8P_____88   ><<    (_)         >>    >>>
    | |  |~~\  /** 8PP"""""""   ><<    (_)         >>>>>>>>
   _/ |  |__/  /** "8b,   ,aa   ><<    (_)_  _  _  

( sub { $_ ~~ $filter }, @$array );
    }

    return List::Util::first( sub { $filter->() }, @$array );

}

sub grep {
    my ( $array, $filter ) = @_;

    my @result = CORE::grep { $_ ~~ $filter } 

               : $obj2+0 eq "$obj1";
    }
    elsif( 'num' ~~ [$type1, $type2] ) {
        return $obj1 == $obj2;
    }
    elsif( 'str' ~~ [$type1, $type2] ) {
        return $obj1 eq $obj2;
    }
 

($r1, $r2) = @_;
    # Hashes can't be equal unless their keys are equal.
    return unless ( %$r1 ~~ %$r2 );

    # Compare the equality of the values for each key.
    foreach my $key (keys %$r1) {

ub { $_ ~~ $filter }, @$array );
    }

    return List::Util::first( sub { $filter->() }, @$array );

}

sub ARRAY::grep {
    my ( $array, $filter ) = @_;

    my @result = CORE::grep { $_ ~~ $filte

gs
            return $r1 eq $r2;
        }
    }
    elsif( $ref1 eq $ref2 ) {
        if ( $ref1 ~~ [qw(Regexp GLOB CODE)] ) {
            return $r1 eq $r2;
        }
        elsif ( $ref1 eq 'ARRA

 $ref1 eq 'HASH' ) {
            return _equal_hashes( $r1, $r2 );
        }
        elsif ( $ref1 ~~ [qw(SCALAR REF)] ) {
            return _are_equal($$r1, $$r2);
        }
        else {
         

 @_;
            croak "ValidateTiny: Wrong validatation rules"
                unless ref($rules) ~~ [ 'ARRAY', 'HASH' ];

            $c->stash('validate_tiny.was_called', 1);

            $rules = 

o_rules;

                foreach my $f ( @{ $rules->{fields} } ) {
                    next if $f ~~ $conf->{exclude};
                    push @fields_wo_rules, $f unless exists $h{$f};
            

n;
}

sub node_level($self,$token) {
    $token = $self->podname($token);
    first_index { $token ~~ @$_ } $self->all_levels;
}

sub parse_pod($self, $end_cond = undef ) {
    while( my $token = $sel

next5 <= $left[-1] ) {

        # stem
        if ( $next5 ~~ @left and $next3 ~~ @right ) {
            while ( $next5 ~~ @left and $next3 ~~ @right ) {
                push @l1, ' ';
               

  elsif ( $next5 !~ @left and $next3 ~~ @right ) {

            # print "[5' gap],$next5,$next3\n";
            $n5 = 0;
            $n5++ until ( $next5 + $n5 ) ~~ @left;
            for ( 1 .. $n5 )

ap
        elsif ( $next5 ~~ @left and $next3 !~ @right ) {

            # print "[3' gap], $next5,$next3\n";
            $n3 = 0;
            $n3++ until ( $next3 - $n3 ) ~~ @right;
            for (

, "", 0.0, 0.0,{0,0,0.0}}

#ifdef PM3D
typedef struct {
    int opt_given; /* option given / not given (otherwise default) */
    int closeto;   /* from list FILLEDCURVES_CLOSED, ... */
    double at;

such that no two objects
of that class will have the same 'id'. If there are no id_by properties
given (including MyClass above that doesn't have _any_ properties), then an
implicit 'id' property will

ed without any arguments after the time-out
elapsed and the port is C<kil>ed.

If no time-out is given (or it is C<undef>), then the local port will
monitor the remote port instead, so it eventually g

;
   }

   given( $type ) {
      when([ "GLOB", "CODE", "STASH" ]) {
         table_add( $table, "Stashname", textarea( $sv->stashname ) ) if defined $sv->stashname;
      }
   }

   given( $type ) {

add( $table, "Output fileno", textarea( $sv->ofileno ) ) if $sv->ofileno != -1;
      }
   }

   given( $type ) {
      when([ "SCALAR", "REF", "ARRAY", "HASH", "STASH", "CODE" ]) {
         table_add

      my $data = $extra->render->( $sv );
      defined $data or next;

      my $widget;
      given( $extra->type ) {
         when( "widget" ) { $widget = $data }
         when( "text" )   { $widg

}) } keys %$a;
    }

    $elem;
}

=head2 _XPC [ %NS | \%NS ]

Return an XPath context with the given (optional) namespaces
registered.The XHTML namespace is registered by default with the
prefix C<h

he value of a 2D Gaussian function with mean 0 
              and standard deviation sig at the given (x,y) point.
    !*/

// ---------------------------------------------------------------------

t void *buffer, png_int_32 row_stride,
   const void *colormap));
   /* Write the image to the given (FILE*). */

/* With both write APIs if image is in one of the linear formats with 16-bit
 * d

 $head_str = '';
  for my $expr (@{atoms($exprs)}) {
    my ($name,$value) = flat($expr);
    given ($name) {
      when ('package') {
        InContext($t,$value);
        $head_str = package_t

urn $strs;
}

sub atom_to_perl {
  my ($t,$atom) = @_;
  my ($name,$args) = flat($atom);
  given ($name) {
    when ('Cursor') {
      return exprs_to_perl($t,$args);
    }
    when ('Lint')

  }
  my $iter_str = atom_to_perl($t,$iter_atom);
  my $type = GetAtomType($t,$iter_atom);
  given ($type) {
    when ('Str') {
      return "my $loop (split '', $iter_str)";
    }
    when ('

match ) {
            $end--;
        }
    }

    #warn "return $start .. $end";
    #warn "$size ~~ " . ( $end - $start );

    return ( $start, $end );
}

=head2 get_window_tokens( I<pos> [, I<size

toms)} ]);
}

sub opt_spp_atom {
  my $atom = shift;
   my ($name,$value) = flat($atom);
  given ($name) {
    when ('Spec') {
      return opt_spp_spec($value);
    }
    when ('Rule') {
 

pt_spp_ep($char));
}

sub opt_spp_ep {
  my $str = shift;
   my $char = last_char($str);
  given ($char) {
    when ('n') {
      return "\n";
    }
    when ('r') {
      return "\r";
   

eturn estr('Nclass',estr_strs($atoms));
}

sub opt_spp_catom {
  my ($name,$value) = @_;
   given ($name) {
    when ('Cclass') {
      return opt_spp_cclass($value);
    }
    when ('Range')