myco 0.1.5 → 0.1.6

data/lib/myco/code_tools/parser/MycoGrammar.my

@@ -41,9 +41,10 @@ rule meme_expr:
 # Expressions allowable as function arguments
 rule arg_expr:
   assignment
-/ left_chained_atoms
+/ left_chained_operations
 / dyn_string
 / dyn_symstr
+/ left_chained_piping
 / expr_atom
 
 # TODO: make expr_atom not redundant with below rules
@@ -57,6 +58,7 @@ rule expr_atom:
 / paren_expr
 / constant
 / lit_simple
+/ lit_other
 / lit_array
 / invoke
 
@@ -69,6 +71,7 @@ rule expr_atom_not_chained:
 / paren_expr
 / constant
 / lit_simple
+/ lit_other
 / lit_array
 / invoke
 
@@ -80,6 +83,7 @@ rule expr_atom_not_string:
 / paren_expr
 / constant
 / lit_simple
+/ lit_other
 / lit_array
 / invoke
 
@@ -96,6 +100,20 @@ rule lit_simple:
 / r(T.integer[:t0])  { ast.lit(t0, t0.integer) }
 / r(T.symbol[:t0])   { ast.lit(t0, t0.text.slice(::Range.new(1,-1)).to_sym) } # TODO: more succinct here
 
+##
+# Other literals
+
+lit_other:
+  lit_block
+
+rule lit_block:
+  r(T.op_toproc[:to] + block_body[:n1])
+    { ast.blklit(to, n1) }
+
+rule block_body:
+  r(C.spc_nl.* + param_list.-[:np] + C.spc_nl.* + meme_enclosed_expr_body[:nb])
+    { ast.block(nb, np, nb) }
+
 ##
 # Enclosed literals
 
@@ -176,7 +194,7 @@ rule declobj_sepd_exprs:
 
 rule declobj_expr_body:
   r(arg_sep_opt + declobj_sepd_exprs[:nlist] + T.declare_end[:te])
-    { ast.block(nlist.first, nlist) }
+    { ast.sequence(nlist.first, nlist) }
 / r(arg_sep_opt + T.declare_end[:te])
     { ast.null(te) }
 
@@ -198,7 +216,7 @@ rule category:
   r(category_name[:n0] + category_sepd_exprs.-[:nlist]
       + !!(arg_sep_opt + (T.catgry_begin / T.declare_end)))
       { ast.category(n0, n0.value,
-        (nlist &? ast.block(nlist.first, nlist) ?? ast.null(n0))) }
+        (nlist &? ast.sequence(nlist.first, nlist) ?? ast.null(n0))) }
 
 rule copen:
   r(constant[:n0] + C.spc_nl.* + T.reopen[:tb] + C.spc_nl.* + T.declare_begin + declobj_expr_body[:n1])
@@ -252,24 +270,20 @@ rule invoke_assignment:
 ##
 # Invoke - Results in a :lambig, :call, or :iter with a :call within
 
-rule invoke_body:
-  r(C.spc_nl.* + param_list.-[:np] + C.spc_nl.* + meme_enclosed_expr_body[:nb])
-    { [np, nb] }
-
-opt_arg_list:    (r(C.spc.*    + arg_list[:n])     { n  }).-
-opt_invoke_body: (r(C.spc_nl.* + invoke_body[:nx]) { nx }).-
+opt_arg_list:   (r(C.spc.*    + arg_list[:n])   { n }).-
+opt_block_body: (r(C.spc_nl.* + block_body[:n]) { n }).-
 
 rule invoke:
-  r(T.identifier[:tn] + opt_arg_list[:na] + opt_invoke_body[:nlist])
-    { ast.invoke(tn, null, tn.sym, na, *(nlist || [])) }
+  r(T.identifier[:tn] + opt_arg_list[:na] + opt_block_body[:nb])
+    { ast.invoke(tn, null, tn.sym, na, nb) }
 
 rule op_invoke: # Allow some binary operators to be invoked with a dot
-  r(op_invoke_id[:tn] + opt_arg_list[:na] + opt_invoke_body[:nlist])
-    { ast.invoke(tn, null, tn.sym, na, *(nlist || [])) }
+  r(op_invoke_id[:tn] + opt_arg_list[:na] + opt_block_body[:nb])
+    { ast.invoke(tn, null, tn.sym, na, nb) }
 
 rule elem_invoke:
