patm 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a6f5f8bcb3f5f3031bac6f117418b1d3bc917e8a
-  data.tar.gz: 56f203d9076b6905894ffb752954c7caa41fcca6
+  metadata.gz: 0e616e4136344078fc78da517f68682dd2ace261
+  data.tar.gz: 759ff1f8066ad8b0f9ea3e1cd28573458b62fc5d
 SHA512:
-  metadata.gz: 7f01fa35d647fea7658029071682a77dea11e7da92968087c383028f13476ba7a7745a7f04093457c1a45beb92bc1328fab4c9feb464f55550ef3df08b38bb40
-  data.tar.gz: 9ac471509e902916d52693fc7fe0bac69fb84106b8a539bcbd1f6a6657c34150e6214e73d0555b28c32ac6038bbdfaa7f40073160327ac024a9be16c2d7d1bdd
+  metadata.gz: 3471bde54cc18238144344e507e66a40cf116bfea3aebb3c4b6c85c18e27edb7931f0db1474f684a5dc6c1044a9a9e89c4a46f8b222e9056ed562d877658abfd
+  data.tar.gz: cb68d3f85838c99f3f39089f78f53e64f5ec8f21734c111563c18e773a17ad29388e563952185aa636b2d0fbef838ed4a4491ec42fae7c3491c2392a6fa6aa24

data/README.md

@@ -10,7 +10,7 @@ require 'patm'
 # With case(simple but slow)
 def match(obj)
   p = Patm
-  _xs = Patm::ARRAY_REST
+  _xs = Patm._xs
   case obj
   when m = Patm.match([:x, p._1, p._2])
     [m._2, m._1]
@@ -29,11 +29,35 @@ match([])
 # => nil
 ```
 
+```ruby
+# With DSL
+class A
+  extend ::Patm::DSL
+
+  define_matcher :match1 do|r|
+    p = Patm
+    r.on [:x, p._1, p._2] do|m|
+      [m._1, m._2]
+    end
+  end
+
+  define_matcher :match2 do|r|
+    r.on [:a, Patm._xs & Patm._1] do|m, _self|
+      _self.match1(m._1)
+    end
+    # ...
+  end
+end
+
+A.new.match1([:x, 1, 2])
+# => [1, 2]
+```
+
 ```ruby
 # With pre-built Rule
 rule = Patm::Rule.new do|r|
   p = Patm
-  _xs = Patm::ARRAY_REST
+  _xs = Patm._xs
   r.on [:x, p._1, p._2] do|m|
     [m._2, m._1]
   end
