divergent 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a97dcb4c7b94772af15a5cc9ec0d794c163a29cf
-  data.tar.gz: fe5ed5e4799c1f2a78421f68e88ac579ec9fb23d
+  metadata.gz: 6f041ffcec9e7a3a5287941abf2e229cd6644229
+  data.tar.gz: 6ce3a0fe3cd1798cd1a96cf7f27a9e79f36fa871
 SHA512:
-  metadata.gz: 8494b52fd3c7c7b5d8dc22577ebd6d25059213c3860ea798cf2527cc3c9f8e7b86dfe29c93247ddef227c130976d2ac30cca3e5bf90bc62730d008faac6c00e7
-  data.tar.gz: 5ba285bb235e644015c16f1dc8153f1fa3f4ee8ce6f526006b3d93fb593315ed03d2edc39667ccbbb02eb0c115cb61373ef94dc931098429dc87b33e1d413636
+  metadata.gz: 2c19e6ec8931dc0d5a719c5ac5a6fd8603badd8672cab190106effac007230f9a281824b6dfd5c18ecd05d264ced8cf5be879565d2064d3131b8626820f0dd16
+  data.tar.gz: 0170760e83aed59e80d28b741b4adc7e947a222773292481956bd332907e7b8aeca0c16d11f741c64450fba7f46c4f3d8b7a9eaa574605e623207bff7572e22d

data/README.md

@@ -79,9 +79,9 @@ Try { 1 / 0 }.recover(ZeroDivisionError, &:message)
 
 ``` ruby
 # provide default value
-user = Maybe.unit User.find('a_non_exist_id')
+user = Maybe(User.find('a_non_exist_id'))
 user.get_or_else(default_user)
-user.or_else(Maybe.unit User.find_by_name("username"))
+user.or_else Maybe(User.find_by_name("username"))
 
 # usage as a collection
 user.each { |u| p u}

data/lib/divergent/maybe.rb

@@ -5,38 +5,23 @@ require_relative 'monad'
 
 module Divergent
   ##
-  # Represents optional values. Instances of Maybe
-  #  are either an instance of Some or the object None.
+  # == Optional values.
   #
-  #  The most idiomatic way to use an Maybe instance is to treat it
-  #  as a collection or monad and use `map`, `fmap`, `filter`, or
-  #  `each`.
+  # An instance of Some or the object None.
+  #
+  # The most idiomatic way to use an Maybe instance is to treat it
+  # as a collection or monad and use `map`, `fmap`, `filter`, or `each`.
   class Maybe
     include Monad
-
-    ##
-    # An Maybe factory which return None.
-    # This always return the same None object.
-    #
-    # Example:
-    #
-    # ```
-    # Maybe.empty == Maybe.empty
-    # ```
-    def self.empty
-      None
-    end
-
     ##
     # An factory which creates Some(v) if the argument is not nil,
     # and None if it is nil.
     #
     # Examples:
     #
-    # ```
-    # Maybe.unit(1)   # => Some(1)
-    # Maybe.unit(nil) # => None
-    # ```
+    #   Maybe.unit(1)   # => Some(1)
+    #   Maybe.unit(nil) # => None
+    #
     def self.unit(v)
       if v.nil?
         None
@@ -45,6 +30,20 @@ module Divergent
       end
     end
 
+
+    ##
+    # An Maybe factory which return None.
+    #
+    # This always return the same None object.
+    #
+    # Example:
+    #
+    #   Maybe.empty == Maybe.empty
+    #
+    def self.empty
+      None
+    end
+
     ##
     # Returns the result of applying block to this Maybe value,
     # if this value is not empty.
@@ -55,11 +54,10 @@ module Divergent
     #
     # Examples
     #
-    # ```
-    # Maybe.unit(1).fmap { |v| Maybe.unit(v + 1) } # => Some(2)
-    # some_hash = {}
-    # Maybe.unit(:a).fmap { |v| Maybe.unit(some_hash[v]) } # => None
-    # ```
+    #   Maybe.unit(1).fmap { |v| Maybe.unit(v + 1) } # => Some(2)
+    #   some_hash = {}
+    #   Maybe.unit(:a).fmap { |v| Maybe.unit(some_hash[v]) } # => None
+    #
     def fmap() # :yields: v
       if empty?
         None
@@ -120,11 +118,7 @@ module Divergent
     # This is similar to +flat_map+ except here,
     # block does not need to wrap its result in a maybe.
     def map() # :yields: v
-      if empty?
-        None
-      else
-        Maybe.unit(yield get)
-      end
+      fmap { |v| Maybe.unit(yield v) }
     end
 
 
@@ -132,10 +126,8 @@ module Divergent
     # Return this maybe if it is not empty and the predicate block evals to true.
     # Otherwise, return None.
     def filter() # :yields: v
-      if !empty? && yield(get)
-        self
-      else
-        None
+      fmap do |v|
+        yield(v) ? Maybe.unit(v) : None
       end
     end
 
@@ -144,11 +136,11 @@ module Divergent
     #
     # Examples:
     #
-    # ```
-    # Maybe.unit(1).include?(1) #=> true
-    # Maybe.unit(1).include?(2) #=> false
-    # Maybe.empty.include?(1) #=> false
-    # ```
+    #
+    #  Maybe.unit(1).include?(1) #=> true
+    #  Maybe.unit(1).include?(2) #=> false
+    #  Maybe.empty.include?(1) #=> false
+    #
     def include?(elem)
       !empty? && get == elem
     end
