parslet 1.3.0 → 1.4.0

data/example/output/deepest_errors.out

@@ -0,0 +1,54 @@
+--------------------------------------------------------------------------------
+       .    10   .    20
+01 
+02     define f()
+03       @res.name
+04     end
+05   
+Failed to match sequence (LINE_SEPARATOR? BLOCK LINE_SEPARATOR?) at line 2 char 5.
+`- Expected one of [DEFINE_BLOCK, BEGIN_BLOCK] at line 2 char 5.
+   |- Failed to match sequence (define:'define' SPACE name:IDENTIFIER '()' BODY 'end') at line 2 char 15.
+   |  `- Failed to match sequence (body:((LINE_SEPARATOR (BLOCK / EXPRESSION)){1, }) LINE_SEPARATOR) at line 3 char 11.
+   |     `- Expected at least 1 of SPACE? (COMMENT? NEWLINE / ';') SPACE? at line 3 char 11.
+   |        `- Failed to match sequence (SPACE? (COMMENT? NEWLINE / ';') SPACE?) at line 3 char 11.
+   |           `- Expected one of [COMMENT? NEWLINE, ';'] at line 3 char 11.
+   |              |- Failed to match sequence (COMMENT? NEWLINE) at line 3 char 11.
+   |              |  `- Expected "()", but got "\n " at line 3 char 16.
+   |              `- Expected "()", but got "\n " at line 3 char 16.
+   `- Failed to match sequence (pre:((type:'concurrent' SPACE)?) begin:'begin' BODY 'end') at line 2 char 5.
+      `- Expected "()", but got "\n " at line 3 char 16.
+--------------------------------------------------------------------------------
+       .    10   .    20
+01 
+02     define f()
+03       begin
+04         @res.name
+05       end
+06     end
+07   
+Failed to match sequence (LINE_SEPARATOR? BLOCK LINE_SEPARATOR?) at line 2 char 5.
+`- Expected one of [DEFINE_BLOCK, BEGIN_BLOCK] at line 2 char 5.
+   |- Failed to match sequence (define:'define' SPACE name:IDENTIFIER '()' BODY 'end') at line 2 char 15.
+   |  `- Failed to match sequence (body:((LINE_SEPARATOR (BLOCK / EXPRESSION)){1, }) LINE_SEPARATOR) at line 2 char 15.
+   |     `- Expected at least 1 of LINE_SEPARATOR (BLOCK / EXPRESSION) at line 2 char 15.
+   |        `- Failed to match sequence (LINE_SEPARATOR (BLOCK / EXPRESSION)) at line 3 char 7.
+   |           `- Expected one of [BLOCK, EXPRESSION] at line 3 char 7.
+   |              |- Expected one of [DEFINE_BLOCK, BEGIN_BLOCK] at line 3 char 7.
+   |              |  |- Failed to match sequence (define:'define' SPACE name:IDENTIFIER '()' BODY 'end') at line 3 char 7.
+   |              |  |  `- Expected "define", but got "begin\n" at line 3 char 7.
+   |              |  `- Failed to match sequence (pre:((type:'concurrent' SPACE)?) begin:'begin' BODY 'end') at line 3 char 12.
+   |              |     `- Failed to match sequence (body:((LINE_SEPARATOR (BLOCK / EXPRESSION)){1, }) LINE_SEPARATOR) at line 4 char 13.
+   |              |        `- Expected at least 1 of SPACE? (COMMENT? NEWLINE / ';') SPACE? at line 4 char 13.
+   |              |           `- Failed to match sequence (SPACE? (COMMENT? NEWLINE / ';') SPACE?) at line 4 char 13.
+   |              |              `- Expected one of [COMMENT? NEWLINE, ';'] at line 4 char 13.
+   |              |                 |- Failed to match sequence (COMMENT? NEWLINE) at line 4 char 13.
+   |              |                 |  `- Expected "()", but got "\n " at line 4 char 18.
+   |              |                 `- Expected "()", but got "\n " at line 4 char 18.
+   |              `- Failed to match sequence (RES_ACTIONS res_field:((':' name:IDENTIFIER)?)) at line 3 char 7.
+   |                 `- Failed to match sequence (resources:REFERENCE res_actions:(res_action:RES_ACTION_OR_LINK{0, })) at line 3 char 7.
+   |                    `- Failed to match sequence ('@'{1, 2} IDENTIFIER) at line 3 char 7.
+   |                       `- Expected at least 1 of '@' at line 3 char 7.
+   |                          `- Expected "()", but got "\n " at line 4 char 18.
+   `- Failed to match sequence (pre:((type:'concurrent' SPACE)?) begin:'begin' BODY 'end') at line 2 char 5.
+      `- Expected "()", but got "\n " at line 4 char 18.
+--------------------------------------------------------------------------------

data/example/output/nested_errors.out

@@ -0,0 +1,54 @@
+--------------------------------------------------------------------------------
+       .    10   .    20
+01 
+02     define f()
+03       @res.name
+04     end
+05   
+Failed to match sequence (LINE_SEPARATOR? BLOCK LINE_SEPARATOR?) at line 2 char 5.
+`- Expected one of [DEFINE_BLOCK, BEGIN_BLOCK] at line 2 char 5.
+   |- Failed to match sequence (define:'define' SPACE name:IDENTIFIER '()' BODY 'end') at line 2 char 15.
+   |  `- Failed to match sequence (body:((LINE_SEPARATOR (BLOCK / EXPRESSION)){1, }) LINE_SEPARATOR) at line 3 char 11.
+   |     `- Expected at least 1 of SPACE? (COMMENT? NEWLINE / ';') SPACE? at line 3 char 11.
+   |        `- Failed to match sequence (SPACE? (COMMENT? NEWLINE / ';') SPACE?) at line 3 char 11.
+   |           `- Expected one of [COMMENT? NEWLINE, ';'] at line 3 char 11.
+   |              |- Failed to match sequence (COMMENT? NEWLINE) at line 3 char 11.
+   |              |  `- Failed to match [\\r\\n] at line 3 char 11.
+   |              `- Expected ";", but got "." at line 3 char 11.
+   `- Failed to match sequence (pre:((type:'concurrent' SPACE)?) begin:'begin' BODY 'end') at line 2 char 5.
+      `- Expected "begin", but got "defin" at line 2 char 5.
+--------------------------------------------------------------------------------
+       .    10   .    20
+01 
+02     define f()
+03       begin
+04         @res.name
+05       end
+06     end
+07   
+Failed to match sequence (LINE_SEPARATOR? BLOCK LINE_SEPARATOR?) at line 2 char 5.
+`- Expected one of [DEFINE_BLOCK, BEGIN_BLOCK] at line 2 char 5.
+   |- Failed to match sequence (define:'define' SPACE name:IDENTIFIER '()' BODY 'end') at line 2 char 15.
+   |  `- Failed to match sequence (body:((LINE_SEPARATOR (BLOCK / EXPRESSION)){1, }) LINE_SEPARATOR) at line 2 char 15.
+   |     `- Expected at least 1 of LINE_SEPARATOR (BLOCK / EXPRESSION) at line 2 char 15.
+   |        `- Failed to match sequence (LINE_SEPARATOR (BLOCK / EXPRESSION)) at line 3 char 7.
+   |           `- Expected one of [BLOCK, EXPRESSION] at line 3 char 7.
+   |              |- Expected one of [DEFINE_BLOCK, BEGIN_BLOCK] at line 3 char 7.
+   |              |  |- Failed to match sequence (define:'define' SPACE name:IDENTIFIER '()' BODY 'end') at line 3 char 7.
+   |              |  |  `- Expected "define", but got "begin\n" at line 3 char 7.
+   |              |  `- Failed to match sequence (pre:((type:'concurrent' SPACE)?) begin:'begin' BODY 'end') at line 3 char 12.
+   |              |     `- Failed to match sequence (body:((LINE_SEPARATOR (BLOCK / EXPRESSION)){1, }) LINE_SEPARATOR) at line 4 char 13.
+   |              |        `- Expected at least 1 of SPACE? (COMMENT? NEWLINE / ';') SPACE? at line 4 char 13.
+   |              |           `- Failed to match sequence (SPACE? (COMMENT? NEWLINE / ';') SPACE?) at line 4 char 13.
+   |              |              `- Expected one of [COMMENT? NEWLINE, ';'] at line 4 char 13.
+   |              |                 |- Failed to match sequence (COMMENT? NEWLINE) at line 4 char 13.
+   |              |                 |  `- Failed to match [\\r\\n] at line 4 char 13.
+   |              |                 `- Expected ";", but got "." at line 4 char 13.
+   |              `- Failed to match sequence (RES_ACTIONS res_field:((':' name:IDENTIFIER)?)) at line 3 char 7.
+   |                 `- Failed to match sequence (resources:REFERENCE res_actions:(res_action:RES_ACTION_OR_LINK{0, })) at line 3 char 7.
+   |                    `- Failed to match sequence ('@'{1, 2} IDENTIFIER) at line 3 char 7.
+   |                       `- Expected at least 1 of '@' at line 3 char 7.
+   |                          `- Expected "@", but got "b" at line 3 char 7.
+   `- Failed to match sequence (pre:((type:'concurrent' SPACE)?) begin:'begin' BODY 'end') at line 2 char 5.
+      `- Expected "begin", but got "defin" at line 2 char 5.
+--------------------------------------------------------------------------------

