dry-monads 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dae639cb8c6a7201b6486ed746ea0a07cdd34d39fb3df6565e84a76f4d135693
-  data.tar.gz: afd6150d91c54a90b8b69d3495e4f2408ab250a370b77e066a098eee24c1c100
+  metadata.gz: c819d8b433c150703fa74c233a2079c524e2841ddeb4acf073fef3e16ef54225
+  data.tar.gz: b2da0bd96075be4863bb2073b434489ecae1374ebf0cf5cf55ed11a89c07263f
 SHA512:
-  metadata.gz: f4eaad835abb5e00b562651d8393a27310e2c6808c3109785d7352123758a7f2e3d54ac293d99c6f1e5ff928b38fc352f0ab6b7637e1399be5444073078528cc
-  data.tar.gz: e2ef0c0ed1a9c759293a09fe640cee08601b0a97f0b8e282f9edd71ce28987e895cd84acf6e2f65e4de58909a6121037378f936ad1f6e68e361df8563c9210d0
+  metadata.gz: bbb8cb8fc13031cc1b75e9f830381b29cc89ae4652c58a927c45c474ae93bd13364a190cf0af792586fe25f5a9c3d6611e7dbdce01e63e4347d1fe56774201a4
+  data.tar.gz: 5a116f3c547e15ad14aa7d72894c4cbafb90f893033fa98c141e4e20a2644a48b741e1fcee762e4e417c4c9437803802e441b2ce7d07b4b7791f73f0e4457ca4

data/.travis.yml

@@ -10,11 +10,11 @@ before_install:
 after_success:
   - '[ -d coverage ] && bundle exec codeclimate-test-reporter'
 rvm:
-  - 2.2.9
-  - 2.3.6
-  - 2.4.3
-  - 2.5.0
-  - jruby-9.1.15.0
+  - 2.2.10
+  - 2.3.7
+  - 2.4.4
+  - 2.5.1
+  - jruby-9.2.0.0
   - ruby-head
 env:
   global:

data/CHANGELOG.md

@@ -1,3 +1,26 @@
+# v1.1.0 2018-10-16
+
+## Fixed
+
+* Do notation was made to work nicely with inheritance. This shouldn't break any existing code but if it does please report (flash-gordon)
+
+## Added
+
+* `Success()`, `Failure()`, and `Some()` now have `Unit` as a default argument:
+  ```ruby
+  include Dry::Monads::Result::Mixin
+  include Dry::Monads::Do
+
+  def call
+    yield do_1
+    yield do_2
+
+    Success() # returns Success(Unit)
+  end
+  ```
+
+[Compare v1.0.1...v1.1.0](https://github.com/dry-rb/dry-monads/compare/v1.0.1...v1.1.0)
+
 # v1.0.1 2018-08-11
 
 ## Fixed

data/lib/dry/monads/do.rb

@@ -76,7 +76,7 @@ module Dry
       # @return [Module]
       def self.for(*methods)
         mod = Module.new do
-          methods.each { |m| Do.wrap_method(self, m) }
+          methods.each { |method_name| Do.wrap_method(self, method_name) }
         end
 
         Module.new do
@@ -103,34 +103,35 @@ module Dry
       end
 
       # @private
-      def self.coerce_to_monad(ms)
-        return ms if ms.size != 1
+      def self.coerce_to_monad(monads)
+        return monads if monads.size != 1
 
-        fst = ms[0]
+        first = monads[0]
 
-        case fst
-        when Array, List
-          list = fst.is_a?(Array) ? List.coerce(fst) : fst
-          [list.traverse]
+        case first
+        when Array
+          [List.coerce(first).traverse]
+        when List
+          [first.traverse]
         else
-          ms
+          monads
         end
       end
 
       # @private
-      def self.wrap_method(target, method)
+      def self.wrap_method(target, method_name)
         target.module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-          def #{ method }(*)
+          def #{ method_name }(*)
             if block_given?
               super
             else
-              super do |*ms|
-                ms = Do.coerce_to_monad(ms)
-                unwrapped = ms.map { |r|
-                  m = r.to_monad
-                  m.or { Do.halt(m) }.value!
+              super do |*monads|
+                monads = Do.coerce_to_monad(monads)
+                unwrapped = monads.map { |result|
+                  monad = result.to_monad
+                  monad.or { Do.halt(monad) }.value!
                 }
-                ms.size == 1 ? unwrapped[0] : unwrapped
+                monads.size == 1 ? unwrapped[0] : unwrapped
               end
             end
           rescue Halt => e

data/lib/dry/monads/do/all.rb

@@ -69,18 +69,24 @@ module Dry
               define_method(:method_added) do |method|
                 super(method)
 
-                tracker.wrap_method(method)
+                tracker.wrap_method(self, method)
+              end
+
+              define_method(:inherited) do |base|
+                super(base)
+
+                base.prepend(wrappers[base])
               end
             end
           end
 
           def extend_object(target)
             super
-            target.prepend(wrappers)
+            target.prepend(wrappers[target])
           end
 
-          def wrap_method(method)
-            Do.wrap_method(wrappers, method)
+          def wrap_method(target, method)
+            Do.wrap_method(wrappers[target], method)
           end
         end
 
@@ -88,9 +94,10 @@ module Dry
         def self.included(base)
           super
 
-          tracker = MethodTracker.new(Module.new)
+          wrappers = Hash.new { |h, k| h[k] = Module.new }
+          tracker = MethodTracker.new(wrappers)
           base.extend(tracker)
-          base.instance_methods(false).each { |m| tracker.wrap_method(m) }
+          base.instance_methods(false).each { |m| tracker.wrap_method(base, m) }
         end
       end
     end

data/lib/dry/monads/maybe.rb

@@ -4,6 +4,7 @@ require 'dry/core/deprecations'
 
 require 'dry/monads/right_biased'
 require 'dry/monads/transformer'
+require 'dry/monads/unit'
 
 module Dry
   module Monads
@@ -87,9 +88,9 @@ module Dry
         include Dry::Equalizer(:value!)
         include RightBiased::Right
 
-        def initialize(value)
+        def initialize(value = Undefined)
           raise ArgumentError, 'nil cannot be some' if value.nil?
-          @value = value
+          @value = Undefined.default(value, Unit)
         end
 
         # Does the same thing as #bind except it also wraps the value
@@ -209,8 +210,7 @@ module Dry
           #   @return [Maybe::Some]
           #
           def Some(value = Undefined, &block)
-            v = Undefined.default(value, block)
-            raise ArgumentError, 'No value given' if !value.nil? && v.nil?
+            v = Undefined.default(value, block || Unit)
             Some.new(v)
           end
 

data/lib/dry/monads/result.rb

@@ -4,6 +4,7 @@ require 'dry/monads/undefined'
 require 'dry/monads/right_biased'
 require 'dry/monads/transformer'
 require 'dry/monads/conversion_stubs'
+require 'dry/monads/unit'
 
 module Dry
   module Monads
@@ -248,8 +249,7 @@ module Dry
           #   @return [Result::Success]
           #
           def Success(value = Undefined, &block)
-            v = Undefined.default(value, block)
-            raise ArgumentError, 'No value given' if !value.nil? && v.nil?
+            v = Undefined.default(value, block || Unit)
             Success.new(v)
           end
 
@@ -264,8 +264,7 @@ module Dry
           #   @return [Result::Failure]
           #
           def Failure(value = Undefined, &block)
-            v = Undefined.default(value, block)
-            raise ArgumentError, 'No value given' if !value.nil? && v.nil?
+            v = Undefined.default(value, block || Unit)
             Failure.new(v, RightBiased::Left.trace_caller)
           end
         end
@@ -299,6 +298,8 @@ module Dry
     #       Types.Value(:user_not_found) |
     #       Types.Value(:account_not_found)
     #
+    #     include Dry::Monads::Result(Error)
+    #
     #     def find_account(id)
     #       account = acount_repo.find(id)
     #

data/lib/dry/monads/result/fixed.rb

@@ -17,8 +17,9 @@ module Dry::Monads
             end
           end
 
-          def Success(value)
-            Success.new(value)
+          def Success(value = Undefined, &block)
+            v = Undefined.default(value, block || Unit)
+            Success.new(v)
           end
         end
       end

data/lib/dry/monads/unit.rb

@@ -2,6 +2,22 @@
 
 module Dry
   module Monads
+    # Unit is a special object you can use whenever your computations don't
+    # return any payload. Previously, if your function ran a side-effect
+    # and returned no meaningful value, you had to return things like
+    # Success(nil), Success([]), Success({}), Maybe(""), Success(true) and
+    # so forth.
+    #
+    # You should use Unit if you wish to return an empty monad.
+    #
+    # @example with Result
+    #   Success(Unit)
+    #   Failure(Unit)
+    #
+    # @example with Maybe
+    #   Maybe(Unit)
+    #   => Some(Unit)
+    #
     Unit = Object.new.tap do |unit|
       def unit.to_s
         'Unit'

data/lib/dry/monads/version.rb

@@ -1,6 +1,6 @@
 module Dry
   module Monads
     # @private
-    VERSION = '1.0.1'.freeze
+    VERSION = '1.1.0'.freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dry-monads
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
 platform: ruby
 authors:
 - Nikita Shilnikov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-08-11 00:00:00.000000000 Z
+date: 2018-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-equalizer