myco 0.1.5 → 0.1.6

data/lib/myco/code_tools/AST/PipeOperator.my

@@ -0,0 +1,25 @@
+
+CodeTools::AST << {
+  
+  PipeOperator < Node {
+    var value, var invoke
+    
+    Form: [:pipe_op, :value, :invoke]
+    
+    implementation_args: ArgumentAssembly.new(
+      line: self.line
+      body: [self.value] + (self.invoke.arguments.?body ?? [])
+    )
+    
+    implementation: Invoke.new(
+      line:         self.line
+      receiver:     self.invoke.receiver
+      name:         self.invoke.name
+      arguments:    self.implementation_args
+      block:        self.invoke.block
+    )
+    
+    bytecode: |g| implementation.bytecode(g)
+  }
+  
+}

data/lib/myco/code_tools/AST/PipeOperator.my.rb

@@ -0,0 +1,28 @@
+
+::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition::PipeOperator = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:value, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:invoke, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  ::Myco.cscope.for_method_definition::Form = ([
+    :pipe_op,
+    :value,
+    :invoke
+  ])
+  declare_meme(:implementation_args, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:ArgumentAssembly).new({
+    :line => self.line,
+    :body => [self.value].__send__(
+      :+,
+      ::Myco.branch_op(:"??", (self.invoke.arguments.respond_to?(:body).false? ? ::Myco::Void : self.invoke.arguments.body)) {[]}
+    )
+  }))}
+  declare_meme(:implementation, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Invoke).new({
+    :line => self.line,
+    :receiver => self.invoke.receiver,
+    :name => self.invoke.name,
+    :arguments => self.implementation_args,
+    :block => self.invoke.block
+  }))}
+  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (self.implementation.bytecode(g))}
+)}}
+.tap { |__c__| __c__.__name__ = :PipeOperator })})}}.instance

data/lib/myco/code_tools/AST/Quest.my.rb

@@ -1,14 +1,14 @@
 
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition.const_set(:Quest, ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition::Quest = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
   declare_meme(:receiver, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:questable, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  ::Myco.cscope.for_method_definition.const_set(:Form, ([
+  ::Myco.cscope.for_method_definition::Form = ([
     :quest,
     :receiver,
     :questable
-  ]))
+  ])
   declare_meme(:questable, [[:setter, []]], nil, ::Myco.cscope.dup) { |given| (
     given.__send__(
       :receiver=,
@@ -41,11 +41,11 @@
     g.find_const(:Void)
     end_label.__send__(:set!)
   )}
-  ::Myco.cscope.for_method_definition.const_set(:FakeReceiver, ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  ::Myco.cscope.for_method_definition::FakeReceiver = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
   .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-    ::Myco.cscope.for_method_definition.const_set(:Form, ([:qrcvr]))
+    ::Myco.cscope.for_method_definition::Form = ([:qrcvr])
     declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (self.pos(g))}
-  )}})
+  )}}
   .tap { |__c__| __c__.__name__ = :FakeReceiver }
-)}})
+)}}
 .tap { |__c__| __c__.__name__ = :Quest })})}}.instance

data/lib/myco/code_tools/AST/Script.my.rb

@@ -1,15 +1,15 @@
 
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition.const_set(:Script, ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition::Script = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
   declare_meme(:file, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:body, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:variable_scope, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  ::Myco.cscope.for_method_definition.const_set(:Form, ([
+  ::Myco.cscope.for_method_definition::Form = ([
     :script,
     :file,
     :body
-  ]))
+  ])
   declare_meme(:nest_scope, [], nil, ::Myco.cscope.dup) { |scope| (scope.__send__(
     :parent=,
     self
@@ -29,5 +29,5 @@
     g.ret
     g.pop_state
   )}
-)}})
+)}}
 .tap { |__c__| __c__.__name__ = :Script })})}}.instance

data/lib/myco/code_tools/AST/{Body.my → Sequence.my}

