oo_peg 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 32be46d729318aafa59078974eeee88c3b8021cf4cff85c2a17d8786ff0a3908
-  data.tar.gz: 6de98652e7c7583db727a647a213a5d48af9faf0106234e34b61871003fee036
+  metadata.gz: 11f34766383a2831c29bcbc2185872fdbe6dc1eb3e6394c9322054c8e6f7e67a
+  data.tar.gz: '078fce739e80aa0a9e2f14d39739ac1c6c1626fa3df529036a0d4f2d5e298bfc'
 SHA512:
-  metadata.gz: 7efb7a5d6fdb13b628e80d7f7876065970f41160f21651572fb535fcac1e4ef05fcbee3a850dbd4f31f23a81a665c728a9f52a869067028f8bc4e1eba8c06034
-  data.tar.gz: 0c0d5ec9eb9930d17bc04fe709d88de42885cccc4c7aee875d2e0749eccee01bbe5404af5f15c5bba3ca8246b7309deb57b35c1f28cef5c9b3883d83e6a164ad
+  metadata.gz: e4f45d6b634aef946eea657ee0dd47b795c36f4368fff764947851ed46ab3fa7c8a5de5ed8a24eca05e4d452ff3ad73653dd9e04c80554165657c52dd517bf9d
+  data.tar.gz: 41d5e123bc0ea70b589bcfa2d45f93cc6e3741a36123ed39e4ad5ee338665972e2192df55b21b38d160b8d0af38041773cd93118b943ad73d84a9322da3ad8fa

data/lib/oo_peg/input.rb

@@ -5,7 +5,7 @@ module OOPeg
     attr_reader :content, :pos
 
     def advance(by=1)
-      self.class.new(content.drop(by), pos+by)
+      [self.class.new(content.drop(by), pos+by), take(by)]
     end
 
     def empty? = content.empty?
@@ -17,6 +17,8 @@ module OOPeg
       "#{content.take(count-3).join}..."
     end
 
+    def take(count=1) = content.take(count)
+
     def ==(other)
       self.class === other &&
         other.content == content &&