-  r(lit_array[:na] + opt_invoke_body[:nlist])
-    { ast.invoke(na, null, :"[]", ast.argass(na, na.body), *(nlist || [])) }
+  r(lit_array[:na] + opt_block_body[:nb])
+    { ast.invoke(na, null, :"[]", ast.argass(na, na.body), nb) }
 
 rule op_invoke_id:
   left_op_normal
@@ -395,7 +409,7 @@ left_op_normal:
 / T.op_mult / T.op_div / T.op_mod
 / T.op_plus / T.op_minus
 / T.op_compare
-/ T.op_and  / T.op_or
+/ T.op_r_pipe
 
 left_op_branch:
   T.op_and  / T.op_or
@@ -411,12 +425,12 @@ rule left_op: left_op_normal / left_op_branch
 # http://www.dalnefre.com/wp/2011/05/parsing-expression-grammars-part-4/
 # for an easy-to-understand explanation of this problem and this solution.
 #
-rule sepd_chained_atom:
+rule sepd_chained_operation:
   r(C.spc_nl.* + left_op[:to] + C.spc_nl.* + expr_atom[:n1])
     { [to, n1] }
 
-rule left_chained_atoms:
-  r(expr_atom[:n0] + sepd_chained_atom.+[:nlist])
+rule left_chained_operations:
+  r(expr_atom[:n0] + sepd_chained_operation.+[:nlist])
     {
   nlist.unshift(n0)
   nlist.flatten!
@@ -429,10 +443,13 @@ rule left_chained_atoms:
                   :t_op_and_q, :t_op_or_q, :t_op_void_q) |n0,op,n1| {
     ast.branch_op(op, op.sym, n0, n1)
   }
+  collapse(nlist, :t_op_r_pipe) |n0,op,n1| {
+    ast.pipe_op(op, n0, n1)
+  }
   
   # There should only be one resulting node left
   (nlist.count == 1)
-    || raise("Failed to fully collapse left_chained_atoms: "nlist"")
+    || raise("Failed to fully collapse left_chained_operations: "nlist"")
   
   nlist.first
 }
@@ -445,7 +462,7 @@ rule left_invoke_op:
 / T.dot
 
 # Achieve left-associativity through iteration.
-# (see left_chained_atoms).
+# (see left_chained_operations).
 #
 rule sepd_chained_invocation:
   r(C.spc_nl.* + left_invoke_op[:t0] + C.spc_nl.* + (invoke / op_invoke)[:n1])
