myco 0.1.9 → 0.1.10

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

@@ -2,12 +2,24 @@
 ::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::StringLiteral = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:str, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:value, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
-    self.pos(g)
-    g.push_literal(self.value)
-    g.string_dup
-  )}
+  declare_meme(
+    :str,
+    [:node_type],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :value,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :bytecode,
+    [],
+    ::Object::Proc.new { |g| (
+      self.pos(g)
+      g.push_literal(self.value)
+      g.string_dup
+    )}
+  )
 )}}
 .tap { |__c__| __c__.__name__ = :StringLiteral })})}}.instance

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

@@ -2,22 +2,34 @@
 ::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::SymbolCompose = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:symbol_compose, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:body, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
-    self.pos(g)
-    self.body.each_slice(2) { |string, other| (
-      g.push_literal(string.value.to_s)
-      ::Myco.branch_op(:"&&", other) {(
-        other.bytecode(g)
-        g.meta_to_s
+  declare_meme(
+    :symbol_compose,
+    [:node_type],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :body,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :bytecode,
+    [],
+    ::Object::Proc.new { |g| (
+      self.pos(g)
+      self.body.each_slice(2) { |string, other| (
+        g.push_literal(string.value.to_s)
+        ::Myco.branch_op(:"&&", other) {(
+          other.bytecode(g)
+          g.meta_to_s
+        )}
       )}
+      g.string_build(self.body.size)
+      g.send(
+        :to_sym,
+        0
+      )
     )}
-    g.string_build(self.body.size)
-    g.send(
-      :to_sym,
-      0
-    )
-  )}
+  )
 )}}
 .tap { |__c__| __c__.__name__ = :SymbolCompose })})}}.instance

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

@@ -2,11 +2,23 @@
 ::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::SymbolLiteral = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:symbol, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:value, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
-    self.pos(g)
-    g.push_literal(self.value)
-  )}
+  declare_meme(
+    :symbol,
+    [:node_type],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :value,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :bytecode,
+    [],
+    ::Object::Proc.new { |g| (
+      self.pos(g)
+      g.push_literal(self.value)
+    )}
+  )
 )}}
 .tap { |__c__| __c__.__name__ = :SymbolLiteral })})}}.instance

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

