yaparc 0.1.6 → 0.2.0

data/README

@@ -19,39 +19,39 @@ All parsers has 'parse' method, each of which takes input string as its argument
 
 == Primitive Parsers
 
-* SucceedParser
-* FailParser
-* ItemParser
-* SatisfyParser
+* Succeed
+* Fail
+* Item
+* Satisfy
 
-=== SucceedParser class
+=== Succeed class
 
-The parser SucceedParser always succeeds with the result value, without consuming any of the input string.
-In the following example, SucceedParser#parse takes an input string "blah, blah, blah" and returns the singleton array [[1, "blah, blah, blah"]].
+The parser Succeed always succeeds with the result value, without consuming any of the input string.
+In the following example, Succeed#parse takes an input string "blah, blah, blah" and returns the singleton array [[1, "blah, blah, blah"]].
 
-    parser = Yaparc::SucceedParser.new(1)
+    parser = Yaparc::Succeed.new(1)
     parser.parse("blah, blah, blah")
     => #<Yaparc::Result::OK:0xb7aaaf5c @input="blah, blah, blah", @value=1>
 
-=== FailParser class
+=== Fail class
 
-The parser FailParser always fails, regardless of the contents of the input string.
+The parser Fail always fails, regardless of the contents of the input string.
 
-    parser = Yaparc::FailParser.new
+    parser = Yaparc::Fail.new
     parser.parse("abc")
     => #<Yaparc::Result::Fail:0xb7aa56b0 @value=nil>
 
-=== ItemParser class
+=== Item class
 
-The parser ItemParser fails if the input string is empty, and succeeds with the first character as the result value otherwise.
+The parser Item fails if the input string is empty, and succeeds with the first character as the result value otherwise.
 
-    parser = Yaparc::ItemParser.new
+    parser = Yaparc::Item.new
     parser.parse("abc")
     => #<Yaparc::Result::OK:0xb7a9fdb4 @input="bc", @value="a">
 
-=== SatisfyParser class
+=== Satisfy class
 
-The parser SatisfyParser recognizes a single input via predicate which determines if an arbitrary input is suitable for the predicate.
+The parser Satisfy recognizes a single input via predicate which determines if an arbitrary input is suitable for the predicate.
 
     is_integer = lambda do |i|
       begin
@@ -61,31 +61,31 @@ The parser SatisfyParser recognizes a single input via predicate which determine
         false
       end
     end
-    parser = Yaparc::SatisfyParser.new(is_integer)
+    parser = Yaparc::Satisfy.new(is_integer)
     parser.parse("123")
     => #<Yaparc::Result::OK:0xb7a8f284 @input="23", @value="1">
 
 
 == Combining Parsers
 
-* AltParser
-* SeqParser
-* ManyParser
-* ManyOneParser
+* Alt
+* Seq
+* Many
+* ManyOne
 
 
   
 === Sequencing parser
 
-The SeqParser corresponds to sequencing in BNF. The following parser recognizes anything that Symbol.new('+') or Natural.new would if placed in succession.
+The Seq corresponds to sequencing in BNF. The following parser recognizes anything that Symbol.new('+') or Natural.new would if placed in succession.
 
-  parser = SeqParser.new(Symbol.new('+'), Natural.new)
+  parser = Seq.new(Symbol.new('+'), Natural.new)
   parser.parse("+321")
   => #<Yaparc::Result::OK:0xb7a81ae4 @input="", @value=321>
 
-if a block given to SeqParser, it analyses input string to construct its logical structure.
+if a block given to Seq, it analyses input string to construct its logical structure.
 
-  parser = Yaparc::SeqParser.new(Yaparc::Symbol.new('+'), Yaparc::Natural.new) do | plus, nat|
+  parser = Yaparc::Seq.new(Yaparc::Symbol.new('+'), Yaparc::Natural.new) do | plus, nat|
     nat
   end
   parser.parse("+1234")
@@ -95,11 +95,11 @@ It produces a parse tree which expounds the semantic structure of the program.
 
 === Alternation parser
 