data/lib/oo_peg/parser/combinators/basics.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module OOPeg
+  class Parser
+    module Combinators
+      module Basics
+        private
+        def _debug(parser, name: nil)
+          Parser.new(parser.name) do |input|
+            puts "debugging #{name || parser.name}: #{input.inspect}"
+            result = Parser.parse(parser, input)
+            puts "debugging #{name || parser.name}: #{result}"
+            result
+          end
+        end
+
+        def _lookahead(parsers, name:)
+          parser = _select(parsers)
+          Parser.new(name || "lookahead(#{parser.name})") do |input, name|
+            case Parser.parse(parser, input)
+            in {ok: true}
+              {ok: true, ast: nil, input:}
+            in error
+              error
+            end
+          end
+        end
+
+        def _not(parser:, name:)
+          name ||= "not(#{parser.name})"
+          Parser.new(name) do |input|
+            case Parser.parse(parser, input)
+            in {ok: false}
+              input.advance => [input, ast]
+              Result.ok(ast:, input:)
+            else
+              Result.nok(input:, error: "not expected to parse #{input.show(6)}", parser_name: name)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/oo_peg/parser/combinators/mappers.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module OOPeg
+  class Parser
+    module Combinators
+      module Mappers
+
+        private
+        def _join_list(parser:, name:)
+          name ||= "joined_list(#{parser.name})"
+          _map(parser:, name:) do
+            it => [head, tail]
+            [head, *tail]
+          end
+        end
+
+        def _map(parser:, name:, &mapper)
+          raise ArgumentError, "missing mapper function" unless mapper
+
+          name ||= "map(#{parser.name})"
+          Parser.new(name) do |input|
+            result = Parser.parse(parser, input)
+            # require "debug"; binding.break
+            result.map(&mapper)
+            # require "debug"; binding.break
+            # case result
+            # in {ok: true, input: rest, ast:}
+            #   Result.ok(ast: mapper.(ast), input: rest)
+            # in {error:}
+            #   Result.nok(error:, input:, parser_name: name)
+            # end
+          end
+        end
+
+        def _map_many(parser:, name:, &mapper)
+          raise ArgumentError, "missing mapper function" unless mapper
+
+          name ||= "map_many(#{parser.name})"
+          _map(parser:, name:) { it.map(&mapper) }
+        end
+
+        def _map_or_rename(parser:, name: nil, error: nil, &mapper)
+          parser_name = name || parser.name
+          Parser.new(name) do |input|
+            result = Parser.parse(parser, input)
+            case result
+            in {ok: true, ast:}
+              mapper ? result.merge(ast: mapper.(ast)) : result
+            in _
+              result.merge(parser_name:, error:)
+            end
+          end
+        end
+
+        def _map_result(parser, name, mapper)
+          Parser.new(name) do |input, name|
+            result = Parser.parse(parser, input)
+            # require "debug"; binding.break
+            mapper.(result)
+          end
+        end
+        def _tagged(tag, parser:, name:)
+          name ||= "tagged(#{parser.name} with #{tag.inspect})"
+          _map(parser:, name:) { [tag, it] }
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/oo_peg/parser/combinators/repeaters.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module OOPeg
+  class Parser
+    module Combinators
+      module Repeaters
+        private 
+        def _many(parser, max:, min:, name:, &blk)
+          name ||= "many(#{parser.name})"
+          many_parser = Parser.new(name) { |input| _many_body(input:, parser:, name:, max:, min:) }
+          return many_parser.map_many(&blk) if blk
+
+          many_parser
+        end
+
+        def _many_body(input:, parser:, name:, max:, min:)
+          total_ast = []
+          original_input = input
+          current_input = input
+          match_count = 0
+          loop do
+            if current_input.empty?
+              break _many_when_empty(ast: total_ast, input: current_input, match_count:, min:, name:, original_input:)
+            end
+
+            # p [total_ast, current_input]
+            r = _many_parse(parser:, current_input:, total_ast:, match_count:, max:, min:, original_input:) 
+            case r
+            in [:cont, {current_input:, total_ast:, match_count:}]
+              nil
+            in [:halt, result]
+              break result
+            end
+          end
+        end
+
+        def _many_parse(parser:, current_input:, total_ast:, match_count:, max:, min:, original_input:) 
+          case Parser.parse(parser, current_input)
+          in {ok: true, ast:, input:}
+            raise InfiniteLoop, "must not parse zero width inside many in parser: #{parser.name}" if input.pos == current_input.pos
+            current_input = input
+            total_ast = [*total_ast, ast]
+            match_count += 1
+            return [:halt, Result.ok(ast: total_ast, input:)] if max && match_count >= max
+            return [:cont, {current_input:, total_ast:, match_count:}]
+          in _
+            return [:halt, Result.ok(ast: total_ast, input: current_input)] if match_count >= min
+            return [:halt, Result.nok(
+              error: "many #{name} did not succeed the required #{min} times, but only #{match_count}",
+              input: original_input,
+              parser_name: name)]
+          end
+        end
+
+        def _many_when_empty(ast:, input:, match_count:, min:, name:, original_input:)
+          return Result.ok(ast:, input:) if match_count >= min
+
+          Result.nok(
+            error: "#{name.inspect} did not succeed the required #{min} times, but only #{match_count}",
+            input: original_input,
+            parser_name: name)
+        end
+      end
+
+      def _maybe(parser:, name: nil, replace_with: nil)
+        Parser.new(name || "maybe(#{parser.name})") do |input, name|
+          case Parser.parse(parser, input)
+          in {ok: false}
+            Result.ok(ast: replace_with, input:)
+          in success
+            success
+          end
+        end
+      end
+
+      def _sequence(*parsers, name:)
+        parsers = parsers.flatten
+        raise ArgumentError, "all parsers must be instances of Parser" unless parsers.all? { Parser === it }
+        name ||= "seq(#{parsers.map(&:name).join(", ")})"
+        Parser.new(name) do |input|
+          original_input = input
+          result = parsers.reduce_while [input, []] do |(input, ast), parser|
+
+            parsed = Parser.parse(parser, input)
+            # require "debug"; binding.break if parsed.input.nil?
+            case parsed
+            in {ok: true, ast: nil, input:}
+              cont_reduce([input, ast])
+            in {ok: true, ast: ast_node, input:}
+              cont_reduce([input, [*ast, ast_node]])
+            in {ok: false, error:}
+              halt_reduce(Result.nok(input: original_input, error:, parser_name: name))
+            end
+          end
+
+          case result
+          in {ok: false} => error
+            result
+          in [input, ast]
+            Result.ok(ast:, input:)
+          end
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/oo_peg/parser/combinators/satisfiers.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module OOPeg
+  class Parser
+    module Combinators
+      module Satisfiers
+        private
+        def _satisfy(parser, name:, &satisfier)
+          name ||= "satisfy(#{parser.name})"
+
+          Parser.new(name) do |input|
+            original_input = input
+            case Parser.parse(parser, input)
+            in {ok: false} => error
+              error
+            in {ok: true, ast:, input:} => result
+              case satisfier.(ast)
+              in true
+                result
+              in [:ok, ast]
+                Result.ok(ast:, input:)
+              in [:error, error]
+                Result.nok(input: original_input, error:, parser_name: name)
+              in _
+                Result.nok(input: original_input, error: "#{name} failed", parser_name: name)
+              end
+            end
+          end
+        end
+
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/oo_peg/parser/combinators/selectors.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module OOPeg
+  class Parser
+    module Combinators
+      module Selectors
+        private
+        def _select(*parsers, name: nil)
+          parsers = parsers.flatten
+          name ||= "select(#{parsers.map(&:name).join(",")})"
+          raise ArgumentError, "all parsers must be instances of Parser" unless parsers.all? { Parser === it }
+          Parser.new(name, &_select_parser(name:, parsers:))
+        end
+
+        def _select_parser(name:, parsers:)
+          -> (input) do 
+            result = Result.nok(error: "No parser matched in select named #{name}", input:, parser_name: name)
+            parsers.each do |parser|
+              # case p(Parser.parse(parser, input))
+              this_result = Parser.parse(parser, input)
+              # require "debug"; binding.break
+              case this_result
+              in {ok: true} => result
+                break result
+              in _
+                nil
+              end
+            end
+            result
+          end
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/oo_peg/parser/combinators.rb

