view release on metacpan or  search on metacpan

lib/Sidef/Types/Array/Array.pm  view on Meta::CPAN

        if (@tmp < @matrix) {
            $#tmp = $#matrix;
        }

        foreach my $j (0 .. $#tmp) {
            $matrix[$j][$i] = $tmp[$j];
        }
    }

    bless $_ for @matrix;
    bless \@matrix;
}

sub pack {
    my ($self, $format) = @_;
    Sidef::Types::String::String->new(CORE::pack("$format", @$self));
}

sub push {
    my ($self, @args) = @_;
    CORE::push(@$self, @args);
    $self;
}

*append = \&push;

sub unshift {
    my ($self, @args) = @_;
    CORE::unshift(@$self, @args);
    $self;
}

*prepend = \&unshift;

sub rotate {
    my ($self, $num) = @_;

    my $len = $#$self + 1;
    return bless([]) if $len == 0;
    $num = CORE::int($num) % $len;
    return bless([@$self], ref($self)) if $num == 0;

    my @array = @$self;
    CORE::unshift(@array, CORE::splice(@array, $num));
    bless \@array, ref($self);
}

sub join {
    my ($self, $delim, $block) = @_;
    $delim = defined($delim) ? "$delim" : '';

    if (defined $block) {
        return Sidef::Types::String::String->new(CORE::join($delim, map { scalar $block->run($_) } @$self));
    }

    Sidef::Types::String::String->new(CORE::join($delim, @$self));
}

sub join_bytes {
    my ($self, $encoding) = @_;
    state $x = require Encode;
    $encoding = defined($encoding) ? "$encoding" : 'UTF-8';
    Sidef::Types::String::String->new(eval { Encode::decode($encoding, CORE::pack('C*', @$self)) } // return);
}

*chrs   = \&join_bytes;
*decode = \&join_bytes;

sub join_insert {
    my ($self, $obj) = @_;

    my @array;
    foreach my $item (@$self) {
        CORE::push(@array, $item, $obj);
    }

    CORE::pop(@array);
    bless \@array;
}

sub reverse {
    my ($self) = @_;
    bless [CORE::reverse @$self], ref($self);
}

*flip = \&reverse;

sub delete_first {
    my ($self, $obj) = @_;

    foreach my $i (0 .. $#$self) {
        if ($self->[$i] eq $obj) {
            CORE::splice(@$self, $i, 1);
            return (Sidef::Types::Bool::Bool::TRUE);
        }
    }

    (Sidef::Types::Bool::Bool::FALSE);
}

*remove_first = \&delete_first;

sub delete_last {
    my ($self, $obj) = @_;

    for (my $i = $#$self ; $i >= 0 ; $i--) {
        if ($self->[$i] eq $obj) {
            CORE::splice(@$self, $i, 1);
            return (Sidef::Types::Bool::Bool::TRUE);
        }
    }

    (Sidef::Types::Bool::Bool::FALSE);
}

*remove_last = \&delete_last;

sub delete {
    my ($self, $obj) = @_;

    for (my $i = $#$self ; $i >= 0 ; --$i) {

lib/Sidef/Types/Array/Array.pm  view on Meta::CPAN

sub extract_last_by {
    my ($self, $block) = @_;

    $block //= Sidef::Types::Block::Block::IDENTITY;

    for (my $i = $#$self ; $i >= 0 ; --$i) {
        if ($block->run($self->[$i])) {
            return CORE::splice(@$self, $i, 1);
        }
    }

    return undef;
}

sub delete_first_if {
    my ($self, $block) = @_;

    $block //= Sidef::Types::Block::Block::IDENTITY;

    foreach my $i (0 .. $#$self) {
        if ($block->run($self->[$i])) {
            CORE::splice(@$self, $i, 1);
            return (Sidef::Types::Bool::Bool::TRUE);
        }
    }

    (Sidef::Types::Bool::Bool::FALSE);
}

*remove_first_if = \&delete_first_if;
*remove_first_by = \&delete_first_if;
*delete_first_by = \&delete_first_if;

sub delete_last_if {
    my ($self, $block) = @_;

    $block //= Sidef::Types::Block::Block::IDENTITY;

    for (my $i = $#$self ; $i >= 0 ; --$i) {
        if ($block->run($self->[$i])) {
            CORE::splice(@$self, $i, 1);
            return (Sidef::Types::Bool::Bool::TRUE);
        }
    }

    (Sidef::Types::Bool::Bool::FALSE);
}

*remove_last_if = \&delete_last_if;
*remove_last_by = \&delete_last_if;
*delete_last_by = \&delete_last_if;

sub to_list { @{$_[0]} }

sub getopt {
    my ($self, %opts) = @_;

    @$self or return Sidef::Types::Array::Array->new;

    state $x = require Getopt::Long;
    Getopt::Long::Configure('no_ignore_case');

    my @argv = map { "$_" } @$self;
    my @opts = CORE::keys %opts;

    my %parsed;
    Getopt::Long::GetOptionsFromArray(\@argv, \%parsed, @opts);

    my %lookup = map {
        my ($name) = Getopt::Long::ParseOptionSpec($_, \my %info);
        defined($name) ? ($name => {obj => $opts{$_}, type => $info{$name}[0]}) : ();
    } @opts;

    foreach my $key (CORE::keys %parsed) {

        my $rec  = $lookup{$key};
        my $obj  = $rec->{obj};
        my $type = $rec->{type};

        if (ref($obj) eq 'REF' or ref($obj) eq 'SCALAR') {
            my $ref = ref($$obj);

            # Determine the type for undefined references
            if ($ref eq '') {
                if ($type eq 'i' or $type eq 'f') {
                    $ref = 'Sidef::Types::Number::Number';
                }
                elsif ($type eq '') {
                    $ref = 'Sidef::Types::Bool::Bool';
                }
                else {
                    $ref = 'Sidef::Types::String::String';
                }
            }

            if (   $ref eq 'Sidef::Types::String::String'
                or $ref eq 'Sidef::Types::Number::Number') {
                $$obj = $ref->new($parsed{$key});
            }
            elsif ($ref eq 'Sidef::Types::Bool::Bool') {
                $$obj =
                  $parsed{$key}
                  ? Sidef::Types::Bool::Bool::TRUE
                  : Sidef::Types::Bool::Bool::FALSE;
            }
            else {
                if ($type eq '') {
                    $$obj = $ref->new(
                                      $parsed{$key}
                                      ? Sidef::Types::Bool::Bool::TRUE
                                      : Sidef::Types::Bool::Bool::FALSE
                                     );
                }
                elsif ($type eq 'i' or $type eq 'f') {
                    $$obj = $ref->new(Sidef::Types::Number::Number->new($parsed{$key}));
                }
                else {
                    $$obj = $ref->new(Sidef::Types::String::String->new($parsed{$key}));
                }
            }