functions 0.0.16 → 0.0.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: f9f07df0e596091bea7d6f8f57d4c877faf3d9bd
-  data.tar.gz: 0642fda991a8aa220b809d22c474f9af47b4ed24
+SHA256:
+  metadata.gz: d884db3d112ebd90fee4cf4ab66325b3800988821512fa097a5bd684dac6024b
+  data.tar.gz: 640c89f3e47031e0f0320c8c9eb8ad811af88779658c6cb0befef25222aaecad
 SHA512:
-  metadata.gz: ea82380d54e0fbb0469c88f9d009662ef803e3d841f9638a894a30d964752b7f94eb0b68c7c04f86d965333cb4182786c322a4fec9d744fc47f41ab82786977e
-  data.tar.gz: 6c3c534d39be490690e25761d09193355bc02a1496404fa222871eb5f71290b7e878f510839e690fb849eb6a927633e063cd8f5627c9327ddfc9290d9bab18a0
+  metadata.gz: ed27fb9cface5baeb4dd000385eda0886425549ec90db99ea2f2afdde51b019cae3f479790d3d5107f48695feded0225e5fed7a50cd2196684df00bf9714a88a
+  data.tar.gz: 5613d93811123dfbd9be92ff0e6c33101cb652af8ad8a4ca3afa4ec68c453ebd26317d5176bf09435f31d1b4d0b868a6d23b72d968aefc27c02c9ae10de63bdf

data/.rspec

@@ -1,3 +1,2 @@
 --color
 --format progress
-# --default_path spec

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.1
+  - 2.0

data/Gemfile

@@ -3,6 +3,12 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in functions.gemspec
 gemspec
 
+# gem 'coveralls', require: false
+# gem 'rake'
+
 group :test do
-  gem 'test-unit'
+  # gem 'test-unit'
+  gem 'rake'
+  gem 'rspec'
+  gem 'coveralls', require: false
 end

data/README.md

