File Coverage

blib/lib/List/Lazy.pm

Criterion	Covered	Total	%
statement	159	159	100.0
branch	35	38	92.1
condition	20	24	83.3
subroutine	36	36	100.0
pod	13	14	92.8
total	263	271	97.0

package List::Lazy;
our $AUTHORITY = 'cpan:YANICK';
# ABSTRACT: Generate lists lazily
$List::Lazy::VERSION = '0.4.0';

use Moo;
use MooX::HandlesVia;

use Clone qw/ clone /;

use 5.22.0;

use experimental 'signatures', 'postderef';

use List::MoreUtils;
use Carp;

*list_before = *List::MoreUtils::before;

extends 'Exporter::Tiny';

sub _exporter_validate_opts {
    my $into = $_[1]->{into};
    eval qq{
        *${into}::a = *::a;
        *${into}::b = *::b;
        1;
    } or die $@;
}

our @EXPORT_OK = qw/ lazy_list lazy_range lazy_fixed_list /;

our $MAX_NEXT = 10_000;

sub _lazy_list ($generator,$state=undef) {
    return List::Lazy->new(
        generator => $generator,
        state     => $state,
    );
}

sub lazy_list :prototype(&@) { goto &_lazy_list }

sub _lazy_range ($min,$max,$step=1) {
    my $it = ref $step ? $step : sub { $_ + $step };

    return scalar lazy_list {
        return if defined $max and  $_ > $max;
        my $current = $_;
        $_ = $it->();
        return $current;
    } $min;
}


sub lazy_range :prototype($$@) { goto &_lazy_range }

sub lazy_fixed_list {
    return List::Lazy->new(
        _next => [ @_ ],
        generator => sub { return () },
    );
}

has generator => (
    is => 'ro',
    required => 1,
);

has state => (
    is => 'rw'
);

has _next => (
    is => 'rw',
    handles_via => 'Array',
    handles => {
        has_next   => 'count',
        shift_next => 'shift',
        push_next => 'push',
        _all_next => 'elements',
    },
    default => sub { [] },
);

has is_done => (
    is => 'rw',
    default => sub { 0 },
);

sub generate_next($self) {
    local $_ = $self->state;

    my @values = $self->generator->();
    $self->state($_);

    $self->is_done(1) unless @values;

    return @values;
}

sub next($self,$num=1) {
    my @returns;

    my $count = 0;

    croak "next called in scalar context with \$num = $num"
        if defined wantarray and not wantarray and $num != 1;

    while( @returns < $num and not $self->is_done ) {
        if( ++$count > $MAX_NEXT ) {
            die <<"END";
Number of items returned by the lazy list exceeds MAX_NEXT ($MAX_NEXT).

If this is what you want, you can increase this limit via \$Lazy::List::MAX_NEXT
END
        }

        $self->push_next( $self->generate_next )
            unless $self->has_next;

        next unless $self->has_next;

        if( ref $self->_next->[0] eq 'List::Lazy' ) {
            my $list = $self->_next->[0];
            push @returns, $list->next;
            $self->shift_next if $list->is_done;
        }
        else {
            push @returns, $self->shift_next;
        }
    }

    return wantarray ? @returns : $returns[0];
}

sub all ($self) {
    return $self->next(1E99);
}

sub reduce($self,$reducer,$reduced=undef) {
    $reduced //= $self->next;

    while( my $next = $self->next ) {
        local ( $::a, $::b ) = ( $reduced, $next );
        $reduced = $reducer->();
    }

    return $reduced;
}

sub map($self,$map) {
    return List::Lazy->new(
        state => $self->_clone,
        generator => sub {
            while( my @next = $_->next ) {
                @next = map { $map->() } @next;
                return @next if @next;
            }
            return;
        },
    );
}

sub batch($self,$n) {
    return List::Lazy->new(
        state => [ $self->_clone, [] ],
        generator => sub {
            my $stash  = $_->[1];

            while( my @next = $_->[0]->next ) {
                push @$stash, @next;
                if( @$stash >= $n ) {
                    return [ splice @$stash, 0, $n ];
                }
            }

            return @$stash ? [ splice @$stash ] : ();
        },
    );
};

sub grep($self,$filter) {
    $self->map(sub{ $filter->() ? $_ : () })
}

sub spy($self,$sub=undef) {
    $sub ||= sub { carp $_ };
    $self->map(sub{ $sub->(); $_ } );
}

sub _clone($self,%args) {
    return List::Lazy->new(
        state     => clone( $self->state ),
        generator => $self->generator,
        _next => [ $self->_next->@* ],
        %args
    );
}

sub until($self,$condition) {
    my $done;
    return List::Lazy->new(
        state => $self->_clone,
        generator => sub {
            return () if $done;
            my @next = $_->next;
            my @filtered = list_before( sub { $condition->() }, @next );
            $done = @filtered < @next;
            return @filtered;
        },
    );
}

sub append($self,@list) {

    my @state = ( $self->_clone );

    while(@list) {
        if( ref $list[0] eq 'List::Lazy' ) {
            push @state, (shift @list)->_clone;
        }
        else {
            my @lazy;
            push @lazy, shift @list while @list and ref $list[0] ne 'List::Lazy';
            push @state, lazy_fixed_list @lazy;
        }
    }

    return List::Lazy->new(
        state => \@state,
        generator => sub {
            while(@$_) {
                shift @$_ while @$_ and $_->[0]->is_done;
                last unless @$_;
                my @next = $_->[0]->next;
                return @next if @next;
            }
            return ();
        },
    );
}

sub prepend( $self, @list ) {
    List::Lazy->new(done => 1, generator => sub {})->append(
        @list, $self,
    );
}

1;

__END__