@@ -457,7 +474,7 @@ rule left_chained_invocations:
   r(expr_atom_not_chained[:n0] + sepd_chained_invocation.+[:nlist])
     {
   nlist.unshift(n0)
-  nlist.send(:"flatten!")
+  nlist.flatten!
   
   collapse(nlist, :t_dot, :t_quest) |n0,op,n1| {
     (op.type == :t_dot)
@@ -472,6 +489,32 @@ rule left_chained_invocations:
   nlist.first
 }
 
+##
+# Piping invocations
+
+pipeable: left_chained_invocations / invoke
+
+rule sepd_chained_piping:
+  r(C.spc.+.token(:t_op_r_pipe)[:to] + pipeable[:n1])
+    { [to, n1] }
+
+rule left_chained_piping:
+  r(expr_atom[:n0] + sepd_chained_piping.+[:nlist])
+    {
+  nlist.unshift(n0)
+  nlist.flatten!
+  
+  collapse(nlist, :t_op_r_pipe) |n0,op,n1| {
+    ast.pipe_op(op, n0, n1)
+  }
+  
+  # There should only be one resulting node left
+  (nlist.count == 1)
+    || raise("Failed to fully collapse left_chained_piping: "nlist"")
+  
+  nlist.first
+}
+
 ##
 # Unary operators
 
@@ -510,17 +553,17 @@ rule meme_sepd_exprs:
 
 rule meme_inline_expr_body:
   r(inln_sep_opt + meme_inline_sepd_exprs[:nlist])
-    { ast.block(nlist.first, nlist) }
+    { ast.sequence(nlist.first, nlist) }
 
 rule meme_expr_body:
   r(expr_sep_opt + meme_sepd_exprs[:nlist] + T.meme_end[:te])
-    { ast.block(nlist.first, nlist) }
+    { ast.sequence(nlist.first, nlist) }
 / r(expr_sep_opt + T.meme_end[:te])
     { ast.null(te) }
 
 rule paren_expr_body:
   r(expr_sep_opt + meme_sepd_exprs[:nlist] + T.paren_end[:te])
-    { nlist.count==1 &? nlist.first ?? ast.block(nlist.first, nlist) }
+    { nlist.count==1 &? nlist.first ?? ast.sequence(nlist.first, nlist) }
 / r(expr_sep_opt + T.paren_end[:te])
     { ast.null(te) }
 

data/lib/myco/code_tools/parser/MycoGrammar.my.rb

@@ -3,10 +3,10 @@
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
   declare_meme(:"MycoCharacterClasses.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:"MycoTokens.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  ::Myco.cscope.for_method_definition.const_set(:MycoGrammar, (::Myco::Component.new([::Myco.find_constant(:Pegleromyces)::Grammar], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  ::Myco.cscope.for_method_definition::MycoGrammar = (::Myco::Component.new([::Myco.find_constant(:Pegleromyces)::Grammar], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
   .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-    ::Myco.cscope.for_method_definition.const_set(:C, (::Myco.find_constant(:MycoCharacterClasses)))
-    ::Myco.cscope.for_method_definition.const_set(:T, (::Myco.find_constant(:MycoTokens)))
+    ::Myco.cscope.for_method_definition::C = (::Myco.find_constant(:MycoCharacterClasses))
+    ::Myco.cscope.for_method_definition::T = (::Myco.find_constant(:MycoTokens))
     __category__(:rules).component_eval {(
       declare_meme(:root, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.declobj_expr_body.__send__(
         :[],
@@ -45,13 +45,16 @@
       declare_meme(:meme_expr, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.arg_expr)}
       declare_meme(:arg_expr, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.assignment.__send__(
         :/,
-        self.left_chained_atoms
+        self.left_chained_operations
       ).__send__(
         :/,
         self.dyn_string
       ).__send__(
         :/,
         self.dyn_symstr
+      ).__send__(
+        :/,
+        self.left_chained_piping
       ).__send__(
         :/,
         self.expr_atom
@@ -77,6 +80,9 @@
       ).__send__(
         :/,
         self.lit_simple
+      ).__send__(
+        :/,
+        self.lit_other
       ).__send__(
         :/,
         self.lit_array
@@ -102,6 +108,9 @@
       ).__send__(
         :/,
         self.lit_simple
+      ).__send__(
+        :/,
+        self.lit_other
       ).__send__(
         :/,
         self.lit_array
@@ -124,6 +133,9 @@
       ).__send__(
         :/,
         self.lit_simple
+      ).__send__(
+        :/,
+        self.lit_other
       ).__send__(
         :/,
         self.lit_array
@@ -189,6 +201,40 @@
           )).to_sym
         ))}
       ))}
+      declare_meme(:lit_other, [], nil, ::Myco.cscope.dup) { |*| (self.lit_block)}
+      declare_meme(:lit_block, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:T).op_toproc.__send__(
+        :[],
+        :to
+      ).__send__(
+        :+,
+        self.block_body.__send__(
+          :[],
+          :n1
+        )
+      )) { || (self.ast.blklit(
+        self.to,
+        self.__send__(:n1)
+      ))})}
+      declare_meme(:block_body, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:C).spc_nl.__send__(:*).__send__(
+        :+,
+        self.param_list.__send__(:-).__send__(
+          :[],
+          :np
+        )
+      ).__send__(
+        :+,
+        ::Myco.find_constant(:C).spc_nl.__send__(:*)
+      ).__send__(
+        :+,
+        self.meme_enclosed_expr_body.__send__(
+          :[],
+          :nb
+        )
+      )) { || (self.ast.block(
+        self.nb,
+        self.np,
+        self.nb
+      ))})}
       declare_meme(:lit_string, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:T).string_begin.__send__(
         :+,
         ::Myco.find_constant(:T).string_body.__send__(
@@ -422,7 +468,7 @@
           :[],
           :te
         )
-      )) { || (self.ast.block(
+      )) { || (self.ast.sequence(
         self.nlist.first,
         self.nlist
       ))}.__send__(
@@ -503,7 +549,7 @@
       )) { || (self.ast.category(
         self.__send__(:n0),
         self.__send__(:n0).value,
-        ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.nlist) {self.ast.block(
+        ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.nlist) {self.ast.sequence(
           self.nlist.first,
           self.nlist
         )}) {self.ast.null(self.__send__(:n0))}
@@ -686,25 +732,6 @@
         )
         self.lhs
       )})}