@@ -1,3 +1,11 @@
+
+[![Gem Version](https://img.shields.io/gem/v/functions.svg)](https://rubygems.org/gems/functions)
+[![Dependency Status](http://img.shields.io/gemnasium/koenhandekyn/functions.svg)](https://gemnasium.com/koenhandekyn/functions)
+[![Build Status](http://img.shields.io/travis/koenhandekyn/functions.svg)](https://travis-ci.org/koenhandekyn/functions)
+[![Code Climate](http://img.shields.io/codeclimate/github/koenhandekyn/functions.svg)](https://codeclimate.com/github/koenhandekyn/functions)
+[![Coverage Status](https://img.shields.io/coveralls/koenhandekyn/functions.svg)](https://coveralls.io/r/koenhandekyn/functions)
+
+
 # Functional
 
 This library facilitates writing code in a more functional style inside Ruby. 

data/Rakefile

@@ -1,8 +1,22 @@
-require "bundler/gem_tasks"
-require 'rake/testtask'
+# require "bundler/gem_tasks"
+# require 'rake/testtask'
 
-Rake::TestTask.new do |t|
-  t.libs << "test" << "."
-  t.test_files = FileList['test/test*.rb']
-  t.verbose = false
+# Rake::TestTask.new do |t|
+#   t.libs << "test" << "."
+#   t.test_files = FileList['test/test*.rb']
+#   t.verbose = false
+# end
+
+require 'rspec/core/rake_task'
+
+desc 'run the basic specs'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.rspec_opts = ['--options', 'spec/rspec.opts']
 end
+
+desc 'do some basic performance tests'
+task :performance do
+  load 'performance/prelude_performance.rb'
+end
+
+task default: [:spec, :performance]

data/examples/Gemfile

@@ -0,0 +1,6 @@
+gem 'functions', path: '..'
+
+group :test do
+  gem 'rake'
+  gem 'rspec'
+end

data/examples/Rakefile

@@ -0,0 +1,22 @@
+# require "bundler/gem_tasks"
+# require 'rake/testtask'
+
+# Rake::TestTask.new do |t|
+#   t.libs << "test" << "."
+#   t.test_files = FileList['test/test*.rb']
+#   t.verbose = false
+# end
+
+require 'rspec/core/rake_task'
+
+desc 'run the example specs'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.rspec_opts = ['--options', 'spec/rspec.opts']
+end
+
+desc 'run the examples'
+task :examples do
+  load 'prelude_lambda.rb'
+end
+
+task default: [:spec, :examples]

data/examples/prelude_lambda.rb

@@ -7,14 +7,14 @@ module PreludeLambdaUsage
   Power = ->(p,x) { x**p }.curry
   Square = Power.(2)
   Squares = Map.(Square)
-  Sum_Of_Squares1 = Compose.(Sum).(Squares)
-  Sum_Of_Squares2 = Sum < Squares
-  Sum_Of_Squares = Sum_Of_Squares2
+  SumOfSquares1 = Compose.(Sum).(Squares)
+  SumOfSquares2 = Sum < Squares
+  SumOfSquares = SumOfSquares2
 
-  Inc_With = ->(f, n, m) { n + f.(m) }.curry
-  Sum_Of1 = ->(f,arr) { Foldl.( Inc_With.(f), 0, arr) }.curry
-  Sum_Of2 = ->(f) { ->(arr) { Foldl.( Inc_With.(f), 0, arr) } }
-  Sum_Of = Sum_Of1
+  IncWith = ->(f, n, m) { n + f.(m) }.curry
+  SumOf1 = ->(f,arr) { Foldl.( IncWith.(f), 0, arr) }.curry
+  SumOf2 = ->(f) { ->(arr) { Foldl.( IncWith.(f), 0, arr) } }
+  SumOf = SumOf1
 
   # Average variations
   Average1 = After.( Parallel.(Sum).(Length) ).( Divide )
@@ -22,9 +22,7 @@ module PreludeLambdaUsage
   Average3 = After.( [Sum,Length] ).( Divide )
 
   # Gcd variations
-  Gcd1 = ->(a, b) {
-    (1..[a,b].min).select { |c| a % c == 0 && b % c == 0 }.max
-  }
+  Gcd1 = ->(a, b) { (1..[a,b].min).select { |c| a % c == 0 && b % c == 0 }.max }
   Gcd2 = ->(a,b) { (Divisors.(a) & Divisors.(b)).max }
 
   # GcdA variations
@@ -37,7 +35,6 @@ module PreludeLambdaUsage
   Dividers = Map.(Divisors)
   GcdA4 = Greatest < Common < Dividers
 
-
   # LcmA variations
   LcmA1 = ->(arr) { arr.inject { |a, r| Lcm.(a, r) } } # the lcm of an array as an iteration of the lcm over the elements
   LcmA2 = ReduceLeft.(Lcm) # the same but without arguments

data/examples/spec/prelude_lambda_spec.rb

@@ -5,37 +5,37 @@ include PreludeLambdaUsage
 describe PreludeLambdaUsage, "basic lambda prelude usage" do
 
   it "sums" do
-    Sum_Of_Squares.([2, 3, 4]).should == 2*2+3*3+4*4
-    Sum_Of.(Square).([2, 3, 1]).should == 2*2+3*3+1*1
+    expect(SumOfSquares.([2, 3, 4])).to eq(2*2+3*3+4*4)
+    expect(SumOf.(Square).([2, 3, 1])).to eq(2*2+3*3+1*1)
   end
 
   it "averages" do
-    Average.([2, 3, 8]).should == 4
+    expect(Average.([2, 3, 8])).to eq(4)
   end
 
   it "flattens" do
-    Flatten.([[1, 2, 3], [2, 3]]).should == [1, 2, 3, 2, 3]
+    expect(Flatten.([[1, 2, 3], [2, 3]])).to eq([1, 2, 3, 2, 3])
   end
 
   it "folds" do
-    Foldl.(->(n, a) { n/a }, 1.0, [1.0, 2.0, 3.0]).should == 1.0/1.0/2.0/3.0
-    Foldr.(->(n, a) { n/a }, 1.0, [1.0, 2.0, 3.0]).should == 1.0/3.0/2.0/1.0
+    expect(Foldl.(->(n, a) { n/a }, 1.0, [1.0, 2.0, 3.0])).to eq(1.0/1.0/2.0/3.0)
+    expect(Foldr.(->(n, a) { n/a }, 1.0, [1.0, 2.0, 3.0])).to eq(1.0/3.0/2.0/1.0)
   end
 
   it "knows about GCD alternatives" do
     # test variant implementations
-    Gcd1.(4,8).should == 4
-    Gcd2.(4,8).should == 4
-    GcdA1.([4,8,2]).should eq(2)
-    GcdA2.([4,8,2]).should eq(2)
-    GcdA3.([4,8,2]).should eq(2)
-    GcdA4.([4,8,2]).should eq(2)
+    expect(Gcd1.(4,8)).to eq(4)
+    expect(Gcd2.(4,8)).to eq(4)
+    expect(GcdA1.([4,8,2])).to eq(2)
+    expect(GcdA2.([4,8,2])).to eq(2)
+    expect(GcdA3.([4,8,2])).to eq(2)
+    expect(GcdA4.([4,8,2])).to eq(2)
   end
 
   it "knows about LCM variations" do
     # test variant implementations
-    LcmA1.([12,9,2]).should eq(36)
-    LcmA2.([12,9,2]).should eq(36)
+    expect(LcmA1.([12,9,2])).to eq(36)
+    expect(LcmA2.([12,9,2])).to eq(36)
   end
 
 

data/functions.gemspec

@@ -8,10 +8,10 @@ Gem::Specification.new do |gem|
   gem.version       = Functions::VERSION
   gem.authors       = ["Koen Handekyn"]
   gem.email         = ["koen.handekyn@up-nxt.com"]
-  gem.description   = %q{functional programming in ruby}
+  gem.description   = %q{A prelude library that belongs to the book "functional programming in ruby".}
   gem.summary       = %q{functional programming in ruby}
   gem.homepage      = "https://github.com/koenhandekyn/functions"
-  gem.license       = 'AGPL'
+  gem.license       = 'LGPL-3.0+'
   gem.files         = `git ls-files`.split($/)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})

data/lib/functions/prelude_enumerable/hash.rb

@@ -16,13 +16,6 @@ class Hash
     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] }]
@@ -32,21 +25,6 @@ class Hash
     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) } ]
@@ -54,8 +32,8 @@ class Hash
 
   # 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) } ]
+  def map_recurse(&b)
+    Hash[ self.map{|k, v| b.(k, v.is_a?(Hash) ? v.map_recurse(&b) : v) } ]
   end
 
   # map a hash into a hash recursively with a seperate key mapping and value mapping function
@@ -68,14 +46,6 @@ class Hash
     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/prelude_lambda/basic.rb

@@ -8,15 +8,18 @@ module Functions
     # the constant function
     Const = ->(c, x) { c }
 
+    # make a function resilient to nil inputs
+    Maybe = ->(fn) { ->(x) { fn.(x) unless x.nil? } }
+
     # splits a list xs in peices of size n
-    Split_In = ->(n, xs) { xs.each_slice((xs.length+1)/n).to_a }
+    SplitIn = ->(n, xs) { xs.each_slice((xs.length+1)/n).to_a }
 
     # splits a list in half
-    Split_In_Half = Split_In.curry.(2)
+    SplitInHalf = SplitIn.curry.(2)
 
     # merges two ordered lists by a function f that compares the values
     # if no function is given the values are compared by the "<" operator
-    Merge_By = ->(f, xs, ys) do
+    MergeBy = ->(f, xs, ys) do
 
       return xs if ys.empty?
       return ys if xs.empty?
@@ -24,13 +27,13 @@ module Functions
       x, *xt = xs
       y, *yt = ys
 
-      return Merge_By.(f, xt, ys) >> x if f.nil? ? x <= y : f.(x) <= f.(y)
-      return Merge_By.(f, xs, yt) >> y
+      return MergeBy.(f, xt, ys) >> x if f.nil? ? x <= y : f.(x) <= f.(y)
+      return MergeBy.(f, xs, yt) >> y
 
     end
 
     # merges two list by the natural comparison operator <
-    Merge = Merge_By.partial(nil)
+    Merge = MergeBy.partial(nil)
 
     # composes two functions
     Compose = ->(f, g, x) { f.(g.(x)) }.curry
@@ -38,6 +41,8 @@ module Functions
     # manually curried version of the Compose function
     ComposeCurried = ->(f) { ->(g) { ->(x) { f.(g.(x)) } } }
 
+    Chain = ->(*fns) { fns.reduce { |f, g| lambda { |x| f.(g.(x)) } } }
+
     # composes two functions in reverse sequence
     After = ->(f, g, x) {
       f = Par.(f) if Array === f;
@@ -81,17 +86,17 @@ module Functions
 
     Zip = ->(a, b) { a.zip(b) }.curry
 
-    Merge_Hash = ->(as, bs) { as.merge(bs) { |k, a, b| [a, b] } }.curry
+    MergeHash = ->(as, bs) { as.merge(bs) { |k, a, b| [a, b] } }.curry
 
-    Zip_Hash_Left = ->(as, bs) { as.each_with_object({}) { |(k, a), h| h[k] = [a, bs[k]]; h } }.curry
+    ZipHashLeft = ->(as, bs) { as.each_with_object({}) { |(k, a), h| h[k] = [a, bs[k]]; h } }.curry
 
-    Zip_Hash_Inner = ->(as, bs) { as.each_with_object({}) { |(k, a), h| b = bs[k]; h[k] = [a, b] if b; h } }.curry
+    ZipHashInner = ->(as, bs) { as.each_with_object({}) { |(k, a), h| b = bs[k]; h[k] = [a, b] if b; h } }.curry
 
-    Zip_Hash_Right = ->(as, bs) { bs.each_with_object({}) { |(k, b), h| h[k] = [as[k], b]; h } }.curry
+    ZipHashRight = ->(as, bs) { bs.each_with_object({}) { |(k, b), h| h[k] = [as[k], b]; h } }.curry
 
     Map = ->(f, a) { a.map { |x| f.(x) } }.curry
 
-    Map_Hash = ->(f, h) { Hash[h.map{|k, v| [k, f.(v)] }] }.curry     
+    MapHash = ->(f, h) { Hash[h.map{|k, v| [k, f.(v)] }] }.curry
 
     Filter = ->(f, xs) { xs.select { |x| f.(x) } }.curry
 
@@ -101,23 +106,23 @@ module Functions
 
     Intersect = ->(as) { as.inject(:&) }
 
-    Group = ->(f,a) { a.group_by(&f) }.curry 
+    Group = ->(f,a) { a.group_by(&f) }.curry
 
     Values = Send.(:values)
 
     # TODO investigate semantics
-    Partition = ->(f) { Group.(f) > Values } 
+    Partition = ->(f) { Group.(f) > Values }
 
     FromTo = ->(from) { ->(to) { Range.new(from, to) } }
 
     FromOneTo = FromTo.(1)
 
-    Count_By = ->(f,a) { a.inject( Hash.new(0) ) { |h,e| h[f.(e)] += 1; h } }.curry
-    # count_by = ->(f) { group_by.( f ) < map_hash.( send.(:length) ) }    
-    
-    Count = ->(a) { a.inject( Hash.new(0) ) { |h,e| h[e] += 1; h } } # probably a bit faster   
+    CountBy = ->(f,a) { a.inject( Hash.new(0) ) { |h,e| h[f.(e)] += 1; h } }.curry
+    # count_by = ->(f) { group_by.( f ) < map_hash.( send.(:length) ) }
+
+    Count = ->(a) { a.inject( Hash.new(0) ) { |h,e| h[e] += 1; h } } # probably a bit faster
     # count = count_by.(identity) # alternative definition (generic)
 
   end
 
-end
+end

data/lib/functions/prelude_lambda/sorting.rb

@@ -2,18 +2,18 @@ module Functions
 
   module Prelude
 
-    Merge_Sort_By = ->(f, xs) do
+    MergeSortBy = ->(f, xs) do
 
       return xs if xs.length <= 1 # stopcondition
       
-      left, right = Split_In_Half.(xs)
-      Merge_By.(f, Merge_Sort_By.(f, left), Merge_Sort_By.(f, right))
+      left, right = SplitInHalf.(xs)
+      MergeBy.(f, MergeSortBy.(f, left), MergeSortBy.(f, right))
     end
 
-    Merge_Sort = Merge_Sort_By.partial(nil)
+    MergeSort = MergeSortBy.partial(nil)
     # = Merge_Sort_By.partial(Identity)
 
-    Quick_Sort_By = ->(f, list) do
+    QuickSortBy = ->(f, list) do
       
       return [] if list.size == 0
       return list if list.size == 1
@@ -21,10 +21,10 @@ module Functions
       pivot, *xs = *list
       smaller_than = f.nil? ? ->(y) { y < pivot } : ->(y) { f.(y) < f.(pivot) }
       less, more = xs.partition &smaller_than
-      Quick_Sort_By.(f, less) + [pivot] + Quick_Sort_By.(f, more)
+      QuickSortBy.(f, less) + [pivot] + QuickSortBy.(f, more)
     end
 
-    Quick_Sort = Quick_Sort_By.partial(nil)
+    QuickSort = QuickSortBy.partial(nil)
     # = Quick_Sort_By.partial(Identity)
 
   end

data/lib/functions/version.rb

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

data/performance/prelude_performance.rb

@@ -8,7 +8,7 @@ include PreludeLambdaUsage
 
 [10, 100, 1000, 10000].each do |n|
   Benchmark.bm(40) do |b|
-    b.report("Sum_Of_Squares(n=#{n}): ") { (100000/n).times { Sum_Of_Squares.((1..n).to_a) } }
+    b.report("Sum_Of_Squares(n=#{n}): ") { (100000/n).times { SumOfSquares.((1..n).to_a) } }
   end
 end
 
@@ -27,14 +27,14 @@ end
 [10, 100, 1000].each do |n|
   random_array = (0..n).to_a.shuffle
   Benchmark.bm(40) do |b|
-    b.report("Merge_Sort(n=#{n}): ") { (100000/n).times { Merge_Sort.(random_array) } }
+    b.report("Merge_Sort(n=#{n}): ") { (100000/n).times { MergeSort.(random_array) } }
   end
 end
 
 [10, 100, 1000].each do |n|
   random_array = (0..n).to_a.shuffle
   Benchmark.bm(40) do |b|
-    b.report("Quick_Sort(n=#{n}): ") { (100000/n).times { Quick_Sort.(random_array) } }
-    b.report("Quick_Sort/identity(n=#{n}): ") { (100000/n).times { Quick_Sort_By.(Id, random_array) } }
+    b.report("Quick_Sort(n=#{n}): ") { (100000/n).times { QuickSort.(random_array) } }
+    b.report("Quick_Sort/identity(n=#{n}): ") { (100000/n).times { QuickSortBy.(Id, random_array) } }
   end
 end

data/spec/prelude_enumerable_spec.rb

@@ -1,131 +1,131 @@
-require 'functions/prelude_enumerable'
+require 'spec_helper'
 
 describe "enumerable" do
 
   it "zip_map" do
-    [1,2,3].zip([2,3,4]).map { |a,b| a+b }.should eq([3,5,7])
-    [1,2,3].zip_map([2,3,4]) { |a,b| a+b }.should eq([3,5,7])
-    [1,2,3].zip_map([2,3,4],[0,1,0]) { |a,b,c| a+b+c }.should eq([3,6,7])
-    [1,2,3].zip_map([2,3,4]).with_index { |(a,b),n| a+b+n }.should eq([3,6,9])
+    expect([1,2,3].zip([2,3,4]).map { |a,b| a+b }).to eq([3,5,7])
+    expect([1,2,3].zip_map([2,3,4]) { |a,b| a+b }).to eq([3,5,7])
+    expect([1,2,3].zip_map([2,3,4],[0,1,0]) { |a,b,c| a+b+c }).to eq([3,6,7])
+    expect([1,2,3].zip_map([2,3,4]).with_index { |(a,b),n| a+b+n }).to eq([3,6,9])
   end
 
   it "transpose" do
-    [[1,2,3]].transpose.should eq([[1],[2],[3]])
-    [[1,2,3],[:a,:b,:c]].transpose.should eq([[1,:a],[2,:b],[3,:c]])
+    expect([[1,2,3]].transpose).to eq([[1],[2],[3]])
+    expect([[1,2,3],[:a,:b,:c]].transpose).to eq([[1,:a],[2,:b],[3,:c]])
   end
 
   it "zip, unzip" do
     ns = [1,2,3]
     as = [:a,:b,:c]
-    ns.zip(as).unzip.should eq([ns, as])
+    expect(ns.zip(as).unzip).to eq([ns, as])
   end
 
   it "split_in" do
-    [1,2,3].split_in(1).should eq([[1,2,3]])
-    [1,2,3].split_in(2).should eq([[1,2],[3]])
-    [1,2,3].split_in(3).should eq([[1],[2],[3]])
-    [1,2,3].split_in(4).should eq([[1],[2],[3],[]]) # do we want this ? length 3 ? or lenght 4 ?
-    [1,2,3].split_in_half.should eq([[1,2],[3]])
+    expect([1,2,3].split_in(1)).to eq([[1,2,3]])
+    expect([1,2,3].split_in(2)).to eq([[1,2],[3]])
+    expect([1,2,3].split_in(3)).to eq([[1],[2],[3]])
+    expect([1,2,3].split_in(4)).to eq([[1],[2],[3],[]]) # do we want this ? length 3 ? or lenght 4 ?
+    expect([1,2,3].split_in_half).to eq([[1,2],[3]])
   end
 
   it "merge" do
     # starts with ordered sets
-    [1,3,5].merge([3,4,8]).should eq([1,3,3,4,5,8])
-    [1,3,5].merge([2]).should eq([1,2,3,5])
-    [].merge([1,2,3]).should eq([1,2,3])
-    [1,2,3].merge([]).should eq([1,2,3])
-    [3,2,1].merge([4,2,1]) { |a,b| a > b }.should eq([4,3,2,2,1,1])
+    expect([1,3,5].merge([3,4,8])).to eq([1,3,3,4,5,8])
+    expect([1,3,5].merge([2])).to eq([1,2,3,5])
+    expect([].merge([1,2,3])).to eq([1,2,3])
+    expect([1,2,3].merge([])).to eq([1,2,3])
+    expect([3,2,1].merge([4,2,1]) { |a,b| a > b }).to eq([4,3,2,2,1,1])
   end
 
   it "interleave" do
-    %w(sex druggs rock roll).interleave([", "," and "," & "]).join("").should eq("sex, druggs and rock & roll")
-    [3,1,4].interleave([:a,:d,:b]).should eq([3,:a,1,:d,4,:b])
-    [3,1,4].interleave([:a,:d]).should eq([3,:a,1,:d,4])
-    [3,1,4].interleave([:a]).should eq([3,:a,1,4])
-    [3,1,4].interleave([]).should eq([3,1,4])
+    expect(%w(sex druggs rock roll).interleave([", "," and "," & "]).join("")).to eq("sex, druggs and rock & roll")
+    expect([3,1,4].interleave([:a,:d,:b])).to eq([3,:a,1,:d,4,:b])
+    expect([3,1,4].interleave([:a,:d])).to eq([3,:a,1,:d,4])
+    expect([3,1,4].interleave([:a])).to eq([3,:a,1,4])
+    expect([3,1,4].interleave([])).to eq([3,1,4])
   end
 
   it "zip_hash" do
     ab = {a: 'a', b: 'b'}
     ad = {a: 'a', d: 'd'}
     cb = {c: 'c', b: 'b'}
-    ab.zip_hash_left(ad).should eq({a: ['a','a'], b:['b',nil]})
-    ab.zip_hash_left(cb).should eq({a: ['a',nil], b:['b','b']})
-    ad.zip_hash_left(cb).should eq({a: ['a',nil], d:['d',nil]})
-    ab.zip_hash_inner(ad).should eq({a:['a','a']})
-    ab.zip_hash_inner(cb).should eq({b:['b','b']})
-    ad.zip_hash_inner(cb).should eq({})
+    expect(ab.zip_hash_left(ad)).to eq({a: ['a','a'], b:['b',nil]})
+    expect(ab.zip_hash_left(cb)).to eq({a: ['a',nil], b:['b','b']})
+    expect(ad.zip_hash_left(cb)).to eq({a: ['a',nil], d:['d',nil]})
+    expect(ab.zip_hash_inner(ad)).to eq({a:['a','a']})
+    expect(ab.zip_hash_inner(cb)).to eq({b:['b','b']})
+    expect(ad.zip_hash_inner(cb)).to 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}
+    expect(ab.map_values { |x| x*2}).to eq({a: 2, b: 4})
+    expect(ab.map_values { |x| x.even? }).to eq({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}}
+    expect(abcde.map_values_recurse { |x| x*2}).to eq({a: 2, b: 4, c: { d: 2, e: 0}})
+    expect(abcde.map_values_recurse { |x| x.even? }).to eq({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 }
+    expect(ab.map_keys { |k| k.to_s }).to eq({"a" => 1, "b" => 2})
+    expect(ab.map_keys { |k| k.to_s[0].ord }).to eq({ 97 => 1, 98 => 2 })
+    expect(ab.map_keys { |k| k.to_s.length }).to eq({ 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 }}
+    expect(abcde.map_keys_recurse { |k| k.to_s }).to eq({"a" => 1, "b" => 2, "c" => { "d" => 1, "e" => 0 }})
   end
 
   it "map_hash" do
     ab = {a: 1, b: 2}
-    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}
+    expect(ab.map_hash { |k,v| [k.to_s, v*2] }).to eq({"a" => 2, "b" => 4})
+    expect(ab.map_hash { |k,v| [k.to_s[0].ord, v.even?] }).to eq({97 => false, 98 => true})
+    expect(ab.map_hash { |k,v| [k.to_s.length, v.even?] }).to eq({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 } }
+    expect(abcde.map_recurse { |k,v| v.is_a?(Hash) ? [k.to_s, v] : [k.to_s, v*2] }).to eq({"a" => 2, "b" => 4, "c" => { "d" => 2, "e" => 0 }})
+    expect(abcde.map_recurse { |k,v| v.is_a?(Hash) ? [k.to_s[0].ord, v] : [k.to_s[0].ord, v.even?] }).to eq({97 => false, 98 => true, 99 => { 100 => false, 101 => true }})
+    expect(abcde.map_recurse { |k,v| v.is_a?(Hash) ? [k.to_s.length, v] : [k.to_s.length, v.even?] }).to eq({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 } }
+    expect(abcde.map_keys_and_values(s, times_2)).to eq({"a" => 2, "b" => 4, "c" => { "d" => 2, "e" => 0 }})
+    expect(abcde.map_keys_and_values(s_ord, even)).to eq({97 => false, 98 => true, 99 => { 100 => false, 101 => true }})
+    expect(abcde.map_keys_and_values(s_length, even)).to eq({1 => { 1=>true } })
 
   end
 
   it "counted_set" do
-    [1,2,3,2,2,1,2].counted_set.should eq({1 => 2, 2 => 4, 3 => 1})
-    ['a','b','a','d'].counted_set.should eq({'a' => 2, 'b' => 1, 'd' => 1})
+    expect([1,2,3,2,2,1,2].counted_set).to eq({1 => 2, 2 => 4, 3 => 1})
+    expect(['a','b','a','d'].counted_set).to eq({'a' => 2, 'b' => 1, 'd' => 1})
   end
 
   it "grouped_by" do
-    [1,2,3,2,2,1,2].grouped_by { |x| x.odd? }.should eq([[1,3,1],[2,2,2,2]])
-    %w(some words are longer then others).grouped_by { |x| x.length > 3 }.should eq([%w(some words longer then others),%w(are)])
+    expect([1,2,3,2,2,1,2].grouped_by { |x| x.odd? }).to eq([[1,3,1],[2,2,2,2]])
+    expect(%w(some words are longer then others).grouped_by { |x| x.length > 3 }).to eq([%w(some words longer then others),%w(are)])
   end
 
-  it "multimap" do
+  it "multi_map" do
 
     folders = { 'main[2]' => { 'child[3]' => 'leaf', 'simple' => 'leaf' } }
 
-    multiply_folder = -> (k,v) do
+    multiply_folder = ->(k,v) do
       match = k.match(/(.*)\[(\d+)\]/)
       k, count = match ? [match[1], match[2].to_i] : [k, nil]
       if count
@@ -136,8 +136,8 @@ describe "enumerable" do
     end
 
     multiplied = folders.multi_map &multiply_folder
-    multiplied.length.should eq(2)
-    multiplied['main_1'].length.should eq(4)
+    expect(multiplied.length).to eq(2)
+    expect(multiplied['main_1'].length).to eq(4)
 
   end
-end
+end

data/spec/prelude_lambda_math_spec.rb

@@ -1,44 +1,42 @@
-require 'functions'
-
-include Functions::Prelude
+require 'spec_helper'
 
 describe Functions::Prelude, "math" do
 
   it "divides" do
-    Divide.([9,2]).should eq(9/2)
-    Divide.([8,2,2]).should eq(8/2/2)
+    expect(Divide.([9,2])).to eq(9/2)
+    expect(Divide.([8,2,2])).to eq(8/2/2)
   end
 
   it "power" do
-    Power.(2,3).should eq(9)
-    Power.(0,3).should eq(1)
-    Power.(3,2).should eq(8)
+    expect(Power.(2,3)).to eq(9)
+    expect(Power.(0,3)).to eq(1)
+    expect(Power.(3,2)).to eq(8)
   end
 
   it "knows about divisors" do
-    IsDivisor.(8,2).should eq(true)
-    IsDivisor.(8,3).should eq(false)
-    Divisors.(12).sort.should eq([1,2,3,4,6,12])
+    expect(IsDivisor.(8,2)).to eq(true)
+    expect(IsDivisor.(8,3)).to eq(false)
+    expect(Divisors.(12).sort).to eq([1,2,3,4,6,12])
   end
 
   it "knows about range building" do
-    FromOneTo.(3).should eq(1..3)
-    FromOneTo.(3).to_a.should eq([1,2,3])
-    FromTo.(2).(8).to_a.should eq([2,3,4,5,6,7,8])
+    expect(FromOneTo.(3)).to eq(1..3)
+    expect(FromOneTo.(3).to_a).to eq([1,2,3])
+    expect(FromTo.(2).(8).to_a).to eq([2,3,4,5,6,7,8])
   end
 
   it "knows about gcd" do
-    Gcd.(12,9).should eq(3)
-    Gcd.(4,8).should eq(4)
-    GcdA.([12,9,6]).should eq(3)
-    GcdA.([4,8,2]).should eq(2)
+    expect(Gcd.(12,9)).to eq(3)
+    expect(Gcd.(4,8)).to eq(4)
+    expect(GcdA.([12,9,6])).to eq(3)
+    expect(GcdA.([4,8,2])).to eq(2)
   end
 
   it "knows about lcm" do
-    Lcm.(12,9).should eq(36)
-    Lcm.(6,8).should eq(24)
-    LcmA.([12,9]).should eq(36)
-    LcmA.([12,9,2]).should eq(36)
+    expect(Lcm.(12,9)).to eq(36)
+    expect(Lcm.(6,8)).to eq(24)
+    expect(LcmA.([12,9])).to eq(36)
+    expect(LcmA.([12,9,2])).to eq(36)
   end
 
 end

data/spec/prelude_lambda_spec.rb

@@ -1,6 +1,4 @@
-require 'functions'
-
-include Functions::Prelude
+require 'spec_helper'
 
 describe Functions::Prelude, "basic" do
 
@@ -10,52 +8,52 @@ describe Functions::Prelude, "basic" do
 
   it "composes" do
     sum_of_squares = Compose.(Sum).(Squares)
-    sum_of_squares.([2, 3, 4]).should eq(4+9+16)
+    expect(sum_of_squares.([2, 3, 4])).to eq(4+9+16)
   end
 
   it "has a compose operator" do
     sum_of_squares = Sum < Squares
-    sum_of_squares.([2, 3, 4]).should eq(4+9+16)
+    expect(sum_of_squares.([2, 3, 4])).to eq(4+9+16)
   end
 
   it "folds" do
     inc_with = ->(f, n, m) { n + f.(m) }.curry
     sum_of = ->(f, arr) { Foldl.(inc_with.(f), 0, arr) }.curry
-    sum_of.(Square).([1,2,3]).should eq(1+4+9)
+    expect(sum_of.(Square).([1,2,3])).to eq(1+4+9)
   end
 
   it "composes using after with implicit parallel" do
     average = After.([Sum, Length]).(Divide)
-    average.([2, 3, 8]).should eq((2+3+8)/3)
+    expect(average.([2, 3, 8])).to eq((2+3+8)/3)
   end
 
   it "mixes parallel with after operator" do
     average = Parallel.(Sum, Length) > Divide
-    average.([2, 3, 8]).should eq((2+3+8)/3)
+    expect(average.([2, 3, 8])).to eq((2+3+8)/3)
   end
 
   it "mixes par with after operator" do
     average = Par.([Sum, Length]) > Divide
-    average.([2, 3, 8]).should eq((2+3+8)/3)
+    expect(average.([2, 3, 8])).to eq((2+3+8)/3)
   end
 
   it "flattens arrays" do
-    Flatten.([[1, 2, 3], [2, 3]]).should eq([1,2,3,2,3])
+    expect(Flatten.([[1, 2, 3], [2, 3]])).to eq([1,2,3,2,3])
   end
 
   it "sorts arrays" do
-    Quick_Sort.([3,3,5,6,7,1,2]).should == [1,2,3,3,5,6,7]
-    Quick_Sort.([1,1,1,1,1,1,1]).should == [1,1,1,1,1,1,1]
-    Merge_Sort.([3,3,5,6,7,1,2]).should == [1,2,3,3,5,6,7]
+    expect(QuickSort.([3,3,5,6,7,1,2])).to eq([1,2,3,3,5,6,7])
+    expect(QuickSort.([1,1,1,1,1,1,1])).to eq([1,1,1,1,1,1,1])
+    expect(MergeSort.([3,3,5,6,7,1,2])).to eq([1,2,3,3,5,6,7])
   end
 
   it "merges hashes" do
     a = { a: 'a', b: 'b' }
     b = { a: '1', c: '3' }
-    Merge_Hash.(a,b).should == { a: ['a','1'], b: 'b', c: '3' }
-    Zip_Hash_Left.(a,b).should == { a: ['a','1'], b: ['b', nil] } 
-    Zip_Hash_Right.(a,b).should == { a: ['a','1'], c: [nil, '3'] } 
-    Zip_Hash_Inner.(a,b).should == { a: ['a','1'] } 
+    expect(MergeHash.(a,b)).to eq({ a: ['a','1'], b: 'b', c: '3' })
+    expect(ZipHashLeft.(a,b)).to eq({ a: ['a','1'], b: ['b', nil] })
+    expect(ZipHashRight.(a,b)).to eq({ a: ['a','1'], c: [nil, '3'] })
+    expect(ZipHashInner.(a,b)).to eq({ a: ['a','1'] })
   end
 
-end
+end

data/spec/spec_helper.rb

@@ -1,13 +1,15 @@
-# This file was generated by the `rspec --init` command. Conventionally, all
-# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
-# Require this file using `require "spec_helper"` to ensure that it is only
-# loaded once.
-#
-# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+require 'coveralls'
+Coveralls.wear!
+
+require 'functions'
+
 RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
+
   config.run_all_when_everything_filtered = true
   config.filter_run :focus
+  config.raise_errors_for_deprecations!
+
+  include Functions::Prelude
 
   # Run specs in random order to surface order dependencies. If you find an
   # order dependency and want to debug it, you can fix the order by providing

data/test/test_prelude_performance.rb

@@ -1,4 +1,6 @@
-require 'examples/prelude_lambda'
+$LOAD_PATH << 'lib'
+
+require_relative '../examples/spec/prelude_lambda_spec'
 
 require 'minitest/autorun'
 require 'minitest/benchmark'

metadata

@@ -1,16 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: functions
 version: !ruby/object:Gem::Version
-  version: 0.0.16
+  version: 0.0.17
 platform: ruby
 authors:
 - Koen Handekyn
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-08 00:00:00.000000000 Z
+date: 2018-12-01 00:00:00.000000000 Z
 dependencies: []
-description: functional programming in ruby
+description: A prelude library that belongs to the book "functional programming in
+  ruby".
 email:
 - koen.handekyn@up-nxt.com
 executables: []
@@ -19,11 +20,13 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
-- examples/multi_hash_map_recursive.rb
+- examples/Gemfile
+- examples/Rakefile
 - examples/prelude_lambda.rb
 - examples/spec/prelude_lambda_spec.rb
 - functions.gemspec
@@ -47,7 +50,7 @@ files:
 - test/test_prelude_performance.rb
 homepage: https://github.com/koenhandekyn/functions
 licenses:
-- AGPL
+- LGPL-3.0+
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -65,7 +68,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.1
+rubygems_version: 2.7.3
 signing_key: 
 specification_version: 4
 summary: functional programming in ruby

data/examples/multi_hash_map_recursive.rb

@@ -1,19 +0,0 @@
-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