@@ -1,7 +1,12 @@
 # frozen_string_literal: true
 
 require_relative '../../enumerable'
+require_relative 'combinators/basics'
 require_relative 'combinators/lazy'
+require_relative 'combinators/mappers'
+require_relative 'combinators/repeaters'
+require_relative 'combinators/satisfiers'
+require_relative 'combinators/selectors'
 module OOPeg
   class Parser
     class InfiniteLoop < Exception; end
@@ -77,6 +82,60 @@ module OOPeg
     #     parse(tagged_char_parser, 'q').ast => [:char, 'q']
     #
     #
+    # ==== Mapping Lists
+    #
+    # Oftentimes, when applying +map+ to the +many+ combinator we want to map
+    # *all* elements of the returned list, enter...
+    #
+    # ===== +map_many+
+    #
+    #     # example: a digit parser
+    #
+    #     digit_parser = char_class_parser(:digit).many.map_many(&:to_i)
+    #
+    #     parse(digit_parser, '104a').ast => [1, 0, 4]
+    #
+    # A shortcut, using the +mapper+ inside +many+
+    #
+    #     # example: a shortcut digit parser
+    #
+    #     digit_parser = char_class_parser(:digit).many(&:to_i)
+    #
+    #     parse(digit_parser, '104a').ast => [1, 0, 4]
+    #
+    # ==== +join_list+
+    #
+    # The inherent structure of this library will oftentimes return a list of the following structure
+    # <tt>[first_element, [second_element, ..., last_element]]</tt>
+    # 
+    # e.g.
+    # 
+    #     # example: the crux with +and+ and +many+
+    #
+    #     element = ws_parser.not.joined
+    #     at_least_one = element.and(ws_parser.ignore.and(element).many(&:first))
+    #
+    #     parse(at_least_one, 'a b c').ast => ['a', ['b', 'c']]
+    #
+    # This can be fixed with +join_list+
+    #
+    #     # example: fixing +and+ and +many+
+    #
+    #     element = ws_parser.not.joined
+    #     at_least_one = element.and(ws_parser.ignore.and(element).many(&:first)).join_list
+    #
+    #     parse(at_least_one, 'a b c').ast => ['a', 'b', 'c']
+    #
+    # *N.B* This is a very specialized combinator which expects the AST it transforms being of the shape
+    # <tt>[_, [*]]</tt> if this is not the case a +NoMatchingPatternError+ will be thrown
+    #
+    #     # example: Just be careful man
+    #
+    #     bad_parser = char_parser.join_list
+    #
+    #       expect { parse(bad_parser, 'a') }
+    #         .to raise_error(NoMatchingPatternError)
+    #
     # ==== +maybe+ (oftentimes called +option+ in other PEG Parsers)
     #
     # If a parser +p+ parses a string, the parser +p.maybe+ parses, well
