compser 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e91d16c77b4d59f8ce036475bb9f00d9d5c673b6c1d5ae83633189b76000ba68
-  data.tar.gz: 0ee49bea1a6235fc2d0da6840c920122cb58e394cd575a2739ce96a2fd9532d7
+  metadata.gz: 323319e8a15dae0341e6c2c9def9238fb14587e5a90d65a4c2366ef6c6c67725
+  data.tar.gz: 6f3ec1d93cb1c702745f363bd586cbd85f18b9ec53c6d49b6fda2a856f63f86d
 SHA512:
-  metadata.gz: 11eded3b70d584c53dc890f133b322e8485c43332c32c8694e40e91dd666bf64365014dc2b714ea94e5b0a25cee575f50479180829806b9a9fccbed4b084b5b6
-  data.tar.gz: 1055a219d1c8645739a891e049e5e0d598bf4643674ddde27807dda3b6efedbd3ffae0a4bd494e5fa84af6e751f5a4ad81b8d5071428e59e2607766137d68b35
+  metadata.gz: b69786e8a9a448ab47a494a2388e608e46546bea33902e0c68ecac9598655e92a7b1cc3abb2214b39a874fc97b3322c32a05228b53894fc3b5404c4212a48fb1
+  data.tar.gz: 6fe207a4536aa12062681558cfdf340709c0a9cab191cf9dea65c6f865c4260e5593ebfcd4e41ef10db56f77957b8c3d9b3de53bcf7bf047a03865282231a949

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    Compser (0.1.0)
+    compser (0.2.0)
 
 GEM
   remote: https://rubygems.org/
@@ -13,7 +13,7 @@ PLATFORMS
   x86_64-linux
 
 DEPENDENCIES
-  Compser!
+  compser!
   minitest (~> 5.0)
   rake (~> 13.0)
 

data/README.md

@@ -1,9 +1,10 @@
 # Compser
 
