functions 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

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

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in functions.gemspec
+gemspec
+
+group :test do
+  gem 'test-unit'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Koen Handekyn
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,35 @@
+# Functional
+
+This library facilitates writing code in a more functional style inside Ruby.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'functional'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install functional
+
+## 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
+
+### Meta Style
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

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

data/examples/prelude_lambda.rb

@@ -0,0 +1,45 @@
+require 'functions'
+
+module PreludeLambdaUsage
+
+  include Functions::Prelude
+
+  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
+
+  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
+
+  # Average variations
+  Average1 = After.( Parallel.(Sum).(Length) ).( Divide )
+  Average2 = After.( Par.([Sum,Length]) ).( Divide )
+  Average3 = After.( [Sum,Length] ).( Divide )
+
+  # Gcd variations
+  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
+  GcdA1 = Max < Intersect < Map.(Divisors) # litteral translation of the definition
+  GcdA2 = ->(arr) { arr.inject { |a, r| Gcd.(a, r) } } # the gcd of an array as an iteration of the gcd over the elements
+  GcdA3 = ReduceLeft.(Gcd) # the same but written without arguments
+
+  Greatest = Max
+  Common = Intersect
+  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
+
+end

data/examples/prelude_meta.rb

@@ -0,0 +1,72 @@
+require 'functions'
+
+module PreludeMetaUsage
+
+  include Functions::PreludeMeta
+
+  def power(x, p)
+    x ** p
+  end
+
+  def square(x)
+    power(x, 2)
+  end
+
+  def_map :squares, :square
+
+  def squares_bis(a)
+    map(a, :square)
+  end
+
+  def_map :squares_tris, ->(x) { x**2 }
+
+  define :squares_quater, as: { map: ->(x) { x**2 } }
+
+  define :squares_quinquies, as: { map: :square }
+
+  def_filter :evens, :even?
+
+  # same as above
+  # filter :evens, :even?
+
+  def_filter :odds, ->(x) { ! x.even? }
+
+  define :evens_bis, as: { filter: :even? }
+
+  def_compose :sum_of_squares, :sum, :squares
+
+  def sum_of_squares_bis(a)
+    compose(:sum, :squares, a)
+  end
+
+  define :sum_of_squares_tris, as: { compose: [:sum, :squares] }
+
+  def average_bis(a)
+    after([:sum, :length], :divide, a)
+  end
+
+  define :average_tris, as: { :after => [ :sum_length, :divide ] }
+
+  def_after :average_quater, :sum_length, :divide
+
+  def inc_with(f, n, m)
+    m + f(f).(n)
+  end
+
+  # can this be improved on ?
+  # a definition as composition ?
+  def sum_of(f, a)
+    a.inject(0) { |r, x| r + f(f).(x) }
+  end
+
+  def add(a,b)
+    a+b
+  end
+
+  def_foldl :sum_bis, :add, 0
+
+  define :sum_tris, as: { foldl: [:add, 0]}
+
+  define foldl: [:add, 0], as: :sum_quater
+
+end

data/examples/spec/prelude_lambda_spec.rb

@@ -0,0 +1,48 @@
+require_relative '../prelude_lambda'
+
+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
+  end
+
+  it "averages" do
+    Average.([2, 3, 8]).should == 4
+  end
+
+  it "flattens" do
+    Flatten.([[1, 2, 3], [2, 3]]).should == [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
+  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)
+  end
+
+  it "knows about LCM variations" do
+    # test variant implementations
+    LcmA1.([12,9,2]).should eq(36)
+    LcmA2.([12,9,2]).should eq(36)
+  end
+
+
+  #def bench_sum_of_squares
+  #  assert_performance_linear 0.9 do |n| # n is a range value
+  #    Sum_Of_Squares.((1..n).to_a)
+  #  end
+  #end
+
+end

data/examples/spec/prelude_meta_spec.rb

