dry-monads 1.0.0.beta1 → 1.0.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e39ab380c859836fb98aad8bc158eeafb73896472cc703254c0f21490c6cde68
-  data.tar.gz: 749f9cf55040d0cafc8f8f4e3d8c60a8e2486768223069adff7f0b4c55cc9a43
+  metadata.gz: 9b72d0fd34804b1fb9f751b61ffe8799386c3836a90625266948469439f576ad
+  data.tar.gz: 3303c72e17d0e905a8ac036c9ebd316fdfcbf6414ab3473d5c18a70ddf5fba01
 SHA512:
-  metadata.gz: 3c66d5ea73e5c781e26acfb1611067a34cc25a9fbbb258a01ad8f5705b33cd569944ae9eab126e18456b4f6eeec0722163e39406e52c332e5224a78b5dae53e9
-  data.tar.gz: 73a8d308f628a5ea630cabdaf240f67627e3310ec3cf64a75cec7140b6c5645853cfcf50ecc463a38f1813c28b78a145d7d40ec45998327c7cbedce1177c60c5
+  metadata.gz: d7ec39938788dcc849f49125404790685785e76a881624df0ab0dd6ff7a9d25d1af2938dfa1af9854cc6b007417c0079a1f6d378bd155704f980cce02a6c279a
+  data.tar.gz: 1b9c4604241164988bc65e5da83b7d33445fda6c7de4de8f93d04d4cf2ae3d0e3592d367961469fe6858f7f58c7b83a89c5a7de01cf99a8108b3294370804b07

data/CHANGELOG.md

@@ -2,7 +2,7 @@
 
 ## Added
 
-* `do`-like notation (the idea comes from Haskell of course). This is the biggest and most important addition in the release which greatly increases the ergonomics of using monads in Ruby. Basically, almost everything it does is passing a block to a given method. You call `yield` on monads to extract the values. If any operation fails i.e. no value can be extracted, the whole computation is halted and the failing step becomes a result. With `Do` you don't need to chain monadic values with `fmap/bind` and block, everything can be done on a single level of indentation. Here is a more or less real-life example:
+* `do`-like notation (the idea comes from Haskell of course). This is the biggest and most important addition to the release which greatly increases the ergonomics of using monads in Ruby. Basically, almost everything it does is passing a block to a given method. You call `yield` on monads to extract the values. If any operation fails i.e. no value can be extracted, the whole computation is halted and the failing step becomes a result. With `Do` you don't need to chain monadic values with `fmap/bind` and block, everything can be done on a single level of indentation. Here is a more or less real-life example:
 
   ```ruby
   class CreateUser
@@ -42,7 +42,7 @@
     def create_user(user_data)
       Try[Sequel::Error] { user_repo.create(user_data) }.to_result
     end
- 
+
     def create_profile(user, profile_data)
       Try[Sequel::Error] {
         user_repo.create_profile(user, profile_data)
@@ -53,7 +53,7 @@
 
   In the code above any `yield` can potentially fail and return the failure reason as a result. In other words, `yield None` acts as `return None`. Internally, `Do` uses exceptions, not `return`, this is somewhat slower but allows to detect failed operations in DB-transactions and roll back the changes which far more useful than an unjustifiable speed boost (flash-gordon)
 
-* The `Task` monad based on `Promise` from the [`concurrent-ruby` gem](https://github.com/ruby-concurrency/concurrent-ruby/). `Task` represents an asynchrounos computation which _can be_ (doesn't have to!) run on a seperated thread. `Promise` already offers a good API and implemented in a safe manner so `dry-monads` just adds a monad-compatible interface for it. Out of the box, `concurrent-ruby` has three types of executors for running blocks: `:io`, `:fast`, `:immediate`, check out [the docs](http://ruby-concurrency.github.io/concurrent-ruby/root/Concurrent.html#executor-class_method) for details. You can provide your own executor if needed (flash-gordon)
+* The `Task` monad based on `Promise` from the [`concurrent-ruby` gem](https://github.com/ruby-concurrency/concurrent-ruby/). `Task` represents an asynchronous computation which _can be_ (doesn't have to!) run on a separated thread. `Promise` already offers a good API and implemented in a safe manner so `dry-monads` just adds a monad-compatible interface for it. Out of the box, `concurrent-ruby` has three types of executors for running blocks: `:io`, `:fast`, `:immediate`, check out [the docs](http://ruby-concurrency.github.io/concurrent-ruby/root/Concurrent.html#executor-class_method) for details. You can provide your own executor if needed (flash-gordon)
 
   ```ruby
   include Dry::Monads::Task::Mixin
