pattern-match 0.1.2 → 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a5dfb4c46f1d15a2d58257a25701821fb2346904
+  data.tar.gz: 65976df31a660ee698f2480a1532c4b51bb38f7c
+SHA512:
+  metadata.gz: fb509e20044ecfb152ae2211782d4c4fd0c3b39e31f9a9554b28f47c4e1fc9dbeb724f5cc17c3c60ac2c4c9e874648eebd2830db5d97761b8d1c96767ddaf879
+  data.tar.gz: 29110d2a035d427dcb48909f8bfd28353dd0b3dd6c0346438a5552761e2618bdf377dc8072ba4a578967a569d5481b64025bdac1780a6c73bedc9007faea7b85

data/.travis.yml

@@ -1,4 +1,5 @@
 rvm:
   - 1.9.2
   - 1.9.3
+  - 2.0.0
   - ruby-head

data/README.rdoc

@@ -3,6 +3,10 @@
 A pattern matching library for Ruby.
 
 ==  Installation
+ $ gem install pattern-match
+
+or
+
  $ git clone git://github.com/k-tsj/pattern-match.git
  $ cd pattern-match
  $ gem build pattern-match.gemspec
@@ -14,70 +18,232 @@ or
  $ echo "gem 'pattern-match', :git => 'git://github.com/k-tsj/pattern-match.git'" > Gemfile
  $ bundle install --path vendor/bundle
 
-== Example
+== Basic Usage
+pattern-match library provides Kernel#match.
+
  require 'pattern-match'
 
