funkr 0.0.21 → 0.0.22

data/.travis.yml

@@ -0,0 +1 @@
+rvm: 1.9.2

data/Rakefile

@@ -1,2 +1,11 @@
 require 'bundler'
+require 'rake/testtask'
+
 Bundler::GemHelper.install_tasks
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test

data/funkr.gemspec

@@ -18,4 +18,5 @@ Gem::Specification.new do |s|
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
+  s.add_development_dependency 'rake', '~> 0.9.2'
 end

data/lib/funkr/adt/adt.rb

@@ -1,25 +1,30 @@
 require "funkr/adt/matcher"
 
 module Funkr
+
+  # Very rought Algebraic Data Types. A class inheriting from ADT can
+  # declare constructors with #adt
   class ADT
 
     def initialize(const, *data)
       @const, @data = const, data
     end
-    
+
+    # Declare ADT constructors, for example :
+    # class Maybe < ADT;  adt :just, :nothing; end
     def self.adt(*constructs)
       build_adt(constructs)
       build_matcher(constructs)
     end
 
-    def self.match_method=(method)
-      @match_method = method
-    end
-
-    self.match_method = :safe
-    
     def self.matcher; @matcher; end
     
+    # Match your ADT against its constructors, for example :
+    # a = Maybe.just("hello")
+    # a.match do |on|
+    #   on.just{|x| puts x}
+    #   on.nothing{ }
+    # end
     def match
       m = self.class.matcher.new(normal_form)
       yield m
@@ -27,10 +32,10 @@ module Funkr
     end
     
     def to_s
-      format("%s%s%s",
+      format("{%s%s%s}",
              @const,
              @data.any? ? " : " : "",
-             @data.map(&:inspect).join(" ") )
+             @data.map(&:inspect).join(", ") )
     end
     
     private

data/lib/funkr/adt/matcher.rb

@@ -1,4 +1,5 @@
 module Funkr
+  # Should not be used directly
   class Matcher
     
     def initialize(match)

data/lib/funkr/categories.rb

@@ -3,3 +3,6 @@ require 'funkr/categories/applicative'
 require 'funkr/categories/alternative'
 require 'funkr/categories/monoid'
 require 'funkr/categories/monad'
+
+
+# Categories describe types capabilities.

data/lib/funkr/extensions/array.rb

@@ -1,62 +1,71 @@
 require 'funkr/categories'
 
+# Extends array (as list) capabilities
 class Array
-  
+
   include Funkr::Categories
-  
+
   class << self
     def unit(e); self.new([e]); end
     alias pure unit
     def mzero; self.new(); end
   end
-  
+
   ### Categories
-  
-  # array est déjà un functor via map
-  # include Functor 
-  
-  
+
+  # Array is already a functor with its correct map implementation
+
+
+  # Array can be made an applicative functor, for example :
+  # f = Array.curry_lift_proc{|x,y| x + y}
+  # f.apply([0,4]).apply([5,7]) => [5, 7, 9, 11]
+  # f.apply([0,4]).apply([]) => []
   include Applicative
   extend Applicative::ClassMethods
-  
+
   def apply(to)
     map do |f|
       to.map{ |t| f.call(t)}
     end.flatten(1)
   end
-  
+
+  # Array is Alternative whith empty? being zero
   include Alternative
-  
+
+  # [].or_else{[5]} => [5]
   def or_else(&block)
     if empty? then yield
     else self end
   end
-  
-  
+
+
+  # Array is a monoid with mplus = (+) and mzero = []
   include Monoid
   extend Monoid::ClassMethods
-  
+
+  # [5].mplus([6]) => [5,6]
   def mplus(m_y)
     self + m_y
   end
-  
-  
+
+
+  # Array is also a monad
   include Monad
   extend Monad::ClassMethods
-  
+
   def bind(&block)
     self.map(&block).flatten(1)
   end
-  
+
   def self.box(value)
     if value.nil? then self.mzero
     else self.unit(value) end
   end
-  
+
   def unbox()
     if self.empty? then nil
     else self.first end
   end
-  
-  
+
+
 end

data/lib/funkr/extensions/hash.rb

