myco 0.1.8 → 0.1.9

data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/Constructions.my

@@ -1,183 +0,0 @@
-
-Constructions < EmptyObject {
-  
-  ##
-  # Basic types of constructions.
-  
-  Base < BasicObject { }
-  UnaryBase  < Base { var inner }
-  BinaryBase < Base { var first, var second }
-  
-  AnyCharacter      < Base { }
-  Character         < Base { var code }
-  CharacterString   < Base { var codes }
-  CharacterSet      < Base { var codes }
-  CharacterRange    < Base { var start, var stop }
-  
-  NegativePredicate < UnaryBase { }
-  PositivePredicate < UnaryBase { }
-  OneOrMore         < UnaryBase { }
-  ZeroOrOne         < UnaryBase { }
-  ZeroOrMore        < UnaryBase { }
-  OrderedChoice     < BinaryBase { }
-  Concatenation     < BinaryBase { }
-  
-  NamedCapture      < UnaryBase { var captargs }
-  NamedTextCapture  < UnaryBase { var captargs }
-  NamedTokenCapture < UnaryBase { var captargs }
-  Reduction         < UnaryBase { var captargs }
-  
-  ##
-  # Bindings of patterns to constructions.
-  
-  Patterns::UnaryBase << {
-    construct: construct_type.new(inner:inner.construct)
-  }
-  
-  Patterns::BinaryBase << {
-    construct: construct_type.new(first:first.construct,second:second.construct)
-  }
-  
-  Patterns::AnyCharacter      << { construct: AnyCharacter.new }
-  Patterns::Character         << { construct: Character      .new(code:code) }
-  Patterns::CharacterString   << { construct: CharacterString.new(codes:codes) }
-  Patterns::CharacterSet      << { construct: CharacterSet   .new(codes:codes) }
-  Patterns::CharacterRange    << { construct: CharacterRange .new(start:start
-                                                                   stop:stop) }
-  
-  Patterns::NegativePredicate << { construct_type: NegativePredicate }
-  Patterns::PositivePredicate << { construct_type: PositivePredicate }
-  Patterns::OneOrMore         << { construct_type: OneOrMore }
-  Patterns::ZeroOrOne         << { construct_type: ZeroOrOne }
-  Patterns::ZeroOrMore        << { construct_type: ZeroOrMore }
-  Patterns::OrderedChoice     << { construct_type: OrderedChoice }
-  Patterns::Concatenation     << { construct_type: Concatenation }
-  
-  Patterns::NamedCapture      << {
-    construct: NamedCapture.new(
-      inner: inner.construct
-      captargs: [self.name]
-    )
-  }
-  Patterns::NamedTextCapture  << {
-    construct: NamedTextCapture.new(
-      inner: inner.construct
-      captargs: [self.name]
-    )
-  }
-  Patterns::NamedTokenCapture  << {
-    construct: NamedTokenCapture.new(
-      inner: inner.construct
-      captargs: [self.name]
-    )
-  }
-  Patterns::Reduction         << {
-    construct: Reduction.new(
-      inner: inner.construct
-      captargs: [self.code, *self.args]
-    )
-  }
-  
-  ##
-  # The instruction sequence generator for each construction.
-  
-  AnyCharacter    << { sequence: [[:any, 1]] }
-  Character       << { sequence: [[:char, code]] }
-  CharacterString << { sequence: codes.map |code| { [:char, code] } }
-  CharacterSet    << { sequence: [[:charset, table]]
-                          table: codes.map |code| { [code, true] }.to_h }
-  CharacterRange  << { sequence: [[:charrange, start, stop]] }
-  
-  NegativePredicate << {
-    sequence: {
-      a = inner.sequence
-      [[:choice, a.size+2], *a, [:fail_twice]]
-    }
-  }
-  
-  PositivePredicate << {
-    sequence: {
-      a = inner.sequence
-      size = a.size
-      [[:choice, size+4], [:choice, size+1], *a, [:commit, 1], [:fail]]
-    }
-  }
-  
-  OneOrMore << {
-    var inlaid
-    sequence: {
-      one = inner.sequence
-      inlaid && (one = one + inlaid)
-      or_more = ZeroOrMore.new(inner:inner,inlaid:inlaid).sequence
-      [*one, *or_more]
-    }
-  }
-  
-  ZeroOrOne << {
-    sequence: {
-      a = inner.sequence
-      [[:choice, a.size+2], *a, [:commit, 1]]
-    }
-  }
-  
-  ZeroOrMore << {
-    var inlaid
-    sequence:
-      switch(inner, :"is_a?")
-        .when(CharacterSet) { [[:span, inner.table]] }
-        .else {
-          a = inner.sequence
-          inlaid && (a = a + inlaid)
-          size = a.size
-          [[:choice, size+2], *a, [:partial_commit, size*-1]]
-        }
-        .output
-  }
-  
-  OrderedChoice << {
-    sequence: {
-      a = first.sequence
-      b = second.sequence
-      [[:choice, a.size+2], *a, [:commit, b.size+1], *b]
-    }
-  }
-  
-  Concatenation << {
-    sequence: [*first.sequence, *second.sequence]
-  }
-  
-  NamedCapture << {
-    sequence: {
-      (inner.is_a?(OneOrMore) || inner.is_a?(ZeroOrMore)) &? (
-        inner.inlaid = [[:capture, [:m_split, captargs]]]
-        a = inner.sequence
-        [[:capture, [:m_start]], *a, [:capture, [:m_end, captargs]]]
-      ) ?? (
-        a = inner.sequence
-        [[:capture, [:c_start]], *a, [:capture, [:c_end, captargs]]]
-      )
-    }
-  }
-  
-  NamedTextCapture << {
-    sequence: {
-      a = inner.sequence
-      [[:capture, [:s_start]], *a, [:capture, [:s_end, captargs]]]
-    }
-  }
-  
-  NamedTokenCapture << {
-    sequence: {
-      a = inner.sequence
-      [[:capture, [:t_start]], *a, [:capture, [:t_end, captargs]]]
-    }
-  }
-  
-  Reduction << {
-    sequence: {
-      a = inner.sequence
-      [[:capture, [:r_start]], *a, [:capture, [:r_end, captargs]]]
-    }
-  }
-  
-}

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