- ## (A)
- match([0, [1, 2, 3, 4]]) {
-   with(_[a, _[b, *c, d]]) { # Same as `Array.(a, Array.(b, *c, d))'
-     p [a, b, c, d] #=> [0, 1, [2, 3], 4]
-   }
- }
-
- ## (B)
- # From util.match in Gauche: http://practical-scheme.net/gauche/man/?l=en&p=util.match
- match([[0, 1], [2, 3]]) {
-   with(_[_[a, b], ___]) {
-     p [a, b] #=> [[0, 2], [1, 3]]
-   }
- }
-
- ## (C)
- # balance in a red-black tree
+ match(object) do
+   with(pattern[, guard]) do
+     ...
+   end
+   with(pattern[, guard]) do
+     ...
+   end
+   ...
+ end
+
+The patterns are run in sequence until the first one that matches.
+
+If a pattern matches, a block passed to <code>with</code> is called and return its result.
+If no pattern matches, a PatternMatch::NoMatchingPatternError exception is raised.
+
+You can specify pattern guard if you want.
+
+== Patterns
+=== Value
+An object (expect the instance of PatternMatch::Pattern) is a value pattern.
+
+The pattern matches an object such that <code>pattern === object</code>.
+
+ match(0) do
+   with(Fixnum) { :match } #=> :match
+ end
+
+If you want to use an another method of matching,
+you have to use <code>_</code> as follows.
+
+ match(0) do
+   with(_(Fixnum, :==)) { :match }
+ end #=> NoMatchingPatternError
+
+=== Deconstructor
+A deconstructor pattern is (typically) of the form <code>deconstructor.([pattern, ...])</code>.
+
+It is equivalent to Extractor in Scala.
+
+Consider the following example:
+
+ match([0, 1]) do
+   with(Array.(0, 1)) { :match } #=> :match
+ end
+
+ match('ab') do
+   with(/(.)(.)/.('a', 'b')) { :match } #=> :match
+ end
+
+Array, Regexp object(<code>/(.)(.)/</code>) are deconstructors.
+You can use any object has the following features as deconstructor.
+
+* PatternMatch::Deconstructable is included in a class of deconstructor
+* Can be responded to <code>deconstruct</code> method
+
+Note that <code>_[]</code> is provided as syntactic sugar for <code>Array.()</code>.
+
+ match([0, 1]) do
+   with(_[0, 1]) { :match } #=> :match
+ end
+
+=== Variable
+An identifier is a variable pattern.
+
+It matches any value, and binds the variable name to that value.
+A special case is the wild-card pattern <code>_</code> which matches any value,
+and never binds.
+
+ match([0, 1]) do
+   with(_[a, b]) { [a, b] } #=> [0, 1]
+ end
+
+ match(0) do
+   with(_) { _ } #=> NameError
+ end
+
+When several patterns with the same name occur in a single pattern,
+all objects bound to variable must be equal.
+
+ match([0, 1]) do
+   with(_[a, a]) { a }
+ end #=> NoMatchingPatternError
+
+=== And/Or/Not
+<code>PatternMatch::Pattern#&</code>, <code>PatternMatch::Pattern#|</code>, <code>PatternMatch::Pattern#!@</code>,
+<code>And</code>, <code>Or</code>, <code>Not</code> return and/or/not pattern.
+
+ match([0, [1]]) do
+   with(a & Finuxm, ! (_[2] | _[3])) { a } #=> 0
+ end
+
+ match(0) do
+   with(0 | 1 | 2) { } # (0 | 1 | 2) is evaluated to 3, so the pattern does not match.
+   with(Or(0, 1, 2)) { :match } #=> :match
+ end
+
+=== Quantifier
+<code>___</code>(triple underscore), <code>___?</code>,
+<code>__n</code>(double underscore + n where n >= 0), <code>__n?</code> are quantifier patterns.
+
+They are equivalent to <code>*</code>, <code>*?</code>,
+<code>{n,}</code>, <code>{n,}?</code> in regular expression.
+You can write as <code>*pattern</code> instead of <code>pattern, ___</code>.
+
+ match([:a, 0, :b, :c]) do
+   with(_[a & Symbol, ___, b & Fixnum, c & Symbol, ___]) do
+     a #=> [:a]
+     b #=> 0
+     c #=> [:b, :c]
+   end
+ end
+
+=== Sequence
+<code>Seq</code> returns a sequence pattern.
+
+It is equivalent to <code>()</code> in regular expression.
+
+ match([:a, 0, :b, 1]) do
+   with(_[Seq(a & Symbol, b & Fixnum), ___]) do
+     a #=> [:a, :b]
+     b #=> [0, 1]
+   end
+ end
+
+=== EXPERIMENTAL
+* Object.()
+* Matcher
+  * KeyMatcher
+    * Hash.()
+  * AttributeMatcher
+
+See source code for more details.
+
+== Pattern guard
+Pattern guard can be specified as a second argument to <code>with</code>.
+
+ match([1, 2, 3, 4, 5]) do
+   with(_[*_, *a, *_], guard { a.inject(:*) == 12 }) do
+     a #=> [3, 4]
+   end
+ end
+
+== Examples
+ # (A)
  Node = Struct.new(:left, :key, :right)
  class R < Node; end
  class B < Node; end
 
  def balance(left, key, right)
-   match([left, key, right]) {
+   match([left, key, right]) do
      with(_[R.(a, x, b), y, R.(c, z, d)]) { R[B[a, x, b], y, B[c, z, d]] }
      with(_[R.(R.(a, x, b), y, c), z, d]) { R[B[a, x, b], y, B[c, z, d]] }
      with(_[R.(a, x, R.(b, y, c)), z, d]) { R[B[a, x, b], y, B[c, z, d]] }
      with(_[a, x, R.(b, y, R.(c, z, d))]) { R[B[a, x, b], y, B[c, z, d]] }
      with(_[a, x, R.(R.(b, y, c), z, d)]) { R[B[a, x, b], y, B[c, z, d]] }
      with(_) { B[left, key, right] }
-   }
+   end
  end
 
- ## (D)
+ # (B)
  class EMail
    def self.deconstruct(value)
-     value.to_s.split(/@/).tap {|parts| raise PatternNotMatch unless parts.length == 2 }
+     parts = value.to_s.split(/@/)
+     if parts.length == 2
+       parts
+     else
+       raise PatternMatch::PatternNotMatch
+     end
    end
  end
 
- match(['foo-bar@example.com', 'baz-bar@example.com']) {
-   with(_[mail & EMail.(name & /(\w+)-(\w+)/.(firstname, 'bar'), domain), ___]) {
-     p [firstname, name, domain, mail] # => [["foo", "baz"], ["foo-bar", "baz-bar"], ["example.com", "example.com"], ["foo-bar@example.com", "baz-bar@example.com"]]
-   }
- }
+ match(['foo-bar@example.com', 'baz-bar@example.com']) do
+   with(_[mail & EMail.(name & /(\w+)-(\w+)/.(firstname, 'bar'), domain), ___]) do
+     mail      #=> ["foo-bar@example.com", "baz-bar@example.com"]
+     name      #=> ["foo-bar", "baz-bar"]
+     firstname #=> ["foo", "baz"]
+     domain    #=> ["example.com", "example.com"]
+   end
+ end
 
- ## (E)
- match(10) {
-   with(Object.(:to_i => a, :foobar => b)) { :not_match }
-   with(Object.(:to_i => a, :to_s.(16) => b)) {
-     p [a, b] #=> [10, "a"]
-   }
- }
+ # (C)
+ def replace_repeated(obj, &block)
+   ret = match(obj, &block)
+   if ret == obj
+     ret
+   else
+     replace_repeated(ret, &block)
+   end
+ rescue PatternMatch::NoMatchingPatternError
+   obj
+ end
+
+ replace_repeated([1, 2, 4, 4, 3, 3, 4, 0, 0]) do
+   with(_[*a, x, x, *b]) { [*a, x, *b] }
+ end #=> [1, 2, 4, 3, 4, 0]
+
+ # (D)
+ match({a: 0, b: 1}) do
+   with(Hash.(:a, b: Object.(:odd? => true))) do
+     a #=> 0
+   end
+ end
+
+ C = Struct.new(:a, :b) do
+   include PatternMatch::AttributeMatcher
+ end
+ match(C[0, 1]) do
+   with(C.(:b, a: 0)) do
+     b # => 1
+   end
+ end
 