-      declare_meme(:invoke_body, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:C).spc_nl.__send__(:*).__send__(
-        :+,
-        self.param_list.__send__(:-).__send__(
-          :[],
-          :np
-        )
-      ).__send__(
-        :+,
-        ::Myco.find_constant(:C).spc_nl.__send__(:*)
-      ).__send__(
-        :+,
-        self.meme_enclosed_expr_body.__send__(
-          :[],
-          :nb
-        )
-      )) { || ([
-        self.np,
-        self.nb
-      ])})}
       declare_meme(:opt_arg_list, [], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:C).spc.__send__(:*).__send__(
         :+,
         self.arg_list.__send__(
@@ -712,13 +739,13 @@
           :n
         )
       )) { || (self.n)}.__send__(:-))}
-      declare_meme(:opt_invoke_body, [], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:C).spc_nl.__send__(:*).__send__(
+      declare_meme(:opt_block_body, [], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:C).spc_nl.__send__(:*).__send__(
         :+,
-        self.invoke_body.__send__(
+        self.block_body.__send__(
           :[],
-          :nx
+          :n
         )
-      )) { || (self.nx)}.__send__(:-))}
+      )) { || (self.n)}.__send__(:-))}
       declare_meme(:invoke, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:T).identifier.__send__(
         :[],
         :tn
@@ -730,16 +757,16 @@
         )
       ).__send__(
         :+,
-        self.opt_invoke_body.__send__(
+        self.opt_block_body.__send__(
           :[],
-          :nlist
+          :nb
         )
       )) { || (self.ast.invoke(
         self.tn,
         nil,
         self.tn.sym,
         self.na,
-        *::Myco.branch_op(:"||", self.nlist) {[]}
+        self.nb
       ))})}
       declare_meme(:op_invoke, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.op_invoke_id.__send__(
         :[],
@@ -752,25 +779,25 @@
         )
       ).__send__(
         :+,
-        self.opt_invoke_body.__send__(
+        self.opt_block_body.__send__(
           :[],
-          :nlist
+          :nb
         )
       )) { || (self.ast.invoke(
         self.tn,
         nil,
         self.tn.sym,
         self.na,
-        *::Myco.branch_op(:"||", self.nlist) {[]}
+        self.nb
       ))})}
       declare_meme(:elem_invoke, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.lit_array.__send__(
         :[],
         :na
       ).__send__(
         :+,
-        self.opt_invoke_body.__send__(
+        self.opt_block_body.__send__(
           :[],
-          :nlist
+          :nb
         )
       )) { || (self.ast.invoke(
         self.na,
@@ -780,7 +807,7 @@
           self.na,
           self.na.body
         ),
-        *::Myco.branch_op(:"||", self.nlist) {[]}
+        self.nb
       ))})}
       declare_meme(:op_invoke_id, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.left_op_normal)}
       declare_meme(:arg_sep, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:C).spc.__send__(:*).__send__(
@@ -1391,10 +1418,7 @@
         ::Myco.find_constant(:T).op_compare
       ).__send__(
         :/,
-        ::Myco.find_constant(:T).op_and
-      ).__send__(
-        :/,
-        ::Myco.find_constant(:T).op_or
+        ::Myco.find_constant(:T).op_r_pipe
       ))}
       declare_meme(:left_op_branch, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:T).op_and.__send__(
         :/,
@@ -1413,7 +1437,7 @@
         :/,
         self.left_op_branch
       ))}
-      declare_meme(:sepd_chained_atom, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:C).spc_nl.__send__(:*).__send__(
+      declare_meme(:sepd_chained_operation, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:C).spc_nl.__send__(:*).__send__(
         :+,
         self.left_op.__send__(
           :[],
@@ -1432,12 +1456,12 @@
         self.to,
         self.__send__(:n1)
       ])})}