@@ -3,368 +3,608 @@
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(
   ::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"))}
-    declare_meme(:add, [], nil, ::Myco.cscope.dup) { |*strings| (strings.each { |string| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", string.__send__(
-      :is_a?,
-      ::Myco.find_constant(:String)
-    )) {self.lines.last.concat(string.dup)}) {string.to_ruby(self)})})}
-    declare_meme(:line, [], nil, ::Myco.cscope.dup) { |*strings| (
-      self.lines.push(self.indents.last.dup)
-      self.add(*strings)
-    )}
-    declare_meme(:list, [], nil, ::Myco.cscope.dup) { |items, separator="", auto_lines:false, &block| (::Myco.branch_op(:"&&", items.__send__(:any?)) {(
-      items = items.dup
-      last_item = items.pop
-      use_lines = ::Myco.branch_op(:"&&", items.__send__(:any?)) {auto_lines}
-      ::Myco.branch_op(:"&&", use_lines) {self.push_indent}
-      items.each { |item| (
+    declare_meme(
+      :lines,
+      [:var],
+      ::Object::Proc.new { |*| ([""])}
+    )
+    declare_meme(
+      :to_s,
+      [],
+      ::Object::Proc.new { |*| (self.lines.join("\n"))}
+    )
+    declare_meme(
+      :add,
+      [],
+      ::Object::Proc.new { |*strings| (strings.each { |string| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", string.__send__(
+        :is_a?,
+        ::Myco.find_constant(:String)
+      )) {self.lines.last.concat(string.dup)}) {string.to_ruby(self)})})}
+    )
+    declare_meme(
+      :line,
+      [],
+      ::Object::Proc.new { |*strings| (
+        self.lines.push(self.indents.last.dup)
+        self.add(*strings)
+      )}
+    )
+    declare_meme(
+      :list,
+      [],
+      ::Object::Proc.new { |items, separator="", auto_lines:false, &block| (::Myco.branch_op(:"&&", items.__send__(:any?)) {(
+        items = items.dup
+        last_item = items.pop
+        use_lines = ::Myco.branch_op(:"&&", items.__send__(:any?)) {auto_lines}
+        ::Myco.branch_op(:"&&", use_lines) {self.push_indent}
+        items.each { |item| (
+          ::Myco.branch_op(:"&&", use_lines) {self.line}
+          ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", block) {block.call(item)}) {self.add(item)}
+          self.add(separator)
+        )}
+        ::Myco.branch_op(:"&&", use_lines) {self.line}
+        ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", block) {block.call(last_item)}) {self.add(last_item)}
+        ::Myco.branch_op(:"&&", use_lines) {self.pop_indent}
         ::Myco.branch_op(:"&&", use_lines) {self.line}
-        ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", block) {block.call(item)}) {self.add(item)}
-        self.add(separator)
+      )})}
+    )
+    declare_meme(
+      :indents,
+      [:var],
+      ::Object::Proc.new { |*| ([""])}
+    )
+    declare_meme(
+      :indent_amount,
+      [:var],
+      ::Object::Proc.new { |*| (2)}
+    )
+    declare_meme(
+      :pop_indent,
+      [],
+      ::Object::Proc.new { |*| (self.indents.pop)}
+    )
+    declare_meme(
+      :push_indent,
+      [],
+      ::Object::Proc.new { |amount=self.indent_amount| (self.indents.push(self.indents.last.__send__(
+        :+,
+        " ".__send__(
+          :*,
+          amount
+        )
+      )))}
+    )
+    declare_meme(
+      :var_scopes,
+      [:var],
+      ::Object::Proc.new { |*| ([])}
+    )
+    declare_meme(
+      :var_scope,
+      [],
+      ::Object::Proc.new { |*| (self.var_scopes.last)}
+    )
+    declare_meme(
+      :with_nested_var_scope,
+      [],
+      ::Object::Proc.new { |node, &block| (
+        self.var_scopes.push(node)
+        block.call
+        self.var_scopes.pop
       )}
-      ::Myco.branch_op(:"&&", use_lines) {self.line}
-      ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", block) {block.call(last_item)}) {self.add(last_item)}
-      ::Myco.branch_op(:"&&", use_lines) {self.pop_indent}
-      ::Myco.branch_op(:"&&", use_lines) {self.line}
-    )})}
-    declare_meme(:indents, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ([""])}
-    declare_meme(:indent_amount, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (2)}
-    declare_meme(:pop_indent, [], nil, ::Myco.cscope.dup) { |*| (self.indents.pop)}
-    declare_meme(:push_indent, [], nil, ::Myco.cscope.dup) { |amount=self.indent_amount| (self.indents.push(self.indents.last.__send__(
-      :+,
-      " ".__send__(
-        :*,
-        amount
-      )
-    )))}
-    declare_meme(:var_scopes, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ([])}
-    declare_meme(:var_scope, [], nil, ::Myco.cscope.dup) { |*| (self.var_scopes.last)}
-    declare_meme(:with_nested_var_scope, [], nil, ::Myco.cscope.dup) { |node, &block| (
-      self.var_scopes.push(node)
-      block.call
-      self.var_scopes.pop
-    )}
-    declare_meme(:var_scope_declare_local, [], nil, ::Myco.cscope.dup) { |name| (self.var_scope.variables.__send__(
-      :[]=,
-      name,
-      true
-    ))}
-    declare_meme(:var_scope_declare_locals, [], nil, ::Myco.cscope.dup) { |*names| (names.each { |name| (self.var_scope_declare_local(name))})}
-    declare_meme(:var_scope_has_local?, [], nil, ::Myco.cscope.dup) { |name| (self.var_scopes.reverse.detect { |scope| (scope.variables.__send__(
-      :has_key?,
-      name
-    ))}.__send__(:!).__send__(:!))}
-    declare_meme(:easy_ident?, [], nil, ::Myco.cscope.dup) { |sym| (
-      str = sym.to_s
-      ::Myco.branch_op(:"&&", str.__send__(
-        :=~,
-        ::Myco.find_constant(:Regexp).new("^[a-z_][A-Za-z_]*$")
-      )) {[
-        :if,
-        :unless,
-        :and,
-        :or,
-        :def,
-        :do,
-        :class,
-        :module,
-        :end,
-        :break,
-        :begin,
-        :rescue,
-        :ensure
-      ].__send__(
-        :include?,
-        sym
-      ).__send__(:!)}
-    )}
+    )
+    declare_meme(
+      :var_scope_declare_local,
+      [],
+      ::Object::Proc.new { |name| (self.var_scope.variables.__send__(
+        :[]=,
+        name,
+        true
+      ))}
+    )
+    declare_meme(
+      :var_scope_declare_locals,
+      [],
+      ::Object::Proc.new { |*names| (names.each { |name| (self.var_scope_declare_local(name))})}
+    )
+    declare_meme(
+      :var_scope_has_local?,
+      [],
+      ::Object::Proc.new { |name| (self.var_scopes.reverse.detect { |scope| (scope.variables.__send__(
+        :has_key?,
+        name
+      ))}.__send__(:!).__send__(:!))}
+    )
+    declare_meme(
+      :easy_ident?,
+      [],
+      ::Object::Proc.new { |sym| (
+        str = sym.to_s
+        ::Myco.branch_op(:"&&", str.__send__(
+          :=~,
+          ::Myco.find_constant(:Regexp).new("^[a-z_][A-Za-z_]*$")
+        )) {[
+          :if,
+          :unless,
+          :and,
+          :or,
+          :def,
+          :do,
+          :class,
+          :module,
+          :end,
+          :break,
+          :begin,
+          :rescue,
+          :ensure
+        ].__send__(
+          :include?,
+          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
-    self.to_ruby(g)
-    g.to_s
-  )})}
-  ::Myco.find_constant(:Self).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.add("self"))})}
-  ::Myco.find_constant(:NullLiteral).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.add("nil"))})}
-  ::Myco.find_constant(:VoidLiteral).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.add("::Myco::Void"))})}
-  ::Myco.find_constant(:TrueLiteral).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.add("true"))})}
-  ::Myco.find_constant(:FalseLiteral).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.add("false"))})}
-  ::Myco.find_constant(:NumericLiteral).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.add(self.value.inspect))})}
-  ::Myco.find_constant(:StringLiteral).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.add(self.value.inspect))})}
-  ::Myco.find_constant(:SymbolLiteral).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.add(self.value.inspect))})}
-  ::Myco.find_constant(:StringCompose).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
-    g.add("\"")
-    self.body.each_slice(2) { |string, to_string| (
-      g.add(string.value.to_s.inspect.slice(::Myco.find_constant(:Range).new(
-        1,
-        -2
-      )))
-      ::Myco.branch_op(:"&&", to_string) {(
-        g.add("\#{")
-        g.add(to_string)
-        g.add("}")
+  ::Myco.find_constant(:Node).component_eval {(declare_meme(
+    :to_ruby_code,
+    [],
+    ::Object::Proc.new { |*| (
+      g = ::Myco.find_constant(:ToRuby).new
+      self.to_ruby(g)
+      g.to_s
+    )}
+  ))}
+  ::Myco.find_constant(:Self).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (g.add("self"))}
+  ))}
+  ::Myco.find_constant(:NullLiteral).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (g.add("nil"))}
+  ))}
+  ::Myco.find_constant(:VoidLiteral).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (g.add("::Myco::Void"))}
+  ))}
+  ::Myco.find_constant(:TrueLiteral).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (g.add("true"))}
+  ))}
+  ::Myco.find_constant(:FalseLiteral).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (g.add("false"))}
+  ))}
+  ::Myco.find_constant(:NumericLiteral).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (g.add(self.value.inspect))}
+  ))}
+  ::Myco.find_constant(:StringLiteral).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (g.add(self.value.inspect))}
+  ))}
+  ::Myco.find_constant(:SymbolLiteral).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (g.add(self.value.inspect))}
+  ))}
+  ::Myco.find_constant(:StringCompose).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (
+      g.add("\"")
+      self.body.each_slice(2) { |string, to_string| (
+        g.add(string.value.to_s.inspect.slice(::Myco.find_constant(:Range).new(
+          1,
+          -2
+        )))
+        ::Myco.branch_op(:"&&", to_string) {(
+          g.add("\#{")
+          g.add(to_string)
+          g.add("}")
+        )}
       )}
+      g.add("\"")
     )}