-Compser is a parser builder library for Ruby inspired by [elm-parser](https://package.elm-lang.org/packages/elm/parser/latest/).
-Take a look at the [JSON parser](https://github.com/luizpvas/Compser/blob/main/examples/json.rb) to get a glimpse of the syntax
-and available building blocks you can use to compose more complex and sophisticated parsers.
+Compser is a parser library for Ruby inspired by [elm-parser](https://package.elm-lang.org/packages/elm/parser/latest/).
+Take a look at the [JSON parser](https://github.com/luizpvas/Compser/blob/main/examples/json.rb) and [Calculator](https://github.com/luizpvas/compser/blob/main/examples/calculator.rb) to get a glimpse of the syntax
+and the building blocks you can sue to compose more complex and sophisticated parsers.
 
+* [Installation](#installation)
 * Building blocks
   * [`drop`](#drop)
   * [`integer`](#integer)
@@ -14,11 +15,22 @@ and available building blocks you can use to compose more complex and sophistica
   * [`map`](#map)
   * [`one_of`](#one_of)
   * [`sequence`](#sequence)
+  * [`lazy`](#lazy)
   * [`spaces`](#spaces)
   * [`chomp_if`](#chomp_if)
   * [`chomp_while`](#chomp_while)
 * [Benchmark](#benchmark)
 
+## Installation
+
+Add the following line to your Gemfile:
+
+```ruby
+gem 'compser', '~> 0.2'
+```
+
+See more details at [https://rubygems.org/gems/compser](https://rubygems.org/gems/compser).
+
 #### `drop`
 
 Discard any result or chomped string produced by the parser.
@@ -51,7 +63,7 @@ parser.parse('123a') # => Bad<...>
 parser.parse('0x1A') # => Bad<...>
 
 
-# negative integers with '-' prefix
+# support negative integers with '-' prefix
 def my_integer
   take(:one_of, [
     map(->(x) { x * -1 }).drop(:token, '-').take(:integer),
@@ -176,6 +188,31 @@ parser.parse('12,')        # => Bad<...>
 parser.parse(',12')        # => Bad<...>
 ```
 
+#### `lazy`
+
+Wraps a parser in a lazy-evaluated proc. Use `lazy` to build recursive parsers.
+
+```ruby
+ToList = ->(*integers) { integers }
+
+CommaSeparatedInteger = -> do
+  take(:integer)
+    .drop(:spaces)
+    .take(:one_of, [
+      drop(:token, ',').drop(:spaces).take(:lazy, CommaSeparatedInteger),
+      succeed
+    ])
+end
+
+parser = map(ToList).take(CommaSeparatedInteger.call())
+
+parser.parse('12, 23, 34') # => Good<[12, 23, 34]>
+parser.parse('123')        # => Good<[123]>
+
+parser.parse('12,')        # => Bad<...>
+parser.parse(',12')        # => Bad<...>
+```
+
 #### `spaces`
 
 Chompes zero or more blankspaces, line breaks and tabs. Always succeeds.
@@ -210,12 +247,14 @@ parser.parse('cccdd').state # => State<good?: true, offset: 0, chomped: ''>
 ## Benchmark
 
 The following result is a benchark of a [JSON parser](https://github.com/luizpvas/Compser/blob/main/examples/json.rb) I implemented
-with this library. I ran the benchmark with and without YJIT, and compared the result against the native `JSON.parse`.
+with this library. I ran the benchmark with and without YJIT, and compared the result against `JSON.parse` (native C implementation) and [Parsby](https://github.com/jolmg/parsby).
 
-The benchmark parses a 1,5kb payload 5000 times.
+[The benchmark](https://github.com/luizpvas/compser/blob/main/examples/json-benchmark.rb) parses a 1,5kb payload 100 times.
 
-Implementation | Time | Difference
+Implementation | Time | Comparison to `JSON.parse`
 :---:|:---:|:---:
-`JSON.parse` | 0.019s | -
-`MyJson.parse` (with YJIT) | 9.9s | 526x slower
-`MyJSON.parse` | 12.3s | 654x slower
+`JSON.parse`                              | 0.00067s | -
+`Compser::Json.parse` (with YJIT)         | 0.216s   | 322x slower
+`Compser::Json.parse`                     | 0.268s   | 400x slower
+`Parsby::Example::JsonParser` (with YJIT) | 24.19s   | 36100x slower
+`Parsby::Example::JsonParser`             | 27.22s   | 40626x slower

data/examples/calculator.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative "../lib/compser"
+
+module Compser::Calculator
+  extend self
+  include Compser
+
+  def evaluate(...)
+    expression.parse(...)
+  end
+
+  OPERATORS = {
+    "+" => ->(a, b) { a + b },
+    "-" => ->(a, b) { a - b },
+    "*" => ->(a, b) { a * b },
+    "/" => ->(a, b) { a / b }
+  }.freeze
+
+  Evaluate = ->(*args) {
+    result = args.shift
+
+    while args.any?
+      oprt = args.shift
+      expr = args.shift
+
+      result = OPERATORS.fetch(oprt).call(result, expr)
+    end
+
+    result
+  }
+
+  ExpressionHelper = ->(continue, done) do
+    take(:one_of, [
+      take(operator).drop(:spaces).take(value).drop(:spaces).and_then(continue),
+      done
+    ])
+  end
+
+  def expression
+    map(Evaluate)
+      .take(value)
+      .drop(:spaces)
+      .take(:sequence, ExpressionHelper)
+  end
+
+  def value
+    take(:one_of, [
+      drop(:token, "(").drop(:spaces).take(:lazy, -> { expression }).drop(:spaces).drop(:token, ")"),
+      number
+    ])
+  end
+
+  def operator
+    take(:chomp_if, ->(c) { OPERATORS.key?(c) })
+      .and_then { |state| state.good!(state.consume_chomped) }
+  end
+
+  def number
+    take(:one_of, [
+      map(->(n) { n * -1 }).drop(:token, "-").take(:decimal),
+      take(:decimal)
+    ])
+  end
+end
+
+calc = ->(input) { input + " = " + sprintf("%.2f", Compser::Calculator.evaluate(input).value) }
+
+puts calc.("1 + 1")
+puts calc.("1 + 2 + 3")
+puts calc.("3 * 3 / 2")
+puts calc.("0.1 + 0.2")
+puts calc.("2 + 2 * 4")
+puts calc.("(2 + 2) * 4")
+puts calc.("((((10))))")
+puts calc.("((((10))+5))")

data/examples/json-benchmark.rb

@@ -1,16 +1,22 @@
+# frozen_string_literal: true
+
 require_relative "json"
 require "json"
 require "benchmark"
+require "stringio"
+require "parsby"
+require "parsby/example/json_parser"
 
 json = File.read("./json-payload.json")
 
-n = 5000
+n = 100
 
-n.times do; MyJson.parse(json); end
+5000.times do; Compser::Json.parse(json); end
 
 Benchmark.bm do |x|
-  x.report("MyJson.parse") { n.times do; MyJson.parse(json); end }
+  x.report("Compser::Json.parse") { n.times do; Compser::Json.parse(json); end }
   x.report("JSON.parse")   { n.times do; ::JSON.parse(json); end }
+  x.report("Parsby")       { n.times do; Parsby::Example::JsonParser.parse(json); end }
 end
 
 puts RubyVM::YJIT.runtime_stats

data/examples/json.rb

@@ -1,18 +1,21 @@
+# frozen_string_literal: true
+
 require_relative "../lib/compser"
 
-module MyJson
-  extend Compser
+module Compser::Json
   extend self
+  include Compser
 
-  def parse(str)
-    value.parse(str)
+  def parse(...)
+    value.parse(...)
   end
 
   def value
     take(:one_of, [
-      take(:double_quoted_string),
+      null,
       number,
       boolean,
+      take(:double_quoted_string),
       array,
       object
     ])
@@ -57,6 +60,10 @@ module MyJson
       .drop(:token, "]")
   end
 
+  def null
+    map(-> { nil }).drop(:token, "null")
+  end
+
   def number
     take(:one_of, [
       map(->(x) { x * -1 }).drop(:token, "-").take(:decimal),

data/lib/compser/result.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
 module Compser::Result
-  Good = Data.define(:state, :value) do
+  Good = Data.define(:value) do
     def good? = true
     def bad?  = false
   end
 
-  Bad = Data.define(:state, :message) do
+  Bad = Data.define(:message) do
     def bad?  = true
     def good? = false
   end

data/lib/compser/state.rb

@@ -9,7 +9,7 @@ class Compser::State
     @line = 0
     @column = 0
     @chomped = ::String.new("")
-    @result_stack = [Compser::Result::Good.new(self, nil)]
+    @result_stack = [Compser::Result::Good.new(nil)]
   end
 
   def result
@@ -76,12 +76,12 @@ class Compser::State
   def good(value)
     return value if value.is_a?(Compser::Result::Good)
 
-    Compser::Result::Good.new(self, value)
+    Compser::Result::Good.new(value)
   end
 
   def bad(message)
     return message if message.is_a?(Compser::Result::Bad)
 
-    Compser::Result::Bad.new(self, message)
+    Compser::Result::Bad.new(message)
   end
 end

data/lib/compser/step/chomp_while.rb

@@ -2,8 +2,8 @@
 
 class Compser::Step
   ChompWhile = ->(predicate, state) do
-    state.chomp while !state.eof? && predicate.call(state.peek)
-
-    state
+    while !state.eof? && predicate.call(state.peek)
+      state.chomp
+    end
   end
 end

data/lib/compser/step/drop.rb

@@ -7,7 +7,5 @@ class Compser::Step
     parser.call(state)
 
     savepoint.rollback_chomped_and_result_stack if state.good?
-
-    state
   end.curry
 end

data/lib/compser/step/integer.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 class Compser::Step
-  IsDigit = ->(char) do
-    char =~ /\d/
-  end
+  DIGIT = /\d/.freeze
+
+  IsDigit = ->(ch) { DIGIT.match?(ch) }
 
   NotFollowedByAlpha = ->(state) do
     return state if state.eof?

data/lib/compser/step/lazy.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Compser::Step
+  Lazy = ->(to_parser, state) do
+    to_parser.call.call(state)
+  end
+end

data/lib/compser/step/one_of.rb

@@ -9,8 +9,8 @@ class Compser::Step
     branches.each_with_index do |branch, index|
       state = branch.call(state)
 
-      return state if state.good? || savepoint.has_changes?
-      return state if index == branches.size - 1 # is last
+      return if savepoint.has_changes?
+      return if index == branches.size - 1 # is last
 
       savepoint.rollback
     end

data/lib/compser/step/sequence.rb

@@ -16,11 +16,8 @@ class Compser::Step
       state = helper.call(continue, done).call(state)
     end
 
-    return state if state.bad?
-
-    if state.good? && state.__sequence__ == DONE
-      return state
-    end
+    return if state.bad?
+    return if state.__sequence__ == DONE
 
     state.bad!("unbound sequence")
   end

data/lib/compser/step.rb

@@ -8,6 +8,7 @@ class Compser::Step
     double_quoted_string: DoubleQuotedString,
     integer:              Integer,
     keyword:              Keyword.curry,
+    lazy:                 Lazy.curry,
     one_of:               OneOf.curry,
     problem:              Problem.curry,
     sequence:             Sequence.curry,
@@ -15,9 +16,9 @@ class Compser::Step
     token:                Token.curry
   }.freeze
 
-  def initialize(mapper = nil)
-    @mapper = mapper
-    @steps   = []
+  def initialize(to_value = nil)
+    @to_value = to_value
+    @steps    = []
   end
 
   def parse(src)
@@ -27,7 +28,7 @@ class Compser::Step
   def call(state)
     results_before = state.result_stack.size
   
-    state = @steps.reduce(state) do |state, step|
+    @steps.each do |step|
       return state if state.bad?
 
       step.call(state)
@@ -35,10 +36,10 @@ class Compser::Step
 
     results_after = state.result_stack.size
 
-    if @mapper && state.good?
+    if @to_value && state.good?
       args = state.pop_results(results_after - results_before).map(&:value)
 
-      state.good!(@mapper.call(*args))
+      state.good!(@to_value.call(*args))
     end
 
     state
@@ -49,11 +50,11 @@ class Compser::Step
 
     step =
       case first
-      when Proc            then first
+      when Proc          then first
       when Compser::Step then first
-      when Symbol          then STEPS.fetch(args.first).call(*rest)
-      when nil             then block ? block : raise(ArgumentError, "expected a callable") 
-      else                 raise ArgumentError, "expected a callable, got #{args.inspect}"
+      when Symbol        then STEPS.fetch(args.first).call(*rest)
+      when nil           then block ? block : raise(ArgumentError, "expected a callable") 
+      else               raise ArgumentError, "expected a callable, got #{args.inspect}"
       end
 
     @steps << step
@@ -68,11 +69,11 @@ class Compser::Step
 
     step =
       case first
-      when Proc            then Drop.(first)
+      when Proc          then Drop.(first)
       when Compser::Step then Drop.(first)
-      when Symbol          then Drop.(STEPS.fetch(first).call(*rest))
-      when nil             then block ? Drop.(block) : raise(ArgumentError, "expected a callable") 
-      else                 raise ArgumentError, "expected a callable"
+      when Symbol        then Drop.(STEPS.fetch(first).call(*rest))
+      when nil           then block ? Drop.(block) : raise(ArgumentError, "expected a callable") 
+      else               raise ArgumentError, "expected a callable"
       end
 
     @steps << step

data/lib/compser/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Compser
-  VERSION = "0.1.0"
+  VERSION = "0.2.1"
 end

data/lib/compser.rb

@@ -11,6 +11,7 @@ require_relative "compser/step/double_quoted_string"
 require_relative "compser/step/drop"
 require_relative "compser/step/integer"
 require_relative "compser/step/keyword"
+require_relative "compser/step/lazy"
 require_relative "compser/step/one_of"
 require_relative "compser/step/problem"
 require_relative "compser/step/sequence"
@@ -23,12 +24,12 @@ module Compser
     Step.new
   end
 
-  def map(mapper)
-    Step.new(mapper)
+  def map(to_value)
+    Step.new(to_value)
   end
 
   def take(...)
-    Step.new.and_then(...)
+    Step.new.take(...)
   end
 
   def drop(...)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: compser
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Luiz Vasconcellos
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-10-14 00:00:00.000000000 Z
+date: 2023-10-15 00:00:00.000000000 Z
 dependencies: []
 description: 
 email:
@@ -24,6 +24,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- examples/calculator.rb
 - examples/json-benchmark.rb
 - examples/json-payload.json
 - examples/json.rb
@@ -39,6 +40,7 @@ files:
 - lib/compser/step/drop.rb
 - lib/compser/step/integer.rb
 - lib/compser/step/keyword.rb
+- lib/compser/step/lazy.rb
 - lib/compser/step/one_of.rb
 - lib/compser/step/problem.rb
 - lib/compser/step/sequence.rb
@@ -70,5 +72,5 @@ requirements: []
 rubygems_version: 3.4.10
 signing_key: 
 specification_version: 4
-summary: Parser combinator for Ruby.
+summary: Compser is a parser library for Ruby inspired by elm-parser.
 test_files: []