egison 0.6.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4220d772a26fbea06a65175e59f77466ef5696b2
-  data.tar.gz: 4c6a23d914dcd4a1c3c4c74f2b36258fce0c24ec
+  metadata.gz: 83b4172902ecda7ac29219caf4ab1fa2ecdd25df
+  data.tar.gz: 715dd8a2affee299c7d139f07f11e57357bb0082
 SHA512:
-  metadata.gz: 42cb47d6867e69defec1a397afbb0f5df6bfe75ed4182ca66496a1248a2c863bd486f9e13b4a5b8834ebcf85af7b29ba06cb9e08c4e21bfd2ed8219752fa05db
-  data.tar.gz: 5db2fa350525a714a6e514b3195a06f4adc0791cf664b92727e258956b5cf19fb24f2c4f2edf2703796693397cef633b07b5f7b8ca6811b7691e4d2c6a30d013
+  metadata.gz: f7750ee40919a1d41a29fcd7e9520b2d98501e1c87d3df960a5a34c770faff22e91961ba46bdaf323e6a9248b080dcdf083ee04b0938aacc3f72d6a121597591
+  data.tar.gz: 1475df510e8428b4d24ef9225a53e19efe4dd5747f556a7d0d9ae15a7ba61ef030e2ad3b89d4429eb6b67ff6b32ce1948c8f5c10795f21d131f281ab46b472ee

data/README.md

@@ -5,13 +5,13 @@ We can directly express pattern-matching against lists, multisets, and sets usin
 
 ## Installation
 
-```
+```shell
 $ gem install egison
 ```
 
 or
 
-```
+```shell
 $ git clone https://github.com/egison/egison-ruby.git
 $ cd egison-ruby
 $ make
@@ -19,7 +19,7 @@ $ make
 
 or
 
-```
+```shell
 $ gem install bundler (if you need)
 $ echo "gem 'egison', :git => 'https://github.com/egison/egison-ruby.git'" > Gemfile
 $ bundle install
@@ -29,7 +29,7 @@ $ bundle install
 
 The library provides `Egison#match_all` and  `Egison#match`.
 
-```
+```Ruby
 require 'egison'
 
 include Egison
@@ -63,7 +63,7 @@ If a pattern matches, it calls the block passed to the matched match-clause and
 
 ## Patterns
 
-### Element patterns and subcollection patterns
+### Element Patterns and Subcollection Patterns
 
 An <i>element pattern</i> matches the element of the target array.
 
@@ -73,7 +73,7 @@ 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.
 
-```
+```Ruby
 match_all([1, 2, 3]) do
   with(List.(*_hs, _x, *_ts)) do
     [hs, x, ts]
@@ -81,7 +81,7 @@ match_all([1, 2, 3]) do
 end  #=> [[[],1,[2,3]],[[1],2,[3]],[[1,2],3,[]]
 ```
 
-### Three matchers: List, Multiset, Set
+### 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.
@@ -92,7 +92,7 @@ It matches with any object.
 Note that `__` and `___` are also interpreted as a wildcard.
 This is because `_` and `__` are system variables and sometimes have its own meaning.
 
-```
+```Ruby
 match_all([1, 2, 3]) do
   with(List.(_a, _b, *_)) do
     [a, b]
@@ -114,7 +114,7 @@ end  #=> [[1, 1],[1, 2],[1, 3],[2, 1],[2, 2],[2, 3],[3, 1],[3, 2],[3, 3]]
 
 Note that `_[]` is provided as syntactic sugar for `List.()`.
 
-```
+```Ruby
 match_all([1, 2, 3]) do
   with(_[_a, _b, *_]) do
     [a, b]
@@ -122,7 +122,7 @@ match_all([1, 2, 3]) do
 end  #=> [[1, 2]]
 ```
 
-### Non-linear patterns
+### 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.
@@ -130,7 +130,7 @@ 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.
 
-```
+```Ruby
 match_all([5, 3, 4, 1, 2]) do
   with(Multiset.(_a, __("a + 1"), __("a + 2"), *_)) do
     a
@@ -140,7 +140,7 @@ end  #=> [1,2,3]
 
 When, the expression in the place of `...` is a single variable, we can omit `("` and `")` as follow.
 
-```
+```Ruby
 match_all([1, 2, 3, 2, 5]) do
   with(Multiset.(_a, __a, *_)) do
     a
@@ -152,7 +152,7 @@ end  #=> [2,2]
 
 We can do pattern-matching against streams with the `match_stream` expression.
 
-```
+```Ruby
 def nats
   (1..Float::INFINITY)
 end
