myco 0.1.9 → 0.1.10

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

@@ -5,65 +5,109 @@
   ::Myco.find_constant(:Common)::Patterns::ShorthandMethods
 ], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:rule_table, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Object::Hash.new)}
-  declare_meme(:construct_all_rules, [], nil, ::Myco.cscope.dup) { |*| (
-    self.rules.memes.each { |name, meme| (::Myco.branch_op(:"&&", meme.name.to_s.__send__(
-      :include?,
-      "root"
-    )) {meme.result_for(self.rules).inner.construct})}
-    seen_keys = []
-    self.loop { || (
-      new_keys = self.rule_table.keys.__send__(
-        :-,
-        seen_keys
-      )
-      ::Myco.branch_op(:"&&", new_keys.__send__(:empty?)) {self.__send__(:break)}
-      new_keys.each { |key| (
-        self.rule_table.__send__(
-          :[],
-          key
-        ).inner.construct
-        seen_keys.push(key)
-      )}
-    )}
-  )}
-  __category__(:decorators).component_eval {(
-    declare_meme(:token, [[:const, []]], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Decorator)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-    .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-      declare_meme(:apply, [], nil, ::Myco.cscope.dup) { |meme| (
-        orig_meme = meme.dup
-        meme.__send__(
-          :body=,
-          ::Object::Proc.new { || (orig_meme.result.token(:"t_#{meme.name}"))}
+  declare_meme(
+    :rule_table,
+    [:var],
+    ::Object::Proc.new { |*| (::Object::Hash.new)}
+  )
+  declare_meme(
+    :construct_all_rules,
+    [],
+    ::Object::Proc.new { |*| (
+      self.rules.memes.each { |name, meme| (::Myco.branch_op(:"&&", meme.name.to_s.__send__(
+        :include?,
+        "root"
+      )) {meme.result_for(self.rules).inner.construct})}
+      seen_keys = []
+      self.loop { |*| (
+        new_keys = self.rule_table.keys.__send__(
+          :-,
+          seen_keys
         )
-      )}
-      __category__(:transforms).component_eval {(declare_meme(:cache, [], nil, ::Myco.cscope.dup) { |*| (true)})}
-    )}}.instance)}
-    declare_meme(:rule, [[:const, []]], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Decorator)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-    .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-      declare_meme(:apply, [], nil, ::Myco.cscope.dup) { |meme| (
-        name = meme.name
-        meme.target.declare_meme(
-          name,
-          [:memoize]
-        ) { || (
-          outer_self = self
-          rule = ::Myco::Component.new([::Myco.find_constant(:Capture)::Patterns::RuleCall], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-          .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-            declare_meme(:name, [], nil, ::Myco.cscope.dup) { |*| (name)}
-            declare_meme(:inner, [], nil, ::Myco.cscope.dup) { |*| (meme.result_for(outer_self))}
-          )}}.instance
+        ::Myco.branch_op(:"&&", new_keys.__send__(:empty?)) {self.__send__(:break)}
+        new_keys.each { |key| (
           self.rule_table.__send__(
-            :[]=,
-            name,
-            rule
-          )
-          rule
+            :[],
+            key
+          ).inner.construct
+          seen_keys.push(key)
         )}
       )}
-      __category__(:transforms).component_eval {(declare_meme(:expose, [], nil, ::Myco.cscope.dup) { |*| (false)})}
-    )}}.instance)}
+    )}
+  )
+  __category__(:decorators).component_eval {(
+    declare_meme(
+      :token,
+      [:const],
+      ::Object::Proc.new { |*| (::Myco::Component.new([::Myco.find_constant(:Decorator)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+      .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+        declare_meme(
+          :apply,
+          [],
+          ::Object::Proc.new { |meme| (
+            orig_meme = meme.dup
+            meme.__send__(
+              :body=,
+              ::Object::Proc.new { |*| (orig_meme.result.token(:"t_#{meme.name}"))}
+            )
+          )}
+        )
+        __category__(:transforms).component_eval {(declare_meme(
+          :cache,
+          [],
+          ::Object::Proc.new { |*| (true)}
+        ))}
+      )}}.instance)}
+    )
+    declare_meme(
+      :rule,
+      [:const],
+      ::Object::Proc.new { |*| (::Myco::Component.new([::Myco.find_constant(:Decorator)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+      .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+        declare_meme(
+          :apply,
+          [],
+          ::Object::Proc.new { |meme| (
+            name = meme.name
+            meme.target.declare_meme(
+              name,
+              [:memoize]
+            ) { |*| (
+              outer_self = self
+              rule = ::Myco::Component.new([::Myco.find_constant(:Capture)::Patterns::RuleCall], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+              .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+                declare_meme(
+                  :name,
+                  [],
+                  ::Object::Proc.new { |*| (name)}
+                )
+                declare_meme(
+                  :inner,
+                  [],
+                  ::Object::Proc.new { |*| (meme.result_for(outer_self))}
+                )
+              )}}.instance
+              self.rule_table.__send__(
+                :[]=,
+                name,
+                rule
+              )
+              rule
+            )}
+          )}
+        )
+        __category__(:transforms).component_eval {(declare_meme(
+          :expose,
+          [],
+          ::Object::Proc.new { |*| (false)}
+        ))}
+      )}}.instance)}
+    )
   )}