data/lib/parslet.rb

@@ -34,41 +34,40 @@
 #
 # == Further reading
 # 
-# All parslet atoms are subclasses of Parslet::Atoms::Base. You might want to
-# look at all of those: Parslet::Atoms::Re, Parslet::Atoms::Str,
-# Parslet::Atoms::Repetition, Parslet::Atoms::Sequence,
-# Parslet::Atoms::Alternative.
+# All parslet atoms are subclasses of {Parslet::Atoms::Base}. You might want to
+# look at all of those: {Parslet::Atoms::Re}, {Parslet::Atoms::Str},
+# {Parslet::Atoms::Repetition}, {Parslet::Atoms::Sequence},
+# {Parslet::Atoms::Alternative}.
 #
 # == When things go wrong
 #
-# A parse that fails will raise Parslet::ParseFailed. A detailed explanation
-# of what went wrong can be obtained from the parslet involved or the root of
-# the parser instance. 
+# A parse that fails will raise {Parslet::ParseFailed}. This exception contains
+# all the details of what went wrong, including a detailed error trace that 
+# can be printed out as an ascii tree. ({Parslet::Cause})
 #
 module Parslet
-  def self.included(base) # :nodoc:
+  # Extends classes that include Parslet with the module
+  # {Parslet::ClassMethods}.
+  #
+  def self.included(base)
     base.extend(ClassMethods)
   end
   
