funkr 0.0.2

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in funkr.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/funkr.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "funkr/version"
+
+Gem::Specification.new do |s|
+  s.name        = "funkr"
+  s.version     = Funkr::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Paul Rivier"]
+  s.email       = ["paul (dot) r (dot) ml (at) gmail (dot) com"]
+  s.homepage    = "http://github.com/paul-r-ml/funkr"
+  s.summary     = %q{[EXPERIMENTAL] Some functionnal constructs for ruby}
+  s.description = %q{[EXPERIMENTAL] Some functionnal constructs for ruby, like ADT, functors, monads}
+
+  s.rubyforge_project = "funkr"
+
+  s.files         = `git ls-files`.split("\n")
+  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"]
+end

data/lib/funkr.rb

@@ -0,0 +1,3 @@
+module Funkr
+  # nada ...  
+end

data/lib/funkr/adt/adt.rb

@@ -0,0 +1,57 @@
+require "funkr/adt/matcher"
+
+module Funkr
+  class ADT
+
+    def initialize(const, *data)
+      @const, @data = const, data
+    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
+    
+    def match
+      m = self.class.matcher.new(normal_form)
+      yield m
+      m.run_match
+    end
+    
+    def to_s
+      format("%s%s%s",
+             @const,
+             @data.any? ? " : " : "",
+             @data.map(&:inspect).join(" ") )
+    end
+    
+    private
+
+    attr_reader :const, :data
+    
+    def normal_form; [@const, *@data]; end
+    
+    def self.build_adt(constructs)
+      constructs.each do |c,*d|
+        define_singleton_method(c) do |*data|
+          self.new(c,*data)
+        end
+      end
+    end
+    
+    def self.build_matcher(constructs)
+      @matcher = Class.new(Funkr::Matcher) do
+        build_matchers(constructs)
+      end
+    end
+
+  end
+end

data/lib/funkr/adt/matcher.rb

@@ -0,0 +1,33 @@
+module Funkr
+  class Matcher
+    
+    def initialize(match)
+      @const, *@data = match
+      @runner = nil
+      @undefined = self.class.constructs.clone
+    end
+    
+    def self.build_matchers(constructs)
+      @constructs = constructs
+      constructs.each do |c|
+        name, *data = c
+        define_method(name) do |&b|
+          @undefined.delete(name)
+          if @const == name then
+            @runner = b
+          end
+        end
+      end
+    end
+    
+    def self.constructs; @constructs; end
+    
+    def run_match
+      if @undefined.any? then
+        raise "Incomplete match, missing : #{@undefined.join(" ")}"
+      end
+      @runner.call(*@data)
+    end
+    
+  end
+end

data/lib/funkr/categories.rb

@@ -0,0 +1,5 @@
+require 'funkr/categories/functor'
+require 'funkr/categories/applicative'
+require 'funkr/categories/alternative'
+require 'funkr/categories/monoid'
+require 'funkr/categories/monad'

data/lib/funkr/categories/alternative.rb

@@ -0,0 +1,11 @@
+module Funkr
+  module Categories
+    module Alternative
+      
+      def or_else
+        raise "Alternative#or_else not implemented"
+      end
+      
+    end
+  end
+end

data/lib/funkr/categories/applicative.rb

@@ -0,0 +1,59 @@
+module Funkr
+  module Categories
+    module Applicative
+      
+      def apply
+        raise "Applicative#apply not implemented"
+      end
+
+      module ClassMethods
+        def curry_lift_proc(&block)
+          self.pure(block.curry)
+        end
+
+        def full_lift_proc(&block)
+          lambda do |*args|
+            args.inject(curry_lift_proc(&block)) do |a,e|
+              a.apply(e)
+            end
+          end
+        end
+      end
+
+      
+      def <=>(other)
+        proxy_comp(other){|a,b| a <=> b}
+      end
+      
+      def ==(other)
+        proxy_comp(other){|a,b| a == b}
+      end
+
+      def <(other)
+        proxy_comp(other){|a,b| a < b}
+      end
+
+      def <=(other)
+        proxy_comp(other){|a,b| a <= b}
+      end
+
+      def >(other)
+        proxy_comp(other){|a,b| a > b}
+      end
+
+      def >=(other)
+        proxy_comp(other){|a,b| a >= b}
+      end
+
+
+      private
+
+      def proxy_comp(other,&block)
+        self.class.
+          curry_lift_proc(&block).
+          apply(self).apply(other)
+      end
+
+    end
+  end
+end

data/lib/funkr/categories/functor.rb

@@ -0,0 +1,18 @@
+module Funkr
+  module Categories
+    module Functor
+      
+      def map
+        raise "Functor#map not implemented"
+      end
+
+
+      module ClassMethods
+
+      end
+    
+
+
+    end
+  end
+end

data/lib/funkr/categories/monad.rb

@@ -0,0 +1,23 @@
+module Funkr
+  module Categories
+    module Monad
+      
+      def bind(&block)
+        raise "Monad#bind not implemented"
+      end
+      
+      module ClassMethods
+        
+        def unit
+          raise "Monad.unit not implemented"
+        end
+        
+      end
+      
+      def bind_(&block)
+        self.bind{|*args| yield}
+      end
+      
+    end
+  end
+end

data/lib/funkr/categories/monoid.rb