-  __category__(:rules).component_eval {(declare_meme(:root, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:String)::Patterns::AnyCharacter.new.__send__(:*))})}
+  __category__(:rules).component_eval {(declare_meme(
+    :root,
+    [:rule],
+    ::Object::Proc.new { |*| (::Myco.find_constant(:String)::Patterns::AnyCharacter.new.__send__(:*))}
+  ))}
 )}}
 .tap { |__c__| __c__.__name__ = :Grammar })}}.instance

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

@@ -2,358 +2,526 @@
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.cscope.for_method_definition::Processor = ::Myco::Component.new([::Myco.find_constant(:BasicObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:string, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ("")}
-  declare_meme(:capture_items, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ([])}
-  declare_meme(:builder, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (nil)}
-  declare_meme(:process, [], nil, ::Myco.cscope.dup) { |*| (
-    self.setup
-    self.process_each
-    self.validate_state
-    self.final_captures
-  )}
+  declare_meme(
+    :string,
+    [:var],
+    ::Object::Proc.new { |*| ("")}
+  )
+  declare_meme(
+    :capture_items,
+    [:var],
+    ::Object::Proc.new { |*| ([])}
+  )
+  declare_meme(
+    :builder,
+    [:var],
+    ::Object::Proc.new { |*| (nil)}
+  )
+  declare_meme(
+    :process,
+    [],
+    ::Object::Proc.new { |*| (
+      self.setup
+      self.process_each
+      self.validate_state
+      self.final_captures
+    )}
+  )
   ::Myco.cscope.for_method_definition::Token = ::Myco::Component.new([::Myco.find_constant(:BasicObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
   .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-    declare_meme(:type, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-    declare_meme(:text, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-    declare_meme(:row, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-    declare_meme(:col, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-    declare_meme(:inspect, [], nil, ::Myco.cscope.dup) { |*| ([
-      self.type,
-      self.text,
-      self.row,
-      self.col
-    ].inspect)}
-    declare_meme(:to_s, [], nil, ::Myco.cscope.dup) { |*| ([
-      self.type,
-      self.text,
-      self.row,
-      self.col
-    ].inspect)}
-    declare_meme(:line, [], nil, ::Myco.cscope.dup) { |*| (self.row)}
-    declare_meme(:sym, [], nil, ::Myco.cscope.dup) { |*| (self.text.to_sym)}
-    declare_meme(:float, [], nil, ::Myco.cscope.dup) { |*| (self.text.to_f)}
-    declare_meme(:integer, [], nil, ::Myco.cscope.dup) { |base=0| (self.text.to_inum(
-      base,
-      true
-    ))}
+    declare_meme(
+      :type,
+      [:var],
+      ::Object::Proc.new { |*| nil}
+    )
+    declare_meme(
+      :text,
+      [:var],
+      ::Object::Proc.new { |*| nil}
+    )
+    declare_meme(
+      :row,
+      [:var],
+      ::Object::Proc.new { |*| nil}
+    )
+    declare_meme(
+      :col,
+      [:var],
+      ::Object::Proc.new { |*| nil}
+    )
+    declare_meme(
+      :inspect,
+      [],
+      ::Object::Proc.new { |*| ([
+        self.type,
+        self.text,
+        self.row,
+        self.col
+      ].inspect)}
+    )
+    declare_meme(
+      :to_s,
+      [],
+      ::Object::Proc.new { |*| ([
+        self.type,
+        self.text,
+        self.row,
+        self.col
+      ].inspect)}
+    )
+    declare_meme(
+      :line,
+      [],
+      ::Object::Proc.new { |*| (self.row)}
+    )
+    declare_meme(
+      :sym,
+      [],
+      ::Object::Proc.new { |*| (self.text.to_sym)}
+    )
+    declare_meme(
+      :float,
+      [],
+      ::Object::Proc.new { |*| (self.text.to_f)}
+    )
+    declare_meme(
+      :integer,
+      [],
+      ::Object::Proc.new { |base=0| (self.text.to_inum(
+        base,
+        true
+      ))}
+    )
   )}}
   .tap { |__c__| __c__.__name__ = :Token }
-  declare_meme(:tokenizer, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Object::Proc.new { |type, source, start, stop| (
-    pos = self.position_of(
-      start,
-      source
-    )
-    value = ::Myco.find_constant(:Token).new({
-      :type => type,
-      :text => source.slice(
+  declare_meme(
+    :tokenizer,
+    [:var],
+    ::Object::Proc.new { |*| (::Object::Proc.new { |type, source, start, stop| (
+      pos = self.position_of(
         start,
-        stop.__send__(
-          :-,
-          start
+        source
+      )
+      value = ::Myco.find_constant(:Token).new({
+        :type => type,
+        :text => source.slice(
+          start,
+          stop.__send__(
+            :-,
+            start
+          )
+        ),
+        :row => pos.first,
+        :col => pos.last
+      })
+    )})}
+  )
+  declare_meme(
+    :reduction_env,
+    [:var],
+    ::Object::Proc.new { |*| (::Myco.find_constant(:Capture)::Patterns::Reduction::Environment.new)}
+  )
+  declare_meme(
+    :reduction_env_cscope,
+    [:var],
+    ::Object::Proc.new { |*| (::Rubinius::ConstantScope.new(::Myco.find_constant(:Capture)::Patterns::Reduction::Environment))}
+  )
+  declare_meme(
+    :cidx_stack,
+    [:var],
+    ::Object::Proc.new { |*| ([])}
+  )
+  declare_meme(
+    :sidx_stack,
+    [:var],
+    ::Object::Proc.new { |*| ([])}
+  )
+  declare_meme(
+    :tidx_stack,
+    [:var],
+    ::Object::Proc.new { |*| ([])}
+  )
+  declare_meme(
+    :midx_stack,
+    [:var],
+    ::Object::Proc.new { |*| ([])}
+  )
+  declare_meme(
+    :ridx_stack,
+    [:var],
+    ::Object::Proc.new { |*| ([])}
+  )
+  declare_meme(
+    :capt_stack,
+    [:var],
+    ::Object::Proc.new { |*| ([])}
+  )
+  declare_meme(
+    :line_map_for,
+    [:memoize],
+    ::Object::Proc.new { |string| (
+      idx_hash = ::Object::Hash.new
+      idx_hash.__send__(
+        :[]=,
+        0,
+        0
+      )
+      count = 0
+      idx = -1
+      self.loop { |*| (
+        idx = string.index(
+          "\n",
+          idx.__send__(
+            :+,
+            1
+          )
         )
-      ),
-      :row => pos.first,
-      :col => pos.last
-    })
-  )})}
-  declare_meme(:reduction_env, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Capture)::Patterns::Reduction::Environment.new)}
-  declare_meme(:reduction_env_cscope, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Rubinius::ConstantScope.new(::Myco.find_constant(:Capture)::Patterns::Reduction::Environment))}
-  declare_meme(:cidx_stack, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ([])}
-  declare_meme(:sidx_stack, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ([])}
-  declare_meme(:tidx_stack, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ([])}
-  declare_meme(:midx_stack, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ([])}
-  declare_meme(:ridx_stack, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ([])}
-  declare_meme(:capt_stack, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ([])}
-  declare_meme(:line_map_for, [[:memoize, []]], nil, ::Myco.cscope.dup) { |string| (
-    idx_hash = ::Object::Hash.new
-    idx_hash.__send__(
-      :[]=,
-      0,
-      0
-    )
-    count = 0
-    idx = -1
-    self.loop { || (
-      idx = string.index(
-        "\n",
-        idx.__send__(
+        ::Myco.branch_op(:"||", idx) {self.__send__(:break)}
+        count = count.__send__(
           :+,
           1
         )
-      )
-      ::Myco.branch_op(:"||", idx) {self.__send__(:break)}
-      count = count.__send__(
+        idx_hash.__send__(
+          :[]=,
+          idx,
+          count
+        )
+      )}
+      idx_hash
+    )}
+  )
+  declare_meme(
+    :position_of,
+    [],
+    ::Object::Proc.new { |idx, string| (
+      nl_idx = ::Myco.branch_op(:"||", string.rindex(
+        "\n",
+        idx
+      )) {0}
+      row = self.line_map_for(string).fetch(nl_idx).__send__(
         :+,
         1
       )
-      idx_hash.__send__(
-        :[]=,
+      col = idx.__send__(
+        :-,
+        nl_idx
+      )
+      [
+        row,
+        col
+      ]
+    )}
+  )
+  declare_meme(
+    :push_layer,
+    [],
+    ::Object::Proc.new { |*| (self.capt_stack.push(::Object::Hash.new))}
+  )
+  declare_meme(
+    :pop_layer,
+    [],
+    ::Object::Proc.new { |*| (self.capt_stack.pop)}
+  )
+  declare_meme(
+    :setup,
+    [],
+    ::Object::Proc.new { |*| (self.push_layer)}
+  )
+  declare_meme(
+    :final_captures,
+    [],
+    ::Object::Proc.new { |*| (self.pop_layer.select { |k, v| (k.__send__(
+      :is_a?,
+      ::Myco.find_constant(:Symbol)
+    ))}.map { |k, v| ([
+      k,
+      v.last
+    ])}.to_h)}
+  )
+  declare_meme(
+    :process_each,
+    [],
+    ::Object::Proc.new { |*| (self.capture_items.each { |idx, metadata| (
+      type = metadata.__send__(
+        :[],
+        0
+      )
+      captargs = ::Myco.branch_op(:"||", metadata.__send__(
+        :[],
+        1
+      )) {[]}
+      self.send(
+        type,
         idx,
-        count
+        *captargs
       )
+    )})}
+  )
+  declare_meme(
+    :validate_state,
+    [],
+    ::Object::Proc.new { |*| (
+      ::Myco.branch_op(:"||", self.cidx_stack.__send__(:empty?)) {self.raise("unbalanced cidx_stack: #{self.cidx_stack}")}
+      ::Myco.branch_op(:"||", self.sidx_stack.__send__(:empty?)) {self.raise("unbalanced sidx_stack: #{self.sidx_stack}")}
+      ::Myco.branch_op(:"||", self.tidx_stack.__send__(:empty?)) {self.raise("unbalanced tidx_stack: #{self.tidx_stack}")}
+      ::Myco.branch_op(:"||", self.midx_stack.__send__(:empty?)) {self.raise("unbalanced midx_stack: #{self.midx_stack}")}
+      ::Myco.branch_op(:"||", self.ridx_stack.__send__(:empty?)) {self.raise("unbalanced ridx_stack: #{self.ridx_stack}")}
     )}
-    idx_hash
-  )}
-  declare_meme(:position_of, [], nil, ::Myco.cscope.dup) { |idx, string| (
-    nl_idx = ::Myco.branch_op(:"||", string.rindex(
-      "\n",
-      idx
-    )) {0}
-    row = self.line_map_for(string).fetch(nl_idx).__send__(
-      :+,
-      1
-    )
-    col = idx.__send__(
-      :-,
-      nl_idx
-    )
-    [
-      row,
-      col
-    ]
-  )}
-  declare_meme(:push_layer, [], nil, ::Myco.cscope.dup) { |*| (self.capt_stack.push(::Object::Hash.new))}
-  declare_meme(:pop_layer, [], nil, ::Myco.cscope.dup) { |*| (self.capt_stack.pop)}
-  declare_meme(:setup, [], nil, ::Myco.cscope.dup) { |*| (self.push_layer)}
-  declare_meme(:final_captures, [], nil, ::Myco.cscope.dup) { |*| (self.pop_layer.select { |k, v| (k.__send__(
-    :is_a?,
-    ::Myco.find_constant(:Symbol)
-  ))}.map { |k, v| ([
-    k,
-    v.last
-  ])}.to_h)}
-  declare_meme(:process_each, [], nil, ::Myco.cscope.dup) { |*| (self.capture_items.each { |idx, metadata| (
-    type = metadata.__send__(
-      :[],
-      0
-    )
-    captargs = ::Myco.branch_op(:"||", metadata.__send__(
-      :[],
-      1
-    )) {[]}
-    self.send(
-      type,
-      idx,
-      *captargs
-    )
-  )})}
-  declare_meme(:validate_state, [], nil, ::Myco.cscope.dup) { |*| (
-    ::Myco.branch_op(:"||", self.cidx_stack.__send__(:empty?)) {self.raise("unbalanced cidx_stack: #{self.cidx_stack}")}
-    ::Myco.branch_op(:"||", self.sidx_stack.__send__(:empty?)) {self.raise("unbalanced sidx_stack: #{self.sidx_stack}")}
-    ::Myco.branch_op(:"||", self.tidx_stack.__send__(:empty?)) {self.raise("unbalanced tidx_stack: #{self.tidx_stack}")}
-    ::Myco.branch_op(:"||", self.midx_stack.__send__(:empty?)) {self.raise("unbalanced midx_stack: #{self.midx_stack}")}
-    ::Myco.branch_op(:"||", self.ridx_stack.__send__(:empty?)) {self.raise("unbalanced ridx_stack: #{self.ridx_stack}")}
-  )}
-  declare_meme(:c_start, [], nil, ::Myco.cscope.dup) { |idx| (self.cidx_stack.push(idx))}
-  declare_meme(:c_end, [], nil, ::Myco.cscope.dup) { |idx, name| (
-    captures = self.capt_stack.last
-    start_idx = self.cidx_stack.pop
-    use_reduction = false
-    value = captures.__send__(
-      :[],
-      idx
-    )
-    ::Myco.branch_op(:"&?", value) {(
-      loc = value.first
-      value = value.last
-      ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", ::Myco.branch_op(:"&&", loc.first.__send__(
-        :>=,
-        start_idx
-      )) {loc.last.__send__(
-        :<=,
+  )
+  declare_meme(
+    :c_start,
+    [],
+    ::Object::Proc.new { |idx| (self.cidx_stack.push(idx))}
+  )
+  declare_meme(
+    :c_end,
+    [],
+    ::Object::Proc.new { |idx, name| (
+      captures = self.capt_stack.last
+      start_idx = self.cidx_stack.pop
+      use_reduction = false
+      value = captures.__send__(
+        :[],
         idx
-      )}) {use_reduction = true}) {value = nil}
-    )}
-    ::Myco.branch_op(:"&&", ::Myco.branch_op(:"&&", use_reduction.__send__(:!)) {start_idx.__send__(
-      :==,
-      idx
-    ).__send__(:!)}) {(
-      size = idx.__send__(
-        :-,
-        start_idx
       )
-      value = ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", size.__send__(
+      ::Myco.branch_op(:"&?", value) {(
+        loc = value.first
+        value = value.last
+        ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", ::Myco.branch_op(:"&&", loc.first.__send__(
+          :>=,
+          start_idx
+        )) {loc.last.__send__(
+          :<=,
+          idx
+        )}) {use_reduction = true}) {value = nil}
+      )}
+      ::Myco.branch_op(:"&&", ::Myco.branch_op(:"&&", use_reduction.__send__(:!)) {start_idx.__send__(
         :==,
-        1
-      )) {self.string.__send__(
-        :[],
-        start_idx
-      )}) {self.string.slice(
-        start_idx,
-        size
+        idx
+      ).__send__(:!)}) {(
+        size = idx.__send__(
+          :-,
+          start_idx
+        )
+        value = ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", size.__send__(
+          :==,
+          1
+        )) {self.string.__send__(
+          :[],
+          start_idx
+        )}) {self.string.slice(
+          start_idx,
+          size
+        )}
       )}
+      store_value = [
+        [
+          start_idx,
+          idx
+        ],
+        value
+      ]
+      captures.store(
+        idx,
+        store_value
+      )
+      captures.store(
+        name,
+        store_value
+      )
     )}
-    store_value = [
-      [
+  )
+  declare_meme(
+    :s_start,
+    [],
+    ::Object::Proc.new { |idx| (self.sidx_stack.push(idx))}
+  )
+  declare_meme(
+    :s_end,
+    [],
+    ::Object::Proc.new { |idx, name| (
+      captures = self.capt_stack.last
+      start_idx = self.sidx_stack.pop
+      value = self.string.slice(
         start_idx,
-        idx
-      ],
-      value
-    ]
-    captures.store(
-      idx,
-      store_value
-    )
-    captures.store(
-      name,
-      store_value
-    )
-  )}
-  declare_meme(:s_start, [], nil, ::Myco.cscope.dup) { |idx| (self.sidx_stack.push(idx))}
-  declare_meme(:s_end, [], nil, ::Myco.cscope.dup) { |idx, name| (
-    captures = self.capt_stack.last
-    start_idx = self.sidx_stack.pop
-    value = self.string.slice(
-      start_idx,
-      idx.__send__(
-        :-,
-        start_idx
+        idx.__send__(
+          :-,
+          start_idx
+        )
       )
-    )
-    store_value = [
-      [
-        start_idx,
-        idx
-      ],
-      value
-    ]
-    captures.store(
-      idx,
-      store_value
-    )
-    captures.store(
-      name,
-      store_value
-    )
-  )}
-  declare_meme(:t_start, [], nil, ::Myco.cscope.dup) { |idx| (self.tidx_stack.push(idx))}
-  declare_meme(:t_end, [], nil, ::Myco.cscope.dup) { |idx, name| (
-    captures = self.capt_stack.last
-    start_idx = self.tidx_stack.pop
-    value = self.tokenizer.call(
-      name,
-      self.string,
-      start_idx,
-      idx
-    )
-    store_value = [
-      [
+      store_value = [
+        [
+          start_idx,
+          idx
+        ],
+        value
+      ]
+      captures.store(
+        idx,
+        store_value
+      )
+      captures.store(
+        name,
+        store_value
+      )
+    )}
+  )
+  declare_meme(
+    :t_start,
+    [],
+    ::Object::Proc.new { |idx| (self.tidx_stack.push(idx))}
+  )
+  declare_meme(
+    :t_end,
+    [],
+    ::Object::Proc.new { |idx, name| (
+      captures = self.capt_stack.last
+      start_idx = self.tidx_stack.pop
+      value = self.tokenizer.call(
+        name,
+        self.string,
         start_idx,
         idx
-      ],
-      value
-    ]
-    captures.store(
-      idx,
-      store_value
-    )
-    captures.store(
-      name,
-      store_value
-    )
-  )}
-  declare_meme(:m_start, [], nil, ::Myco.cscope.dup) { |idx| (
-    self.midx_stack.push(idx)
-    self.c_start(idx)
-  )}
-  declare_meme(:m_split, [], nil, ::Myco.cscope.dup) { |idx, name| (
-    self.c_end(
-      idx,
-      name
-    )
-    self.c_start(idx)
-  )}
-  declare_meme(:m_end, [], nil, ::Myco.cscope.dup) { |idx, name| (
-    captures = self.capt_stack.last
-    start_idx = self.midx_stack.pop
-    self.cidx_stack.pop
-    value = []
-    captures.each { |k, v| (::Myco.branch_op(:"&&", ::Myco.branch_op(:"&&", ::Myco.branch_op(:"&&", k.__send__(
-      :is_a?,
-      ::Myco.find_constant(:Fixnum)
-    )) {k.__send__(
-      :<=,
-      idx
-    )}) {k.__send__(
-      :>,
-      start_idx
-    )}) {(
-      loc = v.first
-      ::Myco.branch_op(:"&&", loc.first.__send__(
-        :>=,
-        start_idx
-      )) {value.push(v.last)}
-    )})}
-    ::Myco.branch_op(:"&&", ::Myco.branch_op(:"&&", value.__send__(:empty?)) {start_idx.__send__(
-      :==,
-      idx
-    ).__send__(:!)}) {value = self.string.slice(
-      start_idx,
-      idx.__send__(
-        :-,
-        start_idx
+      )
+      store_value = [
+        [
+          start_idx,
+          idx
+        ],
+        value
+      ]
+      captures.store(
+        idx,
+        store_value
+      )
+      captures.store(
+        name,
+        store_value
       )
     )}
-    store_value = [
-      [
-        start_idx,
+  )
+  declare_meme(
+    :m_start,
+    [],
+    ::Object::Proc.new { |idx| (
+      self.midx_stack.push(idx)
+      self.c_start(idx)
+    )}
+  )
+  declare_meme(
+    :m_split,
+    [],
+    ::Object::Proc.new { |idx, name| (
+      self.c_end(
+        idx,
+        name
+      )
+      self.c_start(idx)
+    )}
+  )
+  declare_meme(
+    :m_end,
+    [],
+    ::Object::Proc.new { |idx, name| (
+      captures = self.capt_stack.last
+      start_idx = self.midx_stack.pop
+      self.cidx_stack.pop
+      value = []
+      captures.each { |k, v| (::Myco.branch_op(:"&&", ::Myco.branch_op(:"&&", ::Myco.branch_op(:"&&", k.__send__(
+        :is_a?,
+        ::Myco.find_constant(:Fixnum)
+      )) {k.__send__(
+        :<=,
         idx
-      ],
-      value
-    ]
-    captures.store(
-      idx,
-      store_value
-    )
-    captures.store(
-      name,
-      store_value
-    )
-  )}
-  declare_meme(:r_start, [], nil, ::Myco.cscope.dup) { |idx| ((
-    self.push_layer
-    self.ridx_stack.push(idx)
-  ))}
-  declare_meme(:r_end, [], nil, ::Myco.cscope.dup) { |idx, code, *args| (
-    captures = self.pop_layer
-    start_idx = self.ridx_stack.pop
-    captures_map = captures.map { |k, v| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", k.__send__(
-      :is_a?,
-      ::Myco.find_constant(:Symbol)
-    )) {[
-      k,
-      v.last
-    ]}) {nil})}.compact.to_h
-    code.__send__(
-      :scope=,
-      self.reduction_env_cscope
-    )
-    self.reduction_env.__send__(
-      :builder=,
-      self.builder
-    )
-    self.reduction_env.__send__(
-      :captures=,
-      captures_map
-    )
-    value = code.invoke(
-      code.name,
-      ::Myco.find_constant(:Capture)::Patterns::Reduction::Environment,
-      self.reduction_env,
-      [],
-      nil
-    )
-    store_value = [
-      [
-        start_idx,
+      )}) {k.__send__(
+        :>,
+        start_idx
+      )}) {(
+        loc = v.first
+        ::Myco.branch_op(:"&&", loc.first.__send__(
+          :>=,
+          start_idx
+        )) {value.push(v.last)}
+      )})}
+      ::Myco.branch_op(:"&&", ::Myco.branch_op(:"&&", value.__send__(:empty?)) {start_idx.__send__(
+        :==,
         idx
-      ],
-      value
-    ]
-    self.capt_stack.last.store(
-      idx,
-      store_value
-    )
-  )}
+      ).__send__(:!)}) {value = self.string.slice(
+        start_idx,
+        idx.__send__(
+          :-,
+          start_idx
+        )
+      )}
+      store_value = [
+        [
+          start_idx,
+          idx
+        ],
+        value
+      ]
+      captures.store(
+        idx,
+        store_value
+      )
+      captures.store(
+        name,
+        store_value
+      )
+    )}
+  )
+  declare_meme(
+    :r_start,
+    [],
+    ::Object::Proc.new { |idx| ((
+      self.push_layer
+      self.ridx_stack.push(idx)
+    ))}
+  )
+  declare_meme(
+    :r_end,
+    [],
+    ::Object::Proc.new { |idx, code, *args| (
+      captures = self.pop_layer
+      start_idx = self.ridx_stack.pop
+      captures_map = captures.map { |k, v| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", k.__send__(
+        :is_a?,
+        ::Myco.find_constant(:Symbol)
+      )) {[
+        k,
+        v.last
+      ]}) {nil})}.compact.to_h
+      code.__send__(
+        :scope=,
+        self.reduction_env_cscope
+      )
+      self.reduction_env.__send__(
+        :builder=,
+        self.builder
+      )
+      self.reduction_env.__send__(
+        :captures=,
+        captures_map
+      )
+      value = code.invoke(
+        code.name,
+        ::Myco.find_constant(:Capture)::Patterns::Reduction::Environment,
+        self.reduction_env,
+        [],
+        nil
+      )
+      store_value = [
+        [
+          start_idx,
+          idx
+        ],
+        value
+      ]
+      self.capt_stack.last.store(
+        idx,
+        store_value
+      )
+    )}
+  )
 )}}
 .tap { |__c__| __c__.__name__ = :Processor })}}.instance