functions 0.0.12 → 0.0.14

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    N2Q2YWQzNDg3ZDc2MTRjMGZlNjhhOGUwYTM2MmYzMmEwZjBjN2JiMA==
-  data.tar.gz: !binary |-
-    ZmYzMDBlZjM2NTZhNmE4MDBjOWRlYjMxNmY3MWViMjFlMjc0OTE0MA==
+SHA1:
+  metadata.gz: c6dc48ecaa2924694dc2ca346aa3b085b6d61d0d
+  data.tar.gz: cc1476f81c7bc6857ffb5bc3ef39e1a64c2d0cbf
 SHA512:
-  metadata.gz: !binary |-
-    ZGJkYWJmOTIxNzE2MGVmZDllMjU5ZDY3ZDZlYjc0YWM2NDI2YThkOTUzZGMw
-    ZDg1NjZiN2Q1MjI0NmY2OTNhMmI2Zjc1ODI2NWFhYmQzMjZjM2VjMTQxMzZk
-    M2VjNDFjNTYwZDlmYTBkNzVjZTU5MDhhN2ExZWUzZTcxN2YzNjY=
-  data.tar.gz: !binary |-
-    NjEwOGRmMzc5ODRlODU3ZGE2ZGQ5NGRiMDE1ZWFhMGI2MTkwOGI5MDdjZTdl
-    NDhmOGJkNDJhOGU3NzRlZDA2ZDFjZGU4ZjFiN2M0OTdhZTA3NjBhZmUwMTUw
-    NzNlZDM1YzMzNDMwMGQxZDY5YzRkOTg1NTVjNTZkNjUxMWZiYmI=
+  metadata.gz: 396ed57977054e246c594530cd25b08c4cabb379464189ef06c6bfb9939045a282512526111e3a901cd7bb3f99af889d282498923e266fe19e1fb1ed08d1926f
+  data.tar.gz: 10a22bc2fdd3115fdabc7bed2312d1951d5bddc01b69d110f199bfccba2c31baab3bdc3e2748e2f958dc0fd2ec379a20eade9f5e33a3834e403693f3d73458cd

data/README.md

@@ -1,7 +1,6 @@
 # Functional
 
-This library facilitates writing code in a more functional style inside Ruby.
-How this is fun.
+This library facilitates writing code in a more functional style inside Ruby. 
 
 ## Installation
 
@@ -19,12 +18,6 @@ Or install it yourself as:
 
 ## Usage
 
-The library provides two different styles.
-One style builds on Lambda's and another style uses meta-programming.
-The lambda style is a bit more pure but is currently just a bit slower in performance.
-
-### Lambda Style
-
 The lambda style allows you to write functions like this
 
     require 'functions'
@@ -51,32 +44,6 @@ The lambda style allows you to write functions like this
 
     end
 
-### Meta Style
-
-The meta style allows you to write functions like this
-
-    require 'functions'
-
-    module PreludeMetaUsage
-
-      include Functions::PreludeMeta
-
-      def power(x, p) x ** p end
-
-      def square(x) power(x, 2) end
-
-      define :squares, as: { map: :square }
-
-      define :evens, as: { filter: :even? }
-
-      define :sum_of_squares_tris, as: { compose: [:sum, :squares] }
-
-      define :average, as: { :after => [ :sum_length, :divide ] }
-
-      define :sum, as: { foldl: [:add, 0]}
-
-    end
-
 ## License
 
 This code is currently copyrighted under the AGPL license.

data/functions.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |gem|
   gem.description   = %q{functional programming in ruby}
   gem.summary       = %q{functional programming in ruby}
   gem.homepage      = "https://github.com/koenhandekyn/functions"
-
+  gem.license       = 'MIT'
   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.rb

@@ -0,0 +1,2 @@
+require_relative 'prelude_enumerable/enumerable'
+require_relative 'prelude_enumerable/hash'

data/lib/functions/prelude_enumerable/enumerable.rb

