yaparc 0.2.3 → 0.4.0

data/lib/yaparc/no_fail.rb

@@ -0,0 +1,20 @@
+require_relative 'parsable'
+
+module Yaparc
+  # hutton92:_higher_order_funct_parsin,p.19
+  # https://www.cambridge.org/core/journals/journal-of-functional-programming/article/higherorder-functions-for-parsing/0490F2C8511F7625F9FC15BFFEDBB0AA
+  class NoFail
+    include Parsable
+
+    def initialize(parser)
+      @parser = lambda do |input|
+        result = parser.parse(input)
+        if result.instance_of?(Fail)
+          Error.new(value: result.value, input: result.input)
+        else
+          Succeed.new(result.value)
+        end
+      end
+    end
+  end
+end

data/lib/yaparc/parsable.rb

@@ -0,0 +1,20 @@
+module Yaparc
+  module Parsable
+    IS_LOWER      = ->(c) { c >= 'a' and c <= 'z' }
+    IS_ALPHANUM   = ->(c) { (c >= 'a' and c <= 'z') or (c >= '0' and c <= '9') }
+    IS_DIGIT      = ->(i) { i >= '0' and i <= '9' }
+    IS_SPACE      = ->(i) { i == ' ' }
+    IS_WHITESPACE = ->(i) { [' ', "\n", "\t"].include?(i) }
+    IS_CR         = ->(i) { i == "\n" }
+
+    def parse(input)
+      result = @parser.call(input)
+
+      if result.respond_to?(:parse)
+        result.parse(input)
+      else
+        result
+      end
+    end
+  end
+end

data/lib/yaparc/regex.rb

@@ -0,0 +1,22 @@
+require_relative 'parsable'
+
+module Yaparc
+  class Regex
+    include Parsable
+
+    def initialize(regex)
+      @regex = regex
+      @parser = lambda do |input|
+        if match = Regexp.new(regex).match(input)
+          if block_given?
+            Succeed.new(yield(*match.to_a[1..])).parse(match.post_match)
+          else
+            OK.new(value: match[0], input: match.post_match)
+          end
+        else
+          Fail.new(input:)
+        end
+      end
+    end
+  end
+end

data/lib/yaparc/satisfy.rb

@@ -0,0 +1,28 @@
+require_relative 'parsable'
+
+module Yaparc
+  class Satisfy
+    include Parsable
+
+    def initialize(predicate)
+      @parser = lambda do |input|
+        result = Item.new.parse(input)
+
+        if result.instance_of?(OK) && predicate.call(result.value)
+          Succeed.new(result.value, result.input)
+        else
+          FailParser.new
+        end
+      end
+    end
+
+    def parse(input)
+      case parser = @parser.call(input)
+      in Succeed
+        parser.parse(parser.remaining)
+      in FailParser
+        parser.parse(input)
+      end
+    end
+  end
+end

data/lib/yaparc/seq.rb

@@ -0,0 +1,33 @@
+require_relative 'parsable'
+
+module Yaparc
+  class Seq
+    include Parsable
+
+    def initialize(*parsers)
+      @parser = lambda do |input|
+        args = []
+        initial_result = OK.new(input:)
+        final_result = parsers.inject(initial_result) do |subsequent, parser|
+          result = parser.parse(subsequent.input)
+          break Fail.new(input: subsequent.input) if result.instance_of?(Fail)
+
+          args << result.value
+          result
+        end
+
+        case final_result
+        in Fail
+          Fail.new(input: final_result.input)
+        in OK
+          final_value = if block_given?
+                          yield(*args)
+                        else
+                          args.last
+                        end
+          OK.new(value: final_value, input: final_result.input)
+        end
+      end
+    end
+  end
+end

data/lib/yaparc/space.rb

@@ -0,0 +1,11 @@
+require_relative 'parsable'
+
+module Yaparc
+  class Space
+    include Parsable
+
+    def initialize
+      @parser = proc { Regex.new(/\A */) }
+    end
+  end
+end

data/lib/yaparc/string.rb

@@ -0,0 +1,24 @@
+require_relative 'parsable'
+
+module Yaparc
+  class String
+    include Parsable
+
+    def initialize(string, case_sensitive = true)
+      @parser = lambda do |_input|
+        result = Item.new.parse(string)
+        if result.instance_of?(OK)
+          Seq.new(
+            Char.new(result.value, case_sensitive),
+            Yaparc::String.new(result.input, case_sensitive),
+            Succeed.new(result.value + result.input)
+          ) do |_, _, succeed_result|
+            succeed_result
+          end
+        else
+          Succeed.new(result)
+        end
+      end
+    end
+  end
+end

data/lib/yaparc/succeed.rb

@@ -0,0 +1,14 @@
+require_relative 'parsable'
+
+module Yaparc
+  class Succeed
+    include Parsable
+
+    attr_reader :remaining
+
+    def initialize(value, remaining = nil)
+      @parser = ->(input) { OK.new(value:, input:) }
+      @remaining = remaining
+    end
+  end
+end

data/lib/yaparc/symbol.rb

@@ -0,0 +1,11 @@
+require_relative 'parsable'
+
+module Yaparc
+  class Symbol
+    include Parsable
+
+    def initialize(literal)
+      @parser = proc { Literal.new(literal) }
+    end
+  end
+end

data/lib/yaparc/tokenize.rb

@@ -0,0 +1,18 @@
+require_relative 'parsable'
+
+module Yaparc
+  class Tokenize
+    include Parsable
+
+    attr_writer :prefix, :postfix
+
+    def initialize(parser, prefix: nil, postfix: nil)
+      @parser = lambda do |_input|
+        @prefix = prefix || WhiteSpace.new
+        @postfix = postfix || WhiteSpace.new
+        block_given? and yield self
+        Seq.new(@prefix, parser, @postfix) { |_, vs, _| vs }
+      end
+    end
+  end
+end

data/lib/yaparc/white_space.rb

@@ -0,0 +1,11 @@
+require_relative 'parsable'
+
+module Yaparc
+  class WhiteSpace
+    include Parsable
+
+    def initialize
+      @parser = proc { Regex.new(/\A[\t\n ]*/) }
+    end
+  end
+end

data/lib/yaparc/zero_one.rb

@@ -0,0 +1,20 @@
+require_relative 'parsable'
+
+module Yaparc
+  class ZeroOne
+    include Parsable
+
+    def initialize(parser, identity = [])
+      @parser = lambda do |input|
+        case (result = parser.parse(input))
+        in Fail
+          OK.new(value: identity, input:)
+        in Error
+          Error.new(value: result.value, input: result.input)
+        in OK
+          result
+        end
+      end
+    end
+  end
+end