@@ -168,6 +227,23 @@ module OOPeg
     #
     #     parse(parser, "+42").ast => ['42'] 
     #
+    # ==== +not+ negation
+    #
+    #     # example: what is not a character
+    #
+    #     parse(char_class_parser(:digit).not.joined, 'a').ast => 'a'
+    #     parse(char_class_parser(:digit).not, '7') not! ok
+    #
+    # Practical use of not is when it is combined with +many+.
+    #
+    # Like in regular expressions where <tt>\S</tt> is oftentimes combined to <tt>\S+</tt>
+    #
+    #     # example: not whitespaces
+    #
+    #     not_ws_parser = ws_parser.not.many(min: 1).joined
+    #
+    #     parse(not_ws_parser, ' ') not! ok
+    #     parse(not_ws_parser, 't-32 ').ast => 't-32'
     #
     # ==== +satifsfy+ can fail a successful result does not touch failing results
     #
@@ -268,190 +344,11 @@ module OOPeg
     #     $ab_count => 3 
     #
     module Combinators
-
-      private
-      def _debug(parser, name: nil)
-        Parser.new(parser.name) do |input|
-          puts "debugging #{name || parser.name}: #{input.inspect}"
-          result = Parser.parse(parser, input)
-          puts "debugging #{name || parser.name}: #{result}"
-          result
-        end
-      end
-
-      def _lookahead(parsers, name:)
-        parser = _select(parsers)
-        Parser.new(name || "lookahead(#{parser.name})") do |input, name|
-          case Parser.parse(parser, input)
-          in {ok: true}
-            {ok: true, ast: nil, input:}
-          in error
-            error
-          end
-        end
-      end
-
-      def _map(parser:, name:, &mapper)
-        raise ArgumentError, "missing mapper function" unless mapper
-
-        name ||= "map(#{parser.name})"
-        Parser.new(name) do |input|
-          result = Parser.parse(parser, input)
-          # require "debug"; binding.break
-          result.map(&mapper)
-          # require "debug"; binding.break
-          # case result
-          # in {ok: true, input: rest, ast:}
-          #   Result.ok(ast: mapper.(ast), input: rest)
-          # in {error:}
-          #   Result.nok(error:, input:, parser_name: name)
-          # end
-        end
-      end
-
-      def _many(parser, max:, min:, name:)
-        name ||= "many(#{parser.name})"
-        Parser.new(name) do |input|
-          total_ast = []
-          original_input = input
-          current_input = input
-          match_count = 0
-          loop do
-            if current_input.empty?
-              break Result.ok(ast: total_ast, input:) if match_count >= min
-              break Result.nok(
-                error: "#{name.inspect} did not succeed the required #{min} times, but only #{match_count}",
-                input: original_input,
-                parser_name: name)
-            end
-
-            case Parser.parse(parser, current_input)
-            in {ok: true, ast:, input:}
-              raise InfiniteLoop, "must not parse zero width inside many in parser: #{parser.name}" if input.pos == current_input.pos
-              current_input = input
-              total_ast = [*total_ast, ast]
-              match_count += 1
-              break Result.ok(ast: total_ast, input:) if max && match_count >= max
-            in _
-              break Result.ok(ast: total_ast, input:) if match_count >= min
-              break Result.nok(
-                error: "many #{name} did not succeed the required #{min} times, but only #{match_count}",
-                input: original_input,
-                parser_name: name)
-            end
-          end
-        end
-      end
-
-      def _map_or_rename(parser:, name: nil, error: nil, &mapper)
-        parser_name = name || parser.name
-        Parser.new(name) do |input|
-          result = Parser.parse(parser, input)
-          case result
-          in {ok: true, ast:}
-            mapper ? result.merge(ast: mapper.(ast)) : result
-          in _
-            result.merge(parser_name:, error:)
-          end
-        end
-      end
-
-      def _map_result(parser, name, mapper)
-        Parser.new(name) do |input, name|
-          result = Parser.parse(parser, input)
-          # require "debug"; binding.break
-          mapper.(result)
-        end
-      end
-
-      def _maybe(parser:, name: nil, replace_with: nil)
-        Parser.new(name || "maybe(#{parser.name})") do |input, name|
-          case Parser.parse(parser, input)
-          in {ok: false}
-            Result.ok(ast: replace_with, input:)
-          in success
-            success
-          end
-        end
-      end
-
-      def _satisfy(parser, name:, &satisfier)
-        name ||= "satisfy(#{parser.name})"
-
-        Parser.new(name) do |input|
-          original_input = input
-          case Parser.parse(parser, input)
-          in {ok: false} => error
-            error
-          in {ok: true, ast:, input:} => result
-            case satisfier.(ast)
-            in true
-              result
-            in [:ok, ast]
-              Result.ok(ast:, input:)
-            in [:error, error]
-              Result.nok(input: original_input, error:, parser_name: name)
-            in _
-              Result.nok(input: original_input, error: "#{name} failed", parser_name: name)
-            end
-          end
-        end
-      end
-
-      def _select(*parsers, name: nil)
-        parsers = parsers.flatten
-        name ||= "select(#{parsers.map(&:name).join(",")})"
-        raise ArgumentError, "all parsers must be instances of Parser" unless parsers.all? { Parser === it }
-        Parser.new(name || "select #{parsers.map(&:name).join(", ")}") do |input, name|
-          result = Result.nok(error: "No parser matched in select named #{name}", input:, parser_name: name)
-          parsers.each do |parser|
-            # case p(Parser.parse(parser, input))
-            this_result = Parser.parse(parser, input)
-            # require "debug"; binding.break
-            case this_result
-            in {ok: true} => result
-              break result
-            in _
-              nil
-            end
-          end
-          result
-        end
-      end
-
-      def _sequence(*parsers, name:)
-        parsers = parsers.flatten
-        raise ArgumentError, "all parsers must be instances of Parser" unless parsers.all? { Parser === it }
-        name ||= "seq(#{parsers.map(&:name).join(", ")})"
-        Parser.new(name) do |input|
-          original_input = input
-          result = parsers.reduce_while [input, []] do |(input, ast), parser|
-            # require "debug"; binding.break
-            parsed = Parser.parse(parser, input)
-            # p parsed
-            case parsed
-            in {ok: true, ast: nil, input:}
-              cont_reduce([input, ast])
-            in {ok: true, ast: ast_node, input:}
-              cont_reduce([input, [*ast, ast_node]])
-            in {ok: false, error:}
-              halt_reduce(Result.nok(input: original_input, error:, parser_name: name))
-            end
-          end
-
-          case result
-          in {ok: false} => error
-            result
-          in [input, ast]
-            Result.ok(ast:, input:)
-          end
-        end
-      end
-
-      def _tagged(tag, parser:, name:)
-        name ||= "tagged(#{parser.name} with #{tag.inspect})"
-        _map(parser:, name:) { [tag, it] }
-      end
+      include Combinators::Basics
+      include Combinators::Mappers
+      include Combinators::Repeaters
+      include Combinators::Satisfiers
+      include Combinators::Selectors
     end
   end
 end