@@ -0,0 +1,47 @@
+module Enumerable
+
+  def zip_map *lists, &b
+    self.zip(*lists).map(&b)
+  end
+
+  def unzip
+    self.transpose
+  end
+
+  # splits a list xs in n peices
+  def split_in(n) 
+    (split = self.each_slice((self.length+1)/n).to_a).concat [[]] * (n-split.length)
+  end
+
+  def split_in_half 
+    split_in(2)
+  end
+
+  def counted_set 
+    self.inject( Hash.new(0) ) { |h,e| h[e] += 1; h } 
+  end
+
+  def grouped_by &f
+    self.group_by(&f).values
+  end
+
+  def interleave ys
+    self.zip(ys).flatten.compact
+  end
+
+  # merges two ordered lists by a function f that compares the values
+  # if no function is given the values are compared by the "<" operator
+  def merge ys, &f
+
+    return self.dup if ys.empty?
+    return ys.dup if self.empty?
+
+    x, *xt = self
+    y, *yt = ys
+
+    return ys.merge(xt, &f) >> x if ( f.nil? ? x < y : f.(x,y) )
+    return self.merge(yt, &f) >> y
+
+  end
+
+end

data/lib/functions/prelude_enumerable/hash.rb

@@ -0,0 +1,15 @@
+class Hash
+
+  def zip_hash_left(bs)
+    self.each_with_object({}) { |(k, a), h| h[k] = [a, bs[k]]; h }
+  end
+
+  def zip_hash_inner(bs)
+    self.each_with_object({}) { |(k, a), h| b = bs[k]; h[k] = [a, b] if b; h }
+  end
+
+  def map_hash 
+    Hash[self.map{|k, v| [k, yield(v)] }]
+  end
+
+end

data/lib/functions/prelude_lambda/basic.rb

@@ -14,7 +14,7 @@ module Functions
     # splits a list in half
     Split_In_Half = Split_In.curry.(2)
 
-    # merges two lists by a function f that compares the values
+    # 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
 
@@ -105,6 +105,7 @@ module Functions
 
     Values = Send.(:values)
 
+    # TODO investigate semantics
     Partition = ->(f) { Group.(f) > Values } 
 
     FromTo = ->(from) { ->(to) { Range.new(from, to) } }

data/lib/functions/prelude_lambda/math.rb

@@ -14,6 +14,8 @@ module Functions
 
     Average = Parallel.(Sum,Length) > Divide
 
+    Power = ->(p,x) { x**p }.curry
+
     IsDivisor = ->(a, c) { a % c == 0 }
 
     Divisors = ->(a) { Filter.(IsDivisor.partial(a), FromOneTo.(a)) }

data/lib/functions/prelude_lambda/sorting.rb

@@ -5,17 +5,19 @@ module Functions
     Merge_Sort_By = ->(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))
-
     end
 
     Merge_Sort = Merge_Sort_By.partial(nil)
+    # = Merge_Sort_By.partial(Identity)
 
     Quick_Sort_By = ->(f, list) do
+      
       return [] if list.size == 0
       return list if list.size == 1
+      
       pivot, *xs = *list
       smaller_than = f.nil? ? ->(y) { y < pivot } : ->(y) { f.(y) < f.(pivot) }
       less, more = xs.partition &smaller_than
@@ -23,6 +25,7 @@ module Functions
     end
 
     Quick_Sort = Quick_Sort_By.partial(nil)
+    # = Quick_Sort_By.partial(Identity)
 
   end
 end

data/lib/functions/version.rb

@@ -1,3 +1,3 @@
 module Functions
-  VERSION = "0.0.12"
+  VERSION = "0.0.14"
 end

data/{lib/functions/prelude_meta.rb → meta/meta_programming.rb}

@@ -298,4 +298,3 @@ module Functions
 
 end
 
-

data/performance/prelude_performance.rb

@@ -1,49 +1,39 @@
-require_relative '../examples/prelude_usage'
-require_relative '../examples/prelude_meta_usage'
+require_relative '../examples/prelude_lambda'
 
-include PreludeUsage
-include PreludeUsageWithDefs
+include PreludeLambdaUsage
+# include PreludeUsageWithDefs
 
 require 'benchmark'
 
 [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 { sum_of_squares ((1..n).to_a) } }
   end
 end
 
 [10, 100, 1000, 10000].each do |n|
   Benchmark.bm(40) do |b|
     b.report("Average(n=#{n}): ") { (100000/n).times { Average.((1..n).to_a) } }
-    b.report("average(n=#{n}): ") { (100000/n).times { average ((1..n).to_a) } }
   end
 end
 
 [10, 100, 1000, 10000].each do |n|
   Benchmark.bm(40) do |b|
     b.report("Sum.(n=#{n}): ") { (100000/n).times { Sum.((1..n).to_a) } }