-  # Raised when the parse failed to match or to consume all its input. It
-  # contains the message that should be presented to the user. If you want to
-  # display more error explanation, you can print the #error_tree that is
-  # stored in the parslet. This is a graphical representation of what went
-  # wrong. 
-  #
-  # Example: 
-  #     
+  # Raised when the parse failed to match. It contains the message that should
+  # be presented to the user. More details can be extracted from the
+  # exceptions #cause member: It contains an instance of {Parslet::Cause} that
+  # stores all the details of your failed parse in a tree structure. 
+  #
   #   begin
   #     parslet.parse(str)
   #   rescue Parslet::ParseFailed => failure
-  #     puts parslet.error_tree
+  #     puts failure.cause.ascii_tree
   #   end
   #
-  # Alternatively, you can just require 'parslet/convenience' and call 
-  # the method #parse_with_debug instead of #parse. This method will never 
-  # raise and print error trees to stdout.
+  # Alternatively, you can just require 'parslet/convenience' and call the
+  # method #parse_with_debug instead of #parse. This method will never raise
+  # and print error trees to stdout.
   #
-  # Example: 
   #   require 'parslet/convenience'
   #   parslet.parse_with_debug(str)
   #
@@ -77,7 +76,11 @@ module Parslet
       super(message)
       @cause = cause
     end
-    attr_reader :cause
+    
+    # Why the parse failed. 
+    #
+    # @return [Parslet::Cause]
+    attr_reader :cause 
   end
   
   # Raised when the parse operation didn't consume all of its input. In this
@@ -85,6 +88,14 @@ module Parslet
   # parser worked just fine, but didn't account for the characters at the tail
   # of the input?
   #
+  #   str('foo').parse('foobar')
+  #   # raises Parslet::UnconsumedInput: 
+  #   #   Don't know what to do with "bar" at line 1 char 4.
+  #
+  # Note that you can have parslet ignore this error: 
+  #
+  #   str('foo').parse('foobar', prefix: true)  # => "foo"@0
+  #
   class UnconsumedInput < ParseFailed
   end
   
@@ -92,14 +103,12 @@ module Parslet
     # Define an entity for the parser. This generates a method of the same
     # name that can be used as part of other patterns. Those methods can be
     # freely mixed in your parser class with real ruby methods.
