myco 0.1.9 → 0.1.10

data/lib/myco/code_tools/parser/pegleromyces/spec/Processor.test.my

@@ -1,10 +0,0 @@
-
-BasicSpec {
-  name: "Processor"
-  
-  new_processor: Processor { }
-  
-  [tests]
-  
-  it "exists": assert(new_processor)
-}

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

@@ -1,9 +0,0 @@
-
-::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(:BasicSpec)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-.tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:name, [], nil, ::Myco.cscope.dup) { |*| ("Processor")}
-  declare_meme(:new_processor, [], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Processor)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}.instance)}
-  __category__(:tests).component_eval {(declare_meme(:exists, [[:it, []]], nil, ::Myco.cscope.dup) { |*| (self.assert(self.new_processor))})}
-)}}.instance)}}.instance

data/lib/myco/code_tools/parser/pegleromyces/spec/Stream/Parser.test.my

@@ -1,49 +0,0 @@
-
-BasicSpec {
-  name: "Stream::Parser"
-  
-  new_parser: Stream::Parser.new
-  
-  [tests]
-  
-  it "can match from a minimal grammar": {
-    parser = new_parser
-    parser.grammar = Grammar {
-      [rules]
-      rule root: si.+
-    }
-    state = parser.parse([:x, :y, :z])
-    assert_equal(state.end_idx, 3)
-  }
-  
-  it "can match from a minimal grammar with rules in the stream items": {
-    parser = new_parser
-    parser.grammar = Grammar {
-      [rules]
-      rule root: si([:to_sym, [], :x]).+
-    }
-    state = parser.parse([:x, :x, :x])
-    assert_equal(state.end_idx, 3)
-  }
-  
-  it "can create a result from reductions": {
-    parser = new_parser
-    parser.grammar = Grammar {
-      [rules]
-      rule root: r(si.+[:list]) { list.join('.') }[:root]
-    }
-    state = parser.parse([:x, :y, :z])
-    assert_equal(state.result[:root], 'x.y.z')
-  }
-  
-  it "captures individual items for single-item captures": {
-    parser = new_parser
-    parser.grammar = Grammar {
-      [rules]
-      rule root: r(si[:a] + si[:b] + si.+[:rest]) { [a, b, rest] }[:root]
-    }
-    state = parser.parse([:x, :y, :z])
-    assert_equal(state.result[:root], [:x, :y, [:z]])
-  }
-  
-}

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

