functions 0.0.15 → 0.0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2ce638922c8e6bfddfd46e70897d221b1c39b642
-  data.tar.gz: 1747fa2b179e25fe8e64633bd1f391d4bf7e6942
+  metadata.gz: f9f07df0e596091bea7d6f8f57d4c877faf3d9bd
+  data.tar.gz: 0642fda991a8aa220b809d22c474f9af47b4ed24
 SHA512:
-  metadata.gz: 98543846cf5ec5408dbbc7770d299b86d3343c7a20e51264ef83c3d52202e4e43d644d9e737110841beb9d249a11a2085695b040f84326c6c6db37f4e185e72f
-  data.tar.gz: db078d333e4b467cf2cf833e9c1eb26e1a7819899ca84d7e6a4b3206e81f0a29fcfc0ff12b61ee045303a5436e8e12546d29e8bf70d70f5f82d410147311d5a9
+  metadata.gz: ea82380d54e0fbb0469c88f9d009662ef803e3d841f9638a894a30d964752b7f94eb0b68c7c04f86d965333cb4182786c322a4fec9d744fc47f41ab82786977e
+  data.tar.gz: 6c3c534d39be490690e25761d09193355bc02a1496404fa222871eb5f71290b7e878f510839e690fb849eb6a927633e063cd8f5627c9327ddfc9290d9bab18a0

data/examples/multi_hash_map_recursive.rb

@@ -0,0 +1,19 @@
+require_relative '../lib/functions'
+
+folders = {
+  'main[2]' => { 'child[3]' => 'leaf'}
+}
+
+def multiply_folder(k,v)
+  match = k.match(/(.*)\[(\d+)\]/)
+  k, count = match ? [match[1], match[2].to_i] : [k, nil]
+  if count
+    (1..count).map { |i| ["#{k}_#{i}",v] }
+  else
+    [[k,v]]
+  end
+end
+
+multiplied = folders.multi_map_hash_recursive &multiply_folder
+
+puts multiplied

data/lib/functions/prelude_enumerable/hash.rb

@@ -8,8 +8,74 @@ class Hash
     self.each_with_object({}) { |(k, a), h| b = bs[k]; h[k] = [a, b] if b; h }
   end
 
-  def map_hash 
+  def map_values 
     Hash[self.map{|k, v| [k, yield(v)] }]
   end
 
-end
+  def map_values_recurse(&b)
+    Hash[self.map{|k, v| [k, v.is_a?(Hash) ? v.map_values_recurse(&b) : b.(v)] }]
+  end
+
+  #  definition of maarten
+  #  def map_values &blk
+  #    res = {}
+  #    each {|k,v| res[k] = blk.call(v)}
+  #    res
+  #  end
+
+  # TODO discuss if we should not map onto array as values can colide
+  def map_keys
+    Hash[self.map{|k, v| [yield(k), v] }]
+  end
+
+  def map_keys_recurse(&b)
+    Hash[self.map{|k, v| [b.(k), v.is_a?(Hash) ? v.map_keys_recurse(&b) : v ] }]
+  end
+
+  # def map_keys
+  #   each_with_object({}) { |h, (k,v)| h[yield(k)] = v }  
+  # end
+
+  # def map_keys &blk
+  #   each_with_object({}) {|h, (k,v)| h[blk.(k)] = v}  
+  # end
+
+  # definition of maarten
+  # def map_keys &blk
+  #   res = {}
+  #   each {|k,v| res[blk.call(k)] = v}
+  #   res
+  # end
+
+  # map a hash into a hash
+  def map_hash 
+    Hash[ self.map{|k, v| yield(k,v) } ]
+  end
+
+  # map a hash into a hash recursively. 
+  # the mapping function needs to check itself wether or not the value is hash and act appropriately 
+  def map_recursive(&b)
+    Hash[ self.map{|k, v| b.(k, v.is_a?(Hash) ? v.map_recursive(&b) : v) } ]
+  end
+
+  # map a hash into a hash recursively with a seperate key mapping and value mapping function
+  def map_keys_and_values(km, vm)
+    Hash[ self.map{|k, v| [ km.(k), v.is_a?(Hash) ? v.map_keys_and_values(km, vm) : vm.(v) ] } ]
+  end
+
+  # map a hash into a hash recursively where one key value mapping can be mapped onto multi key value mappings
+  def multi_map(&b)
+    Hash[ self.map{|k, v| b.(k, ( v.is_a?(Hash) ? v.multi_map(&b) : v) ) }.flatten(1) ]
+  end
+
+   # def map_hash &blk
+   #   res = {}
+   #   each do |k,v|
+   #     kk, vv = blk.call(k,v)
+   #     res[kk] = vv
+   #   end
+   #   res
+   # end
+
+end
+

data/lib/functions/version.rb

@@ -1,3 +1,3 @@
 module Functions
-  VERSION = "0.0.15"
+  VERSION = "0.0.16"
 end

data/spec/prelude_enumerable_spec.rb

@@ -57,10 +57,58 @@ describe "enumerable" do
     ad.zip_hash_inner(cb).should eq({})
   end
 