@@ -76,9 +100,37 @@ class A
 end
  ```
 
+## Patterns
+
+### `1`, `:x`, String, ...
+
+Normal pattern matches if `pattern === value` is true.
+
+### Array
+
+`[1, 2, _xs]` matches `[1, 2]`, `[1, 2, 3]`, `[1, 2, 3, 4]`, etc.
+`[1, _xs, 2]` matches `[1, 2]`, `[1, 10, 2]`, etc.
+
+Note: More than one `_xs` in same array is invalid.
+
+### Capture
+
+`_1`, `_2`, etc matches any value, and capture the value as correspond match group.
+
+### Compose
+
+`_1&[_any, _any]` matches any two element array, and capture the array as _1.
+`Patm.or(1, 2)` matches 1 or 2.
+
 
 ## Changes
 
+### 1.0.0
+
+- DSL
+- Compile is enabled by default
+- Change interface
+
 ### 0.1.0
 
 - Faster matching with pattern compilation

data/benchmark/benchmark.rb

@@ -8,7 +8,7 @@ def match_with_case(obj)
   _2 = P._2
   _3 = P._3
   _4 = P._4
-  _xs = P::ARRAY_REST
+  _xs = P._xs
 
   case obj
   when m = P.match([:assign, [:var_field, [:@ident, _1, [_2, _3]]], _4])
@@ -31,7 +31,7 @@ end
   _2 = P._2
   _3 = P._3
   _4 = P._4
-  _xs = P::ARRAY_REST
+  _xs = P._xs
 
   r.on [:assign, [:var_field, [:@ident, _1, [_2, _3]]], _4] do|m|
     :as
@@ -53,7 +53,7 @@ end
   end
 end
 
-@rule = P::Rule.new(&@ruledef)
+@rule = P::Rule.new(false, &@ruledef)
 @compiled_rule = P::Rule.new(true, &@ruledef)
 
 def match_with_rule(obj)

data/lib/patm.rb

@@ -1,33 +1,30 @@
 module Patm
   class Pattern
-    def execute(match, obj); true; end
-
-    def rest?
-      false
-    end
 
     def self.build_from(plain)
       case plain
       when Pattern
         plain
       when Array
-        build_from_array(plain)
+        array = plain.map{|a| build_from(a)}
+        rest_index = array.index(&:rest?)
+        if rest_index
+          head = array[0...rest_index]
+          rest = array[rest_index]
+          tail = array[(rest_index+1)..-1]
+          Arr.new(head, rest, tail)
+        else
+          Arr.new(array)
+        end
       else
         Obj.new(plain)
       end
     end
 
-    def self.build_from_array(array)
-      array = array.map{|a| build_from(a)}
-      rest_index = array.index(&:rest?)
-      if rest_index
-        head = array[0...rest_index]
-        rest = array[rest_index]
-        tail = array[(rest_index+1)..-1]
-        Arr.new(head, rest, tail)
-      else
-        Arr.new(array)
-      end
+    def execute(match, obj); true; end
+
+    def rest?
+      false
     end
 
     def &(rhs)
@@ -271,15 +268,38 @@ module Patm
     end
   end
 
-  ANY = Pattern::Any.new
   GROUP = 100.times.map{|i| Pattern::Group.new(i) }
-  ARRAY_REST = Pattern::ArrRest.new
+
+  def self.or(*pats)
+    Pattern::Or.new(pats.map{|p| Pattern.build_from(p) })
+  end
+
+  def self._any
+    @any ||= Pattern::Any.new
+  end
+
+  def self._xs
+    @xs = Pattern::ArrRest.new
+  end
+
+  class <<self
+    GROUP.each do|g|
+      define_method "_#{g.index}" do
+        g
+      end
+    end
+  end
+
+  def self.match(plain_pat)
+    CaseBinder.new Pattern.build_from(plain_pat)
+  end
 
   class Rule
-    def initialize(compile = false, &block)
+    def initialize(compile = true, &block)
       @compile = compile
       # { Pattern => Proc }
       @rules = []
+      @else = ->(obj){nil}
       block[self]
     end
 
@@ -292,31 +312,27 @@ module Patm
     end
 
     def else(&block)
-      if @compile
-        @rules << [ANY.compile, lambda {|m,o| block[o] }]
-      else
-        @rules << [ANY, lambda {|m,o| block[o] }]
-      end
+      @else = block
     end
 
-    def apply(obj)
+    def apply(obj, _self = nil)
       match = Match.new
       @rules.each do|(pat, block)|
         if pat.execute(match, obj)
-          return block.call(match, obj)
+          return block.call(match, _self)
         end
       end
-      nil
+      @else[obj, _self]
     end
   end
 
   class RuleCache
-    def initialize(compile = false)
+    def initialize(compile = true)
       @compile = compile
       @rules = {}
     end
-    def match(rule_name, obj, &rule)
-      (@rules[rule_name] ||= ::Patm::Rule.new(@compile, &rule)).apply(obj)
+    def match(rule_name, obj, _self = nil, &rule)
+      (@rules[rule_name] ||= ::Patm::Rule.new(@compile, &rule)).apply(obj, _self)
     end
   end
 
@@ -358,29 +374,12 @@ module Patm
     end
   end
 
-  def self.match(plain_pat)
-    CaseBinder.new Pattern.build_from(plain_pat)
-  end
-
-  def self.match_array(head, rest_spat = nil, tail = [])
-    # TODO: deprecated
-    Match.new(
-      Pattern::Arr.new(
-        head.map{|e| Pattern.build_from(e)},
-        rest_spat,
-        tail.map{|e| Pattern.build_from(e)}
-      )
-    )
-  end
-
-  def self.or(*pats)
-    Pattern::Or.new(pats.map{|p| Pattern.build_from(p) })
-  end
-
-  class <<self
-    GROUP.each do|g|
-      define_method "_#{g.index}" do
-        g
+  module DSL
+    def define_matcher(name, &rule)
+      @patm_rules ||= RuleCache.new
+      rules = @patm_rules
+      define_method name do|obj|
+        rules.match(name, obj, self, &rule)
       end
     end
   end

data/patm.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.platform    = Gem::Platform::RUBY
   s.name        = 'patm'
-  s.version     = '0.1.0'
+  s.version     = '1.0.0'
   s.summary     = 'PATtern Matching library'
   s.description = 'Pattern matching library for plain data structure'
   s.required_ruby_version = '>= 1.9.0'

data/spec/patm_spec.rb

@@ -51,7 +51,7 @@ describe "Usage:" do
 
   it 'with predefined Rule' do
     p = Patm
-    r = p::Rule.new do|r|
+    r = p::Rule.new(false) do|r|
       r.on [1, p._1, p._2] do|m|
         [m._1, m._2]
       end
@@ -100,6 +100,37 @@ describe "Usage:" do
 
     rs.match(:pattern_1, [1, 3, 5]) {|r| fail "should not reach here" }.should == [3, 5]
   end
+
+  it 'with DSL' do
+    o = Object.new
+    class <<o
+      extend ::Patm::DSL
+      define_matcher :match1 do|r|
+        r.on [1, 2, ::Patm._1] do|m|
+          m._1
+        end
+        r.else do|obj|
+          obj.to_s
+        end
+      end
+
+      define_matcher :match2 do|r|
+        r.on [1] do
+          1
+        end
+        r.on [1, ::Patm._xs & ::Patm._1] do|m, _self|
+          _self.match1(m._1)
+        end
+      end
+    end
+
+    o.match1([1, 2, 3]).should == 3
+    o.match1([1, 2, 4]).should == 4
+    o.match1([1, 2]).should == "[1, 2]"
+
+    o.match2([1]).should == 1
+    o.match2([1, 2, 3]).should == "[2, 3]"
+  end
 end
 
 describe Patm::Pattern do
@@ -133,12 +164,12 @@ describe Patm::Pattern do
     it { should_not match_to [1,2,3] }
   end
 
-  pattern Patm::ANY do
+  pattern Patm._any do
     it { should match_to 1 }
     it { should match_to ["foo", "bar"] }
   end
 
-  pattern [1, Patm::ANY, 3] do
+  pattern [1, Patm._any, 3] do
     it { should match_to [1, 2, 3] }
     it { should match_to [1, 0, 3] }
     it { should_not match_to [1, 0, 4] }
@@ -164,18 +195,18 @@ describe Patm::Pattern do
     it { should_not match_to(['x', 1, 2]).and_capture(1, 2) }
   end
 
-  pattern [0, 1, Patm::ARRAY_REST] do
+  pattern [0, 1, Patm._xs] do
     it { should_not match_to([0]) }
     it { should match_to([0, 1]) }
     it { should match_to([0, 1, 2, 3]) }
   end
 
-  pattern [0, 1, Patm::ARRAY_REST & Patm._1] do
+  pattern [0, 1, Patm._xs & Patm._1] do
     it { should match_to([0, 1]).and_capture([]) }
     it { should match_to([0, 1, 2, 3]).and_capture([2, 3]) }
   end
 
-  pattern [0, 1, Patm::ARRAY_REST, 2] do
+  pattern [0, 1, Patm._xs, 2] do
     it { should match_to([0,1,2]) }
     it { should match_to([0,1,10,20,30,2]) }
     it { should_not match_to([0,1]) }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: patm
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - todesking