functions 0.0.3 → 0.0.4

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    Yjc3YjRkZDYwYmMzZjZmYmUwMzVjMTVkZGQxYWJkMThlZWEyZWJiMg==
+  data.tar.gz: !binary |-
+    Y2ZmYjg4OGJiNTg1ZmQxY2M1MjMxNmZmMzZjNWE2ODU5NWY1YzljOA==
+SHA512:
+  metadata.gz: !binary |-
+    NGRmMWYxMmY1ZTU0OWY1ZTM0ODk5ZmJhNTZkNjQwYmJmNWU3NmExZmViYWM3
+    NzQxOTYwMzliNTRhMDczNDE5OTRhZmYzYWE0MjhhNjZkODYyOTBiYTlkM2Y3
+    YzQwMmM2YjkxZTZkMjczNWM5YWVjNGQ0NmM2ODRmZjhiZjgxN2Q=
+  data.tar.gz: !binary |-
+    MDNmNDYxZDRlMDMzN2ZkM2U0ODY3MTkyZGMzN2JhMDAyMzA0ZGFkMmJiZWVi
+    NGRmYzFkZGY3OWI1ZjAzZjJiZDk0NmQ2M2JkZDI1ZjRjNWQyM2U4YTdmOGZj
+    ZjM5Nzg2NzlhZTVlYTNlMTMzOGFjYThjZTdkYzRkMTcxNmZiNDQ=

data/README.md

@@ -1,6 +1,7 @@
 # Functional
 
 This library facilitates writing code in a more functional style inside Ruby.
+How this is fun.
 
 ## Installation
 
@@ -39,10 +40,10 @@ The lambda style allows you to write functions like this
 
       Average = After.( [Sum,Length] ).( Divide )
 
-      Gcd = ->(a,b) { (Divisors.(a) & Divisors.(b)).max }
+      Gcd = ->(a,b) { (Divisors.(a) & Divisors.(b)).max }  # literal translation of the definition, just as an example
 
       # Gcd of an array
-      GcdA1 = Max < Intersect < Map.(Divisors) # litteral translation of the definition
+      GcdA1 = Max < Intersect < Map.(Divisors) # literal translation of the definition
       GcdA2 = ReduceLeft.(Gcd) # faster
 
       # Lcm of an array in function of Lcm of a pair
@@ -76,6 +77,13 @@ The meta style allows you to write functions like this
 
     end
 