-    g.add("\"")
-  )})}
-  ::Myco.find_constant(:SymbolCompose).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
-    g.add(":\"")
-    self.body.each_slice(2) { |string, to_string| (
-      g.add(string.value.to_s.inspect.slice(::Myco.find_constant(:Range).new(
-        1,
-        -2
-      )))
-      ::Myco.branch_op(:"&&", to_string) {(
-        g.add("\#{")
-        g.add(to_string)
-        g.add("}")
+  ))}
+  ::Myco.find_constant(:SymbolCompose).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (
+      g.add(":\"")
+      self.body.each_slice(2) { |string, to_string| (
+        g.add(string.value.to_s.inspect.slice(::Myco.find_constant(:Range).new(
+          1,
+          -2
+        )))
+        ::Myco.branch_op(:"&&", to_string) {(
+          g.add("\#{")
+          g.add(to_string)
+          g.add("}")
+        )}
       )}
+      g.add("\"")
     )}
-    g.add("\"")
-  )})}
-  ::Myco.find_constant(:ArrayAssembly).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
-    g.add("[")
-    g.list(
-      self.body,
-      ",",
-      {:auto_lines => true}
-    )
-    g.add("]")
-  )})}
-  ::Myco.find_constant(:KeywordAssembly).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
-    g.add("{")
-    g.list(
-      self.body.each_slice(2).to_a,
-      ",",
-      {:auto_lines => true}
-    ) { |pair| (g.add(
-      pair.first,
-      " => ",
-      pair.last
-    ))}
-    g.add("}")
-  )})}
-  ::Myco.find_constant(:ConstantAccess).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
-    name_list = self.names.map(&:to_sym)
-    first_name = name_list.shift
-    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.toplevel) {self.case(
-      first_name,
-      :Myco,
-      ::Object::Proc.new { || (g.add("::Myco"))},
-      :Ruby,
-      ::Object::Proc.new { || (g.add("::Object"))},
-      :Rubinius,
-      ::Object::Proc.new { || (g.add("::Rubinius"))},
-      ::Object::Proc.new { || (g.add("::Myco::#{first_name}"))}
-    )}) {g.add("::Myco.find_constant(#{first_name.inspect})")}
-    name_list.each { |name| (g.add("::#{name}"))}
-  )})}
-  ::Myco.find_constant(:ConstantAssignment).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
-    name_list = self.constant.names.map(&:to_sym)
-    last_name = name_list.pop
-    first_name = ::Myco.branch_op(:"&&", name_list.__send__(:any?)) {name_list.shift}
-    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.constant.toplevel) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", first_name) {self.case(
-      first_name,
-      :Myco,
-      ::Object::Proc.new { || (g.add("::Myco"))},
-      :Ruby,
-      ::Object::Proc.new { || (g.add("::Object"))},
-      :Rubinius,
-      ::Object::Proc.new { || (g.add("::Rubinius"))},
-      ::Object::Proc.new { || (g.add("::Myco::#{first_name}"))}
-    )}) {g.add("::Myco")}}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", first_name) {g.add("::Myco.find_constant(#{first_name.inspect})")}) {g.add("::Myco.cscope.for_method_definition")}}
-    name_list.each { |name| (g.add("::#{name}"))}
-    g.add("::#{last_name} = ")
-    g.add(self.value)
-  )})}
-  ::Myco.find_constant(:ConstantDefine).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
-    g.add(self.implementation)
-    g.line(".tap { |__c__| __c__.__name__ = ")
-    g.add(self.constant.names.last.inspect)
-    g.add(" }")
-  )})}
-  ::Myco.find_constant(:DeclareExtension).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
-    g.add(self.constant)
-    g.add(".component_eval {")
-    g.add(self.body)
-    g.add("}")
-  )})}
-  ::Myco.find_constant(:DeclaredScope).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.with_nested_var_scope(self) { || (g.add(self.body))})})}
-  ::Myco.find_constant(:Script).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.add(self.body))})}
-  ::Myco.find_constant(:DeclareFile).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
-    g.line
-    self.implementation.to_ruby(g)
-    g.line
-  )})}
-  ::Myco.find_constant(:DeclareObject).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
-    g.add("::Myco::Component.new(")
-    g.add(self.types)
-    g.add(", ::Myco.cscope.for_method_definition, __FILE__, __LINE__)")
-    g.line(".tap { |__c__| __c__.__last__ = __c__.component_eval {")
-    g.add(self.scope_implementation)
-    g.add("}}")
-    ::Myco.branch_op(:"&&", self.create) {g.add(".instance")}
-  )})}
-  ::Myco.find_constant(:DeclareString).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.add(self.implementation))})}
-  ::Myco.find_constant(:DeclareCategory).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
-    g.add("__category__(#{self.name.inspect})")
-    g.add(".component_eval {")
-    g.add(self.body)
-    g.add("}")
-  )})}
-  ::Myco.find_constant(:DeclareMeme).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
-    name = self.decorations.last
-    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", name.node_type.__send__(
-      :==,
-      :symbol
-    )) {(
-      g.add("declare_meme(")
+  ))}
+  ::Myco.find_constant(:ArrayAssembly).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (
+      g.add("[")
       g.list(
-        [
-          self.effective_name,
-          self.effective_decorations,
-          self.effective_body
-        ],
+        self.body,
         ",",
         {:auto_lines => true}
       )
-      g.add(")")
-    )}) {g.add(::Myco.find_constant(:ConstantAssignment).new({
-      :line => self.line,
-      :constant => self.effective_name,
-      :value => self.effective_body.block.body
-    }))}
-  )})}
-  ::Myco.find_constant(:RequiredParameter).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.add("#{self.name}"))})}
-  ::Myco.find_constant(:OptionalParameter).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
-    g.add("#{self.name}=")
-    g.add(self.value)
-  )})}
-  ::Myco.find_constant(:RestParameter).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.add("*#{self.name}"))})}
-  ::Myco.find_constant(:KeywordRequiredParameter).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.add("#{self.name}:"))})}
-  ::Myco.find_constant(:KeywordOptionalParameter).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
-    g.add("#{self.name}:")
-    g.add(self.value)
-  )})}
-  ::Myco.find_constant(:KeywordRestParameter).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.add("**#{self.name}"))})}
-  ::Myco.find_constant(:BlockParameter).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.add("&#{self.name}"))})}
-  ::Myco.find_constant(:ParameterAssembly).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
-    g.add("|")
-    g.list(
-      self.all_params,
-      ", "
-    )
-    g.add("|")
-  )})}
-  ::Myco.find_constant(:Sequence).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
-    g.add("(")
-    g.list(
-      self.array,
-      "",
-      {:auto_lines => true}
-    )
-    g.add(")")
-  )})}
-  ::Myco.find_constant(:Invoke).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (g.add(self.implementation))})}
-  ::Myco.find_constant(:InvokeMethod).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
-    list = ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.arguments) {self.arguments.body.dup}) {[]}
-    ::Myco.branch_op(:"&&", self.arguments.block.__send__(
-      :is_a?,
-      ::Myco.find_constant(:BlockArgument)
-    )) {list.push(self.arguments.block)}
-    g.add(self.receiver)
-    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", g.__send__(
-      :easy_ident?,
-      self.name
-    )) {g.add(".#{self.name}")}) {(
-      g.add(".__send__")
-      list.unshift(::Myco.find_constant(:SymbolLiteral).new({
+      g.add("]")
+    )}
+  ))}
+  ::Myco.find_constant(:KeywordAssembly).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (
+      g.add("{")
+      g.list(
+        self.body.each_slice(2).to_a,
+        ",",
+        {:auto_lines => true}
+      ) { |pair| (g.add(
+        pair.first,
+        " => ",
+        pair.last
+      ))}
+      g.add("}")
+    )}
+  ))}
+  ::Myco.find_constant(:ConstantAccess).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (
+      name_list = self.names.map(&:to_sym)
+      first_name = name_list.shift
+      ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.toplevel) {self.case(
+        first_name,
+        :Myco,
+        ::Object::Proc.new { |*| (g.add("::Myco"))},
+        :Ruby,
+        ::Object::Proc.new { |*| (g.add("::Object"))},
+        :Rubinius,
+        ::Object::Proc.new { |*| (g.add("::Rubinius"))},
+        ::Object::Proc.new { |*| (g.add("::Myco::#{first_name}"))}
+      )}) {g.add("::Myco.find_constant(#{first_name.inspect})")}
+      name_list.each { |name| (g.add("::#{name}"))}
+    )}
+  ))}
+  ::Myco.find_constant(:ConstantAssignment).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (
+      name_list = self.constant.names.map(&:to_sym)
+      last_name = name_list.pop
+      first_name = ::Myco.branch_op(:"&&", name_list.__send__(:any?)) {name_list.shift}
+      ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.constant.toplevel) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", first_name) {self.case(
+        first_name,
+        :Myco,
+        ::Object::Proc.new { |*| (g.add("::Myco"))},
+        :Ruby,
+        ::Object::Proc.new { |*| (g.add("::Object"))},
+        :Rubinius,
+        ::Object::Proc.new { |*| (g.add("::Rubinius"))},
+        ::Object::Proc.new { |*| (g.add("::Myco::#{first_name}"))}
+      )}) {g.add("::Myco")}}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", first_name) {g.add("::Myco.find_constant(#{first_name.inspect})")}) {g.add("::Myco.cscope.for_method_definition")}}
+      name_list.each { |name| (g.add("::#{name}"))}
+      g.add("::#{last_name} = ")
+      g.add(self.value)
+    )}
+  ))}
+  ::Myco.find_constant(:ConstantDefine).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (
+      g.add(self.implementation)
+      g.line(".tap { |__c__| __c__.__name__ = ")
+      g.add(self.constant.names.last.inspect)
+      g.add(" }")
+    )}
+  ))}
+  ::Myco.find_constant(:DeclareExtension).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (
+      g.add(self.constant)
+      g.add(".component_eval {")
+      g.add(self.body)
+      g.add("}")
+    )}
+  ))}
+  ::Myco.find_constant(:DeclaredScope).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (g.with_nested_var_scope(self) { |*| (g.add(self.body))})}
+  ))}
+  ::Myco.find_constant(:Script).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (g.add(self.body))}
+  ))}
+  ::Myco.find_constant(:DeclareFile).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (
+      g.line
+      self.implementation.to_ruby(g)
+      g.line
+    )}
+  ))}
+  ::Myco.find_constant(:DeclareObject).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (
+      g.add("::Myco::Component.new(")
+      g.add(self.types)
+      g.add(", ::Myco.cscope.for_method_definition, __FILE__, __LINE__)")
+      g.line(".tap { |__c__| __c__.__last__ = __c__.component_eval {")
+      g.add(self.scope_implementation)
+      g.add("}}")
+      ::Myco.branch_op(:"&&", self.create) {g.add(".instance")}
+    )}
+  ))}
+  ::Myco.find_constant(:DeclareString).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (g.add(self.implementation))}
+  ))}
+  ::Myco.find_constant(:DeclareCategory).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (
+      g.add("__category__(#{self.name.inspect})")
+      g.add(".component_eval {")
+      g.add(self.body)
+      g.add("}")
+    )}
+  ))}
+  ::Myco.find_constant(:DeclareMeme).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (
+      name = self.decorations.last
+      ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", name.node_type.__send__(
+        :==,
+        :symbol
+      )) {(
+        g.add("declare_meme(")
+        g.list(
+          [
+            self.effective_name,
+            self.effective_decorations,
+            self.effective_body
+          ],
+          ",",
+          {:auto_lines => true}
+        )
+        g.add(")")
+      )}) {g.add(::Myco.find_constant(:ConstantAssignment).new({
         :line => self.line,
-        :value => self.name
-      }))
+        :constant => self.effective_name,
+        :value => self.effective_body.block.body
+      }))}
+    )}
+  ))}
+  ::Myco.find_constant(:RequiredParameter).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (g.add("#{self.name}"))}
+  ))}
+  ::Myco.find_constant(:OptionalParameter).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (
+      g.add("#{self.name}=")
+      g.add(self.value)
     )}
