class Regexp::Expression::Subexpression

def <<(exp) 

def <<(exp)
  if exp.is_a?(WhiteSpace) and @expressions.last and
    @expressions.last.is_a?(WhiteSpace)
    @expressions.last.merge(exp)
  else
    @expressions << exp
  end
end

def [](index) 

def [](index)
  @expressions[index]
end

def all?(&block) 

def all?(&block)
  @expressions.all? {|exp| yield(exp) }
end

def clone

Override base method to clone the expressions as well. 
def clone
  copy = super
  copy.expressions = @expressions.map {|e| e.clone }
  copy
end

def each(&block) 

def each(&block)
  @expressions.each {|e| yield e}
end

def each_expression(include_self = false, &block)

the expression and its index within its parent to the given block.
Iterates over the expressions of this expression as an array, passing 
def each_expression(include_self = false, &block)
  traverse(include_self) do |event, exp, index|
    yield(exp, index) unless event == :exit
  end
end

def each_with_index(&block) 

def each_with_index(&block)
  @expressions.each_with_index {|e, i| yield e, i}
end

def empty? 

def empty?
  @expressions.empty?
end

def first 

def first
  @expressions.first
end

def initialize(token, options = {}) 

def initialize(token, options = {})
  super
  @expressions = []
end

def insert(exp) 

def insert(exp)
  @expressions.insert 0, exp
end

def last 

def last
  @expressions.last
end

def length 

def length
  @expressions.length
end

def map(include_self = false, &block)

each expression and its level index as an array.
for every expression. If a block is not given, returns an array with
Returns a new array with the results of calling the given block once 
def map(include_self = false, &block)
  result = []
  each_expression(include_self) do |exp, index|
    if block_given?
      result << yield(exp, index)
    else
      result << [exp, index]
    end
  end
  result
end

def strfregexp_tree(format = '%a', include_self = true, separator = "\n") 

def strfregexp_tree(format = '%a', include_self = true, separator = "\n")
  output = include_self ? [self.strfregexp(format)] : []
  output += map {|exp, index|
    exp.strfregexp(format, (include_self ? 1 : 0), index)
  }
  output.join(separator)
end

def te 

def te
  ts + to_s.length
end

def to_h 

def to_h
  h = super
  h[:text] = to_s(:base)
  h[:expressions] = @expressions.map(&:to_h)
  h
end

def to_s(format = :full) 

def to_s(format = :full)
  s = ''
  # Note: the format does not get passed down to subexpressions.
  case format
  when :base
    s << @text.dup
    s << @expressions.map{|e| e.to_s}.join unless @expressions.empty?
  else
    s << @text.dup
    s << @expressions.map{|e| e.to_s}.join unless @expressions.empty?
    s << @quantifier if quantified?
  end
  s
end

def traverse(include_self = false, &block)

Returns self.

- For terminal expressions, :visit is called once.

:exit upon exiting it.
- For subexpressions, :enter upon entrering the subexpression, and

The event argument is passed as follows:

the expression, and the index of the expression within its parent.
block for each expression with three arguments; the traversal event,
Traverses the subexpression (depth-first, pre-order) and calls the given 
def traverse(include_self = false, &block)
  raise 'traverse requires a block' unless block_given?
  block.call(:enter, self, 0) if include_self
  each_with_index do |exp, index|
    if exp.terminal?
      block.call(:visit, exp, index)
    else
      block.call(:enter, exp, index)
      exp.traverse(&block)
      block.call(:exit, exp, index)
    end
  end
  block.call(:exit, self, 0) if include_self
  self
end

def ts 

def ts
  starts_at
end