@@ -61,7 +61,7 @@
   def call
     name = Task { get_name_via_http }    # runs a request in the background
     email = Task { get_email_via_http }  # runs another one request in the background
-  
+
     # to_result forces both computations/requests to complete by pausing current thread
     # returns `Result::Success/Result::Failure`
     name.bind { |n| email.fmap { |e| create(e, n) } }.to_result
@@ -87,15 +87,15 @@
   list = List::Task[Task { get_name }, Task { get_email }]
   list.traverse # => Task(List['John', 'john@doe.org'])
   ```
-  
+
   The code above runs two tasks in parallel and automatically combines their results with `traverse` (flash-gordon)
-  
+
 * `Try` got a new call syntax supported in Ruby 2.5+
 
   ```ruby
-    Try[ArgumentError, TypeError] { unsafe_operation } 
+    Try[ArgumentError, TypeError] { unsafe_operation }
   ```
-  
+
   Prior to 2.5, it wasn't possible to pass a block to `[]`.
 
 * The `Validated` “monad” that represents a result of a validation. Suppose, you want to collect all the errors and return them at once. You can't have it with `Result` because when you `traverse` a `List` of `Result`s it returns the first value and this is the correct behavior from the theoretical point of view. `Validated`, in fact, doesn't have a monad instance but provides a useful variant of applicative which concatenates the errors.
@@ -103,31 +103,41 @@
   ```ruby
     include Dry::Monads
     include Dry::Monads::Do.for(:call)
-    
+
     def call(input)
       name, email = yield [
         validate_name(input[:name]),
         validate_email(input[:email])
       ]
-      
+
       Success(create(name, email))
     end
-    
-    # can return 
+
+    # can return
     # * Success(User(...))
     # * Invalid(List[:invalid_name])
-    # * Invalid(List[:invalid_email])    
-    # * Invalid(List[:invalid_name, :invalid_email])    
+    # * Invalid(List[:invalid_email])
+    # * Invalid(List[:invalid_name, :invalid_email])
   ```
-  
-  In the example above an array of `Validated` values is implicitly casted to `List::Validated`. It's supported because it's useful but don't forget it's all about types and don't mix different types of monads in a single array, the consequences are unclear. You always can be explicit with `List::Validated[validate_name(...), ...]`, choose what you like (flash-gordon).
-  
-* `Failure`, `None`, and `Invalid` values now store the line where they were created. On of the biggest downside of dealing wtih monadic code is lack of backtraces. If you have a long list of computations and one of them fails how do you know where did it actually happen? Say, you've got `None` and this tells you nothing about _what variable_ was assigned to `None`. It makes sense to use `Result` instead of `Maybe` and use distinct errors everywhere but it doesn't always look good and forces you to think more. TLDR; call `.trace` to get the line where a fail-case was constructed
+
+  In the example above an array of `Validated` values is implicitly coerced to `List::Validated`. It's supported because it's useful but don't forget it's all about types so don't mix different types of monads in a single array, the consequences are unclear. You always can be explicit with `List::Validated[validate_name(...), ...]`, choose what you like (flash-gordon).
+
+* `Failure`, `None`, and `Invalid` values now store the line where they were created. One of the biggest downsides of dealing with monadic code is lack of backtraces. If you have a long list of computations and one of them fails how do you know where did it actually happen? Say, you've got `None` and this tells you nothing about _what variable_ was assigned to `None`. It makes sense to use `Result` instead of `Maybe` and use distinct errors everywhere but it doesn't always look good and forces you to think more. TLDR; call `.trace` to get the line where a fail-case was constructed
 
   ```ruby
   Failure(:invalid_name).trace # => app/operations/create_user.rb:43
   ```
-  
+
+* `Dry::Monads::Unit` which can be used as a replacement for `Success(nil)` and in similar situations when you have side effects yet doesn't return anything meningful as a result. There's also the `.discard` method for mapping any successful result (i.e. `Success(?)`, `Some(?)`, `Value(?)`, etc) to `Unit`.
+
+  ```ruby
+    # we're making an HTTP request but "forget" any successful result,
+    # we only care if the task was complete without an error
+    Task { do_http_request }.discard
+    # ... wait for the task to finish ...
+    # => Task(valut=Unit)
+  ```
+
 ## Deprecations
 
 * `Either`, the former name of `Result`, is now deprecated
@@ -135,6 +145,7 @@
 ## BREAKING CHANGES
 
 * `Either#value` and `Maybe#value` were both droped, use `value_or` or `value!` when you :100: sure it's safe
