Skip to content

Instantly share code, notes, and snippets.

@jnthn
Last active Aug 29, 2015
Embed
What would you like to do?
Great List Re-implementation: initial draft/exploration
# This file contains some work-in-progress bottom-up design work for the GLR.
# All types and operators introduced are prefixed with GLR, so there are no
# conflicts with those in core (the GLR prefix has even been used where there
# isn't anything in core to conflict with, to make clear what's being added).
# There's no syntax sugar, but rather explanations of what some syntax will
# desugar to are included. The various MAIN subs do tests to check correctness
# and various benchmarks to compare with what we have in Rakudo today.
# Up-front summary:
# * (1, 2, 3) makes a List; there is no Parcel. List supports laziness and
# positional read access, but notably not push/pop/shift/unshift/splice
# * [1, 2, 3] makes an Array, which supports binding to slots, enforces
# Scalar containers, provides push/pop/shift/unshift/splice, etc. It
# inherits from List.
# * slip(1, 2, 3) makes a Slip, which "slips" its values into an iterator
# that sees it. It also inherits from List.
# * (1, (2, 3), 4).elems is 3, (1, slip(2, 3), 4).elems is 4
# * xx, map/grep/etc., gather/take, and ... (and likely more) all return a
# Seq. A Seq is something that you can only iterate once; it does not
# remember its values. Calling .list on it obtains the iterator and
# gives back a List that will be populated (and cache) values from the
# iteration. It also remembers this list, so multiple calls to .list
# will work out. Effectively, a Seq is memoized through .list. Trying to
# obtain the iterator from a Seq more than once will result in an
# exception. It's also possible to .List and .Slip a Seq; both take
# ownership of the iterator and do not memoize the result.
# * A Seq is not Positional, thus:
# my @a := (^10).map(* + 1); # Type check error
# my @a := gather { loop { take 'away' } } # The same
# my @a := 1 xx 100; # You guessed it...
# The ::= binding form (which is used in signature binding) will call
# .list on the Seq and bind the result of that, however.
# my @a ::= 1 xx 1000000; # Works
# for @a { } # Congrats, you now have 1 million Ints
# A Scalar container can hold anything, and so such an assignment or
# binding works out. However, you're talking about a thing that can
# produce values in that case.
# my $a = 1 xx 1000000; # Works
# for $a { } # Iterates 1000000 times, constant memory
# for $a { } # Exception: you already consumed that Seq
# Note that since the Seq is not Positional, you can't index it:
# my $a = (2, 4 ... *); # Assigns a Seq
# say $a[10]; # Exception because you can't index a Seq
# Note that every single example in this section failed to use what most
# programmers will actually use: assignment into an array.
# my @a = 2, 4, ... 100; # Works, and eagerly assigns
# for @a.map(* + 1) { } # But won't remember the map results
# for lines() { } # Constant in memory as lines() returns Seq
# * Iterable is just a role saying you have an iterator method. It implies
# that flat should flatten the values unless there is a Scalar container
# around the Iterable thing.
# * Iterator is a role done by iterators, with common infrastructure. We don't
# expect normal code to ever see the objects that do Iterator. Unless it
# calls .iterator, of course. The Iterator API only demands implementation
# of the pull-one method, which asks for a single value. Every other method
# has a default implementation in terms of this. However, any Iterator is
# free to override other methods when it can do something smarter. (This is
# how we realize the negotiation that Larry has mentioned. For example, an
# .elems call on a List will tell any iterators to simply dump all of their
# things into its reified items buffer, and they can do their best to make
# that happen quickly.)
# * A couple of other types show up as infrastructure, but they're only of
# interest to anyone implementing the Iterator API.
# * The [...] array constructor does not flatten, but respects Slips. It will
# eagerly evluate up until it encounters something lazy.
# * Array assignment (@a = ...) considers the right hand side as a whole. If
# it's not Iterable, the Array ends up with one item. If it is Iterable, the
# iterator is obtained and used to populate the array up until something
# lazy is encountered. Remembering that an array also stores all of the
# things you put in it into a Scalar container, this gives:
# my @a = 1, 2, 3; # 3 elements [1, 2, 3]
# my @b = [1, 2], [3, 4]; # 2 elements [$[1, 2], $[3, 4]]
# my @c = @a, @b; # 2 elements [$[1, 2, 3], $[$[1, 2], $[3, 4]]]
# my @d = @a.Slip, @b.Slip; # 5 elements [1, 2, 3, $[1, 2], $[3, 4]]
# my @e = flat @a, @b; # 5 elements [1, 2, 3, $[1, 2], $[3, 4]]
# my @f = 'ale' xx 4; # 4 elements
# my @g = 1..10; # 10 elements
# Noting that [...] is not an item, then:
# my @x = flat [1, 2], [3]; # 3 elements, [1, 2, 3]
# Note that [...] not producing an item is the reason the flat is needed. If
# we didn't demand it, then we'd end up with assigning [1, 2], [3, 4] giving
# 4 values, which is clearly worse than having to write flat now and then!
# * The desire to iterate until an lazy thing is hit is carried deep into
# the iterator, so composites that may iterate many things along the way can
# do the right thing. Thus, there's no hang from doing:
# my @y = 1, 2, (3 xx *).Slip;
# Or, as it is more comfortably written:
# my @y = flat 1, 2, 3 xx *;
# * .hyper() and .race() return a HyperSeq.
# * They are also both contaigous for operations that know what to do with
# them. That is, once you have opted in to parallelizing, operations that
# are chained on and know how to parallelize will be. Those that would
# normally return a Seq will instead return a HyperSeq. Those that give
# a Scalar result are free to to something smarter with a HyperSeq.
use nqp;
use MONKEY-TYPING;
# IterationBuffer is used when the list/iteration implementation needs a
# lightweight way to store/transmit values. Replaces the use of nqp::list in
# the list guts, which is an impediment to introspectability and also to
# allowing the implementation of custom iterators (though in reality most
# folks won't implement Iterator directly, but instead use gather/take or lazy
# loops). It doesn't make Scalar containers, and only supports mutation
# through implementing push and BIND-POS, and access by implementing AT-POS.
# Hot-paths are free to use the nqp:: op set directly on this, and do things
# outside the scope of the method API it exposes. This type is engineered for
# performance over friendliness, and normal Perl 6 users should never see it,
# just as they never saw the things we did with nqp::list(...) in previous
# list guts implementations. Do NOT add any checks and validation to methods
# in here. They need to remain trivially inlineable for performance reasons.
my class GLRIterationBuffer is repr('VMArray') {
method clear(GLRIterationBuffer:D:) {
nqp::setelems(self, 0)
}
multi method elems(GLRIterationBuffer:D:) {
nqp::elems(self)
}
multi method push(GLRIterationBuffer:D: Mu \value) {
nqp::push(self, value)
}
multi method AT-POS(GLRIterationBuffer:D: int $pos) {
nqp::atpos(self, $pos)
}
multi method AT-POS(GLRIterationBuffer:D: Int $pos) {
nqp::atpos(self, $pos)
}
multi method BIND-POS(GLRIterationBuffer:D: int $pos, Mu \value) {
nqp::bindpos(self, $pos, value)
}
multi method BIND-POS(GLRIterationBuffer:D: Int $pos, Mu \value) {
nqp::bindpos(self, $pos, value)
}
}
# We use a sentinel value to mark the end of an iteration.
my constant GLRIterationEnd = Mu.new;
# The Iterator role defines the API for an iterator and provides simple
# fallback implementations for most of it, so any given iterator can pick
# and choose what bits it can implement better for performance and/or
# correctness reasons.
my role GLRIterator {
# Pulls one value from the iterator. If there's nothing more to pull,
# returns the constant IterationEnd. If you don't override any other
# methods in this role, they'll all end up falling back to using this.
method pull-one() { ... }
# Has the iterator produce a certain number of values and push them into
# the target. The only time the iterator may push less values than asked
# for is when it reaches the end of the iteration. It may never push more
# values than are requested. Iterators that can do something smarter than
# the default implementation here should override this method. Should
# return how many things were pushed. Note that if the iterator does any
# side-effects as a result of producing values then up to $n of them will
# occur; you must be sure this is desired. Returns the number of things
# pushed, or IterationEnd if it reached the end of the iteration.
method push-exactly($target, int $n) {
my int $i = 0;
my $pulled;
while $i < $n {
$pulled := self.pull-one();
last if $pulled =:= GLRIterationEnd;
$target.push($pulled);
$i = $i + 1;
}
$pulled =:= GLRIterationEnd
?? GLRIterationEnd
!! $i
}
# Has the iteration push at least a certain number of values into the
# target buffer. For iterators that do side-effects, this should always
# be the same as push-exactly. Those that know they can safely work ahead
# to achieve better throughput may do so. Returns the number of things
# pushed, or IterationEnd if it reached the end of the iteration.
method push-at-least($target, int $n) {
self.push-exactly($target, $n)
}
# Has the iterator produce all of its values into the target. This is
# mostly just for convenience/clarity; it calls push-at-least with a
# very large value in a loop, but will probably only ever need to do
# one call to it. Thus, overriding push-at-least or push-exactly is
# sufficient; you needn't override this. Returns IterationEnd.
method push-all($target) {
# Size chosen for when int is 32-bit
until self.push-at-least($target, 0x7FFFFFFF) =:= GLRIterationEnd { }
GLRIterationEnd
}
# Pushes things until we hit a lazy iterator (one whose lazy method returns
# True). The default works well for non-composite iterators (that is, those
# that don't trigger the evaluation of other iterators): it looks at the
# lazy property of itself, and if it's true, does nothing, otherwise it
# calls push-all. If all values the iterator can produce are pushed, then
# IterationEnd should be returned. Otherwise, return something else (Mu
# will do fine).
method push-until-lazy($target) {
self.lazy
?? Mu
!! self.push-all($target)
}
# Consumes all of the values in the iterator for their side-effects only.
# May be overridden by iterators to either warn about use of things in
# sink context that should not be used that way, or to process things in
# a more efficient way when we know we don't need the results.
method sink-all() {
until self.pull-one() =:= GLRIterationEnd { }
GLRIterationEnd
}
# Whether the iterator is lazy (True if yes, False if no).
method lazy() {
False
}
}
# A SlippyIterator is one that comes with some infrastructure for handling
# flattening a received Slip into its own stream of values.
my class GLRSlip { ... }
my role GLRSlippyIterator does GLRIterator {
# Flat set to non-zero if the iterator is currently consuming a Slip.
has int $!slipping;
# The current Slip we're iterating.
has $!slip-iter;
method start-slip(GLRSlip:D $slip) {
$!slipping = 1;
$!slip-iter := $slip.iterator;
self.slip-one()
}
method slip-one() {
my \result = $!slip-iter.pull-one;
if result =:= GLRIterationEnd {
$!slipping = 0;
$!slip-iter := Mu;
}
result
}
}
# Configuration for hyper/race, controlling how we parallelize. Not a class
# end users can expect to work with unless they're doing truly special
# things.
my class HyperConfiguration {
has Bool $.race;
has int $.batch;
has Int $.degree;
}
# A HyperWorkBuffer represents a chunk of work to be processed as part of a
# parallelized operation (either thanks to hyper or race). It carries a
# sequence number, and input buffer (items to process), and an output buffer
# (results of processing them).
my class GLRHyperWorkBuffer {
has int $.sequence-number is rw;
has $.input;
has $.output;
method new() {
my \wb = self.CREATE;
nqp::bindattr(wb, GLRHyperWorkBuffer, '$!input', GLRIterationBuffer.CREATE);
nqp::bindattr(wb, GLRHyperWorkBuffer, '$!output', GLRIterationBuffer.CREATE);
wb
}
# Clears both buffers.
method clear() {
nqp::setelems($!input, 0);
nqp::setelems($!output, 0);
Nil
}
# Swaps around the input/output buffers, and clears the output buffer.
# (This is used between pipelined stages, where the next stage will
# use the items in the first.)
method swap() {
my $new-input := $!output;
$!output := $!input;
$!input := $new-input;
nqp::setelems($!output, 0);
Nil
}
# Gets an iterator of the input.
method input-iterator() {
class :: does GLRIterator {
has $!buffer;
has int $!i;
method new(\buffer) {
my \iter = self.CREATE;
nqp::bindattr(iter, self, '$!buffer', buffer);
iter
}
method pull-one() {
my int $i = $!i;
if $i < nqp::elems($!buffer) {
$!i = $i + 1;
nqp::atpos($!buffer, $i)
}
else {
GLRIterationEnd
}
}
}.new($!input)
}
}
# HyperIterator is done by things that know how to get a batch of values
# filled up, and maybe to process it.
my role GLRHyperIterator {
# Called in order to fill up a work buffer with items. For things that
# can be part of a pipeline of operations, this simply defers to the
# next thing in the pipeline, up until a source is reached. The source
# should push items to the input of the work buffer. Only one thread
# can ever be calling fill-batch on a given iterator chain at a time
# (usually the co-ordinating thread), so you can safely consume items
# from any usual iterable to fill the batch. Return IterationEnd if this
# is the last buffer you can produce, and anything else otherwise.
method fill-buffer(GLRHyperWorkBuffer:D $work, int $items) { ... }
# Process the provided work buffer. If you are a source, then return Mu.
# If you are a processing stage, you should pass the work buffer down to
# the next process-buffer in the chain. If it returns a GLRHyperWorkBuffer,
# then .swap() it so the previous stage's output is now your input, and
# then process it, putting your results into the output buffer. This is
# the code that can run on any thread; keep it side-effect free.
method process-buffer(GLRHyperWorkBuffer:D $work) { ... }
# Gets HyperConfiguration information for this parallelized operation.
# Processing stages should ask their source.
method configuration() returns HyperConfiguration { ... }
}
# Iterable is done by anything that we should be able to get an iterator
# from. Things that are Iterable will flatten in flattening contexts, so a
# default implementation of .flat is provided by this role. As itemization is
# what defeats flattening, this role also provides a default .item method.
# Additionally, as .lazy and .eager are about iterator behavior, they are
# provided by this role. Overriding those is not likely to be needed, and
# discouraged to maintain predictable semantics. Finally, both .hyper() and
# .race() are implemented here, and return a HyperSeq wrapping the iterator.
my class GLRSeq { ... }
my class GLRHyperSeq { ... }
my role GLRIterable {
method iterator() returns GLRIterator { ... }
method item() {
nqp::p6bindattrinvres(nqp::create(Scalar), Scalar, '$!value', self)
}
method flat() {
GLRSeq.new(class :: does GLRIterator {
has $!source;
has GLRIterator $!nested-iter;
method new(\source-iter) {
my \iter = self.CREATE;
nqp::bindattr(iter, self, '$!source', source-iter);
iter
}
method pull-one() {
my $result;
loop {
if $!nested-iter {
$result := $!nested-iter.pull-one();
last unless $result =:= GLRIterationEnd;
$!nested-iter := GLRIterator;
}
$result := $!source.pull-one();
last unless nqp::istype($result, GLRIterable) && !nqp::iscont($result);
$!nested-iter := $result.flat.iterator;
}
$result
}
# This is a prime candidate for implementing most of the other
# methods, for speed reasons
}.new(self.iterator))
}
method lazy() {
# Return a Seq with an iterator wrapping this Iterable, claiming to
# be lazy, and implicitly preventing working ahead (by hiding any
# push-at-least-n of the source iterator).
GLRSeq.new(class :: does GLRIterator {
has $!iterable;
has $!iterator;
method new(\iterable) {
my \iter = self.CREATE;
nqp::bindattr(iter, self, '$!iterable', iterable);
iter
}
method pull-one() {
unless $!iterator.DEFINITE {
$!iterator := $!iterable.iterator;
}
$!iterator.pull-one
}
method push-exactly($target, int $n) {
unless $!iterator.DEFINITE {
$!iterator := $!iterable.iterator;
}
$!iterator.push-exactly($target, $n);
}
method lazy() { True }
}.new(self))
}
method eager() {
GLRSeq.new(class :: does GLRIterator {
has $!iterator;
has $!cache;
method new(\iterator) {
my \iter = self.CREATE;
nqp::bindattr(iter, self, '$!iterator', iterator);
iter
}
method pull-one() {
self!fill-cache() unless $!cache.DEFINITE;
nqp::elems($!cache)
?? nqp::shift($!cache)
!! GLRIterationEnd
}
method push-exactly($target, int $n) {
self!fill-cache() unless $!cache.DEFINITE;
my $cache := $!cache;
my int $todo = $n < nqp::elems($cache)
?? $n
!! nqp::elems($cache);
my int $i = 0;
while $i < $n {
$target.push(nqp::shift($cache));
$i = $i + 1
}
nqp::elems($cache)
?? $todo
!! GLRIterationEnd
}
method push-at-least($target, int $n) {
self!all($target)
}
method push-until-lazy($target) {
self!all($target)
}
method push-all($target) {
self!all($target)
}
method !fill-cache() {
$!cache := GLRIterationBuffer.CREATE;
$!iterator.push-all($!cache);
}
method !all($target) {
# Normally if we end up here, we didn't pull things into the
# cache. But if we did, delegate to the default version of
# push-all from the role to make sure we eat out the cache,
# not from the now-depleted iterator.
$!cache.DEFINITE
?? self.GLRIterator::push-all($target)
!! $!iterator.push-all($target)
}
}.new(self.iterator))
}
method hyper(Int(Cool) :$batch = 64, Int(Cool) :$degree = 4) {
self!go-hyper(HyperConfiguration.new(:!race, :$batch, :$degree))
}
method race(Int(Cool) :$batch = 64, Int(Cool) :$degree = 4) {
self!go-hyper(HyperConfiguration.new(:race, :$batch, :$degree))
}
method !go-hyper($configuration) {
GLRHyperSeq.new(class :: does GLRHyperIterator {
has $!source;
has $!configuration;
method new(\iter, $configuration) {
my \hyper-iter = self.CREATE;
nqp::bindattr(hyper-iter, self, '$!source', iter);
nqp::bindattr(hyper-iter, self, '$!configuration', $configuration);
hyper-iter
}
method fill-buffer(GLRHyperWorkBuffer:D $work, int $items) {
$!source.push-exactly($work.input, $items)
}
method process-buffer(GLRHyperWorkBuffer:D $work) {
Mu
}
method configuration() { $!configuration }
}.new(self.iterator, $configuration));
}
}
# HyperIterable is done by anything that can produce a HyperIterator.
my role GLRHyperIterable {
method hyper-iterator() { ... }
}
# A Seq represents anything that can lazily produce a sequence of values. A
# Seq is born in a state where iterating it will consume the values. However,
# calling .list on a Seq will return a List that will lazily reify to the
# values in the Seq. The List is memoized, so that subsequent calls to .list
# will always return the same List (safe thanks to List being immutable). More
# than one call to .iterator throws an exception (and calling .list calls the
# .iterator method the first time also). The memoization can be avoided by
# asking very specifically for the Seq to be coerced to a List (.List), a
# Slip (.Slip) or an Array (.Array). The actual memoization functionality is
# factored out into a role, MemoizeAsPositional, which is used by the binder
# to identify types that, on failure to bind to an @-sigilled thing, can have
# .list called on them and expect memoization semantics. This not only makes
# it easy for HyperSeq to also have this functionality, but makes it available
# for other kinds of paradigm that show up in the future (beyond sequential
# and parallel) that also want to have this behavior.
my class GLRList { ... }
my class GLRArray { ... }
class X::GLRSeq::Consumed is Exception {
method message() {
"This Seq has already been iterated, and its values consumed"
}
}
class X::GLRSeq::NotIndexable is Exception {
method message() {
"Cannot index a Seq; coerce it to a list or assign it to an array first"
}
}
my role PositionalBindFailover {
has $!list;
method list() {
$!list.DEFINITE
?? $!list
!! ($!list := GLRList.from-iterator(self.iterator))
}
}
my class GLRSeq does GLRIterable does PositionalBindFailover {
# The underlying iterator that iterating this sequence will work its
# way through. Can only be obtained once.
has GLRIterator $!iter;
# The only valid way to create a Seq directly is by giving it the
# iterator it will consume and maybe memoize.
method new(GLRIterator:D $iter) {
my $seq := self.CREATE;
nqp::bindattr($seq, GLRSeq, '$!iter', nqp::decont($iter));
$seq
}
method iterator(GLRSeq:D:) {
my \iter = $!iter;
X::GLRSeq::Consumed.new.throw unless iter.DEFINITE;
$!iter := GLRIterator;
iter
}
method List() {
GLRList.from-iterator(self.iterator)
}
method Slip() {
GLRSlip.from-iterator(self.iterator)
}
method Array() {
GLRArray.from-iterator(self.iterator)
}
method sink() {
self.iterator.sink-all;
self
}
multi method AT-POS(GLRSeq:D: $) {
X::GLRSeq::NotIndexable.new.throw
}
multi method EXISTS-POS(GLRSeq:D: $) {
X::GLRSeq::NotIndexable.new.throw
}
multi method DELETE-POS(GLRSeq:D: $) {
X::GLRSeq::NotIndexable.new.throw
}
# Lazy loops produce a Seq wrapping a loop iterator. We have a few
# special cases of that.
my class InfiniteLoopIter does GLRSlippyIterator {
has &!body;
method new(&body) {
my \iter = self.CREATE;
nqp::bindattr(iter, self, '&!body', &body);
iter
}
method pull-one() {
my int $redo = 1;
my $result;
if $!slipping && ($result := self.slip-one()) !=:= GLRIterationEnd {
$result
}
else {
nqp::while(
$redo,
nqp::stmts(
$redo = 0,
nqp::handle(
nqp::stmts(
($result := &!body()),
nqp::if(
nqp::istype($result, GLRSlip),
nqp::stmts(
($result := self.start-slip($result)),
nqp::if(
nqp::eqaddr($result, GLRIterationEnd),
($redo = 1)
))
)),
'NEXT', ($redo = 1),
'REDO', ($redo = 1),
'LAST', ($result := GLRIterationEnd))),
:nohandler);
$result
}
}
method lazy() { True }
}
my class WhileLoopIter does GLRSlippyIterator {
has &!body;
has &!cond;
has int $!skip-cond;
method new(&body, &cond, :$repeat) {
my \iter = self.CREATE;
nqp::bindattr(iter, self, '&!body', &body);
nqp::bindattr(iter, self, '&!cond', &cond);
nqp::bindattr_i(iter, self, '$!skip-cond', $repeat ?? 1 !! 0);
iter
}
method pull-one() {
my int $redo = 1;
my $result;
if $!slipping && ($result := self.slip-one()) !=:= GLRIterationEnd {
$result
}
else {
if $!skip-cond || &!cond() {
$!skip-cond = 0;
nqp::while(
$redo,
nqp::stmts(
$redo = 0,
nqp::handle(
nqp::stmts(
($result := &!body()),
nqp::if(
nqp::istype($result, GLRSlip),
nqp::stmts(
($result := self.start-slip($result)),
nqp::if(
nqp::eqaddr($result, GLRIterationEnd),
($redo = &!cond() ?? 1 !! 0)
))
)),
'NEXT', ($redo = &!cond() ?? 1 !! 0),
'REDO', ($redo = 1),
'LAST', ($result := GLRIterationEnd))),
:nohandler);
$result
}
else {
GLRIterationEnd
}
}
}
method lazy() { False }
}
my class CStyleLoopIter does GLRSlippyIterator {
has &!body;
has &!cond;
has &!afterwards;
has int $!first-time;
method new(&body, &cond, &afterwards) {
my \iter = self.CREATE;
nqp::bindattr(iter, self, '&!body', &body);
nqp::bindattr(iter, self, '&!cond', &cond);
nqp::bindattr(iter, self, '&!afterwards', &afterwards);
nqp::bindattr_i(iter, self, '$!first-time', 1);
iter
}
method pull-one() {
my int $redo = 1;
my $result;
if $!slipping && ($result := self.slip-one()) !=:= GLRIterationEnd {
$result
}
else {
$!first-time
?? ($!first-time = 0)
!! &!afterwards();
if &!cond() {
nqp::while(
$redo,
nqp::stmts(
$redo = 0,
nqp::handle(
nqp::stmts(
($result := &!body()),
nqp::if(
nqp::istype($result, GLRSlip),
nqp::stmts(
($result := self.start-slip($result)),
nqp::if(
nqp::eqaddr($result, GLRIterationEnd),
nqp::stmts(
&!afterwards(),
($redo = &!cond() ?? 1 !! 0))
))
)),
'NEXT', nqp::stmts(
&!afterwards(),
($redo = &!cond() ?? 1 !! 0)),
'REDO', ($redo = 1),
'LAST', ($result := GLRIterationEnd))),
:nohandler);
$result
}
else {
GLRIterationEnd
}
}
}
method lazy() { False }
}
proto method from-loop(|) { * }
multi method from-loop(&body) {
GLRSeq.new(InfiniteLoopIter.new(&body))
}
multi method from-loop(&body, &cond, :$repeat) {
GLRSeq.new(WhileLoopIter.new(&body, &cond, :$repeat))
}
multi method from-loop(&body, &cond, &afterwards) {
GLRSeq.new(CStyleLoopIter.new(&body, &cond, &afterwards))
}
}
# A HyperSeq wraps up a HyperIterator. When asked for the hyper-iterator, it
# simply returns it, then complains if you ask a second time - much like Seq
# does for its iterator. If you ask for its iterator, then you are ending the
# declaration of a chain of parallelizable operations. That is, in fact, the
# thing that will actually kick off the parallel work.
my class GLRHyperSeq does GLRIterable does GLRHyperIterable does PositionalBindFailover {
has GLRHyperIterator $!hyper-iter;
# The only valid way to create a HyperSeq directly is by giving it the
# hyper-iterator it will expose and maybe memoize.
method new(GLRHyperIterator:D $hyper-iter) {
my \hseq := self.CREATE;
nqp::bindattr(hseq, GLRHyperSeq, '$!hyper-iter', nqp::decont($hyper-iter));
hseq
}
# Obtains the hyper-iterator (meaning we're being consumed as part of a
# parallel processing pipeline).
method hyper-iterator(GLRHyperSeq:D:) {
my \hyper-iter = $!hyper-iter;
X::GLRSeq::Consumed.new.throw unless hyper-iter.DEFINITE;
$!hyper-iter := GLRHyperIterator;
hyper-iter
}
# Obtain the iterator, the consumption of which will kick off parallel
# processing.
method iterator(GLRHyperSeq:D:) {
class :: does GLRIterator {
constant NOT_STARTED = 0;
constant STARTED = 1;
constant ALL_ADDED = 2;
# For concurrency control
has $!lock;
has $!cond-have-work;
has $!cond-have-result;
# State that must be protected by the above lock, used by all
# threads involved.
has $!work-available;
has $!work-completed;
has int $!in-progress;
# State only touched by the thread controlling the iteration.
has $!configuration;
has $!hyper-iterator;
has $!active-result-buffer;
has $!status;
has int $!sequence-number;
method new(\hyper-iterator) {
my \iter = self.CREATE;
my \lock = Lock.new;
nqp::bindattr(iter, self, '$!hyper-iterator', hyper-iterator);
nqp::bindattr(iter, self, '$!configuration', hyper-iterator.configuration);
nqp::bindattr(iter, self, '$!work-available', GLRIterationBuffer.CREATE);
nqp::bindattr(iter, self, '$!work-completed', GLRIterationBuffer.CREATE);
nqp::bindattr(iter, self, '$!lock', lock);
nqp::bindattr(iter, self, '$!cond-have-work', lock.condition);
nqp::bindattr(iter, self, '$!cond-have-result', lock.condition);
nqp::bindattr(iter, self, '$!status', NOT_STARTED);
iter
}
method pull-one() {
self!start() if $!status == NOT_STARTED;
self!block-for-result() unless $!active-result-buffer.DEFINITE;
if $!active-result-buffer.DEFINITE {
my \result = nqp::shift($!active-result-buffer);
$!active-result-buffer := Mu
unless nqp::elems($!active-result-buffer);
result
}
else {
GLRIterationEnd
}
}
method !start() {
# Mark that we've started the work (done here because this
# may get upgraded to ALL_ADDED if there's not much work).
$!status := STARTED;
# Add batches and start workers. Provided there is enough
# work to do, this should feed them all nicely.
for ^$!configuration.degree {
my \done = self!add-batch();
self!start-worker();
last if done =:= GLRIterationEnd;
}
}
method !add-batch() {
my \work = GLRHyperWorkBuffer.new;
work.sequence-number = $!sequence-number++;
# XXX error handling around below
my \done = $!hyper-iterator.fill-buffer(work, $!configuration.batch);
$!lock.protect({
nqp::push($!work-available, work);
if done =:= GLRIterationEnd {
$!status := ALL_ADDED;
$!cond-have-work.signal_all();
#nqp::say("added batch, signalled all");
} else {
$!cond-have-work.signal();
#nqp::say("added batch, signalled one");
}
});
done
}
method !start-worker() {
start {
loop {
# Acquire work.
my $my-work;
$!lock.protect({
until $my-work.DEFINITE {
if nqp::elems($!work-available) {
$my-work := nqp::shift($!work-available);
$!in-progress++;
}
elsif $!status == ALL_ADDED {
last;
}
else {
$!cond-have-work.wait();
}
}
});
unless $my-work.DEFINITE {
$!cond-have-result.signal();
last;
}
# Do work.
#nqp::say("processing work batch (size = {$my-work.input.elems})");
try {
$!hyper-iterator.process-buffer($my-work);
CATCH {
default {
# XXX error handling
nqp::say(.gist);
}
}
}
# Place in results and signal anyone waiting for it.
#nqp::say("send back work batch (size = {$my-work.output.elems})");
$!lock.protect({
nqp::push($!work-completed, $my-work);
$!in-progress--;
$!cond-have-result.signal();
});
}
}
}
method !block-for-result() {
my int $we-got-an-empty-buffer;
repeat while $we-got-an-empty-buffer {
my int $work-deficit = 0;
$we-got-an-empty-buffer = 0;
$!lock.protect({
until nqp::elems($!work-completed) || self!finished() {
$!cond-have-result.wait();
}
if nqp::elems($!work-completed) {
$!active-result-buffer := nqp::shift($!work-completed).output;
$work-deficit = $!configuration.degree - nqp::elems($!work-available);
if $!active-result-buffer.elems == 0 {
$!active-result-buffer := Mu;
$we-got-an-empty-buffer = 1;
}
}
});
while $!status != ALL_ADDED && $work-deficit > 0 {
last if self!add-batch() =:= GLRIterationEnd;
$work-deficit--;
}
}
}
method !finished() {
$!status == ALL_ADDED &&
nqp::elems($!work-available) == 0 &&
$!in-progress == 0
}
}.new(self.hyper-iterator)
}
# Various operations use the sequential iterator since they wish to set
# off the parallel processing and consume the results.
method List(GLRHyperSeq:D:) {
GLRList.from-iterator(self.iterator)
}
method Slip(GLRHyperSeq:D:) {
GLRSlip.from-iterator(self.iterator)
}
method Array(GLRHyperSeq:D:) {
GLRArray.from-iterator(self.iterator)
}
method sink(GLRHyperSeq:D:) {
# Means we're doing parallel work for its side-effects. Doesn't need
# any special handling, nor does it warrant a warning since this is
# what 'hyper for @xs -> $x { }' will end up calling.
self.iterator.sink-all;
self
}
# Not indexable.
multi method AT-POS(GLRHyperSeq:D: $) {
X::GLRSeq::NotIndexable.new.throw
}
multi method EXISTS-POS(GLRHyperSeq:D: $) {
X::GLRSeq::NotIndexable.new.throw
}
multi method DELETE-POS(GLRHyperSeq:D: $) {
X::GLRSeq::NotIndexable.new.throw
}
}
# A List is a (potentially infite) immutable list. The immutability is not
# deep; a List may contain Scalar containers that can be assigned to. However,
# it is not possible to shift/unshift/push/pop/splice/bind. A List is also
# Positional, and so may be indexed.
my class GLRList does GLRIterable does Positional {
# The reified elements in the list so far (that is, those that we already
# have produced the values for).
has $!reified;
# Object that reifies the rest of the list. We don't just inline it into
# the List class itself, because a STORE on Array can clear things and
# upset an ongoing iteration. (An easy way to create such a case is to
# assign an array with lazy parts into itself.)
has $!todo;
# The object that goes into $!todo.
class Reifier {
# Our copy of the reified elements in the list so far.
has $!reified;
# The current iterator, if any, that we're working our way through in
# order to lazily reify values. Must be depleted before $!future is
# considered.
has GLRIterator $!current-iter;
# The (possibly lazy) values we've not yet incorporated into the list. The
# only thing we can't simply copy from $!future into $!reified is a Slip
# (and so the only reason to have a $!future is that there is at least one
# Slip).
has $!future;
# The reification target (what .reify-* will .push to). Exists so we can
# share the reification code between List/Array. List just uses its own
# $!reified buffer; the Array one shoves stuff into Scalar containers
# first.
has $!reification-target;
method reify-at-least(int $elems) {
if $!current-iter.DEFINITE {
if $!current-iter.push-at-least($!reification-target,
$elems - nqp::elems($!reified)) =:= GLRIterationEnd {
$!current-iter := GLRIterator;
}
}
if nqp::elems($!reified) < $elems && $!future.DEFINITE {
repeat while nqp::elems($!reified) < $elems && nqp::elems($!future) {
my \current = nqp::shift($!future);
$!future := Mu unless nqp::elems($!future);
if nqp::istype(current, GLRSlip) && nqp::isconcrete(current) {
my \iter = current.iterator;
my int $deficit = $elems - nqp::elems($!reified);
unless iter.push-at-least($!reification-target, $deficit) =:= GLRIterationEnd {
# The iterator produced enough values to fill the need,
# but did not reach its end. We save it for next time. We
# know we'll exit the loop, since the < $elems check must
# come out False (unless the iterator broke contract).
$!current-iter := iter;
}
}
else {
$!reification-target.push(current);
}
}
}
nqp::elems($!reified);
}
method reify-until-lazy() {
if $!current-iter.DEFINITE {
if $!current-iter.push-until-lazy($!reification-target) =:= GLRIterationEnd {
$!current-iter := GLRIterator;
}
}
if $!future.DEFINITE && !$!current-iter.DEFINITE {
while nqp::elems($!future) {
my \current = nqp::shift($!future);
if nqp::istype(current, GLRSlip) && nqp::isconcrete(current) {
my \iter = current.iterator;
unless iter.push-until-lazy($!reification-target) =:= GLRIterationEnd {
$!current-iter := iter;
last;
}
}
else {
$!reification-target.push(current);
}
}
$!future := Mu unless nqp::elems($!future);
}
nqp::elems($!reified);
}
method reify-all() {
if $!current-iter.DEFINITE {
$!current-iter.push-all($!reification-target);
$!current-iter := GLRIterator;
}
if $!future.DEFINITE {
while nqp::elems($!future) {
my \current = nqp::shift($!future);
nqp::istype(current, GLRSlip) && nqp::isconcrete(current)
?? current.iterator.push-all($!reification-target)
!! $!reification-target.push(current);
}
$!future := Mu;
}
nqp::elems($!reified);
}
method fully-reified() {
!$!current-iter.DEFINITE && !$!future.DEFINITE
}
method lazy() {
$!current-iter.DEFINITE ?? $!current-iter.lazy !! False
}
}
method from-iterator(GLRList:U: GLRIterator $iter) {
my \result := self.CREATE;
my \buffer := GLRIterationBuffer.CREATE;
my \todo := Reifier.CREATE;
nqp::bindattr(result, GLRList, '$!reified', buffer);
nqp::bindattr(result, GLRList, '$!todo', todo);
nqp::bindattr(todo, Reifier, '$!reified', buffer);
nqp::bindattr(todo, Reifier, '$!current-iter', $iter);
nqp::bindattr(todo, Reifier, '$!reification-target',
result.reification-target());
result
}
method reification-target(GLRList:D:) {
$!reified
}
multi method elems(GLRList:D:) {
$!todo.DEFINITE
?? $!todo.reify-all()
!! nqp::elems($!reified)
}
multi method AT-POS(GLRList:D: Int $pos) is rw {
my int $ipos = nqp::unbox_i($pos);
$ipos < nqp::elems($!reified) && $ipos >= 0
?? nqp::atpos($!reified, $ipos)
!! self!AT-POS-SLOWPATH($ipos);
}
multi method AT-POS(GLRList:D: int $pos) is rw {
$pos < nqp::elems($!reified) && $pos >= 0
?? nqp::atpos($!reified, $pos)
!! self!AT-POS-SLOWPATH($pos);
}
method !AT-POS-SLOWPATH(int $pos) is rw {
fail X::OutOfRange.new(:what<Index>, :got($pos), :range<0..Inf>)
if $pos < 0;
$!todo.DEFINITE && $!todo.reify-at-least($pos + 1) > $pos
?? nqp::atpos($!reified, $pos)
!! Nil
}
method iterator(GLRList:D:) {
class :: does GLRIterator {
has int $!i;
has $!reified;
has $!todo;
method new(\list) {
my $iter := self.CREATE;
nqp::bindattr($iter, self, '$!reified',
nqp::getattr(list, GLRList, '$!reified'));
nqp::bindattr($iter, self, '$!todo',
nqp::getattr(list, GLRList, '$!todo'));
$iter
}
method pull-one() {
my int $i = $!i;
$i < nqp::elems($!reified)
?? nqp::atpos($!reified, ($!i = $i + 1) - 1)
!! self!reify-and-pull-one()
}
method !reify-and-pull-one() {
my int $i = $!i;
$!todo.DEFINITE && $i < $!todo.reify-at-least($i + 1)
?? nqp::atpos($!reified, ($!i = $i + 1) - 1)
!! GLRIterationEnd
}
method push-until-lazy($target) {
my int $n = $!todo.DEFINITE
?? $!todo.reify-until-lazy()
!! nqp::elems($!reified);
my int $i = $!i;
while $i < $n {
$target.push(nqp::atpos($!reified, $i));
$i = $i + 1;
}
$!i = $n;
!$!todo.DEFINITE || $!todo.fully-reified ?? GLRIterationEnd !! Mu
}
method lazy() {
$!todo.DEFINITE ?? $!todo.lazy !! False
}
}.new(self)
}
method Slip() {
if $!todo.DEFINITE {
# We're not fully reified, and so have internal mutability still.
# The safe thing to do is to take an iterator of ourself and build
# the Slip out of that.
GLRSlip.from-iterator(self.iterator)
}
else {
# We're fully reified - and so immutable inside and out! Just make
# a Slip that shares our reified buffer.
my \result := GLRSlip.CREATE;
nqp::bindattr(result, GLRList, '$!reified', $!reified);
result
}
}
method Array() {
# We need to populate the Array slots with Scalar containers, so no
# shortcuts (and no special casing is likely worth it; iterators can
# batch up the work too).
GLRArray.from-iterator(self.iterator)
}
}
# The , operator produces a List.
proto infix:<GLR,>(|) is assoc('list') {*}
multi infix:<GLR,>() {
my \result = GLRList.CREATE;
nqp::bindattr(result, GLRList, '$!reified', BEGIN GLRIterationBuffer.CREATE);
result
}
multi infix:<GLR,>(|) {
my \result = GLRList.CREATE;
my \in = nqp::p6argvmarray();
my \reified = GLRIterationBuffer.CREATE;
nqp::bindattr(result, GLRList, '$!reified', reified);
while nqp::elems(in) {
if nqp::istype(nqp::atpos(in, 0), GLRSlip) {
# We saw a Slip, so we'll lazily deal with the rest of the things
# (as the Slip may expand to something lazy).
my \todo := GLRList::Reifier.CREATE;
nqp::bindattr(result, GLRList, '$!todo', todo);
nqp::bindattr(todo, GLRList::Reifier, '$!reified', reified);
nqp::bindattr(todo, GLRList::Reifier, '$!future', in);
nqp::bindattr(todo, GLRList::Reifier, '$!reification-target',
result.reification-target());
last;
}
else {
nqp::push(reified, nqp::shift(in));
Nil # don't Sink the thing above
}
}
result
}
# A Slip is a kind of List that is immediately incorporated into an iteration
# or another List. Other than that, it's a totally normal List.
my class GLRSlip is GLRList {
}
# The slip(...) function creates a Slip.
proto GLRslip(|) { * }
multi GLRslip() {
my \result = GLRSlip.CREATE;
nqp::bindattr(result, GLRList, '$!reified', BEGIN GLRIterationBuffer.CREATE);
result
}
multi GLRslip(|) {
my \result = GLRSlip.CREATE;
my \in = nqp::p6argvmarray();
my \reified = GLRIterationBuffer.CREATE;
nqp::bindattr(result, GLRList, '$!reified', reified);
while nqp::elems(in) {
if nqp::istype(nqp::atpos(in, 0), GLRSlip) {
# We saw a Slip, so we'll lazily deal with the rest of the things
# (as the Slip may expand to something lazy).
my \todo := GLRList::Reifier.CREATE;
nqp::bindattr(result, GLRList, '$!todo', todo);
nqp::bindattr(todo, GLRList::Reifier, '$!reified', reified);
nqp::bindattr(todo, GLRList::Reifier, '$!future', in);
nqp::bindattr(todo, GLRList::Reifier, '$!reification-target',
result.reification-target());
last;
}
else {
nqp::push(reified, nqp::shift(in));
Nil # don't Sink the thing above
}
}
result
}
# An Array is a List that ensures every item added to it is in a Scalar
# container. It also supports push, pop, shift, unshift, splice, BIND-POS,
# and so forth.
my class GLRArray is GLRList {
has Mu $!descriptor;
my class ArrayReificationTarget {
has $!target;
has $!descriptor;
method new(\target, Mu \descriptor) {
my \rt = self.CREATE;
nqp::bindattr(rt, self, '$!target', target);
nqp::bindattr(rt, self, '$!descriptor', descriptor);
rt
}
method push(\value) {
nqp::push($!target,
nqp::assign(nqp::p6scalarfromdesc($!descriptor), value));
}
}
method from-iterator(GLRArray:U: GLRIterator $iter) {
my \result := self.CREATE;
my \buffer := GLRIterationBuffer.CREATE;
my \todo := GLRList::Reifier.CREATE;
nqp::bindattr(result, GLRList, '$!reified', buffer);
nqp::bindattr(result, GLRList, '$!todo', todo);
nqp::bindattr(todo, GLRList::Reifier, '$!reified', buffer);
nqp::bindattr(todo, GLRList::Reifier, '$!current-iter', $iter);
nqp::bindattr(todo, GLRList::Reifier, '$!reification-target',
result.reification-target());
todo.reify-until-lazy();
result
}
proto method STORE(|) { * }
multi method STORE(GLRArray:D: GLRIterable:D \iterable) {
nqp::iscont(iterable)
?? self!STORE-ONE(iterable)
!! self!STORE-ITERABLE(iterable)
}
multi method STORE(GLRArray:D: \item) {
self!STORE-ONE(item)
}
method !STORE-ITERABLE(\iterable) {
my \new-storage = GLRIterationBuffer.CREATE;
my \iter = iterable.iterator;
my \target = ArrayReificationTarget.new(new-storage,
nqp::decont($!descriptor));
if iter.push-until-lazy(target) =:= GLRIterationEnd {
nqp::bindattr(self, GLRList, '$!todo', Mu);
}
else {
my \new-todo = GLRList::Reifier.CREATE;
nqp::bindattr(new-todo, GLRList::Reifier, '$!reified', new-storage);
nqp::bindattr(new-todo, GLRList::Reifier, '$!current-iter', iter);
nqp::bindattr(new-todo, GLRList::Reifier, '$!reification-target', target);
nqp::bindattr(self, GLRList, '$!todo', new-todo);
}
nqp::bindattr(self, GLRList, '$!reified', new-storage);
self
}
method !STORE-ONE(\item) {
my \new-storage = GLRIterationBuffer.CREATE;
nqp::push(new-storage, item);
nqp::bindattr(self, GLRList, '$!reified', new-storage);
nqp::bindattr(self, GLRList, '$!todo', Mu);
self
}
method reification-target() {
ArrayReificationTarget.new(
nqp::getattr(self, GLRList, '$!reified'),
nqp::decont($!descriptor))
}
}
# The [...] term creates an Array. BUT at the moment a custom circumfix
# ends up with a Parcel which means we will end up in a tangle with the
# existing list model in Rakudo. So we just do it as a normal function. So
# wherever you see GLRArrayCircumfix(...), imagine it's [...] instead.
proto GLRArrayCircumfix(|) { * }
multi GLRArrayCircumfix() {
my \result = GLRArray.CREATE;
nqp::bindattr(result, GLRList, '$!reified', GLRIterationBuffer.CREATE);
result
}
multi GLRArrayCircumfix(GLRIterable:D \iterable) {
GLRArray.from-iterator(iterable.iterator)
}
multi GLRArrayCircumfix(|) {
my \in = nqp::p6argvmarray();
my \result = GLRArray.CREATE;
my \reified = GLRIterationBuffer.CREATE;
nqp::bindattr(result, GLRList, '$!reified', reified);
while nqp::elems(in) {
if nqp::istype(nqp::atpos(in, 0), GLRSlip) {
# We saw a Slip, which may expand to something lazy. Put all that
# remains in the future, and let normal reification take care of
# it.
my \todo := GLRList::Reifier.CREATE;
nqp::bindattr(result, GLRList, '$!todo', todo);
nqp::bindattr(todo, GLRList::Reifier, '$!reified', reified);
nqp::bindattr(todo, GLRList::Reifier, '$!future', in);
nqp::bindattr(todo, GLRList::Reifier, '$!reification-target',
result.reification-target());
todo.reify-until-lazy();
last;
}
else {
# Just an item, no need to go through the whole maybe-lazy
# business.
nqp::push(reified,
nqp::assign(nqp::p6scalarfromdesc(nqp::null()), nqp::shift(in)));
}
}
result
}
# GLR implementation of gather/take.
sub GLRgather(&block) {
GLRSeq.new(class :: does GLRSlippyIterator {
has &!resumption;
has $!push-target;
has int $!wanted;
my constant PROMPT = Mu.CREATE;
method new(&block) {
my \iter = self.CREATE;
my int $wanted;
my $taken;
nqp::bindattr(iter, self, '&!resumption', {
nqp::handle(&block(),
'TAKE', nqp::stmts(
($taken := nqp::getpayload(nqp::exception())),
nqp::if(nqp::istype($taken, GLRSlip),
nqp::stmts(
iter!start-slip-wanted($taken),
($wanted = nqp::getattr_i(iter, self, '$!wanted'))),
nqp::stmts(
nqp::getattr(iter, self, '$!push-target').push($taken),
($wanted = nqp::bindattr_i(iter, self, '$!wanted',
nqp::sub_i(nqp::getattr_i(iter, self, '$!wanted'), 1))))),
nqp::if(nqp::iseq_i($wanted, 0),
nqp::continuationcontrol(0, PROMPT, -> Mu \c {
nqp::bindattr(iter, self, '&!resumption', c);
})),
nqp::resume(nqp::exception())
));
nqp::continuationcontrol(0, PROMPT, -> | {
nqp::bindattr(iter, self, '&!resumption', Callable)
});
});
iter
}
method pull-one() {
if $!slipping && (my \result = self.slip-one()) !=:= GLRIterationEnd {
result
}
else {
$!push-target := GLRIterationBuffer.CREATE
unless $!push-target.DEFINITE;
$!wanted = 1;
nqp::continuationreset(PROMPT, &!resumption);
&!resumption.DEFINITE
?? nqp::shift($!push-target)
!! GLRIterationEnd
}
}
method push-exactly($target, int $n) {
$!wanted = $n;
$!push-target := $target;
if $!slipping && self!slip-wanted() !=:= GLRIterationEnd {
$!push-target := Mu;
$n
}
else {
nqp::continuationreset(PROMPT, &!resumption);
$!push-target := Mu;
&!resumption.DEFINITE
?? $n - $!wanted
!! GLRIterationEnd
}
}
method !start-slip-wanted(\slip) {
my $value := self.start-slip(slip);
unless $value =:= GLRIterationEnd {
$!push-target.push($value);
my int $i = 1;
my int $n = $!wanted;
while $i < $n {
last if ($value := self.slip-one()) =:= GLRIterationEnd;
$!push-target.push($value);
$i = $i + 1;
}
$!wanted = $!wanted - $i;
}
}
method !slip-wanted() {
my int $i = 0;
my int $n = $!wanted;
my $value;
while $i < $n {
last if ($value := self.slip-one()) =:= GLRIterationEnd;
$!push-target.push($value);
$i = $i + 1;
}
$!wanted = $!wanted - $i;
$value =:= GLRIterationEnd
?? GLRIterationEnd
!! $n
}
}.new(&block))
}
# We add GLR implementations of various methods.
augment class Any {
proto method GLRmap(|) { * }
multi method GLRmap(&block) {
my $source = self.DEFINITE && nqp::istype(self, GLRIterable)
?? self.iterator
!! self.GLRlist.iterator;
sequential-map($source, &block);
}
multi method GLRmap(GLRHyperIterable:D: &block) {
# For now we only know how to parallelize when we've only one input
# value needed per block. For the rest, fall back to sequential.
if &block.count != 1 {
my $source = self.DEFINITE && nqp::istype(self, GLRIterable)
?? self.iterator
!! self.GLRlist.iterator;
sequential-map($source, &block)
}
else {
GLRHyperSeq.new(class :: does GLRHyperIterator {
has $!source;
has &!block;
method new(\source, &block) {
my \iter = self.CREATE;
nqp::bindattr(iter, self, '$!source', source);
nqp::bindattr(iter, self, '&!block', &block);
iter
}
method fill-buffer(GLRHyperWorkBuffer:D $work, int $items) {
$!source.fill-buffer($work, $items);
}
method process-buffer(GLRHyperWorkBuffer:D $work) {
unless $!source.process-buffer($work) =:= Mu {
$work.swap();
}
my \buffer-mapper = sequential-map($work.input-iterator, &!block);
buffer-mapper.iterator.push-all($work.output);
$work
}
method configuration() {
$!source.configuration
}
}.new(self.hyper-iterator, &block))
}
}
sub sequential-map(\source, &block) {
my role GLRMapIterCommon does GLRSlippyIterator {
has &!block;
has $!source;
method new(&block, $source) {
my $iter := self.CREATE;
nqp::bindattr($iter, self, '&!block', &block);
nqp::bindattr($iter, self, '$!source', $source);
$iter
}
method lazy() {
$!source.lazy
}
}
# We want map to be fast, so we go to some effort to build special
# case iterators that can ignore various interesting cases.
my $count = &block.count;
if $count == 1 {
# XXX We need a funkier iterator to care about phasers. Will
# put that on a different code-path to keep the commonest
# case fast.
# XXX Support labels
GLRSeq.new(class :: does GLRMapIterCommon {
method pull-one() {
my int $redo = 1;
my $value;
my $result;
if $!slipping && ($result := self.slip-one()) !=:= GLRIterationEnd {
$result
}
elsif ($value := $!source.pull-one()) =:= GLRIterationEnd {
$value
}
else {
nqp::while(
$redo,
nqp::stmts(
$redo = 0,
nqp::handle(
nqp::stmts(
($result := &!block($value)),
nqp::if(
nqp::istype($result, GLRSlip),
nqp::stmts(
($result := self.start-slip($result)),
nqp::if(
nqp::eqaddr($result, GLRIterationEnd),
nqp::stmts(
($value = $!source.pull-one()),
($redo = 1 unless nqp::eqaddr($value, GLRIterationEnd))
))
))
),
'NEXT', nqp::stmts(
($value := $!source.pull-one()),
nqp::eqaddr($value, GLRIterationEnd)
?? ($result := GLRIterationEnd)
!! ($redo = 1)),
'REDO', $redo = 1,
'LAST', ($result := GLRIterationEnd))),
:nohandler);
$result
}
}
}.new(&block, source));
}
else {
die "map with .count > 1 NYI";
}
}
}
# And here are GLR versions of various operators. (Note: xx was actually the
# first thing implemented, since it's about the simplest possible Iterator
# implementation to write. When we're further along, these may well get a
# good bit of simplification.)
multi infix:<GLRxx>(Mu \x, Whatever) {
GLRSeq.new(class :: does GLRIterator {
has $!value;
method new(\value) {
my $iter := self.CREATE;
nqp::bindattr($iter, self, '$!value', value);
$iter
}
method pull-one() { $!value }
method sink-all() {
warn "Useless use of xx with literal value in sink context";
}
method lazy() { True }
}.new(x))
}
multi infix:<GLRxx>(Mu \x, Int $i) {
GLRSeq.new(class :: does GLRIterator {
has $!value;
has int $!remaining;
method new(\value, $limit) {
my $iter := self.CREATE;
nqp::bindattr($iter, self, '$!value', value);
nqp::bindattr_i($iter, self, '$!remaining', $limit);
$iter
}
method pull-one() {
($!remaining = $!remaining - 1) >= 0
?? $!value
!! GLRIterationEnd
}
method push-exactly($target, int $n) {
my int $to-take = $n > $!remaining ?? $!remaining !! $n;
my int $i = 0;
my \value = $!value;
while $i < $to-take {
$target.push(value);
$i = $i + 1;
}
$!remaining = $!remaining - $to-take;
$!remaining == 0 ?? GLRIterationEnd !! $to-take
}
method push-at-least($target, int $n) {
self.push-exactly($target, $n < 256 ?? 256 !! $n)
}
method sink-all() {
warn "Useless use of xx with literal value in sink context";
}
}.new(x, $i))
}
proto GLRflat(|) { * }
multi GLRflat(GLRIterable:D \iterable) is rw {
nqp::iscont(iterable) ?? iterable !! iterable.flat
}
multi GLRflat(|c) {
infix:<GLR,>(|c).flat
}
# Re-compose classes after adding methods.
GLRSeq.^compose;
GLRHyperSeq.^compose;
GLRList.^compose;
GLRSlip.^compose;
GLRArray.^compose;
# A for loop at statement list level will do code-gen something like this,
# though it statically knows the .count thing so will only emit one of the
# two branches, and with some optimizer work we can likely often inline the
# block also.
sub GLRfor(\iterable, &block) {
if &block.count == 1 {
my $iter := iterable.iterator();
until (my \value = $iter.pull-one) =:= GLRIterationEnd {
block(value);
}
}
else {
die "GLRfor NYI when count > 0";
}
}
multi MAIN('test') {
use Test;
# A very basic case of iteration with xx.
{
my $simple-seq = &infix:<GLRxx>('beer', *); # Defeat auto-currying
ok $simple-seq ~~ GLRSeq, 'xx * returns a Seq';
my $iter = $simple-seq.iterator;
ok $iter ~~ GLRIterator, '.iterator returns something that does Iterator';
is $iter.pull-one, 'beer', 'lazy iterator produces value';
is $iter.pull-one, 'beer', 'lazy iterator produces another value';
}
# Iteration with xx and a limit.
{
my $finite-seq = 'beer' GLRxx 3;
ok $finite-seq ~~ GLRSeq, 'xx 3 returns a Seq';
my $iter = $finite-seq.iterator;
ok $iter ~~ GLRIterator, '.iterator returns something that does Iterator';
is $iter.pull-one, 'beer', 'iterator produces value (1)';
is $iter.pull-one, 'beer', 'iterator produces value (2)';
is $iter.pull-one, 'beer', 'iterator produces value (3)';
ok $iter.pull-one =:= GLRIterationEnd, 'iterator reached end';
}
# Basic for loop over xx.
{
my $i = 0;
GLRfor('beer' GLRxx 300, -> $beer {
$i++;
});
is $i, 300, "Iterating 'beer' xx 300 works";
}
# Map
{
my $test-seq = ('beer' GLRxx 3).GLRmap(*.uc);
ok $test-seq ~~ GLRSeq, 'map returns a Seq';
my $iter = $test-seq.iterator;
ok $iter ~~ GLRIterator, '.iterator returns something that does Iterator';
is $iter.pull-one, 'BEER', 'map iterator produces value (1)';
is $iter.pull-one, 'BEER', 'map iterator produces value (2)';
is $iter.pull-one, 'BEER', 'map iterator produces value (3)';
ok $iter.pull-one =:= GLRIterationEnd, 'iterator reached end';
}
# Map with last
{
my $test-seq = ('beer' GLRxx 3).GLRmap({ last if state $i++; .uc });
my $iter = $test-seq.iterator;
is $iter.pull-one, 'BEER', 'map iterator produces value before last used';
ok $iter.pull-one =:= GLRIterationEnd, 'iterator reached end when last used';
}
# Map with next
{
my $test-seq = ('beer' GLRxx 4).GLRmap({ next if state $i++ > 1; .uc });
my $iter = $test-seq.iterator;
is $iter.pull-one, 'BEER', 'map iterator produces value before next (1)';
is $iter.pull-one, 'BEER', 'map iterator produces value before next (2)';
ok $iter.pull-one =:= GLRIterationEnd, 'iterator reached end due to next skipping iterations';
}
# Map with redo
{
my $i = 0;
my $test-seq = ('beer' GLRxx 2).GLRmap({ redo if $i++ == 1; .uc });
my $iter = $test-seq.iterator;
is $iter.pull-one, 'BEER', 'map iterator with redo produces 2 values (1)';
is $iter.pull-one, 'BEER', 'map iterator with redo produces 2 values (2)';
ok $iter.pull-one =:= GLRIterationEnd, 'iterator reached end in loop with redo';
is $i, 3, 'Did 3 iterations thanks to redo';
}
# List basics.
{
my $x = (2 GLR, 4 GLR, 6);
ok $x ~~ GLRList, ', makes a List';
is $x.elems, 3, 'List.elems gives correct result';
is $x[0], 2, 'Can access list (1)';
is $x[1], 4, 'Can access list (2)';
is $x[2], 6, 'Can access list (3)';
{
my $n = 0;
GLRfor($x, -> $i {
$n += $i;
});
is $n, 12, 'Can iterate a List';
}
{
my $n = 0;
GLRfor($x.GLRmap(* + 2), -> $i {
$n += $i;
});
is $n, 18, 'Can iterate a mapped List';
}
}
# Slip basics (dealing with empty slips; easy).
{
my $x = (2 GLR, GLRslip() GLR, 6);
ok $x ~~ GLRList, ', with an empty slip in middle makes a List';
is $x.elems, 2, 'List.elems reflects the vanishing slip()';
is $x[0], 2, 'Can access list with slip in middle (1)';
is $x[1], 6, 'Can access list with slip in middle (2)';
}
{
my $x = (GLRslip() GLR, 4 GLR, 6);
ok $x ~~ GLRList, ', with an empty slip at start makes a List';
is $x.elems, 2, 'List.elems reflects the vanishing slip()';
is $x[0], 4, 'Can access list with slip at start (1)';
is $x[1], 6, 'Can access list with slip at start (2)';
}
{
my $x = (2 GLR, 4 GLR, GLRslip());
ok $x ~~ GLRList, ', with an empty slip at end makes a List';
is $x.elems, 2, 'List.elems reflects the vanishing slip()';
is $x[0], 2, 'Can access list with slip at end (1)';
is $x[1], 4, 'Can access list with slip at end (2)';
}
{
my $x = (2 GLR, GLRslip() GLR, 6);
is $x[0], 2, 'Can index list with slip in middle without calling .elems first (1)';
is $x[1], 6, 'Can index list with slip in middle without calling .elems first (2)';
}
{
my $x = (2 GLR, GLRslip() GLR, 4 GLR, GLRslip() GLR, 6);
my $n = 0;
GLRfor($x, -> $i {
$n += $i;
});
is $n, 12, 'Can iterate a List with empty slips in it';
}
# A Seq is not Positional and can not be indexed.
{
dies-ok { my @a := 1 GLRxx 100 }, 'Seq is not Positional';
throws-like { (1 GLRxx 100)[42] }, X::GLRSeq::NotIndexable, 'Indexing a Seq dies...';
throws-like { (1 GLRxx 100)[0] }, X::GLRSeq::NotIndexable, '...even with 0';
}
# Trying to iterate a Seq twice is an error.
{
my $a = 1 GLRxx 100;
lives-ok { $a.iterator }, 'Can get iterator for a Seq once...';
throws-like { $a.iterator }, X::GLRSeq::Consumed, '...and only once';
}
# A Seq can become a list, and the list it becomes is memoized.
{
my $seq = 1 GLRxx 100;
my $list;
lives-ok { $list := $seq.list }, 'Seq can be coerced into a .list';
isa-ok $list, GLRList, 'Actually got a List back';
ok $list =:= $seq.list, 'Seq gives back the same List every time';
throws-like { $seq.iterator }, X::GLRSeq::Consumed, '.list takes the iterator';
is $list[0], 1, 'Can index into List from Seq (1)';
is $list[5], 1, 'Can index into List from Seq (2)';
is $list.elems, 100, '.elems on the List gives the correct answer';
}
# Can iterate a List created from a Seq.
{
my @list := (5 GLRxx 100).list;
my $n = 0;
GLRfor(@list, -> $i {
$n += $i;
});
is $n, 500, 'Can iterate a List created from a Seq';
}
# Slip with values in it
{
my @xs := 1 GLR, GLRslip(2, 3) GLR, 4 GLR, GLRslip(5, 6);
is @xs.elems, 6, 'A slip in a , list automatically flattens (elems)';
}
{
my @xs := 1 GLR, GLRslip(2, 3) GLR, 4 GLR, GLRslip(5, 6);
is @xs[0], 1, 'A slip in a , list automatically flattens (index 0)';
is @xs[1], 2, 'A slip in a , list automatically flattens (index 1)';
is @xs[2], 3, 'A slip in a , list automatically flattens (index 2)';
is @xs[3], 4, 'A slip in a , list automatically flattens (index 3)';
is @xs[4], 5, 'A slip in a , list automatically flattens (index 4)';
is @xs[5], 6, 'A slip in a , list automatically flattens (index 5)';
}
{
my $n = 0;
GLRfor((1 GLR, GLRslip(2, 3) GLR, 4 GLR, GLRslip(5, 6)), -> $i {
$n += $i;
});
is $n, 21, 'Loop over list with slips in it works as expected';
}
# Can coerce a Seq into a Slip
{
my $seq = 2 GLRxx 5;
my $n = 0;
GLRfor((1 GLR, $seq.Slip GLR, 3), -> $i {
$n += $i;
});
is $n, 14, 'A Seq can be made into a Slip';
}
# Can coerce a List into a Slip also
{
my $list = 2 GLR, 4 GLR, 6;
my $n = 0;
GLRfor((1 GLR, $list.Slip GLR, 3), -> $i {
$n += $i;
});
is $n, 16, 'A List can be made into a Slip';
}
# map deals with Slip correctly
{
my @slippy := (1 GLR, 2 GLR, 3).GLRmap({ GLRslip($_, 3 * $_) }).list;
is @slippy[0], 1, 'map/Slip interaction produces correct elements (1)';
is @slippy[1], 3, 'map/Slip interaction produces correct elements (2)';
is @slippy[2], 2, 'map/Slip interaction produces correct elements (3)';
is @slippy[3], 6, 'map/Slip interaction produces correct elements (4)';
is @slippy[4], 3, 'map/Slip interaction produces correct elements (5)';
is @slippy[5], 9, 'map/Slip interaction produces correct elements (6)';
is @slippy.elems, 6, 'map/Slip interaction has correct .elems';
}
{
my @slippy := (1 GLR, 2 GLR, 3).GLRmap({ GLRslip($_, 3 * $_) }).list;
is @slippy.elems, 6, 'map/Slip interaction has correct .elems (.elems first)';
is @slippy[0], 1, 'map/Slip interaction produces correct elements (.elems first) (1)';
is @slippy[1], 3, 'map/Slip interaction produces correct elements (.elems first) (2)';
is @slippy[2], 2, 'map/Slip interaction produces correct elements (.elems first) (3)';
is @slippy[3], 6, 'map/Slip interaction produces correct elements (.elems first) (4)';
is @slippy[4], 3, 'map/Slip interaction produces correct elements (.elems first) (5)';
is @slippy[5], 9, 'map/Slip interaction produces correct elements (.elems first) (6)';
}
# [...] creates an Array, which can be indexed. No flattening, but same
# single-item rule as assignment (so [1 xx 10] has 10 elements).
{
isa-ok GLRArrayCircumfix(), GLRArray, '[] creates an Array';
isa-ok GLRArrayCircumfix(1, 2), GLRArray, '[1, 2] creates an Array';
is GLRArrayCircumfix(1, 2).elems, 2, '[1, 2].elems is 2';
is GLRArrayCircumfix(GLRArrayCircumfix(1, 2), GLRArrayCircumfix(3, 4)).elems,
2, '[[1, 2], [3, 4]].elems is 2';
}
{
my @a := GLRArrayCircumfix(1, 2);
is @a[0], 1, 'Can index an array (1)';
is @a[1], 2, 'Can index an array (2)';
lives-ok { @a[0] = 3; @a[1] = 4; }, 'Can assign to array elements';
is @a[0], 3, 'Array elements have new values after assignment (1)';
is @a[1], 4, 'Array elements have new values after assignment (2)';
}
{
my @a := GLRArrayCircumfix(1, GLRslip(2, 3), 4);
is @a[0], 1, 'Can index an array with a slip in it (1)';
is @a[1], 2, 'Can index an array with a slip in it (2)';
is @a[2], 3, 'Can index an array with a slip in it (3)';
is @a[3], 4, 'Can index an array with a slip in it (4)';
lives-ok { @a[0] = 6 }, 'Can assign to array element before slip';
is @a[0], 6, 'Array elements before slip has new value after assignment';
lives-ok { @a[1] = 7; @a[2] = 8 }, 'Can assign to array element getting value from slip';
is @a[1], 7, 'Array elements from slip have new values after assignment (1)';
is @a[2], 8, 'Array elements from slip have new values after assignment (2)';
lives-ok { @a[3] = 9 }, 'Can assign to array element after slip';
is @a[3], 9, 'Array elements after slip has new value after assignment';
}
{
# XXX auto-extension tests
}
# [...] evaluates eagerly...up until an lazy thing is encountered.
{
my @a := GLRArrayCircumfix(1, 2);
my @b := GLRArrayCircumfix(@a);
@a[0] = 3;
@a[1] = 4;
is @b[0], 1, 'Inside of [...] is eager on a single array';
is @b[1], 2, 'Inside of [...] is eager on a single array';
}
{
my @a := GLRArrayCircumfix(1, 2, infix:<GLRxx>(42, *).Slip);
pass "Array constructed with lazy slip didn't hang";
is @a[0], 1, 'Can index into array with lazy slip (1)';
is @a[1], 2, 'Can index into array with lazy slip (2)';
is @a[2], 42, 'Can index into array with lazy slip (3)';
is @a[3], 42, 'Can index into array with lazy slip (4)';
is @a[4], 42, 'Can index into array with lazy slip (5)';
}
# Can STORE into an Array, which also evaluates everything eagerly that is
# not lazy.
{
my @a := GLRArrayCircumfix();
@a = 1 GLR, 2 GLR, 3;
is @a.elems, 3, 'Assigned list of 3 things into array';
is @a[0], 1, 'Can access assigned array value (1)';
is @a[1], 2, 'Can access assigned array value (2)';
is @a[2], 3, 'Can access assigned array value (3)';
}
{
my @a := GLRArrayCircumfix();
my @b := GLRArrayCircumfix(1, 2);
@a = @b;
is @a.elems, 2, 'Assigned array of 2 things into array';
is @a[0], 1, 'Can access assigned array value (1)';
is @a[1], 2, 'Can access assigned array value (2)';
@b[0] = 3;
is @a[0], 1, 'Changing array that was asigned does not mutate one assinged to';
}
{
my @a := GLRArrayCircumfix();
@a = GLRArrayCircumfix(1, 2) GLR, GLRArrayCircumfix(3, 4);
is @a.elems, 2, 'Array assignment does not flatten beyond top level list';
is @a[0][0], 1, 'Nested array preserved as expected (1)';
is @a[0][1], 2, 'Nested array preserved as expected (2)';
is @a[1][0], 3, 'Nested array preserved as expected (3)';
is @a[1][1], 4, 'Nested array preserved as expected (4)';
}
{
my @a := GLRArrayCircumfix();
@a = 'beer' GLRxx 3;
is @a.elems, 3, 'Array assigned a Seq gets correct number of elements';
is @a[0], 'beer', 'Can access assigned array value (1)';
is @a[1], 'beer', 'Can access assigned array value (2)';
is @a[2], 'beer', 'Can access assigned array value (3)';
}
{
my @a := GLRArrayCircumfix();
@a = infix:<GLRxx>('whisky', *);
pass 'Assigning lazy sequence to an array did not hang';
is @a[0], 'whisky', 'Can access assigned array value (1)';
is @a[42], 'whisky', 'Can access assigned array value (2)';
}
{
my @a := GLRArrayCircumfix();
@a = 'ale' GLR, 'barley wine' GLR, infix:<GLRxx>('whisky', *).Slip;
pass 'Assigning list containing lazy slip does not hang';
is @a[0], 'ale', 'Can access assigned array value (1)';
is @a[1], 'barley wine', 'Can access assigned array value (2)';
is @a[2], 'whisky', 'Can access assigned array value (3)';
is @a[3], 'whisky', 'Can access assigned array value (4)';
is @a[99], 'whisky', 'Can access assigned array value (5)';
}
{
my @a := GLRArrayCircumfix();
@a = 'lonely';
is @a.elems, 1, 'Array assigned a single item has 1 element';
is @a[0], 'lonely', 'Can access assigned array value';
}
# Storing into an array actually replaces existing content
{
my @a := GLRArrayCircumfix(1, 2, 3);
is @a.elems, 3, 'Storing an item clears array (sanity check)';
@a = 'one thing';
is @a.elems, 1, 'Correct number of items after single item assignment';
is @a[0], 'one thing', 'Correct element after single item assignment';
nok @a[1].DEFINITE, 'Original elements gone (1)';
nok @a[1].DEFINITE, 'Original elements gone (2)';
}
{
my @a := GLRArrayCircumfix(1, 2, GLRslip(3, 4));
is @a.elems, 4, 'Storing a list clears array (sanity check)';
@a = 5 GLRxx 3;
is @a.elems, 3, 'Correct number of items after list assignment';
is @a[0], 5, 'Correct element after list assignment (1)';
is @a[1], 5, 'Correct element after list assignment (2)';
is @a[2], 5, 'Correct element after list assignment (3)';
nok @a[3].DEFINITE, 'Original elements gone';
}
# Storing into an array respects $ and .item
{
my @a := GLRArrayCircumfix();
@a = $(1 GLR, 2);
is @a.elems, 1, 'Array has one element after assigning list as item ($)';
isa-ok @a[0], GLRList, 'The one element is a list';
is @a[0][0], 1, 'Can access nested list (1)';
is @a[0][1], 2, 'Can access nested list (2)';
}
{
my @a := GLRArrayCircumfix();
@a = (1 GLR, 2).item;
is @a.elems, 1, 'Array has one element after assigning list as item (.item)';
isa-ok @a[0], GLRList, 'The one element is a list';
is @a[0][0], 1, 'Can access nested list (1)';
is @a[0][1], 2, 'Can access nested list (2)';
}
{
my @a := GLRArrayCircumfix();
@a = $(GLRArrayCircumfix(1, 2));
is @a.elems, 1, 'Array has one element after assigning array as item ($)';
isa-ok @a[0], GLRArray, 'The one element is an array';
is @a[0][0], 1, 'Can access nested array (1)';
is @a[0][1], 2, 'Can access nested array (2)';
}
{
my @a := GLRArrayCircumfix();
@a = GLRArrayCircumfix(1, 2).item;
is @a.elems, 1, 'Array has one element after assigning list as item (.item)';
isa-ok @a[0], GLRArray, 'The one element is an array';
is @a[0][0], 1, 'Can access nested array (1)';
is @a[0][1], 2, 'Can access nested array (2)';
}
{
my @a := GLRArrayCircumfix();
@a = $(1 GLRxx 5);
is @a.elems, 1, 'Array has one element after assigning Seq as item ($)';
isa-ok @a[0], GLRSeq, 'The one element is a Seq';
}
{
my @a := GLRArrayCircumfix();
@a = (1 GLRxx 5).item;
is @a.elems, 1, 'Array has one element after assigning Seq as item (.item)';
isa-ok @a[0], GLRSeq, 'The one element is a Seq';
}
# flat flattens all iterable non-item things recursively, and returns a
# Seq
{
my $flat-seq := GLRflat (1 GLR, 2) GLR, (3 GLR, 4);
isa-ok $flat-seq, GLRSeq, 'flat returns a Seq';
my @flattened := $flat-seq.list;
pass 'Can .list a Seq obtained from flat';
is @flattened.elems, 4, 'Flattened to 4 elements';
is @flattened[0], 1, 'Correct flattened element (1)';
is @flattened[1], 2, 'Correct flattened element (2)';
is @flattened[2], 3, 'Correct flattened element (3)';
is @flattened[3], 4, 'Correct flattened element (4)';
}
{
my $flat-seq := ((1 GLR, 2) GLR, (3 GLR, 4 GLR, 5)).flat;
isa-ok $flat-seq, GLRSeq, '.flat on a List returns a Seq';
my @flattened := $flat-seq.list;
pass 'Can .list a Seq obtained from .flat';
is @flattened.elems, 5, 'Flattened to 5 elements';
is @flattened[0], 1, 'Correct flattened element (1)';
is @flattened[1], 2, 'Correct flattened element (2)';
is @flattened[2], 3, 'Correct flattened element (3)';
is @flattened[3], 4, 'Correct flattened element (4)';
is @flattened[4], 5, 'Correct flattened element (5)';
}
{
my $flat-seq := ((1 GLR, (2 GLR, (3 GLR, 4 GLR, 5) GLR, 6))).flat;
my @flattened := $flat-seq.list;
is @flattened.elems, 6, 'Flattened nested lists to 6 elements';
is @flattened[0], 1, 'Correct flattened element (1)';
is @flattened[1], 2, 'Correct flattened element (2)';
is @flattened[2], 3, 'Correct flattened element (3)';
is @flattened[3], 4, 'Correct flattened element (4)';
is @flattened[4], 5, 'Correct flattened element (5)';
is @flattened[5], 6, 'Correct flattened element (6)';
}
{
my $flat-seq := ((1 GLR, (2 GLR, $(3 GLR, 4 GLR, 5) GLR, 6))).flat;
my @flattened := $flat-seq.list;
is @flattened.elems, 4, 'Flattened nested lists, one with $, to 4 elements';
is @flattened[0], 1, 'Correct flattened element (1)';
is @flattened[1], 2, 'Correct flattened element (2)';
is @flattened[3], 6, 'Correct flattened element (3)';
isa-ok @flattened[2], GLRList, 'Respected $ and did not flatten list with it';
is @flattened[2][0], 3, 'Can access unflattened item list (1)';
is @flattened[2][1], 4, 'Can access unflattened item list (2)';
is @flattened[2][2], 5, 'Can access unflattened item list (3)';
}
# my @a = flat ...;
{
my @a := GLRArrayCircumfix();
@a = GLRflat 1, 2, (3 GLRxx 3);
is @a.elems, 5, 'flat with array assignment gives correct element count';
is @a[0], 1, 'flattening array assignment got correct element (1)';
is @a[1], 2, 'flattening array assignment got correct element (2)';
is @a[2], 3, 'flattening array assignment got correct element (3)';
is @a[3], 3, 'flattening array assignment got correct element (4)';
is @a[4], 3, 'flattening array assignment got correct element (5)';
}
# Storing an Array into itself is unproblematic (including if we are
# assigning a map over it, etc.)
{
my @a := GLRArrayCircumfix(1, 2);
@a = @a;
is @a.elems, 2, 'Array assigned to itself retains elements (simple)';
is @a[0], 1, 'Array assigned to itself retains element values (simple) (1)';
is @a[1], 2, 'Array assigned to itself retains element values (simple) (2)';
}
{
my @a := GLRArrayCircumfix(infix:<GLRxx>(42, *));
@a = @a;
is @a[0], 42, 'Array assigned to itself retains element values (lazy seq) (1)';
is @a[1], 42, 'Array assigned to itself retains element values (lazy seq) (2)';
is @a[2], 42, 'Array assigned to itself retains element values (lazy seq) (3)';
}
{
my @a := GLRArrayCircumfix(infix:<GLRxx>(42, *));
is @a[1], 42, 'Lazy array OK before assignment to self';
@a = @a;
is @a[0], 42, 'Array assigned to itself retains element values (lazy seq part reified) (1)';
is @a[1], 42, 'Array assigned to itself retains element values (lazy seq part reified) (2)';
is @a[2], 42, 'Array assigned to itself retains element values (lazy seq part reified) (3)';
}
{
my @a := GLRArrayCircumfix(infix:<GLRxx>(42, *));
is @a[1], 42, 'Infinite array OK before assignment to mapped self';
@a = @a.GLRmap(* + 10);
is @a[0], 52, 'Array assigned to its mapped self gets correct element values (1)';
is @a[1], 52, 'Array assigned to its mapped self gets correct element values (2)';
is @a[2], 52, 'Array assigned to its mapped self gets correct element values (3)';
}
# Seq.Array, List.Array, Slip.Array
{
my $seq = 2 GLRxx 4;
my @arr := $seq.Array;
is @arr.elems, 4, 'Seq coerced to Array got correct number of elements';
is @arr[0], 2, 'Seq coerced to Array got correct element (1)';
is @arr[1], 2, 'Seq coerced to Array got correct element (2)';
is @arr[2], 2, 'Seq coerced to Array got correct element (3)';
is @arr[3], 2, 'Seq coerced to Array got correct element (4)';
lives-ok { @arr[1] = 5 }, 'Can assign to array element populated by coerced Seq';
is @arr[1], 5, 'Assigned value actually updated array';
}
{
my @list := 5 GLR, 6 GLR, 7;
my @arr := @list.Array;
is @arr.elems, 3, 'List coerced to Array got correct number of elements';
is @arr[0], 5, 'List coerced to Array got correct element (1)';
is @arr[1], 6, 'List coerced to Array got correct element (2)';
is @arr[2], 7, 'List coerced to Array got correct element (3)';
lives-ok { @arr[1] = 8 }, 'Can assign to array element populated by coerced List';
is @arr[1], 8, 'Assigned value actually updated array';
}
{
my @slip := GLRslip(6, 7, 8, 9);
my @arr := @slip.Array;
is @arr.elems, 4, 'Slip coerced to Array got correct number of elements';
is @arr[0], 6, 'Slip coerced to Array got correct element (1)';
is @arr[1], 7, 'Slip coerced to Array got correct element (2)';
is @arr[2], 8, 'Slip coerced to Array got correct element (3)';
is @arr[3], 9, 'Slip coerced to Array got correct element (4)';
lives-ok { @arr[1] = 1 }, 'Can assign to array element populated by coerced Slip';
is @arr[1], 1, 'Assigned value actually updated array';
}
# gather/take
{
my $gt := GLRgather({ take 'lunch'; take 'siesta'; });
isa-ok $gt, GLRSeq, 'gather block returns a Seq';
my $iter := $gt.iterator;
is $iter.pull-one, 'lunch', 'first take produced result';
is $iter.pull-one, 'siesta', 'second take produced result';
ok $iter.pull-one =:= GLRIterationEnd, 'reached end of iteration at block end';
}
{
my $state = 1;
my $gt := GLRgather({ loop { take $state } });
my $iter := $gt.iterator;
is $iter.pull-one, 1, 'first take in loop produces initial value of state';
$state++;
is $iter.pull-one, 2, 'second take in loop produces updated state';
}
{
my @arr := GLRArrayCircumfix();
lives-ok { @arr = GLRgather({ take 'tram'; take 'train'; take 'plane'; }) },
'Can assign a gather into an array';
is @arr.elems, 3, 'Array has correct number of elements';
is @arr[0], 'tram', 'Array got correct element (1)';
is @arr[1], 'train', 'Array got correct element (2)';
is @arr[2], 'plane', 'Array got correct element (3)';
}
{
my $gt := GLRgather({
take GLRslip('pale ale', 'ipa');
take 'brown ale';
take GLRslip('stout', 'barley wine');
});
my $iter := $gt.iterator;
is $iter.pull-one, 'pale ale', 'first result is first value from first slip';
is $iter.pull-one, 'ipa', 'second result is second value from first slip';
is $iter.pull-one, 'brown ale', 'third result is from take without slip';
is $iter.pull-one, 'stout', 'forth result is first value from second slip';
is $iter.pull-one, 'barley wine', 'fifth result is second value from second slip';
ok $iter.pull-one =:= GLRIterationEnd, 'reached end of iteration at block end';
}
{
my @arr := GLRArrayCircumfix();
@arr = GLRgather({
take GLRslip('pale ale', 'ipa');
take 'brown ale';
take GLRslip('stout', 'barley wine');
});
is @arr.elems, 5, 'Array assigned gather/take with Slips has correct number of elements';
is @arr[0], 'pale ale', 'Array assigned gather/take with slips has correct values (1)';
is @arr[1], 'ipa', 'Array assigned gather/take with slips has correct values (2)';
is @arr[2], 'brown ale', 'Array assigned gather/take with slips has correct values (3)';
is @arr[3], 'stout', 'Array assigned gather/take with slips has correct values (4)';
is @arr[4], 'barley wine', 'Array assigned gather/take with slips has correct values (5)';
}
{
my $gt := GLRgather({
take GLRslip('pale ale', 'ipa');
take 'brown ale';
take GLRslip('stout', 'barley wine');
});
my $iter := $gt.iterator;
is $iter.pull-one, 'pale ale', 'first result is first value from first slip';
my \buffer = GLRIterationBuffer.CREATE;
$iter.push-exactly(buffer, 2);
is buffer[0], 'ipa', 'push-exactly(2) got second value from slip as first item';
is buffer[1], 'brown ale', 'push-exactly(2) got second take value as second item';
is $iter.pull-one, 'stout', 'forth result is first value from second slip';
my \buffer2 = GLRIterationBuffer.CREATE;
ok $iter.push-exactly(buffer2, 2) =:= GLRIterationEnd,
'asking for 2 things when only one more to be taken returns GLRIterationEnd';
is buffer2[0], 'barley wine', 'the one available result was pushed';
}
# Lazy loops (loop/while/until/repeat while/repeat until). Note that there
# are no negated forms; the compiler can do that bit.
{
# Below is how we compile 'lazy loop { 42 }', an infinite loop
my $seq := GLRSeq.from-loop({ ++(state $i = 0) });
my @a := GLRArrayCircumfix();
@a = $seq;
pass 'loop { ... } with no condition is lazy; array assign OK';
is @a[0], 1, 'correct value from lazy loop (1)';
is @a[1], 2, 'correct value from lazy loop (2)';
is @a[42], 43, 'correct value from lazy loop (3)';
is @a[19], 20, 'correct value from lazy loop (4)';
}
{
my $seq := GLRSeq.from-loop({ GLRslip(++(state $i = 0), ++(state $j = 2)) });
my @a := GLRArrayCircumfix();
@a = $seq;
is @a[0], 1, 'correct value from lazy loop with slip (1)';
is @a[1], 3, 'correct value from lazy loop with slip (2)';
is @a[2], 2, 'correct value from lazy loop with slip (3)';
is @a[3], 4, 'correct value from lazy loop with slip (4)';
}
{
my $seq := GLRSeq.from-loop({
(state $a)++;
next if (state $)++ < 2;
redo if (state $)++ == 4;
last if (state $)++ == 6;
$a
});
my @a := GLRArrayCircumfix();
@a = $seq;
is @a.elems, 6, 'infinite loop with next/redo/last produced correct number of elements';
is @a[0], 3, 'correct value from lazy loop with next/redo/last (1)';
is @a[1], 4, 'correct value from lazy loop with next/redo/last (2)';
is @a[2], 5, 'correct value from lazy loop with next/redo/last (3)';
is @a[3], 6, 'correct value from lazy loop with next/redo/last (4)';
is @a[4], 8, 'correct value from lazy loop with next/redo/last (5)';
is @a[5], 9, 'correct value from lazy loop with next/redo/last (6)';
}
{
# This is how we compile 'lazy loop (my $i = 0; $i < 5; $i++) { $i * 2 }'
# (with the caveat that the second two args to from-loop will be Code,
# not Block, because they don't imply a lexical scope):
my $i = 0;
my $seq := GLRSeq.from-loop({ $i * 2 }, { $i < 5 }, { $i++ });
my @a := GLRArrayCircumfix();
@a = $seq;
is @a.elems, 5, 'Got correct number of elements from lazy C-style loop';
is @a[0], 0, 'correct value from lazy C-style loop (1)';
is @a[1], 2, 'correct value from lazy C-style loop (2)';
is @a[2], 4, 'correct value from lazy C-style loop (3)';
is @a[3], 6, 'correct value from lazy C-style loop (4)';
is @a[4], 8, 'correct value from lazy C-style loop (5)';
}
{
my $i = 0;
my $seq := GLRSeq.from-loop(
{
(state $a)++;
redo if $a == 2;
next if $a == 4;
last if $a == 6;
GLRslip($i, $a)
},
{ $i < 10 },
{ $i++ });
my @a := GLRArrayCircumfix();
@a = $seq;
is @a.elems, 6, 'Got correct number of elements from lazy C-style loop (control + slip)';
is @a[0], 0, 'correct value from lazy C-style loop (control + slip) (1)';
is @a[1], 1, 'correct value from lazy C-style loop (control + slip) (2)';
is @a[2], 1, 'correct value from lazy C-style loop (control + slip) (3)';
is @a[3], 3, 'correct value from lazy C-style loop (control + slip) (4)';
is @a[4], 3, 'correct value from lazy C-style loop (control + slip) (5)';
is @a[5], 5, 'correct value from lazy C-style loop (control + slip) (6)';
}
{
# This is how we compile 'lazy while $i < 5 { $i++ * 2 }' (with the
# caveat that the second args to from-loop will be Code, not Block,
# because it doesn't imply a lexical scope):
my $i = 0;
my $seq := GLRSeq.from-loop({ $i++ * 2 }, { $i < 5 });
my @a := GLRArrayCircumfix();
@a = $seq;
is @a.elems, 5, 'Got correct number of elements from lazy while loop';
is @a[0], 0, 'correct value from lazy while loop (1)';
is @a[1], 2, 'correct value from lazy while loop (2)';
is @a[2], 4, 'correct value from lazy while loop (3)';
is @a[3], 6, 'correct value from lazy while loop (4)';
is @a[4], 8, 'correct value from lazy while loop (5)';
}
{
my $i = 0;
my $seq := GLRSeq.from-loop(
{
(state $a)++;
redo if $a == 2;
next if $a == 4;
last if $a == 6;
GLRslip($i++, $a)
},
{ $i < 10 });
my @a := GLRArrayCircumfix();
@a = $seq;
is @a.elems, 6, 'Got correct number of elements from lazy while loop (control + slip)';
is @a[0], 0, 'correct value from lazy while loop (control + slip) (1)';
is @a[1], 1, 'correct value from lazy while loop (control + slip) (2)';
is @a[2], 1, 'correct value from lazy while loop (control + slip) (3)';
is @a[3], 3, 'correct value from lazy while loop (control + slip) (4)';
is @a[4], 2, 'correct value from lazy while loop (control + slip) (5)';
is @a[5], 5, 'correct value from lazy while loop (control + slip) (6)';
}
{
# A lazy repeat while just passes :repeat.
my $i = 42;
my $seq := GLRSeq.from-loop({ $i++ }, { $i < 0 }, :repeat);
my @a := GLRArrayCircumfix();
@a = $seq;
is @a.elems, 1, 'Got element from lazy repeat despite false start condition';
is @a[0], 42, 'correct value from lazy repeat';
}
# lazy
{
my @a := GLRArrayCircumfix();
my @b := GLRArrayCircumfix(1, 2);
isa-ok @b.lazy, GLRSeq, '.lazy returns a Seq';
@a = @b.lazy;
is @a[0], 1, 'Accessing array element 0 after assigning lazy reifies it';
@b[1] = 42;
is @a[1], 42, 'Later elements reified lazily so we see change in source array';
@b[1] = 69;
is @a[1], 42, 'But after reification, future changes to source are not seen';
}
{
my $i = 0;
my $seq := GLRSeq.from-loop({ $i++ * 2 }, { $i < 5 });
my @a := GLRArrayCircumfix();
@a = $seq.lazy;
is $i, 0, 'lazy assignment of while loop does no work until needed';
is @a[0], 0, 'correct value from lazily assigned while loop (1)';
is @a[2], 4, 'correct value from lazily assigned while loop (2)';
is $i, 3, 'only did the needed iterations of the lazy while loop';
}
# eager
{
my $i = 0;
my $seq := GLRSeq.from-loop({ last if $i == 5; $i++ });
my $eseq := $seq.eager;
my @a := GLRArrayCircumfix();
isa-ok $eseq, GLRSeq, '.eager returns a Seq';
@a = $eseq;
is $i, 5, 'eager assigment of lazy-by-default loop evaluates all of it';
}
# .eager.lazy interaction (this *is* weird, but should have a test to be
# clear on the semantics). The .lazy defers the obtaining of the iterator
# marked .eager, so up until we try to read something from the array we do
# no work. But as soon as we touch even the first array element, all the
# results of the loop marked .eager are produced and cached.
{
my $i = 0;
my $seq := GLRSeq.from-loop({ last if $i == 5; $i++ });
my $leseq := $seq.eager.lazy;
my @a := GLRArrayCircumfix();
is $i, 0, 'No work done before assigning .eager.lazy loop';
@a = $leseq;
is $i, 0, 'No work done after assigning .eager.lazy loop';
is @a[1], 1, 'Get correct value at element 1 of array';
is $i, 5, 'The one access triggered doing the whole loop';
is @a[0], 0, 'Correct values in array (1)';
is @a[2], 2, 'Correct values in array (2)';
is @a[3], 3, 'Correct values in array (3)';
is @a[4], 4, 'Correct values in array (4)';
is @a.elems, 5, 'Corret number of array elements';
}
# race
{
my $i = 0;
my $nums := GLRSeq.from-loop({ ++$i }, { $i < 20000 });
my @b := GLRArrayCircumfix();
@b = $nums.race().GLRmap({ next unless .is-prime; $_ });
is @b.elems, 2262, 'Found correct number of primes in parallel';
}
{
my $i = 0;
my $nums := GLRSeq.from-loop({ ++$i }, { $i < 500 });
my @b := GLRArrayCircumfix();
@b = $nums.race(:batch(50)).GLRmap({ next if $_ > 100; $_ });
is @b.elems, 100, 'Can handle empty batches';
}
{
my $i = 0;
my $nums := GLRSeq.from-loop({ ++$i }, { $i < 500 });
my @b := GLRArrayCircumfix();
@b = $nums.race(:batch(50), :degree(1))\
.GLRmap({ next if $_ > 200; $_ })\
.GLRmap({ next if $_ <= 150; $_ });
is @b.elems, 50, 'Chained hyper maps work';
}
# error communication and teardown
# hyper
done;
}
# Run with --optimize=3 to give the code the same set of optimizations it'll
# get when incorporated into CORE.setting.
multi MAIN('benchmark') {
contrast("for loop over 'beer' xx 100000",
before => { for 'beer' xx 100000 -> $beer { } },
after => { GLRfor('beer' GLRxx 100000, -> $beer { }) });
contrast("for loop over 'beer' xx 100000 with map",
before => { for ('beer' xx 100000).map(*.uc) -> $beer { } },
after => { GLRfor(('beer' GLRxx 100000).GLRmap(*.uc), -> $beer { }) });
contrast("for loop over ('beer' xx 100000) in a list (so must remember values)",
before => {
my @a := ('beer' xx 100000).list;
for @a -> $beer { }
die 'oops' unless @a.elems == 100000;
},
after => {
my @a := ('beer' GLRxx 100000).list;
GLRfor(@a, -> $beer { });
die 'oops' unless @a.elems == 100000;
});
contrast("for loop over ('beer' xx 100000) in a list, mapping it with *.uc",
before => {
my @a := ('beer' xx 100000).list;
for @a.map(*.uc) -> $beer { }
die 'oops' unless @a.elems == 100000;
},
after => {
my @a := ('beer' GLRxx 100000).list;
GLRfor(@a.GLRmap(*.uc), -> $beer { });
die 'oops' unless @a.elems == 100000;
});
contrast("for loop over ('beer' xx 100000).map(*.uc) in a list",
before => {
my @a := ('beer' xx 100000).map(*.uc).list;
for @a -> $beer { }
die 'oops' unless @a.elems == 100000;
},
after => {
my @a := ('beer' GLRxx 100000).GLRmap(*.uc).list;
GLRfor(@a, -> $beer { });
die 'oops' unless @a.elems == 100000;
});
contrast("gather/take assigned into an array",
before => {
my @a = gather {
my int $i = 0;
while $i < 100000 {
take 'x';
$i = $i + 1;
}
}
die 'oops' unless @a.elems == 100000;
},
after => {
my @a := GLRArrayCircumfix();
@a = GLRgather {
my int $i = 0;
while $i < 100000 {
take 'x';
$i = $i + 1;
}
}
die 'oops' unless @a.elems == 100000;
});
contrast("for loop over gather/take",
before => {
my \things = gather {
my int $i = 0;
while $i < 100000 {
take 'x';
$i = $i + 1;
}
}
for things -> $i { }
},
after => {
my \things = GLRgather {
my int $i = 0;
while $i < 100000 {
take 'x';
$i = $i + 1;
}
}
GLRfor(things, -> $i { });
});
sub contrast($title, :&before, :&after) {
# Run to allow most warm-up (for JIT, etc.)
before(); after();
# Measure runs before and after.
sub time(&task) {
my num $start = nqp::time_n();
task();
return nqp::time_n() - $start
}
my @before-times = time(&before) xx 3;
my @after-times = time(&after) xx 3;
# Show means.
sub mean(@times) { # insert bad pun involving Greenwich here...
@times R/ [+] @times
}
say "$title ==> was &mean(@before-times)s, now &mean(@after-times)s";
}
}
# Run with --profile to actually get profiling output
multi MAIN('profile') {
my $i = 0;
my $nums := GLRSeq.from-loop({ ++$i }, { $i < 100000 });
my @b := GLRArrayCircumfix();
# @b = $nums.GLRmap({ next unless .is-prime; $_ });
# @b = $nums.race(:degree(1)).GLRmap({ next unless .is-prime; $_ });
# @b = $nums.race(:degree(2)).GLRmap({ next unless .is-prime; $_ });
# @b = $nums.race(:degree(3)).GLRmap({ next unless .is-prime; $_ });
@b = $nums.race(:degree(4)).GLRmap({ next unless .is-prime; $_ });
die 'oops' unless @b.elems == 9592;
}
# Outstanding GLR issues
# * $foo[1..10] calls .list on the thing it'll index into, which creates an
# extra burden for those doing custom list types (see discussion with smls
# on 2015-08-01).