@@ -1,370 +0,0 @@
-
-::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.cscope.for_method_definition::Constructions = ::Myco::Component.new([::Myco.find_constant(:EmptyObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-.tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  ::Myco.cscope.for_method_definition::Base = ::Myco::Component.new([::Myco.find_constant(:BasicObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}
-  .tap { |__c__| __c__.__name__ = :Base }
-  ::Myco.cscope.for_method_definition::UnaryBase = ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-  .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:inner, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil})}}
-  .tap { |__c__| __c__.__name__ = :UnaryBase }
-  ::Myco.cscope.for_method_definition::BinaryBase = ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-  .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-    declare_meme(:first, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-    declare_meme(:second, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  )}}
-  .tap { |__c__| __c__.__name__ = :BinaryBase }
-  ::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 {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__.__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__.__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__.__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}
-  )}}
-  .tap { |__c__| __c__.__name__ = :CharacterRange }
-  ::Myco.cscope.for_method_definition::NegativePredicate = ::Myco::Component.new([::Myco.find_constant(:UnaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}
-  .tap { |__c__| __c__.__name__ = :NegativePredicate }
-  ::Myco.cscope.for_method_definition::PositivePredicate = ::Myco::Component.new([::Myco.find_constant(:UnaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}
-  .tap { |__c__| __c__.__name__ = :PositivePredicate }
-  ::Myco.cscope.for_method_definition::OneOrMore = ::Myco::Component.new([::Myco.find_constant(:UnaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}
-  .tap { |__c__| __c__.__name__ = :OneOrMore }
-  ::Myco.cscope.for_method_definition::ZeroOrOne = ::Myco::Component.new([::Myco.find_constant(:UnaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}
-  .tap { |__c__| __c__.__name__ = :ZeroOrOne }
-  ::Myco.cscope.for_method_definition::ZeroOrMore = ::Myco::Component.new([::Myco.find_constant(:UnaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}
-  .tap { |__c__| __c__.__name__ = :ZeroOrMore }
-  ::Myco.cscope.for_method_definition::OrderedChoice = ::Myco::Component.new([::Myco.find_constant(:BinaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}
-  .tap { |__c__| __c__.__name__ = :OrderedChoice }
-  ::Myco.cscope.for_method_definition::Concatenation = ::Myco::Component.new([::Myco.find_constant(:BinaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}
-  .tap { |__c__| __c__.__name__ = :Concatenation }
-  ::Myco.cscope.for_method_definition::NamedCapture = ::Myco::Component.new([::Myco.find_constant(:UnaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-  .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:captargs, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil})}}
-  .tap { |__c__| __c__.__name__ = :NamedCapture }
-  ::Myco.cscope.for_method_definition::NamedTextCapture = ::Myco::Component.new([::Myco.find_constant(:UnaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-  .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:captargs, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil})}}
-  .tap { |__c__| __c__.__name__ = :NamedTextCapture }
-  ::Myco.cscope.for_method_definition::NamedTokenCapture = ::Myco::Component.new([::Myco.find_constant(:UnaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-  .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:captargs, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil})}}
-  .tap { |__c__| __c__.__name__ = :NamedTokenCapture }
-  ::Myco.cscope.for_method_definition::Reduction = ::Myco::Component.new([::Myco.find_constant(:UnaryBase)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-  .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:captargs, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil})}}
-  .tap { |__c__| __c__.__name__ = :Reduction }
-  ::Myco.find_constant(:Patterns)::UnaryBase.component_eval {(declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (self.construct_type.new({:inner => self.inner.construct}))})}
-  ::Myco.find_constant(:Patterns)::BinaryBase.component_eval {(declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (self.construct_type.new({
-    :first => self.first.construct,
-    :second => self.second.construct
-  }))})}
-  ::Myco.find_constant(:Patterns)::AnyCharacter.component_eval {(declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:AnyCharacter).new)})}
-  ::Myco.find_constant(:Patterns)::Character.component_eval {(declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Character).new({:code => self.code}))})}
-  ::Myco.find_constant(:Patterns)::CharacterString.component_eval {(declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:CharacterString).new({:codes => self.codes}))})}
-  ::Myco.find_constant(:Patterns)::CharacterSet.component_eval {(declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:CharacterSet).new({:codes => self.codes}))})}
-  ::Myco.find_constant(:Patterns)::CharacterRange.component_eval {(declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:CharacterRange).new({
-    :start => self.start,
-    :stop => self.stop
-  }))})}
-  ::Myco.find_constant(:Patterns)::NegativePredicate.component_eval {(declare_meme(:construct_type, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:NegativePredicate))})}
-  ::Myco.find_constant(:Patterns)::PositivePredicate.component_eval {(declare_meme(:construct_type, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:PositivePredicate))})}
-  ::Myco.find_constant(:Patterns)::OneOrMore.component_eval {(declare_meme(:construct_type, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:OneOrMore))})}
-  ::Myco.find_constant(:Patterns)::ZeroOrOne.component_eval {(declare_meme(:construct_type, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:ZeroOrOne))})}
-  ::Myco.find_constant(:Patterns)::ZeroOrMore.component_eval {(declare_meme(:construct_type, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:ZeroOrMore))})}
-  ::Myco.find_constant(:Patterns)::OrderedChoice.component_eval {(declare_meme(:construct_type, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:OrderedChoice))})}
-  ::Myco.find_constant(:Patterns)::Concatenation.component_eval {(declare_meme(:construct_type, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Concatenation))})}
-  ::Myco.find_constant(:Patterns)::NamedCapture.component_eval {(declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:NamedCapture).new({
-    :inner => self.inner.construct,
-    :captargs => [self.name]
-  }))})}
-  ::Myco.find_constant(:Patterns)::NamedTextCapture.component_eval {(declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:NamedTextCapture).new({
-    :inner => self.inner.construct,
-    :captargs => [self.name]
-  }))})}
-  ::Myco.find_constant(:Patterns)::NamedTokenCapture.component_eval {(declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:NamedTokenCapture).new({
-    :inner => self.inner.construct,
-    :captargs => [self.name]
-  }))})}
-  ::Myco.find_constant(:Patterns)::Reduction.component_eval {(declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Reduction).new({
-    :inner => self.inner.construct,
-    :captargs => [
-      self.code,
-      *self.args
-    ]
-  }))})}
-  ::Myco.find_constant(:AnyCharacter).component_eval {(declare_meme(:sequence, [], nil, ::Myco.cscope.dup) { |*| ([[
-    :any,
-    1
-  ]])})}
-  ::Myco.find_constant(:Character).component_eval {(declare_meme(:sequence, [], nil, ::Myco.cscope.dup) { |*| ([[
-    :char,
-    self.code
-  ]])})}
-  ::Myco.find_constant(:CharacterString).component_eval {(declare_meme(:sequence, [], nil, ::Myco.cscope.dup) { |*| (self.codes.map { |code| ([
-    :char,
-    code
-  ])})})}
-  ::Myco.find_constant(:CharacterSet).component_eval {(
-    declare_meme(:sequence, [], nil, ::Myco.cscope.dup) { |*| ([[
-      :charset,
-      self.table
-    ]])}
-    declare_meme(:table, [], nil, ::Myco.cscope.dup) { |*| (self.codes.map { |code| ([
-      code,
-      true
-    ])}.to_h)}
-  )}
-  ::Myco.find_constant(:CharacterRange).component_eval {(declare_meme(:sequence, [], nil, ::Myco.cscope.dup) { |*| ([[
-    :charrange,
-    self.start,
-    self.stop
-  ]])})}
-  ::Myco.find_constant(:NegativePredicate).component_eval {(declare_meme(:sequence, [], nil, ::Myco.cscope.dup) { |*| (
-    a = self.inner.sequence
-    [
-      [
-        :choice,
-        a.size.__send__(
-          :+,
-          2
-        )
-      ],
-      *a,
-      [:fail_twice]
-    ]
-  )})}
-  ::Myco.find_constant(:PositivePredicate).component_eval {(declare_meme(:sequence, [], nil, ::Myco.cscope.dup) { |*| (
-    a = self.inner.sequence
-    size = a.size
-    [
-      [
-        :choice,
-        size.__send__(
-          :+,
-          4
-        )
-      ],
-      [
-        :choice,
-        size.__send__(
-          :+,
-          1
-        )
-      ],
-      *a,
-      [
-        :commit,
-        1
-      ],
-      [:fail]
-    ]
-  )})}
-  ::Myco.find_constant(:OneOrMore).component_eval {(
-    declare_meme(:inlaid, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-    declare_meme(:sequence, [], nil, ::Myco.cscope.dup) { |*| (
-      one = self.inner.sequence
-      ::Myco.branch_op(:"&&", self.inlaid) {one = one.__send__(
-        :+,
-        self.inlaid
-      )}
-      or_more = ::Myco.find_constant(:ZeroOrMore).new({
-        :inner => self.inner,
-        :inlaid => self.inlaid
-      }).sequence
-      [
-        *one,
-        *or_more
-      ]
-    )}
-  )}
-  ::Myco.find_constant(:ZeroOrOne).component_eval {(declare_meme(:sequence, [], nil, ::Myco.cscope.dup) { |*| (
-    a = self.inner.sequence
-    [
-      [
-        :choice,
-        a.size.__send__(
-          :+,
-          2
-        )
-      ],
-      *a,
-      [
-        :commit,
-        1
-      ]
-    ]
-  )})}
-  ::Myco.find_constant(:ZeroOrMore).component_eval {(
-    declare_meme(:inlaid, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-    declare_meme(:sequence, [], nil, ::Myco.cscope.dup) { |*| (self.switch(
-      self.inner,
-      :is_a?
-    ).when(::Myco.find_constant(:CharacterSet)) { || ([[
-      :span,
-      self.inner.table
-    ]])}.else { || (
-      a = self.inner.sequence
-      ::Myco.branch_op(:"&&", self.inlaid) {a = a.__send__(
-        :+,
-        self.inlaid
-      )}
-      size = a.size
-      [
-        [
-          :choice,
-          size.__send__(
-            :+,
-            2
-          )
-        ],
-        *a,
-        [
-          :partial_commit,
-          size.__send__(
-            :*,
-            -1
-          )
-        ]
-      ]
-    )}.output)}
-  )}
-  ::Myco.find_constant(:OrderedChoice).component_eval {(declare_meme(:sequence, [], nil, ::Myco.cscope.dup) { |*| (
-    a = self.first.sequence
-    b = self.second.sequence
-    [
-      [
-        :choice,
-        a.size.__send__(
-          :+,
-          2
-        )
-      ],
-      *a,
-      [
-        :commit,
-        b.size.__send__(
-          :+,
-          1
-        )
-      ],
-      *b
-    ]
-  )})}
-  ::Myco.find_constant(:Concatenation).component_eval {(declare_meme(:sequence, [], nil, ::Myco.cscope.dup) { |*| ([
-    *self.first.sequence,
-    *self.second.sequence
-  ])})}
-  ::Myco.find_constant(:NamedCapture).component_eval {(declare_meme(:sequence, [], nil, ::Myco.cscope.dup) { |*| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", ::Myco.branch_op(:"||", self.inner.__send__(
-    :is_a?,
-    ::Myco.find_constant(:OneOrMore)
-  )) {self.inner.__send__(
-    :is_a?,
-    ::Myco.find_constant(:ZeroOrMore)
-  )}) {(
-    self.inner.__send__(
-      :inlaid=,
-      [[
-        :capture,
-        [
-          :m_split,
-          self.captargs
-        ]
-      ]]
-    )
-    a = self.inner.sequence
-    [
-      [
-        :capture,
-        [:m_start]
-      ],
-      *a,
-      [
-        :capture,
-        [
-          :m_end,
-          self.captargs
-        ]
-      ]
-    ]
-  )}) {(
-    a = self.inner.sequence
-    [
-      [
-        :capture,
-        [:c_start]
-      ],
-      *a,
-      [
-        :capture,
-        [
-          :c_end,
-          self.captargs
-        ]
-      ]
-    ]
-  )})})}
-  ::Myco.find_constant(:NamedTextCapture).component_eval {(declare_meme(:sequence, [], nil, ::Myco.cscope.dup) { |*| (
-    a = self.inner.sequence
-    [
-      [
-        :capture,
-        [:s_start]
-      ],
-      *a,
-      [
-        :capture,
-        [
-          :s_end,
-          self.captargs
-        ]
-      ]
-    ]
-  )})}
-  ::Myco.find_constant(:NamedTokenCapture).component_eval {(declare_meme(:sequence, [], nil, ::Myco.cscope.dup) { |*| (
-    a = self.inner.sequence
-    [
-      [
-        :capture,
-        [:t_start]
-      ],
-      *a,
-      [
-        :capture,
-        [
-          :t_end,
-          self.captargs
-        ]
-      ]
-    ]
-  )})}
-  ::Myco.find_constant(:Reduction).component_eval {(declare_meme(:sequence, [], nil, ::Myco.cscope.dup) { |*| (
-    a = self.inner.sequence
-    [
-      [
-        :capture,
-        [:r_start]
-      ],
-      *a,
-      [
-        :capture,
-        [
-          :r_end,
-          self.captargs
-        ]
-      ]
-    ]
-  )})}
-)}}
-.tap { |__c__| __c__.__name__ = :Constructions })}}.instance