@@ -1,10 +1,10 @@
 
 CodeTools::AST << {
   
-  Body < Node {
+  Sequence < Node {
     var array
     
-    Form: [:block, :array]
+    Form: [:sequence, :array]
     
     bytecode: |g| {
       ary = self.array.dup

data/lib/myco/code_tools/AST/{Body.my.rb → Sequence.my.rb}

@@ -1,12 +1,12 @@
 
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition.const_set(:Body, ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition::Sequence = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
   declare_meme(:array, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  ::Myco.cscope.for_method_definition.const_set(:Form, ([
-    :block,
+  ::Myco.cscope.for_method_definition::Form = ([
+    :sequence,
     :array
-  ]))
+  ])
   declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
     ary = self.array.dup
     last = ary.pop
@@ -16,5 +16,5 @@
     )}
     last.bytecode(g)
   )}
-)}})
-.tap { |__c__| __c__.__name__ = :Body })})}}.instance
+)}}
+.tap { |__c__| __c__.__name__ = :Sequence })})}}.instance

data/lib/myco/code_tools/AST/SplatValue.my.rb

@@ -1,12 +1,12 @@
 
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition.const_set(:SplatValue, ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition::SplatValue = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
   declare_meme(:value, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  ::Myco.cscope.for_method_definition.const_set(:Form, ([
+  ::Myco.cscope.for_method_definition::Form = ([
     :splat,
     :value
-  ]))
+  ])
   declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
     self.value.bytecode(g)
     g.dup
@@ -21,5 +21,5 @@
     g.swap
     g.pop
   )}
-)}})
+)}}
 .tap { |__c__| __c__.__name__ = :SplatValue })})}}.instance

data/lib/myco/code_tools/AST/StringLiteral.my.rb

@@ -1,16 +1,16 @@
 
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition.const_set(:StringLiteral, ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition::StringLiteral = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
   declare_meme(:value, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  ::Myco.cscope.for_method_definition.const_set(:Form, ([
+  ::Myco.cscope.for_method_definition::Form = ([
     :str,
     :value
-  ]))
+  ])
   declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
     self.pos(g)
     g.push_literal(self.value)
     g.string_dup
   )}
-)}})
+)}}
 .tap { |__c__| __c__.__name__ = :StringLiteral })})}}.instance

data/lib/myco/code_tools/AST/SymbolLiteral.my.rb

@@ -1,15 +1,15 @@
 
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition.const_set(:SymbolLiteral, ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition::SymbolLiteral = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
   declare_meme(:value, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  ::Myco.cscope.for_method_definition.const_set(:Form, ([
+  ::Myco.cscope.for_method_definition::Form = ([
     :lit,
     :value
-  ]))
+  ])
   declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
     self.pos(g)
     g.push_literal(self.value)
   )}
-)}})
+)}}
 .tap { |__c__| __c__.__name__ = :SymbolLiteral })})}}.instance

data/lib/myco/code_tools/AST/ToRuby.my

@@ -294,7 +294,7 @@ CodeTools::AST << {
     }
   }
   