@@ -0,0 +1,53 @@
+# -*- coding: utf-8 -*-
+require 'funkr/categories'
+
+# Extends Hash capabilities
+class Hash
+
+  # maps function over hash values
+  def map_v # &block
+    h = Hash.new(self.default)
+    self.each{|k,v| h[k] = yield(v)}
+    return h
+  end
+
+  # maps function over hash keys
+  def map_k # &block
+    h = Hash.new(self.default)
+    self.each{|k,v| h[yield(k)] = v}
+    return h
+  end
+
+  # maps function over hash keys and values. Block should take
+  # 2 parameters, and should return a 2 elements array.
+  def map_kv # &block
+    h = Hash.new(self.default)
+    self.each do |k,v|
+      nk, nv = yield(k,v)
+      h[nk] = nv
+    end
+    return h
+  end
+
+  include Funkr::Categories
+
+  class << self
+    def mzero; self.new(); end
+  end
+
+  ### Categories
+  
+  # Hash is a functor via map_v, but unfortunatly a dumb map method is
+  # already defined by the enumerable module, and is kept for
+  # compatibility
+
+
+  # Hash is a monoid if values type is a monoid
+  include Monoid
+  extend Monoid::ClassMethods
+  
+  def mplus(m_y)
+    self.merge(m_y){|k, v1, v2| v1.mplus(v2)}
+  end
+
+end

data/lib/funkr/extensions.rb

@@ -1,3 +1,4 @@
 require 'funkr/extensions/fixnum'
 require 'funkr/extensions/array'
 require 'funkr/extensions/enumerable'
+require 'funkr/extensions/hash'

data/lib/funkr/types/maybe.rb

@@ -4,25 +4,32 @@ require 'funkr/categories'
 module Funkr
   module Types
     class Maybe < ADT
-      
+
       include Funkr::Categories
-      
+
       adt :just, :nothing
-      
+
       ### Categories
-      
+
       include Functor
-      
+
       def map(&block)
         self.match do |on|
           on.just {|v| self.class.just(yield(v))}
           on.nothing { self }
         end
       end
-      
+
+      # Maybe can be made an applicative functor, for example :
+      # f = Maybe.curry_lift_proc{|x,y| x + y}
+      # a = Maybe.just(3)
+      # b = Maybe.just(4)
+      # c = Maybe.nothing
+      # f.apply(a).apply(b) => Just 7
+      # f.apply(a).apply(c) => Nothing
       include Applicative
       extend Applicative::ClassMethods
-      
+
       def apply(to)
         self.match do |f_on|
           f_on.just do |f|
@@ -34,20 +41,20 @@ module Funkr
           f_on.nothing { self }
         end
       end
-      
+
       include Alternative
-      
+
       def or_else(&block)
         self.match do |on|
           on.just {|v| self}
           on.nothing { yield }
         end
       end
-      
-      
+
+
       include Monoid
       extend Monoid::ClassMethods
-      
+
       def mplus(m_y)
         self.match do |x_on|
           x_on.nothing { m_y }
@@ -59,18 +66,18 @@ module Funkr
           end
         end
       end
-      
-      
+
+
       include Monad
       extend Monad::ClassMethods
-      
+
       def bind(&block)
         self.match do |on|
           on.just {|v| yield(v)}
           on.nothing {self}
         end
       end
-      
+
       def unbox(default=nil)
         self.match do |on|
           on.just {|v| v }
@@ -83,7 +90,7 @@ module Funkr
         alias pure just
         alias mzero nothing
       end
-      
+
       def self.box(value)
         if value.nil? then self.nothing
         else self.just(value) end
@@ -94,7 +101,7 @@ module Funkr
       #  a list of all the Just values.
       def self.concat(maybes)
         maybes.inject([]) do |a, e|
-          e.match do |on| 
+          e.match do |on|
             on.just{|v| a + [v]}
             on.nothing{ a }
           end

data/lib/funkr/types/simple_record.rb

@@ -62,20 +62,18 @@ module Funkr
 
       def to_s; @key_vals.to_s; end
 
-    end
-
-    private
+      private
 
-    def rebuild_array
-      self.replace(@key_vals.values)
-    end
+      def rebuild_array
+        self.replace(@key_vals.values)
+      end
 
-    def check_keys(keys)
-      unless keys.all?{|k| @allowed_keys.include?(k)} then
+      def check_keys(keys)
+        unless keys.all?{|k| @allowed_keys.include?(k)} then
           raise "#{self.class.to_s} forbidden key in update"
+        end
       end
-    end
-
 
+    end
   end
 end

data/lib/funkr/version.rb

@@ -1,3 +1,3 @@
 module Funkr
-  VERSION = "0.0.21"
+  VERSION = "0.0.22"
 end

data/lib/funkr.rb

@@ -2,6 +2,7 @@ if RUBY_VERSION.split(".")[0..1] == ["1","8"] then
   require 'funkr/compat/1.8'
 end
 
+# Funkr brings some common functional programming constructs to ruby
 module Funkr
-  # constructs defined in submodules
+
 end

data/test/test_container.rb