-    b.report("sum(n=#{n}): ") { (100000/n).times { sum((1..n).to_a) } }
-    b.report("sum_bis(n=#{n}): ") { (100000/n).times { sum_bis((1..n).to_a) } }
-    b.report("sum_tris(n=#{n}): ") { (100000/n).times { sum_tris((1..n).to_a) } }
-    b.report("sum_quater(n=#{n}): ") { (100000/n).times { sum_quater((1..n).to_a) } }
   end
 end
 
 [10, 100, 1000].each do |n|
   random_array = (0..n).to_a.shuffle
   Benchmark.bm(40) do |b|
-    b.report("lambda/merge_sort(n=#{n}): ") { (100000/n).times { Merge_Sort.(random_array) } }
-    b.report("def/merge_sort(n=#{n}): ") { (100000/n).times { merge_sort(random_array) } }
+    b.report("Merge_Sort(n=#{n}): ") { (100000/n).times { Merge_Sort.(random_array) } }
   end
 end
 
 [10, 100, 1000].each do |n|
   random_array = (0..n).to_a.shuffle
   Benchmark.bm(40) do |b|
-    b.report("lambda/quick_sort(n=#{n}): ") { (100000/n).times { Quick_Sort.(random_array) } }
-    # b.report("lambda/quick_sort/nil(n=#{n}): ") { (100000/n).times { Quick_Sort_By.(nil, random_array) } } # the same by definition
-    b.report("lambda/quick_sort/identity(n=#{n}): ") { (100000/n).times { Quick_Sort_By.(Id, random_array) } }
-    b.report("def/quick_sort(n=#{n}): ") { (100000/n).times { quick_sort(random_array) } }
+    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) } }
   end
 end

data/spec/prelude_enumerable_spec.rb

@@ -0,0 +1,76 @@
+require 'functions/prelude_enumerable'
+
+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])
+  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]])
+  end
+
+  it "zip, unzip" do
+    ns = [1,2,3]
+    as = [:a,:b,:c]
+    ns.zip(as).unzip.should 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]])
+  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])
+  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])
+  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({})
+  end
+
+  it "map_hash" do
+    ab = {a: 1, b: 2}
+    ab.map_hash { |x| x*2}.should eq({a: 2, b: 4})
+    ab.map_hash { |x| x.even? }.should eq({a: false, b: 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})
+  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)])
+  end
+
+end

data/spec/prelude_lambda_math_spec.rb

@@ -9,6 +9,12 @@ describe Functions::Prelude, "math" do
     Divide.([8,2,2]).should 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)
+  end
+
   it "knows about divisors" do
     IsDivisor.(8,2).should eq(true)
     IsDivisor.(8,3).should eq(false)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: functions
 version: !ruby/object:Gem::Version
-  version: 0.0.12
+  version: 0.0.14
 platform: ruby
 authors:
 - Koen Handekyn
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-21 00:00:00.000000000 Z
+date: 2013-11-01 00:00:00.000000000 Z
 dependencies: []
 description: functional programming in ruby
 email:
@@ -24,27 +24,29 @@ files:
 - README.md
 - Rakefile
 - examples/prelude_lambda.rb
-- examples/prelude_meta.rb
 - examples/spec/prelude_lambda_spec.rb
-- examples/spec/prelude_meta_spec.rb
 - functions.gemspec
 - lib/functions.rb
+- lib/functions/prelude_enumerable.rb
+- lib/functions/prelude_enumerable/enumerable.rb
+- lib/functions/prelude_enumerable/hash.rb
 - lib/functions/prelude_lambda.rb
 - lib/functions/prelude_lambda/basic.rb
 - lib/functions/prelude_lambda/ext.rb
 - lib/functions/prelude_lambda/math.rb
 - lib/functions/prelude_lambda/sorting.rb
-- lib/functions/prelude_meta.rb
 - lib/functions/shared/ext.rb
 - lib/functions/version.rb
+- meta/meta_programming.rb
 - performance/prelude_performance.rb
+- spec/prelude_enumerable_spec.rb
 - spec/prelude_lambda_math_spec.rb
 - spec/prelude_lambda_spec.rb
-- spec/prelude_meta_spec.rb
 - spec/spec_helper.rb
 - test/test_prelude_performance.rb
 homepage: https://github.com/koenhandekyn/functions