-    #
-    # Example: 
-    #
+    # 
     #   class MyParser
     #     include Parslet
     #
-    #     rule :bar { str('bar') }
-    #     rule :twobar do
+    #     rule(:bar) { str('bar') }
+    #     rule(:twobar) do
     #       bar >> bar
     #     end
     #
@@ -123,7 +132,8 @@ module Parslet
 
   # Allows for delayed construction of #match. See also Parslet.match.
   #
-  class DelayedMatchConstructor # :nodoc:
+  # @api private
+  class DelayedMatchConstructor
     def [](str)
       Atoms::Re.new("[" + str + "]")
     end
@@ -132,8 +142,6 @@ module Parslet
   # Returns an atom matching a character class. All regular expressions can be
   # used, as long as they match only a single character at a time. 
   #
-  # Example: 
-  #
   #   match('[ab]')     # will match either 'a' or 'b'
   #   match('[\n\s]')   # will match newlines and spaces
   #
@@ -142,6 +150,10 @@ module Parslet
   #   match['a-z']      # synonymous to match('[a-z]')
   #   match['\n']       # synonymous to match('[\n]')
   #
+  # @overload match(str)
+  #   @param str [String] character class to match (regexp syntax)
+  #   @return [Parslet::Atoms::Re] a parslet atom
+  #
   def match(str=nil)
     return DelayedMatchConstructor.new unless str
     
@@ -149,12 +161,13 @@ module Parslet
   end
   module_function :match
   
-  # Returns an atom matching the +str+ given. 
-  #
-  # Example: 
+  # Returns an atom matching the +str+ given:
   #
   #   str('class')      # will match 'class' 
   #
+  # @param str [String] string to match verbatim
+  # @return [Parslet::Atoms::Str] a parslet atom
+  # 
   def str(str)
     Atoms::Str.new(str)
   end
@@ -163,10 +176,10 @@ module Parslet
   # Returns an atom matching any character. It acts like the '.' (dot)
   # character in regular expressions.
   #
-  # Example: 
-  #
   #   any.parse('a')    # => 'a'
   #
+  # @return [Parslet::Atoms::Re] a parslet atom
+  #
   def any
     Atoms::Re.new('.')
   end
@@ -175,39 +188,43 @@ module Parslet
   # A special kind of atom that allows embedding whole treetop expressions
   # into parslet construction. 
   #
-  # Example: 
+  #   # the same as str('a') >> str('b').maybe
+  #   exp(%Q("a" "b"?))     
   #
-  #   exp(%Q("a" "b"?))     # => returns the same as str('a') >> str('b').maybe
+  # @param str [String] a treetop expression
+  # @return [Parslet::Atoms::Base] the corresponding parslet parser
   #
-  def exp(str) # :nodoc:
+  def exp(str)
     Parslet::Expression.new(str).to_parslet
   end
   module_function :exp
   
-  # Returns a placeholder for a tree transformation that will only match a 
-  # sequence of elements. The +symbol+ you specify will be the key for the 
+  # Returns a placeholder for a tree transformation that will only match a
+  # sequence of elements. The +symbol+ you specify will be the key for the
   # matched sequence in the returned dictionary.
   #
-  # Example: 
-  #
   #   # This would match a body element that contains several declarations.
   #   { :body => sequence(:declarations) }
   #
-  # The above example would match :body => ['a', 'b'], but not :body => 'a'. 
+  # The above example would match <code>:body => ['a', 'b']</code>, but not
+  # <code>:body => 'a'</code>. 
+  #
+  # see {Parslet::Transform}
   #
   def sequence(symbol)
     Pattern::SequenceBind.new(symbol)
   end
   module_function :sequence
   
-  # Returns a placeholder for a tree transformation that will only match 
-  # simple elements. This matches everything that #sequence doesn't match.
-  #
-  # Example: 
+  # Returns a placeholder for a tree transformation that will only match
+  # simple elements. This matches everything that <code>#sequence</code>
+  # doesn't match.
   #
   #   # Matches a single header. 
   #   { :header => simple(:header) }
   #
+  # see {Parslet::Transform}
+  #
   def simple(symbol)
     Pattern::SimpleBind.new(symbol)
   end
@@ -216,8 +233,6 @@ module Parslet
   # Returns a placeholder for tree transformation patterns that will match 
   # any kind of subtree. 
   #
