funkr 0.0.24 → 0.0.30

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7cb4f5366a7c1c68082cb5982e5cd7700440d94344fdfb8cdff7bd94b723bb4a
+  data.tar.gz: 4c79978d034dbbc0fc650644808ca3de77efa6e934770a4602d09ea042891c01
+SHA512:
+  metadata.gz: e2767fe18dbf634574240a8b40acf5a8d42f2caa0770605a3b9b5e25ff62b9307552088da7a381f9c3a5e5ee3cb2b9dd2a6db93f7d8034b7ad6641d595cc5307
+  data.tar.gz: c7110ff660fb041f5f09b63bff32e187c99fccfec855d75d1be99993115f1654255144185140cdd1b47dffc4c78d3a8d2fac0e4d60fe9ab2ab120ef05726c6ed

data/README

@@ -1,13 +1,16 @@
 Funkr brings some common functional programming constructs to ruby.
 
-In particular, it offers a simple mechanism to create Algebraïc Data
-Types and do pattern matching on them. For an exemple
-implementation, {Funkr::Types see provided classes}.
+In particular, it offers a simple mechanism to create Algebraic Data
+Types and do pattern matching on them. For an exemple implementation,
+see provided classes.
 
 It also provide modules for common categories (Monoid, Monad,
 Functor, Applicative ...), and extends common types to support
 categories they belongs to (Array, Hash ...). Categories can also be
-used with custom types, {Funkr::Types see provided classes}.
+used with custom types,  see provided classes.
 
 To get started, we recommand you to read the tests, and get feets wet
-with provided Algebraic Data Types (like Maybe).
+with provided Algebraic Data Types (like Maybe).
+
+Funkr is heavily used by its authors in production at
+http://www.atikteam.com/en to ensure better code reliability.

data/funkr.gemspec

@@ -1,4 +1,3 @@
-# -*- encoding: utf-8 -*-
 $:.push File.expand_path("../lib", __FILE__)
 require "funkr/version"
 
@@ -9,8 +8,27 @@ Gem::Specification.new do |s|
   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.summary     = %q{Functionnal toolbox for Ruby}
+  s.description = <<EOF
+Funkr is a functionnal toolbox for the Ruby language.
+
+In particular, it offers a simple mechanism to create Algebraic Data
+Types and do pattern matching on them.
+
+-
+
+It also provide modules for common categories (Monoid, Monad,
+Functor, Applicative ...), and extends common types to support
+categories they belongs to (Array, Hash ...). Categories can also be
+used with custom types,  see provided classes.
+
+-
+
+Array and Hash classes are extended with methods providing correct
+behaviour with respect to categories. Enumerable module comes with
+a lot of useful functions for working with lists and sets. See the
+module documentation and the test suite for examples.
+EOF
 
   s.rubyforge_project = "funkr"
 
@@ -18,5 +36,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'
+  s.add_development_dependency 'rake', '~> 12.3'
 end

data/lib/funkr/adt/adt.rb

@@ -13,7 +13,7 @@ module Funkr
     end
 
     # Declare ADT constructors, for example :
-    # class Maybe < ADT;  adt :just, :nothing; end
+    #   class Maybe < ADT;  adt :just, :nothing; end
     def self.adt(*constructs)
       build_adt(constructs)
       build_matcher(constructs)
@@ -22,11 +22,11 @@ module Funkr
     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
+    #   a = Maybe.just("hello")
+    #   a.match do |on|
+    #     on.just{|x| puts x}
+    #     on.nothing{ }
+    #   end
     def match(&block)
       self.class.matcher.match_with(normal_form, &block)
     end

data/lib/funkr/adt/matcher.rb

@@ -14,7 +14,7 @@ module Funkr
       def self.build_matchers(constructs)
         @constructs = constructs
         constructs.each do |c|
-          name, *data = c
+          name, *_ = c
           define_method(name) do |&b|
             @undefined.delete(name)
             if @const == name then

data/lib/funkr/extensions.rb

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

data/lib/funkr/extensions/array.rb

@@ -17,9 +17,10 @@ class Array
 
 
   # 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([]) => []
+  #
+  #   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
 
@@ -49,10 +50,12 @@ class Array
   end
 
 
-  # Array is also a monad
   include Monad
   extend Monad::ClassMethods
 
+  # Array is also a monad
+  #
+  # [1,2].bind{|x| [3,4].bind{|y| x + y}} # => [4,5,5,6]
   def bind(&block)
     self.map(&block).flatten(1)
   end

