myco 0.1.8 → 0.1.9

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

@@ -1,24 +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::Machine = ::Myco::Component.new([
-  ::Myco.find_constant(:BasicObject),
-  ::Myco.find_constant(:Instructions)
-], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-.tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:ip, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (0)}
-  declare_meme(:ipk, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (:root)}
-  declare_meme(:idx, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (0)}
-  declare_meme(:stack, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ([])}
-  declare_meme(:captures, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ([])}
-  declare_meme(:subject, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ([])}
-  declare_meme(:sequence_table, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Object::Hash.new)}
-  declare_meme(:execute, [], nil, ::Myco.cscope.dup) { |*| (self.loop { || (::Myco.branch_op(:"??", ::Myco.branch_op(:"|?", self.ip) {self.handle_fail}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.ip.__send__(
-    :==,
-    true
-  )) {self.__send__(:break)}) {self.send(*self.sequence_table.fetch(self.ipk).__send__(
-    :[],
-    self.ip
-  ))}})})}
-  declare_meme(:had_failure, [], nil, ::Myco.cscope.dup) { |*| (self.ip.__send__(:!))}
-)}}
-.tap { |__c__| __c__.__name__ = :Machine })}}.instance

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

@@ -1,123 +0,0 @@
-
-Patterns < EmptyObject {
-  
-  ##
-  # Basic types of patterns.
-  
-  Base < BasicObject { var name: parent_meme.name }
-  UnaryBase  < Base { var inner }
-  BinaryBase < Base { var first, var second }
-  
-  AnyCharacter      < Base { }
-  Character         < Base { var code }
-  CharacterString   < Base { var codes } # Concatenation for Characters
-  CharacterSet      < Base { var codes } # OrderedChoice for Characters
-  CharacterRange    < Base { var start, var stop }
-  
-  NegativePredicate < UnaryBase { }
-  PositivePredicate < UnaryBase { }
-  OneOrMore         < UnaryBase { }
-  ZeroOrOne         < UnaryBase { }
-  ZeroOrMore        < UnaryBase { }
-  OrderedChoice     < BinaryBase { }
-  Concatenation     < BinaryBase { }
-  
-  NamedCapture      < UnaryBase { }
-  NamedTextCapture  < UnaryBase { }
-  NamedTokenCapture < UnaryBase { }
-  Reduction         < UnaryBase { var block, var args: [] }
-  
-  ##
-  # Shorthand methods for creating primitive patterns
-  
-  ShorthandMethods < EmptyObject {
-    any:                   AnyCharacter.new
-    char:  |character|        Character.new(code:character.ord)
-    str:   |string|     CharacterString.new(codes:string.each_char.map(&:ord))
-    set:   |string|        CharacterSet.new(codes:string.each_char.map(&:ord))
-    range: |start, stop| CharacterRange.new(start:start.ord, stop:stop.ord)
-    r:     |pattern, &block|  Reduction.new(inner:pattern, block:block)
-  }
-  
-  ##
-  # Operator overloading for combining and modifying patterns.
-  #
-  # Each operation returns a new Pattern object composed of the operands
-  # so that complex grammars can be specified with relatively succint syntax.
-  
-  Base << {
-    "!":         NegativePredicate .new(inner:self)
-    "/": |other| OrderedChoice     .new(first:self, second:other)
-    "+": |other=false|
-      other &? Concatenation       .new(first:self, second:other)
-            ?? OneOrMore           .new(inner:self)
-    "-": |other=false|
-      other &? ErrorCondition      .new() # TODO: add exception handling to Myco
-            ?? ZeroOrOne           .new(inner:self)
-    "*": |other=false|
-      other &? ErrorCondition      .new()
-            ?? ZeroOrMore          .new(inner:self)
-    
-    "[]": |name| NamedCapture      .new(inner:self, name:name)
-    text: |name=:text|
-                 NamedTextCapture  .new(inner:self, name:name)
-    token: |name|
-                 NamedTokenCapture .new(inner:self, name:name)
-    
-    [private]
-    
-    # Add |other| to |orig| in a right-associative tree of type |type|
-    binary_right_assoc: |orig, other, type| {
-      cursor = orig
-      loop {
-        unless(cursor.second.is_a?(type)) { break }
-        cursor = cursor.second
-      }
-      cursor.second = type.new(first:cursor.second, second:other)
-      orig
-    }
-  }
-  
-  NegativePredicate << {
-    # Invert the polarity of the predicate instead of nesting the predicate
-    "!": PositivePredicate.new(inner:inner)
-  }
-  
-  PositivePredicate << {
-    # Invert the polarity of the predicate instead of nesting the predicate
-    "!": NegativePredicate.new(inner:inner)
-  }
-  
-  OrderedChoice << {
-    # Build a right-associative tree if the first operand of another "/"
-    "/": |other|
-      private.binary_right_assoc(self, other, OrderedChoice)
-  }
-  
-  Concatenation << {
-    # Build a right-associative tree if the first operand of another "+"
-    "+": |other=false|
-      other
-        &? private.binary_right_assoc(self, other, Concatenation)
-        ?? OneOrMore.new(inner:self)
-  }
-  
-  ##
-  # Reduction and associated named captures implementation
-  
-  Reduction << {
-    Environment < EmptyObject, BasicDecorators {
-      var captures # A Hash of capture names to values
-      var builder # The fallback delegate for methods that are not capture names
-      
-      method_missing: |name, *args, &block|
-        captures.fetch(name) { builder.__send__(name, *args, &block) }
-      
-      # Implement the action for the reduction in the '!' method.
-      # It will have access to the captures via method_missing.
-      "!": null
-    }
-    
-    code: block.block.compiled_code
-  }
-}

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

