myco 0.1.9 → 0.1.10

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

@@ -8,12 +8,24 @@
     .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}
     .tap { |__c__| __c__.__name__ = :Base }
     ::Myco.cscope.for_method_definition::End = ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-    .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Constructions)::End.new)})}}
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(
+      :construct,
+      [],
+      ::Object::Proc.new { |*| (::Myco.find_constant(:Constructions)::End.new)}
+    ))}}
     .tap { |__c__| __c__.__name__ = :End }
     ::Myco.cscope.for_method_definition::Item = ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
     .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-      declare_meme(:checks, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-      declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Constructions)::Item.new({:checks => self.checks}))}
+      declare_meme(
+        :checks,
+        [:var],
+        ::Object::Proc.new { |*| nil}
+      )
+      declare_meme(
+        :construct,
+        [],
+        ::Object::Proc.new { |*| (::Myco.find_constant(:Constructions)::Item.new({:checks => self.checks}))}
+      )
     )}}
     .tap { |__c__| __c__.__name__ = :Item }
   )}}
@@ -27,126 +39,138 @@
     .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}
     .tap { |__c__| __c__.__name__ = :End }
     ::Myco.cscope.for_method_definition::Item = ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-    .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:checks, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil})}}
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(
+      :checks,
+      [:var],
+      ::Object::Proc.new { |*| nil}
+    ))}}
     .tap { |__c__| __c__.__name__ = :Item }
   )}}
   .tap { |__c__| __c__.__name__ = :Constructions }
   ::Myco.find_constant(:Constructions).component_eval {(
-    ::Myco.find_constant(:End).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
-      g.push_subject
-      g.send(
-        :size,
-        0
-      )
-      g.push_idx
-      g.send(
-        :>,
-        1
-      )
-      g.goto_if_true(g.overall_fail)
-    )})}
-    ::Myco.find_constant(:Item).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
-      many_checks = self.checks.size.__send__(
-        :>,
-        1
-      )
-      local_fail = g.overall_fail
-      self.__send__(
-        :if,
-        many_checks
-      ) { || (local_fail = g.new_label)}
-      g.push_subject
-      g.send(
-        :size,
-        0
-      )
-      g.push_idx
-      g.send(
-        :>,
-        1
-      )
-      g.goto_if_false(g.overall_fail)
-      ::Myco.branch_op(:"||", self.checks.__send__(:empty?)) {(
-        g.push_subject_at_idx
-        self.checks.each { |method, args, result| (
-          self.__send__(
-            :if,
-            many_checks
-          ) { || (g.dup_top)}
-          ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", :self.__send__(
-            :equal?,
-            method
-          )) {nil}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", method.__send__(
-            :is_a?,
-            ::Myco.find_constant(:Symbol)
-          )) {(
-            args.each { |arg| (g.push_literal_or_array(arg))}
-            g.send(
-              method,
-              args.size
-            )
-          )}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", method.__send__(
-            :is_a?,
-            ::Myco.find_constant(:Proc)
-          )) {(
-            code = method.block.compiled_code
-            g.push_literal(code)
-            g.swap_stack
-            g.push_literal(code.name)
-            g.swap_stack
-            g.push_cpath_top
-            g.find_const(:Myco)
-            g.swap_stack
-            g.push_literal_array(args)
-            g.push_nil
-            g.send(
-              :invoke,
-              5
-            )
-          )}) {self.raise("Unknown type of check method: #{method}")}}}
-          ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", nil.__send__(
-            :equal?,
-            result
-          )) {g.goto_if_not_nil(local_fail)}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", ::Myco.branch_op(:"||", ::Myco.branch_op(:"||", ::Myco.branch_op(:"||", false.__send__(
-            :equal?,
-            result
-          )) {true.__send__(
-            :equal?,
-            result
-          )}) {result.__send__(
-            :is_a?,
-            ::Myco.find_constant(:Symbol)
-          )}) {result.__send__(
-            :is_a?,
-            ::Myco.find_constant(:Fixnum)
-          )}) {(
-            g.push_literal(result)
-            g.goto_if_not_equal(local_fail)
-          )}) {(
-            g.push_literal_or_array(result)
-            g.send(
-              :==,
-              1
-            )
-            g.goto_if_false(local_fail)
-          )}}
-        )}
+    ::Myco.find_constant(:End).component_eval {(declare_meme(
+      :bytecode,
+      [],
+      ::Object::Proc.new { |g| (
+        g.push_subject
+        g.send(
+          :size,
+          0
+        )
+        g.push_idx
+        g.send(
+          :>,
+          1
+        )
+        g.goto_if_true(g.overall_fail)
+      )}
+    ))}
+    ::Myco.find_constant(:Item).component_eval {(declare_meme(
+      :bytecode,
+      [],
+      ::Object::Proc.new { |g| (
+        many_checks = self.checks.size.__send__(
+          :>,
+          1
+        )
+        local_fail = g.overall_fail
         self.__send__(
           :if,
           many_checks
-        ) { || (
-          local_done = g.new_label
-          g.pop
-          g.goto(local_done)
-          local_fail.__send__(:set!)
-          g.pop
-          g.goto(g.overall_fail)
-          local_done.__send__(:set!)
+        ) { |*| (local_fail = g.new_label)}
+        g.push_subject
+        g.send(
+          :size,
+          0
+        )
+        g.push_idx
+        g.send(
+          :>,
+          1
+        )
+        g.goto_if_false(g.overall_fail)
+        ::Myco.branch_op(:"||", self.checks.__send__(:empty?)) {(
+          g.push_subject_at_idx
+          self.checks.each { |method, args, result| (
+            self.__send__(
+              :if,
+              many_checks
+            ) { |*| (g.dup_top)}
+            ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", :self.__send__(
+              :equal?,
+              method
+            )) {nil}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", method.__send__(
+              :is_a?,
+              ::Myco.find_constant(:Symbol)
+            )) {(
+              args.each { |arg| (g.push_literal_or_array(arg))}
+              g.send(
+                method,
+                args.size
+              )
+            )}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", method.__send__(
+              :is_a?,
+              ::Myco.find_constant(:Proc)
+            )) {(
+              code = method.block.compiled_code
+              g.push_literal(code)
+              g.swap_stack
+              g.push_literal(code.name)
+              g.swap_stack
+              g.push_cpath_top
+              g.find_const(:Myco)
+              g.swap_stack
+              g.push_literal_array(args)
+              g.push_nil
+              g.send(
+                :invoke,
+                5
+              )
+            )}) {self.raise("Unknown type of check method: #{method}")}}}
+            ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", nil.__send__(
+              :equal?,
+              result
+            )) {g.goto_if_not_nil(local_fail)}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", ::Myco.branch_op(:"||", ::Myco.branch_op(:"||", ::Myco.branch_op(:"||", false.__send__(
+              :equal?,
+              result
+            )) {true.__send__(
+              :equal?,
+              result
+            )}) {result.__send__(
+              :is_a?,
+              ::Myco.find_constant(:Symbol)
+            )}) {result.__send__(
+              :is_a?,
+              ::Myco.find_constant(:Fixnum)
+            )}) {(
+              g.push_literal(result)
+              g.goto_if_not_equal(local_fail)
+            )}) {(
+              g.push_literal_or_array(result)
+              g.send(
+                :==,
+                1
+              )
+              g.goto_if_false(local_fail)
+            )}}
+          )}
+          self.__send__(
+            :if,
+            many_checks
+          ) { |*| (
+            local_done = g.new_label
+            g.pop
+            g.goto(local_done)
+            local_fail.__send__(:set!)
+            g.pop
+            g.goto(g.overall_fail)
+            local_done.__send__(:set!)
+          )}
         )}