@@ -0,0 +1,59 @@
+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]
+    squares_tris([1, 2, 3]).should == [1, 4, 9]
+    squares_quater([1, 2, 3]).should == [1, 4, 9]
+    squares_quinquies([1, 2, 3]).should == [1, 4, 9]
+  end
+
+  it "evens and odds" do
+    evens([1, 2, 3, 4, 5]).should == [2, 4]
+    evens_bis([1, 2, 3, 4, 5]).should == [2, 4]
+    odds([1, 2, 3, 4, 5]).should == [1, 3, 5]
+  end
+
+  it "takes sums of squares and more" do
+    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
+    sum_of_squares_tris([2, 3, 4]).should == 2*2+3*3+4*4
+    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([1, 2, 3]).should == 1+2+3
+    sum_bis([1, 2, 3]).should == 1+2+3
+    sum_tris([1, 2, 3]).should == 1+2+3
+    sum_quater([1, 2, 3]).should == 1+2+3
+  end
+
+  it "takes averages" do
+    average([2, 3, 8]).should == 4
+    average_bis([2, 3, 8]).should == 4
+    average_tris([2, 3, 8]).should == 4
+    average_quater([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

data/functions.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'functions/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "functions"
+  gem.version       = Functions::VERSION
+  gem.authors       = ["Koen Handekyn"]
+  gem.email         = ["koen.handekyn@up-nxt.com"]
+  gem.description   = %q{functions programming in ruby}
+  gem.summary       = %q{functions programming in ruby}
+  gem.homepage      = "http://github.com"
+
+  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)/})
+  gem.require_paths = ["lib"]
+end

data/lib/functions.rb

@@ -0,0 +1,4 @@
+require "functions/version"
+require 'functions/shared/ext'
+require 'functions/prelude_lambda'
+require 'functions/prelude_meta'

data/lib/functions/prelude_lambda.rb

@@ -0,0 +1,5 @@
+require_relative 'prelude_lambda/ext'
+require_relative 'prelude_lambda/basic'
+require_relative 'prelude_lambda/math'
+require_relative 'prelude_lambda/sorting'
+

data/lib/functions/prelude_lambda/basic.rb

@@ -0,0 +1,83 @@
+module Functions
+
+  module Prelude
+
+    Id = ->(x) { x }
+
+    Const = ->(c, x) { c }
+
+    Split_In = ->(n, xs) { xs.each_slice((xs.length+1)/n).to_a }
+
+    Split_In_Half = Split_In.curry.(2)
+
+    Merge_By = ->(f, xs, ys) do
+
+      return xs if ys.empty?
+      return ys if xs.empty?
+
+      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
+
+    end
+
+    Merge = Merge_By.partial(nil)
+
+    Compose = ->(f, g, x) { f.(g.(x)) }.curry
+
+    # Manually curried version
+    # ComposeCurried = ->(f) { ->(g) { ->(x) { f.(g.(x)) } } }
+
+    After = ->(f, g, x) {
+      f = Par.(f) if Array === f;
+      g = Par.(g) if Array === g;
+      g.(f.(x))
+    }.curry
+
+    # Manually Curried Version
+    # AfterCurried = ->(f) { ->(g) { ->(x) {
+    #  f = Par.(f) if Array === f;
+    #  g = Par.(g) if Array === g;
+    #  g.(f.(x))
+    # } } }
+
+    Send = ->(m, o) { o.send(m) }.curry
+
+    Flatten = Send.(:flatten)
+    # Flatten = ->(a) { a.flatten }
+
+    Reverse = Send.(:reverse)
+    # Reverse = ->(a) { a.reverse }
+
+    Length = Send.(:length)
+    # Length = ->(x) { x.length }
+
+    Foldl = ->(f, i, a) { a.inject(i) { |r, x| f.(r, x) } }.curry
+
+    ReduceLeft = ->(f, a) { a.inject { |r, x| f.(r, x) } }.curry
+
+    Foldr = ->(f, i, a) { Foldl.(f, i, a.reverse) }
+
+    ReduceRight = ->(f, a) { ReduceLeft.(f, a.reverse) }.curry
+
+    Zip = ->(a, b) { a.zip(b) }.curry
+
+    Map = ->(f, a) { a.map { |x| f.(x) } }.curry
+
+    Filter = ->(xs, f) { xs.select { |x| f.(x) } }.curry
+
+    Parallel = ->(f, g, x) { [f.(x), g.(x)] }.curry
+
+    Par = ->(fs, x) { fs.map { |f| f.(x) } }.curry
+
+    Intersect = ->(as) { as.inject(:&) }
+
+    FromTo = ->(from) { ->(to) { Range.new(from, to) } }
+
+    FromOneTo = FromTo.(1)
+
+  end
+
+end

data/lib/functions/prelude_lambda/ext.rb