-  Body << {
+  Sequence << {
     to_ruby: |g|
       g.add("("); g.list(self.array, "", auto_lines:true); g.add(")")
   }
@@ -322,7 +322,7 @@ CodeTools::AST << {
         g.add(")")
       )
       
-      self.arguments.block.is_a?(BlockLiteral) && (
+      self.arguments.block.is_a?(Block) && (
         g.add(" {"); g.add(self.arguments.block); g.add("}")
       )
     }
@@ -367,7 +367,7 @@ CodeTools::AST << {
     to_ruby: |g| g.add("&"); g.add(self.body)
   }
   
-  BlockLiteral << {
+  Block << {
     to_ruby: |g| {
       g.with_nested_var_scope(self) {
         g.var_scope_declare_locals(*self.parameters.names)
@@ -377,6 +377,8 @@ CodeTools::AST << {
     }
   }
   
+  BlockLiteral << { to_ruby: |g| g.add(implementation) }
+  
   Quest << {
     to_ruby: |g| {
       associated_questable = self.questable.dup
@@ -399,4 +401,8 @@ CodeTools::AST << {
         g.add(self.right); g.add('}')
     }
   }
+  
+  PipeOperator << {
+    to_ruby: |g| g.add(implementation)
+  }
 }

data/lib/myco/code_tools/AST/ToRuby.my.rb

@@ -1,7 +1,7 @@
 
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(
-  ::Myco.cscope.for_method_definition.const_set(:ToRuby, ::Myco::Component.new([::Myco::Object], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  ::Myco.cscope.for_method_definition::ToRuby = ::Myco::Component.new([::Myco::Object], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
   .tap { |__c__| __c__.__last__ = __c__.component_eval {(
     declare_meme(:lines, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ([""])}
     declare_meme(:to_s, [], nil, ::Myco.cscope.dup) { |*| (self.lines.join("\n"))}
@@ -79,7 +79,7 @@
         sym
       ).__send__(:!)}
     )}
-  )}})
+  )}}
   .tap { |__c__| __c__.__name__ = :ToRuby }
   ::Myco.find_constant(:Node).component_eval {(declare_meme(:to_ruby_code, [], nil, ::Myco.cscope.dup) { |*| (
     g = ::Myco.find_constant(:ToRuby).new
@@ -266,7 +266,7 @@
     ) { |proc| (proc.call)}
     g.add("|")
   )})}
-  ::Myco.find_constant(:Body).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
+  ::Myco.find_constant(:Sequence).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
     g.add("(")
     g.list(
       self.array,
@@ -304,7 +304,7 @@
     )}
     ::Myco.branch_op(:"&&", self.arguments.block.__send__(
       :is_a?,
-      ::Myco.find_constant(:BlockLiteral)
+      ::Myco.find_constant(:Block)
     )) {(
       g.add(" {")
       g.add(self.arguments.block)
@@ -343,13 +343,14 @@
     g.add("&")
     g.add(self.body)
   )})}
-  ::Myco.find_constant(:BlockLiteral).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.with_nested_var_scope(self) { || (
+  ::Myco.find_constant(:Block).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.with_nested_var_scope(self) { || (
     g.var_scope_declare_locals(*self.parameters.names)
     g.add(" ")
     g.add(self.parameters)
     g.add(" ")
     g.add(self.body)
   )})})}
+  ::Myco.find_constant(:BlockLiteral).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.add(self.implementation))})}
   ::Myco.find_constant(:Quest).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
     associated_questable = self.questable.dup
     associated_questable.__send__(
@@ -372,4 +373,5 @@
     g.add(self.right)
     g.add("}")
   )})}
+  ::Myco.find_constant(:PipeOperator).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.add(self.implementation))})}
 )})}}.instance

data/lib/myco/code_tools/AST/misc.my.rb

@@ -12,52 +12,52 @@
     )}
     declare_meme(:push_null, [], nil, ::Myco.cscope.dup) { |*| (self.push_nil)}
   )}
-  ::Myco.cscope.for_method_definition.const_set(:Self, ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  ::Myco.cscope.for_method_definition::Self = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
   .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-    ::Myco.cscope.for_method_definition.const_set(:Form, ([:self]))
+    ::Myco.cscope.for_method_definition::Form = ([:self])
     declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
       self.pos(g)
       g.push_self
     )}
-  )}})
+  )}}
   .tap { |__c__| __c__.__name__ = :Self }
-  ::Myco.cscope.for_method_definition.const_set(:NullLiteral, ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  ::Myco.cscope.for_method_definition::NullLiteral = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
   .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-    ::Myco.cscope.for_method_definition.const_set(:Form, ([:null]))
+    ::Myco.cscope.for_method_definition::Form = ([:null])
     declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
       self.pos(g)
       g.push_null
     )}
-  )}})
+  )}}
   .tap { |__c__| __c__.__name__ = :NullLiteral }