@@ -0,0 +1,17 @@
+require 'test/unit'
+require 'funkr/types/container'
+
+class TestContainer < Test::Unit::TestCase
+  C = Funkr::Types::Container
+
+  def test_comparable
+    # assert_equal(C.new('foo'), C.new('foo'))
+  end
+
+  def test_container
+    c = C.new("Value")
+    assert_equal("Value", c.unbox)
+    assert_equal("eulaV", c.map(&:reverse).unbox)
+  end
+
+end

data/test/test_extensions.rb

@@ -0,0 +1,63 @@
+require 'test/unit'
+require 'funkr/extensions'
+
+class TestExtensions < Test::Unit::TestCase
+
+  def test_array_full_lift
+    a = [1,2,3]
+    b = [10,20,30]
+    f = Array.full_lift_proc{|x,y| x + y}
+    assert_equal([11, 21, 31, 12, 22, 32, 13, 23, 33], f.call(a,b))
+    assert_equal([], f.call(a,[]))
+  end
+
+  def test_array_monad
+    a = [1,2,3]
+    b = [10,20,30]
+    assert_equal([11, 21, 31, 12, 22, 32, 13, 23, 33],
+                 a.bind do |x|
+                   b.bind do |y|
+                     Array.unit(x + y)
+                   end
+                 end)
+  end
+
+  def test_span
+    assert_equal([[1, 2, 4], [5, 7, 5, 8, 2, 10]],
+                 [1,2,4,5,7,5,8,2,10].span{|x| x < 5})
+  end
+
+  def test_group_seq_by
+    assert_equal([[1], [2, 4], [5, 7, 5], [8, 2, 10]],
+                 [1,2,4,5,7,5,8,2,10].group_seq_by{|x| x % 2})
+  end
+
+  def test_groups_of
+    assert_equal([[1, 2, 4, 5], [7, 5, 8, 2], [10]],
+                 [1,2,4,5,7,5,8,2,10].groups_of(4))
+  end
+
+  def test_sliding_groups_of
+    assert_equal([[1, 2, 3], [2, 3, 4], [3, 4, 5], [4, 5, 6], 
+                  [5, 6, 7], [6, 7, 8], [7, 8, 9], [8, 9, 10]],
+                 (1..10).to_a.sliding_groups_of(3))
+  end
+
+  def test_seq_index
+    assert_equal(30, (0..100).to_a.seq_index([30,31,32]))
+  end
+
+  def test_diff_with
+    a = [ {:v => 1}, {:v => 2}, {:v => 3}, {:v => 2}, {:v => 3} ]
+    b = [ {:v => 2}, {:v => 3}, {:v => 4}, {:v => 3}, {:v => 4} ]
+    assert_equal([[{:v=>1}], [{:v=>2}, {:v=>3}], [{:v=>4}]], 
+                 a.diff_with(b){|x,y| x[:v] == y[:v]})
+  end
+
+  def test_make_uniq_by
+    a = [ {:v => 1}, {:v => 2}, {:v => 3}, {:v => 2}, {:v => 3}, {:v => 1} ]
+    assert_equal([{:v=>1}, {:v=>2}, {:v=>3}],
+                 a.make_uniq_by{|x,y| x[:v] == y[:v]})
+  end
+
+end

data/test/test_hash.rb

@@ -0,0 +1,13 @@
+require 'test/unit'
+require 'funkr/extensions/hash'
+
+class TestHash < Test::Unit::TestCase
+
+  def test_map_v
+    assert_equal( {a: 2, b: 3},
+           {a: 1, b: 2}.map_v{|v| v + 1} )
+    h = Hash.new(:patate)
+    assert_equal( :patate, h.map_v{|x| x + 1}[:foo] )
+  end
+
+end

data/test/test_maybe.rb