@@ -1,119 +0,0 @@
-
-::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(:BasicSpec)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-.tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:name, [], nil, ::Myco.cscope.dup) { |*| ("Stream::Parser")}
-  declare_meme(:new_parser, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Stream)::Parser.new)}
-  __category__(:tests).component_eval {(
-    declare_meme(:"can match from a minimal grammar", [[:it, []]], nil, ::Myco.cscope.dup) { |*| (
-      parser = self.new_parser
-      parser.__send__(
-        :grammar=,
-        ::Myco::Component.new([::Myco.find_constant(:Grammar)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-        .tap { |__c__| __c__.__last__ = __c__.component_eval {(__category__(:rules).component_eval {(declare_meme(:root, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.si.__send__(:+))})})}}.instance
-      )
-      state = parser.parse([
-        :x,
-        :y,
-        :z
-      ])
-      self.assert_equal(
-        state.end_idx,
-        3
-      )
-    )}
-    declare_meme(:"can match from a minimal grammar with rules in the stream items", [[:it, []]], nil, ::Myco.cscope.dup) { |*| (
-      parser = self.new_parser
-      parser.__send__(
-        :grammar=,
-        ::Myco::Component.new([::Myco.find_constant(:Grammar)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-        .tap { |__c__| __c__.__last__ = __c__.component_eval {(__category__(:rules).component_eval {(declare_meme(:root, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.si([
-          :to_sym,
-          [],
-          :x
-        ]).__send__(:+))})})}}.instance
-      )
-      state = parser.parse([
-        :x,
-        :x,
-        :x
-      ])
-      self.assert_equal(
-        state.end_idx,
-        3
-      )
-    )}
-    declare_meme(:"can create a result from reductions", [[:it, []]], nil, ::Myco.cscope.dup) { |*| (
-      parser = self.new_parser
-      parser.__send__(
-        :grammar=,
-        ::Myco::Component.new([::Myco.find_constant(:Grammar)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-        .tap { |__c__| __c__.__last__ = __c__.component_eval {(__category__(:rules).component_eval {(declare_meme(:root, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.si.__send__(:+).__send__(
-          :[],
-          :list
-        )) { || (self.list.join("."))}.__send__(
-          :[],
-          :root
-        ))})})}}.instance
-      )
-      state = parser.parse([
-        :x,
-        :y,
-        :z
-      ])
-      self.assert_equal(
-        state.result.__send__(
-          :[],
-          :root
-        ),
-        "x.y.z"
-      )
-    )}
-    declare_meme(:"captures individual items for single-item captures", [[:it, []]], nil, ::Myco.cscope.dup) { |*| (
-      parser = self.new_parser
-      parser.__send__(
-        :grammar=,
-        ::Myco::Component.new([::Myco.find_constant(:Grammar)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-        .tap { |__c__| __c__.__last__ = __c__.component_eval {(__category__(:rules).component_eval {(declare_meme(:root, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.si.__send__(
-          :[],
-          :a
-        ).__send__(
-          :+,
-          self.si.__send__(
-            :[],
-            :b
-          )
-        ).__send__(
-          :+,
-          self.si.__send__(:+).__send__(
-            :[],
-            :rest
-          )
-        )) { || ([
-          self.a,
-          self.b,
-          self.rest
-        ])}.__send__(
-          :[],
-          :root
-        ))})})}}.instance
-      )
-      state = parser.parse([
-        :x,
-        :y,
-        :z
-      ])
-      self.assert_equal(
-        state.result.__send__(
-          :[],
-          :root
-        ),
-        [
-          :x,
-          :y,
-          [:z]
-        ]
-      )
-    )}
-  )}
-)}}.instance)}}.instance

data/lib/myco/code_tools/parser/pegleromyces/spec/Stream/Patterns.test.my