data/lib/funkr/extensions/enumerable.rb

@@ -40,26 +40,27 @@ module Enumerable
     return [ inc, [] ]
   end
 
-  # Constitue des groupes disjoints de n éléments au plus
+  # builds up disjoint groups of n elements or less
   def groups_of(n)
     g = self.take(n)
     return [] if g.empty?
     [g] + self.drop(n).groups_of(n)
   end
 
-  # constitue des groupes de n éléments exactement, décalés de 1
+  # builds up sliding groups of exactly n elements
   def sliding_groups_of(n)
     return [] if self.size < n
     [ self.take(n) ] + self.drop(1).sliding_groups_of(n)
   end
 
-  # trouve l'index d'une séquence
+  # find the position of a sequence
+  #  [1,2,3,4,5,4,3,2,1].seq_index([4,3])  # => 5
   def seq_index(seq)
     self.sliding_groups_of(seq.size).index(seq)
   end
 
-  # Prend un prédicat p(x,y), et construit un tableau dans lequel tous
-  # les couples (a,b), tels que 'a' précède 'b', vérifient p(a,b).
+  # Takes a block predicate p(x,y) and builds an array of elements so
+  # that for any (a,b), a being before b in the list, p(a,b) holds.
   def make_uniq_by(&block)
     result = []
     self.each do |e|
@@ -68,8 +69,7 @@ module Enumerable
     return result
   end
 
-  # difference entre 2 tableaux, retourne le triplet [ [missing] , [intersection], [added] ]
-  # codé en impératif parce que inject est trop lent :(
+  # compare 2 enumerables, and returns [ [missing] , [intersection], [added] ]
   def diff_with(other, &block)
     m, i, a = [], [], []
     u_s = self.make_uniq_by(&block)

data/lib/funkr/extensions/{fixnum.rb → integer.rb}

@@ -1,6 +1,6 @@
 require "funkr/categories/monoid"
 
-class Fixnum
+class Integer
 
   include Funkr::Categories
   
@@ -10,6 +10,9 @@ class Fixnum
   def mplus(y)
     self + y
   end
+
+  def self.mzero
+    0
+  end
   
 end
-

data/lib/funkr/types/maybe.rb

@@ -23,18 +23,18 @@ module Funkr
       ### Categories
 
       include Functor
-
-      # Maybe.nothing.map{|x| something(x)} # => nothing
-      # Maybe.just(x).map{|x| something(x)} # => just something(x)
-      #
+      
       # {Funkr::Categories::Functor#map see functor map}
+      #
+      #   Maybe.nothing.map{|x| something(x)} # => nothing
+      #   Maybe.just(x).map{|x| something(x)} # => just something(x)
       def map(&block)
         # This implementation isn't safe but is a bit faster than the
         # safe one. A safe implementation would be as follow :
-        # self.match do |on|
-        #   on.just {|v| self.class.just(yield(v))}
-        #   on.nothing { self }
-        # end
+        #   self.match do |on|
+        #     on.just {|v| self.class.just(yield(v))}
+        #     on.nothing { self }
+        #   end
         if self.just? then self.class.just(yield(unsafe_content))
         else self end
       end
@@ -42,27 +42,27 @@ module Funkr
       include Applicative
       extend Applicative::ClassMethods
 
-      # 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
-      #
       # {Funkr::Categories::Applicative#apply see applicative apply}
+      #
+      # 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
       def apply(to)
         # This implementation isn't safe but is a bit faster than the
         # safe one. A safe implementation would be as follow :
-        # self.match do |f_on|
-        #   f_on.just do |f|
-        #     to.match do |t_on|
-        #       t_on.just {|t| self.class.unit(f.call(t)) }
-        #       t_on.nothing { to }
+        #   self.match do |f_on|
+        #     f_on.just do |f|
+        #       to.match do |t_on|
+        #         t_on.just {|t| self.class.unit(f.call(t)) }
+        #         t_on.nothing { to }
+        #       end
         #     end
+        #     f_on.nothing { self }
         #   end
-        # f_on.nothing { self }
-        # end
         if self.just? and to.just? then
           self.class.unit(self.unsafe_content.call(to.unsafe_content))
         else self.class.nothing end
@@ -103,10 +103,10 @@ module Funkr
       def bind(&block)
         # This implementation isn't safe but is a bit faster than the
         # safe one. A safe implementation would be as follow :