@@ -170,7 +170,7 @@ match_stream(nats){ with(Set.(_m, _n, *_)) { [m, n] } }.take(10)
 
 We can enumerates all combinations of the elements of a collection with pattern-matching.
 
-```
+```Ruby
 require 'egison'
 
 include Egison
@@ -189,7 +189,7 @@ We can write patterns for all poker-hands in one single pattern.
 It is as follow.
 Isn't it exciting?
 
-```
+```Ruby
 require 'egison'
 
 include Egison
@@ -232,20 +232,20 @@ p(poker_hands([["diamond", 4], ["club", 2], ["club", 5], ["heart", 1], ["diamond
 p(poker_hands([["diamond", 4], ["club", 10], ["club", 5], ["heart", 1], ["diamond", 3]])) #=> "Nothing"
 ```
 
-### Twin Primes
+### Twin Primes and Prime Triplets
 
 The following code enumerates all twin primes with pattern-matching!
 I believe it is also a really exciting demonstration.
 
-```
+```Ruby
 require 'egison'
 require 'prime'
 
 include Egison
 
 twin_primes = match_stream(Prime) {
-  with(List.(*_, _x, __("x + 2"), *_)) {
-    [x, x + 2]
+  with(List.(*_, _p, __("p + 2"), *_)) {
+    [p, p + 2]
   }
 }
 
@@ -253,22 +253,35 @@ p twin_primes.take(10)
 #=>[[3, 5], [5, 7], [11, 13], [17, 19], [29, 31], [41, 43], [59, 61], [71, 73], [101, 103], [107, 109]]
 ```
 
+We can also enumerate prime triplets using **and-patterns** and **or-patterns** effectively.
+
+```Ruby
+prime_triplets = match_stream(Prime) {
+  with(List.(*_, _p, And(Or(__("p + 2"), __("p + 4")), _m), __("p + 6"), *_)) {
+    [p, m, p + 6]
+  }
+}
+
+p prime_triplets.take(10)
+#=>[[5, 7, 11], [7, 11, 13], [11, 13, 17], [13, 17, 19], [17, 19, 23], [37, 41, 43], [41, 43, 47], [67, 71, 73], [97, 101, 103], [101, 103, 107]]
+```
+
 ### Algebraic Data Types
 
 We can also patten match against algebraic data types as ordinary functional programming languages.
 Here is a simple example.
 Note that, the object in the pattern matches if the target object is equal with it.
 
-```
+```Ruby
 class User < Struct.new(:name, :gender, :married, :doctor, :professor)
   def greet
     match(self) do
-      with(_[_name,       _,    _,    _, true]) { "Hello, Prof. #{name}!" }
-      with(_[_name,       _,    _, true,    _]) { "Hello, Dr. #{name}!" }
-      with(_[_name,   :male,    _,    _,    _]) { "Hello, Mr. #{name}!" }
-      with(_[_name, :female, true,    _,    _]) { "Hello, Mrs. #{name}!" }
-      with(_[_name, :female,    _,    _,    _]) { "Hello, Ms. #{name}!" }
-      with(_[_name,       _,    _,    _,    _]) { "Hello, #{name}!" }
+      with(User.(_name,       _,    _,    _, true)) { "Hello, Prof. #{name}!" }
+      with(User.(_name,       _,    _, true,    _)) { "Hello, Dr. #{name}!" }
+      with(User.(_name, :female, true,    _,    _)) { "Hello, Mrs. #{name}!" }
+      with(User.(_name, :female,    _,    _,    _)) { "Hello, Ms. #{name}!" }
+      with(User.(_name,   :male,    _,    _,    _)) { "Hello, Mr. #{name}!" }
+      with(User.(_name,       _,    _,    _,    _)) { "Hello, #{name}!" }
     end
   end
 end
@@ -302,12 +315,14 @@ There is a new programming world!
 
 ## Contact
 
-If you get interested in this Gem, please contact [Satoshi Egi](http://www.egison.org/~egi/) or tweet to [@Egison_Lang](https://twitter.com/Egison_Lang).
+If you get interested in this Gem, please contact <a target="_blank" href="http://www.egison.org/~egi/">Satoshi Egi</a> or tweet to <a target="_blank" href="https://twitter.com/Egison_Lang">@Egison_Lang</a>.
+
+We will talk about this gem in <a target="_blank" href="http://rubykaigi.org/2014">RubyKaigi 2014</a>!
 
 ## 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 learned how to extend Ruby and how to write a gem from the code of  <a target="_blank" href="https://github.com/k-tsj/pattern-match">the pattern-match gem</a> 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/lib/egison/core.rb

@@ -141,10 +141,9 @@ module PatternMatch
     def match(tgt, bindings)
       tgt = tgt.to_a
       if subpatterns.empty?
-        if tgt.empty?
-          return [[[], []]]
-        else
-          return []
+        unnileds = @matcher.unnil(tgt)
+        unnileds.map do
+          [[], []]
         end
       else
         subpatterns = @subpatterns.clone
@@ -219,6 +218,32 @@ module PatternMatch
     end
   end
 
+  class OrPattern < PatternElement
+    attr_reader :pats
+
+    def initialize(*subpatterns)
+      super()
+      @pats = subpatterns
+    end
+
+    def match(tgt, bindings)
+      @pats.map { |pat| [[[pat, tgt]], []] }
+    end
+  end
+  
+  class AndPattern < PatternElement
+    attr_reader :pats
+
+    def initialize(*subpatterns)
+      super()
+      @pats = subpatterns
+    end
+
+    def match(tgt, bindings)
+      [[@pats.map { |pat| [pat, tgt] }, []]]
+    end
+  end
+  
   class Wildcard < PatternElement
     def initialize()
       super()
@@ -375,6 +400,14 @@ module PatternMatch
       end
     end
 
+    def Or(*subpatterns)
+      OrPattern.new(*subpatterns)
+    end
+
+    def And(*subpatterns)
+      AndPattern.new(*subpatterns)
+    end
+
     class BindingModule < ::Module
     end
 

data/lib/egison/matcher-core.rb

@@ -4,6 +4,14 @@ require 'egison/lazyarray'
 class Class
   include PatternMatch::Matchable
 
+  def unnil(val)
+    if val.empty?
+      [[]]
+    else
+      []
+    end
+  end
+
   def uncons(val)
     raise NotImplementedError, "need to define `#{__method__}'"
   end
@@ -23,6 +31,32 @@ end
 module Egison
   extend self
 
+  class << Struct
+    def unnil(val)
+      [[]]
+    end
+    
+    def uncons(val)
+      val2 = val.clone
+      x = val2.shift
+      [[x, val2]]
+    end
+
+    def unjoin(val)
+      val2 = val.clone
+      xs = []
+      ys = val2.clone
+      rets = [[xs, ys]]
+      until val2.empty? do
+        x = val2.shift
+        ys = val2.clone
+        xs += [x]
+        rets += [[xs, ys]]
+      end
+      rets
+    end
+  end
+
   class List
   end
 

data/lib/egison/version.rb

@@ -1,3 +1,3 @@
 module Egison
-  VERSION = "0.6.0"
+  VERSION = "1.0.0"
 end

data/sample/greet.rb

@@ -5,12 +5,12 @@ include Egison
 class User < Struct.new(:name, :gender, :married, :doctor, :professor)
   def greet
     match(self) do
-      with(_[_name,       _,    _,    _, true]) { "Hello, Prof. #{name}!" }
-      with(_[_name,       _,    _, true,    _]) { "Hello, Dr. #{name}!" }
-      with(_[_name,   :male,    _,    _,    _]) { "Hello, Mr. #{name}!" }
-      with(_[_name, :female, true,    _,    _]) { "Hello, Mrs. #{name}!" }
-      with(_[_name, :female,    _,    _,    _]) { "Hello, Ms. #{name}!" }
-      with(_[_name,       _,    _,    _,    _]) { "Hello, #{name}!" }
+      with(User.(_name,       _,    _,    _, true)) { "Hello, Prof. #{name}!" }
+      with(User.(_name,       _,    _, true))       { "Hello, Dr. #{name}!" }
+      with(User.(_name, :female, true))             { "Hello, Mrs. #{name}!" }
+      with(User.(_name, :female))                   { "Hello, Ms. #{name}!" }
+      with(User.(_name,   :male))                   { "Hello, Mr. #{name}!" }
+      with(User.(_name))                            { "Hello, #{name}!" }
     end
   end
 end

data/sample/primes.rb

@@ -4,9 +4,17 @@ require 'prime'
 include Egison
 
 twin_primes = match_stream(Prime) {
-  with(List.(*_, _x, __("x + 2"), *_)) {
-    [x, x + 2]
+  with(List.(*_, _p, __("p + 2"), *_)) {
+    [p, p + 2]
   }
 }
 
 p twin_primes.take(10)
+
+prime_triplets = match_stream(Prime) {
+  with(List.(*_, _p, And(Or(__("p + 2"), __("p + 4")), _m), __("p + 6"), *_)) {
+    [p, m, p + 6]
+  }
+}
+
+p prime_triplets.take(10)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: egison
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Satoshi Egi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-23 00:00:00.000000000 Z
+date: 2014-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake