myco 0.1.8 → 0.1.9

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

@@ -0,0 +1,49 @@
+
+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

@@ -0,0 +1,119 @@
+
+::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

@@ -0,0 +1,131 @@
+
+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

@@ -0,0 +1,595 @@
+
+::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