patternmatching 0.1.0

data/spec/patternmatching_spec.rb

@@ -0,0 +1,162 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+require 'patternmatching'
+
+class CalcM
+  # At first, extends with the module
+  extend PatternMatching
+
+  # def calcm(o), as 3 partial styles
+  func(:calcm).seems as {plus(:left, :right)} do
+    calcm(left) + calcm(right)
+  end
+  func(:calcm).seems as {mul(:left, :right)} do
+    calcm(left) * calcm(right)
+  end
+  func(:calcm).seems as {:value} do
+    value
+  end
+end
+
+class CalcX
+  extend PatternMatching
+
+  func(:calcx) do
+    seems as {plus(:left, :right)} do
+      calcx(left) + calcx(right)
+    end
+    seems as {mul(:left, :right)} do
+      calcx(left) * calcx(right)
+    end
+  end
+  func(:calcx).seems as {:value} do
+    value
+  end
+end
+
+class Person
+  def initialize(name, age)
+    @name = name
+    @age = age
+  end
+  attr :name
+  attr :age
+end
+
+include PatternMatching
+def calc(code)
+  make(code) {
+    seems as {plus(:a, :b)} do calc(a) + calc(b) end
+    seems as {mul(:a, :b)} do  calc(a) * calc(b) end
+    seems something do code end
+  }
+end
+
+describe "PatternMatching from Example" do
+  it "shuold run calcm as a regular method." do
+    code = PatternMatching.build {plus(mul(100, 100), 200)}
+    ret = CalcM.new.calcm(code)
+    ret.should == 10200
+  end
+  
+  it "shuold run calcx as a regular method." do
+    code = PatternMatching.build {plus(mul(100, 100), 200)}
+    ret = CalcX.new.calcx(code)
+    ret.should == 10200
+  end
+  
+  it "should run calc as a regular function." do
+    code = PatternMatching.build {plus(mul(100, 100), 200)}
+    ret = calc(code)
+    ret.should == 10200
+  end
+  
+  it "should look Enumerable pattern." do
+    is = build { exact([1,2,3,4,5]) }
+    result = make is do
+      seems as {exact([:a,:b,:c])} do # not match
+        a.to_s + " and " + b.to_s  + " and" + c.to_s
+      end
+      seems as {exact([:a,:b, _!(:c)])} do
+        a.to_s + ", " + b.to_s  + " and " + c.to_s
+      end
+      seems something do
+        "not matched"
+      end
+    end
+    result.should == "1, 2 and 345"
+  end
+  
+  it "should look Just Enumerable pattern." do
+    is = build { exact([1,2,3,4,5]) }
+    result = make is do
+      seems as {exact([:a,:b,:c])} do # not match
+        a.to_s + " and " + b.to_s  + " and" + c.to_s
+      end
+      seems as {exact([:a,:b, :c, :d, :e])} do
+        a.to_s + ", " + b.to_s  + ", " + c.to_s + ", " + d.to_s + ", " + e.to_s
+      end
+      seems something do
+        "not matched"
+      end
+    end
+    result.should == "1, 2, 3, 4, 5"
+  end
+  
+  it "should look Hash pattern." do
+    dict = build { {:name => "Taro", :age => 5} }
+    result = make dict do
+      seems as {{:name => :name}} do
+        "He is " + name
+      end
+      seems something do
+        "no name"
+      end
+    end 
+    result.should == "He is Taro"
+  end
+  
+  it "should look non-Hash pattern." do
+    person = Person.new("Jiro", 3)
+    result = make person do
+      seems as {{:name => :name}} do
+        "He is " + name
+      end
+      seems something do
+        "no name"
+      end
+    end
+    result.should == "He is Jiro"
+  end
+  
+  it "should look nested pattern." do
+    code = build {plus(mul(100, 120, 300), plus(200, 150))}
+    result = make code do
+      seems as {plus(plus(:a, :b, _), plus(:c, _))} do # not match
+        [a, b, c]
+      end
+      seems as {plus(mul(_, :a, _), plus(:b, _))} do
+        [a, b]
+      end
+      seems something do
+        nil
+      end
+    end
+    result.should == [120, 200]
+  end
+
+  it "should look wildcard node pattern." do
+    code = build {plus(mul(100, 120, 300), plus(200, 150))}
+    result = make code do
+      seems as {_(_(_, _, :a), mul(_, :b))} do # not match
+        [a, b]
+      end
+      seems as {plus(_(_, :a, _), _(:b, _))} do
+        [a, b]
+      end
+      seems something do
+        nil
+      end
+    end
+    result.should == [120, 200]
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--colour

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'spec'