data/lib/oo_peg/parser.rb

@@ -45,15 +45,19 @@ module OOPeg
 
     def ignore = self.map { nil }
 
+    def join_list(name: nil) = _join_list(parser: self, name:)
     def joined(joiner: "") = self.map { |ast| ast.join(joiner) }
 
     def lookahead(name: nil) = _lookahead(self, name:)
 
-    def many(name: nil, max: nil, min: 0) = _many(self, name:, max:, min:)
+    def many(name: nil, max: nil, min: 0, &blk) = _many(self, name:, max:, min:, &blk)
     def map(name: nil, &blk) = _map(parser: self, name:, &blk)
+    def map_many(name: nil, &blk) = _map_many(parser: self, name:, &blk)
     def map_or_rename(name: nil, error: nil, &blk) = _map_or_rename(parser: self, name:, error:, &blk)
     def maybe(name: nil, replace_with: nil) = _maybe(parser: self, name:, replace_with:)
 
+    def not(name: nil) = _not(parser: self, name:)
+
     def or(*parsers, name: nil) = _select(self, *parsers, name:)
 
     def satisfy(name: nil, &satisfier) = _satisfy(self, name:, &satisfier)

data/lib/oo_peg/parsers/advanced/list_parser.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module OOPeg
+  module Parsers
+    module Advanced
+      module ListParser extend self
+        include OOPeg::Parsers
+        include Advanced
+
+        def make(
+          element_parser: ws_parser.not.many(min: 1).joined,
+          sep_parser: ws_parser,
+          leading_sep: true,
+          trailing_sep: true,
+          name: nil)
+          name ||= "ListParser"
+
+          head_parser = leading_sep ? sep_parser.maybe.ignore : nil
+          tail_parser = trailing_sep ? sep_parser.maybe.ignore : nil
+
+          inner_parser =
+            element_parser.and(sep_parser.and(element_parser).many(&:first)).join_list
+
+          Parser.and([head_parser, inner_parser, tail_parser].compact, name:).map(&:first)
+        end
+
+        private
+
+        def _flatten_ast
+          -> ast do
+            ast.first => [head, tail]
+            [head, *tail]
+          end
+        end
+
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/oo_peg/parsers/advanced.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../parsers'
+require_relative 'advanced/list_parser'
 require_relative 'advanced/operator_parser'
 require_relative 'advanced/sexp_parser'
 require_relative 'advanced/string_parser'