-  # Example: 
-  #
   #   { :expression => subtree(:exp) }
   #
   def subtree(symbol)
@@ -231,10 +246,9 @@ end
 require 'parslet/slice'
 require 'parslet/cause'
 require 'parslet/source'
-require 'parslet/error_tree'
 require 'parslet/atoms'
 require 'parslet/pattern'
 require 'parslet/pattern/binding'
 require 'parslet/transform'
 require 'parslet/parser'
-require 'parslet/bytecode'
+require 'parslet/error_reporter'

data/lib/parslet/atoms.rb

@@ -5,7 +5,7 @@ module Parslet::Atoms
   # The precedence module controls parenthesis during the #inspect printing
   # of parslets. It is not relevant to other aspects of the parsing. 
   #
-  module Precedence # :nodoc:
+  module Precedence
     prec = 0
     BASE       = (prec+=1)    # everything else
     LOOKAHEAD  = (prec+=1)    # &SOMETHING

data/lib/parslet/atoms/alternative.rb

@@ -26,26 +26,25 @@ class Parslet::Atoms::Alternative < Parslet::Atoms::Base
   # Don't construct a hanging tree of Alternative parslets, instead store them
   # all here. This reduces the number of objects created.
   #+++
-  def |(parslet) # :nodoc:
+  def |(parslet)
     self.class.new(*@alternatives + [parslet])
   end
   