-The parser AltParser class is an alternation parser, which returns the result of the first parser to succeed, and failure if neither does.
+The parser Alt class is an alternation parser, which returns the result of the first parser to succeed, and failure if neither does.
 
 
-  parser = Yaparc::AltParser.new(
-                          Yaparc::SeqParser.new(Yaparc::Symbol.new('+'), Yaparc::Natural.new) do | _, nat|
+  parser = Yaparc::Alt.new(
+                          Yaparc::Seq.new(Yaparc::Symbol.new('+'), Yaparc::Natural.new) do | _, nat|
                             nat
                           end,
                           Yaparc::Natural.new
@@ -110,17 +110,17 @@ The parser AltParser class is an alternation parser, which returns the result of
   => #<Yaparc::Result::Fail:0xb7a57ba4 @value=nil>
 
 
-=== ManyParser
+=== Many
 
-In ManyParser, zero or more applications of parser are admissible.
+In Many, zero or more applications of parser are admissible.
 
-    parser = Yaparc::ManyParser.new(Yaparc::SatisfyParser.new(lambda {|i| i > '0' and i < '9'}))
+    parser = Yaparc::Many.new(Yaparc::Satisfy.new(lambda {|i| i > '0' and i < '9'}))
     parser.parse("123abc")
     => #<Yaparc::Result::OK:0xb7a49dc4 @input="abc", @value="123">
 
-=== ManyOneParser
+=== ManyOne
 
-The ManyOneParser requires at least one successfull application of parser.
+The ManyOne requires at least one successfull application of parser.
 
 
 == Tokenized parser
@@ -143,7 +143,7 @@ In order to construct parsers, you make parser class to be inherited from Yaparc
   class Identifier < Yaparc::AbstractParser
     def initialize
       @parser = lambda do
-        Yaparc::Token.new(Yaparc::Ident.new)
+        Yaparc::Tokenize.new(Yaparc::Ident.new)
       end
     end
   end
@@ -154,8 +154,8 @@ In the following example, note that Expr class is instantiated inside Expr#initi
   class Expr < Yaparc::AbstractParser
     def initialize
       @parser = lambda do
-        Yaparc::AltParser.new(
-                              Yaparc::SeqParser.new(Term.new,
+        Yaparc::Alt.new(
+                              Yaparc::Seq.new(Term.new,
                                                     Yaparc::Symbol.new('+'),
                                                     Expr.new) do |term, _, expr|
                                 ['+', term,expr]

data/lib/yaparc.rb

@@ -56,18 +56,13 @@ module Yaparc
     module ClassMethods
       def included(mod)
       end
-
-#       def define_parser(&block)
-#         @@cparser = lambda do
-#           yield
-#         end
-#       end
     end
   end # of Module Parsable
 
 
 
-  class SucceedParser
+#  class SucceedParser
+  class Succeed
     include Parsable
     attr_reader :remaining
     def initialize(value, remaining = nil)
@@ -78,7 +73,8 @@ module Yaparc
     end
   end
 
-  class FailParser
+#  class FailParser
+  class Fail
     include Parsable
     def initialize
       @parser = lambda do |input|
@@ -89,7 +85,8 @@ module Yaparc
 
 
 
-  class ItemParser
+#  class ItemParser
+  class Item
     include Parsable
     def initialize
       @parser = lambda do |input|
@@ -102,13 +99,15 @@ module Yaparc
     end
   end
 
-  class ZeroOneParser
+#  class ZeroOneParser
+  class ZeroOne
     include Parsable
     def initialize(parser, identity = [])
       @parser = lambda do |input|
         case result = parser.parse(input)
         when Result::Fail
-          SucceedParser.new(identity)
+          Result::OK.new(:value => identity, :input => input)
+#          Succeed.new(identity)
         when Result::Error
           Result::Error.new(:value => result.value, :input => result.input)
         when Result::OK
@@ -117,8 +116,8 @@ module Yaparc
           raise
         end
 
-#        AltParser.new(parser, SucceedParser.new(identity))
-#         case result = AltParser.new(parser, SucceedParser.new(identity)).parse(input)
+#        AltParser.new(parser, Succeed.new(identity))
+#         case result = AltParser.new(parser, Succeed.new(identity)).parse(input)
 #         if input.nil? or input.empty?
 #           Result::Fail.new(:input => input)
 #         else
@@ -129,30 +128,31 @@ module Yaparc
     end
   end
 
-  class SatisfyParser
+#  class SatisfyParser
+  class Satisfy
     include Parsable
     def initialize(predicate)
       raise unless predicate.instance_of?(Proc)
 
       @parser = lambda do |input|
-        case result = ItemParser.new.parse(input)
+        case result = Item.new.parse(input)
         when Result::OK
           parser = if predicate.call(result.value)
-                     SucceedParser.new(result.value, result.input)
+                     Succeed.new(result.value, result.input)
                    else
-                     FailParser.new
+                     Fail.new
                    end
         else # Result::Fail or Result::Error
-          FailParser.new
+          Fail.new
         end
       end
     end
 
     def parse(input)
       case parser = @parser.call(input)
-      when SucceedParser
+      when Succeed
         parser.parse(parser.remaining)
-      when FailParser
+      when Fail
         parser.parse(input)
       else
         raise
@@ -171,9 +171,9 @@ module Yaparc
         when Result::Fail
           Result::Error.new(:value => result.value, :input => result.input)
         when Result::OK
-          SucceedParser.new(result.value)
+          Succeed.new(result.value)
         else
-          SucceedParser.new(result.value)
+          Succeed.new(result.value)
 #          Result::OK.new(:value => result.value,:input => result.input)
         end
       end
@@ -181,7 +181,8 @@ module Yaparc
   end # of NoFail
 
 
-  class SeqParser
+#  class SeqParser
+  class Seq
     include Parsable
     def initialize(*parsers, &block)
       @parser = lambda do |input|
@@ -191,6 +192,8 @@ module Yaparc
           case result = parser.parse(subsequent.input)
           when Result::Fail
             break Result::Fail.new(:input => subsequent.input)
+#           when Result::Error
+#             break Result::Error.new(:input => subsequent.input)
           else
             args << result.value
             result
@@ -212,10 +215,11 @@ module Yaparc
         end
       end
     end # of initialize
-  end # of SeqParser
+  end # of Seq
 
 
-  class AltParser
+#  class AltParser
+  class Alt
     include Parsable
     def initialize(*parsers)
       @parser = lambda do |input|
@@ -239,48 +243,48 @@ module Yaparc
     end # of initialize
   end
 
-
-
-  class ApplyParser
+#  class ApplyParser
+  class Apply
     include Parsable
     def initialize(parser, &block)
       @parser = lambda do |input|
         case result = parser.parse(input)
         when Result::OK
-          SucceedParser.new(yield(result.value)).parse(result.input)
+          Succeed.new(yield(result.value)).parse(result.input)
         else
-          FailParser.new.parse(input)
+          Fail.new.parse(input)
         end
       end
     end # of initialize
-  end # of ApplyParser
+  end # of Apply
 
 
-  class StringParser
+  class String
     include Parsable
     def initialize(string)
       @parser = lambda do |input|
-        case result = ItemParser.new.parse(string)
+        case result = Item.new.parse(string)
         when Result::OK
-          SeqParser.new(
-                        CharParser.new(result.value),
-                        StringParser.new(result.input),
-                        SucceedParser.new(result.value + result.input)
-                        ) do |char_result, string_result, succeed_result|
+          Seq.new(
+                  Char.new(result.value),
+                  Yaparc::String.new(result.input),
+                  Succeed.new(result.value + result.input)
+                  ) do |char_result, string_result, succeed_result|
             succeed_result
           end
         else
-          SucceedParser.new(result) # Is it OK?
+          Succeed.new(result) # Is it OK?
         end
       end
     end
 
-    def parse(input)
-      @parser.call(input).parse(input)
-    end
+#     def parse(input)
+#       @parser.call(input).parse(input)
+#     end
   end
 
-  class RegexParser
+#  class RegexParser
+  class Regex
     include Parsable
     
     def initialize(regex, &block)
@@ -288,7 +292,7 @@ module Yaparc
       @parser = lambda do |input|
         if match = Regexp.new(regex).match(input)
           if block_given?
-            SucceedParser.new(yield(*match.to_a[1..match.to_a.length])).parse(match.post_match)
+            Succeed.new(yield(*match.to_a[1..match.to_a.length])).parse(match.post_match)
           else
             Result::OK.new(:value => match[0], :input => match.post_match)
           end
@@ -310,89 +314,93 @@ module Yaparc
       end
     end
   end
-#   class RegexParser
-#     include Parsable
-
-#     def initialize(regex)
-#       @parser = lambda do |input|
-#         if match = Regexp.new(regex).match(input)
-#           Result::OK.new(:value => match[0], :input => match.post_match)
-#         else
-#           Result::Fail.new(:input => input)
-#         end
-#       end
-#     end
-#   end
 
   # permits zero or more applications of parser.
-  class ManyParser
+#  class ManyParser
+  class Many
     include Parsable
     def initialize(parser, identity = [])
       @parser = lambda do |input|
-        AltParser.new(ManyOneParser.new(parser, identity), SucceedParser.new(identity))
+        Alt.new(ManyOne.new(parser, identity), Succeed.new(identity))
       end
     end
-
-#     def parse(input)
-#       @parser.call(input).parse(input)
-#     end
   end
 
   # requires at least one successfull application of parser.
-  class ManyOneParser
+#  class ManyOne
+  class ManyOne
     include Parsable
     def initialize(parser, identity = [])
       @parser = lambda do |input|
-        SeqParser.new(
-                      parser,
-                      ManyParser.new(parser, identity)
-                      ) do |head, tail|
-          head + tail
+        Seq.new(parser, Many.new(parser, identity)) do |head, tail|
+          case head
+          when ::String
+            if tail.instance_of?(::String)
+              head + tail
+            else
+              raise "Incompatible type: head => #{head}, tail => #{tail}"
+            end
+          when ::Array
+            if tail.instance_of?(Array)
+              head + tail
+            else
+              raise "Incompatible type: head => #{head}, tail => #{tail}"
+            end
+          when ::Hash
+            if tail.instance_of?(Hash)
+              head.merge(tail)
+            else
+              raise "Incompatible type: head => #{head}, tail => #{tail}"
+            end
+          when ::Integer
+            if tail.kind_of?(Integer)
+              head + tail
+            else
+              raise "Incompatible type: head => #{head}, tail => #{tail}"
+            end
+          else
+            raise "Incompatible type: head => #{head}"
+          end
+          #head + tail
         end
       end
     end
-
-    def parse(input)
-      @parser.call(input).parse(input)
-    end
   end
 
-
-
-
-  class SpaceParser
+#  class SpaceParser
+  class Space
     include Parsable
     def initialize
       @parser = lambda do |input|
-        SeqParser.new(ManyParser.new(SatisfyParser.new(IS_SPACE),""))
+        Seq.new(Many.new(Satisfy.new(IS_SPACE),""))
       end
     end
   end
 
-  class WhiteSpaceParser
+  class WhiteSpace
     include Parsable
     def initialize
       @parser = lambda do |input|
-        SeqParser.new(ManyParser.new(SatisfyParser.new(IS_WHITESPACE),''))
+        Seq.new(Many.new(Satisfy.new(IS_WHITESPACE),''))
       end
     end
   end
 
-  class TokenizeParser
+  class Tokenize
     include Parsable
     attr_accessor :prefix, :postfix
 
     def initialize(parser, args = { }, &block)
       @parser = lambda do |input|
-        @prefix = args[:prefix] ? args[:prefix] : WhiteSpaceParser.new 
-        @postfix = args[:postfix] ? args[:postfix] : WhiteSpaceParser.new
+        @prefix = args[:prefix] ? args[:prefix] : WhiteSpace.new 
+        @postfix = args[:postfix] ? args[:postfix] : WhiteSpace.new
         if block_given?
           yield self
-          SeqParser.new(@prefix, parser, @postfix) do |_, vs, _|
+          Seq.new(@prefix, parser, @postfix) do |_, vs, _|
             vs
           end
         else
-          SeqParser.new(@prefix, parser, @postfix) do |_, vs, _|
+          Seq.new(@prefix, parser, @postfix) do |_, vs, _|
             vs
           end
         end
@@ -400,23 +408,12 @@ module Yaparc
     end
   end
 
-#   class Tokenize < ParserBase
-#     attr_accessor :prefix, :postfix
-
-#     def initialize(parser, &block)
-#       @prefix, @postfix = WhiteSpace.new,WhiteSpace.new
-#       yield self
-#       @parser = SeqParser.new(@prefix, parser, @postfix) do |_, vs, _|
-#         vs
-#       end
-#     end
-#   end
-
-  class LiteralParser
+#  class LiteralParser
+  class Literal
     include Parsable
     def initialize(literal)
       @parser =  lambda do |input|
-        TokenizeParser.new(StringParser.new(literal))
+        Tokenize.new(Yaparc::String.new(literal))
       end
     end
   end
@@ -425,23 +422,21 @@ module Yaparc
 
   class Identifier
     include Yaparc::Parsable
-    @@identifier_regex = ::Yaparc::RegexParser.new(/\A[a-zA-Z_]+[a-zA-Z0-9_]*/)
+    @@identifier_regex = ::Yaparc::Regex.new(/\A[a-zA-Z_]+[a-zA-Z0-9_]*/)
 
     def initialize(*keywords)
       if keywords == []
         @parser = lambda do |input|
-          TokenizeParser.new(@@identifier_regex)
-#          Yaparc::Token.new(@@identifier_regex)
+          Tokenize.new(@@identifier_regex)
         end
       else
         @parser = lambda do |input|
-          keyword_parsers = keywords.map {|keyword| Yaparc::StringParser.new(keyword)}
-          case result = Yaparc::AltParser.new(*keyword_parsers).parse(input)
+          keyword_parsers = keywords.map {|keyword| Yaparc::String.new(keyword)}
+          case result = Yaparc::Alt.new(*keyword_parsers).parse(input)
           when Yaparc::Result::OK
-            Yaparc::FailParser.new
+            Yaparc::Fail.new
           else # Result::Fail or Result::Error
-            TokenizeParser.new(@@identifier_regex)
-#            Yaparc::Token.new(@@identifier_regex)
+            Tokenize.new(@@identifier_regex)
           end
         end
       end
@@ -452,69 +447,48 @@ module Yaparc
     end
   end
 
-#   class ParserBase
-#     include Parsable
-
-#     def parse(input)
-#       @parser.parse(input)
-#     end
-#   end
-
-  class CharParser
+#  class Char
+  class Char
     include Parsable
 
     def initialize(char)
       equal_char = lambda {|i| i == char}
       @parser =  lambda do |input|
-        SatisfyParser.new(equal_char)
+        Satisfy.new(equal_char)
       end
     end
   end
-#   class CharParser < ParserBase
-
-#     def initialize(char)
-#       equal_char = lambda {|i| i == char}
-#       @parser = SatisfyParser.new(equal_char)
-#     end
-#   end
-
-#   class ZeroOneParser < ParserBase
-#     def initialize(parser, identity = [])
-#       @parser = AltParser.new(parser, SucceedParser.new(identity)) # Is it OK?
-#     end
-#   end
 
   class Ident
     include Parsable
     def initialize
       @parser = lambda do |input|
-        SeqParser.new(
-                      SatisfyParser.new(IS_LOWER),
-                      ManyParser.new(SatisfyParser.new(IS_ALPHANUM),"")
+        Seq.new(
+                      Satisfy.new(IS_LOWER),
+                      Many.new(Satisfy.new(IS_ALPHANUM),"")
                       ) do |head, tail|
           head + tail
         end
       end
     end
   end
-#   class Ident < ParserBase
-#     def initialize
-#       @parser = SeqParser.new(
-#                               SatisfyParser.new(IS_LOWER),
-#                               ManyParser.new(SatisfyParser.new(IS_ALPHANUM),"")
-#                               ) do |head, tail|
-#         head + tail
-#       end
-#     end
-#   end
+
+  class Digit
+    include Parsable
+    def initialize
+      @parser = lambda do |input|
+        Satisfy.new(IS_DIGIT)
+      end
+    end
+  end
 
   class Nat
     include Parsable
     def initialize
       @parser = lambda do |input|
-        SeqParser.new(ManyOneParser.new(SatisfyParser.new(IS_DIGIT),"")) do |vs|
+        Seq.new(ManyOne.new(Digit.new,'')) do |vs|
           if vs == ""
-            vs
+            0 #            vs
           else
             vs.to_i
           end
@@ -523,77 +497,25 @@ module Yaparc
     end
   end
 
-#   class Nat < ParserBase
-#     def initialize
-#       @parser = SeqParser.new(ManyOneParser.new(SatisfyParser.new(IS_DIGIT),"")) do |vs|
-#         if vs == ""
-#           vs
-#         else
-#           vs.to_i
-#         end
-#       end
-#     end
-#   end
-
-#   class Space < ParserBase
-#     def initialize
-#       @parser = SeqParser.new(ManyParser.new(SatisfyParser.new(IS_SPACE),"")) do |vs|
-#         SucceedParser.new([])
-#       end
-#     end
-#   end
-
-#   class WhiteSpace < ParserBase
-#     def initialize
-#       @parser = SeqParser.new(ManyParser.new(SatisfyParser.new(IS_WHITESPACE),"")) do |vs|
-#         SucceedParser.new([])
-#       end
-#     end
-#   end
-
-#   class Token < ParserBase
-#     attr_accessor :prefix, :postfix
-
-#     def initialize(parser, prefix = WhiteSpace.new, postfix = WhiteSpace.new)
-#       @prefix, @postfix  = prefix, postfix
-#       @parser = SeqParser.new(@prefix, parser, @postfix) do |_, vs, _|
-#         vs
-#       end
-#     end
-#   end
 
   class Natural
     include Parsable
     def initialize(args = {})
       @parser = lambda do |input|
-        TokenizeParser.new(Nat.new, args)
+        Tokenize.new(Nat.new, args)
       end
     end
   end
-#   class Natural < ParserBase
-
-#     def initialize
-#       @parser = Token.new(Nat.new)
-#     end
-#   end
-
 
   class Symbol
     include Parsable
     def initialize(literal, args = {})
       @parser = lambda do |input|
-        LiteralParser.new(literal)
+        Literal.new(literal)
       end
     end
   end
 
-#   class Symbol < ParserBase
-
-#     def initialize(literal)
-#       @parser = Token.new(StringParser.new(literal))
-#     end
-#   end
-
   class AbstractParser
     include Parsable