lass
=back
=head2 C<<< comb >>>
=over
=item (string method) - $str.comb(/pattern/) equals $str ~~ m:g/pattern/, except it returns the list of findings, not a match object like .match aka m//; defa
<<< match >>>
=over
=item (string method) - method alias to m//, $str.match( /pat/ ) equals $str ~~ s/pat/;, returns a match object
=back
=head2 C<<< max >>>
=over
=item (array op & method) - re
over
=item (string method) - method alias to s///, $str.subst( /pat/, "replacement" ) equals $str ~~ s/pat/"replacement/;
=back
=head2 C<<< substr >>>
=over
=item (string method) - the scalar sub
$value = $list->index(0);
my ($key, $value) = $map->index(0);
Returns the value at the index given (zero starting). Returns a list if a map type. Returns undef or () if not present. Throws L<Th
# do we have a log object as an attribute?
my $is_logging = 0;
$is_logging = 1 if 'log' ~~ @methods && Scalar::Util::blessed $self->log eq 'Thorium::Log';
if ($meta->is_immutable) {
d dumping.
for my $method (@methods) {
# avoid deep recursion
next if $method ~~ @_skip_methods;
next if $method eq 'meta' && !$self->trace_meta;
push(@_skip_metho
# do we have a log object as an attribute?
my $is_logging = 0;
$is_logging = 1 if 'log' ~~ @methods && Scalar::Util::blessed $self->log eq 'Thorium::Log';
$dbh->{'Callbacks'} = {
h my $obj (@{$array}) {
while ( my ($key, $value) = each %{$obj} ) {
if ( $key ~~ @special_keys ) {
$self->_date_to_datetime($value);
}
$obj
(1) {
my ($pkg, $sub) = (caller(++$min_level))[ 0, 3 ];
last unless [ $pkg, $sub ] ~~ /^(Aspect::|dip\b)/o;
}
for my $level ($min_level .. $min_level + $depth - 1) {
my
)
} keys %{$namespace};
for my $hash_symbol (@hash_symbols) {
next if $hash_symbol ~~ [qw(counter quantize opt)];
my $hash = *{ $namespace . $hash_symbol }{HASH};
no wa
= $self->bot->pocoirc->channel_list( $chan );
# don't tell Gianni I used ~~
@nick_list = grep { $_ ~~ @all_nicks && $_ ne $self->bot->nick } @nick_list;
my $extra = '';
elf->idx+$offset) ~~ @{$self->all_latin_vowels}) {
return 0;
}
}
return 1;
}
sub _is_current_a_vowel {
my ($seq) = @_;
return $seq->current ~~ @{$seq->all_latin
rent_a_vowel
and ($self->at_start or $self->wrote_vowel)
and not ( $self->current ~~ @{$self->types_of_i}
and $self->match_vowel_after
and ($self->match_before
d_parameters;
Carp::croak("Attempt to access non-existant parameter $key")
unless $key ~~ @allowed;
# quit if this parameter has already been processed
return if exists $$ref{$key
d_parameters;
Carp::croak("Attempt to create non-existant parameter $key")
unless $key ~~ @allowed;
my $caller = caller;
my $op = $_[-1];
if ( # see http://rt.cpan.org/Publ
for a pathway will be available
for many individuals, meaning that we now have many tests of the given (single)
hypothesis.
(This should not be confused with the scenario of multiple hypothesis
testin
############
# ===
# NEW create a new population path-scan object
# === ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
=head2 new
The object constructor takes a mandatory, but otherwise un-ordere
gn the manner in which genes will be internally organized
# ====== ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
=head2 assign
This method assigns the manner in which genes will b
_m->get_modem_property($_, 'MCC') == 262 # Germany
and $real_m->get_modem_property($_, 'MNC') ~~ qw(07 08 11) # O2
} @rf;
=head1 METHODS
=head2 new($imp;@impl_args)
Instantiates new modem
$tree->children );
return [];
}
sub _match_svn_dirs {
my @dirs = @_;
return any { $_ ~~ [qw(trunk branches tags)] } @dirs;
}
sub _children_value {
return map { $_->value->stringify
ct->children;
}
return \%branches;
}
sub _trunk_or_branches {
my $tree = shift;
given ( $tree->value ) {
when ('trunk') { return $tree }
when ('branches') {
me, $dirent ) = @_;
my $name = $dirent->name;
my $tree = Tree::Path::Class->new();
given ( $dirent->kind ) {
## no critic (Variables::ProhibitPackageVars)
when ($SVN::Nod
sub {
(ref($_[0])
and (local $_ = $getter->($_[0], $attr)))
? ($_ ~~ $val)
: 0;
};
}
sub _gen_less_than_sub {
my ($context, $val, $attr) = @_;
onvert
chomp();
# filtering invalid character
$_ = word_replace($_);
my $converted;
given ( $_ ) {
when ( /$self->{rules}->{Definition}/ ) {
if ( length($1) < 25 ) {
$conver
is a scalar,
# debug it?!
if (defined $func and $Modes->{$level}) {
given (ref $func) {
when ("CODE") { return &$func; };
when ("") { retur
# Iterate through array and recursively call process, call code refs,
# and run tests
given (ref $obj) {
when ('ARRAY') {
return map(process($_), @{$obj});
}
}
return $ret;
};
# see if what we are returning is serializable itself
given (ref $value) {
when ('HASH') {
while (my ($k, $v) = each %$value) {
$self = shift;
given ("$^O") {
when (/^freebsd$/) { return 'pkg_info'; }
when (/^netbsd$/) { return 'pkg_info'; }
when (/^linux$/) {
given (Linux::Distribution
g_name {
my $self = shift;
my $pkg = $self->{target};
my $type = $self->{type};
given (ref $pkg) {
when ('') {
return $pkg if ($pkg =~ m/^[A-Za-z0-9\-\_\.\/]+$/);
my $uri = $request.uri;
my $scheme = $uri.scheme;
unless ($scheme ~~ m:P5/^https?\z/) {
#LWP::Debug::debug('Will not add cookies to non-HTTP requests');
path; # for backwards compatibility
my method normalize_path (Str $str is rw) {
given ($str) {
s:P5:g/%([0-9a-fA-F][0-9a-fA-F])/{
my $x = $0.uc;
and sprintf('{%s}%s', $current_element->namespaceURI, $current_element->localname)
~~ ['{}'.$self->{options}{bookmark_start}, $self->{options}{bookmark_start}]
) {
@current_proper
rm->readline("Enter choice: ");
exit if ( $test =~ /q/i );
exit if !( $test ~~ [ 1, 2, 3, 4, 5 ] );
my $deck;
given ($test) {
when (/1/) { $deck = VANAMBURG::BCS->new; }
when (/2/) { $deck =
o Top
END
say $sub_menu;
my $direction = $term->readline("Enter choice: ");
if ( !( $direction ~~ [ 1, 2 ] ) ) {
say "invalid option";
exit;
}
my @locations = ( 1 .. 52 );
@locations = re