+## License
+
+This code is currently copyrighted under the AGPL license.
+See <http://www.gnu.org/licenses/agpl.html> for more information.
+
+![AGPL license](http://www.gnu.org/graphics/agplv3-155x51.png)
+
 ## Contributing
 
 1. Fork it

data/examples/prelude_meta.rb

@@ -4,69 +4,55 @@ module PreludeMetaUsage
 
   include Functions::PreludeMeta
 
-  def power(x, p)
-    x ** p
-  end
+  # returns x to the power of p
+  def power(x, p) x ** p end
 
-  def square(x)
-    power(x, 2)
-  end
+  # returns x^2
+  def square(x) power(x, 2) end
 
-  def_map :squares, :square
+  # returns the list of the squares
+  def squares(a) map(a, :square) end
 
-  def squares_bis(a)
-    map(a, :square)
-  end
+  define :squares_bis, as: { map: :square }
 
-  def_map :squares_tris, ->(x) { x**2 }
+  # test
+  # def_map :squares, :square
+  # def_map :squares_tris, ->(x) { x**2 }
+  # define :squares, as: { map: ->(x) { x**2 } }
 
-  define :squares_quater, as: { map: ->(x) { x**2 } }
+  # returns all elements of an enumerable that are even
+  define :evens, as: { filter: :even? }
 
-  define :squares_quinquies, as: { map: :square }
+  # def_filter :evens, :even?
 
-  def_filter :evens, :even?
-
-  # same as above
   # filter :evens, :even?
 
-  def_filter :odds, ->(x) { ! x.even? }
+  define :odds, as: { filter: :odd? }
 
-  define :evens_bis, as: { filter: :even? }
+  # def_filter :odds, ->(x) { ! x.even? }
 
-  def_compose :sum_of_squares, :sum, :squares
+  def sum_of_squares(a) compose(:sum, :squares, a) end
 
-  def sum_of_squares_bis(a)
-    compose(:sum, :squares, a)
-  end
+  define :sum_of_squares_bis, as: { compose: [:sum, :squares] }
 
-  define :sum_of_squares_tris, as: { compose: [:sum, :squares] }
+  # compose :sum_of_squares, :sum, :squares
 
-  def average_bis(a)
-    after([:sum, :length], :divide, a)
-  end
+  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
+  # after :average_quater, :sum_length, :divide
 
-  def inc_with(f, n, m)
-    m + f(f).(n)
-  end
+  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 sum_of(f, a) a.inject(0) { |r, x| r + f(f).(x) } end
 
-  def add(a,b)
-    a+b
-  end
+  def add(a,b) a+b end
 
-  def_foldl :sum_bis, :add, 0
+  define :sum_bis, as: { foldl: [:add, 0]}
 
-  define :sum_tris, as: { foldl: [:add, 0]}
+  # foldl :sum_bis, :add, 0
 
-  define foldl: [:add, 0], as: :sum_quater
+  # define foldl: [:add, 0], as: :sum_quater
 
 end

data/examples/spec/prelude_meta_spec.rb

@@ -7,53 +7,27 @@ 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
+  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([1, 2, 3]).should == 1+2+3
+    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
-    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
+  it "takes averages by some variant definitions" do
     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/lib/functions/prelude_lambda/basic.rb

@@ -2,14 +2,20 @@ module Functions
 
   module Prelude
 
+    # the identity function
     Id = ->(x) { x }
 
+    # the constant function
     Const = ->(c, x) { c }
 
+    # splits a list xs in peices of size n
     Split_In = ->(n, xs) { xs.each_slice((xs.length+1)/n).to_a }
 
+    # splits a list in half
     Split_In_Half = Split_In.curry.(2)
 
+    # merges two 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
 
       return xs if ys.empty?
@@ -23,37 +29,49 @@ module Functions
 
     end
 
+    # merges two list by the natural comparison operator <
     Merge = Merge_By.partial(nil)
 
+    # composes two functions
     Compose = ->(f, g, x) { f.(g.(x)) }.curry
 
-    # Manually curried version
-    # ComposeCurried = ->(f) { ->(g) { ->(x) { f.(g.(x)) } } }
+    # manually curried version of the Compose function
+    ComposeCurried = ->(f) { ->(g) { ->(x) { f.(g.(x)) } } }
 
+    # composes two functions in reverse sequence
     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))
-    # } } }
+    # manually curried Version of the After composition function
+    AfterCurried = ->(f) { ->(g) { ->(x) {
+      f = Par.(f) if Array === f;
+      g = Par.(g) if Array === g;
+      g.(f.(x))
+    } } }
 
+    # sends the message m to an object o
+    #
+    # @param [Symbol] the method to be called on the object o
+    # @return the result of calling the message m on the object o
     Send = ->(m, o) { o.send(m) }.curry
 
+    # Flattens an array
+    #
+    # @param [#flatten] the array to flatten
     Flatten = Send.(:flatten)
-    # Flatten = ->(a) { a.flatten }
 
+    # Reverses an array
+    #
+    # @param [#reverse] the array to reverse
     Reverse = Send.(:reverse)
-    # Reverse = ->(a) { a.reverse }
 
+    # Returns the length
     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
@@ -66,7 +84,7 @@ module Functions
 
     Map = ->(f, a) { a.map { |x| f.(x) } }.curry
 
-    Filter = ->(xs, f) { xs.select { |x| f.(x) } }.curry
+    Filter = ->(f, xs) { xs.select { |x| f.(x) } }.curry
 
     Parallel = ->(f, g, x) { [f.(x), g.(x)] }.curry
 

data/lib/functions/prelude_lambda/ext.rb

@@ -10,6 +10,9 @@ class Array
 end
 
 class Proc
+  def self.compose(f, g)
+    ->(*args) { g[f[*args]] }
+  end
   # Composition of Procs (functions): (f+g)(x) = f(g(x))
   def +(g)
     # Prelude::Compose.(self,g)
@@ -29,4 +32,4 @@ class Proc
   def partial(a)
     self.curry.(a)
   end
-end
+end

data/lib/functions/prelude_lambda/math.rb

@@ -16,7 +16,7 @@ module Functions
 
     IsDivisor = ->(a, c) { a % c == 0 }
 
-    Divisors = ->(a) { Filter.(FromOneTo.(a), IsDivisor.partial(a)) }
+    Divisors = ->(a) { Filter.(IsDivisor.partial(a), FromOneTo.(a)) }
 
     Gcd = ->(a, b) { b == 0 ? a : Gcd.(b, a % b) } # euclid algorithm
 

data/lib/functions/prelude_lambda/sorting.rb

@@ -15,6 +15,7 @@ module Functions
 
     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