-      declare_meme(:left_chained_atoms, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.expr_atom.__send__(
+      declare_meme(:left_chained_operations, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.expr_atom.__send__(
         :[],
         :n0
       ).__send__(
         :+,
-        self.sepd_chained_atom.__send__(:+).__send__(
+        self.sepd_chained_operation.__send__(:+).__send__(
           :[],
           :nlist
         )
@@ -1476,10 +1500,18 @@
           n0,
           n1
         ))}
+        self.collapse(
+          self.nlist,
+          :t_op_r_pipe
+        ) { |n0, op, n1| (self.ast.pipe_op(
+          op,
+          n0,
+          n1
+        ))}
         ::Myco.branch_op(:"||", self.nlist.count.__send__(
           :==,
           1
-        )) {self.raise("Failed to fully collapse left_chained_atoms: #{self.nlist}")}
+        )) {self.raise("Failed to fully collapse left_chained_operations: #{self.nlist}")}
         self.nlist.first
       )})}
       declare_meme(:left_invoke_op, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:T).quest.__send__(
@@ -1534,7 +1566,7 @@
         )
       )) { || (
         self.nlist.unshift(self.__send__(:n0))
-        self.nlist.send(:flatten!)
+        self.nlist.__send__(:flatten!)
         self.collapse(
           self.nlist,
           :t_dot,
@@ -1559,6 +1591,49 @@
         )) {self.raise("Failed to fully collapse left_chained_invocations: #{self.nlist}")}
         self.nlist.first
       )})}
+      declare_meme(:pipeable, [], nil, ::Myco.cscope.dup) { |*| (self.left_chained_invocations.__send__(
+        :/,
+        self.invoke
+      ))}
+      declare_meme(:sepd_chained_piping, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:C).spc.__send__(:+).token(:t_op_r_pipe).__send__(
+        :[],
+        :to
+      ).__send__(
+        :+,
+        self.pipeable.__send__(
+          :[],
+          :n1
+        )
+      )) { || ([
+        self.to,
+        self.__send__(:n1)
+      ])})}
+      declare_meme(:left_chained_piping, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.expr_atom.__send__(
+        :[],
+        :n0
+      ).__send__(
+        :+,
+        self.sepd_chained_piping.__send__(:+).__send__(
+          :[],
+          :nlist
+        )
+      )) { || (
+        self.nlist.unshift(self.__send__(:n0))
+        self.nlist.__send__(:flatten!)
+        self.collapse(
+          self.nlist,
+          :t_op_r_pipe
+        ) { |n0, op, n1| (self.ast.pipe_op(
+          op,
+          n0,
+          n1
+        ))}
+        ::Myco.branch_op(:"||", self.nlist.count.__send__(
+          :==,
+          1
+        )) {self.raise("Failed to fully collapse left_chained_piping: #{self.nlist}")}
+        self.nlist.first
+      )})}
       declare_meme(:unary_operation, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(::Myco.find_constant(:T).op_not.__send__(
         :[],
         :to
@@ -1652,7 +1727,7 @@
           :[],
           :nlist
         )
-      )) { || (self.ast.block(
+      )) { || (self.ast.sequence(
         self.nlist.first,
         self.nlist
       ))})}
@@ -1668,7 +1743,7 @@
           :[],
           :te
         )
-      )) { || (self.ast.block(
+      )) { || (self.ast.sequence(
         self.nlist.first,
         self.nlist
       ))}.__send__(
@@ -1696,7 +1771,7 @@
       )) { || (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.nlist.count.__send__(
         :==,
         1
-      )) {self.nlist.first}) {self.ast.block(
+      )) {self.nlist.first}) {self.ast.sequence(
         self.nlist.first,
         self.nlist
       )})}.__send__(
@@ -1847,5 +1922,5 @@
         ))}
       ))}
     )}
-  )}}.instance))
+  )}}.instance)
 )}}.instance

data/lib/myco/code_tools/parser/MycoTokens.my