@@ -1,164 +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::Patterns = ::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 {(declare_meme(:name, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (self.parent_meme.name)})}}
-  .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 {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 {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 {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(:block, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-    declare_meme(:args, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ([])}
-  )}}
-  .tap { |__c__| __c__.__name__ = :Reduction }
-  ::Myco.cscope.for_method_definition::ShorthandMethods = ::Myco::Component.new([::Myco.find_constant(:EmptyObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-  .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-    declare_meme(:any, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:AnyCharacter).new)}
-    declare_meme(:char, [], nil, ::Myco.cscope.dup) { |character| (::Myco.find_constant(:Character).new({:code => character.ord}))}
-    declare_meme(:str, [], nil, ::Myco.cscope.dup) { |string| (::Myco.find_constant(:CharacterString).new({:codes => string.each_char.map(&:ord)}))}
-    declare_meme(:set, [], nil, ::Myco.cscope.dup) { |string| (::Myco.find_constant(:CharacterSet).new({:codes => string.each_char.map(&:ord)}))}
-    declare_meme(:range, [], nil, ::Myco.cscope.dup) { |start, stop| (::Myco.find_constant(:CharacterRange).new({
-      :start => start.ord,
-      :stop => stop.ord
-    }))}
-    declare_meme(:r, [], nil, ::Myco.cscope.dup) { |pattern, &block| (::Myco.find_constant(:Reduction).new({
-      :inner => pattern,
-      :block => block
-    }))}
-  )}}
-  .tap { |__c__| __c__.__name__ = :ShorthandMethods }
-  ::Myco.find_constant(:Base).component_eval {(
-    declare_meme(:!, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:NegativePredicate).new({:inner => self}))}
-    declare_meme(:/, [], nil, ::Myco.cscope.dup) { |other| (::Myco.find_constant(:OrderedChoice).new({
-      :first => self,
-      :second => other
-    }))}
-    declare_meme(:+, [], nil, ::Myco.cscope.dup) { |other=false| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", other) {::Myco.find_constant(:Concatenation).new({
-      :first => self,
-      :second => other
-    })}) {::Myco.find_constant(:OneOrMore).new({:inner => self})})}
-    declare_meme(:-, [], nil, ::Myco.cscope.dup) { |other=false| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", other) {::Myco.find_constant(:ErrorCondition).new}) {::Myco.find_constant(:ZeroOrOne).new({:inner => self})})}
-    declare_meme(:*, [], nil, ::Myco.cscope.dup) { |other=false| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", other) {::Myco.find_constant(:ErrorCondition).new}) {::Myco.find_constant(:ZeroOrMore).new({:inner => self})})}
-    declare_meme(:[], [], nil, ::Myco.cscope.dup) { |name| (::Myco.find_constant(:NamedCapture).new({
-      :inner => self,
-      :name => name
-    }))}
-    declare_meme(:text, [], nil, ::Myco.cscope.dup) { |name=:text| (::Myco.find_constant(:NamedTextCapture).new({
-      :inner => self,
-      :name => name
-    }))}
-    declare_meme(:token, [], nil, ::Myco.cscope.dup) { |name| (::Myco.find_constant(:NamedTokenCapture).new({
-      :inner => self,
-      :name => name
-    }))}
-    __category__(:private).component_eval {(declare_meme(:binary_right_assoc, [], nil, ::Myco.cscope.dup) { |orig, other, type| (
-      cursor = orig
-      self.loop { || (
-        self.__send__(
-          :unless,
-          cursor.second.__send__(
-            :is_a?,
-            type
-          )
-        ) { || (self.__send__(:break))}
-        cursor = cursor.second
-      )}
-      cursor.__send__(
-        :second=,
-        type.new({
-          :first => cursor.second,
-          :second => other
-        })
-      )
-      orig
-    )})}
-  )}
-  ::Myco.find_constant(:NegativePredicate).component_eval {(declare_meme(:!, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:PositivePredicate).new({:inner => self.inner}))})}
-  ::Myco.find_constant(:PositivePredicate).component_eval {(declare_meme(:!, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:NegativePredicate).new({:inner => self.inner}))})}
-  ::Myco.find_constant(:OrderedChoice).component_eval {(declare_meme(:/, [], nil, ::Myco.cscope.dup) { |other| (self.private.binary_right_assoc(
-    self,
-    other,
-    ::Myco.find_constant(:OrderedChoice)
-  ))})}
-  ::Myco.find_constant(:Concatenation).component_eval {(declare_meme(:+, [], nil, ::Myco.cscope.dup) { |other=false| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", other) {self.private.binary_right_assoc(
-    self,
-    other,
-    ::Myco.find_constant(:Concatenation)
-  )}) {::Myco.find_constant(:OneOrMore).new({:inner => self})})})}
-  ::Myco.find_constant(:Reduction).component_eval {(
-    ::Myco.cscope.for_method_definition::Environment = ::Myco::Component.new([
-      ::Myco.find_constant(:EmptyObject),
-      ::Myco.find_constant(:BasicDecorators)
-    ], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-    .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-      declare_meme(:captures, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-      declare_meme(:builder, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-      declare_meme(:method_missing, [], nil, ::Myco.cscope.dup) { |name, *args, &block| (self.captures.fetch(name) { || (self.builder.__send__(
-        name,
-        *args,
-        &block
-      ))})}
-      declare_meme(:!, [], nil, ::Myco.cscope.dup) { |*| (nil)}
-    )}}
-    .tap { |__c__| __c__.__name__ = :Environment }
-    declare_meme(:code, [], nil, ::Myco.cscope.dup) { |*| (self.block.block.compiled_code)}
-  )}
-)}}
-.tap { |__c__| __c__.__name__ = :Patterns })}}.instance

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

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

