egison 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e5afc8d46f5b374e4e9aa32fb7b8328b9c687fd3
+  data.tar.gz: 37e963f48ccea8f645d18b16b29cb2a96005c436
+SHA512:
+  metadata.gz: a999b3b1b4687d3fbc6b7ec65b5883d2992ba96478a8206ee6d7bf240475bb4113730ac2062e217c9877077f6ab2294268f98e7bcf8ab40182580d3ac459561f
+  data.tar.gz: 8cd1ee8f05b986418f223980e5c31491562caf7ceb4c020dd211c7d3f2ccfa4924ac6021da90ea6f029476c9dec57d1d89c7477432cfb18e52bb9c8ec88158e3

data/.gitignore

@@ -0,0 +1,7 @@
+.bundle
+Gemfile.lock
+coverage
+pkg/*
+vendor/*
+*.gem
+pattern-match

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,46 @@
+Copyright (C) 2012-2014 Kazuki Tsujimoto, All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.
+
+Copyright (C) 2014 Satoshi Egi, All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.
+

data/Makefile

@@ -0,0 +1,3 @@
+all:
+	gem build egison.gemspec
+	gem install egison-*.gem

data/README.md

@@ -0,0 +1,206 @@
+# The Gem for Egison Pattern Matching 
+
+This Gem provides a way to access Egison pattern-matching from Ruby.
+Egison is the world's first programming language that can represent non-linear pattern-match against unfree data types.
+We can directly express pattern-matching against lists, multisets, and sets using this gem.
+
+## Installation
+
+```
+$ gem install egison
+```
+
+or
+
+```
+$ git clone git://github.com/egison/egison-ruby.git
+$ cd egison-ruby
+$ gem build egison.gemspec
+$ gem install egison-*.gem
+```
+
+or
+
+```
+$ gem install bundler (if you need)
+$ echo "gem 'egison', :git => 'git://github.com/egison/egison-ruby.git'" > Gemfile
+$ bundle install --path vendor/bundle
+```
+
+## Basic Usage
+
+egison library provides `Kernel#match` and  `Kernel#match_all`.
+
+```
+require 'egison'
+
+match_all(object) do
+  with(pattern) do
+    ...
+  end
+end
+
+match(object) do
+  with(pattern) do
+    ...
+  end
+  with(pattern) do
+    ...
+  end
+  ...
+end
+```
+
+If a pattern matches, a block passed to `with` is called and returns its result.
+
+In our pattern-matching system, there are cases that pattern-matching has multiple results.
+`match_all` calls the block passed to `with` for each pattern-matching result and returns all results as an array.
+`match_all` takes one single match-clause.
+
+On the other hand, `match` takes multiple match-clauses.
+It pattern-matches from the first match-clause.
+If a pattern matches, it calls the block passed to the matched match-clause and returns a result for the first pattern-matching result.
+
+## Patterns
+
+### Element patterns and subcollection patterns
+
+An <i>element pattern</i> matches the element of the target array.
+
+A <i>subcollection pattern</i> matches the subcollection of the target array.
+A subcollection pattern has `*` ahead.
+
+A literal that contain `_` ahead is a <i>pattern-variable</i>.
+We can refer the result of pattern-matching through them.
+
+```
+match_all([1, 2, 3]) do
+  with(List.(*_hs, _x, *_ts)) do
+    [hs, x, ts]
+  end
+end  #=> [[[],1,[2,3]],[[1],2,[3]],[[1,2],3,[]]
+```
+
+### Three matchers: List, Multiset, Set
+
+We can write pattern-matching against lists, multisets, and sets.
+When we regard an array as a multiset, the order of elements is ignored.
+When we regard an array as a set, the duplicates and order of elements are ignored.
+
+```
+match_all([1, 2, 3]) do
+  with(List.(_a, _b, *_)) do
+    [a, b]
+  end
+end  #=> [[1, 2]]
+
+match_all([1, 2, 3]) do
+  with(Multiset.(_a, _b, *_)) do
+    [a, b]
+  end
+end  #=> [[1, 2], [1, 3], [2, 1], [2, 3], [3, 1], [3, 2]]
+
+match_all([1, 2, 3]) do
+  with(Set.(_a, _b, *_)) do
+    [a, b]
+  end
+end  #=> [[1, 1],[1, 2],[1, 3],[2, 1],[2, 2],[2, 3],[3, 1],[3, 2],[3, 3]]
+```
+
+### Non-linear patterns
+
+Non-linear pattern is the most important feature of our pattern-matching system.
+Our pattern-matching system allows users multiple occurrences of same variables in a pattern.
+A Pattern whose form is `__("...")` is a value pattern.
+In the place of `...`, we can write any ruby expression we like.
+It matches the target when the target is equal with the value that `...` evaluated to.
+
+```
+match_all([5, 3, 4, 1, 2]) do
+  with(Multiset.(_a, __("a + 1"), __("a + 2"), *_)) do
+    a
+  end
+end  #=> [1,2,3]
+```
+
+When, the expression in the place of `...` is a single variable, we can omit `("` and `")` as follow.
+
+```
+match_all([1, 2, 3, 2, 5]) do
+  with(Multiset.(_a, __a, *_)) do
+    a
+  end
+end  #=> [2,2]
+```
+
+## Demonstration - Poker Hands
+
+We can write patterns for all poker-hands in one single pattern.
+It is as follow.
+Isn't it exciting?
+
+```
+require 'egison'
+
+def poker_hands cs
+  match(cs) do
+    with(Multiset.(_[_s, _n], _[__s, __("n+1")], _[__s, __("n+2")], _[__s, __("n+3")], _[__s, __("n+4")])) do
+      "Straight flush"
+    end
+    with(Multiset.(_[_, _n], _[_, __n], _[_, __n], _[_, __n], _)) do
+      "Four of kind"
+    end
+    with(Multiset.(_[_, _m], _[_, __m], _[_, __m], _[_, _n], _[_, __n])) do
+      "Full house"
+    end
+    with(Multiset.(_[_s, _], _[__s, _], _[__s, _], _[__s, _], _[__s, _])) do
+      "Flush"
+    end
+    with(Multiset.(_[_, _n], _[_, __("n+1")], _[_, __("n+2")], _[_, __("n+3")], _[_, __("n+4")])) do
+      "Straight"
+    end
+    with(Multiset.(_[_, _n], _[_, __n], _[_, __n], _, _)) do
+      "Three of kind"
+    end
+    with(Multiset.(_[_, _m], _[_, __m], _[_, _n], _[_, __n], _)) do
+      "Two pairs"
+    end
+    with(Multiset.(_[_, _n], _[_, __n], _, _, _)) do
+      "One pair"
+    end
+    with(Multiset.(_, _, _, _, _)) do
+      "Nothing"
+    end
+  end
+end
+
+p(poker_hands([["diamond", 1], ["diamond", 3], ["diamond", 5], ["diamond", 4], ["diamond", 2]])) #=> "Straight flush"
+p(poker_hands([["diamond", 1], ["club", 2], ["club", 1], ["heart", 1], ["diamond", 2]])) #=> "Full house"
+p(poker_hands([["diamond", 4], ["club", 2], ["club", 5], ["heart", 1], ["diamond", 3]])) #=> "Straight"
+p(poker_hands([["diamond", 4], ["club", 10], ["club", 5], ["heart", 1], ["diamond", 3]])) #=> "Nothing"
+```
+
+## About Egison
+
+If you get to love the above pattern-matching, please try [the Egison programming language](http://www.egison.org), too.
+Egison is the pattern-matching oriented pure functional programming language.
+Actually, the original pattern-matching system of Egison is more powerful.
+For example, we can do following things in the original Egison.
+
+- We can pattern-match against infinite lists
+- We can define new pattern-constructors.
+- We can modularize useful patterns.
+
+There is a new programming world!
+
+## Contact
+
+If you get interested in this Gem, please mail to [Satoshi Egi](http://www.egison.org/~egi/) or tweet to [@Egison_Lang](https://twitter.com/Egison_Lang).
+
+## LICENSE
+
+The license of this library code is BSD.
+I learned how to extend Ruby and how to write a gem from the code of [the pattern-match gem](https://github.com/k-tsj/pattern-match) by Kazuki Tsujimoto.
+I designed syntax of pattern-matching to go with that gem.
+This library contains the copy from that gem.
+The full license text is [here](https://github.com/egisatoshi/egison-ruby/blob/master/LICENSE).

data/Rakefile

@@ -0,0 +1,10 @@
+ENV['BUNDLE_GEMFILE'] = File.expand_path('../Gemfile', __FILE__)
+require 'bundler/setup'
+require "bundler/gem_tasks"
+
+require "rake/testtask"
+task :default => :test
+Rake::TestTask.new do |t|
+  t.libs << "lib"
+  t.test_files = FileList["test/test_*.rb"]
+end

data/egison.gemspec

@@ -0,0 +1,21 @@
+$:.push File.expand_path('../lib', __FILE__)
+require 'egison/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'egison'
+  s.version     = Egison::VERSION
+  s.authors     = ['Satoshi Egi']
+  s.email       = ['egi@egison.org']
+  s.homepage    = 'https://github.com/egisatoshi/egison-ruby'
+  s.summary     = %q{The Egison pattern matching library}
+  s.description = %w{
+    The library to access Egison pattern-matching from Ruby.
+  }.join(' ')
+
+  s.files            = `git ls-files`.split("\n")
+  s.test_files       = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables      = `git ls-files -- bin/*`.split("\n").map{|f| File.basename(f) }
+  s.require_paths    = ['lib']
+  s.add_development_dependency 'rake'
+  s.rdoc_options     = ['--main', 'README.rdoc']
+end

data/lib/egison.rb

@@ -0,0 +1,3 @@
+require 'egison/version'
+require 'egison/core'
+require 'egison/matcher'

data/lib/egison/core.rb

@@ -0,0 +1,355 @@
+require 'egison/version'
+require 'continuation'
+
+module PatternMatch
+  module Matchable
+    def call(*subpatterns)
+      pattern_matcher(*subpatterns)
+    end
+  end
+
+  class ::Object
+    private
+
+    def pattern_matcher(*subpatterns)
+      PatternWithMatcher.new(self, *subpatterns)
+    end
+  end
+
+  class MatchingStateStack
+    attr_accessor :states
+    attr_accessor :results
+    
+    def initialize(pat, tgt)
+      @states = [MatchingState.new(pat, tgt)]
+      @results = []
+    end
+
+    def match
+      while !@states.empty? do
+        process
+      end
+      @results
+    end
+    
+    def process
+      state = @states.shift
+      rets = state.process
+      new_states = []
+      rets.each { |ret|
+        if ret.atoms.empty? then
+          @results = @results + [ret.bindings]
+        else
+          new_states = new_states + [ret]
+        end
+      }
+      @states = new_states + @states
+    end
+  end
+
+  class MatchingState
+    attr_accessor :atoms, :bindings
+
+    def initialize(pat, tgt)
+      @atoms = [[pat, tgt]]
+      @bindings = []
+    end
+
+    def process
+      atom = @atoms.shift
+      rets = atom.first.match(atom.last, @bindings)
+      rets.map { |new_atoms, new_bindings|
+        new_state = self.clone
+        new_state.atoms = new_atoms + new_state.atoms
+        new_state.bindings = new_state.bindings + new_bindings
+        new_state
+      }
+    end
+  end
+
+  class Pattern
+    attr_accessor :quantified
+    
+    def initialize
+    end
+
+    def match(tgt, bindings)
+    end
+
+    def to_a
+      [PatternCollection.new(self)]
+    end
+  end
+
+  class PatternElement < Pattern
+    def initialize
+      super()
+      @quantified = false
+    end
+  end
+
+  class PatternWithMatcher < PatternElement
+    attr_reader :matcher, :subpatterns
+
+    def initialize(matcher, *subpatterns)
+      super()
+      @matcher = matcher
+      @subpatterns = subpatterns
+    end
+
+    def match(tgt, bindings)
+      if subpatterns.empty? then
+        if tgt.empty? then
+          return [[[], []]]
+        else
+          return []
+        end
+      else
+        subpatterns = @subpatterns.clone
+        px = subpatterns.shift
+        if px.quantified then
+          if subpatterns.empty? then
+            [[[[px.pattern, tgt]], []]]
+          else
+            unjoineds = @matcher.unjoin(tgt)
+            unjoineds.map { |xs, ys| [[[px.pattern, xs], [PatternWithMatcher.new(@matcher, *subpatterns), ys]], []] }
+          end
+        else
+          if tgt.empty? then
+            []
+          else
+            unconseds = @matcher.uncons(tgt)
+            unconseds.map { |x, xs| [[[px, x], [PatternWithMatcher.new(@matcher, *subpatterns), xs]], []] }
+          end
+        end
+      end
+    end
+  end
+
+  class Wildcard < PatternElement
+    def initialize()
+      super()
+    end
+
+    def match(tgt, bindings)
+      [[[], []]]
+    end
+  end
+
+  class PatternVariable < PatternElement
+    attr_reader :name
+
+    def initialize(name)
+      super()
+      @name = name
+    end
+
+    def match(tgt, bindings)
+      [[[], [[name, tgt]]]]
+    end
+  end
+
+  class ValuePattern < PatternElement
+    def initialize(ctx, expr)
+      super()
+      @ctx = ctx
+      @expr = expr
+    end
+
+    def match(tgt, bindings)
+      val = with_bindings(@ctx, bindings, {:expr => @expr}) { eval expr }
+      if val.__send__(:===, tgt) then
+        [[[], []]]
+      else
+        []
+      end
+    end
+
+    class BindingModule < ::Module
+    end
+
+    def with_bindings(obj, bindings, ext_bindings, &block)
+      binding_module(obj).module_eval do
+        begin
+          bindings.each do |name, val|
+            define_method(name) { val }
+            private name
+          end
+          ext_bindings.each do |name, val|
+            define_method(name) { val }
+            private name
+          end
+          obj.instance_eval(&block)
+        ensure
+          bindings.each do |name, _|
+            remove_method(name)
+          end
+          ext_bindings.each do |name, _|
+            remove_method(name)
+          end
+        end
+      end
+    end
+
+    def binding_module(obj)
+      m = obj.singleton_class.ancestors.find {|i| i.kind_of?(BindingModule) }
+      unless m
+        m = BindingModule.new
+        obj.singleton_class.class_eval do
+          if respond_to?(:prepend, true)
+            prepend m
+          else
+            include m
+          end
+        end
+      end
+      m
+    end
+  end
+
+  class PatternCollection < Pattern
+    attr_accessor :pattern
+    
+    def initialize(pat)
+      super()
+      @quantified = true
+      @pattern = pat
+    end
+  end
+
+  class Env < BasicObject
+    def initialize(ctx, tgt)
+      @ctx = ctx
+      @tgt = tgt
+    end
+
+    private
+
+    def with(pat, &block)
+      ctx = @ctx
+      tgt = @tgt
+      mstack = MatchingStateStack.new(pat,tgt)
+      mstack.match
+      mstack.results.map { |bindings|
+        ret = with_bindings(ctx, bindings, &block)
+      }
+    rescue PatternNotMatch
+    end
+
+    def method_missing(name, *args)
+      ::Kernel.raise ::ArgumentError, "wrong number of arguments (#{args.length} for 0)" unless args.empty?
+      if /^__/.match(name.to_s)
+        ValuePattern.new(@ctx, name.to_s.gsub(/^__/, "").gsub("_plus_", "+").gsub("_minus_", "-"))
+      elsif /^_/.match(name.to_s)
+        PatternVariable.new(name.to_s.gsub(/^_/, "").to_sym)
+      else
+        undefined
+      end
+    end
+
+    def _(*vals)
+      case vals.length
+      when 0
+        uscore = Wildcard.new()
+        class << uscore
+          def [](*args)
+            List.call(*args)
+          end
+        end
+        uscore
+      when 1
+        ValuePattern.new(@ctx, vals[0])
+      else
+        undefined
+      end
+    end
+
+    def __(val)
+      ValuePattern.new(@ctx, val)
+    end
+
+    class BindingModule < ::Module
+    end
+
+    def with_bindings(obj, bindings, &block)
+      binding_module(obj).module_eval do
+        begin
+          bindings.each do |name, val|
+            define_method(name) { val }
+            private name
+          end
+          obj.instance_eval(&block)
+        ensure
+          bindings.each do |name, _|
+            remove_method(name)
+          end
+        end
+      end
+    end
+
+    def binding_module(obj)
+      m = obj.singleton_class.ancestors.find {|i| i.kind_of?(BindingModule) }
+      unless m
+        m = BindingModule.new
+        obj.singleton_class.class_eval do
+          if respond_to?(:prepend, true)
+            prepend m
+          else
+            include m
+          end
+        end
+      end
+      m
+    end
+  end
+
+  class Env2 < Env
+    def with(pat, &block)
+      ctx = @ctx
+      tgt = @tgt
+      mstack = MatchingStateStack.new(pat,tgt)
+      mstack.match
+      if mstack.results.empty? then
+        nil
+      else
+        ret = with_bindings(ctx, mstack.results.first, &block)
+        ::Kernel.throw(:exit_match, ret)
+      end
+    rescue PatternNotMatch
+    end
+  end
+    
+  class PatternNotMatch < Exception; end
+  class PatternMatchError < StandardError; end
+  class NoMatchingPatternError < PatternMatchError; end
+  class MalformedPatternError < PatternMatchError; end
+
+  # Make Pattern and its subclasses/Env private.
+  if respond_to?(:private_constant)
+    constants.each do |c|
+      klass = const_get(c)
+      next unless klass.kind_of?(Class)
+      if klass <= Pattern
+        private_constant c
+      end
+    end
+    private_constant :Env, :Env2
+  end
+end
+
+module Kernel
+  private
+
+  def match_all(tgt, &block)
+    env = PatternMatch.const_get(:Env).new(self, tgt)
+    env.instance_eval(&block)
+  end
+
+  def match(tgt, &block)
+    env = PatternMatch.const_get(:Env2).new(self, tgt)
+    catch(:exit_match) do
+      env.instance_eval(&block)
+    end
+  end
+
+end

data/lib/egison/matcher.rb

@@ -0,0 +1,104 @@
+require 'egison/core'
+
+class Class
+  include PatternMatch::Matchable
+
+  def uncons(val)
+    raise NotImplementedError, "need to define `#{__method__}'"
+  end
+
+  private
+
+  def accept_array_only(val)
+    raise PatternMatch::PatternNotMatch unless val.kind_of?(Array)
+  end
+end
+
+class List
+end
+
+class << List
+  def uncons(val)
+    accept_array_only(val)
+    val2 = val.clone
+    x = val2.shift
+    [[x, val2]]
+  end
+
+  def unjoin(val)
+    accept_array_only(val)
+    val2 = val.clone
+    xs = []
+    ys = val2.clone
+    rets = [[xs, ys]]
+    while !val2.empty? do
+      x = val2.shift
+      ys = val2.clone
+      xs = xs + [x]
+      rets = rets + [[xs, ys]]
+    end
+    rets
+  end
+end
+
+class Multiset
+end
+
+class << Multiset
+  def uncons(val)
+    accept_array_only(val)
+    rets = val.map {|x|
+      val2 = val.clone
+      val2.delete_at(val2.find_index(x))
+      [x, val2]
+    }
+    rets
+  end
+  
+  def unjoin(val)
+    accept_array_only(val)
+    val2 = val.clone
+    xs = []
+    ys = val2.clone
+    rets = [[xs, ys]]
+    if !val2.empty? then
+      x = val2.shift
+      ys = val2.clone
+      rets2 = unjoin(ys)
+      rets = (rets2.map {|xs2, ys2| [xs2, [x]+ys2]}) + (rets2.map {|xs2, ys2| [[x]+xs2, ys2]})
+      rets
+    else
+      rets
+    end
+  end
+end
+
+class Set
+end
+
+class << Set
+  def uncons(val)
+    accept_array_only(val)
+    rets = val.map {|x|
+      val2 = val.clone
+      [x, val2]
+    }
+    rets
+  end
+  def unjoin(val)
+    accept_array_only(val)
+    val2 = val.clone
+    xs = []
+    ys = val2.clone
+    rets = [[xs, ys]]
+    if !val2.empty? then
+      x = val2.shift
+      ys2 = val2.clone
+      rets2 = unjoin(ys2)
+      rets = (rets2.map {|xs2, _| [xs2, ys]}) + (rets2.map {|xs2, ys2| [[x]+xs2, ys]})
+      rets
+    else
+      rets
+    end
+  end
+end

data/lib/egison/version.rb

@@ -0,0 +1,3 @@
+module Egison
+  VERSION = "0.0.1"
+end

data/sample/combination.rb

@@ -0,0 +1,5 @@
+require 'egison'
+
+p(match_all([1,2,3,4,5]) do with(List.(*_, _x, *_, _y, *_)) { [x, y] } end)
+
+p(match_all([1,2,3,4,5]) do with(List.(*_, _x, *_, _y, *_, _z, *_)) { [x, y, z] } end)

data/sample/poker_hands.rb

@@ -0,0 +1,38 @@
+require 'egison'
+
+def poker_hands cs
+  match(cs) do
+    with(Multiset.(_[_s, _n], _[__s, __("n+1")], _[__s, __("n+2")], _[__s, __("n+3")], _[__s, __("n+4")])) do
+      "Straight flush"
+    end
+    with(Multiset.(_[_, _n], _[_, __n], _[_, __n], _[_, __n], _)) do
+      "Four of kind"
+    end
+    with(Multiset.(_[_, _m], _[_, __m], _[_, __m], _[_, _n], _[_, __n])) do
+      "Full house"
+    end
+    with(Multiset.(_[_s, _], _[__s, _], _[__s, _], _[__s, _], _[__s, _])) do
+      "Flush"
+    end
+    with(Multiset.(_[_, _n], _[_, __("n+1")], _[_, __("n+2")], _[_, __("n+3")], _[_, __("n+4")])) do
+      "Straight"
+    end
+    with(Multiset.(_[_, _n], _[_, __n], _[_, __n], _, _)) do
+      "Three of kind"
+    end
+    with(Multiset.(_[_, _m], _[_, __m], _[_, _n], _[_, __n], _)) do
+      "Two pairs"
+    end
+    with(Multiset.(_[_, _n], _[_, __n], _, _, _)) do
+      "One pair"
+    end
+    with(Multiset.(_, _, _, _, _)) do
+      "Nothing"
+    end
+  end
+end
+
+p(poker_hands([["diamond", 1], ["diamond", 3], ["diamond", 5], ["diamond", 4], ["diamond", 2]])) #=> "Straight flush"
+p(poker_hands([["diamond", 1], ["club", 2], ["club", 1], ["heart", 1], ["diamond", 2]])) #=> "Full house"
+p(poker_hands([["diamond", 4], ["club", 2], ["club", 5], ["heart", 1], ["diamond", 3]])) #=> "Straight"
+p(poker_hands([["diamond", 4], ["club", 10], ["club", 5], ["heart", 1], ["diamond", 3]])) #=> "Nothing"

data/sample/set.rb

@@ -0,0 +1,3 @@
+require 'egison'
+
+p(match_all([1,2,3,4,5]) do with(Set.(_x,_y, *_)) { [x, y] } end)

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: egison
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Satoshi Egi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: The library to access Egison pattern-matching from Ruby.
+email:
+- egi@egison.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- Makefile
+- README.md
+- Rakefile
+- egison.gemspec
+- lib/egison.rb
+- lib/egison/core.rb
+- lib/egison/matcher.rb
+- lib/egison/version.rb
+- sample/combination.rb
+- sample/poker_hands.rb
+- sample/set.rb
+homepage: https://github.com/egisatoshi/egison-ruby
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--main"
+- README.rdoc
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: The Egison pattern matching library
+test_files: []