+  it "map_values" do
+    ab = {a: 1, b: 2}
+    ab.map_values { |x| x*2}.should == {a: 2, b: 4}
+    ab.map_values { |x| x.even? }.should == {a: false, b: true}
+  end
+
+  it "map_values_recurse" do
+    abcde = {a: 1, b: 2, c: { d: 1, e: 0 } }
+    abcde.map_values_recurse { |x| x*2}.should == {a: 2, b: 4, c: { d: 2, e: 0}}
+    abcde .map_values_recurse { |x| x.even? }.should == {a: false, b: true, c: { d:false, e: true}}
+  end
+
+  it "map_keys" do
+    ab = {a: 1, b: 2}
+    ab.map_keys { |k| k.to_s }.should == {"a" => 1, "b" => 2}
+    ab.map_keys { |k| k.to_s[0].ord }.should == { 97 => 1, 98 => 2 }
+    ab.map_keys { |k| k.to_s.length }.should == { 1 => 2 }
+  end
+
+  it "map_keys_recurse" do
+    abcde = {a: 1, b: 2, c: { d: 1, e: 0 } }
+    abcde.map_keys_recurse { |k| k.to_s }.should == {"a" => 1, "b" => 2, "c" => { "d" => 1, "e" => 0 }}
+  end
+
   it "map_hash" do
     ab = {a: 1, b: 2}
-    ab.map_hash { |x| x*2}.should == {a: 2, b: 4}
-    ab.map_hash { |x| x.even? }.should == {a: false, b: true}
+    ab.map_hash { |k,v| [k.to_s, v*2] }.should == {"a" => 2, "b" => 4}
+    ab.map_hash { |k,v| [k.to_s[0].ord, v.even?] }.should == {97 => false, 98 => true}
+    ab.map_hash { |k,v| [k.to_s.length, v.even?] }.should == {1 => true}
+  end
+
+  it "map_recursive" do
+    abcde = {a: 1, b: 2, c: { d: 1, e: 0 } }
+    abcde.map_recursive { |k,v| v.is_a?(Hash) ? [k.to_s, v] : [k.to_s, v*2] }.should == {"a" => 2, "b" => 4, "c" => { "d" => 2, "e" => 0 }}
+    abcde.map_recursive { |k,v| v.is_a?(Hash) ? [k.to_s[0].ord, v] : [k.to_s[0].ord, v.even?] }.should == {97 => false, 98 => true, 99 => { 100 => false, 101 => true }}
+    abcde.map_recursive { |k,v| v.is_a?(Hash) ? [k.to_s.length, v] : [k.to_s.length, v.even?] }.should == {1 => true, 1 => { 1=>true } }
+  end
+
+  it "map_keys_and_values" do
+    
+    s = ->(x) { x.to_s }
+    s_ord = ->(x) { x.to_s[0].ord }
+    s_length = ->(x) { x.to_s.length }
+    times_2 = ->(x) { x * 2 }
+    even = ->(x) { x.even? }
+    
+    abcde = {a: 1, b: 2, c: { d: 1, e: 0 } }
+
+    abcde.map_keys_and_values(s, times_2).should == {"a" => 2, "b" => 4, "c" => { "d" => 2, "e" => 0 }}
+    abcde.map_keys_and_values(s_ord, even).should == {97 => false, 98 => true, 99 => { 100 => false, 101 => true }}
+    abcde.map_keys_and_values(s_length, even).should == {1 => true, 1 => { 1=>true } }
+
   end
 
   it "counted_set" do
@@ -73,4 +121,23 @@ describe "enumerable" do
     %w(some words are longer then others).grouped_by { |x| x.length > 3 }.should eq([%w(some words longer then others),%w(are)])
   end
 
+  it "multimap" do
+
+    folders = { 'main[2]' => { 'child[3]' => 'leaf', 'simple' => 'leaf' } }
+
+    multiply_folder = -> (k,v) do
+      match = k.match(/(.*)\[(\d+)\]/)
+      k, count = match ? [match[1], match[2].to_i] : [k, nil]
+      if count
+        (1..count).map { |i| ["#{k}_#{i}",v] }
+      else
+        [[k,v]]
+      end
+    end
+
+    multiplied = folders.multi_map &multiply_folder
+    multiplied.length.should eq(2)
+    multiplied['main_1'].length.should eq(4)
+
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: functions
 version: !ruby/object:Gem::Version
-  version: 0.0.15
+  version: 0.0.16
 platform: ruby
 authors:
 - Koen Handekyn
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-05 00:00:00.000000000 Z
+date: 2014-04-08 00:00:00.000000000 Z
 dependencies: []
 description: functional programming in ruby
 email:
@@ -17,12 +17,13 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
+- ".gitignore"
+- ".rspec"
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- examples/multi_hash_map_recursive.rb
 - examples/prelude_lambda.rb
 - examples/spec/prelude_lambda_spec.rb
 - functions.gemspec
@@ -54,17 +55,17 @@ 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.0.3
+rubygems_version: 2.2.1
 signing_key: 
 specification_version: 4
 summary: functional programming in ruby