+        g.__send__(:meta_push_1)
+        g.increment_idx
       )}
-      g.__send__(:meta_push_1)
-      g.increment_idx
-    )})}
+    ))}
   )}
 )}}
 .tap { |__c__| __c__.__name__ = :Stream })}}.instance

data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/Stream/Parser.my.rb

@@ -4,54 +4,66 @@
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
   ::Myco.cscope.for_method_definition::State = ::Myco::Component.new([::Myco.find_constant(:Common)::Parser::State], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
   .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-    declare_meme(:stream, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-    declare_meme(:raise_error, [], nil, ::Myco.cscope.dup) { |*| (::Myco.branch_op(:"&&", self.error_idx) {self.raise(
-      ::Myco.find_constant(:SyntaxError),
-      "Unexpected item with parser: #{self.rule} at index: #{self.error_idx}, item: #{self.stream.__send__(
-        :[],
-        self.error_idx
-      ).inspect}"
-    )})}
+    declare_meme(
+      :stream,
+      [:var],
+      ::Object::Proc.new { |*| nil}
+    )
+    declare_meme(
+      :raise_error,
+      [],
+      ::Object::Proc.new { |*| (::Myco.branch_op(:"&&", self.error_idx) {self.raise(
+        ::Myco.find_constant(:SyntaxError),
+        "Unexpected item with parser: #{self.rule} at index: #{self.error_idx}, item: #{self.stream.__send__(
+          :[],
+          self.error_idx
+        ).inspect}"
+      )})}
+    )
   )}}
   .tap { |__c__| __c__.__name__ = :State }