@@ -0,0 +1,32 @@
+# reference http://iain.nl/going-crazy-with-to_proc
+
+class Array
+  # converts the array into a Proc where
+  # the first element is the method name, other elements are the values
+  def to_proc
+    head, *tail = *self
+    Proc.new { |obj, *other| obj.__send__(head, *(other + tail)) }
+  end
+end
+
+class Proc
+  # Composition of Procs (functions): (f+g)(x) = f(g(x))
+  def +(g)
+    # Prelude::Compose.(self,g)
+    ->(x) { self.(g.(x)) }
+  end
+  # Composition of Procs (functions): (f<g)(x) = f(g(x))
+  def <(g)
+    # Prelude::Compose.(self,g)
+    ->(x) { self.(g.(x)) }
+  end
+  # Composition of Procs (functions): (f>g)(x) = g(f(x))
+  def >(g)
+    # Prelude::After.(self,g)
+    ->(x) { g.(self.(x)) }
+  end
+  # Partial evaluation of a Proc (function)
+  def partial(a)
+    self.curry.(a)
+  end
+end

data/lib/functions/prelude_lambda/math.rb

@@ -0,0 +1,31 @@
+module Functions
+
+  module Prelude
+
+    Max = Send.(:max)
+
+    Min = Send.(:min)
+
+    Sum = ->(arr) { arr.inject(0, :+) }
+
+    Multiply = ->(arr) { arr.inject(1, :*) }
+
+    Divide = ->(arr) { arr.inject(:/) }
+
+    Average = Parallel.(Sum,Length) > Divide
+
+    IsDivisor = ->(a, c) { a % c == 0 }
+
+    Divisors = ->(a) { Filter.(FromOneTo.(a), IsDivisor.partial(a)) }
+
+    Gcd = ->(a, b) { b == 0 ? a : Gcd.(b, a % b) } # euclid algorithm
+
+    GcdA = ReduceLeft.(Gcd)
+
+    Lcm = ->(a, b) { a*b / Gcd.(a, b) } # mathematical law
+
+    LcmA = ReduceLeft.(Lcm)
+
+  end
+
+end

data/lib/functions/prelude_lambda/sorting.rb

@@ -0,0 +1,27 @@
+module Functions
+
+  module Prelude
+
+    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)
+
+    Quick_Sort_By = ->(f, list) do
+      return [] if list.size == 0
+      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)
+    end
+
+    Quick_Sort = Quick_Sort_By.partial(nil)
+
+  end
+end

data/lib/functions/prelude_meta.rb