@@ -53,6 +54,24 @@ module OOPeg
     #
     #     parse(symbol_parser, ':hello ').ast => :hello
     #   
+    # == The List Parser
+    #
+    # Lists are omnipresent in computer languages, they are easily defined as a parser and
+    # many sequences of a separator and a parser.
+    #
+    # They can be configured to accept leading and trailing separators too.
+    #
+    # The default configuration is with the +separator_parser+ being the +ws_parser+
+    # and the +element_parser+ being the negated +ws_parser+, both with a minimum
+    # length of 1.
+    #
+    # The +leading_sep+ and +trailing_sep+ flags are set to +true+ by default.
+    #
+    #       # example: the default list_parser
+    #
+    #       parse(list_parser, " a b  21 \n:hello").ast => ["a", "b", "21", ":hello"]
+    #
+    #
     # == Putting it all together: The SexpParser
     #
     # with all the above and all the other predefined parsers it is now very easy
@@ -104,6 +123,8 @@ module OOPeg
     # 
     module Advanced
 
+      def list_parser(**kwds) = ListParser.make(**kwds)
+
       def operator_parser(**kwds) = OperatorParser.make(**kwds)
 
       def sexp_parser(**kwds) = SexpParser.make(**kwds)

data/lib/oo_peg/parsers/base_parsers.rb

@@ -141,7 +141,7 @@ module OOPeg
             Result.nok(error: "unexpected end of input", input:, parser_name:)
           in [h, *]
             if set.member?(h) && !negate || !set.member?(h) && negate
