view release on metacpan or  search on metacpan

lib/Fauxtobox.pm  view on Meta::CPAN

    $^V ge v5.14.0 ? (
        s_r  => eval_string('sub { ref($_[2]) ? $_[0] =~ s/$_[1]/$_[2]()/re  : $_[0] =~ s/$_[1]/$_[2]/r  }'),
        s_gr => eval_string('sub { ref($_[2]) ? $_[0] =~ s/$_[1]/$_[2]()/gre : $_[0] =~ s/$_[1]/$_[2]/gr }'),
    ) : (
        s_r  => sub { my $s = $_[0]; if (ref $_[2]) { $s =~ s/$_[1]/$_[2]()/e  } else { $s =~ s/$_[1]/$_[2]/  } $s },
        s_gr => sub { my $s = $_[0]; if (ref $_[2]) { $s =~ s/$_[1]/$_[2]()/ge } else { $s =~ s/$_[1]/$_[2]/g } $s },
    ),

    (map _filetest($_), qw(
        r w x o
        R W X O
        e z s
        f d l p S b c t
        u g k
        T B
        M A C
    )),

    _scalar('abs'),
    _scalar('alarm'),
    _fixed(2, 'atan2'),
    bless => defined &CORE::bless ? \&CORE::bless : sub { bless $_[0], @_ > 1 ? $_[1] : scalar caller },
    _scalar('chdir'),
    _xlist(1, 'chmod'),
    _xlist(0, 'chomp'),
    _xlist(0, 'chop'),
    _xlist(2, 'chown'),
    _scalar('chr'),
    _scalar('chroot'),
    _scalar('cos'),
    _fixed(2, 'crypt'),
    defined => sub { defined $_[0] },
    delete => sub {
        ref($_[0]) eq 'ARRAY' ?
            delete $_[0][$_[1]] :
            delete $_[0]{$_[1]}
    },
    _scalar('die'),
    _hxa('each'),
    eval => sub { eval $_[0] },
    exec => sub {
        my $prog = shift;
        @_ ? exec { $prog } @_ :
        ref($prog) eq 'ARRAY' ? exec @$prog :
        exec $prog
    },
    exists => sub {
        ref($_[0]) eq 'ARRAY' ?
            exists $_[0][$_[1]] :
            exists $_[0]{$_[1]}
    },
    _scalar('exit'),
    _scalar('exp'),
    $^V ge v5.16.0 ? (fc => \&CORE::fc) : (),
    _scalar('getpgrp'),
    _scalar('getpwnam'),
    _scalar('getgrnam'),
    _scalar('gethostbyname'),
    _scalar('getnetbyname'),
    _scalar('getprotobyname'),
    _scalar('getpwuid'),
    _scalar('getgrgid'),
    _fixed(2, 'getservbyname'),
    _fixed(2, 'gethostbyaddr'),
    _fixed(2, 'getnetbyaddr'),
    _scalar('getprotobynumber'),
    _fixed(2, 'getservbyport'),
    glob => sub { [ glob $_[0] ] },
    _scalar('gmtime'),
    grep => sub { my ($arg, $f) = @_; [ grep $f->($_), @$arg ] },
    _scalar('hex'),
    _fixed_opt(2, 1, 'index'),
    _scalar('int'),
    join => sub { join $_[1], @{$_[0]} },
    _hxa('keys'),
    _xlist(1, 'kill'),
    _scalar('lc'),
    _scalar('lcfirst'),
    _scalar('length'),
    _fixed(2, 'link'),
    _scalar('localtime'),
    _scalar('log'),
    _scalar('lstat'),
    map => sub { my ($arg, $f) = @_; [ map $f->($_), @$arg ] },
    _scalar('mkdir'),
    _scalar('oct'),
    _scalar('ord'),
    _xlist(1, 'pack'),
    pop => sub { pop @{$_[0]} },
    pos => sub :lvalue { @_ > 1 ? pos($_[0]) = $_[1] : pos($_[0]) },
    _scalar('prototype'),
    push => sub { my $arg = shift; push @$arg, @_ },
    _scalar('quotemeta'),
    _scalar('rand'),
    _scalar('readlink'),
    _scalar('ref'),
    _fixed(2, 'rename'),
    _scalar('require'),
    reverse => sub { ref($_[0]) eq 'ARRAY' ? [ reverse @{$_[0]} ] : scalar reverse $_[0] },
    _fixed_opt(2, 1, 'rindex'),
    _scalar('rmdir'),
    shift => sub { shift @{$_[0]} },
    _scalar('sin'),
    _scalar('sleep'),
    sort => sub { [ @_ > 1 ? sort { $_[1]($a, $b) } @{$_[0]} : sort @{$_[0]} ] },
    splice => sub {
        my $arg = shift;
        return splice @$arg unless @_;
        my $offset = shift;
        return splice @$arg, $offset unless @_;
        my $length = shift;
        splice @$arg, $offset, $length, @_
    },
    split => sub { [ @_ > 2 ? split $_[1], $_[0], $_[2] : @_ > 1 ? split $_[1], $_[0] : split ' ', $_[0] ] },
    _xlist(1, 'sprintf'),
    _scalar('sqrt'),
    _scalar('srand'),
    _scalar('stat'),
    _fixed_opt(2, 2, 'substr'),
    _fixed(2, 'symlink'),
    syscall => sub { my $arg = shift; syscall $arg, @_ },

