I am a lambdacamel and therefore I like to adapt concepts and techniques from functional programming, and in particular from the Haskell language, to Raku. One of the techniques that I use a lot is generic traversals, also known as “Scrap Your Boilerplate” after the title of the paper by Simon Peyton Jones and Ralf Lämmel that introduced this approach. In their words:
Many programs traverse data structures built from rich mutuallyrecursive data types. Such programs often have a great deal of “boilerplate” code that simply walks the structure, hiding a small amount of “real” code that constitutes the reason for the traversal. ”Generic programming” is the umbrella term to describe a wide variety of programming technology directed at this problem.
So to save you having to write your own custom traversal, this approach gives you generic functions that do traversals on arbitrary data strucures. In this article, I will explain how you can easily implement such generics in Raku for arbitrary rolebased datastructures. There is no Haskell in this article.
Roles as datatypes by example
I implemented of these generics for use with rolebased datatypes. Raku’s parameterised roles make creating complex datastructures very easy. I use the roles purely as datatypes, so they have no associated methods.
For example, here is an example code snippet in a little language that I use in my research.
map (f1 . f2) (map g (zipt (v1,map h v2)))
The primitives are map
, .
(function composition), zipt
and the tuple (...)
, and the names of functions and vectord. The datatype for the abstract syntax of this little language is called Expr
and looks as follows:
# Any expression in the language
role Expr {}
# map f v
role MapV[Expr \f_,Expr \v_] does Expr {
has Expr $.f = f_;
has Expr $.v = v_;
}
# function composition f . g
role Comp[Expr \f_, Expr \g_] does Expr {
has Expr $.f = f_;
has Expr $.g = g_;
}
# zipt t turns a tuple of vectors into a vector of tuples
role ZipT[Expr \t_] does Expr {
has Expr $.t = t_
}
# tuples are just arrays of Expr
role Tuple[Array[Expr] \e_] does Expr {
has Array[Expr] $.e = e_
}
# names of functions and vectors are just string constants
role Name[Str \n_] does Expr {
has Str $.n = n_
}
The Expr
role is the toplevel datatype. It is empty because it is implemented entirely in terms of the other roles, which thanks to the does
are all of type Expr
. And most of the roles have attributes that are also of type Expr
. So we have a recursive datatype, a tree with the Name
node as leaves.
We can now write the abstract syntax tree (AST) of the example code using this Expr
datatype:
my \ast = MapV[
Comp[
Name['f1'].new,
Name['f2'].new
].new,
MapV[
Name['g'].new,
ZipT[
Tuple[
Array[Expr].new(
Name['v1'].new,
MapV[
Name['h'].new,
Name['v2'].new
].new
)
].new
].new
].new
].new;
The typical way to work with such a datastructure is using a given/when
:
sub worker(Expr \expr) {
given expr {
when MapV {...}
when Comp {...}
when ZipT {...}
...
}
}
Alternatively, you can use a multi sub:
multi sub worker(Mapv \expr) {...}
multi sub worker(Comp \expr) {...}
multi sub worker(ZipT \expr) {...}
...
In both cases, we use the roles as the types to match against for the actions we want to take.
(For more details about algebraic datatypes see my earlier article Roles as Algebraic Data Types in Raku.)
Generics
If I want to traverse the AST above, what I would normally do is write a worker as above, where for every node except the leaf nodes, I would call the worker recursively, for example:
sub worker(Expr \expr) {
given expr {
when MapV {
my \f_ = worker(expr.f);
my \v_ = worker(expr.v);
...
}
...
}
}
But wouldn’t it be nice if I did not have to write that code at all? Enter generics.
I base my naming and function arguments on that of the Haskell library Data.Generics
. It provides many schemes for traversals, but the most important ones are everything
and everywhere
.

everything
is a function which takes a datastructure, a matching function, an accumulator and an update function for the accumulator. The matching function defines what you are looking for in the datastructure. The result is put into the accumulator using the update function.sub everything( Any \datastructure, Any \accumulator, &joiner, &matcher > Any){...}