+* `require 'dry/monads'` doesn't load all monads anymore, use `require 'dry/monads/all'` instead or cherry pick them with `require 'dry/monads/maybe'` etc (timriley)
 
 [Compare v0.4.0...v1.0.0](https://github.com/dry-rb/dry-monads/compare/v0.4.0...master)
 

data/bin/console

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
 require 'bundler/setup'
-require 'dry-monads'
+require 'dry/monads/all'
 
 M = Dry::Monads
 

data/lib/dry/monads.rb

@@ -1,87 +1,14 @@
-require 'dry/core/constants'
-require 'dry/monads/maybe'
-require 'dry/monads/try'
-require 'dry/monads/list'
-require 'dry/monads/task'
-require 'dry/monads/lazy'
-require 'dry/monads/result'
-require 'dry/monads/result/fixed'
-require 'dry/monads/do'
-require 'dry/monads/validated'
-
 module Dry
   # Common, idiomatic monads for Ruby
   #
   # @api public
   module Monads
-    # @private
-    Undefined = Dry::Core::Constants::Undefined
-
-    # List of monad constructors
-    CONSTRUCTORS = [
-      Maybe::Mixin::Constructors,
-      Result::Mixin::Constructors,
-      Validated::Mixin::Constructors,
-      Try::Mixin::Constructors,
-      Task::Mixin::Constructors,
-      Lazy::Mixin::Constructors
-    ].freeze
-
-    # @see Maybe::Some
-    Some = Maybe::Some
-    # @see Maybe::None
-    None = Maybe::None
-    # @see Result::Success
-    Success = Result::Success
-    # @see Result::Failure
-    Failure = Result::Failure
-    # @see Validated::Valid
-    Valid = Validated::Valid
-    # @see Validated::Invalid
-    Invalid = Validated::Invalid
-
-    extend(*CONSTRUCTORS)
-
-    # @private
     def self.included(base)
-      super
-
-      base.include(*CONSTRUCTORS)
-    end
-
-    # Creates a module that has two methods: `Success` and `Failure`.
-    # `Success` is identical to {Result::Mixin::Constructors#Success} and Failure
-    # rejects values that don't conform the value of the `error`
-    # parameter. This is essentially a Result type with the `Failure` part
-    # fixed.
-    #
-    # @example using dry-types
-    #   module Types
-    #     include Dry::Types.module
-    #   end
-    #
-    #   class Operation
-    #     # :user_not_found and :account_not_found are the only
-    #     # values allowed as failure results
-    #     Error =
-    #       Types.Value(:user_not_found) |
-    #       Types.Value(:account_not_found)
-    #
-    #     def find_account(id)
-    #       account = acount_repo.find(id)
-    #
-    #       account ? Success(account) : Failure(:account_not_found)
-    #     end
-    #
-    #     def find_user(id)
-    #       # ...
-    #     end
-    #   end
-    #
-    # @param error [#===] the type of allowed failures
-    # @return [Module]
-    def self.Result(error, **options)
-      Result::Fixed[error, **options]
+      if const_defined?(:CONSTRUCTORS)
+        base.include(*CONSTRUCTORS)
+      else
+        raise "Load all monads first with require 'dry/monads/all'"
+      end
     end
   end
 end

data/lib/dry/monads/all.rb

@@ -0,0 +1,26 @@
+require 'dry/monads'
+require 'dry/monads/do'
+require 'dry/monads/lazy'
+require 'dry/monads/list'
+require 'dry/monads/maybe'
+require 'dry/monads/result'
+require 'dry/monads/result/fixed'
+require 'dry/monads/task'
+require 'dry/monads/try'
+require 'dry/monads/validated'
+
+module Dry
+  module Monads
+    # List of monad constructors
+    CONSTRUCTORS = [
+      Lazy::Mixin::Constructors,
+      Maybe::Mixin::Constructors,
+      Result::Mixin::Constructors,
+      Task::Mixin::Constructors,
+      Try::Mixin::Constructors,
+      Validated::Mixin::Constructors,
+    ].freeze
+
+    extend(*CONSTRUCTORS)
+  end
+end

data/lib/dry/monads/conversion_stubs.rb

@@ -0,0 +1,31 @@
+module Dry
+  module Monads
+    module ConversionStubs
+      def self.[](*method_names)
+        Module.new do
+          method_names.each do |name|
+            define_method(name) do |*|
+              Methods.public_send(name)
+            end
+          end
+        end
+      end
+
+      module Methods
+        module_function
+
+        def to_maybe
+          raise "Load Maybe first with require 'dry/monads/maybe'"
+        end
+
+        def to_result
+          raise "Load Result first with require 'dry/monads/result'"
+        end
+
+        def to_validated
+          raise "Load Validated first with require 'dry/monads/validated'"
+        end
+      end
+    end
+  end
+end

data/lib/dry/monads/do.rb

@@ -74,45 +74,58 @@ module Dry
       # @return [Module]
       def self.for(*methods)
         mod = Module.new do
-          methods.each do |method|
-            class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-              def #{ method }(*)
-                super do |*ms|
-                  ms = coerce_to_monad(ms)
-                  unwrapped = ms.map { |m| m.to_monad.or { halt(m) }.value! }
-                  ms.size == 1 ? unwrapped[0] : unwrapped
-                end
-              rescue Halt => e
-                e.result
-              end
-            RUBY
-          end
+          methods.each { |m| Do.wrap_method(self, m) }
         end
 
         Module.new do
           singleton_class.send(:define_method, :included) do |base|
             base.prepend(mod)
           end
+        end
+      end
 
-          def halt(result)
-            raise Halt.new(result)
-          end
+      protected
 
-          # @private
-          def coerce_to_monad(ms)
-            return ms if ms.size != 1
+      # @private
+      def self.halt(result)
+        raise Halt.new(result)
+      end
 
-            fst = ms[0]
+      # @private
+      def self.coerce_to_monad(ms)
+        return ms if ms.size != 1
 
-            case fst
-            when Array, List
-              list = fst.is_a?(Array) ? List.coerce(fst) : fst
-              [list.traverse]
+        fst = ms[0]
+
+        case fst
+        when Array, List
+          list = fst.is_a?(Array) ? List.coerce(fst) : fst
+          [list.traverse]
+        else
+          ms
+        end
+      end
+
+      # @private
+      def self.wrap_method(target, method)
+        target.module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+          def #{ method }(*)
+            if block_given?
+              super
             else
-              ms
+              super do |*ms|
+                ms = Do.coerce_to_monad(ms)
+                unwrapped = ms.map { |r|
+                  m = r.to_monad
+                  m.or { Do.halt(m) }.value!
+                }
+                ms.size == 1 ? unwrapped[0] : unwrapped
+              end
             end
+          rescue Halt => e
+            e.result
           end
-        end
+        RUBY
       end
     end
   end

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

@@ -0,0 +1,98 @@
+require 'dry/monads/do'
+
+module Dry
+  module Monads
+    module Do
+      # Do::All automatically wraps methods defined in a class with an unwrapping block.
+      # Similar to what `Do.for(...)` does except wraps every method so you don't have
+      # to list them explicitly.
+      #
+      # @example annotated example
+      #
+      #   require 'dry/monads/do/all'
+      #   require 'dry/monads/result'
+      #
+      #   class CreateUser
+      #     include Dry::Monads::Do::All
+      #     include Dry::Monads::Result::Mixin
+      #
+      #     def call(params)
+      #       # Unwrap a monadic value using an implicitly passed block
+      #       # if `validates` returns Failure, the execution will be halted
+      #       values = yield validate(params)
+      #       user = create_user(values)
+      #       # If another block is passed to a method then takes
+      #       # precedence over the unwrapping block
+      #       safely_subscribe(values[:email]) { Logger.info("Already subscribed") }
+      #
+      #       Success(user)
+      #     end
+      #
+      #     def validate(params)
+      #       if params.key?(:email)
+      #         Success(email: params[:email])
+      #       else
+      #         Failure(:no_email)
+      #       end
+      #     end
+      #
+      #     def create_user(user)
+      #       # Here a block is passed to the method but we don't use it
+      #       UserRepo.new.add(user)
+      #     end
+      #
+      #     def safely_subscribe(email)
+      #       repo = SubscriptionRepo.new
+      #
+      #       if repo.subscribed?(email)
+      #          # This calls the logger because a block
+      #          # explicitly passed from `call`
+      #          yield
+      #       else
+      #         repo.subscribe(email)
+      #       end
+      #     end
+      #   end
+      #
+      module All
+        # @private
+        class MethodTracker < Module
+          attr_reader :wrappers
+
+          def initialize(wrappers)
+            super()
+
+            @wrappers = wrappers
+            tracker = self
+
+            module_eval do
+              define_method(:method_added) do |method|
+                super(method)
+
+                tracker.wrap_method(method)
+              end
+            end
+          end
+
+          def extend_object(target)
+            super
+            target.prepend(wrappers)
+          end
+
+          def wrap_method(method)
+            Do.wrap_method(wrappers, method)
+          end
+        end
+
+        # @private
+        def self.included(base)
+          super
+
+          tracker = MethodTracker.new(Module.new)
+          base.extend(tracker)
+          base.instance_methods(false).each { |m| tracker.wrap_method(m) }
+        end
+      end
+    end
+  end
+end

data/lib/dry/monads/lazy.rb

@@ -60,6 +60,9 @@ module Dry
         # @see Dry::Monads::Lazy
         Lazy = Lazy
 
+        # @see Dry::Monads::Unit
+        Unit = Unit
+
         # Lazy constructors
         module Constructors
           # Lazy computation contructor
@@ -74,5 +77,7 @@ module Dry
         include Constructors
       end
     end
+
+    extend Lazy::Mixin::Constructors
   end
 end

data/lib/dry/monads/list.rb

@@ -1,5 +1,4 @@
 require 'dry/equalizer'
-require 'dry/core/deprecations'
 
 require 'dry/monads/maybe'
 require 'dry/monads/task'
@@ -232,7 +231,7 @@ module Dry
         coerce(value.drop(1))
       end
 
-      # Turns the list into a types one.
+      # Turns the list into a typed one.
       # Type is required for some operations like .traverse.
       #
       # @param type [Monad] Monad instance

data/lib/dry/monads/maybe.rb

@@ -216,5 +216,78 @@ module Dry
         include Constructors
       end
     end
+
+    extend Maybe::Mixin::Constructors
+
+    # @see Maybe::Some
+    Some = Maybe::Some
+    # @see Maybe::None
+    None = Maybe::None
+
+    class Result
+      class Success < Result
+        # @return [Maybe::Some]
+        def to_maybe
+          Kernel.warn 'Success(nil) transformed to None' if @value.nil?
+          Dry::Monads::Maybe(@value)
+        end
+      end
+
+      class Failure < Result
+        # @return [Maybe::None]
+        def to_maybe
+          Maybe::None.new(trace)
+        end
+      end
+    end
+
+    class Task
+      # Converts to Maybe. Blocks the current thread if required.
+      #
+      # @return [Maybe]
+      def to_maybe
+        if promise.wait.fulfilled?
+          Maybe::Some.new(promise.value)
+        else
+          Maybe::None.new(RightBiased::Left.trace_caller)
+        end
+      end
+    end
+
+    class Try
+      class Value < Try
+        # @return [Maybe]
+        def to_maybe
+          Dry::Monads::Maybe(@value)
+        end
+      end
+
+      class Error < Try
+        # @return [Maybe::None]
+        def to_maybe
+          Maybe::None.new(RightBiased::Left.trace_caller)
+        end
+      end
+    end
+
+    class Validated
+      class Valid < Validated
+        # Converts to Maybe::Some
+        #
+        # @return [Maybe::Some]
+        def to_maybe
+          Maybe.pure(value!)
+        end
+      end
+
+      class Invalid < Validated
+        # Converts to Maybe::None
+        #
+        # @return [Maybe::None]
+        def to_maybe
+          Maybe::None.new(RightBiased::Left.trace_caller)
+        end
+      end
+    end
   end
 end

data/lib/dry/monads/result.rb

@@ -1,9 +1,9 @@
 require 'dry/equalizer'
-require 'dry/core/constants'
 
+require 'dry/monads/undefined'
 require 'dry/monads/right_biased'
 require 'dry/monads/transformer'
-require 'dry/monads/maybe'
+require 'dry/monads/conversion_stubs'
 
 module Dry
   module Monads
@@ -12,6 +12,7 @@ module Dry
     # @api public
     class Result
       include Transformer
+      include ConversionStubs[:to_maybe, :to_validated]
 
       # @return [Object] Successful result
       attr_reader :success
@@ -107,25 +108,12 @@ module Dry
         end
         alias_method :inspect, :to_s
 
-        # @return [Maybe::Some]
-        def to_maybe
-          Kernel.warn 'Success(nil) transformed to None' if @value.nil?
-          Dry::Monads::Maybe(@value)
-        end
-
         # Transforms to a Failure instance
         #
         # @return [Result::Failure]
         def flip
           Failure.new(@value, RightBiased::Left.trace_caller)
         end
-
-        # Transforms to Validated
-        #
-        # @return [Validated::Valid]
-        def to_validated
-          Validated::Valid.new(value!)
-        end
       end
 
       # Represents a value of a failed operation.
@@ -206,11 +194,6 @@ module Dry
         end
         alias_method :inspect, :to_s
 
-        # @return [Maybe::None]
-        def to_maybe
-          Maybe::None.new(trace)
-        end
-
         # Transform to a Success instance
         #
         # @return [Result::Success]
@@ -232,13 +215,6 @@ module Dry
         def ===(other)
           Failure === other && failure === other.failure
         end
-
-        # Transforms to Validated
-        #
-        # @return [Validated::Valid]
-        def to_validated
-          Validated::Invalid.new(failure, trace)
-        end
       end
 
       # A module that can be included for easier access to Result monads.
@@ -290,5 +266,96 @@ module Dry
         include Constructors
       end
     end
+
+    extend Result::Mixin::Constructors
+
+    # @see Result::Success
+    Success = Result::Success
+    # @see Result::Failure
+    Failure = Result::Failure
+
+    # Creates a module that has two methods: `Success` and `Failure`.
+    # `Success` is identical to {Result::Mixin::Constructors#Success} and Failure
+    # rejects values that don't conform the value of the `error`
+    # parameter. This is essentially a Result type with the `Failure` part
+    # fixed.
+    #
+    # @example using dry-types
+    #   module Types
+    #     include Dry::Types.module
+    #   end
+    #
+    #   class Operation
+    #     # :user_not_found and :account_not_found are the only
+    #     # values allowed as failure results
+    #     Error =
+    #       Types.Value(:user_not_found) |
+    #       Types.Value(:account_not_found)
+    #
+    #     def find_account(id)
+    #       account = acount_repo.find(id)
+    #
+    #       account ? Success(account) : Failure(:account_not_found)
+    #     end
+    #
+    #     def find_user(id)
+    #       # ...
+    #     end
+    #   end
+    #
+    # @param error [#===] the type of allowed failures
+    # @return [Module]
+    def self.Result(error, **options)
+      Result::Fixed[error, **options]
+    end
+
+    class Task
+      # Converts to Result. Blocks the current thread if required.
+      #
+      # @return [Result]
+      def to_result
+        if promise.wait.fulfilled?
+          Result::Success.new(promise.value)
+        else
+          Result::Failure.new(promise.reason, RightBiased::Left.trace_caller)
+        end
+      end
+    end
+
+    class Try
+      class Value < Try
+        # @return [Result::Success]
+        def to_result
+          Dry::Monads::Result::Success.new(@value)
+        end
+      end
+
+      class Error < Try
+        # @return [Result::Failure]
+        def to_result
+          Result::Failure.new(exception, RightBiased::Left.trace_caller)
+        end
+      end
+    end
+
+    class Validated
+      class Valid < Validated
+        # Converts to Result::Success
+        #
+        # @return [Result::Success]
+        def to_result
+          Result.pure(value!)
+        end
+      end
+
+      class Invalid < Validated
+        # Concerts to Result::Failure
+        #
+        # @return [Result::Failure]
+        def to_result
+          Result::Failure.new(error, RightBiased::Left.trace_caller)
+        end
+      end
+    end
   end
 end

data/lib/dry/monads/right_biased.rb

@@ -1,5 +1,6 @@
 require 'dry/core/constants'
 
+require 'dry/monads/unit'
 require 'dry/monads/curry'
 require 'dry/monads/errors'
 
@@ -99,13 +100,13 @@ module Dry
         # otherwise returns the argument.
         #
         # @example happy path
-        #   create_user = Dry::Monads::Right(CreateUser.new)
-        #   name = Right("John")
+        #   create_user = Dry::Monads::Success(CreateUser.new)
+        #   name = Success("John")
         #   create_user.apply(name) # equivalent to CreateUser.new.call("John")
         #
         # @example unhappy path
-        #   name = Left(:name_missing)
-        #   create_user.apply(name) # => Left(:name_missing)
+        #   name = Failure(:name_missing)
+        #   create_user.apply(name) # => Failure(:name_missing)
         #
         # @return [RightBiased::Left,RightBiased::Right]
         def apply(val = Undefined)
@@ -116,12 +117,24 @@ module Dry
           Undefined.default(val) { yield }.fmap { |unwrapped| curry.(unwrapped) }
         end
 
-        # @param other [RightBiased]
+        # @param other [Object]
         # @return [Boolean]
         def ===(other)
           self.class == other.class && value! === other.value!
         end
 
+        # Maps the value to Dry::Monads::Unit, useful when you don't care
+        # about the actual value.
+        #
+        # @example
+        #   Dry::Monads::Success(:success).discard
+        #   # => Success(Unit)
+        #
+        # @return [RightBiased::Right]
+        def discard
+          fmap { Unit }
+        end
+
         private
 
         # @api private
@@ -215,6 +228,14 @@ module Dry
         def apply(*)
           self
         end
+
+        # Returns self back. It exists to keep the interface
+        # identical to that of {RightBiased::Right}.
+        #
+        # @return [RightBiased::Left]
+        def discard
+          fmap { Unit }
+        end
       end
     end
   end

data/lib/dry/monads/task.rb

@@ -1,6 +1,8 @@
 require 'concurrent/promise'
 
+require 'dry/monads/unit'
 require 'dry/monads/curry'
+require 'dry/monads/conversion_stubs'
 
 module Dry
   module Monads
@@ -68,6 +70,8 @@ module Dry
         end
       end
 
+      include ConversionStubs[:to_maybe, :to_result]
+
       # @api private
       attr_reader :promise
       protected :promise
@@ -112,28 +116,6 @@ module Dry
       end
       alias_method :then, :bind
 
-      # Converts to Result. Blocks the current thread if required.
-      #
-      # @return [Result]
-      def to_result
-        if promise.wait.fulfilled?
-          Result::Success.new(promise.value)
-        else
-          Result::Failure.new(promise.reason, RightBiased::Left.trace_caller)
-        end
-      end
-
-      # Converts to Maybe. Blocks the current thread if required.
-      #
-      # @return [Maybe]
-      def to_maybe
-        if promise.wait.fulfilled?
-          Maybe::Some.new(promise.value)
-        else
-          Maybe::None.new(RightBiased::Left.trace_caller)
-        end
-      end
-
       # @return [String]
       def to_s
         state = case promise.state
@@ -244,6 +226,13 @@ module Dry
         bind { |f| arg.fmap { |v| curry(f).(v) } }
       end
 
+      # Maps a successful result to Unit, effectively discards it
+      #
+      # @return [Task]
+      def discard
+        fmap { Unit }
+      end
+
       private
 
       # @api private
@@ -271,7 +260,11 @@ module Dry
       #
       # @api public
       module Mixin
-        Task = Task # @private
+        # @private
+        Task = Task
+
+        # @see Dry::Monads::Unit
+        Unit = Unit # @private
 
         # Created a mixin with the given executor injected.
         #
@@ -305,5 +298,7 @@ module Dry
         include Constructors
       end
     end
+
+    extend Task::Mixin::Constructors
   end
 end

data/lib/dry/monads/try.rb

@@ -2,8 +2,7 @@ require 'dry/equalizer'
 require 'dry/core/deprecations'
 
 require 'dry/monads/right_biased'
-require 'dry/monads/result'
-require 'dry/monads/maybe'
+require 'dry/monads/conversion_stubs'
 
 module Dry
   module Monads
@@ -15,6 +14,8 @@ module Dry
       # @private
       DEFAULT_EXCEPTIONS = [StandardError].freeze
 
+      include ConversionStubs[:to_maybe, :to_result]
+
       # @return [Exception] Caught exception
       attr_reader :exception
 
@@ -153,16 +154,6 @@ module Dry
           Error.new(e)
         end
 
-        # @return [Maybe]
-        def to_maybe
-          Dry::Monads::Maybe(@value)
-        end
-
-        # @return [Result::Success]
-        def to_result
-          Dry::Monads::Result::Success.new(@value)
-        end
-
         # @return [String]
         def to_s
           "Try::Value(#{ @value.inspect })"
@@ -182,16 +173,6 @@ module Dry
           @exception = exception
         end
 
-        # @return [Maybe::None]
-        def to_maybe
-          Maybe::None.new(RightBiased::Left.trace_caller)
-        end
-
-        # @return [Result::Failure]
-        def to_result
-          Result::Failure.new(exception, RightBiased::Left.trace_caller)
-        end
-
         # @return [String]
         def to_s
           "Try::Error(#{ exception.class }: #{ exception.message })"
@@ -291,5 +272,7 @@ module Dry
         end
       end
     end
+
+    extend Try::Mixin::Constructors
   end
 end

data/lib/dry/monads/undefined.rb

@@ -0,0 +1,8 @@
+require 'dry/core/constants'
+
+module Dry
+  module Monads
+    # @private
+    Undefined = Dry::Core::Constants::Undefined
+  end
+end

data/lib/dry/monads/unit.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Dry
+  module Monads
+    Unit = Object.new.tap do |unit|
+      def unit.to_s
+        'Unit'
+      end
+
+      def unit.inspect
+        'Unit'
+      end
+    end
+  end
+end

data/lib/dry/monads/validated.rb

@@ -1,5 +1,6 @@
-require 'dry/monads/maybe'
-require 'dry/monads/result'
+require 'dry/monads/conversion_stubs'
+require 'dry/monads/undefined'
+require 'dry/monads/right_biased'
 
 module Dry
   module Monads
@@ -19,6 +20,8 @@ module Dry
     #   # => Valid(List['London', 'John'])
     #
     class Validated
+      include ConversionStubs[:to_maybe, :to_result]
+
       class << self
         # Wraps a value with `Valid`.
         #
@@ -121,18 +124,10 @@ module Dry
         end
         alias_method :to_s, :inspect
 
-        # Converts to Maybe::Some
-        #
-        # @return [Maybe::Some]
-        def to_maybe
-          Maybe.pure(value!)
-        end
-
-        # Converts to Result::Success
-        #
-        # @return [Result::Success]
-        def to_result
-          Result.pure(value!)
+        # @param other [Object]
+        # @return [Boolean]
+        def ===(other)
+          self.class == other.class && value! === other.value!
         end
       end
 
@@ -213,18 +208,10 @@ module Dry
         end
         alias_method :to_s, :inspect
 
-        # Converts to Maybe::None
-        #
-        # @return [Maybe::None]
-        def to_maybe
-          Maybe::None.new(RightBiased::Left.trace_caller)
-        end
-
-        # Concerts to Result::Failure
-        #
-        # @return [Result::Failure]
-        def to_result
-          Result::Failure.new(error, RightBiased::Left.trace_caller)
+        # @param other [Object]
+        # @return [Boolean]
+        def ===(other)
+          self.class == other.class && error === other.error
         end
       end
 
@@ -279,5 +266,32 @@ module Dry
         include Constructors
       end
     end
+
+    extend Validated::Mixin::Constructors
+
+    # @see Validated::Valid
+    Valid = Validated::Valid
+    # @see Validated::Invalid
+    Invalid = Validated::Invalid
+
+    class Result
+      class Success < Result
+        # Transforms to Validated
+        #
+        # @return [Validated::Valid]
+        def to_validated
+          Validated::Valid.new(value!)
+        end
+      end
+
+      class Failure < Result
+        # Transforms to Validated
+        #
+        # @return [Validated::Valid]
+        def to_validated
+          Validated::Invalid.new(failure, trace)
+        end
+      end
+    end
   end
 end

data/lib/dry/monads/version.rb

@@ -1,6 +1,6 @@
 module Dry
   module Monads
     # @private
-    VERSION = '1.0.0.beta1'.freeze
+    VERSION = '1.0.0.beta2'.freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dry-monads
 version: !ruby/object:Gem::Version
-  version: 1.0.0.beta1
+  version: 1.0.0.beta2
 platform: ruby
 authors:
 - Nikita Shilnikov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-02-10 00:00:00.000000000 Z
+date: 2018-05-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-equalizer
@@ -137,8 +137,11 @@ files:
 - dry-monads.gemspec
 - lib/dry-monads.rb
 - lib/dry/monads.rb
+- lib/dry/monads/all.rb
+- lib/dry/monads/conversion_stubs.rb
 - lib/dry/monads/curry.rb
 - lib/dry/monads/do.rb
+- lib/dry/monads/do/all.rb
 - lib/dry/monads/either.rb
 - lib/dry/monads/errors.rb
 - lib/dry/monads/lazy.rb
@@ -151,6 +154,8 @@ files:
 - lib/dry/monads/transformer.rb
 - lib/dry/monads/traverse.rb
 - lib/dry/monads/try.rb
+- lib/dry/monads/undefined.rb
+- lib/dry/monads/unit.rb
 - lib/dry/monads/validated.rb
 - lib/dry/monads/version.rb
 - lib/json/add/dry/monads/maybe.rb