-You can see another example in test/test_pattern-match.rb.
+== Reference
+* {Pattern Matching in Ruby (at Sapporo RubyKaigi 2012) // Speaker Deck}[https://speakerdeck.com/k_tsj/patternmatchinginruby]
 
 == Development
  $ git clone git://github.com/k-tsj/pattern-match.git
  $ cd pattern-match
  $ gem install bundler (if you need)
  $ bundle install --path vendor/bundle
- $ rake test (or simply type "rake")
- $ rake build
+ $ bundle exec rake test (or "bundle exec rake")
+ $ bundle exec rake build
 
 == Travis Build Status {<img src="https://secure.travis-ci.org/k-tsj/pattern-match.png"/>}[http://travis-ci.org/k-tsj/pattern-match]

data/lib/pattern-match.rb

@@ -8,13 +8,35 @@ module PatternMatch
   module Deconstructable
     def call(*subpatterns)
       if Object == self
-        raise MalformedPatternError unless subpatterns.length == 1
-        PatternObject.new(subpatterns[0])
-      elsif Hash == self
-        raise MalformedPatternError unless subpatterns.length == 1
-        PatternHash.new(subpatterns[0])
+        PatternKeywordArgStyleDeconstructor.new(Object, :respond_to?, :__send__, *subpatterns)
       else
-        PatternDeconstructor.new(self, *subpatterns)
+        pattern_matcher(*subpatterns)
+      end
+    end
+  end
+
+  class ::Object
+    def pattern_matcher(*subpatterns)
+      PatternObjectDeconstructor.new(self, *subpatterns)
+    end
+  end
+
+  module AttributeMatcher
+    def self.included(klass)
+      class << klass
+        def pattern_matcher(*subpatterns)
+          PatternKeywordArgStyleDeconstructor.new(self, :respond_to?, :__send__, *subpatterns)
+        end
+      end
+    end
+  end
+
+  module KeyMatcher
+    def self.included(klass)
+      class << klass
+        def pattern_matcher(*subpatterns)
+          PatternKeywordArgStyleDeconstructor.new(self, :has_key?, :[], *subpatterns)
+        end
       end
     end
   end
@@ -34,6 +56,10 @@ module PatternMatch
       @subpatterns.map(&:vars).flatten
     end
 
+    def ancestors
+      root? ? [self] : parent.ancestors.unshift(self)
+    end
+
     def binding
       vars.each_with_object({}) {|v, h| h[v.name] = v.val }
     end
@@ -51,11 +77,19 @@ module PatternMatch
     end
 
     def to_a
-      [self, PatternQuantifier.new(0)]
+      [self, PatternQuantifier.new(0, true)]
+    end
+
+    def quantifier?
+      raise NotImplementedError
     end
 
     def quantified?
-      @next.kind_of?(PatternQuantifier) || (root? ? false : @parent.quantified?)
+      (@next and @next.quantifier?) || (root? ? false : @parent.quantified?)
+    end
+
+    def root
+      root? ? self : @parent.root
     end
 
     def root?
@@ -63,114 +97,205 @@ module PatternMatch
     end
 
     def validate
-      if root?
-        dup_vars = vars - vars.uniq {|i| i.name }
-        raise MalformedPatternError, "duplicate variables: #{dup_vars.map(&:name).join(', ')}" unless dup_vars.empty?
-      end
-      raise MalformedPatternError if @subpatterns.count {|i| i.kind_of?(PatternQuantifier) } > 1
       @subpatterns.each(&:validate)
     end
 
+    def match(vals)
+      if @next and @next.quantifier?
+        q = @next
+        repeating_match(vals, q.longest?) do |vs, rest|
+          if vs.length < q.min_k
+            next false
+          end
+          vs.all? {|v| yield(v) } and q.match(rest)
+        end
+      else
+        if vals.empty?
+          return false
+        end
+        val, *rest = vals
+        yield(val) and (@next ? @next.match(rest) : rest.empty?)
+      end
+    end
+
+    def append(pattern)
+      if @next
+        @next.append(pattern)
+      else
+        if @subpatterns.empty?
+          if root?
+            new_root = PatternAnd.new(self)
+            self.parent = new_root
+          end
+          pattern.parent = @parent
+          @next = pattern
+        else
+          @subpatterns[-1].append(pattern)
+        end
+      end
+    end
+
     private
 
+    def repeating_match(vals, longest)
+      quantifier = @next
+      lp = longest_patterns(vals)
+      (longest ? lp : lp.reverse).each do |(vs, rest)|
+        vars.each {|i| i.set_bind_to(quantifier) }
+        begin
+          if yield vs, rest
+            return true
+          end
+        rescue PatternNotMatch
+        end
+        vars.each {|i| i.unset_bind_to(quantifier) }
+      end
+      false
+    end
+
+    def longest_patterns(vals)
+      vals.length.downto(0).map do |n|
+        [vals.take(n), vals.drop(n)]
+      end
+    end
+
     def set_subpatterns_relation
       @subpatterns.each do |i|
         i.parent = self
       end
-      @subpatterns.each_cons(2) do |a, b|
-        a.next = b
-        b.prev = a
+    end
+  end
+
+  class PatternQuantifier < Pattern
+    attr_reader :min_k
+
+    def initialize(min_k, longest)
+      super()
+      @min_k = min_k
+      @longest = longest
+    end
+
+    def validate
+      super
+      raise MalformedPatternError unless @prev and ! @prev.quantifier?
+      seqs = ancestors.grep(PatternSequence).reverse
+      if seqs.any? {|i| i.next and i.next.quantifier? and not i.vars.empty? }
+        raise NotImplementedError
+      end
+      case @parent
+      when PatternObjectDeconstructor
+        # do nothing
+      when PatternSequence
+        # do nothing
+      else
+        raise MalformedPatternError
       end
     end
 
-    def ancestors
-      ary = []
-      pat = self
-      until pat == nil
-        ary << pat
-        pat = pat.parent
+    def quantifier?
+      true
+    end
+
+    def match(vals)
+      if @next
+        @next.match(vals)
+      else
+        vals.empty?
       end
-      ary
     end
-  end
 
-  class PatternObject < Pattern
-    def initialize(spec)
-      super(*spec.values)
-      @spec = spec.map {|k, pat| [k.to_proc, pat] }
-    rescue
-      raise MalformedPatternError
+    def longest?
+      @longest
     end
 
-    def match(val)
-      @spec.all? {|k, pat| pat.match(k.(val)) rescue raise PatternNotMatch }
+    def inspect
+      "#<#{self.class.name}: min_k=#{@min_k}, longest=#{@longest}>"
     end
   end
 
-  class PatternHash < Pattern
-    def initialize(spec)
-      super(*spec.values)
-      @spec = spec
+  class PatternElement < Pattern
+    def quantifier?
+      false
     end
+  end
 
-    def match(val)
-      raise PatternNotMatch unless val.kind_of?(Hash)
-      raise PatternNotMatch unless @spec.keys.all? {|k| val.has_key?(k) }
-      @spec.all? {|k, pat| pat.match(val[k]) rescue raise PatternNotMatch }
-    end
+  class PatternDeconstructor < PatternElement
   end
 
-  class PatternDeconstructor < Pattern
+  class PatternObjectDeconstructor < PatternDeconstructor
     def initialize(deconstructor, *subpatterns)
       super(*subpatterns)
       @deconstructor = deconstructor
     end
 
-    def match(val)
-      deconstructed_vals = @deconstructor.deconstruct(val)
-      k = deconstructed_vals.length - (@subpatterns.length - 2)
-      quantifier = @subpatterns.find {|i| i.kind_of?(PatternQuantifier) }
-      if quantifier
-        return false unless quantifier.min_k <= k
-      else
-        return false unless @subpatterns.length == deconstructed_vals.length
-      end
-      @subpatterns.flat_map do |pat|
-        case
-        when pat.next.kind_of?(PatternQuantifier)
-          []
-        when pat.kind_of?(PatternQuantifier)
-          pat.prev.vars.each {|v| v.set_bind_to(pat) }
-          Array.new(k, pat.prev)
-        else
-          [pat]
+    def match(vals)
+      super do |val|
+        deconstructed_vals = @deconstructor.deconstruct(val)
+        if @subpatterns.empty?
+          next deconstructed_vals.empty?
         end
-      end.zip(deconstructed_vals).all? do |pat, v|
-        pat.match(v)
+        @subpatterns[0].match(deconstructed_vals)
+      end
+    end
+
+    def inspect
+      "#<#{self.class.name}: deconstructor=#{@deconstructor.inspect}, subpatterns=#{@subpatterns.inspect}>"
+    end
+
+    private
+
+    def set_subpatterns_relation
+      super
+      @subpatterns.each_cons(2) do |a, b|
+        a.next = b
+        b.prev = a
       end
     end
   end
 
-  class PatternQuantifier < Pattern
-    attr_reader :min_k
+  class PatternKeywordArgStyleDeconstructor < PatternDeconstructor
+    def initialize(klass, checker, getter, *keyarg_subpatterns)
+      spec = normalize_keyword_arg(keyarg_subpatterns)
+      super(*spec.values)
+      @klass = klass
+      @checker = checker
+      @getter = getter
+      @spec = spec
+    end
 
-    def initialize(min_k)
-      super()
-      @min_k = min_k
+    def match(vals)
+      super do |val|
+        next false unless val.kind_of?(@klass)
+        next false unless @spec.keys.all? {|k| val.__send__(@checker, k) }
+        @spec.all? do |k, pat|
+          pat.match([val.__send__(@getter, k)]) rescue false
+        end
+      end
     end
 
-    def match(val)
-      raise PatternMatchError, 'must not happen'
+    def inspect
+      "#<#{self.class.name}: klass=#{@klass.inspect}, spec=#{@spec.inspect}>"
     end
 
-    def validate
-      super
-      raise MalformedPatternError unless @prev
-      raise MalformedPatternError unless @parent.kind_of?(PatternDeconstructor)
+    private
+
+    def normalize_keyword_arg(subpatterns)
+      syms = subpatterns.take_while {|i| i.kind_of?(Symbol) }
+      rest = subpatterns.drop(syms.length)
+      hash = case rest.length
+             when 0
+               {}
+             when 1
+               rest[0]
+             else
+               raise MalformedPatternError
+             end
+      variables = Hash[syms.map {|i, h| [i, PatternVariable.new(i)] }]
+      Hash[variables.merge(hash).map {|k, v| [k, v.kind_of?(Pattern) ? v : PatternValue.new(v)] }]
     end
   end
 
-  class PatternVariable < Pattern
+  class PatternVariable < PatternElement
     attr_reader :name, :val
 
     def initialize(name)
@@ -180,9 +305,11 @@ module PatternMatch
       @bind_to = nil
     end
 
-    def match(val)
-      bind(val)
-      true
+    def match(vals)
+      super do |val|
+        bind(val)
+        true
+      end
     end
 
     def vars
@@ -190,18 +317,37 @@ module PatternMatch
     end
 
     def set_bind_to(quantifier)
-      if @val
+      n = nest_level(quantifier)
+      if n == 0
+        @val = @bind_to = []
+      else
         outer = @val
-        (nest_level(quantifier) - 1).times do
+        (n - 1).times do
           outer = outer[-1]
         end
         @bind_to = []
         outer << @bind_to
+      end
+    end
+
+    def unset_bind_to(quantifier)
+      n = nest_level(quantifier)
+      @bind_to = nil
+      if n == 0
+        # do nothing
       else
-        @val = @bind_to = []
+        outer = @val
+        (n - 1).times do
+          outer = outer[-1]
+        end
+        outer.pop
       end
     end
 
+    def inspect
+      "#<#{self.class.name}: name=#{name.inspect}, val=#{@val.inspect}>"
+    end
+
     private
 
     def bind(val)
@@ -213,56 +359,220 @@ module PatternMatch
     end
 
     def nest_level(quantifier)
-      qs = ancestors.map {|i| i.next.kind_of?(PatternQuantifier) ? i.next : nil }.find_all {|i| i }.reverse
+      raise PatternMatchError unless quantifier.kind_of?(PatternQuantifier)
+      qs = ancestors.map {|i| (i.next and i.next.quantifier?) ? i.next : nil }.find_all {|i| i }.reverse
       qs.index(quantifier) || (raise PatternMatchError)
     end
   end
 
-  class PatternValue < Pattern
+  class PatternValue < PatternElement
     def initialize(val, compare_by = :===)
       super()
       @val = val
       @compare_by = compare_by
     end
 
-    def match(val)
-      @val.__send__(@compare_by, val)
+    def match(vals)
+      super do |val|
+        @val.__send__(@compare_by, val)
+      end
+    end
+
+    def inspect
+      "#<#{self.class.name}: val=#{@val.inspect}>"
     end
   end
 
-  class PatternAnd < Pattern
-    def match(val)
-      @subpatterns.all? {|i| i.match(val) }
+  class PatternSequence < PatternElement
+    class PatternRewind < PatternElement
+      attr_reader :ntimes
+
+      def initialize(ntimes, head_pattern, next_pattern)
+        super()
+        @ntimes = ntimes
+        @head = head_pattern
+        @next = next_pattern
+      end
+
+      def match(vals)
+        if @ntimes > 0
+          @ntimes -= 1
+          @head.match(vals)
+        else
+          @next ? @next.match(vals) : vals.empty?
+        end
+      end
+
+      def inspect
+        "#<#{self.class.name}: ntimes=#{@ntimes} head=#{@head.inspect} next=#{@next.inspect}>"
+      end
+    end
+
+    def match(vals)
+      if @next and @next.quantifier?
+        repeating_match(vals, @next.longest?) do |rewind|
+          if rewind.ntimes < @next.min_k
+            next false
+          end
+          rewind.match(vals)
+        end
+      else
+        with_rewind(make_rewind(1)) do |rewind|
+          rewind.match(vals)
+        end
+      end
+    end
+
+    def validate
+      super
+      if @subpatterns.empty?
+        raise MalformedPatternError
+      end
+      case @parent
+      when PatternObjectDeconstructor
+        # do nothing
+      when PatternSequence
+        # do nothing
+      else
+        raise MalformedPatternError
+      end
+    end
+
+    def inspect
+      "#<#{self.class.name}: subpatterns=#{@subpatterns.inspect}>"
+    end
+
+    private
+
+    def make_rewind(n)
+      PatternRewind.new(n, @subpatterns[0], (@next and @next.quantifier?) ? @next.next : @next)
+    end
+
+    def repeating_match(vals, longest)
+      quantifier = @next
+      lp = longest_patterns(vals)
+      (longest ? lp : lp.reverse).each do |rewind|
+        vars.each {|i| i.set_bind_to(quantifier) }
+        begin
+          with_rewind(rewind) do |rewind|
+            if yield rewind
+              return true
+            end
+          end
+        rescue PatternNotMatch
+        end
+        vars.each {|i| i.unset_bind_to(quantifier) }
+      end
+      false
+    end
+
+    def longest_patterns(vals)
+      vals.length.downto(0).map do |n|
+        make_rewind(n)
+      end
+    end
+
+    def with_rewind(rewind)
+      @subpatterns[-1].next = rewind
+      yield rewind
+    ensure
+      @subpatterns[-1].next = nil
+    end
+
+    def set_subpatterns_relation
+      super
+      @subpatterns.each_cons(2) do |a, b|
+        a.next = b
+        b.prev = a
+      end
     end
   end
 
-  class PatternOr < Pattern
-    def match(val)
-      @subpatterns.find do |i|
+  class PatternAnd < PatternElement
+    def match(vals)
+      super do |val|
+        @subpatterns.all? {|i| i.match([val]) }
+      end
+    end
+
+    def validate
+      super
+      raise MalformedPatternError if @subpatterns.empty?
+    end
+
+    def inspect
+      "#<#{self.class.name}: subpatterns=#{@subpatterns.inspect}>"
+    end
+  end
+
+  class PatternOr < PatternElement
+    def match(vals)
+      super do |val|
+        @subpatterns.find do |i|
+          begin
+            i.match([val])
+          rescue PatternNotMatch
+            false
+          end
+        end
+      end
+    end
+
+    def validate
+      super
+      raise MalformedPatternError if @subpatterns.empty?
+      raise MalformedPatternError unless vars.empty?
+    end
+
+    def inspect
+      "#<#{self.class.name}: subpatterns=#{@subpatterns.inspect}>"
+    end
+  end
+
+  class PatternNot < PatternElement
+    def match(vals)
+      super do |val|
         begin
-          i.match(val)
+          ! @subpatterns[0].match([val])
         rescue PatternNotMatch
-          false
+          true
         end
       end
     end
 
     def validate
       super
-      raise MalformedPatternError unless vars.length == 0
+      raise MalformedPatternError unless @subpatterns.length == 1
+      raise MalformedPatternError unless vars.empty?
+    end
+
+    def inspect
+      "#<#{self.class.name}: subpatterns=#{@subpatterns.inspect}>"
     end
   end
 
-  class PatternNot < Pattern
-    def match(val)
-      ! @subpatterns[0].match(val)
-    rescue PatternNotMatch
-      true
+  class PatternCondition < PatternElement
+    def initialize(&condition)
+      super()
+      @condition = condition
+    end
+
+    def match(vals)
+      return false unless vals.empty?
+      if @condition.call
+        @next ? @next.match(vals) : true
+      else
+        false
+      end
     end
 
     def validate
       super
-      raise MalformedPatternError unless vars.length == 0
+      raise MalformedPatternError if ancestors.find {|i| i.next and ! i.next.kind_of?(PatternCondition) }
+    end
+
+    def inspect
+      "#<#{self.class.name}: condition=#{@condition.inspect}>"
     end
   end
 
@@ -275,10 +585,28 @@ module PatternMatch
     private
 
     def with(pat_or_val, guard_proc = nil, &block)
+      ctx = @ctx
       pat = pat_or_val.kind_of?(Pattern) ? pat_or_val : PatternValue.new(pat_or_val)
+      pat.append(
+        PatternCondition.new do
+          pat.vars.each_with_object({}) do |v, h|
+            if h.has_key?(v.name)
+              unless h[v.name] == v.val
+                ::Kernel.raise PatternNotMatch
+              end
+            else
+              h[v.name] = v.val
+            end
+          end
+          true
+        end
+      )
+      if guard_proc
+        pat.append(PatternCondition.new { with_tmpbinding(ctx, pat.binding, &guard_proc) })
+      end
       pat.validate
-      if pat.match(@val) and (guard_proc ? with_tmpbinding(@ctx, pat.binding, &guard_proc) : true)
-        ret = with_tmpbinding(@ctx, pat.binding, &block)
+      if pat.match([@val])
+        ret = with_tmpbinding(ctx, pat.binding, &block)
         ::Kernel.throw(:exit_match, ret)
       else
         nil
@@ -290,12 +618,18 @@ module PatternMatch
       block
     end
 
+    def ___
+      PatternQuantifier.new(0, true)
+    end
+
+    def ___?
+      PatternQuantifier.new(0, false)
+    end
+
     def method_missing(name, *)
       case name.to_s
-      when '___'
-        PatternQuantifier.new(0)
-      when /\A__(\d+)\z/
-        PatternQuantifier.new($1.to_i)
+      when /\A__(\d+)(\??)\z/
+        PatternQuantifier.new($1.to_i, ! $2.empty?)
       else
         PatternVariable.new(name)
       end
@@ -310,13 +644,14 @@ module PatternMatch
             Array.call(*args)
           end
 
-          def match(val)
-            true
-          end
-
           def vars
             []
           end
+
+          private
+
+          def bind(val)
+          end
         end
         uscore
       when 1
@@ -331,6 +666,26 @@ module PatternMatch
     alias __ _
     alias _l _
 
+    def Seq(*subpatterns)
+      PatternSequence.new(*subpatterns)
+    end
+
+    def And(*subpatterns)
+      PatternAnd.new(*subpatterns)
+    end
+
+    def Or(*subpatterns)
+      PatternOr.new(*subpatterns)
+    end
+
+    def Not(*subpatterns)
+      PatternNot.new(*subpatterns)
+    end
+
+
+    class TmpBindingModule < ::Module
+    end
+
     def with_tmpbinding(obj, binding, &block)
       tmpbinding_module(obj).instance_eval do
         begin
@@ -345,7 +700,8 @@ module PatternMatch
           obj.instance_eval(&block)
         ensure
           binding.each do |name, _|
-            if @stacks[name].tap(&:pop).empty?
+            @stacks[name].pop
+            if @stacks[name].empty?
               remove_method(name)
             end
           end
@@ -353,9 +709,6 @@ module PatternMatch
       end
     end
 
-    class TmpBindingModule < ::Module
-    end
-
     def tmpbinding_module(obj)
       m = obj.singleton_class.ancestors.find {|i| i.kind_of?(TmpBindingModule) }
       unless m
@@ -429,6 +782,10 @@ class Class
   end
 end
 
+class Hash
+  include PatternMatch::KeyMatcher
+end
+
 class << Array
   def deconstruct(val)
     accept_self_instance_only(val)
@@ -473,9 +830,3 @@ class Regexp
     m.captures.empty? ? [m[0]] : m.captures
   end
 end
-
-class Symbol
-  def call(*args)
-    Proc.new {|obj| obj.__send__(self, *args) }
-  end
-end