data/website/index.html

@@ -0,0 +1,231 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<head>
+  <link rel="stylesheet" href="stylesheets/screen.css" type="text/css" media="screen" />
+  <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+  <title>
+      PatternMatching module
+  </title>
+  <script src="javascripts/rounded_corners_lite.inc.js" type="text/javascript"></script>
+<style>
+
+</style>
+  <script type="text/javascript">
+    window.onload = function() {
+      settings = {
+          tl: { radius: 10 },
+          tr: { radius: 10 },
+          bl: { radius: 10 },
+          br: { radius: 10 },
+          antiAlias: true,
+          autoPad: true,
+          validTags: ["div"]
+      }
+      var versionBox = new curvyCorners(settings, document.getElementById("version"));
+      versionBox.applyCornersToAll();
+    }
+  </script>
+</head>
+<body>
+<div id="main">
+
+    <h1>PatternMatching module</h1>
+    <div id="version" class="clickable" onclick='document.location = "http://rubyforge.org/projects/patternmatching"; return false'>
+      Get Version
+      <a href="http://rubyforge.org/projects/patternmatching" class="numbers">0.1.0</a>
+    </div>
+    <h1>&#x2192; &#8216;patternmatching&#8217;</h1>
+
+
+	<h2>What</h2>
+
+
+Provides a pure ruby module that:
+	<ul>
+	<li>can build structured objects easily</li>
+		<li>can enable pattern match of objects</li>
+		<li>can define method as a partial function style</li>
+	</ul>
+
+
+	<h2>Installing</h2>
+
+
+<pre syntax="ruby">sudo gem install patternmatching</pre>
+
+	<h2>The basics</h2>
+
+
+	<p>This module provides methods for tree pattern matching features.</p>
+
+
+	<ul>
+	<li>For detail, see Wikipedia: <a href="http://en.wikipedia.org/wiki/Pattern_matching">Pattern matching</a></li>
+		<li>Syntax based on meta-programming, like &#8220;rspec&#8221;, and so on.</li>
+	</ul>
+
+
+	<p>Note: Default equivalence used in structured pattern matching is 
+based on &#8220;pattern === data&#8221;, so &#8220;foo(Numeric)&#8221; matches with &#8220;foo(100)&#8221;</p>
+
+
+	<p>Note: Not thread safe now.</p>
+
+
+	<h2>Demonstration of usage</h2>
+
+
+<h3>Pattern matching expression</h3>
+<pre>
+require "patternmatching" 
+
+# For DSL style code, include PatternMatching
+include PatternMatching
+
+# match example
+def calc(code)
+  make(code) {
+    seems as {plus(:x, :y)} do calc(x) + calc(y) end
+    seems as {mul(:x, :y)} do  calc(x) * calc(y) end
+    seems something do code end
+  }
+end
+
+code = build {plus(mul(100, 100), 200)}
+p calc(code) #=&gt; 10200
+</pre>
+
+<h3>Partial style method</h3>
+<pre>
+require "patternmatching" 
+
+# Structured data builder
+code = PatternMatching.build {plus(mul(100, 100), 200)}
+
+# Partial style method example
+class Calc
+  # At first, extends with the module
+  extend PatternMatching
+
+  # def calcm(o), as 3 partial styles
+  func(:calcm).seems as {plus(:x, :y)} do
+    calcm(x) + calcm(y)
+  end
+  func(:calcm).seems as {mul(:x, :y)} do
+    calcm(x) * calcm(y)
+  end
+  func(:calcm).seems as {:value} do
+    value
+  end
+end
+
+# use as standard method
+p Calc.new.calcm(code) #=&gt; 10200
+</pre>
+
+<h3>Array/Enumerable pattern</h3>
+<pre>
+require "patternmatching" 
+
+include PatternMatching
+
+# Example for matching Enumerable
+is = build { exact([1,2,3,4,5]) }
+make is do
+   # _!  matches rest of lists
+  seems as {exact([:a,:b, _!(:c)])} do
+    puts a.to_s + ", " + b.to_s  + " and " + c.to_s
+  end
+  seems something do
+    puts "not matched" 
+  end
+end # =&gt; "1, 2, and 345" 
+</pre>
+
+<h3>Hash pattern</h3>
+<pre>
+require "patternmatching" 
+
+include PatternMatching
+
+# Example for matching Hash
+dict = build { {:name =&gt; "Taro", :age =&gt; 5} }
+make dict do
+  seems as {{:name =&gt; :name}} do
+    puts "He is " + name
+  end
+  seems something do
+    puts "no name" 
+  end
+end # =&gt; "He is Taro" 
+</pre>
+
+<h3>Non-Hash/Object pattern</h3>
+<pre>
+require "patternmatching" 
+
+include PatternMatching
+
+class Person
+  def initialize(name, age)
+    @name = name
+    @age = age
+  end
+  attr :name
+  attr :age
+end
+
+# Example for matching Object except Hash
+person = Person.new("Jiro", 3)
+make person do
+  seems as {{:name =&gt; :name}} do
+    puts "He is " + name
+  end
+  seems something do
+    puts "no name" 
+  end
+end # =&gt; "He is Jiro" 
+</pre>
+
+	<h2>Forum</h2>
+
+
+	<h2>How to submit patches</h2>
+
+
+	<p>Read the <a href="http://drnicwilliams.com/2007/06/01/8-steps-for-fixing-other-peoples-code/">8 steps for fixing other people&#8217;s code</a> and for section <a href="http://drnicwilliams.com/2007/06/01/8-steps-for-fixing-other-peoples-code/#8b-google-groups">8b: Submit patch to Google Groups</a>, use the Google Group above.</p>
+
+
+	<p>The trunk repository is <code>svn://rubyforge.org/var/svn/patternmatching/trunk</code> for anonymous access.</p>
+
+
+	<h2>License</h2>
+
+
+	<p>This code is free to use under the terms of the <span class="caps">MIT</span> license.</p>
+
+
+	<h2>Link</h2>
+
+
+	<ul>
+	<li><a href="http://patternmatching.rubyforge.org/">Web Site</a></li>
+		<li><a href="http://rubyforge.org/projects/patternmatching/">Project Page</a></li>
+	</ul>
+
+
+	<h2>Contact</h2>
+
+
+	<p>Comments are welcome. Send an email to <a href="mailto:bellbind@gmail.com"><span class="caps">ICHIYAMA</span> Ryoichi</a>. <a href="http://d.hatena.ne.jp/bellbind">My blog</a> (written in Japanese) could be help you.</p>
+    <p class="coda">
+      <a href="mailto:drnicwilliams@gmail.com">Dr Nic</a>, 4th June 2007<br>
+      Theme extended from <a href="http://rb2js.rubyforge.org/">Paul Battley</a>
+    </p>
+</div>
+
+<!-- insert site tracking codes here, like Google Urchin -->
+
+</body>
+</html>