everywhere
is a function which takes a datastructure and a modifier function. The modifier function defines which parts of the datastructure you want to modify. The result of the traversal is a modified version of the datastructure.sub everywhere( Any \datastructure, &modifier > Any){...}
The most common case for the accumulator is to use a list, so the updated function appends lists to the accumulator:
sub append(\acc, \res) {
return (acc, res);
}
As an example of a matching function, let’s for example find all the function and vector names in our AST above:
sub matcher(\expr) {
given expr {
when Name {
return [expr.n]
}
}
return []
}
So if we find a Name
node, we return its n
attribute as a singleelement list; otherwise we return an empty list.
my \names = everything(ast,[],&append,&matcher);
# => returns (f1 f2 g h v1 v2)
Or let’s say we want to change the names in this AST:
sub modifier(\t) {
given t {
when Name {
Name[t.n~'_updated'].new
}
default {t}
}
}
my \ast_ = everywhere(ast,&modifier);
# => returns the AST with all names appended with "_updated"
Implementing Generics
So how do we implement these magic everything
and everywhere
functions? The problem to solve is that we want to iterate through the attributes of every role without having to name it. The solution for this is to use Raku’s Metaobject protocol (MOP) for introspection. In practice, we use the Rakudospecific Metamodel
. We need only three methods: attribute
, get_value
and set_value
. With these, we can iterate through the attributes and visit them recursively.
Attributes can be $
, @
or %
(and even &
but I will skip this). What this means in terms of Raku’s type system is that they can be scalar, Iterable or Associative, and we need to distinguish these cases. With that, we can write everything
as follows:
sub everything (\t, \acc,&update,&match) {
# Arguments a immutable, so copy to $acc_
my $acc_ = acc;
# Match and update $acc_
$acc_ =update($acc_,match(t));
# Test the attribute type
if t ~~ Associative {
# Iterate over the values
for t.values > \t_elt {
$acc_ = everything(t_elt,$acc_,&update,&match)
}
return $acc_;
}
elsif t ~~ Iterable {
# Iterate
for t > \t_elt {
$acc_ = everything(t_elt,$acc_,&update,&match)
}
return $acc_;
}
else {
# Go through all attributes
for t.^attributes > \attr {
# Not everyting return by ^attributes
# is of type Attribute
if attr ~~ Attribute {
# Get the attribute value
my \expr = attr.get_value(t);
if not expr ~~ Any { # for ContainerDescriptor::Untyped
return $acc_;
}
# Descend into this expression
$acc_ = everything(expr,$acc_,&update, &match);
}
}
}
return $acc_
}
So what we do here essentially is:
 for
@
and%
we iterate through the values  iterate through the attributes using
^attributes
 for each attribute, get the expression using
get_value
 call
everything
on that expression  the first thing
everything
does is update the accumulator
everywhere
is similar:
sub everywhere (\t_,&modifier) {
# Modify the node
my \t = modifier(t_);
# Test the type for Iterable or Associative
if t ~~ Associative {
# Build the updated map
my %t_;
for t.keys > \t_k {
my \t_v = t{t_k};
%t_{t_k} = everywhere (t_v,&modifier);
}
return %t_;
}
elsif t ~~ Iterable {
# Build the updated list
my @t_=[];
for t > \t_elt {
@t_.push( everywhere(t_elt,&modifier) );
}
return @t_;
}
else {
# t is immutable so copyto $t_
my $t_ = t;
for t.^attributes > \attr {
if attr ~~ Attribute {
my \expr = attr.get_value(t);
if not expr ~~ Any { # for ContainerDescriptor::Untyped
return $t_;
}
my \expr_ = everywhere(expr,&modifier);
attr.set_value($t_,expr_);
}
}
return $t_;
}
return t;
}
So what we do here essentially is:
 for
@
and%
we iterate through the values  iterate through the attributes using
^attributes
 for each attribute, get the expression using
get_value
 call
everywhere
on that expression  update the attribute using
set_value
This works without roles too
First of all, the above works for classes too, because the Metamodel methods are not specific to roles. Furthermore, because we test for @
and %
, the generics above work just fine for data structures without roles, built from hashes and arrays:
my \lst = [1,[2,3,4,[5,6,7]],[8,9,[10,11,[12]]]];
sub matcher (\expr) {
given expr {
when List {
if expr[0] % 2 == 0 {
return [expr]
}
}
}
return []
}
my \res = everything(lst,[],&append,matcher);
say res;
# ([2 3 4 [5 6 7]] [8 9 [10 11 [12]]] [10 11 [12]] [12])
Or for hashes:
my %hsh =
a => {
b => {
c => 1,
a => {
b =>1,c=>2
}
},
c => {
a =>3
}
},
b => 4,
c => {d=>5,e=>6}
;
sub hmatcher (\expr) {
given (expr) {
when Map {
my $acc=[];
for expr.keys > \k {
if k eq 'a' {
$acc.push(expr{k})
}
}
return $acc;
}
}
return []
}
my \hres = everything(%hsh,[],&append,&hmatcher);
say hres;
# ({b => {a => {b => 1, c => 2}, c => 1}, c => {a => 3}} {b => 1, c => 2} 3)
Conclusion
Generic datastructure traversals are a great way to reduce boilerplate code and focus on the actual purpose of the traversals. And now you can have them in Raku too. I have shown the implementation for the two main schemes everything
and everywhere
and shown that they work for role based datastructures as well as traditional hash or arraybased datastructures.