pattern-match 0.0.1 → 0.0.2

data/README.rdoc

@@ -15,7 +15,89 @@ or
  $ bundle install --path vendor/bundle
 
 == Example
-See test/test_pattern-match.rb.
+ 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
+ Node = Struct.new(:left, :key, :right)
+ class R < Node; end
+ class B < Node; end
+
+ def balance(left, key, right)
+   match([left, key, right]) {
+     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
+
+ # With Refinements
+ def balance(left, key, right)
+   match([left, key, right]) {
+     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
+
+ ## (D)
+ class EMail
+   def self.extract(value)
+     value.to_s.split(/@/).tap {|parts| raise PatternNotMatch unless parts.length == 2 }
+   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"]]
+   }
+ }
+
+ # With Refinements
+ 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"]]
+   }
+ }
+
+ ## (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"]
+   }
+ }
+
+ # With Refinements
+ match(10) {
+   with(:to_i[a] & :foobar[b]) { :not_match }
+   with(:to_i[a] & :to_s.(16)[b])) {
+     p [a, b] #=> [10, "a"]
+   }
+ }
+
+You can see another example in test/test_pattern-match.rb.
 
 == Development
  $ git clone git://github.com/k-tsj/pattern-match.git

data/lib/pattern-match/version.rb

@@ -1,3 +1,3 @@
 module PatternMatch
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/pattern-match.rb

@@ -61,6 +61,27 @@ module PatternMatch
       end
     end
 
+    refine Complex.singleton_class do
+      def extract(val)
+        accept_self_instance_only(val)
+        val.rect
+      end
+    end
+
+    refine Rational.singleton_class do
+      def extract(val)
+        accept_self_instance_only(val)
+        [val.numerator, val.denominator]
+      end
+    end
+
+    refine MatchData.singleton_class do
+      def extract(val)
+        accept_self_instance_only(val)
+        val.captures.empty? ? [val[0]] : val.captures
+      end
+    end
+
     if SUPPORT_REFINEMENTS
       def Struct.method_added(name)
         if name == members[0]
@@ -301,13 +322,14 @@ module PatternMatch
   end
 
   class PatternValue < Pattern
-    def initialize(val)
+    def initialize(val, compare_by = :===)
       super()
       @val = val
+      @compare_by = compare_by
     end
 
     def match(val)
-      @val === val
+      @val.send(@compare_by, val)
     end
   end
 
@@ -410,6 +432,8 @@ module PatternMatch
         uscore
       when 1
         PatternValue.new(vals[0])
+      when 2
+        PatternValue.new(vals[0], vals[1])
       else
         raise MalformedPatternError
       end

data/test/test_pattern-match.rb

@@ -52,8 +52,8 @@ class TestPatternMatch < Test::Unit::TestCase
   end
 
   def test_uscore
-    match([0, 1]) {
-      with(_[_, ! _(Float)]) {
+    match([0, 1, Fixnum]) {
+      with(_[_, ! _(Float), _(Fixnum, :==)]) {
         assert_raise(NameError) { _ }
       }
       with(_) { flunk }
@@ -279,6 +279,46 @@ class TestPatternMatch < Test::Unit::TestCase
     }
   end
 
+  def test_extractor_class_complex
+    match(Complex(0, 1)) {
+      with(Complex.(a, b)) {
+        assert_equal(0, a)
+        assert_equal(1, b)
+      }
+      with(_) { flunk }
+    }
+  end
+
+  def test_extractor_class_rational
+    match(Rational(0, 1)) {
+      with(Rational.(a, b)) {
+        assert_equal(0, a)
+        assert_equal(1, b)
+      }
+      with(_) { flunk }
+    }
+  end
+
+  def test_extractor_class_matchdata
+    m = /.../.match('abc')
+    match(m) {
+      with(MatchData.(a)) {
+        assert_equal('abc', a)
+      }
+      with(_) { flunk }
+    }
+
+    m = /(.)(.)(.)/.match('abc')
+    match(m) {
+      with(MatchData.(a, b, c)) {
+        assert_equal('a', a)
+        assert_equal('b', b)
+        assert_equal('c', c)
+      }
+      with(_) { flunk }
+    }
+  end
+
   def test_extractor_obj_regexp
     match('abc') {
       with(/./.(a)) { flunk }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pattern-match
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-03 00:00:00.000000000 Z
+date: 2012-03-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &8351800 !ruby/object:Gem::Requirement
+  requirement: &6408560 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *8351800
+  version_requirements: *6408560
 description: A pattern matching library.
 email:
 - kazuki@callcc.net
@@ -57,7 +57,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2652740272817572795
+      hash: 2122497246809249036
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -66,7 +66,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2652740272817572795
+      hash: 2122497246809249036
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.11