$clmfile . ".a";
say MONITOR "CLMFILEA $clmfilea";
#if ( ( "getweather" ~~ @calcprocedures ) or ( "embedded" ~~ @calcprocedure ) )
{
if ( not ( -e $clmfilea ) )
{# THE CALL DOES
NOT WORK WITH MODELS FLATTENED INTO ONE ROOT DIRECTORY. FIX THIS.
#if ( "embedded" ~~ @calcprocedures )
#{
# defendshd( $shdfile );
#}
`cd $path/cfg \n clm -file $paths{rootc
le $paths{rootconffile} -mode script<<YYY
$clmfile
j
a
y
-
YYY
";
#if ( "embedded" ~~ @calcprocedures )
#{
# restoreshd( $shdfile );
#}
}
}
# if (
l", as &Item, where { ref $_ eq "" and /^(1|0|)\z/ };
subtype "Enum[A...]", as &Item, where { $_ ~~ ARGS };
subtype "Maybe[A]", as &Item, where { !defined($_) || A->test };
subtype "Undef", as &
qr/\bkitty\b/i],
message { "Speak is'nt included kitty!" };
}
"Kitty!" ~~ SpeakOfKitty # -> 1
"abc" ~~ SpeakOfKitty # -> ""
eval { SpeakOfKitty->validate("abc", "This") }; "$@" # ~>
BEGIN {
subtype IntOrArrayRef => as (Int | ArrayRef);
}
[] ~~ IntOrArrayRef # -> 1
35 ~~ IntOrArrayRef # -> 1
"" ~~ IntOrArrayRef # -> ""
coerce IntOrArrayRef, from Num, via { int
$!text ~~ m{^ <[0..9]> } ?? +$!text
!! $!text.unival.Int
!! Num;
}
method Real {
$!text.defined
?? $!text ~~ m{^ <
return; # Default is False for both
$!text ~~ m:m{^ <[ \x09, \x20 .. \x7E ]>+ $} or
$!is_binary = True;
$!text ~~ m:m{^ <[ \x00 .. \x7F ]>+ $} or
$!i
$!sep ~~ m{<[\r\n]>} and self!fail (1003);
$!quo.defined and $!quo ~~ m{<[\r\n]>} and self!fail (1003);
$!esc.defined and $!esc ~~ m{<[\r\n]>} and self!fail
str(self.orig,$pos++,1);
if $char ~~ /^\s$/ {
self.panic("Whitespace character is not allowed as delimiter"); # "can't happen"
}
elsif $char ~~ /^\w$/ {
self.panic("Alphanu
$text ~= $ch;
$to = $¢.pos;
if $ch ~~ "\n" {
$multiline++;
}
.pos - self.pos);
my ($inside) = $all ~~ m!^...\s*(.*?)\s*.$!;
$¢.obs("Perl 5's $all construct", "a smartmatch like \$! ~~ $inside" );
}
}
token special_var
], [b => 2], [c => 3]);
in scalar context, C< tuples > returns a generator:
tuples(...) ~~ zipwith {\@_} ...
=cut
sub tuples {
unless (wantarray) {
unshift
s by default
=over 4
=item * B<iteration>:
$gen->next # iterates over generator ~~ $gen->get($gen->index++)
$gen->() # same. iterators return () when past the end
$gen->filter(do {my %seen; sub {not $seen{$_}++}})
$gen->deref # tuples($a, $b)->deref ~~ zip($a, $b)
=item * B<combinations>:
$gen->zip($gen2, ...) # takes any number of gener
], [b => 2], [c => 3]);
in scalar context, C< tuples > returns a generator:
tuples(...) ~~ zipwith {\@_} ...
=cut
sub tuples {
unless (wantarray) {
unshift
s by default
=over 4
=item * B<iteration>:
$gen->next # iterates over generator ~~ $gen->get($gen->index++)
$gen->() # same. iterators return () when past the end
$gen->filter(do {my %seen; sub {not $seen{$_}++}})
$gen->deref # tuples($a, $b)->deref ~~ zip($a, $b)
=item * B<combinations>:
$gen->zip($gen2, ...) # takes any number of gener
@_;
__PACKAGE__->new(name => "Exclude", args => [$type1], test => sub { !$type1->test });
},
"~~" => "include",
;
# конструктор
# * args (ArrayRef) — Список аргументо
ion::Type;
my $Int = Aion::Type->new(name => "Int", test => sub { /^-?\d+$/ });
12 ~~ $Int # => 1
12.1 ~~ $Int # -> ""
my $Char = Aion::Type->new(name => "Char", test => sub { /^.\z/ });
$C
har;
77 ~~ $IntOrChar # => 1
"a" ~~ $IntOrChar # => 1
"ab" ~~ $IntOrChar # -> ""
my $Digit = $Int & $Char;
7 ~~ $Digit # => 1
77 ~~ $Digit # -> ""
"a" ~~ ~$Int; # => 1
5 ~~ ~$Int; #
~~ RangeString
if (UNIVERSAL::isa($second, 'Sidef::Types::Range::RangeString')) {
return $second->contains($first);
}
# String ~~
if (UNIVERSAL::isa($first, 'Sidef::Types::Number::Number')) {
# Number ~~ RangeNumber
if (UNIVERSAL::isa($second, 'Sidef::Types::Range::RangeNumber')) {
if (UNIVERSAL::isa($first, 'Sidef::Types::Range::RangeNumber')) {
# RangeNumber ~~ Number
if (UNIVERSAL::isa($second, 'Sidef::Types::Number::Number')) {
}
push ( @{ $morphstruct[$countcase][$countblock] }, $to{cleanto} );
# if ( ( not ( $to ~~ @morphcases ) ) or ( $dowhat{actonmodels} eq "y" ) )
if ( ( $dowhat{actonmodels} eq "y" ) and
percube} eq "yes" ) or ( $dirfiles{ga} eq "yes" ) )
{
if ( ( "begin" ~~ @whatto ) and ( not ( "end" ~~ @whatto ) ) and ( $dowhat{jumpinst} eq "yes" ) )
{
$orig = "$mypa
LEVEL 1a: cp -R $orig $target\n\n";
}
}
elsif ( ( "begin" ~~ @whatto ) and ( not ( "end" ~~ @whatto ) ) and ( not ( $dowhat{jumpinst} eq "yes" ) ) )
{
$orig
;
foreach my $inst_r ( @instances )
{
my %d = %{ $inst_r };
my $is = $d{is};
unless ( $is ~~ @bagnames )
{
push( @bagnames, $is );
push( @baginst, $inst_r );
}
}
return( @baginst
hash = %{ $_[0] };
my ( @bagnames, %newhash );
foreach my $key ( keys %hash )
{
unless ( $key ~~ @bagnames )
{
push( @bagnames, $key );
$newhash{$key} = $hash{$key};
}
}
return( \%ne
werinstnames;
foreach my $instance ( @fewerinsts )
{
my %d = %{ $instance };
unless ( $d{is} ~~ @fewerinstnames )
{
push( @fewerinstnames, $d{is} );
}
}
say $tee "FEWERINSTNAMES" . dump
$resultlist = $data ~~ dpath '/AAA/*/CCC'; # [ ['XXX', 'YYY', 'ZZZ'], [ 'RR1', 'RR2', 'RR3' ] ]
Note that the C<match()> function returns an array but the overloaded
C<~~> operator returns an
ove data structure):
$data ~~ dpath '/AAA/*/CCC'
$data ~~ dpath '/AAA/BBB/CCC/../..' # parents (..)
$data ~~ dpath '//AAA' # anywhere (//)
$data ~~ dpath '//AAA/*'
# anywhere + anystep
$data ~~ dpath '//AAA/*[size == 3]' # filter by arrays/hash size
$data ~~ dpath '//AAA/*[size != 3]' # filter by arrays/hash size
$data ~~ dpath '/"EE/E"/CCC'
. operadores unarios nombrados
no asoc. < > <= >= lt gt le ge
no asoc. == != <=> eq ne cmp ~~
izquierda &
izquierda | ^
izquierda &&
izquierda || //
no asoc. .. ...
de
la
derecha. X<cmp>
El binario C<"~~"> hace una coincidencia inteligente entre sus argumentos. La
Coincidencia inteligente se describe en la sección siguiente. X<~~>
C<"lt">, C<"le">, C<"ge">, C<"g
or primera vez en Perl 5.10.1 (la versión 5.10.0 se comportaba de
manera diferente), el binario C<~~> hace una "coincidencia inteligente" entre
sus argumentos. Casi siempre se usa implícitamente en
d(NUM) && () ~~ [1..10]' | less -r
unichars 'defined(NUM) && [1..10] ~~ NUM' | less -r
unichars 'defined(NUM) && [1..1] ~~ NUM' | less -r
unichars 'defined(NUM) && ! (NUM() ~~ [0..10])' |
less -r
unichars 'defined(NUM) && ! NUM() ~~ [0..10]' | less -r
unichars 'defined(NUM) && NUM <= 10'
unichars 'defined(NUM) && NUM <= 10' | less
unichars 'defined(NUM) && NUM <= 10' |
less -r
unichars 'defined(NUM) && ! NUM() ~~ [1..10]' | less -r
unichars 'defined(NUM) && NUM() ~~ [1..10]' | less -r
unichars '\d' '\p{common}'
unichars '\d' '\p{Latin}
unichars '
d(NUM) && () ~~ [1..10]' | less -r
unichars 'defined(NUM) && [1..10] ~~ NUM' | less -r
unichars 'defined(NUM) && [1..1] ~~ NUM' | less -r
unichars 'defined(NUM) && ! (NUM() ~~ [0..10])' |
less -r
unichars 'defined(NUM) && ! NUM() ~~ [0..10]' | less -r
unichars 'defined(NUM) && NUM <= 10'
unichars 'defined(NUM) && NUM <= 10' | less
unichars 'defined(NUM) && NUM <= 10' |
less -r
unichars 'defined(NUM) && ! NUM() ~~ [1..10]' | less -r
unichars 'defined(NUM) && NUM() ~~ [1..10]' | less -r
unichars '\d' '\p{common}'
unichars '\d' '\p{Latin}
unichars '
@_;
return match { return $_ ~~ $match for $sub->() };
}
sub any {
my @possibilities = @_;
return match {
for my $candidate (@possibilities) {
return 1 if $_ ~~ $candidate;
}
return;
};
rn match { scalar hash and [ sort keys %{$_} ] ~~ [ sort keys %{$hash} ] };
}
sub value {
my $value = shift;
return $value if blessed($value);
given (ref $value) {
when ('') {
return $value;
NAME
Smart::Match - Smart matching utilities
=head1 VERSION
version 0.008
=head1 SYNOPSIS
given ($foo) {
say "We've got a positive number" when positive;
say "We've got an array" when
up; $i++) {
my @mm = split /,/, $group->[$i][3];
next unless $user ~~ @mm || $group->[$i][0] eq $user;
if (!$detail) {
push @rows, $
return undef unless $res->[0] == 200;
my @mm = split /,/, $res->[2]{members};
return $user ~~ @mm ? 1:0;
}
$SPEC{get_max_uid} = {
v => 1.1,
summary => 'Get maximum UID used',
args
for ($min_gid .. $max_gid) {
do { $gid = $_; last } unless $_ ~~ @gids;
}
return [412, "Can't find available GID"]
rence;
my @int = get_intersection( \@aa, \@bb );
foreach my $el ( @aa )
{
if ( not ( $_ ~~ @int ) )
#if ( not ( any { $_ eq $el } @int ) )
{
push ( @difference, $_ );
}
y = @{ $modality_ref };
my @neighbours;
my %bank;
my @newneighbours;
if ( "flat" ~~ @modality )
{
foreach my $e ( @arra )
{
push ( @newneighbours, $e->[0] );
if ( ( $el->[2] ne "" ) and ( $el->[3] >= $minimumcertain ) )
{
unless ( "bankflat" ~~ @modality )
{
if ( scalar( @{ $nears{$el->[0]}{neighbours} } ) == 0 )
turns true if any one pair of
inflexions matches (case-insensitively).
That is:
noun($word1) ~~ noun($word2)
is just a shorthand for:
lc(noun($word1)->singular) eq lc(noun($wor
is then smartmatched
against the other argument.
That is:
$something_else ~~ noun($word1)
noun($word1) ~~ $something_else
are just slightly shorter (and less order-specific) ways of wri
~~ noun($word2) # (ditto)
noun($word1) =~ $word2 # $word1 matches $word2 exactly
noun($word1) ~~ $word2 # any inflexion of $word1 matches $word2
noun($word1) ~~
r escape sequence", "Illegal combo 1001");
#%state{1001} ~~ m{"separator is equal to"} or warn "HELP";
#%state{1001} ~~ m{"separator is equal to"} or die %state{1001};
}
el
te{1001}.defined and
%attr<sep_char> ~~ m/[\r\n]/ ||
%attr<quote_char> ~~ m/[\r\n]/ ||
%attr<escape_char> ~~ m/[\r\n]/
) {
ok (%state{1003}.
tate{1003} ~~ rx{"in main attr not"}, "Illegal combo (1003)");
}
if (%attr<allow_whitespace> and
%attr<quote_char> ~~ m/^[ \t]/ ||
%attr<escape_char> ~~ m/^[ \t]/
r term is expected
# next.
if ( $rsquare_bracket_type->[$square_bracket_depth] eq '~~' ) {
$tok = $rsquare_bracket_type->[$square_bracket_depth];
}
if ( $s
'||=' => undef,
## '//=' => undef,
## '~' => undef,
## '~~' => undef,
## '!~~' => undef,
};
# ---------------------------------------------------------
|| >= != mm *= => .. !~ == && |= .= pp -= =~ += <= %= ^= x= ~~ ** << /=
&= // >> ~. &. |. ^.
... **= <<= >>= &&= ||= //= <=> !~~ &.= |.= ^.= <<~
);
push @q, ',';
push @q, '(';