funkr 0.0.9 → 0.0.10

data/lib/funkr/adt/adt.rb

@@ -44,6 +44,9 @@ module Funkr
         define_singleton_method(c) do |*data|
           self.new(c,*data)
         end
+        define_method(format("%s?",c).to_sym) do
+          const() == c
+        end
       end
     end
     

data/lib/funkr/extensions.rb

@@ -1,2 +1,3 @@
 require 'funkr/extensions/fixnum'
 require 'funkr/extensions/array'
+require 'funkr/extensions/enumerable'

data/lib/funkr/extensions/array.rb

@@ -59,64 +59,4 @@ class Array
   end
   
   
-  # other extensions
-  class NoHead; end
-  
-  def head; empty? ? NoHead : first; end
-  
-  def tail; size > 1 ? self[1..-1] : []; end
-  
-  def all_different?
-    return true if tail.empty?
-    !tail.include?(head) and tail.all_different?
-  end
-  
-  # http://www.haskell.org/ghc/docs/6.12.2/html/libraries/base-4.2.0.1/src/Data-List.html#group
-  def group_seq_by(&block)
-    if empty? then []
-    else
-      a,b = tail.span{|x| (yield head) == (yield x)}
-      [a.unshift(head)] + b.group_seq_by(&block)
-    end
-  end
-  
-  # http://www.haskell.org/ghc/docs/6.12.2/html/libraries/base-4.2.0.1/src/GHC-List.html#span
-  def span(&block)
-    if empty? then [[],[]]
-    elsif (yield head) then
-      a,b = tail.span(&block)
-      [a.unshift(head),b]
-    else [[], self]
-    end
-  end
-
-  # Constitue des groupes disjoints de n éléments au plus
-  def groups_of(n)
-    return [] if self.empty?
-    [self.take(n)] + self.drop(n).groups_of(n)
-  end
-
-  # constitue des groupes de n éléments exactement, décalés de 1
-  def sliding_groups_of(n)
-    return [] if self.size < n
-    [ self.take(n) ] + self.tail.sliding_groups_of(n)
-  end
-
-  # trouve l'index d'une séquence
-  def seq_index(seq)
-    self.sliding_groups_of(seq.size).index(seq)
-  end
-
-  # difference entre 2 tableaux, retourne le triplet [ [missing] , [intersection], [added] ]
-  # codé en impératif parce que inject est trop lent :(
-  def diff_with(other, &block)
-    m, i, a = [], [], []
-    self.each do |e| 
-      if other.find{|x| yield(e,x)} then i.push(e)  # intersection
-      else m.push(e) end   # missing
-    end
-    other.each { |e| a.push(e) unless self.find{|x| yield(e,x)} } # added
-    [ m, i, a ]
-  end
-  
 end

data/lib/funkr/extensions/enumerable.rb

@@ -0,0 +1,79 @@
+module Enumerable
+  
+  # enumerable extensions
+  class NoHead; end
+  
+  def head; empty? ? NoHead : first; end
+  
+  def tail; self.drop(1); end
+  
+  def all_different?
+    return true if tail.empty?
+    !tail.include?(head) and tail.all_different?
+  end
+  
+  # http://www.haskell.org/ghc/docs/6.12.2/html/libraries/base-4.2.0.1/src/Data-List.html#group
+  def group_seq_by(&block)
+    if empty? then []
+    else
+      res = []
+      rst = self
+      while rst.any? do
+        v = yield(rst.head)
+        a,rst = rst.span{|x| (yield x) == v}
+        res.push(a)
+      end
+      return res
+    end
+  end
+  
+  # http://www.haskell.org/ghc/docs/6.12.2/html/libraries/base-4.2.0.1/src/GHC-List.html#span
+  def span(&block)
+    inc = []
+    self.each_with_index do |e,i|
+      if yield(e) then inc.push(e)
+      else return [ inc, self.drop(i) ] end
+    end
+    return [ inc, [] ]
+  end
+
+  # Constitue des groupes disjoints de n éléments au plus
+  def groups_of(n)
+    return [] if self.empty?
+    [self.take(n)] + self.drop(n).groups_of(n)
+  end
+
+  # constitue des groupes de n éléments exactement, décalés de 1
+  def sliding_groups_of(n)
+    return [] if self.size < n
+    [ self.take(n) ] + self.tail.sliding_groups_of(n)
+  end
+
+  # trouve l'index d'une séquence
+  def seq_index(seq)
+    self.sliding_groups_of(seq.size).index(seq)
+  end
+
+  def uniq_by(&block)
+    result = []
+    self.each do |e|
+      unless result.any?{|x| yield(x,e)} then result.push(e) end
+    end
+    return result
+  end
+
+  # difference entre 2 tableaux, retourne le triplet [ [missing] , [intersection], [added] ]
+  # codé en impératif parce que inject est trop lent :(
+  def diff_with(other, &block)
+    m, i, a = [], [], []
+    u_s = self.uniq_by(&block)
+    u_o = other.uniq_by(&block)
+    u_s.each do |e| 
+      if u_o.find{|x| yield(e,x)} then i.push(e)  # intersection
+      else m.push(e) end   # missing
+    end
+    u_o.each { |e| a.push(e) unless u_s.find{|x| yield(e,x)} } # added
+    return [ m, i, a ]
+  end
+
+end

data/lib/funkr/version.rb

@@ -1,3 +1,3 @@
 module Funkr
-  VERSION = "0.0.9"
+  VERSION = "0.0.10"
 end

data/test/tests.rb

@@ -74,10 +74,12 @@ puts(a.bind do |x|
      end.inspect)
 
 
+puts "\n> span"
+puts([1,2,4,5,7,5,8,2,10].span{|x| x < 5}.inspect)
+
 puts "\n> group_seq_by"
 puts([1,2,4,5,7,5,8,2,10].group_seq_by{|x| x % 2}.inspect)
 
-
 puts "\n> groups_of"
 puts([1,2,4,5,7,5,8,2,10].groups_of(4).inspect)
 
@@ -88,6 +90,10 @@ puts "\n> seq_index (30)"
 puts((0..100).to_a.seq_index([30,31,32]))
 
 puts "\n> diff_with"
-a = [ {:v => 1}, {:v => 2}, {:v => 3} ]
-b = [ {:v => 2}, {:v => 3}, {:v => 4} ]
+a = [ {:v => 1}, {:v => 2}, {:v => 3}, {:v => 2}, {:v => 3} ]
+b = [ {:v => 2}, {:v => 3}, {:v => 4}, {:v => 3}, {:v => 4} ]
 puts(a.diff_with(b){|x,y| x[:v] == y[:v]}.inspect)
+
+puts "\n> uniq_by"
+a = [ {:v => 1}, {:v => 2}, {:v => 3}, {:v => 2}, {:v => 3}, {:v => 1} ]
+puts(a.uniq_by{|x,y| x[:v] == y[:v]}.inspect)

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: funkr
 version: !ruby/object:Gem::Version 
-  hash: 13
+  hash: 11
   prerelease: 
   segments: 
   - 0
   - 0
-  - 9
-  version: 0.0.9
+  - 10
+  version: 0.0.10
 platform: ruby
 authors: 
 - Paul Rivier
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-21 00:00:00 +01:00
+date: 2011-03-24 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
@@ -45,6 +45,7 @@ files:
 - lib/funkr/compat/1.8.rb
 - lib/funkr/extensions.rb
 - lib/funkr/extensions/array.rb
+- lib/funkr/extensions/enumerable.rb
 - lib/funkr/extensions/fixnum.rb
 - lib/funkr/types.rb
 - lib/funkr/types/failable.rb