I think the closest things we've got to pattern matching come from a
combination of multiple dispatch, where clauses and signature
unpacking. I don't know much about the latter, but a where clause can
discriminate multiple dispatch variants based on parameter values
rather than just the type, so you can say:

multi doSomething(@a where { .elems == 0 }) {
  # empty arrays only

multi doSomething(@a where { .elems >= 3 && .[2] == 4 }) {
  # arrays with a third element numerically equal to 4

multi doSomething(@a) {
  # anything else

Which is pretty powerful, really.

> This is a contrived example of what I'm referring to:
> sub traverse([Leaf $a]) {
>  # do something
> }
> sub traverse([Tree $left, Tree $right]) {
>  traverse($left);
>  traverse($right);
> }
> my $t = Tree(...);
> traverse($t);

You could do most of this with multidispatch and where clauses. It
doesn't quite work because of the unpacking which pattern matching
does, and also because Perl 6 data structures don't get built in the
same way that Haskell ones do, and you've used a Haskell-like syntax
for Leaf and Tree and so forth.

Now, while it might be nice to say let me write a signature which
accepts a Tree object which has a left and right subtree, and binds
them to $left and $right respectively, arguably a where clause can
check that the subtrees exist, and your tree class should have good
accessors for the subtrees which make unpacking them a little
pointless. This is where Perl 6 is not the same as functional
languages, since it's got an imperative OO element as well.

multi traverse(Tree $t where { all(.left, .right).defined }) { ... }


Reply via email to