-  ::Myco.cscope.for_method_definition.const_set(:VoidLiteral, ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  ::Myco.cscope.for_method_definition::VoidLiteral = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
   .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-    ::Myco.cscope.for_method_definition.const_set(:Form, ([:void]))
+    ::Myco.cscope.for_method_definition::Form = ([:void])
     declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
       self.pos(g)
       g.push_void
     )}
-  )}})
+  )}}
   .tap { |__c__| __c__.__name__ = :VoidLiteral }
-  ::Myco.cscope.for_method_definition.const_set(:TrueLiteral, ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  ::Myco.cscope.for_method_definition::TrueLiteral = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
   .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-    ::Myco.cscope.for_method_definition.const_set(:Form, ([:true]))
+    ::Myco.cscope.for_method_definition::Form = ([:true])
     declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
       self.pos(g)
       g.push_true
     )}
-  )}})
+  )}}
   .tap { |__c__| __c__.__name__ = :TrueLiteral }
-  ::Myco.cscope.for_method_definition.const_set(:FalseLiteral, ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  ::Myco.cscope.for_method_definition::FalseLiteral = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
   .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-    ::Myco.cscope.for_method_definition.const_set(:Form, ([:false]))
+    ::Myco.cscope.for_method_definition::Form = ([:false])
     declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
       self.pos(g)
       g.push_false
     )}
-  )}})
+  )}}
   .tap { |__c__| __c__.__name__ = :FalseLiteral }
-  ::Myco.cscope.for_method_definition.const_set(:EVALUATE_NOW, (::CodeTools::AST.component_eval { || (self.constants.select { |const_name| (self.const_get(const_name).constants.__send__(
+  ::Myco.cscope.for_method_definition::EVALUATE_NOW = (::CodeTools::AST.component_eval { || (self.constants.select { |const_name| (self.const_get(const_name).constants.__send__(
     :include?,
     :Form
   ))}.each { |const_name| (
@@ -77,5 +77,5 @@
       ))}
       inst
     )}
-  )})}))
+  )})})
 )})}}.instance

data/lib/myco/code_tools/AST.my

@@ -13,18 +13,20 @@ import 'AST/SymbolLiteral.my'
 import 'AST/DynamicString.my'
 import 'AST/DynamicSymbol.my'
 
-import 'AST/Body.my'
+import 'AST/Sequence.my'
 
 import 'AST/SplatValue.my'
 import 'AST/ArrayAssembly.my'
 import 'AST/KeywordAssembly.my'
 import 'AST/ArgumentAssembly.my'
 import 'AST/BlockArgument.my'
-import 'AST/BlockLiteral.my'
+import 'AST/Block.my'
 
 import 'AST/BlockParameter.my'
 import 'AST/ParameterAssembly.my'
 
+import 'AST/BlockLiteral.my'
+
 import 'AST/MycoModuleScope.my'
 
 import 'AST/ConstantAccess.my'
@@ -42,10 +44,10 @@ import 'AST/Invoke.my'
 import 'AST/InvokeMethod.my'
 import 'AST/LocalVariableAccessAmbiguous.my'
 import 'AST/LocalVariableAssignment.my'
-import 'AST/BlockLiteral.my'
 
 import 'AST/Quest.my'
 import 'AST/BranchOperator.my'
+import 'AST/PipeOperator.my'
 
 # TODO: refactor and break out misc
 import "AST/misc.my"

data/lib/myco/code_tools/AST.my.rb