data/website/index.txt

@@ -0,0 +1,163 @@
+h1. PatternMatching module
+
+h1. → 'patternmatching'
+
+h2. What
+
+Provides a pure ruby module that:
+* can build structured objects easily
+* can enable pattern match of objects
+* can define method as a partial function style
+
+h2. Installing
+
+<pre syntax="ruby">sudo gem install patternmatching</pre>
+
+h2. The basics
+
+This module provides methods for tree pattern matching features.
+
+* For detail, see Wikipedia: "Pattern matching":http://en.wikipedia.org/wiki/Pattern_matching
+* Syntax based on meta-programming, like "rspec", and so on.
+
+Note: Default equivalence used in structured pattern matching is 
+based on "pattern === data", so "foo(Numeric)" matches with "foo(100)"
+
+Note: Not thread safe now.
+
+h2. Demonstration of usage
+
+<h3>Pattern matching expression</h3>
+<pre>
+require "patternmatching"
+
+# For DSL style code, include PatternMatching
+include PatternMatching
+
+# match example
+def calc(code)
+  make(code) {
+    seems as {plus(:x, :y)} do calc(x) + calc(y) end
+    seems as {mul(:x, :y)} do  calc(x) * calc(y) end
+    seems something do code end
+  }
+end
+
+code = build {plus(mul(100, 100), 200)}
+p calc(code) #=> 10200
+</pre>
+
+<h3>Partial style method</h3>
+<pre>
+require "patternmatching"
+
+# Structured data builder
+code = PatternMatching.build {plus(mul(100, 100), 200)}
+
+# Partial style method example
+class Calc
+  # At first, extends with the module
+  extend PatternMatching
+
+  # def calcm(o), as 3 partial styles
+  func(:calcm).seems as {plus(:x, :y)} do
+    calcm(x) + calcm(y)
+  end
+  func(:calcm).seems as {mul(:x, :y)} do
+    calcm(x) * calcm(y)
+  end
+  func(:calcm).seems as {:value} do
+    value
+  end
+end
+
+# use as standard method
+p Calc.new.calcm(code) #=> 10200
+</pre>
+
+<h3>Array/Enumerable pattern</h3>
+<pre>
+require "patternmatching"
+
+include PatternMatching
+
+# Example for matching Enumerable
+is = build { exact([1,2,3,4,5]) }
+make is do
+   # _!  matches rest of lists
+  seems as {exact([:a,:b, _!(:c)])} do
+    puts a.to_s + ", " + b.to_s  + " and " + c.to_s
+  end
+  seems something do
+    puts "not matched"
+  end
+end # => "1, 2, and 345"
+</pre>
+
+<h3>Hash pattern</h3>
+<pre>
+require "patternmatching"
+
+include PatternMatching
+
+# Example for matching Hash
+dict = build { {:name => "Taro", :age => 5} }
+make dict do
+  seems as {{:name => :name}} do
+    puts "He is " + name
+  end
+  seems something do
+    puts "no name"
+  end
+end # => "He is Taro"
+</pre>
+
+<h3>Non-Hash/Object pattern</h3>
+<pre>
+require "patternmatching"
+
+include PatternMatching
+
+class Person
+  def initialize(name, age)
+    @name = name
+    @age = age
+  end
+  attr :name
+  attr :age
+end
+
+# Example for matching Object except Hash
+person = Person.new("Jiro", 3)
+make person do
+  seems as {{:name => :name}} do
+    puts "He is " + name
+  end
+  seems something do
+    puts "no name"
+  end
+end # => "He is Jiro"
+</pre>
+
+h2. Forum
+
+
+h2. How to submit patches
+
+Read the "8 steps for fixing other people's code":http://drnicwilliams.com/2007/06/01/8-steps-for-fixing-other-peoples-code/ and for section "8b: Submit patch to Google Groups":http://drnicwilliams.com/2007/06/01/8-steps-for-fixing-other-peoples-code/#8b-google-groups, use the Google Group above.
+
+The trunk repository is <code>svn://rubyforge.org/var/svn/patternmatching/trunk</code> for anonymous access.
+
+h2. License
+
+This code is free to use under the terms of the MIT license. 
+
+h2. Link
+
+* "Web Site":http://patternmatching.rubyforge.org/
+* "Project Page":http://rubyforge.org/projects/patternmatching/
+
+h2. Contact
+
+Comments are welcome. Send an email to "ICHIYAMA Ryoichi":mailto:bellbind@gmail.com. "My blog":http://d.hatena.ne.jp/bellbind (written in Japanese) could be help you.
+