-  declare_meme(:parse, [], nil, ::Myco.cscope.dup) { |stream, rule:"root", start_idx:0| (
-    worker = self.new_worker
-    processor = self.new_processor
-    state = ::Myco.find_constant(:State).new({
-      :stream => stream,
-      :rule => rule.to_sym,
-      :start_idx => start_idx.to_i
-    })
-    state.__send__(
-      :end_idx=,
-      worker.__send__(
-        state.rule,
-        state.stream,
-        state.start_idx
-      )
-    )
-    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", state.end_idx) {(
-      processor.__send__(
-        :string=,
-        state.stream
-      )
-      processor.__send__(
-        :capture_items=,
-        self.captures_of_worker(worker)
-      )
-      ::Myco.branch_op(:"&&", (Rubinius::Type.object_respond_to?(self.grammar, :tokenizer).false? ? ::Myco::Void : self.grammar.tokenizer)) {processor.__send__(
-        :tokenizer=,
-        self.grammar.tokenizer
-      )}
+  declare_meme(
+    :parse,
+    [],
+    ::Object::Proc.new { |stream, rule:"root", start_idx:0| (
+      worker = self.new_worker
+      processor = self.new_processor
+      state = ::Myco.find_constant(:State).new({
+        :stream => stream,
+        :rule => rule.to_sym,
+        :start_idx => start_idx.to_i
+      })
       state.__send__(
-        :result=,
-        processor.process
+        :end_idx=,
+        worker.__send__(
+          state.rule,
+          state.stream,
+          state.start_idx
+        )
       )
-    )}) {state.__send__(
-      :error_idx=,
-      self.highest_idx_of_worker(worker)
+      ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", state.end_idx) {(
+        processor.__send__(
+          :string=,
+          state.stream
+        )
+        processor.__send__(
+          :capture_items=,
+          self.captures_of_worker(worker)
+        )
+        ::Myco.branch_op(:"&&", (Rubinius::Type.object_respond_to?(self.grammar, :tokenizer).false? ? ::Myco::Void : self.grammar.tokenizer)) {processor.__send__(
+          :tokenizer=,
+          self.grammar.tokenizer
+        )}
+        state.__send__(
+          :result=,
+          processor.process
+        )
+      )}) {state.__send__(
+        :error_idx=,
+        self.highest_idx_of_worker(worker)
+      )}
+      state
     )}
-    state
-  )}
+  )
 )}}
 .tap { |__c__| __c__.__name__ = :Parser })})}}.instance

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

@@ -8,34 +8,74 @@
     .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}
     .tap { |__c__| __c__.__name__ = :Base }
     ::Myco.cscope.for_method_definition::AnyCharacter = ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-    .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Constructions)::AnyCharacter.new)})}}
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(
+      :construct,
+      [],
+      ::Object::Proc.new { |*| (::Myco.find_constant(:Constructions)::AnyCharacter.new)}
+    ))}}
     .tap { |__c__| __c__.__name__ = :AnyCharacter }
     ::Myco.cscope.for_method_definition::Character = ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
     .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-      declare_meme(:code, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-      declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Constructions)::Character.new({:code => self.code}))}
+      declare_meme(
+        :code,
+        [:var],
+        ::Object::Proc.new { |*| nil}
+      )
+      declare_meme(
+        :construct,
+        [],
+        ::Object::Proc.new { |*| (::Myco.find_constant(:Constructions)::Character.new({:code => self.code}))}
+      )
     )}}
     .tap { |__c__| __c__.__name__ = :Character }
     ::Myco.cscope.for_method_definition::CharacterString = ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
     .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-      declare_meme(:codes, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-      declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Constructions)::CharacterString.new({:codes => self.codes}))}