@@ -0,0 +1,306 @@
+module Functions
+
+  module PreludeMeta
+
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+
+    module ClassMethods
+
+      def create_proc_method(c, f, i=:f)
+        if Proc === f
+          define_method("#{c}_#{i}_proc", f)
+          return "#{c}_#{i}_proc"
+        else
+          return f
+        end
+      end
+
+      def define_v1(c, definition)
+        key, value = definition[:as].first
+        self.send(key, c, *value)
+      end
+
+      def define_v2(definition, name)
+        key, value = definition
+        self.send(key, name, *value)
+      end
+
+      def define(*params)
+        if Symbol === params[0]
+          define_v1(*params)
+        else
+          name = params[0].delete(:as)
+          define_v2(*params[0], name)
+        end
+      end
+
+      def compose(c, f, g)
+        m = create_proc_method(c, f, :f)
+        n = create_proc_method(c, g, :g)
+        code = %Q{
+        def #{c}(x)
+          #{m}(#{n}(x))
+        end
+      }
+        module_eval(code)
+      end
+
+      alias :def_compose :compose
+
+      def after(c, f, g)
+        compose(c, g, f)
+      end
+
+      alias :def_after :after
+
+      def parallel(c, f, g)
+        m = create_proc_method(c, f, :f)
+        n = create_proc_method(c, g, :g)
+        code = %Q{
+        def #{c}(x)
+          [#{m}(x),#{n}(x)]
+        end
+      }
+        module_eval(code)
+      end
+
+      alias :def_parallel :parallel
+
+      def foldl(c, f, i)
+        m = create_proc_method(c, f)
+        code = %Q{
+        def #{c}(arr)
+          arr.inject(#{i}) { |r, x| #{m}(r,x) }
+        end
+      }
+        module_eval(code)
+      end
+
+      alias :def_foldl :foldl
+
+      def reduce_left(c, f)
+        m = create_proc_method(c, f)
+        code = %Q{
+        def #{c}(arr)
+          arr.inject { |r, x| #{m}(r,x) }
+        end
+      }
+        module_eval(code)
+      end
+
+      alias :def_reduce_left :reduce_left
+
+      def foldr(c, f, i)
+        m = create_proc_method(c, f)
+        code = %Q{
+        def #{c}(arr)
+          arr.reverse.inject(#{i}) { |r, x| #{m}(r,x) }
+        end
+      }
+        module_eval(code)
+      end
+
+      alias :def_foldr :foldr
+
+      def reduce_right(c, f)
+        m = create_proc_method(c, f)
+        code = %Q{
+        def #{c}(arr)
+          arr.reverse.inject { |r, x| #{m}(r,x) }
+        end
+      }
+        module_eval(code)
+      end
+
+      alias :def_reduce_right :reduce_right
+
+      def map(c, f)
+        m = create_proc_method(c, f)
+        code = %Q{
+        def #{c}(arr)
+          arr.map { |x| #{m}(x) }
+        end
+      }
+        module_eval(code)
+      end
+
+      alias :def_map :map
+
+      def filter(c, f)
+        m = create_proc_method(c, f)
+        code = %Q{
+        def #{c}(arr)
+          arr.select { |x| #{m}(x) }
+        end
+      }
+        module_eval(code)
+      end
+
+      alias :def_filter :filter
+
+      def method(m)
+        code = %Q{
+        def #{m}(o)
+          o.#{m}
+        end
+      }
+        module_eval(code)
+      end
+
+      alias :def_method :method
+
+    end
+
+    def m(method)
+      lambda(&method(method))
+    end
+
+    def f(f)
+      Symbol === f ? f = m(f) : f
+    end
+
+    def id(x)
+      x
+    end
+
+    def const(c, x)
+      c
+    end
+
+    def split_in(xs, n)
+      xs.each_slice((xs.length+1)/n).to_a
+    end
+
+    def split_in_half(xs)
+      split_in(xs, 2)
+    end
+
+    def merge(xs, ys, &by)
+
+      return xs if ys.empty?
+      return ys if xs.empty?
+
+      x, *xt = xs
+      y, *yt = ys
+
+      return merge(xt, ys, &by) >> x if block_given? ? by.(x) <= by.(y) : x <= y
+      return merge(xs, yt, &by) >> y
+
+    end
+
+    def merge_sort(xs, &by)
+      return xs if xs.length <= 1 # stopcondition
+      left, right = split_in_half(xs)
+      merge(merge_sort(left, &by), merge_sort(right, &by), &by)
+    end
+
+    def quick_sort(list)
+      return [] if list.size == 0
+      pivot, *xs = *list
+      less, more = xs.partition { |y| y < pivot }
+      quick_sort(less) + [pivot] + quick_sort(more)
+    end
+
+    def compose(f, g, x)
+      f = f(f)
+      g = f(g)
+      f.(g.(x))
+    end
+
+    def after(f, g, x)
+      f = f(f)
+      g = f(g)
+      return g.(par(*f, x)) if Array === f && Proc === g
+      return par(*g, f.(x)) if Proc === f && Array === g
+      return par(*g, par(*f, x)) if Array === f && Array === g
+      return g.(f.(x)) # else
+    end
+
+    extend ClassMethods
+
+    def_method :flatten
+
+    #def flatten(a)
+    #  a.flatten
+    #end
+
+    def_method :length
+
+    #def length(a)
+    #  a.length
+    #end
+
+    def_method :reverse
+
+    #def reverse(a)
+    #  a.reverse
+    #end
+
+    def foldl(f, i, a)
+      a.inject(i) { |r, x| f(f).(r, x) }
+    end
+
+    def foldr(f, i, a)
+      foldl(f(f), i, a.reverse)
+    end
+
+    def zip(a, b)
+      a.zip(b)
+    end
+
+    def map(a, f)
+      a.map { |x| f(f).(x) }
+    end
+
+    def filter(a, f)
+      a.select { |x| f(f).(x) }
+    end
+
+    def sum(a)
+      a.inject(0, :+)
+    end
+
+    def parallel(f, g, x)
+      [f(f).(x), f(g).(x)]
+    end
+
+    def par(*fs, x)
+      fs.map { |f| f(f).(x) }
+    end
+
+    def_method :even?
+
+    def_method :odd?
+
+    def divide(arr)
+      arr.inject { |a,b| a/b }
+    end
+
+    define :sum_length, as: { parallel: [:sum, :length] }
+
+    define :average, as: { :after => [ :sum_length, :divide ] }
+
+    # TODO write with operator :& ?
+    # def_reduce_left :intersect, ->(a,b) { a&b } # short
+    # reduce_left :intersect, ->(a,b) { a&b } # longer
+    define :intersect, as: {reduce_left: ->(a, b) { a&b }} # longest
+
+    def_method :min
+
+    def_method :max
+
+    def from_to(from, to)
+      Range.new(from, to)
+    end
+
+    def from_one_to(to)
+      Range.new(1, to)
+    end
+
+  end
+
+end
+
+

data/lib/functions/shared/ext.rb

@@ -0,0 +1,6 @@
+class Array
+  # prepend element a to the array (self)
+  def >> a
+    self.unshift a
+  end
+end

data/lib/functions/version.rb

@@ -0,0 +1,3 @@
+module Functions
+  VERSION = "0.0.1"
+end

data/performance/prelude_performance.rb

@@ -0,0 +1,49 @@
+require_relative '../examples/prelude_usage'
+require_relative '../examples/prelude_meta_usage'
+
+include PreludeUsage
+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) } }
+  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) } }
+  end
+end

data/spec/prelude_lambda_math_spec.rb

@@ -0,0 +1,41 @@
+require 'functions'
+
+include Functions::Prelude
+
+describe Functions::Prelude, "math" do
+
+  it "divides" do
+    Divide.([9,2]).should eq(9/2)
+    Divide.([8,2,2]).should eq(8/2/2)
+  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])
+  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])
+  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)
+  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)
+  end
+
+end
+
+
+