@@ -0,0 +1,73 @@
+require 'test/unit'
+require 'funkr/types/maybe'
+require 'funkr/extensions'
+
+class TestMaybe < Test::Unit::TestCase
+
+  M = Funkr::Types::Maybe
+
+  def j(v)
+    M.just(v)
+  end
+
+  def n
+    M.nothing
+  end
+
+  def test_map
+    assert_equal(j(6), j(5).map{|v| v+1 })
+    assert_equal(n, j(5).map{|v| v+1})
+  end
+
+  def test_curry_lift
+    f = M.curry_lift_proc{|x,y| x + y}
+    assert_equal(j(8), f.apply(j(5)).apply(j(3)))
+    assert_equal(n, f.apply(j(5)).apply(n))
+  end
+
+  def test_or_else
+    assert_equal(j(10), n.or_else{j(10)})
+    assert_equal(j(4), j(4).or_else{j(2)})
+    # assert_nothing_raised(j(2).or_else{raise 'should not be raised'})
+  end
+
+  def test_full_lift
+    f = M.full_lift_proc{|x,y| x + y}
+    assert_equal(j(6), f.call(j(4),j(2)))
+    assert_equal(n, f.call(j(1),n))
+  end
+
+  def test_lift_with
+    assert_equal(j(7), M.lift_with(j(4),j(3)){|x,y| x + y})
+  end
+
+  def test_mconcat
+    assert_equal(j(60), M.mconcat([j(10), j(20), n, j(30)]))
+  end
+
+  def test_concat
+    assert_equal([10,20,30], M.concat([j(10), j(20), n, j(30)]))
+  end
+
+  def test_comparisons
+    assert_equal(j(0), j(5) <=> j(5))
+    assert_equal(j(-1), j(5) <=> j(7))
+    assert_equal(j(1), j(2) <=> j(1))
+    assert_equal(j(true), j(3) < j(7))
+    assert_equal(n, j(4) <=> n)
+    assert_equal(n, n <=> j(2))
+  end
+
+  def test_unbox
+    assert_equal(5, j(5).unbox)
+    assert_equal(5, j(5).unbox(2))
+    assert_equal(nil, n.unbox)
+    assert_equal(2, n.unbox(2))
+  end
+
+  def test_box
+    assert_equal(j(5), M.box(5))
+    assert_equal(n, M.box(nil))
+  end
+
+end

data/test/test_simple_records.rb

@@ -0,0 +1,25 @@
+require 'test/unit'
+require 'funkr/types/simple_record'
+
+class TestSimpleRecords < Test::Unit::TestCase
+
+  def test_simple_records
+    r = Funkr::Types::SimpleRecord.new(name: "Paul", age: 27, city: "Rennes")
+    name, age, city = r
+    assert_equal("Paul", name)
+    assert_equal(27, age)
+    assert_equal("Rennes", city)
+    name, age, city = r.with(age: 28, city: "Trouville")
+    assert_equal("Paul", name)
+    assert_equal(28, age)
+    assert_equal("Trouville", city)
+
+    r.name = "Paul R"
+    assert_equal("Paul R", r.name)
+
+    r.update!(name: "Paul")
+    n, _x, _y = r
+    assert_equal("Paul", n)
+  end
+
+end

metadata

@@ -1,34 +1,37 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: funkr
-version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 0
-  - 21
-  version: 0.0.21
+version: !ruby/object:Gem::Version
+  version: 0.0.22
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Paul Rivier
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-09-29 00:00:00 +02:00
-default_executable: 
-dependencies: []
-
-description: "[EXPERIMENTAL] Some functionnal constructs for ruby, like ADT, functors, monads"
-email: 
+date: 2011-10-14 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &15155260 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+  type: :development
+  prerelease: false
+  version_requirements: *15155260
+description: ! '[EXPERIMENTAL] Some functionnal constructs for ruby, like ADT, functors,
+  monads'
+email:
 - paul (dot) r (dot) ml (at) gmail (dot) com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - .gitignore
+- .travis.yml
 - Gemfile
 - Rakefile
 - funkr.gemspec
@@ -46,44 +49,40 @@ files:
 - lib/funkr/extensions/array.rb
 - lib/funkr/extensions/enumerable.rb
 - lib/funkr/extensions/fixnum.rb
+- lib/funkr/extensions/hash.rb
 - lib/funkr/types.rb
 - lib/funkr/types/container.rb
 - lib/funkr/types/failable.rb
 - lib/funkr/types/maybe.rb
 - lib/funkr/types/simple_record.rb
 - lib/funkr/version.rb
-- test/tests.rb
-has_rdoc: true
+- test/test_container.rb
+- test/test_extensions.rb
+- test/test_hash.rb
+- test/test_maybe.rb
+- test/test_simple_records.rb
 homepage: http://github.com/paul-r-ml/funkr
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: funkr
-rubygems_version: 1.3.7
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
-summary: "[EXPERIMENTAL] Some functionnal constructs for ruby"
+summary: ! '[EXPERIMENTAL] Some functionnal constructs for ruby'
 test_files: []
-

data/test/tests.rb