+      declare_meme(
+        :codes,
+        [:var],
+        ::Object::Proc.new { |*| nil}
+      )
+      declare_meme(
+        :construct,
+        [],
+        ::Object::Proc.new { |*| (::Myco.find_constant(:Constructions)::CharacterString.new({:codes => self.codes}))}
+      )
     )}}
     .tap { |__c__| __c__.__name__ = :CharacterString }
     ::Myco.cscope.for_method_definition::CharacterSet = ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
     .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-      declare_meme(:codes, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-      declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Constructions)::CharacterSet.new({:codes => self.codes}))}
+      declare_meme(
+        :codes,
+        [:var],
+        ::Object::Proc.new { |*| nil}
+      )
+      declare_meme(
+        :construct,
+        [],
+        ::Object::Proc.new { |*| (::Myco.find_constant(:Constructions)::CharacterSet.new({:codes => self.codes}))}
+      )
     )}}
     .tap { |__c__| __c__.__name__ = :CharacterSet }
     ::Myco.cscope.for_method_definition::CharacterRange = ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
     .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-      declare_meme(:start, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-      declare_meme(:stop, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-      declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Constructions)::CharacterRange.new({
-        :start => self.start,
-        :stop => self.stop
-      }))}
+      declare_meme(
+        :start,
+        [:var],
+        ::Object::Proc.new { |*| nil}
+      )
+      declare_meme(
+        :stop,
+        [:var],
+        ::Object::Proc.new { |*| nil}
+      )
+      declare_meme(
+        :construct,
+        [],
+        ::Object::Proc.new { |*| (::Myco.find_constant(:Constructions)::CharacterRange.new({
+          :start => self.start,
+          :stop => self.stop
+        }))}
+      )
     )}}
     .tap { |__c__| __c__.__name__ = :CharacterRange }
   )}}
@@ -49,99 +89,139 @@
     .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}
     .tap { |__c__| __c__.__name__ = :AnyCharacter }
     ::Myco.cscope.for_method_definition::Character = ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-    .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:code, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil})}}
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(
+      :code,
+      [:var],
+      ::Object::Proc.new { |*| nil}
+    ))}}
     .tap { |__c__| __c__.__name__ = :Character }
     ::Myco.cscope.for_method_definition::CharacterString = ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-    .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:codes, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil})}}
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(
+      :codes,
+      [:var],
+      ::Object::Proc.new { |*| nil}
+    ))}}
     .tap { |__c__| __c__.__name__ = :CharacterString }
     ::Myco.cscope.for_method_definition::CharacterSet = ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-    .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:codes, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil})}}
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(
+      :codes,
+      [:var],
+      ::Object::Proc.new { |*| nil}
+    ))}}
     .tap { |__c__| __c__.__name__ = :CharacterSet }
     ::Myco.cscope.for_method_definition::CharacterRange = ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
     .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-      declare_meme(:start, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-      declare_meme(:stop, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+      declare_meme(
+        :start,
+        [:var],
+        ::Object::Proc.new { |*| nil}
+      )
+      declare_meme(
+        :stop,
+        [:var],
+        ::Object::Proc.new { |*| nil}
+      )
     )}}
     .tap { |__c__| __c__.__name__ = :CharacterRange }
   )}}
   .tap { |__c__| __c__.__name__ = :Constructions }
   ::Myco.find_constant(:Constructions).component_eval {(
-    ::Myco.find_constant(:AnyCharacter).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
-      g.push_idx
-      g.push_subject
-      g.send(
-        :size,
-        0
-      )
-      g.send(
-        :==,
-        1
-      )
-      g.goto_if_true(g.overall_fail)
-      g.__send__(:meta_push_1)
-      g.increment_idx
-    )})}
-    ::Myco.find_constant(:Character).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
-      g.push_literal(self.code.chr)
-      g.push_subject_chr_at_idx
-      g.send(
-        :==,
-        1
-      )
-      g.goto_if_false(g.overall_fail)
-      g.__send__(:meta_push_1)
-      g.increment_idx
-    )})}
+    ::Myco.find_constant(:AnyCharacter).component_eval {(declare_meme(
+      :bytecode,
+      [],
+      ::Object::Proc.new { |g| (
+        g.push_idx
+        g.push_subject
+        g.send(
+          :size,
+          0
+        )
+        g.send(
+          :==,
+          1
+        )
+        g.goto_if_true(g.overall_fail)
+        g.__send__(:meta_push_1)
+        g.increment_idx
+      )}
+    ))}
+    ::Myco.find_constant(:Character).component_eval {(declare_meme(
+      :bytecode,
+      [],
+      ::Object::Proc.new { |g| (
+        g.push_literal(self.code.chr)
+        g.push_subject_chr_at_idx
+        g.send(
+          :==,
+          1
+        )
+        g.goto_if_false(g.overall_fail)
+        g.__send__(:meta_push_1)
+        g.increment_idx
+      )}
+    ))}
     ::Myco.cscope.for_method_definition::STRING_HACK_PATCH = (::Myco.find_constant(:Ruby).eval("\n      class ::String\n        def compare_substring_safe(*args)\n          compare_substring(*args)\n        rescue Exception\n          nil\n        end\n      end\n    "))
