egison 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 146ed0f768555e2dc73b59c7468dc1d2dd0cfa6a
-  data.tar.gz: 8d4a4486865bff5cca675ac45117443b2da7e665
+  metadata.gz: 94a489dfeb3722cf74e46e867076fec46fb389b7
+  data.tar.gz: 9b115c122986dd02864a4b25a7754273f4eadd9d
 SHA512:
-  metadata.gz: dd3b48d5efa466113bae4eca3eb6e2f0bc5efb9405783a95f3d91bdad65d7b15a7aa4aad8d4859a36eebc3d30df245fa093a5caa69d3312d35069a5747965ccd
-  data.tar.gz: bd41119e0da423aa3b9fb66ca69c6bf03d25bb8e7a81fe9030de230ded0ffd7e10e82ab09f236e9d828c9ccf6de1abed9452322b3bfef697979daf2196aff144
+  metadata.gz: 896c6d1ad74e28517083ae6cfea6465895f1af804c5fbf51da7c291b51f16effdc120e0a50e5325b61273490e71ebd71b1e46924e3eb34ff2906c0eca2cd12f6
+  data.tar.gz: bb189940c54dcb19358b5d30b2e94b48d3e262fb2ec22f0c6e7e28299a0ed2853f50e935090f0f45d70266b82e351bfab15e7cdde854e87c4422b752c3aaf7ef

data/README.md

@@ -258,7 +258,11 @@ You can find more demonstrations in the [`sample`](https://github.com/egison/egi
 ## 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.
+<<<<<<< HEAD
+Egison is the pattern-matching oriented, purely functional programming language.
+=======
+Egison is the pattern-matching oriented purely functional programming language.
+>>>>>>> 39ede8d0f3300244c240fce2d8069dda3a2f065e
 Actually, the original pattern-matching system of Egison is more powerful.
 For example, we can do following things in the original Egison.
 
@@ -269,7 +273,7 @@ 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).
+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).
 
 ## LICENSE
 

data/lib/egison/core.rb

@@ -50,33 +50,26 @@ module PatternMatch
 
   class MatchingStateStream
     def initialize(pat, tgt)
-      @states = [MatchingState.new(pat, tgt)]
+      @state = MatchingState.new(pat, tgt)
       @processes = []
     end
 
     def match(&block)
-      state = @states.shift
-      @processes << Egison::LazyArray.new(state.process_stream)
-      until @states.empty? && @processes.empty?
-        unless @processes.empty?
-          process(@processes.shift, &block)
-        end
-        unless @states.empty?
-          state = @states.shift
-          process(Egison::LazyArray.new(state.process_stream), &block)
-        end
+      @processes << Egison::LazyArray.new(@state.process_stream)
+      until @processes.empty?
+        process(@processes.shift, &block)
       end
     end
 
     def process(process_iter, &block)
       unless process_iter.empty?
-        @processes << process_iter
         ret = process_iter.shift
         if ret.atoms.empty?
           block.(ret.bindings)
         else
-          @states << ret
+          @processes << Egison::LazyArray.new(ret.process_stream)
         end
+        @processes << process_iter
       end
     end
   end
@@ -332,7 +325,7 @@ module PatternMatch
         uscore = Wildcard.new()
         class << uscore
           def [](*args)
-            List.call(*args)
+            Egison::List.call(*args)
           end
         end
         uscore
@@ -417,11 +410,11 @@ module PatternMatch
       ctx = @ctx
       tgt = @tgt
       mstack = MatchingStateStream.new(pat,tgt)
-      ::Enumerator.new do |y|
+      ::Egison::LazyArray.new(::Enumerator.new{|y|
         mstack.match do |bindings|
           y << with_bindings(ctx, bindings, &block)
         end
-      end
+      })
     rescue PatternNotMatch
     end
   end

data/lib/egison/lazyarray.rb

@@ -150,7 +150,7 @@ module Egison
     end
 
     def inspect