@@ -158,11 +150,11 @@ module Divergent
     #
     # Examples:
     #
-    # ```
-    # Maybe.unit(1).any?{ |v| v == 1} #=> true
-    # Maybe.unit(1).any?{ |v| v == 2} #=> false
-    # Maybe.empty.any?{ |v| v == 1} #=> false
-    # ```
+    #
+    #   Maybe.unit(1).any?{ |v| v == 1} #=> true
+    #   Maybe.unit(1).any?{ |v| v == 2} #=> false
+    #   Maybe.empty.any?{ |v| v == 1} #=> false
+    #
     def any?() # :yields: v
       !empty? && yield(get)
     end
@@ -173,11 +165,11 @@ module Divergent
     #
     # Examples:
     #
-    # ```
-    # Maybe.unit(1).all?{ |v| v == 1} #=> true
-    # Maybe.unit(1).all?{ |v| v == 2} #=> false
-    # Maybe.empty.all?{ |v| v == 1} #=> true
-    # ```
+    #
+    #   Maybe.unit(1).all?{ |v| v == 1} #=> true
+    #   Maybe.unit(1).all?{ |v| v == 2} #=> false
+    #   Maybe.empty.all?{ |v| v == 1} #=> true
+    #
     def all?() # :yields: v
       empty? || yield(get)
     end

data/lib/divergent/monad.rb

@@ -4,17 +4,26 @@ module Divergent
   #
   # Examples:
   #
-  # ```
-  # Maybe.unit(1) # => Some(1)
-  # Maybe.unit(1).fmap { |v| v + 1 } => Some(2)
-  # ```
+  #
+  #   Maybe.unit(1) # => Some(1)
+  #   Maybe.unit(1).fmap { |v| v + 1 } => Some(2)
+  #
   module Monad
-    def self.unit(v)
-      raise NotImplementedError
+    module InstanceMethods
+      def fmap(&f)
+        raise NotImplementedError
+      end
+    end
+
+    module ClassMethods
+      def unit(v)
+        raise NotImplementedError
+      end
     end
 
-    def fmap(&f)
-      raise NotImplementedError
+    def self.included(subclass)
+      subclass.extend ClassMethods
+      subclass.include InstanceMethods
     end
   end
 end

data/lib/divergent/try.rb

@@ -15,8 +15,10 @@ module Divergent
   # all of the places that an exception might occur.
   module Try
     include Monad
-    def self.unit(v)
-      Success.new(v)
+    def self.unit()
+      Success.new(yield)
+    rescue => e
+      Failure.new(e)
     end
 
     # Returns `true` if the `Try` is a `Failure`, `false` otherwise.
@@ -84,6 +86,7 @@ module Divergent
     # otherwise returns this if this is a `Success`.
     #
     # Notes: block call should return an instance of Try.
+    # And, error raised from the block call will not rescued by it!
     # This is like `fmap` for the exception.
     def recover_with(&block)
       raise NotImplementedError
@@ -93,6 +96,7 @@ module Divergent
     # and leave other error case unrecoverd.
     # If no class is given, recover it anyway.
     # The error instance(if this is a Failure) will be passed into the block.
+    # And, error raised from the block call will not rescued by it!
     # Otherwise returns this if this is a `Success`.
     #
     # This is like `fmap` for the exception.
@@ -156,25 +160,18 @@ module Divergent
     end
 
     def map()
-      t = begin
-            yield(@value)
-          rescue => e
-            Failure.new(e)
-          end
-
-      Success.new(t)
+      fmap do |v|
+        Try.unit { yield v }
+      end
     end
 
     def filter()
-      p = begin
-            yield(@value)
-          rescue => e
-            return Failure.new(e)
-          end
-      if p
-        self
-      else
-        Failure.new(NoSuchElementError.new("Predicate does not hold for #{@value}"))
+      fmap do |v|
+        if yield(v)
+          self
+        else
+          Failure.new(NoSuchElementError.new("Predicate does not hold for #{v}"))
+        end
       end
     end
 
@@ -249,11 +246,7 @@ module Divergent
     end
 
     def recover_with()
-      begin
-        yield(@error)
-      rescue => e
-        Failure.new(e)
-      end
+      yield(@error)
     end
 
     def recover(*errors)
@@ -264,12 +257,8 @@ module Divergent
 
       raise 'no block given' unless block_given?
 
-      begin
-        t = yield(@error)
-        Success.new(t)
-      rescue => e
-        Failure.new(e)
-      end
+      t = yield(@error)
+      Success.new(t)
     end
 
     def failed
@@ -303,9 +292,7 @@ module Divergent
   # method will ensure any StandardError is caught and a
   # `Failure` object is returned.
   def Try
-    Success.new(yield)
-  rescue => e
-    Failure.new(e)
+    Try.unit { yield }
   end
   module_function :Try
 end

data/lib/divergent/version.rb

@@ -1,3 +1,3 @@
 module Divergent
-  VERSION = "0.1.4"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: divergent
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - Cao Jiafeng
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-26 00:00:00.000000000 Z
+date: 2016-08-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -109,7 +109,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: a collection of monad implemented in ruby inspired by scala