-    ::Myco.branch_op(:"&&", list.__send__(:any?)) {(
+  ))}
+  ::Myco.find_constant(:RestParameter).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (g.add("*#{self.name}"))}
+  ))}
+  ::Myco.find_constant(:KeywordRequiredParameter).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (g.add("#{self.name}:"))}
+  ))}
+  ::Myco.find_constant(:KeywordOptionalParameter).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (
+      g.add("#{self.name}:")
+      g.add(self.value)
+    )}
+  ))}
+  ::Myco.find_constant(:KeywordRestParameter).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (g.add("**#{self.name}"))}
+  ))}
+  ::Myco.find_constant(:BlockParameter).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (g.add("&#{self.name}"))}
+  ))}
+  ::Myco.find_constant(:ParameterAssembly).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (
+      g.add("|")
+      g.list(
+        self.all_params,
+        ", "
+      )
+      g.add("|")
+    )}
+  ))}
+  ::Myco.find_constant(:Sequence).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (
       g.add("(")
       g.list(
-        list,
-        ",",
+        self.array,
+        "",
         {:auto_lines => true}
       )
       g.add(")")
     )}
-    ::Myco.branch_op(:"&&", self.arguments.block.__send__(
+  ))}
+  ::Myco.find_constant(:Invoke).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (g.add(self.implementation))}
+  ))}
+  ::Myco.find_constant(:InvokeMethod).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (
+      list = ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.arguments) {self.arguments.body.dup}) {[]}
+      ::Myco.branch_op(:"&&", self.arguments.block.__send__(
+        :is_a?,
+        ::Myco.find_constant(:BlockArgument)
+      )) {list.push(self.arguments.block)}
+      g.add(self.receiver)
+      ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", g.__send__(
+        :easy_ident?,
+        self.name
+      )) {g.add(".#{self.name}")}) {(
+        g.add(".__send__")
+        list.unshift(::Myco.find_constant(:SymbolLiteral).new({
+          :line => self.line,
+          :value => self.name
+        }))
+      )}
+      ::Myco.branch_op(:"&&", list.__send__(:any?)) {(
+        g.add("(")
+        g.list(
+          list,
+          ",",
+          {:auto_lines => true}
+        )
+        g.add(")")
+      )}
+      ::Myco.branch_op(:"&&", self.arguments.block.__send__(
+        :is_a?,
+        ::Myco.find_constant(:Block)
+      )) {(
+        g.add(" {")
+        g.add(self.arguments.block)
+        g.add("}")
+      )}
+    )}
+  ))}
+  ::Myco.find_constant(:LocalVariableAssignment).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (
+      g.var_scope_declare_local(self.name)
+      g.var_scope.variables.__send__(
+        :[]=,
+        self.name,
+        true
+      )
+      g.add(self.name.to_s)
+      g.add(" = ")
+      g.add(self.value)
+    )}
+  ))}
+  ::Myco.find_constant(:LocalVariableAccessAmbiguous).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", g.__send__(
+      :var_scope_has_local?,
+      self.name
+    )) {g.add(self.name.to_s)}) {(
+      g.add("self")
+      ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", g.__send__(
+        :easy_ident?,
+        self.name
+      )) {g.add(".#{self.name}")}) {g.add(".__send__(#{self.name.inspect})")}
+    )})}
+  ))}
+  ::Myco.find_constant(:SplatValue).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.value.__send__(
       :is_a?,
-      ::Myco.find_constant(:Block)
-    )) {(
-      g.add(" {")
-      g.add(self.arguments.block)
+      self.__send__(:class)
+    )) {self.value.to_ruby(g)}) {(
+      g.add("*")
+      self.value.to_ruby(g)
+    )})}
+  ))}
+  ::Myco.find_constant(:BlockArgument).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (
+      g.add("&")
+      g.add(self.body)
+    )}
+  ))}
+  ::Myco.find_constant(:Block).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (g.with_nested_var_scope(self) { |*| (
+      g.var_scope_declare_locals(*self.effective_parameters.names)
+      g.add(" ")
+      g.add(self.effective_parameters)
+      g.add(" ")
+      g.add(self.body)
+    )})}
+  ))}
+  ::Myco.find_constant(:BlockLiteral).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (g.add(self.implementation))}
+  ))}
+  ::Myco.find_constant(:Quest).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (
+      associated_questable = self.questable.dup
+      associated_questable.__send__(
+        :receiver=,
+        self.receiver
+      )
+      g.add("(")
+      g.add("Rubinius::Type.object_respond_to?(")
+      g.add(self.receiver)
+      g.add(", #{self.questable.name.inspect}).false?")
+      g.add(" ? ::Myco::Void : ")
+      g.add(associated_questable)
+      g.add(")")
+    )}
+  ))}
+  ::Myco.find_constant(:BranchOperator).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (
+      g.add("::Myco.branch_op(")
+      g.add(self.type.inspect)
+      g.add(", ")
+      g.add(self.left)
+      g.add(") {")
+      g.add(self.right)
       g.add("}")
     )}