@@ -0,0 +1,20 @@
+module Funkr
+  module Categories
+    module Monoid
+      
+      def mplus
+        raise "Monoid#mplus not implemented"
+      end
+      
+      module ClassMethods
+        def mzero
+          raise "Monoid#mzero not implemented"
+        end
+        
+        def mconcat(list)
+          list.inject(mzero){|a,e| a.mplus(e)}
+        end
+      end
+    end
+  end
+end

data/lib/funkr/extensions/fixnum.rb

@@ -0,0 +1,13 @@
+require "funkr/categories/monoid"
+
+class Fixnum
+  
+  include Monoid
+  extend Monoid::ClassMethods
+  
+  def mplus(y)
+    self + y
+  end
+  
+end
+

data/lib/funkr/types.rb

@@ -0,0 +1,2 @@
+require 'funkr/types/maybe'
+require 'funkr/types/failable'

data/lib/funkr/types/failable.rb

@@ -0,0 +1,81 @@
+require 'funkr/adt/adt'
+require 'funkr/categories'
+
+module Funkr
+  module Types
+    class Failable < ADT
+      
+      include Funkr::Categories
+      
+      adt :ok, :failed
+      
+      class << self
+        alias unit ok
+        alias pure ok
+      end
+      
+      include Functor
+      
+      def map(&block)
+        case self.const
+        when :ok then
+          Failable.ok(yield(*self.data))
+        else self
+        end
+      end
+      
+      include Applicative
+      
+      def apply(to)
+        self.match do |f_on|
+          f_on.ok do |f|
+            to.match do |t_on|
+              t_on.ok {|t| Failable.ok(f.call(t)) }
+              t_on.failed { to }
+            end
+          end
+          f_on.failed { self }
+        end
+      end
+      
+      
+      include Alternative
+      
+      def or_else(&block)
+        case self.const
+        when :ok then self
+        else yield
+        end
+      end
+      
+      
+      include Monoid
+      extend Monoid::ClassMethods
+      
+      def mplus(m_y)
+        self.match do |x_on|
+          x_on.failed { m_y }
+          x_on.ok do |x|
+            m_y.match do |y_on|
+              y_on.failed { self }
+              y_on.ok {|y| Failable.ok(x.mplus(y))}
+            end
+          end
+        end
+      end
+      
+      
+      include Monad
+      extend Monad::ClassMethods
+      
+      def bind(&block)
+        case self.const
+        when :ok then yield(*self.data)
+        else self
+        end
+      end
+      
+      
+    end
+  end
+end

data/lib/funkr/types/maybe.rb

@@ -0,0 +1,95 @@
+require 'funkr/adt/adt'
+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| Maybe.just(yield(v))}
+          on.nothing { self }
+        end
+      end
+      
+      include Applicative
+      extend Applicative::ClassMethods
+      
+      def apply(to)
+        self.match do |f_on|
+          f_on.just do |f|
+            to.match do |t_on|
+              t_on.just {|t| Maybe.unit(f.call(t)) }
+              t_on.nothing { to }
+            end
+          end
+          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 }
+          x_on.just do |x|
+            m_y.match do |y_on|
+              y_on.nothing { self }
+              y_on.just {|y| Maybe.just(x.mplus(y))}
+            end
+          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
+      
+      
+      class << self
+        alias unit just
+        alias pure just
+        alias mzero nothing
+      end
+      
+      def self.box(value)
+        if value.nil? then self.nothing
+        else self.just(value) end
+      end
+      
+      def unbox
+        self.match do |on|
+          on.just {|v| v }
+          on.nothing { nil }
+        end
+      end
+      
+    end
+  end
+end

data/lib/funkr/version.rb

@@ -0,0 +1,3 @@
+module Funkr
+  VERSION = "0.0.2"
+end

data/test/tests.rb

@@ -0,0 +1,49 @@
+require 'rubygems'
+require 'funkr/types'
+
+include Funkr::Types
+
+m = Maybe.just(5)
+
+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 Maybe.mconcat([Maybe.just(10),
+#                     Maybe.just(20),
+#                     Maybe.nothing,
+#                     Maybe.just(30)])
+
+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
+puts n.unbox
+puts (Maybe.box(12)).unbox
+puts (Maybe.box(nil)).unbox

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification 
+name: funkr
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- Paul Rivier
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-03 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+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: 
+- .gitignore
+- Gemfile
+- Rakefile
+- funkr.gemspec
+- lib/funkr.rb
+- lib/funkr/adt/adt.rb
+- lib/funkr/adt/matcher.rb
+- lib/funkr/categories.rb
+- lib/funkr/categories/alternative.rb
+- lib/funkr/categories/applicative.rb
+- lib/funkr/categories/functor.rb
+- lib/funkr/categories/monad.rb
+- lib/funkr/categories/monoid.rb
+- lib/funkr/extensions/fixnum.rb
+- lib/funkr/types.rb
+- lib/funkr/types/failable.rb
+- lib/funkr/types/maybe.rb
+- lib/funkr/version.rb
+- test/tests.rb
+has_rdoc: true
+homepage: http://github.com/paul-r-ml/funkr
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+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 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: funkr
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: "[EXPERIMENTAL] Some functionnal constructs for ruby"
+test_files: []
+