@@ -25,7 +25,7 @@ MycoTokens: Pegleromyces::Grammar {
   
   token constant:     C.upper + C.alnum.*
   token identifier:   C.lower + C.alnum.* + C.suffix.-
-  token symbol:       str(':') + C.lower + C.alnum.*
+  token symbol:       str(':') + (C.lower / C.upper) + C.alnum.* + C.suffix.-
   token null:         str('null')
   token void:         str('void')
   token true:         str('true')
@@ -35,7 +35,7 @@ MycoTokens: Pegleromyces::Grammar {
   token integer:      str('-').- + C.num.+
   
   token dot:          str('.')
-  token quest:        str('.') + C.spc_nl.* + str('?')
+  token quest:        str('.') + str('?')
   token scope:        str('::')
   token assign:       str('=')
   token op_toproc:    str('&')
@@ -53,6 +53,7 @@ MycoTokens: Pegleromyces::Grammar {
   token op_void_q:    str('??')
   token op_compare:   str('<=>') / str('=~') / str('==') /
                       str('<=') / str('>=') / str('<') / str('>')
+  token op_r_pipe:    str('|>')
   
   string_norm:     !set("\\\"") + any
   token string_body:   string_norm.* + (str("\\") + any + string_norm.*).*

data/lib/myco/code_tools/parser/MycoTokens.my.rb

@@ -1,8 +1,8 @@
 
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.cscope.for_method_definition.const_set(:MycoTokens, (::Myco::Component.new([::Myco.find_constant(:Pegleromyces)::Grammar], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.cscope.for_method_definition::MycoTokens = (::Myco::Component.new([::Myco.find_constant(:Pegleromyces)::Grammar], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  ::Myco.cscope.for_method_definition.const_set(:C, (::Myco.find_constant(:MycoCharacterClasses)))
+  ::Myco.cscope.for_method_definition::C = (::Myco.find_constant(:MycoCharacterClasses))
   __category__(:main).component_eval {(
     declare_meme(:const_sep, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str(","))}
     declare_meme(:expr_sep, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str(";").__send__(
@@ -44,10 +44,16 @@
     ))}
     declare_meme(:symbol, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str(":").__send__(
       :+,
-      ::Myco.find_constant(:C).lower
+      ::Myco.find_constant(:C).lower.__send__(
+        :/,
+        ::Myco.find_constant(:C).upper
+      )
     ).__send__(
       :+,
       ::Myco.find_constant(:C).alnum.__send__(:*)
+    ).__send__(
+      :+,
+      ::Myco.find_constant(:C).suffix.__send__(:-)
     ))}
     declare_meme(:null, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("null"))}
     declare_meme(:void, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("void"))}
@@ -70,9 +76,6 @@
     ))}
     declare_meme(:dot, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("."))}
     declare_meme(:quest, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str(".").__send__(
-      :+,
-      ::Myco.find_constant(:C).spc_nl.__send__(:*)
-    ).__send__(
       :+,
       self.str("?")
     ))}
@@ -110,6 +113,7 @@
       :/,
       self.str(">")
     ))}
+    declare_meme(:op_r_pipe, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("|>"))}
     declare_meme(:string_norm, [], nil, ::Myco.cscope.dup) { |*| (self.set("\\\"").__send__(:!).__send__(
       :+,
       self.any
@@ -167,4 +171,4 @@
     declare_meme(:declstr_begin, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("@@@"))}
     declare_meme(:declstr_end, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("@@@"))}
   )}
-)}}.instance)))}}.instance
+)}}.instance))}}.instance

data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/Builder.my.rb

@@ -1,5 +1,5 @@
 
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.cscope.for_method_definition.const_set(:Builder, ::Myco::Component.new([::Myco.find_constant(:BasicObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-.tap { |__c__| __c__.__last__ = __c__.component_eval {nil}})
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.cscope.for_method_definition::Builder = ::Myco::Component.new([::Myco.find_constant(:BasicObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}
 .tap { |__c__| __c__.__name__ = :Builder })}}.instance

data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/BytecodeHelpers.my

@@ -136,7 +136,7 @@ BytecodeHelpers < BasicObject {
     ary.each |lit| { g.push_literal_or_array(lit) }; make_array(ary.size)
   
   push_literal_or_array: |item|
-    item.is_a?(::Array)
+    item.is_a?(Array)
       &? push_literal_array(item)
       ?? push_literal(item)
 }