-  )})}
-  ::Myco.find_constant(:LocalVariableAssignment).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
-    g.var_scope_declare_local(self.name)
-    g.var_scope.variables.__send__(
-      :[]=,
-      self.name,
-      true
-    )
-    g.add(self.name.to_s)
-    g.add(" = ")
-    g.add(self.value)
-  )})}
-  ::Myco.find_constant(:LocalVariableAccessAmbiguous).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", g.__send__(
-    :var_scope_has_local?,
-    self.name
-  )) {g.add(self.name.to_s)}) {(
-    g.add("self")
-    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", g.__send__(
-      :easy_ident?,
-      self.name
-    )) {g.add(".#{self.name}")}) {g.add(".__send__(#{self.name.inspect})")}
-  )})})}
-  ::Myco.find_constant(:SplatValue).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.value.__send__(
-    :is_a?,
-    self.__send__(:class)
-  )) {self.value.to_ruby(g)}) {(
-    g.add("*")
-    self.value.to_ruby(g)
-  )})})}
-  ::Myco.find_constant(:BlockArgument).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
-    g.add("&")
-    g.add(self.body)
-  )})}
-  ::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.effective_parameters.names)
-    g.add(" ")
-    g.add(self.effective_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__(
-      :receiver=,
-      self.receiver
-    )
-    g.add("(")
-    g.add("Rubinius::Type.object_respond_to?(")
-    g.add(self.receiver)
-    g.add(", #{self.questable.name.inspect}).false?")
-    g.add(" ? ::Myco::Void : ")
-    g.add(associated_questable)
-    g.add(")")
-  )})}
-  ::Myco.find_constant(:BranchOperator).component_eval {(declare_meme(:to_ruby, [], nil, ::Myco.cscope.dup) { |g| (
-    g.add("::Myco.branch_op(")
-    g.add(self.type.inspect)
-    g.add(", ")
-    g.add(self.left)
-    g.add(") {")
-    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))})}
+  ))}
+  ::Myco.find_constant(:PipeOperator).component_eval {(declare_meme(
+    :to_ruby,
+    [],
+    ::Object::Proc.new { |g| (g.add(self.implementation))}
+  ))}
 )})}}.instance