-    ::Myco.find_constant(:CharacterString).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
-      string = self.codes.map(&:chr).join
-      g.push_literal(string)
-      g.push_subject
-      g.push_idx
-      g.push_int(string.size)
-      g.send(
-        :compare_substring_safe,
-        3
-      )
-      g.__send__(:meta_push_0)
-      g.goto_if_not_equal(g.overall_fail)
-      g.push_int(string.size)
-      g.increment_idx
-    )})}
-    ::Myco.find_constant(:CharacterSet).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
-      string = self.codes.map(&:chr).join
-      g.push_subject_chr_at_idx
-      g.goto_if_nil(g.overall_fail)
-      g.push_literal(string)
-      g.push_subject_chr_at_idx
-      g.__send__(:meta_push_0)
-      g.send(
-        :find_string,
-        2
-      )
-      g.goto_if_false(g.overall_fail)
-      g.__send__(:meta_push_1)
-      g.increment_idx
-    )})}
-    ::Myco.find_constant(:CharacterRange).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
-      codes = ::Myco.find_constant(:Range).new(
-        self.start,
-        self.stop
-      )
-      string = codes.map(&:chr).join
-      g.push_subject_chr_at_idx
-      g.goto_if_nil(g.overall_fail)
-      g.push_literal(string)
-      g.push_subject_chr_at_idx
-      g.__send__(:meta_push_0)
-      g.send(
-        :find_string,
-        2
-      )
-      g.goto_if_false(g.overall_fail)
-      g.__send__(:meta_push_1)
-      g.increment_idx
-    )})}
+    ::Myco.find_constant(:CharacterString).component_eval {(declare_meme(
+      :bytecode,
+      [],
+      ::Object::Proc.new { |g| (
+        string = self.codes.map(&:chr).join
+        g.push_literal(string)
+        g.push_subject
+        g.push_idx
+        g.push_int(string.size)
+        g.send(
+          :compare_substring_safe,
+          3
+        )
+        g.__send__(:meta_push_0)
+        g.goto_if_not_equal(g.overall_fail)
+        g.push_int(string.size)
+        g.increment_idx
+      )}
+    ))}
+    ::Myco.find_constant(:CharacterSet).component_eval {(declare_meme(
+      :bytecode,
+      [],
+      ::Object::Proc.new { |g| (
+        string = self.codes.map(&:chr).join
+        g.push_subject_chr_at_idx
+        g.goto_if_nil(g.overall_fail)
+        g.push_literal(string)
+        g.push_subject_chr_at_idx
+        g.__send__(:meta_push_0)
+        g.send(
+          :find_string,
+          2
+        )
+        g.goto_if_false(g.overall_fail)
+        g.__send__(:meta_push_1)
+        g.increment_idx
+      )}
+    ))}
+    ::Myco.find_constant(:CharacterRange).component_eval {(declare_meme(
+      :bytecode,
+      [],
+      ::Object::Proc.new { |g| (
+        codes = ::Myco.find_constant(:Range).new(
+          self.start,
+          self.stop
+        )
+        string = codes.map(&:chr).join
+        g.push_subject_chr_at_idx
+        g.goto_if_nil(g.overall_fail)
+        g.push_literal(string)
+        g.push_subject_chr_at_idx
+        g.__send__(:meta_push_0)
+        g.send(
+          :find_string,
+          2
+        )
+        g.goto_if_false(g.overall_fail)
+        g.__send__(:meta_push_1)
+        g.increment_idx
+      )}
+    ))}
   )}
 )}}
 .tap { |__c__| __c__.__name__ = :String })}}.instance