[v6] Remove categorical debugging print

v6/tryfile

@@ -56,6 +56,78 @@ augment class Hash {
 
 augment class STD {
     our $ALL;
+my %term            = (:dba('term')            , :prec<z=>);
+my %methodcall      = (:dba('methodcall')      , :prec<y=>, :assoc<unary>, :uassoc<left>, :fiddly, :!pure);
+my %autoincrement   = (:dba('autoincrement')   , :prec<x=>, :assoc<unary>, :uassoc<non>, :!pure);
+my %exponentiation  = (:dba('exponentiation')  , :prec<w=>, :assoc<right>, :pure);
+my %symbolic_unary  = (:dba('symbolic unary')  , :prec<v=>, :assoc<unary>, :uassoc<left>, :pure);
+my %multiplicative  = (:dba('multiplicative')  , :prec<u=>, :assoc<left>, :pure);
+my %additive        = (:dba('additive')        , :prec<t=>, :assoc<left>, :pure);
+my %replication     = (:dba('replication')     , :prec<s=>, :assoc<left>, :pure);
+my %concatenation   = (:dba('concatenation')   , :prec<r=>, :assoc<list>, :pure);
+my %junctive_and    = (:dba('junctive and')    , :prec<q=>, :assoc<list>, :pure);
+my %junctive_or     = (:dba('junctive or')     , :prec<p=>, :assoc<list>, :pure);
+my %named_unary     = (:dba('named unary')     , :prec<o=>, :assoc<unary>, :uassoc<left>, :pure);
+my %structural      = (:dba('structural infix'), :prec<n=>, :assoc<non>, :diffy);
+my %chaining        = (:dba('chaining')        , :prec<m=>, :assoc<chain>, :diffy, :iffy, :pure);
+my %tight_and       = (:dba('tight and')       , :prec<l=>, :assoc<list>);
+my %tight_or        = (:dba('tight or')        , :prec<k=>, :assoc<list>);
+my %conditional     = (:dba('conditional')     , :prec<j=>, :assoc<right>, :fiddly);
+my %item_assignment = (:dba('item assignment') , :prec<i=>, :assoc<right>, :!pure);
+my %list_assignment = (:dba('list assignment') , :prec<i=>, :assoc<right>, :sub<e=>, :fiddly, :!pure);
+my %loose_unary     = (:dba('loose unary')     , :prec<h=>, :assoc<unary>, :uassoc<left>, :pure);
+my %comma           = (:dba('comma')           , :prec<g=>, :assoc<list>, :nextterm<nulltermish>, :fiddly, :pure);
+my %list_infix      = (:dba('list infix')      , :prec<f=>, :assoc<list>, :pure);
+my %list_prefix     = (:dba('list prefix')     , :prec<e=>, :assoc<unary>, :uassoc<left>);
+my %loose_and       = (:dba('loose and')       , :prec<d=>, :assoc<list>);
+my %loose_or        = (:dba('loose or')        , :prec<c=>, :assoc<list>);
+my %sequencer       = (:dba('sequencer')       , :prec<b=>, :assoc<list>, :nextterm<statement>, :fiddly);
+my %LOOSEST         = (:dba('LOOSEST')         , :prec<a=!>);
+my %terminator      = (:dba('terminator')      , :prec<a=>, :assoc<list>);
+role sym_categorical2[$name,$sym,$O] {
+    token ::($name) () { $sym $<O>={$O} }
+}
+role bracket_categorical2[$name,$sym1,$sym2,$O] {
+    token ::($name) () { :my $*GOAL = $sym2; $sym1 {}:s [ :lang($¢.unbalanced($sym2)) <semilist> ] [ $sym2 || <.FAILGOAL($sym2, $name, self.pos)> ] $<O>={$O} }
+}
+method add_categorical($name) {
+    # Signature extension, not categorical
+    if $name ~~ /^\w+\:\(/ {
+        self.add_my_name($name);
+        return self;
+    }
+    my $M = ($name ~~ /^(\w+)\: <?[ \< \« ]> /);
+    return self unless $M;
+    my $cat = $M[0];
+    my $sym = substr($name, $M.to+1, $name.chars-$M.to-2);
+
+    my $O;
+
+    if $cat eq 'infix'            { $O = %additive }
+    elsif $cat eq 'prefix'        {
+        $O = ($sym ~~ /^\W/) ?? %symbolic_unary !! %named_unary
+    }
+    elsif $cat eq 'postfix'       { $O = %methodcall }
+    elsif $cat eq 'circumfix'     { $O = %term }
+    elsif $cat eq 'postcircumfix' { $O = %methodcall }
+    elsif $cat eq 'term'          { $O = %term }
+    else {
+        self.sorry("Cannot extend category:$name with subs");
+        return self;
+    }
+
+    # XXX to do this right requires .comb and .trans
+    if $M = ($sym ~~ /\s+/) {
+        my $sym1 = $sym.substr(0, $M.from);
+        my $sym2 = $sym.substr($M.to, $sym.chars - $M.to);
+        my $cname = $cat ~ ":<$sym1 $sym2>";
+        %*LANG<MAIN> = self.WHAT but OUR::bracket_categorical2[$cname, $sym1, $sym2, $O];
+    } else {
+        my $cname = $cat ~ ":<$sym>";
+        %*LANG<MAIN> = self.WHAT but OUR::sym_categorical2[$cname, $sym, $O];
+    }
+    self.cursor_fresh(%*LANG<MAIN>);
+}
 method load_lex($setting) {
     if $setting eq 'NULL' {
         my $id = "MY:file<NULL.pad>:line(1):pos(0)";