funkr 0.0.24 → 0.0.25

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/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.25"
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 24
-  version: 0.0.24
+  - 25
+  version: 0.0.25
 platform: ruby
 authors: 
 - Paul Rivier