@@ -2,12 +2,12 @@
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
   ::Myco.find_constant(:CodeTools)::AST.component_eval {(
-    ::Myco.cscope.for_method_definition.const_set(:BuilderMethods, (::Myco.find_constant(:Module).new { || nil}))
-    ::Myco.cscope.for_method_definition.const_set(:Builder, ::Myco::Component.new([
+    ::Myco.cscope.for_method_definition::BuilderMethods = (::Myco.find_constant(:Module).new { || nil})
+    ::Myco.cscope.for_method_definition::Builder = ::Myco::Component.new([
       ::Myco.find_constant(:BasicObject),
       ::Myco.find_constant(:BuilderMethods)
     ], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-    .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}})
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}
     .tap { |__c__| __c__.__name__ = :Builder }
   )}
   declare_meme(:"AST/Node.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
@@ -16,15 +16,16 @@
   declare_meme(:"AST/SymbolLiteral.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:"AST/DynamicString.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:"AST/DynamicSymbol.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/Body.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"AST/Sequence.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:"AST/SplatValue.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:"AST/ArrayAssembly.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:"AST/KeywordAssembly.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:"AST/ArgumentAssembly.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:"AST/BlockArgument.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/BlockLiteral.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"AST/Block.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:"AST/BlockParameter.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:"AST/ParameterAssembly.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"AST/BlockLiteral.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:"AST/MycoModuleScope.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:"AST/ConstantAccess.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:"AST/ConstantAssignment.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
@@ -40,9 +41,9 @@
   declare_meme(:"AST/InvokeMethod.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:"AST/LocalVariableAccessAmbiguous.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:"AST/LocalVariableAssignment.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/BlockLiteral.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:"AST/Quest.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:"AST/BranchOperator.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"AST/PipeOperator.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:"AST/misc.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:"AST/ToRuby.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
 )}}.instance

data/lib/myco/code_tools/Parser.my.rb

@@ -8,13 +8,13 @@
   ::Myco::Pegleromyces = (::Myco.find_constant(:Pegleromyces))
   ::Myco.find_constant(:CodeTools)::Parser = ::Myco::Component.new([::Myco.find_constant(:BasicObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
   .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-    ::Myco.cscope.for_method_definition.const_set(:MycoGrammar, (::Myco.find_constant(:Myco).eval_file("parser/MycoGrammar.my")))
-    ::Myco.cscope.for_method_definition.const_set(:MycoBuilder, (::Myco.find_constant(:Myco).eval_file("parser/MycoBuilder.my")))
-    ::Myco.cscope.for_method_definition.const_set(:MycoParser, (::Myco::Component.new([::Myco.find_constant(:Pegleromyces)::BytecodeParser], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    ::Myco.cscope.for_method_definition::MycoGrammar = (::Myco.find_constant(:Myco).eval_file("parser/MycoGrammar.my"))
+    ::Myco.cscope.for_method_definition::MycoBuilder = (::Myco.find_constant(:Myco).eval_file("parser/MycoBuilder.my"))
+    ::Myco.cscope.for_method_definition::MycoParser = (::Myco::Component.new([::Myco.find_constant(:Pegleromyces)::BytecodeParser], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
     .tap { |__c__| __c__.__last__ = __c__.component_eval {(
       declare_meme(:grammar, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:MycoGrammar))}
       declare_meme(:new_builder, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:MycoBuilder))}
-    )}}.instance))
+    )}}.instance)
     declare_meme(:parse_string, [], nil, ::Myco.cscope.dup) { |string| (
       parser = ::Myco.find_constant(:MycoParser)
       parser.parse(string)

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

@@ -2,7 +2,7 @@
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco::Component.new([::Myco.find_constant(:BasicObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  ::Myco.cscope.for_method_definition.const_set(:ASTBuilder, (::CodeTools::AST::Builder.new))
+  ::Myco.cscope.for_method_definition::ASTBuilder = (::CodeTools::AST::Builder.new)
   declare_meme(:ast, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:ASTBuilder))}
   declare_meme(:escape_encodings, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (
     hash = ::Myco.find_constant(:Hash).new

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

@@ -1,6 +1,6 @@
 
 ::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(:MycoCharacterClasses, (::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::MycoCharacterClasses = (::Myco::Component.new([::Myco.find_constant(:Pegleromyces)::Grammar], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
   declare_meme(:eol_comment, [], nil, ::Myco.cscope.dup) { |*| (self.str("#").__send__(
     :+,
@@ -53,4 +53,4 @@
     :/,
     self.str("?")
   ))}
-)}}.instance)))}}.instance
+)}}.instance))}}.instance