data/lib/myco/code_tools/parser/pegleromyces/spec/Builder.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) { |*| ("Builder")}
-  declare_meme(:new_builder, [], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Builder)], ::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_builder))})}
-)}}.instance)}}.instance

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

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

data/lib/myco/code_tools/parser/pegleromyces/spec/BytecodeInstructions.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) { |*| ("BytecodeInstructions")}
-  declare_meme(:instructions, [], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:BytecodeInstructions)], ::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.instructions))})}
-)}}.instance)}}.instance

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

@@ -1,229 +0,0 @@
-
-BasicSpec {
-  name: "Constructions"
-  
-  [tests]
-  
-  specify "AnyCharacter creates a single any instruction": {
-    construct = Constructions::AnyCharacter.new
-    assert_equal(construct.sequence, [
-      [:any, 1]
-    ])
-  }
-  
-  specify "Character creates a single char instruction": {
-    construct = Constructions::Character.new(code:120)
-    assert_equal(construct.sequence, [
-      [:char, 120]
-    ])
-  }
-  
-  specify "CharacterString creates a string of char instructions": {
-    construct = Constructions::CharacterString.new(codes:[120,121,122])
-    assert_equal(construct.sequence, [
-      [:char, 120]
-      [:char, 121]
-      [:char, 122]
-    ])
-  }
-  
-  specify "CharacterSet creates a single charset instruction": {
-    construct = Constructions::CharacterSet.new(codes:[120,121,122])
-    expected_table = [120,121,122].map |code| { [code,true] }.to_h
-    assert_equal(construct.sequence, [
-      [:charset, expected_table]
-    ])
-  }
-  
-  specify "CharacterRange creates a single charrange instruction": {
-    construct = Constructions::CharacterRange.new(start:120, stop:122)
-    assert_equal(construct.sequence, [
-      [:charrange, 120, 122]
-    ])
-  }
-  
-  specify "NegativePredicate assembles choice, fail_twice instructions": {
-    a = Constructions::CharacterString.new(codes:[120,121,122])
-    construct = Constructions::NegativePredicate.new(inner:a)
-    assert_equal(construct.sequence, [
-      [:choice, 5] # ip+5 == L1
-      [:char, 120]
-      [:char, 121]
-      [:char, 122]
-      [:fail_twice]
-    ])             # (L1)
-  }
-  
-  specify "PositivePredicate assembles choice, commit, fail instructions": {
-    a = Constructions::CharacterString.new(codes:[120,121,122])
-    construct = Constructions::PositivePredicate.new(inner:a)
-    assert_equal(construct.sequence, [
-      [:choice, 7] # ip+7 == L1
-      [:choice, 4] # ip+4 == L2
-      [:char, 120]
-      [:char, 121]
-      [:char, 122]
-      [:commit, 1] # ip+1 == L3 (L2)
-      [:fail]      # (L3)
-    ])             # (L1)
-  }
-  
-  specify "OneOrMore assembles UNOPTIMIZED instructions": {
-    a = Constructions::CharacterString.new(codes:[120,121,122])
-    construct = Constructions::OneOrMore.new(inner:a)
-    assert_equal(construct.sequence, [
-      [:char, 120] # TODO: optimize and eliminate the double specification here
-      [:char, 121]
-      [:char, 122]
-      [:choice, 5] # ip+5 == L2
-      [:char, 120] # (L1)
-      [:char, 121]
-      [:char, 122]
-      [:partial_commit, -3] # ip-3 == L1
-    ])             # (L2)
-  }
-  
-  specify "ZeroOrOne assembles choice and commit instructions": {
-    a = Constructions::CharacterString.new(codes:[120,121,122])
-    construct = Constructions::ZeroOrOne.new(inner:a)
-    assert_equal(construct.sequence, [
-      [:choice, 5] # ip+5 == L1
-      [:char, 120]
-      [:char, 121]
-      [:char, 122]
-      [:commit, 1] # ip+1 == L1
-    ])             # (L1)
-  }
-  
-  specify "ZeroOrMore assembles choice and partial_commit instructions": {
-    a = Constructions::CharacterString.new(codes:[120,121,122])
-    construct = Constructions::ZeroOrMore.new(inner:a)
-    assert_equal(construct.sequence, [
-      [:choice, 5] # ip+5 == L2
-      [:char, 120] # (L1)
-      [:char, 121]
-      [:char, 122]
-      [:partial_commit, -3] # ip-3 == L1
-    ])             # (L2)
-  }
-  
-  specify "ZeroOrMore<CharacterSet> creates a single span instruction": {
-    a = Constructions::CharacterSet.new(codes:[120,121,122])
-    construct = Constructions::ZeroOrMore.new(inner:a)
-    expected_table = [120,121,122].map |code| { [code,true] }.to_h
-    assert_equal(construct.sequence, [
-      [:span, expected_table]
-    ])
-  }
-  
-  specify "OrderedChoice assembles choice and commit instructions": {
-    a = Constructions::CharacterString.new(codes:[110,111,112])
-    b = Constructions::CharacterString.new(codes:[120,121,122])
-    construct = Constructions::OrderedChoice.new(first:a, second:b)
-    assert_equal(construct.sequence, [
-      [:choice, 5] # ip+5 == L1
-      [:char, 110]
-      [:char, 111]
-      [:char, 112]
-      [:commit, 4] # ip+4 == L2
-      [:char, 120] # (L1)
-      [:char, 121]
-      [:char, 122]
-    ])             # (L2)
-    
-    a = Constructions::CharacterString.new(codes:[110,111,112])
-    b = Constructions::CharacterString.new(codes:[120,121,122])
-    c = Constructions::CharacterString.new(codes:[130,131,132])
-    construct = Constructions::OrderedChoice.new(first:b, second:c)
-    construct = Constructions::OrderedChoice.new(first:a, second:construct)
-    assert_equal(construct.sequence, [
-      [:choice, 5] # ip+5 == L1
-      [:char, 110]
-      [:char, 111]
-      [:char, 112]
-      [:commit, 9] # ip+9 == L2
-      [:choice, 5] # ip+5 == L3; (L1)
-      [:char, 120]
-      [:char, 121]
-      [:char, 122]
-      [:commit, 4] # ip+4 == L2
-      [:char, 130] # (L3)
-      [:char, 131]
-      [:char, 132]
-    ])             # (L2)
-  }
-  
-  specify "Concatenation simply concatenates the operands": {
-    a = Constructions::CharacterString.new(codes:[110,111,112])
-    b = Constructions::CharacterString.new(codes:[120,121,122])
-    construct = Constructions::Concatenation.new(first:a, second:b)
-    assert_equal(construct.sequence, [
-      [:char, 110]
-      [:char, 111]
-      [:char, 112]
-      [:char, 120]
-      [:char, 121]
-      [:char, 122]
-    ])
-  }
-  
-  specify "NamedCapture assembles capture instructions": {
-    a = Constructions::CharacterString.new(codes:[120,121,122])
-    construct = Constructions::NamedCapture.new(inner:a)
-    assert_equal(construct.sequence, [
-      [:capture, [:c_start]]
-      [:char, 120]
-      [:char, 121]
-      [:char, 122]
-      [:capture, [:c_end, construct.captargs]]
-    ])
-  }
-  
-  specify "NamedCapture of ZeroOrMore has a special multiplicit strategy": {
-    a = Constructions::CharacterString.new(codes:[120,121,122])
-    b = Constructions::ZeroOrMore.new(inner:a)
-    construct = Constructions::NamedCapture.new(inner:b)
-    assert_equal(construct.sequence, [
-      [:capture, [:m_start]]
-      [:choice, 6]
-      [:char, 120]
-      [:char, 121]
-      [:char, 122]
-      [:capture, [:m_split, null]]
-      [:partial_commit, -4]
-      [:capture, [:m_end, null]]
-    ])
-  }
-  
-  specify "NamedCapture of OneOrMore has a special multiplicit strategy": {
-    a = Constructions::CharacterString.new(codes:[120,121,122])
-    b = Constructions::OneOrMore.new(inner:a)
-    construct = Constructions::NamedCapture.new(inner:b)
-    assert_equal(construct.sequence, [
-      [:capture, [:m_start]]
-      [:char, 120]
-      [:char, 121]
-      [:char, 122]
-      [:capture, [:m_split, null]]
-      [:choice, 6]
-      [:char, 120]
-      [:char, 121]
-      [:char, 122]
-      [:capture, [:m_split, null]]
-      [:partial_commit, -4]
-      [:capture, [:m_end, null]]
-    ])
-  }
-  
-  specify "Reduction assembles capture instructions": {
-    a = Constructions::CharacterString.new(codes:[120,121,122])
-    construct = Constructions::Reduction.new(inner:a)
-    assert_equal(construct.sequence, [
-      [:capture, [:r_start]]
-      [:char, 120]
-      [:char, 121]
-      [:char, 122]
-      [:capture, [:r_end, construct.captargs]]
-    ])
-  }
-}