-  def try(source, context) # :nodoc:
-    alternatives.each { |a|
-      value = a.apply(source, context)
-      return value unless value.error?
+  def try(source, context)
+    errors = alternatives.map { |a|
+      success, value = result = a.apply(source, context)
+      return result if success
+      
+      # Aggregate all errors
+      value
     }
+    
     # If we reach this point, all alternatives have failed. 
-    error(source, @error_msg)
+    context.err(self, source, @error_msg, errors)
   end
 
   precedence ALTERNATE
-  def to_s_inner(prec) # :nodoc:
+  def to_s_inner(prec)
     alternatives.map { |a| a.to_s(prec) }.join(' / ')
   end
-
-  def error_tree # :nodoc:
-    Parslet::ErrorTree.new(self, *alternatives.
-      map { |child| child.error_tree })
-  end
 end

data/lib/parslet/atoms/base.rb

@@ -8,99 +8,84 @@ class Parslet::Atoms::Base
   include Parslet::Atoms::DSL
   include Parslet::Atoms::CanFlatten
   
-  # Internally, all parsing functions return either an instance of Fail 
-  # or an instance of Success. 
-  #
-  class Fail < Struct.new(:message)
-    def error?; true end
-  end
-
-  # Internally, all parsing functions return either an instance of Fail 
-  # or an instance of Success.
-  #
-  class Success < Struct.new(:result)
-    def error?; false end
-  end
-  
   # Given a string or an IO object, this will attempt a parse of its contents
   # and return a result. If the parse fails, a Parslet::ParseFailed exception
   # will be thrown. 
   #
-  def parse(io, traditional=true)
-    if traditional
-      parse_traditional(io)
-    else
-      parse_vm(io)
-    end
-  end
-  
-  def parse_vm(io)
-    compiler = Parslet::Bytecode::Compiler.new
-    program = compiler.compile(self)
-    
-    vm = Parslet::Bytecode::VM.new
-    vm.run(program, io)
-  end
-  
-  def parse_traditional(io)
-    source = Parslet::Source.new(io)
-    context = Parslet::Atoms::Context.new
-    
-    result = nil
-    value = apply(source, context)
+  # @param io [String, Source] input for the parse process
+  # @option options [Parslet::ErrorReporter] :reporter error reporter to use, 
+  #   defaults to Parslet::ErrorReporter::Tree 
+  # @option options [Boolean] :prefix Should a prefix match be accepted? 
+  #   (default: false)
+  # @return [Hash, Array, Parslet::Slice] PORO (Plain old Ruby object) result
+  #   tree
+  #
+  def parse(io, options={})
+    source = io.respond_to?(:line_and_column) ? 
+      io : 
+      Parslet::Source.new(io)
+
+    # Try to cheat. Assuming that we'll be able to parse the input, don't 
+    # run error reporting code. 
+    success, value = setup_and_apply(source, nil)
     
     # If we didn't succeed the parse, raise an exception for the user. 
     # Stack trace will be off, but the error tree should explain the reason
     # it failed.
-    if value.error?
-      @last_cause = value.message
-      @last_cause.raise
+    unless success
+      # Cheating has not paid off. Now pay the cost: Rerun the parse,
+      # gathering error information in the process.
+      reporter = options[:reporter] || Parslet::ErrorReporter::Tree.new
+      success, value = setup_and_apply(source, reporter)
+      
+      fail "Assertion failed: success was true when parsing with reporter" \
+        if success
+      
+      # Value is a Parslet::Cause, which can be turned into an exception:
+      value.raise
+      
+      fail "NEVER REACHED"
     end
     
-    # assert: value is a success answer
+    # assert: success is true
     
     # If we haven't consumed the input, then the pattern doesn't match. Try
     # to provide a good error message (even asking down below)
-    unless source.eof?
-      # Do we know why we stopped matching input? If yes, that's a good
-      # error to fail with. Otherwise just report that we cannot consume the
-      # input.
-      if cause 
-        # NOTE We don't overwrite last_cause here.
-        raise Parslet::UnconsumedInput, 
-          "Unconsumed input, maybe because of this: #{cause}"
-      else
-        old_pos = source.pos
-        @last_cause = source.error(
-          "Don't know what to do with #{source.read(100)}", old_pos)
-
-        @last_cause.raise(Parslet::UnconsumedInput)
-      end
+    if !options[:prefix] && !source.eof?
+      old_pos = source.pos
+      Parslet::Cause.format(
+        source, old_pos, 
+        "Don't know what to do with #{source.consume(10).to_s.inspect}").
+        raise(Parslet::UnconsumedInput)
     end
     
-    return flatten(value.result)
+    return flatten(value)
+  end
+  
+  # Creates a context for parsing and applies the current atom to the input. 
+  # Returns the parse result. 
+  #
+  # @return [<Boolean, Object>] Result of the parse. If the first member is 
+  #   true, the parse has succeeded. 
+  def setup_and_apply(source, error_reporter)
+    context = Parslet::Atoms::Context.new(error_reporter)
+    apply(source, context)
   end
 
   #---
   # Calls the #try method of this parslet. In case of a parse error, apply
   # leaves the source in the state it was before the attempt. 
   #+++
-  def apply(source, context) # :nodoc:
+  def apply(source, context)
     old_pos = source.pos
     
-    result = context.cache(self, source) {
-      try(source, context)
-    }
-    
-    # This has just succeeded, so last_cause must be empty
-    unless result.error?
-      @last_cause = nil 
-      return result
-    end
+    success, value = result = context.try_with_cache(self, source)
+
+    return result if success
     
     # We only reach this point if the parse has failed. Rewind the input.
     source.pos = old_pos
-    return result # is instance of Fail
+    return result
   end
   
   # Override this in your Atoms::Base subclasses to implement parsing
@@ -111,54 +96,27 @@ class Parslet::Atoms::Base
       "Atoms::Base doesn't have behaviour, please implement #try(source, context)."
   end
 
-
   # Debug printing - in Treetop syntax. 
   #
-  def self.precedence(prec) # :nodoc:
+  def self.precedence(prec)
     define_method(:precedence) { prec }
   end
   precedence BASE
-  def to_s(outer_prec=OUTER) # :nodoc:
+  def to_s(outer_prec=OUTER)
     if outer_prec < precedence
       "("+to_s_inner(precedence)+")"
     else
       to_s_inner(precedence)
     end
   end
-  def inspect # :nodoc:
+  def inspect
     to_s(OUTER)
   end
-
-  # Cause should return the current best approximation of this parslet
-  # of what went wrong with the parse. Not relevant if the parse succeeds, 
-  # but needed for clever error reports. 
-  #
-  def cause # :nodoc:
-    @last_cause && @last_cause.to_s || nil
-  end
-  def cause? # :nodoc:
-    !!@last_cause
-  end
-
-  # Error tree returns what went wrong here plus what went wrong inside 
-  # subexpressions as a tree. The error stored for this node will be equal
-  # to #cause. 
-  #
-  def error_tree
-    Parslet::ErrorTree.new(self)
-  end
 private
 
   # Produces an instance of Success and returns it. 
   #
-  def success(result)
-    Success.new(result)
-  end
-
-  # Produces an instance of Fail and returns it. 
-  #
-  def error(source, str, pos=nil)
-    @last_cause = source.error(str, pos)
-    Fail.new(@last_cause)
+  def succ(result)
+    [true, result]
   end
 end