-      "\#<#{self.class.name}#{@terminated ? @cache.inspect : "[#{@cache.join(', ')}...]"}>"
+      "\#<#{self.class.name}#{@terminated ? @cache.inspect : "[#{@cache.map(&:inspect).join(', ')}...]"}>"
     end
   end
 end

data/lib/egison/matcher-core.rb

@@ -24,54 +24,58 @@ class Class
   end
 end
 
-class List
-end
-
-class << List
-  def uncons(val)
-    accept_array_only(val)
-    val2 = val.clone
-    x = val2.shift
-    [[x, val2]]
+module Egison
+  extend self
+  
+  class List
   end
 
-  def uncons_stream(val, &block)
-    if !(val.kind_of?(Array) || val.kind_of?(Egison::LazyArray))
-      val = test_conv_lazy_array(val)
+  class << List
+    def uncons(val)
+      accept_array_only(val)
+      val2 = val.clone
+      x = val2.shift
+      [[x, val2]]
     end
-    val2 = val.clone
-    x = val2.shift
-    block.([x, val2])
-  end
 
-  def unjoin(val)
-    accept_array_only(val)
-    val2 = val.clone
-    xs = []
-    ys = val2.clone
-    rets = [[xs, ys]]
-    until val2.empty? do
+    def uncons_stream(val, &block)
+      if !(val.kind_of?(Array) || val.kind_of?(Egison::LazyArray))
+        val = test_conv_lazy_array(val)
+      end
+      val2 = val.clone
       x = val2.shift
-      ys = val2.clone
-      xs += [x]
-      rets += [[xs, ys]]
+      block.([x, val2])
     end
-    rets
-  end
 
-  def unjoin_stream(val, &block)
-    if !(val.kind_of?(Array) || val.kind_of?(Egison::LazyArray))
-      val = test_conv_lazy_array(val)
+    def unjoin(val)
+      accept_array_only(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
-    val2 = val.clone
-    xs = []
-    ys = val2.clone
-    block.([xs, ys])
-    until val2.empty?
-      x = val2.shift
+
+    def unjoin_stream(val, &block)
+      if !(val.kind_of?(Array) || val.kind_of?(Egison::LazyArray))
+        val = test_conv_lazy_array(val)
+      end
+      val2 = val.clone
+      xs = []
       ys = val2.clone
-      xs += [x]
       block.([xs, ys])
+      until val2.empty?
+        x = val2.shift
+        ys = val2.clone
+        xs += [x]
+        block.([xs, ys])
+      end
     end
   end
 end

data/lib/egison/matcher.rb

@@ -3,123 +3,125 @@ require 'egison/lazyarray'
 require 'egison/matcher-core'
 require 'set'
 
-class Multiset
-end
+module Egison
+  extend self
+  
+  class Multiset
+  end
 
-class << Multiset
-  def uncons(val)
-    accept_array_only(val)
-    match_all(val) do
-      with(List.(*_hs, _x, *_ts)) do
-        [x, hs + ts]
+  class << Multiset
+    def uncons(val)
+      accept_array_only(val)
+      match_all(val) do
+        with(List.(*_hs, _x, *_ts)) do
+          [x, hs + ts]
+        end
       end
     end
-  end
 
-  def uncons_stream(val, &block)
-    if !(val.kind_of?(Array) || val.kind_of?(Egison::LazyArray))
-      val = test_conv_lazy_array(val)
-    end
-    stream = match_stream(val) {
-      with(List.(*_hs, _x, *_ts)) do
-        [x, hs + ts]
+    def uncons_stream(val, &block)
+      if !(val.kind_of?(Array) || val.kind_of?(Egison::LazyArray))
+        val = test_conv_lazy_array(val)
       end
-    }
-    stream.each(&block)
-  end
+      stream = match_stream(val) {
+        with(List.(*_hs, _x, *_ts)) do
+          [x, hs + ts]
+        end
+      }
+      stream.each(&block)
+    end
 
-  def unjoin(val)
-    accept_array_only(val)
-    val2 = val.clone
-    xs = []
-    ys = val2.clone
-    rets = [[xs, ys]]
-    if val2.empty?
-      rets
-    else
-      x = val2.shift
+    def unjoin(val)
+      accept_array_only(val)
+      val2 = val.clone
+      xs = []
       ys = val2.clone
-      rets2 = unjoin(ys)
-      rets = (rets2.map { |xs2, ys2| [xs2, [x] + ys2] }) + (rets2.map { |xs2, ys2| [[x] + xs2, ys2] })
-      rets
+      rets = [[xs, ys]]
+      if val2.empty?
+        rets
+      else
+        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
+      end
     end
-  end
 
-  def unjoin_stream(val, &block)
-    if !(val.kind_of?(Array) || val.kind_of?(Egison::LazyArray))
-      val = test_conv_lazy_array(val)
-    end
-    val2 = val.clone
-    xs = []
-    ys = val2.clone
-    if val2.empty?
-      block.([xs, ys])
-    else
-      x = val2.shift
+    def unjoin_stream(val, &block)
+      if !(val.kind_of?(Array) || val.kind_of?(Egison::LazyArray))
+        val = test_conv_lazy_array(val)
+      end
+      val2 = val.clone
+      xs = []
       ys = val2.clone
-      rets_stream = Egison::LazyArray.new(to_enum(:unjoin_stream, ys))
-      # rets_stream.each{|xs2, ys2| block.([xs2, [x] + ys2])}
-      rets_stream.each{|xs2, ys2| block.([xs2, ys2.clone.unshift(x)])}
-      # rets_stream.each{|xs2, ys2| block.([[x] + xs2, ys2])}
-      rets_stream.each{|xs2, ys2| block.([xs2.clone.unshift(x), ys2])}
+      block.([xs, ys])
+      unless val2.empty?
+        x = val2.shift
+        ys = val2.clone
+        unjoin_stream(ys) do |xs2, ys2|
+          block.([xs2, [x] + ys2]) unless xs2.empty?
+          block.([[x] + xs2, ys2])
+        end
+      end
     end
   end
-end
 
-class << Set
-  def uncons(val)
-    accept_array_only(val)
-    match_all(val) do
-      with(List.(*_, _x, *_)) do
-        [x, val]
+  class << Set
+    def uncons(val)
+      accept_array_only(val)
+      match_all(val) do
+        with(List.(*_, _x, *_)) do
+          [x, val]
+        end
       end
     end
-  end
 
-  def uncons_stream(val, &block)
-    if !(val.kind_of?(Array) || val.kind_of?(Egison::LazyArray))
-      val = test_conv_lazy_array(val)
-    end
-    stream = match_stream(val) {
-      with(List.(*_, _x, *_)) do
-        [x, val]
+    def uncons_stream(val, &block)
+      if !(val.kind_of?(Array) || val.kind_of?(Egison::LazyArray))
+        val = test_conv_lazy_array(val)
       end
-    }
-    stream.each(&block)
-  end
-
-  def unjoin(val)
-    accept_array_only(val)
-    val2 = val.clone
-    xs = []
-    ys = val2.clone
-    rets = [[xs, ys]]
-    if val2.empty?
-      rets
-    else
-      x = val2.shift
-      ys2 = val2.clone
-      rets2 = unjoin(ys2)
-      rets = (rets2.map { |xs2, _| [xs2, ys] }) + (rets2.map { |xs2, ys2| [[x] + xs2, ys] })
-      rets
+      stream = match_stream(val) {
+        with(List.(*_, _x, *_)) do
+          [x, val]
+        end
+      }
+      stream.each(&block)
     end
-  end
 
-  def unjoin_stream(val, &block)
-    if !(val.kind_of?(Array) || val.kind_of?(Egison::LazyArray))
-      val = test_conv_lazy_array(val)
+    def unjoin(val)
+      accept_array_only(val)
+      val2 = val.clone
+      xs = []
+      ys = val2.clone
+      rets = [[xs, ys]]
+      if val2.empty?
+        rets
+      else
+        x = val2.shift
+        ys2 = val2.clone
+        rets2 = unjoin(ys2)
+        rets = (rets2.map { |xs2, _| [xs2, ys] }) + (rets2.map { |xs2, ys2| [[x] + xs2, ys] })
+        rets
+      end
     end
-    val2 = val.clone
-    xs = []
-    ys = val2.clone
-    if val2.empty?
+
+    def unjoin_stream(val, &block)
+      if !(val.kind_of?(Array) || val.kind_of?(Egison::LazyArray))
+        val = test_conv_lazy_array(val)
+      end
+      val2 = val.clone
+      xs = []
+      ys = val2.clone
       block.([xs, ys])
-    else
-      x = val2.shift
-      ys2 = val2.clone
-      rets_stream = Egison::LazyArray.new(to_enum(:unjoin_stream, ys2))
-      rets_stream.each{|xs2, _| block.([xs2, ys])}
-      rets_stream.each{|xs2, _| block.([xs2.clone.unshift(x), ys])}
+      unless val2.empty?
+        x = val2.shift
+        ys2 = val2.clone
+        unjoin_stream(ys2) do |xs2, _|
+          block.([xs2, ys]) unless xs2.empty?
+          block.([[x] + xs2, ys])
+        end
+      end
     end
   end
 end

data/lib/egison/version.rb

@@ -1,3 +1,3 @@
 module Egison
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/spec/sample/join_stream_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'egison'
+
+include Egison
+
+def nats
+  (1..Float::INFINITY)
+end
+
+describe "sample" do
+  describe "join_stream.rb" do
+    # (take 30 (match-all nats (list integer) [<join $hs <join $ts _>> [hs ts]]))
+    # => {[{} {}] [{} {1}] [{1} {}] [{} {1 2}] [{1} {2}] [{1 2} {}] [{} {1 2 3}] [{1} {2 3}] [{1 2} {3}] [{1 2 3} {}] [{} {1 2 3 4}] [{1} {2 3 4}] [{1 2} {3 4}] [{1 2 3} {4}] [{1 2 3 4} {}] [{} {1 2 3 4 5}] [{1} {2 3 4 5}] [{1 2} {3 4 5}] [{1 2 3} {4 5}] [{1 2 3 4} {5}] [{1 2 3 4 5} {}] [{} {1 2 3 4 5 6}] [{1} {2 3 4 5 6}] [{1 2} {3 4 5 6}] [{1 2 3} {4 5 6}] [{1 2 3 4} {5 6}] [{1 2 3 4 5} {6}] [{1 2 3 4 5 6} {}] [{} {1 2 3 4 5 6 7}] [{1} {2 3 4 5 6 7}]}
+    # v- same result as above
+    it %q{match_stream(nats) { with(List.(*_hs, *_ts, *_)) { [hs, ts] } }.take(30)} do
+      expect(match_stream(nats) { with(List.(*_hs, *_ts, *_)) { [hs, ts] } }.take(30)).to eq \
+        [[[], []], [[], [1]], [[1], []], [[], [1, 2]], [[1], [2]], [[1, 2], []], [[], [1, 2, 3]], [[1], [2, 3]], [[1, 2], [3]], [[1, 2, 3], []], [[], [1, 2, 3, 4]], [[1], [2, 3, 4]], [[1, 2], [3, 4]], [[1, 2, 3], [4]], [[1, 2, 3, 4], []], [[], [1, 2, 3, 4, 5]], [[1], [2, 3, 4, 5]], [[1, 2], [3, 4, 5]], [[1, 2, 3], [4, 5]], [[1, 2, 3, 4], [5]], [[1, 2, 3, 4, 5], []], [[], [1, 2, 3, 4, 5, 6]], [[1], [2, 3, 4, 5, 6]], [[1, 2], [3, 4, 5, 6]], [[1, 2, 3], [4, 5, 6]], [[1, 2, 3, 4], [5, 6]], [[1, 2, 3, 4, 5], [6]], [[1, 2, 3, 4, 5, 6], []], [[], [1, 2, 3, 4, 5, 6, 7]], [[1], [2, 3, 4, 5, 6, 7]]]
+    end
+    # (take 30 (match-all nats (multiset integer) [<join $hs <join $ts _>> [hs ts]]))
+    # => {[{} {}] [{} {1}] [{1} {}] [{} {2}] [{1} {2}] [{2} {}] [{} {3}] [{1} {3}] [{2} {1}] [{3} {}] [{} {4}] [{1} {4}] [{2} {3}] [{3} {1}] [{4} {}] [{} {5}] [{1} {5}] [{2} {4}] [{3} {2}] [{4} {1}] [{5} {}] [{} {6}] [{1} {6}] [{2} {5}] [{3} {4}] [{4} {2}] [{5} {1}] [{6} {}] [{} {7}] [{1} {7}]}
+    # v- diffrent result as above, but natural
+    it %q{match_stream(nats) { with(Multiset.(*_hs, *_ts, *_)) { [hs, ts] } }.take(30)} do
+      expect(match_stream(nats) { with(Multiset.(*_hs, *_ts, *_)) { [hs, ts] } }.take(30)).to eq \
+        [[[], []], [[], [1]], [[1], []], [[], [2]], [[1], [2]], [[2], []], [[], [1, 2]], [[1], [3]], [[2], [1]], [[1, 2], []], [[], [3]], [[1], [2, 3]], [[2], [3]], [[1, 2], [3]], [[3], []], [[], [1, 3]], [[1], [4]], [[2], [1, 3]], [[1, 2], [4]], [[3], [1]], [[1, 3], []], [[], [2, 3]], [[1], [2, 4]], [[2], [4]], [[1, 2], [3, 4]], [[3], [2]], [[1, 3], [2]], [[2, 3], []], [[], [1, 2, 3]], [[1], [3, 4]]]
+    end
+    # (take 30 (match-all nats (set integer) [<join $hs <join $ts _>> [hs ts]]))
+    # => {[{} {}] [{} {1}] [{1} {}] [{} {2}] [{1} {1}] [{2} {}] [{} {3}] [{1} {2}] [{2} {1}] [{3} {}] [{} {1 2}] [{1} {3}] [{2} {2}] [{3} {1}] [{1 2} {}] [{} {4}] [{1} {1 2}] [{2} {3}] [{3} {2}] [{1 2} {1}] [{4} {}] [{} {1 3}] [{1} {4}] [{2} {1 2}] [{3} {3}] [{1 2} {2}] [{4} {1}] [{1 3} {}] [{} {2 1}] [{1} {1 3}]}
+    # v- diffrent result as above, but natural
+    it %q{match_stream(nats) { with(Set.(*_hs, *_ts, *_)) { [hs, ts] } }.take(30)} do
+      expect(match_stream(nats) { with(Set.(*_hs, *_ts, *_)) { [hs, ts] } }.take(30)).to eq \
+        [[[], []], [[], [1]], [[1], []], [[], [2]], [[1], [1]], [[2], []], [[], [1, 2]], [[1], [2]], [[2], [1]], [[1, 2], []], [[], [3]], [[1], [1, 2]], [[2], [2]], [[1, 2], [1]], [[3], []], [[], [1, 3]], [[1], [3]], [[2], [1, 2]], [[1, 2], [2]], [[3], [1]], [[1, 3], []], [[], [2, 3]], [[1], [1, 3]], [[2], [3]], [[1, 2], [1, 2]], [[3], [2]], [[1, 3], [1]], [[2, 3], []], [[], [1, 2, 3]], [[1], [2, 3]]]
+    end
+  end
+end
+

data/spec/sample/stream_spec.rb

@@ -34,10 +34,32 @@ describe "sample" do
         [[1, 2], [1, 3], [2, 1], [1, 4], [2, 3], [3, 1], [1, 5], [2, 4], [3, 2], [4, 1]]
     end
 
+    # (take 20 (match-all nats (multiset integer) [<cons $m <cons $n _>> [m n]]))
+    it %q{match_stream(nats){ with(Multiset.(_m, _n, *_)) { [m, n] } }.take(20)} do
+      expect(match_stream(nats){ with(Multiset.(_m, _n, *_)) { [m, n] } }.take(20)).to eq \
+        [[1, 2], [1, 3], [2, 1], [1, 4], [2, 3], [3, 1], [1, 5], [2, 4], [3, 2], [4, 1],
+         [1, 6], [2, 5], [3, 4], [4, 2], [5, 1], [1, 7], [2, 6], [3, 5], [4, 3], [5, 2]]
+    end
+
     # (take 10 (match-all nats (set integer) [<cons $m <cons $n _>> [m n]]))
     it %q{match_stream(nats){ with(Set.(_m, _n, *_)) { [m, n] } }.take(10)} do
       expect(match_stream(nats){ with(Set.(_m, _n, *_)) { [m, n] } }.take(10)).to eq \
         [[1, 1], [1, 2], [2, 1], [1, 3], [2, 2], [3, 1], [1, 4], [2, 3], [3, 2], [4, 1]]
     end
+
+    # (take 20 (match-all nats (set integer) [<cons $m <cons $n _>> [m n]]))
+    it %q{match_stream(nats){ with(Set.(_m, _n, *_)) { [m, n] } }.take(20)} do
+      expect(match_stream(nats){ with(Set.(_m, _n, *_)) { [m, n] } }.take(20)).to eq \
+        [[1, 1], [1, 2], [2, 1], [1, 3], [2, 2], [3, 1], [1, 4], [2, 3], [3, 2], [4, 1],
+         [1, 5], [2, 4], [3, 3], [4, 2], [5, 1], [1, 6], [2, 5], [3, 4], [4, 3], [5, 2]]
+    end
+
+    # assign to a variable, execute twice (or more), then obtain the same results. (for twin-primes)
+    it %q{assign to a variable, execute twice (or more), then obtain the same results. (for twin-primes)} do
+      tp = twin_primes
+      tp.take(10) # discard
+      expect(tp.take(10)).to eq \
+        [[3, 5], [5, 7], [11, 13], [17, 19], [29, 31], [41, 43], [59, 61], [71, 73], [101, 103], [107, 109]]
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: egison
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Satoshi Egi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-19 00:00:00.000000000 Z
+date: 2014-07-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -83,6 +83,7 @@ files:
 - spec/lib/egison_spec.rb
 - spec/sample/combination_spec.rb
 - spec/sample/join_spec.rb
+- spec/sample/join_stream_spec.rb
 - spec/sample/poker_hands_spec.rb
 - spec/sample/set_spec.rb
 - spec/sample/stream_spec.rb