lib/Fauxtobox.pm  view on Meta::CPAN

C<< $X->$_exists($KEY) >> is equivalent to C<< exists $X->[$KEY] >> if C<$X>
is an array reference and C<< exists $X->{$KEY} >> otherwise.

See L<perlfunc/exists>.

=item $_exit

C<< $X->$_exit >> is equivalent to C<< exit $X >>.

See L<perlfunc/exit>.

=item $_exp

C<< $X->$_exp >> is equivalent to C<< exp $X >>.

See L<perlfunc/exp>.

=item $_fc

C<< $X->$_fc >> is equivalent to C<< fc $X >>.

See L<perlfunc/fc>.

=item $_getpgrp

C<< $X->$_getpgrp >> is equivalent to C<< getpgrp $X >>.

See L<perlfunc/getpgrp>.

=item $_getpwnam

C<< $X->$_getpwnam >> is equivalent to C<< getpwnam $X >>.

See L<perlfunc/getpwnam>.

=item $_getgrnam

C<< $X->$_getgrnam >> is equivalent to C<< getgrnam $X >>.

See L<perlfunc/getgrnam>.

=item $_gethostbyname

C<< $X->$_gethostbyname >> is equivalent to C<< gethostbyname $X >>.

See L<perlfunc/gethostbyname>.

=item $_getnetbyname

C<< $X->$_getnetbyname >> is equivalent to C<< getnetbyname $X >>.

See L<perlfunc/getnetbyname>.

=item $_getprotobyname

C<< $X->$_getprotobyname >> is equivalent to C<< getprotobyname $X >>.

See L<perlfunc/getprotobyname>.

=item $_getpwuid

C<< $X->$_getpwuid >> is equivalent to C<< getpwuid $X >>.

See L<perlfunc/getpwuid>.

=item $_getgrgid

C<< $X->$_getgrgid >> is equivalent to C<< getgrgid $X >>.

See L<perlfunc/getgrgid>.

=item $_getservbyname

C<< $X->$_getservbyname($Y) >> is equivalent to C<< getservbyname $X, $Y >>.

See L<perlfunc/getservbyname>.

=item $_gethostbyaddr

C<< $X->$_gethostbyaddr($Y) >> is equivalent to C<< gethostbyaddr $X, $Y >>.

See L<perlfunc/gethostbyaddr>.

=item $_getnetbyaddr

C<< $X->$_getnetbyaddr($Y) >> is equivalent to C<< getnetbyaddr $X, $Y >>.

See L<perlfunc/getnetbyaddr>.

=item $_getprotobynumber

C<< $X->$_getprotobynumber >> is equivalent to C<< getprotobynumber $X >>.

See L<perlfunc/getprotobynumber>.

=item $_getservbyport

C<< $X->$_getservbyport($Y) >> is equivalent to C<< getservbyport $X, $Y >>.

See L<perlfunc/getservbyport>.

=item $_glob

C<< $X->$_glob >> is equivalent to C<< [ glob $X ] >>, i.e. it returns an array
reference of results.

See L<perlfunc/glob>.

=item $_gmtime

C<< $X->$_gmtime >> is equivalent to C<< gmtime $X >>.

See L<perlfunc/gmtime>.

=item $_grep

C<< $X->$_grep($F) >> is equivalent to C<< [ grep $F->($_), @{$X} ] >>, i.e. it
takes and returns an array reference. The function C<$F> is passed the current
element as an argument.

See L<perlfunc/grep>.

=item $_hex