Why is Raku reporting "two terms in a row" when I define a new operator? - operators

Question

I have an application where I wish to create a new operator to work on one of my custom classes. The definition (sub infix:<α>) compiles without complaint, but when I attempt to use the operator, Raku reports two terms in a row.
I guess there is something weird I'm doing in my module file. Sometimes problems are cured by exiting and re-initializing interactive Raku - but it is perhaps so obvious I can't see it.
**UPDATE
**
Embedding these statements within the module works as expected - this leads me to suspect that I'm doing something wrong in the module, possibly related to exports (the "two terms in a row" message implies the compiler doesn't recognize the customer operators outside the module file).
There's nothing secret or magical about my module:
########################################################################
### Convert goofy old Perl5 module to Raku
########################################################################
unit module Format;
use List::Util;
=begin comment
Class supporting a bidrectional map lookup. Given a hash containing
keys and aliases (e.g., key=>alias) two lookaside hashes are created
to convert between the two values.
=end comment
class Bidirectional is export {
has Any %!aliasMap = ();
has Any %!keyMap = ();
has Any %.map = ();
has Bool $!initialized = False;
=begin comment
Do nothing if this object has already been initialized, otherwise loop
through the supplied map and populate the alias and key maps.
=end comment
method !initialize () {
if !($!initialized) {
for self.map.kv -> $key, $alias {
%!aliasMap{$alias} = $key;
%!keyMap{$key} = $alias;
}
$!initialized = True;
say %!aliasMap;
say %!keyMap;
}
return self;
}
=begin comment
Convert from an alias to a key value
=end comment
method aliasToKey (Str $alias) {
self!initialize();
return %!aliasMap{$alias} || $alias;
}
=begin comment
Convert from a key to an alias value.
=end comment
method keyToAlias (Str $key) {
self!initialize();
return %!keyMap{$key} || $key;
}
=begin comment
Return either a key from an alias (first priority) or an alias from a key
(second priority).
=end comment
method either (Str $candidate) {
return self.aliasToKey($candidate) || self.keyToAlias($candidate);
}
}
sub infix:<α> (Format::Bidirectional $name, Str $value) is export {
return $name.keyToAlias($value);
}
sub infix:<κ> (Format::Bidirectional $name, Str $value) is export {
return $name.aliasToKey($value);
}
sub infix:<∨> (Format::Bidirectional $name, Str $value) is export {
return $name.either($value);
}
class Formatter {
has Str $.span is rw;
has Str $.border is rw;
has Str $.top is rw;
has Str $.reading_order is rw;
has Bool $.locked is rw;
has Str $.left is rw;
has Str $.right_color is rw;
has Str $.font_outline is rw;
has Str $.rotation is rw;
has Str $.shrink is rw;
has Str $.text_wrap is rw;
has Str $.right is rw;
has Str $.bottom is rw;
has Str $.indent is rw;
has Str $.left_color is rw;
has Str $.font_encoding is rw;
has Str $.color is rw;
has Str $.font_script is rw;
has Str $.fg_color is rw;
has Str $.font_strikeout is rw;
has Str $.bg_color is rw;
has Bool $.hidden is rw;
has Str $.align is rw;
has Str $.valign is rw;
has Str $.font_charset is rw;
has Str $.num_format is rw;
has Str $.top_color is rw;
has Bool $.italic is rw;
has Str $.font_family is rw;
has Bool $.bold is rw;
has Str $.bottom_color is rw;
has Str $.size is rw;
has Str $.pattern is rw;
has Str $.font is rw;
has Str $.font_shadow is rw;
has Str $.text_justlast is rw;
has Str $.underline is rw;
=begin comment
Map any properties with aliases. The property name and the alis name
will return the same results with Bidirectional objects.
=end comment
has Bidirectional $!map = Bidirectional.new(:map(
font_encoding => <_font_encoding>;
));
=begin comment
Convert an attribute name such as is used by get_value and set_value
to a property name which keys the .object() hash.
=end comment
method !a2p (Str $candidate) {
return $candidate.substr(2) if $candidate.match(/^\$\W/);
}
=begin comment
Convert the property name to an attribute name that can be used with
get_value and set_value.
=end comment
method !p2a (Str $candidate, Str $prefix='$!') {
return $prefix ~ $candidate if !$candidate.match(/^\$\W/);
}
=begin comment
Given an attribute key, return its attribute alias.
=end comment
method alias (Str $candidate) {
return $!map.keyToAlias($candidate);
}
=begin comment
Given an attribute alias, return its attribute key.
=end comment
method key (Str $candidate) {
return $!map.aliasToKey($candidate);
}
=begin comment
Set the attribute values of the object. Any name supplied in the argument
must be a valid attribute and it must not be a private attribute.
=end comment
method set (%object) {
my #attributes = self.^attributes(:local);
for %object.kv -> $key, $value {
my $attribute = first { $_ ~~ /$key/ }, #attributes;
if $attribute && ($attribute.has_accessor) {
$attribute.set_value(self, $value);
}
}
}
=begin comment
Coverts a Format::Formatter object to a Hash containing only the public
attributes and values.
=end comment
method object (Format::Formatter:D $override?) {
my %answer = ();
my $victim = $override ?? $override !! self;
for $victim.^attributes(:local) -> $attribute {
next if !$attribute.has_accessor;
my $candidate = $attribute.get_value($victim);
my $property = self!a2p($attribute.name);
if $candidate {
%answer{$property} = $candidate;
}
}
return %answer;
}
=begin comment
Determine whether two Format::Formatter objects are the same. This comparison
is carried out against the .object() form of both objects, which excludes any
private attributes. If the two .object() values have the same keys and values,
True is returned; else False
=end comment
method same (Any $other) {
if $other.WHAT ∉ (Hash, Format::Formatter) {
X::TypeCheck.new(operation=>'Format::Formatter comparison',
got=>$other.WHAT, expected=>Format::Formatter).throw;
}
my $left = self.object;
my $right = $other ~~ Format::Formatter ?? $other.object !! $other;
my $answer = $left eqv $right;
return $answer;
}
}
=begin comment
Override === operator for Format::Formatter equivalence - this may have
unforseen results, and the .same() method should probably be used instead
The first form covers the case of $format1===$format2 -- both arguments
are converted to hashes using .object()
The second form covers the case of $format1==$hash2 -- the first argument
is converted to a hash using .object()
=end comment
multi sub infix:<===> (Format::Formatter:D $left, Format::Formatter:D $right) is export {
return $left.object eqv $right.object;
}
multi sub infix:<===> (Format::Formatter:D $left, Hash:D $right) is export {
return $left.object eqv $right;
}
I tried the following. I expect the custom operators to perform the operations I specify.
[2] > my $m = Format::Bidirectional.new(map=>{a => <_a>})
Format::Bidirectional.new(map => (my Any % = :a("_a")))
[3] > say $m.WHAT
(Bidirectional)
[3] > $m ~~ Format::Bidirectional
True
[4] > my $t = 'test'
test
[5] > $t ~~ Str
True
[6] > sub infix:<α> (Format::Bidirectional $name, Str $value) {
return $name.keyToAlias($value);
}
&infix:<α>
[7] > $m α $t
===SORRY!=== Error while compiling:
Two terms in a row
------> $m⏏ α $t
expecting any of:
infix
infix stopper
statement end
statement modifier
statement modifier loop
But using an example from the Raku documentation works:
sub infix:<:=:>( $a is rw, $b is rw ) {
($a, $b) = ($b, $a)
}
my ($num, $letter) = ('A', 3);
say $num; # OUTPUT: «A␤»
say $letter; # OUTPUT: «3␤»
# Swap two variables' values
$num :=: $letter;
say $num; # OUTPUT: «3␤»
say $letter; # OUTPUT: «A␤»
A
3
3
A
Trying to use the example substituting only my operations (though 'is rw' is spurious here), I get "cannot make assignment" (please note I exited the interaction shell and re-entered before attempting this):
[3] > sub infix:<:==:>($a is rw, $b is rw) { return $a.keyToAlias($b) }
&infix:<:==:>
[4] > $m :==: 'a'
===SORRY!=== Error while compiling:
Cannot make assignment out of := because list assignment operators are too fiddly
------> $m :==⏏: 'a'
I thought perhaps it was the unicode character I used (small alpha) or the class, so:
[0] > use lib "."
Nil
[1] > use Format
Nil
[2] > my $aa = {a=>'_a', b=>'_b'}
{a => _a, b => _b}
[3] > sub infix:<alias>($a, $b) { return $a=>$b }
&infix:<alias>
[4] > $aa alias 'a'
===SORRY!=== Error while compiling:
Two terms in a row
------> $aa⏏ alias 'a'
expecting any of:
infix
infix stopper
statement end
statement modifier
statement modifier loop
And to add insult to injury, thinking a literal term like "alias" might not work:
[4] > sub infix:<swap>( $a is rw, $b is rw ) {
($a, $b) = ($b, $a)
}
my ($num, $letter) = ('A', 3);
say $num; # OUTPUT: «A␤»
say $letter; # OUTPUT: «3␤»
# Swap two variables' values
$num swap $letter;
say $num; # OUTPUT: «3␤»
A
3
3
[4] >
Maybe it was the specific word I was using?
[4] > sub infix:<alias>( $a is rw, $b is rw ) {
($a, $b) = ($b, $a)
}
my ($num, $letter) = ('A', 3);
say $num; # OUTPUT: «A␤»
say $letter; # OUTPUT: «3␤»
# Swap two variables' values
$num alias $letter;
say $num; # OUTPUT: «3␤»
===SORRY!=== Error while compiling:
Two terms in a row
at line 10
------> $num⏏ swap $letter;
expecting any of:
infix
infix stopper
statement end
statement modifier
statement modifier loop
But then I exit and reinitialize:
[3] > sub infix:<alias>( $a is rw, $b is rw ) {
($a, $b) = ($b, $a)
}
my ($num, $letter) = ('A', 3);
say $num; # OUTPUT: «A␤»
say $letter; # OUTPUT: «3␤»
# Swap two variables' values
$num alias $letter;
say $num; # OUTPUT: «3␤»
A
3
3
And for good measure:
my $a = {a=>"_a", b=>"_b"}
{a => _a, b => _b}
[3] > sub infix:<α>( $a is rw, $b is rw ) {
($a, $b) = ($b, $a)
}
my ($num, $letter) = ('A', 3);
say $num; # OUTPUT: «A␤»
say $letter; # OUTPUT: «3␤»
# Swap two variables' values
$num α $letter;
say $num;
A
3
3
In the module file I define these custom operators. The subs do not work, the multi subs DO work:
sub infix:<α> (Format::Bidirectional $name, Str $value) is export {
return $name.keyToAlias($value);
}
sub infix:<κ> (Format::Bidirectional $name, Str $value) is export {
return $name.aliasToKey($value);
}
sub infix:<∨> (Format::Bidirectional $name, Str $value) is export {
return $name.either($value);
}
multi sub infix:<===> (Format::Formatter:D $left, Format::Formatter:D $right) is export {
return $left.object eqv $right.object;
}
multi sub infix:<===> (Format::Formatter:D $left, Hash:D $right) is export {
return $left.object eqv $right;
}