@@ -1,136 +0,0 @@
-$:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
-
-require 'rubygems'
-require 'funkr'
-require 'funkr/types'
-require 'funkr/extensions'
-
-include Funkr::Types
-
-m = Maybe.just(5)
-
-puts "\n> All different ?"
-puts([1,2,3].all_different?)
-puts([1,2,2,3].all_different?)
-
-puts "\n> Maybe"
-puts(m.match do |on|
-       on.nothing{ Maybe.nothing }
-       on.just{|v| Maybe.just(v + 1) }
-     end.to_s)
-
-puts(m.map{|v| v+1 })
-
-
-n = Maybe.nothing
-
-puts(n.match do |on|
-       on.nothing{ Maybe.nothing }
-       on.just{|v| Maybe.just(v + 1) }
-     end.to_s)
-
-
-puts "\n> Curry lift"
-f = Maybe.curry_lift_proc{|x,y| x + y}
-puts f.apply(m).apply(m)
-puts f.apply(m).apply(n)
-puts f.apply(m).apply(n.or_else{Maybe.just(10)})
-
-puts "\n> Full lift"
-f = Maybe.full_lift_proc{|x,y| x + y}
-puts f.call(m,m)
-puts f.call(m,n)
-
-puts "\n> Lift with"
-puts Maybe.lift_with(m,m){|x,y| x + y}
-
-puts "\n> mconcat"
-puts Maybe.mconcat([Maybe.just(10),
-                    Maybe.just(20),
-                    Maybe.nothing,
-                    Maybe.just(30)])
-
-puts "\n> concat"
-puts Maybe.concat([ Maybe.just(10),
-                    Maybe.just(20),
-                    Maybe.nothing,
-                    Maybe.just(30) ]).inspect
-
-puts "\n> Comparisons"
-puts(m <=> m)
-puts(m <=> (m.map{|v| v+1}))
-puts(m < (m.map{|v| v+1}))
-puts(m <=> n)
-
-puts "\n> Boxing and unboxing"
-puts m.unbox.inspect
-puts n.unbox.inspect
-puts (Maybe.box(12)).unbox.inspect
-puts (Maybe.box(nil)).unbox.inspect
-
-puts "\n> Containers"
-c = Container.new("Value")
-puts c.unbox
-puts c.map(&:reverse)
-
-a = [1,2,3]
-b = [10,20,30]
-
-puts "\n> Array full lift"
-f = Array.full_lift_proc{|x,y| x + y}
-puts f.call(a,b).inspect
-puts f.call(a,[]).inspect
-
-puts "\n> Array monad"
-puts(a.bind do |x|
-       b.bind do |y|
-         Array.unit(x + y)
-       end
-     end.inspect)
-
-
-puts "\n> span"
-puts([1,2,4,5,7,5,8,2,10].span{|x| x < 5}.inspect)
-
-puts "\n> group_seq_by"
-puts([1,2,4,5,7,5,8,2,10].group_seq_by{|x| x % 2}.inspect)
-
-puts "\n> groups_of"
-puts([1,2,4,5,7,5,8,2,10].groups_of(4).inspect)
-
-puts "\n> sliding_groups_of"
-puts((1..10).to_a.sliding_groups_of(3).inspect)
-
-puts "\n> seq_index (30)"
-puts((0..100).to_a.seq_index([30,31,32]))
-
-puts "\n> diff_with"
-a = [ {:v => 1}, {:v => 2}, {:v => 3}, {:v => 2}, {:v => 3} ]
-b = [ {:v => 2}, {:v => 3}, {:v => 4}, {:v => 3}, {:v => 4} ]
-puts(a.diff_with(b){|x,y| x[:v] == y[:v]}.inspect)
-
-puts "\n> make_uniq_by"
-a = [ {:v => 1}, {:v => 2}, {:v => 3}, {:v => 2}, {:v => 3}, {:v => 1} ]
-puts(a.make_uniq_by{|x,y| x[:v] == y[:v]}.inspect)
-
-
-puts "\n> SimpleRecords"
-r = SimpleRecord.new(name: "Paul", age: 27, city: "Rennes")
-puts r.to_s
-name, age, city = r
-puts format("%s is %s and lives in %s", name, age, city)
-name, age, city = r.with(age: 28, city: "Trouville")
-puts format("%s is now %s and lives in %s", name, age, city)
-puts format("%s is back to %s and really lives in %s", r.name, r.age, r.city)
-r.name = "Paul R"
-puts r.to_s
-r.update!(name: "Paul")
-n, _x, _y = r
-puts n
-
-class Person < SimpleRecord;  fields :name, :age, :city; end
-r = Person.new(name: "Paul", age: 27, city: "Rennes")
-puts r.to_s
-x = Person.new(name: "Paul", age: 27, city: "Rennes", genre: "Male") rescue "Forbidden"
-y = Person.new(name: "Paul", age: 27) rescue "Forbidden"
-