-licenses: []
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -52,24 +54,23 @@ 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.1.9
+rubygems_version: 2.0.6
 signing_key: 
 specification_version: 4
 summary: functional programming in ruby
 test_files:
+- spec/prelude_enumerable_spec.rb
 - spec/prelude_lambda_math_spec.rb
 - spec/prelude_lambda_spec.rb
-- spec/prelude_meta_spec.rb
 - spec/spec_helper.rb
 - test/test_prelude_performance.rb
-has_rdoc: 

data/examples/prelude_meta.rb

@@ -1,58 +0,0 @@
-require 'functions'
-
-module PreludeMetaUsage
-
-  include Functions::PreludeMeta
-
-  # returns x to the power of p
-  def power(x, p) x ** p end
-
-  # returns x^2
-  def square(x) power(x, 2) end
-
-  # returns the list of the squares
-  def squares(a) map(a, :square) end
-
-  define :squares_bis, as: { map: :square }
-
-  # test
-  # def_map :squares, :square
-  # def_map :squares_tris, ->(x) { x**2 }
-  # define :squares, as: { map: ->(x) { x**2 } }
-
-  # returns all elements of an enumerable that are even
-  define :evens, as: { filter: :even? }
-
-  # def_filter :evens, :even?
-
-  # filter :evens, :even?
-
-  define :odds, as: { filter: :odd? }
-
-  # def_filter :odds, ->(x) { ! x.even? }
-
-  def sum_of_squares(a) compose(:sum, :squares, a) end
-
-  define :sum_of_squares_bis, as: { compose: [:sum, :squares] }
-
-  # compose :sum_of_squares, :sum, :squares
-
-  def average_bis(a) after([:sum, :length], :divide, a) end
-
-  define :average_tris, as: { :after => [ :sum_length, :divide ] }
-
-  # after :average_quater, :sum_length, :divide
-
-  def inc_with(f, n, m) m + f(f).(n) end
-
-  def sum_of(f, a) a.inject(0) { |r, x| r + f(f).(x) } end
-
-  def add(a,b) a+b end
-
-  define :sum_bis, as: { foldl: [:add, 0]}
-
-  # foldl :sum_bis, :add, 0
-
-  # define foldl: [:add, 0], as: :sum_quater
-
-end

data/examples/spec/prelude_meta_spec.rb

@@ -1,33 +0,0 @@
-require_relative '../prelude_meta'
-
-include PreludeMetaUsage
-
-describe PreludeMetaUsage, "basic meta prelude usage" do
-
-  it "squares" do
-    squares([1, 2, 3]).should == [1, 4, 9]
-    squares_bis([1, 2, 3]).should == [1, 4, 9]
-  end
-
-  it "evens and odds" do
-    evens([1, 2, 3, 4, 5]).should == [2, 4]
-    odds([1, 2, 3, 4, 5]).should == [1, 3, 5]
-  end
-
-  it "takes sums of squares" do
-    sum_of(:square, [2, 3, 1]).should == 2*2+3*3+1*1
-    sum_of(->(x) { x*x }, [2, 3, 1]).should == 2*2+3*3+1*1
-    sum_of_squares([2, 3, 4]).should == 2*2+3*3+4*4
-    sum_of_squares_bis([2, 3, 4]).should == 2*2+3*3+4*4
-  end
-
-  it "takes sums by some variant definitions" do
-    sum_bis([1, 2, 3]).should == 1+2+3
-  end
-
-  it "takes averages by some variant definitions" do
-    average_bis([2, 3, 8]).should == 4
-    average_tris([2, 3, 8]).should == 4
-  end
-
-end

data/spec/prelude_meta_spec.rb

@@ -1,34 +0,0 @@
-require 'functions'
-
-include Functions::PreludeMeta
-
-describe Functions::PreludeMeta, "basic meta prelude usage" do
-
-  it "sums" do
-    sum([1, 2, 3]).should == 1+2+3
-  end
-
-  it "takes averages" do
-    average([2, 3, 8]).should == 4
-  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
-  end
-
-  it "mins and maxes" do
-    min([1, 2, 3]).should == 1
-    max([1, 2, 3]).should == 3
-  end
-
-  it "makes ranges" do
-    from_to(2, 3).should == (2..3)
-    from_one_to(3).should == (1..3)
-  end
-
-  it "intersects arrays" do
-    intersect([[1, 2, 3], [2, 3, 4], [2, 3, 8]]).should == [2, 3]
-  end
-
-end