-              Result.ok(ast: h, input: input.advance)
+              Result.ok(ast: h, input: input.advance.first)
             else
               Result.nok(input:, error: "#{h} is not member of the required set #{set}", parser_name: name)
             end
@@ -198,7 +198,7 @@ module OOPeg
             Result.nok(error: "unexpected end of input", parser_name: name, input:)
           in [h, *]
             if rgx.match?(h)
-              Result.ok(ast: h, input: input.advance)
+              Result.ok(ast: h, input: input.advance.first)
             else
               Result.nok(input:, parser_name: name, error: "#{h} does not match the char class: :#{char_class}")
             end
@@ -215,7 +215,7 @@ module OOPeg
             Result.nok(error: "unexpected end of input", input:, parser_name: name)
           in [h, *]
             if rgx.match?(h)
-              Result.ok(ast: h, input: input.advance)
+              Result.ok(ast: h, input: input.advance.first)
             else
               Result.nok(input:, error: "#{h} does not match the char class: :#{char_classes}")
             end

data/lib/oo_peg/version.rb

@@ -2,7 +2,7 @@
 
 module OOPeg
   module Version
-    VERSION = "0.1.0"
+    VERSION = "0.1.1"
   end
 end
 # SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/oo_peg.rb

@@ -189,7 +189,7 @@ require_relative 'oo_peg/parser'
 #       in [a, b, *]
 #         if a.to_i < b.to_i
 #           # it is important to advance the input
-#           R.ok(ast: "#{a.to_i} < #{b.to_i}", input: input.advance(2))
+#           R.ok(ast: "#{a.to_i} < #{b.to_i}", input: input.advance(2).first)
 #         else
 #           R.nok(input:, error: "not rising", parser_name: "my parser")
 #         end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: oo_peg
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Robert Dober
@@ -52,16 +52,21 @@ files:
 - lib/oo_peg/parser.rb
 - lib/oo_peg/parser/class_methods.rb
 - lib/oo_peg/parser/combinators.rb
+- lib/oo_peg/parser/combinators/basics.rb
 - lib/oo_peg/parser/combinators/lazy.rb
+- lib/oo_peg/parser/combinators/mappers.rb
+- lib/oo_peg/parser/combinators/repeaters.rb
+- lib/oo_peg/parser/combinators/satisfiers.rb
+- lib/oo_peg/parser/combinators/selectors.rb
 - lib/oo_peg/parsers.rb
 - lib/oo_peg/parsers/advanced.rb
+- lib/oo_peg/parsers/advanced/list_parser.rb
 - lib/oo_peg/parsers/advanced/operator_parser.rb
 - lib/oo_peg/parsers/advanced/sexp_parser.rb
 - lib/oo_peg/parsers/advanced/string_parser.rb
 - lib/oo_peg/parsers/advanced/symbol_parser.rb
 - lib/oo_peg/parsers/base_parsers.rb
 - lib/oo_peg/parsers/common_parsers.rb
-- lib/oo_peg/parsers/lispy_parser.rb
 - lib/oo_peg/parsers/pseudo_parsers.rb
 - lib/oo_peg/parsers/true_set.rb
 - lib/oo_peg/result.rb
@@ -70,6 +75,7 @@ homepage: https://codeberg.org/lab419/oo_peg
 licenses:
 - AGPL-3.0-or-later
 metadata:
+  documentation_uri: https://rubydoc.info/gems/oo_peg/0.1.1
   homepage_uri: https://codeberg.org/lab419/oo_peg
 rdoc_options: []
 require_paths:
@@ -87,5 +93,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.8
 specification_version: 4
-summary: '["A peg parser not using custom sytnax but exposing an OO based API"]'
+summary: A peg parser not using custom sytnax but exposing an OO based API
 test_files: []

data/lib/oo_peg/parsers/lispy_parser.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'advanced'
-module OOPeg
-  module Parsers
-    ##
-    # 
-    # A highly configurable parser for s-expressions
-    class LispyParser
-
-      private
-      def initialize(prefix: "([", suffix: "])", sep_parser: ws_parser)
-      end
-      
-    end
-  end
-end
-# SPDX-License-Identifier: AGPL-3.0-or-later