-        # self.match do |on|
-        #   on.just {|v| yield(v)}
-        #   on.nothing {self}
-        # end
+        #   self.match do |on|
+        #     on.just {|v| yield(v)}
+        #     on.nothing {self}
+        #   end
         if self.just? then yield(self.unsafe_content)
         else self end
       end

data/lib/funkr/types/simple_record.rb

@@ -11,16 +11,17 @@ module Funkr
     #    mistyping it or by combining it with a different structure
     #  - you have easy access to fields : named AND positional
     #
-    # usage : r = SimpleRecord.new(Hash), then r.field
-    # r = SimpleRecord.new( name: "Paul", age: 27 )
-    # r.name # => "Paul"
-    # r.age  # => 27
-    # name, age = r  # => [ "Paul", 27 ]
-    # r.with(age: 29)  # => [ "Paul", 29 ]
+    # usage :
+    #
+    #   r = SimpleRecord.new( name: "Paul", age: 27 )
+    #   r.name # => "Paul"
+    #   r.age  # => 27
+    #   name, age = r  # => [ "Paul", 27 ]
+    #   r.with(age: 29)  # => [ "Paul", 29 ]
     #
     # other usage :
-    # class Person < SimpleRecord; fields :name, :age; end
-    # Person.new( name: Paul ) => Error, missing :age
+    #   class Person < SimpleRecord; fields :name, :age; end
+    #   Person.new( name: Paul ) => Error, missing :age
     class SimpleRecord < Array
 
       class << self; attr_accessor :fields_list; end

data/lib/funkr/version.rb

@@ -1,3 +1,3 @@
 module Funkr
-  VERSION = "0.0.24"
+  VERSION = "0.0.30"
 end

data/test/test_extensions.rb

@@ -66,4 +66,9 @@ class TestExtensions < Test::Unit::TestCase
                  a.make_uniq_by{|x,y| x[:v] == y[:v]})
   end
 
+
+  def test_mconcat_integer
+    assert_equal(6, Integer.mconcat([1,2,3]))
+  end
+
 end

metadata

@@ -1,49 +1,56 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: funkr
-version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 0
-  - 24
-  version: 0.0.24
+version: !ruby/object:Gem::Version
+  version: 0.0.30
 platform: ruby
-authors: 
+authors:
 - Paul Rivier
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-12-06 00:00:00 +01:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2020-11-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rake
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        - 9
-        - 2
-        version: 0.9.2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
   type: :development
-  version_requirements: *id001
-description: "[EXPERIMENTAL] Some functionnal constructs for ruby, like ADT, functors, monads"
-email: 
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+description: |
+  Funkr is a functionnal toolbox for the Ruby language.
+
+  In particular, it offers a simple mechanism to create Algebraic Data
+  Types and do pattern matching on them.
+
+  -
+
+  It also provide modules for common categories (Monoid, Monad,
+  Functor, Applicative ...), and extends common types to support
+  categories they belongs to (Array, Hash ...). Categories can also be
+  used with custom types,  see provided classes.
+
+  -
+
+  Array and Hash classes are extended with methods providing correct
+  behaviour with respect to categories. Enumerable module comes with
+  a lot of useful functions for working with lists and sets. See the
+  module documentation and the test suite for examples.
+email:
 - paul (dot) r (dot) ml (at) gmail (dot) com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-- .gitignore
-- .travis.yml
+files:
+- ".gitignore"
+- ".travis.yml"
 - Gemfile
 - README
 - Rakefile
@@ -61,8 +68,8 @@ files:
 - lib/funkr/extensions.rb
 - lib/funkr/extensions/array.rb
 - lib/funkr/extensions/enumerable.rb
-- lib/funkr/extensions/fixnum.rb
 - lib/funkr/extensions/hash.rb
+- lib/funkr/extensions/integer.rb
 - lib/funkr/types.rb
 - lib/funkr/types/container.rb
 - lib/funkr/types/failable.rb
@@ -74,37 +81,27 @@ files:
 - test/test_hash.rb
 - test/test_maybe.rb
 - test/test_simple_records.rb
-has_rdoc: true
 homepage: http://github.com/paul-r-ml/funkr
 licenses: []
-
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: funkr
-rubygems_version: 1.3.7
+rubygems_version: 2.7.6.2
 signing_key: 
-specification_version: 3
-summary: "[EXPERIMENTAL] Some functionnal constructs for ruby"
+specification_version: 4
+summary: Functionnal toolbox for Ruby
 test_files: []
-