data/spec/prelude_lambda_spec.rb

@@ -0,0 +1,46 @@
+require 'functions'
+
+include Functions::Prelude
+
+describe Functions::Prelude, "basic" do
+
+  Power = ->(p, x) { x**p }.curry
+  Square = Power.(2)
+  Squares = Map.(Square)
+
+  it "composes" do
+    sum_of_squares = Compose.(Sum).(Squares)
+    sum_of_squares.([2, 3, 4]).should 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)
+  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)
+  end
+
+  it "composes using after with implicit parallel" do
+    average = After.([Sum, Length]).(Divide)
+    average.([2, 3, 8]).should 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)
+  end
+
+  it "mixes par with after operator" do
+    average = Par.([Sum, Length]) > Divide
+    average.([2, 3, 8]).should eq((2+3+8)/3)
+  end
+
+  it "flattens arrays" do
+    Flatten.([[1, 2, 3], [2, 3]]).should eq([1,2,3,2,3])
+  end
+
+end

data/spec/prelude_meta_spec.rb

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

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+# 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
+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
+
+  # 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
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

data/test/test_prelude_performance.rb

@@ -0,0 +1,36 @@
+require 'examples/prelude_lambda'
+require 'examples/prelude_meta'
+
+#require 'test/unit'
+require 'minitest/autorun'
+require 'minitest/benchmark'
+
+#require "minitest/reporters"
+# MiniTest::Reporters.use! # add this to your run configuration
+
+include PreludeLambdaUsage
+include PreludeMetaUsage
+
+class TestPrelude < MiniTest::Unit::TestCase
+
+  include Functions::Prelude
+
+  def test_sum_of_squares
+    assert_performance_linear 0.99 do |n| # n is a range value
+      100.times { Sum_Of_Squares.((1..n).to_a) }
+    end
+    assert_performance_linear 0.99 do |n| # n is a range value
+      100.times { sum_of_squares((1..n).to_a) }
+    end
+  end
+
+  def test_average
+    assert_performance_linear 0.99 do |n| # n is a range value
+      100.times { Average.((1..n).to_a) }
+    end
+    assert_performance_linear 0.99 do |n| # n is a range value
+      100.times { average((1..n).to_a) }
+    end
+  end
+
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: functions
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Koen Handekyn
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-10 00:00:00.000000000 Z
+dependencies: []
+description: functions programming in ruby
+email:
+- koen.handekyn@up-nxt.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- 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_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
+- performance/prelude_performance.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: http://github.com
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: functions programming in ruby
+test_files:
+- 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