@@ -1,131 +0,0 @@
-
-BasicSpec {
-  name: "Stream::Patterns"
-  
-  new_parser: Stream::Parser.new
-  
-  var shorthand: Common::Patterns::ShorthandMethods { }
-  si:  |*args| shorthand.si(*args)
-  esi: |*args| shorthand.esi(*args)
-  
-  match?: |pattern, *items| {
-    parser = new_parser
-    parser.grammar = Grammar {
-      [rules]
-      rule root: pattern
-    }
-    state = parser.parse(items)
-    state.end_idx == items.size
-  }
-  
-  assert_match: |pattern, *items| assert(
-    match?(pattern, *items)
-    "Expected "pattern.inspect" to match "items.inspect"."
-  )
-  
-  refute_match: |pattern, *items| assert(
-    !match?(pattern, *items)
-    "Expected "pattern.inspect" not to match "items.inspect"."
-  )
-  
-  var test_item: BasicObject {
-    return_true:   true
-    return_false:  false
-    return_null:   null
-    return_88:     88
-    return_99:     99
-    return_foo:    :foo
-    return_bar:    :bar
-    return_foo_s:  "foo"
-    return_bar_s:  "bar"
-    return_object: BasicObject.new
-    first_arg:  |*a| a[0]
-    second_arg: |*a| a[1]
-    third_arg:  |*a| a[2]
-  }
-  
-  [tests]
-  
-  "no checks": {
-    si |> assert_match(test_item)
-    si |> assert_match(true)
-    si |> assert_match(false)
-    si |> assert_match(null)
-    si |> assert_match(88)
-    si |> assert_match(99)
-    si |> assert_match(:foo)
-    si |> assert_match(:bar)
-    si |> assert_match("foo")
-    si |> assert_match("bar")
-  }
-  
-  "single check with no arguments for literal result": {
-    si([:return_true,   [], true ]) |> assert_match(test_item)
-    si([:return_false,  [], false]) |> assert_match(test_item)
-    si([:return_null,   [], null ]) |> assert_match(test_item)
-    si([:return_88,     [], 88   ]) |> assert_match(test_item)
-    si([:return_99,     [], 99   ]) |> assert_match(test_item)
-    si([:return_foo,    [], :foo ]) |> assert_match(test_item)
-    si([:return_bar,    [], :bar ]) |> assert_match(test_item)
-    si([:return_false,  [], true ]) |> refute_match(test_item)
-    si([:return_null,   [], true ]) |> refute_match(test_item)
-    si([:return_88,     [], true ]) |> refute_match(test_item)
-    si([:return_null,   [], false]) |> refute_match(test_item)
-    si([:return_false,  [], null ]) |> refute_match(test_item)
-    si([:return_88,     [], 99   ]) |> refute_match(test_item)
-    si([:return_99,     [], 88   ]) |> refute_match(test_item)
-    si([:return_foo,    [], :bar ]) |> refute_match(test_item)
-    si([:return_bar,    [], :foo ]) |> refute_match(test_item)
-    si([:return_object, [], true ]) |> refute_match(test_item)
-    si([:return_object, [], false]) |> refute_match(test_item)
-    si([:return_object, [], null ]) |> refute_match(test_item)
-  }
-  
-  "single check with no arguments for nonliteral result": {
-    si([:return_foo_s,  [], "foo"]) |> assert_match(test_item)
-    si([:return_bar_s,  [], "bar"]) |> assert_match(test_item)
-    si([:return_foo_s,  [], "bar"]) |> refute_match(test_item)
-    si([:return_bar_s,  [], "foo"]) |> refute_match(test_item)
-    si([:return_true,   [], "bar"]) |> refute_match(test_item)
-    si([:return_false,  [], "bar"]) |> refute_match(test_item)
-    si([:return_null,   [], "bar"]) |> refute_match(test_item)
-    si([:return_88,     [], "bar"]) |> refute_match(test_item)
-    si([:return_99,     [], "bar"]) |> refute_match(test_item)
-    si([:return_object, [], "bar"]) |> refute_match(test_item)
-    si([:return_object, [], test_item.return_object]) |> refute_match(test_item)
-  }
-  
-  "single check with arguments": {
-    si([:first_arg,  [:x,"y",3], :x   ]) |> assert_match(test_item)
-    si([:second_arg, [:x,"y",3], "y"  ]) |> assert_match(test_item)
-    si([:third_arg,  [:x,"y",3],  3   ]) |> assert_match(test_item)
-    si([:first_arg,  [:x,"y",3], true ]) |> refute_match(test_item)
-    si([:second_arg, [:x,"y",3], false]) |> refute_match(test_item)
-    si([:third_arg,  [:x,"y",3], null ]) |> refute_match(test_item)
-  }
-  
-  "multiple checks": {
-    si([:return_true, [], true],  [:first_arg, [:x,"y",3], :x]) |> assert_match(test_item)
-    si([:return_true, [], false], [:first_arg, [:x,"y",3], :x]) |> refute_match(test_item)
-    si([:return_true, [], true],  [:first_arg, [:x,"y",3], 88]) |> refute_match(test_item)
-    si([:return_true, [], false], [:first_arg, [:x,"y",3], 88]) |> refute_match(test_item)
-  }
-  
-  "with :self as check method, checks the item directly against the result": {
-    si([:self, [], 88]) |> assert_match(88)
-    si([:self, [], 99]) |> refute_match(88)
-  }
-  
-  "with block literal as check method, runs the block with the item as self": {
-    si([&{ self.return_88 }, [], 88]) |> assert_match(test_item)
-    si([&{ self.return_99 }, [], 88]) |> refute_match(test_item)
-    si([&|a,b,c|{ self.return_88 + (a * b) - c }, [2,3,4], 90]) |> assert_match(test_item)
-    si([&|a,b,c|{ self.return_99 + (a * b) - c }, [2,3,4], 90]) |> refute_match(test_item)
-  }
-  
-  "end of stream pattern": {
-    esi |> assert_match()
-    esi |> refute_match(test_item)
-    esi |> refute_match(test_item, test_item)
-  }
-}

data/lib/myco/code_tools/parser/pegleromyces/spec/Stream/Patterns.test.my.rb