data/lib/functions/prelude_meta.rb

@@ -47,13 +47,13 @@ module Functions
         module_eval(code)
       end
 
-      alias :def_compose :compose
+      #alias :def_compose :compose
 
       def after(c, f, g)
         compose(c, g, f)
       end
 
-      alias :def_after :after
+      #alias :def_after :after
 
       def parallel(c, f, g)
         m = create_proc_method(c, f, :f)
@@ -66,7 +66,7 @@ module Functions
         module_eval(code)
       end
 
-      alias :def_parallel :parallel
+      #alias :def_parallel :parallel
 
       def foldl(c, f, i)
         m = create_proc_method(c, f)
@@ -78,7 +78,7 @@ module Functions
         module_eval(code)
       end
 
-      alias :def_foldl :foldl
+      #alias :def_foldl :foldl
 
       def reduce_left(c, f)
         m = create_proc_method(c, f)
@@ -90,7 +90,7 @@ module Functions
         module_eval(code)
       end
 
-      alias :def_reduce_left :reduce_left
+      #alias :def_reduce_left :reduce_left
 
       def foldr(c, f, i)
         m = create_proc_method(c, f)
@@ -102,7 +102,7 @@ module Functions
         module_eval(code)
       end
 
-      alias :def_foldr :foldr
+      #alias :def_foldr :foldr
 
       def reduce_right(c, f)
         m = create_proc_method(c, f)
@@ -114,7 +114,7 @@ module Functions
         module_eval(code)
       end
 
-      alias :def_reduce_right :reduce_right
+      #alias :def_reduce_right :reduce_right
 
       def map(c, f)
         m = create_proc_method(c, f)
@@ -126,7 +126,7 @@ module Functions
         module_eval(code)
       end
 
-      alias :def_map :map
+      #alias :def_map :map
 
       def filter(c, f)
         m = create_proc_method(c, f)
@@ -138,7 +138,7 @@ module Functions
         module_eval(code)
       end
 
-      alias :def_filter :filter
+      #alias :def_filter :filter
 
       def method(m)
         code = %Q{
@@ -222,21 +222,21 @@ module Functions
 
     def_method :flatten
 
-    #def flatten(a)
-    #  a.flatten
-    #end
-
+    # @return calls the length method on the object
     def_method :length
 
-    #def length(a)
-    #  a.length
-    #end
-
+    # @param object the target object
+    # @return calls the reverse method on the object
     def_method :reverse
 
-    #def reverse(a)
-    #  a.reverse
-    #end
+    # @param object [#min] the object to call the min method on
+    # @return calls the min method on the Enumerable
+    def_method :min
+
+    # @param [#max] the object to call the max method on
+    # @return [Integer] the maximum
+    def_method :max
+
 
     def foldl(f, i, a)
       a.inject(i) { |r, x| f(f).(r, x) }
@@ -280,15 +280,12 @@ module Functions
 
     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
-
+    # creates a range
+    #
+    # param from [Fixnum] the start of the range
+    # param to [Fixnum] the end of the range
     def from_to(from, to)
       Range.new(from, to)
     end

data/lib/functions/shared/ext.rb

@@ -3,4 +3,15 @@ class Array
   def >> a
     self.unshift a
   end
+end
+
+module Kernel
+
+  def tailrecurse(&b)
+    result = []
+    loop do
+      result = b.(*result)
+    end
+  end
+
 end

data/lib/functions/version.rb

@@ -1,3 +1,3 @@
 module Functions
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/spec/prelude_lambda_spec.rb

@@ -43,4 +43,10 @@ describe Functions::Prelude, "basic" do
     Flatten.([[1, 2, 3], [2, 3]]).should 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]
+  end
+
 end

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: functions
 version: !ruby/object:Gem::Version
-  version: 0.0.3
-  prerelease: 
+  version: 0.0.4
 platform: ruby
 authors:
 - Koen Handekyn
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-10 00:00:00.000000000 Z
+date: 2013-10-17 00:00:00.000000000 Z
 dependencies: []
 description: functional programming in ruby
 email:
@@ -46,27 +45,26 @@ files:
 - test/test_prelude_performance.rb
 homepage: https://github.com/koenhandekyn/functions
 licenses: []
+metadata: {}
 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
+rubygems_version: 2.1.9
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: functional programming in ruby
 test_files:
 - spec/prelude_lambda_math_spec.rb
@@ -74,3 +72,4 @@ test_files:
 - spec/prelude_meta_spec.rb
 - spec/spec_helper.rb
 - test/test_prelude_performance.rb
+has_rdoc: