Implementing iterable classes with the Iterable and Iterator roles - iterator

Question

Suppose we have the following class composing the role Iterable:
class Word-Char does Iterable {
has #.words;
method !pairize($item) {
return $item => $item.chars;
}
method iterator( Word-Char:D: ) {
#!words.map({self!pairize($_)}).rotor(1).iterator
}
}
I could assign the object to a Positional variable during object construction and iterate over that variable:
my #words = Word-Char.new: words => <the sky is blue>;
.say for #words;
OUTPUT:
(the => 3)
(sky => 3)
(is => 2)
(blue => 4)
However, what if the object is being passed around? How do I make sure it's still iterable?:
my $w = Word-Char.new: words => <the sky is blue>;
sub f( $w ) {
.say for $w
}
f($w);
OUTPUT:
Word-Char.new(words => ["the", "sky", "is", "blue"])
Goal:
By using Iterable, Iterator or both, I would like, if possible, to be able to iterate over an instance object of the class implementing these roles anywhere. Right now I know that by assigning the instance object during the object construction to a Positional variable, I can get the iterable items the class provide but this isn't what I want. Instead I want to pass the object itself and iterate over it wherever/whenever I deem it necessary.

Answer 1

When dealing with scalar values that do the iterator role, the simplest way to accomplish what you are attempting is to tell perl6 your scalar value is iterable. You can do that by postfixing it with []. Your example then looks like this:
my $w = Word-Char.new: words => <the sky is blue>;
.say for $w[]
Another thing....
Your iteration code has a bug in that it doesn't reset itself before returning IterationEnd. A quick fix looks like the following:
class Word-Char does Iterable does Iterator {
has #.words;
has Int $!index = 0;
method !pairize($item) {
return $item => $item.chars;
}
method iterator() {self}
method pull-one( --> Mu ) {
if $!index < #!words.elems {
my $item = #!words[$!index];
$!index += 1;
return self!pairize($item);
}
else {
$!index = 0;
return IterationEnd;
}
}
}
However, this means that you have to keep all of the iteration logic (and its attributes) with the main class. Another, way would be to use an anonymous class, instead of using self:
class Word-Char does Iterable {
has #.words;
method !pairize($item) {
return $item => $item.chars;
}
method iterator() {
my #words = #!words;
class :: does Iterator {
has $.index is rw = 0;
method pull-one {
return IterationEnd if $!index >= #words.elems;
#words[$!index++];
}
}.new;
}
}
The advantage of the above is that you can keep your iteration logic cleaner and isolated from the rest of the object. You also don't need to worry about resetting state.

Answer 2

OK, not clear what you want to achieve here, but let's give it a try.
The main problem in the second example is that you have changed a Positional (with w) with an Scalar. Simply use again #w and you're set
my #w = Word-Char.new: words => <the sky is blue>;
sub f( #w ) {
.say for #w
}
f(#w);
This would work exactly in the same way, because #w is still Positional, and thus Iterable. When you call $w, the Scalar just returns its only item, which is the object, and that's what is printed. If you want to use the scalar sigil on this object and also iterate over it, you need to make it an Iterator also.

Answer 3

On #perl6, jnthn provided several approaches. Some of them don't behave as I expect them to though.
I updated the class as follow as per
jjmerelo's suggestion:
class Word-Char does Iterable does Iterator {
has #.words;
has Int $!index = 0;
method !pairize($item) {
return $item => $item.chars;
}
method iterator() {self}
method pull-one( --> Mu ) {
if $!index < #!words.elems {
my $item = #!words[$!index];
$!index += 1;
return self!pairize($item);
}
else {
return IterationEnd;
}
}
}
1. Bind the object to a Positional
# Binding to a Positional
my #w01 := Word-Char.new: words => <the sky is blue>;
This produces the following error:
Type check failed in binding; expected Positional but got Word-Char...
2. Use | at the point of iteration
my $w = Word-Char.new: words => <the sky is blue>;
for |$w {
.say
}
=begin comment
Word-Char.new(words => ["the", "sky", "is", "blue"])
=end comment
| doesn't have an affect on the object which seems to hold on to its scalar nature and thus for doesn't iterate over it.
3. Use a sigilless variable
my \w = Word-Char.new: words => <the sky is blue>;
for w {
.say
}
=begin comment
he => 3
sky => 3
is => 2
blue => 4
=end comment
So far this is the cleanest approach which does what I expect.
4. Rather than making the class iterable, add a method that returns something iterable.
In fact, this one was my first approach but I didn't find it to be too p6y. In any case, for this to work we need to update our class and add a method that returns something iterable. The method's name of my choice is LOOP-OVER if only to make it stand out from everything else.
class Word-Char {
has #.words;
method !pairize($item) {
return $item => $item.chars;
}
method LOOP-OVER {
gather for #!words -> $word {
take self!pairize($word)
}
}
}
my $w = Word-Char.new: words => <the sky is blue>;
for $w.LOOP-OVER {
.say
}
=begin comment
he => 3
sky => 3
is => 2
blue => 4
=end comment
But what if we rely on several classes behaving iteratively? How do we make sure they implement the same method? The most straightforward way
is to compose a role (e.g., Iterationable) which implements a stub LOOP-OVER method, in this instance.
role Iterationable {
method LOOP-OVER { ... }
}
class Word-Char does Iterationable {
has #.words;
method !pairize($item) {
return $item => $item.chars;
}
method LOOP-OVER {
gather for #!words -> $word {
take self!pairize($word)
}
}
}
class Names does Iterationable {
has #.names;
method LOOP-OVER {
gather for #!names -> $name {
take $name.split(/\s+/)».tc.join(' ')
}
}
}
class NotIterable {
has #.items
}
my #objs =
Word-Char.new(words => <the sky is blue>),
Names.new(names => ['Jose arat', 'elva delorean', 'alphonse romer']),
NotIterable.new(items => [5, 'five', 'cinco', 'cinq'])
;
for #objs -> $obj {
if $obj.can('LOOP-OVER') {
put "» From {$obj.^name}: ";
for $obj.LOOP-OVER {
.say
}
}
else {
put "» From {$obj.^name}: Cannot iterate over it";
}
}
=begin comment
» From Word-Char:
the => 3
sky => 3
is => 2
blue => 4
» From Names:
Jose Arat
Elva Delorean
Alphonse Romer
» From NotIterable: Cannot iterate over it
=end comment
As stated by jnthn, what approach to use (from the working ones at least) will hardly depend on the problem at hand.

Answer 4

Another (somewhat messy) solution is:
class Word-Char does Iterator {
has #.words;
has Int $.index is rw = 0;
method pull-one() {
LEAVE { $!index++ }
return $!index < #!words.elems
?? (#!words[$!index] => #!words[$!index].chars)
!! IterationEnd;
}
}
my $w = Word-Char.new: words => <the sky is blue>;
my $seq = Seq.new($w).cache;
sub f( $w ) {
.say for $w[]
}
f($seq);
$w.index = 0;
f($seq);