@@ -1,595 +0,0 @@
-
-::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(:BasicSpec)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-.tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:name, [], nil, ::Myco.cscope.dup) { |*| ("Stream::Patterns")}
-  declare_meme(:new_parser, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Stream)::Parser.new)}
-  declare_meme(:shorthand, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Common)::Patterns::ShorthandMethods], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}.instance)}
-  declare_meme(:si, [], nil, ::Myco.cscope.dup) { |*args| (self.shorthand.si(*args))}
-  declare_meme(:esi, [], nil, ::Myco.cscope.dup) { |*args| (self.shorthand.esi(*args))}
-  declare_meme(:match?, [], nil, ::Myco.cscope.dup) { |pattern, *items| (
-    parser = self.new_parser
-    parser.__send__(
-      :grammar=,
-      ::Myco::Component.new([::Myco.find_constant(:Grammar)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-      .tap { |__c__| __c__.__last__ = __c__.component_eval {(__category__(:rules).component_eval {(declare_meme(:root, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (pattern)})})}}.instance
-    )
-    state = parser.parse(items)
-    state.end_idx.__send__(
-      :==,
-      items.size
-    )
-  )}
-  declare_meme(:assert_match, [], nil, ::Myco.cscope.dup) { |pattern, *items| (self.assert(
-    self.__send__(
-      :match?,
-      pattern,
-      *items
-    ),
-    "Expected #{pattern.inspect} to match #{items.inspect}."
-  ))}
-  declare_meme(:refute_match, [], nil, ::Myco.cscope.dup) { |pattern, *items| (self.assert(
-    self.__send__(
-      :match?,
-      pattern,
-      *items
-    ).__send__(:!),
-    "Expected #{pattern.inspect} not to match #{items.inspect}."
-  ))}
-  declare_meme(:test_item, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:BasicObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-  .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-    declare_meme(:return_true, [], nil, ::Myco.cscope.dup) { |*| (true)}
-    declare_meme(:return_false, [], nil, ::Myco.cscope.dup) { |*| (false)}
-    declare_meme(:return_null, [], nil, ::Myco.cscope.dup) { |*| (nil)}
-    declare_meme(:return_88, [], nil, ::Myco.cscope.dup) { |*| (88)}
-    declare_meme(:return_99, [], nil, ::Myco.cscope.dup) { |*| (99)}
-    declare_meme(:return_foo, [], nil, ::Myco.cscope.dup) { |*| (:foo)}
-    declare_meme(:return_bar, [], nil, ::Myco.cscope.dup) { |*| (:bar)}
-    declare_meme(:return_foo_s, [], nil, ::Myco.cscope.dup) { |*| ("foo")}
-    declare_meme(:return_bar_s, [], nil, ::Myco.cscope.dup) { |*| ("bar")}
-    declare_meme(:return_object, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:BasicObject).new)}
-    declare_meme(:first_arg, [], nil, ::Myco.cscope.dup) { |*a| (a.__send__(
-      :[],
-      0
-    ))}
-    declare_meme(:second_arg, [], nil, ::Myco.cscope.dup) { |*a| (a.__send__(
-      :[],
-      1
-    ))}
-    declare_meme(:third_arg, [], nil, ::Myco.cscope.dup) { |*a| (a.__send__(
-      :[],
-      2
-    ))}
-  )}}.instance)}
-  __category__(:tests).component_eval {(
-    declare_meme(:"no checks", [], nil, ::Myco.cscope.dup) { |*| (
-      self.assert_match(
-        self.si,
-        self.test_item
-      )
-      self.assert_match(
-        self.si,
-        true
-      )
-      self.assert_match(
-        self.si,
-        false
-      )
-      self.assert_match(
-        self.si,
-        nil
-      )
-      self.assert_match(
-        self.si,
-        88
-      )
-      self.assert_match(
-        self.si,
-        99
-      )
-      self.assert_match(
-        self.si,
-        :foo
-      )
-      self.assert_match(
-        self.si,
-        :bar
-      )
-      self.assert_match(
-        self.si,
-        "foo"
-      )
-      self.assert_match(
-        self.si,
-        "bar"
-      )
-    )}
-    declare_meme(:"single check with no arguments for literal result", [], nil, ::Myco.cscope.dup) { |*| (
-      self.assert_match(
-        self.si([
-          :return_true,
-          [],
-          true
-        ]),
-        self.test_item
-      )
-      self.assert_match(
-        self.si([
-          :return_false,
-          [],
-          false
-        ]),
-        self.test_item
-      )
-      self.assert_match(
-        self.si([
-          :return_null,
-          [],
-          nil
-        ]),
-        self.test_item
-      )
-      self.assert_match(
-        self.si([
-          :return_88,
-          [],
-          88
-        ]),
-        self.test_item
-      )
-      self.assert_match(
-        self.si([
-          :return_99,
-          [],
-          99
-        ]),
-        self.test_item
-      )
-      self.assert_match(
-        self.si([
-          :return_foo,
-          [],
-          :foo
-        ]),
-        self.test_item
-      )
-      self.assert_match(
-        self.si([
-          :return_bar,
-          [],
-          :bar
-        ]),
-        self.test_item
-      )
-      self.refute_match(
-        self.si([
-          :return_false,
-          [],
-          true
-        ]),
-        self.test_item
-      )
-      self.refute_match(
-        self.si([
-          :return_null,
-          [],
-          true
-        ]),
-        self.test_item
-      )
-      self.refute_match(
-        self.si([
-          :return_88,
-          [],
-          true
-        ]),
-        self.test_item
-      )
-      self.refute_match(
-        self.si([
-          :return_null,
-          [],
-          false
-        ]),
-        self.test_item
-      )
-      self.refute_match(
-        self.si([
-          :return_false,
-          [],
-          nil
-        ]),
-        self.test_item
-      )
-      self.refute_match(
-        self.si([
-          :return_88,
-          [],
-          99
-        ]),
-        self.test_item
-      )
-      self.refute_match(
-        self.si([
-          :return_99,
-          [],
-          88
-        ]),
-        self.test_item
-      )
-      self.refute_match(
-        self.si([
-          :return_foo,
-          [],
-          :bar
-        ]),
-        self.test_item
-      )
-      self.refute_match(
-        self.si([
-          :return_bar,
-          [],
-          :foo
-        ]),
-        self.test_item
-      )
-      self.refute_match(
-        self.si([
-          :return_object,
-          [],
-          true
-        ]),
-        self.test_item
-      )
-      self.refute_match(
-        self.si([
-          :return_object,
-          [],
-          false
-        ]),
-        self.test_item
-      )
-      self.refute_match(
-        self.si([
-          :return_object,
-          [],
-          nil
-        ]),
-        self.test_item
-      )
-    )}
-    declare_meme(:"single check with no arguments for nonliteral result", [], nil, ::Myco.cscope.dup) { |*| (
-      self.assert_match(
-        self.si([
-          :return_foo_s,
-          [],
-          "foo"
-        ]),
-        self.test_item
-      )
-      self.assert_match(
-        self.si([
-          :return_bar_s,
-          [],
-          "bar"
-        ]),
-        self.test_item
-      )
-      self.refute_match(
-        self.si([
-          :return_foo_s,
-          [],
-          "bar"
-        ]),
-        self.test_item
-      )
-      self.refute_match(
-        self.si([
-          :return_bar_s,
-          [],
-          "foo"
-        ]),
-        self.test_item
-      )
-      self.refute_match(
-        self.si([
-          :return_true,
-          [],
-          "bar"
-        ]),
-        self.test_item
-      )
-      self.refute_match(
-        self.si([
-          :return_false,
-          [],
-          "bar"
-        ]),
-        self.test_item
-      )
-      self.refute_match(
-        self.si([
-          :return_null,
-          [],
-          "bar"
-        ]),
-        self.test_item
-      )
-      self.refute_match(
-        self.si([
-          :return_88,
-          [],
-          "bar"
-        ]),
-        self.test_item
-      )
-      self.refute_match(
-        self.si([
-          :return_99,
-          [],
-          "bar"
-        ]),
-        self.test_item
-      )
-      self.refute_match(
-        self.si([
-          :return_object,
-          [],
-          "bar"
-        ]),
-        self.test_item
-      )
-      self.refute_match(
-        self.si([
-          :return_object,
-          [],
-          self.test_item.return_object
-        ]),
-        self.test_item
-      )
-    )}
-    declare_meme(:"single check with arguments", [], nil, ::Myco.cscope.dup) { |*| (
-      self.assert_match(
-        self.si([
-          :first_arg,
-          [
-            :x,
-            "y",
-            3
-          ],
-          :x
-        ]),
-        self.test_item
-      )
-      self.assert_match(
-        self.si([
-          :second_arg,
-          [
-            :x,
-            "y",
-            3
-          ],
-          "y"
-        ]),
-        self.test_item
-      )
-      self.assert_match(
-        self.si([
-          :third_arg,
-          [
-            :x,
-            "y",
-            3
-          ],
-          3
-        ]),
-        self.test_item
-      )
-      self.refute_match(
-        self.si([
-          :first_arg,
-          [
-            :x,
-            "y",
-            3
-          ],
-          true
-        ]),
-        self.test_item
-      )
-      self.refute_match(
-        self.si([
-          :second_arg,
-          [
-            :x,
-            "y",
-            3
-          ],
-          false
-        ]),
-        self.test_item
-      )
-      self.refute_match(
-        self.si([
-          :third_arg,
-          [
-            :x,
-            "y",
-            3
-          ],
-          nil
-        ]),
-        self.test_item
-      )
-    )}
-    declare_meme(:"multiple checks", [], nil, ::Myco.cscope.dup) { |*| (
-      self.assert_match(
-        self.si(
-          [
-            :return_true,
-            [],
-            true
-          ],
-          [
-            :first_arg,
-            [
-              :x,
-              "y",
-              3
-            ],
-            :x
-          ]
-        ),
-        self.test_item
-      )
-      self.refute_match(
-        self.si(
-          [
-            :return_true,
-            [],
-            false
-          ],
-          [
-            :first_arg,
-            [
-              :x,
-              "y",
-              3
-            ],
-            :x
-          ]
-        ),
-        self.test_item
-      )
-      self.refute_match(
-        self.si(
-          [
-            :return_true,
-            [],
-            true
-          ],
-          [
-            :first_arg,
-            [
-              :x,
-              "y",
-              3
-            ],
-            88
-          ]
-        ),
-        self.test_item
-      )
-      self.refute_match(
-        self.si(
-          [
-            :return_true,
-            [],
-            false
-          ],
-          [
-            :first_arg,
-            [
-              :x,
-              "y",
-              3
-            ],
-            88
-          ]
-        ),
-        self.test_item
-      )
-    )}
-    declare_meme(:"with :self as check method, checks the item directly against the result", [], nil, ::Myco.cscope.dup) { |*| (
-      self.assert_match(
-        self.si([
-          :self,
-          [],
-          88
-        ]),
-        88
-      )
-      self.refute_match(
-        self.si([
-          :self,
-          [],
-          99
-        ]),
-        88
-      )
-    )}
-    declare_meme(:"with block literal as check method, runs the block with the item as self", [], nil, ::Myco.cscope.dup) { |*| (
-      self.assert_match(
-        self.si([
-          ::Object::Proc.new { || (self.__send__(:return_88))},
-          [],
-          88
-        ]),
-        self.test_item
-      )
-      self.refute_match(
-        self.si([
-          ::Object::Proc.new { || (self.__send__(:return_99))},
-          [],
-          88
-        ]),
-        self.test_item
-      )
-      self.assert_match(
-        self.si([
-          ::Object::Proc.new { |a, b, c| (self.__send__(:return_88).__send__(
-            :+,
-            a.__send__(
-              :*,
-              b
-            )
-          ).__send__(
-            :-,
-            c
-          ))},
-          [
-            2,
-            3,
-            4
-          ],
-          90
-        ]),
-        self.test_item
-      )
-      self.refute_match(
-        self.si([
-          ::Object::Proc.new { |a, b, c| (self.__send__(:return_99).__send__(
-            :+,
-            a.__send__(
-              :*,
-              b
-            )
-          ).__send__(
-            :-,
-            c
-          ))},
-          [
-            2,
-            3,
-            4
-          ],
-          90
-        ]),
-        self.test_item
-      )
-    )}
-    declare_meme(:"end of stream pattern", [], nil, ::Myco.cscope.dup) { |*| (
-      self.assert_match(self.esi)
-      self.refute_match(
-        self.esi,
-        self.test_item
-      )
-      self.refute_match(
-        self.esi,
-        self.test_item,
-        self.test_item
-      )
-    )}
-  )}
-)}}.instance)}}.instance