dry-monads 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ae0ce757dc3f6ec60e8fb1d3e111535fe3e32d40956c5e38cdbef583805b5f6a
-  data.tar.gz: 83962c10f05f0a53d37a34c77c4197a799a8a78f7a6de767999a6eebd0f30571
+  metadata.gz: 3b5983b622b49edc1008fc8717adf6f4150f011c55ca094879f6788cfed657f2
+  data.tar.gz: 8e01a982d197dbc26e82df01c804dba93e8aa327aeb9cb248a07eeda7a7c636c
 SHA512:
-  metadata.gz: 1754fea24d90657ea3947de3c1b4206d22c977ec30546377ccb82c166a898ca8f4dc0b6b21dd384ceea78a706c29c9570951222f48e6a40b661964b1f43ffef2
-  data.tar.gz: 7667bcb8d8a009f68055c9cade624e7276a51749f42fdbfacc8e47b13763e10f57e7e34b00878017498f100f9eae55de72e10b9d8ffcad8d952043311aea74ed
+  metadata.gz: f81e00f7455a03b12996724fd35404d81dff4cbc934e1868a2329c26cbaae5cb7f5edcde6c9766f754844e8ce0b839d5ca10781e0c1c08702020e938956703b3
+  data.tar.gz: 4ea9d2ffa5988996517ba096ef8985331a213fadbdb6d81b2597012a0d7ada3da3716422ba155accd0a9932bf5802a905a3b19162526c5f2a501f45e0b46537e

data/.travis.yml

@@ -1,26 +1,28 @@
 language: ruby
 dist: trusty
-sudo: false
 cache: bundler
 bundler_args: --without benchmarks docs
 script:
-  - bundle exec rake spec
+  - bundle exec rspec spec $RSPEC_OPTS
 before_install:
   - gem update --system
   - gem install bundler
 after_success:
-  - '[ -d coverage ] && bundle exec codeclimate-test-reporter'
+  - "[ -d coverage ] && bundle exec codeclimate-test-reporter"
 rvm:
-  - 2.3.8
-  - 2.4.5
-  - 2.5.3
-  - 2.6.0
-  - jruby-9.2.4.0
+  - 2.4.6
+  - 2.5.5
+  - 2.6.3
+  - jruby-9.2.7.0
 env:
   global:
     - JRUBY_OPTS='--dev -J-Xmx1024M'
     - COVERAGE=true
+    - RSPEC_OPTS='--exclude-pattern spec/integration/pattern_matching_spec.rb'
 matrix:
+  include:
+    - rvm: 2.7
+      env: "RSPEC_OPTS=''"
   allow_failures:
     - rvm: ruby-head
 
@@ -30,10 +32,10 @@ notifications:
       - fg@flashgordon.ru
     on_success: change
     on_failure: always
-    on_start: false     # default: false
+    on_start: false # default: false
   webhooks:
     urls:
       - https://webhooks.gitter.im/e/19098b4253a72c9796db
-    on_success: change  # options: [always|never|change] default: always
-    on_failure: always  # options: [always|never|change] default: always
-    on_start: false     # default: false
+    on_success: change # options: [always|never|change] default: always
+    on_failure: always # options: [always|never|change] default: always
+    on_start: false # default: false

data/CHANGELOG.md

@@ -1,3 +1,88 @@
+# v1.3.0 2019-08-03
+
+## BREAKING CHANGES
+
+* Support for Ruby 2.3 was dropped.
+
+## Added
+
+* `Result#either` (waiting-for-dev)
+  ```ruby
+  Success(1).either(-> x { x + 1 }, -> x { x + 2 }) # => 2
+  Failure(1).either(-> x { x + 1 }, -> x { x + 2 }) # => 3
+  ```
+* `Maybe#to_result` (SpyMachine + flash-gordon)
+  ```ruby
+  Some(3).to_result(:no_value)   # => Success(3)
+  None().to_result { :no_value } # => Failure(:no_value)
+  None().to_result               # => Failure()
+  ```
+* Do notation can be used with `extend`. This simplifies usage in class methods and in other "complicated" cases (gogiel + flash-gordon)
+
+  ```ruby
+  class CreateUser
+    extend Dry::Monads::Do::Mixin
+    extend Dry::Monads[:result]
+
+    def self.run(params)
+      self.call do
+        values = bind Validator.validate(params)
+        user = bind UserRepository.create(values)
+
+        Success(user)
+      end
+    end
+  end
+  ```
+  
+  Or you can bind values directly:
+  ```ruby
+  ma = Dry::Monads.Success(1)
+  mb = Dry::Monads.Success(2)
+  
+  Dry::Monads::Do.() do
+    a = Dry::Monads::Do.bind(ma)
+    b = Dry::Monads::Do.bind(mb)
+    
+    Dry::Monads.Success(a + b)
+  end
+  ```
+* `{Some,Success,Failure}#[]` shortcuts for building arrays wrapped within monadic value (flash-gordon)
+  ```ruby
+  Success[1, 2] # => Success([1, 2]) 
+  ```
+* `List.unfold` yields a block returning `Maybe<Any>`. If the block returns `Some(a)` `a` is appended to the output list. Returning `None` halts the unfloding (flash-gordon)
+  ```ruby
+  List.unfold(0) do |x|
+    if x > 5
+      None()
+    else
+      Some[x + 1, 2**x]
+    end
+  end # => List[1, 2, 3, 4, 5]
+  ```
+  
+* Experimental support for pattern matching! :tada: (flash-gordon)
+  ```ruby
+  case value
+  in Failure(_) then :failure
+  in Success(10) then :ten
+  in Success(100..500 => code) then code
+  in Success() then :empty
+  in Success(:code, x) then x
+  in Success[:status, x] then x
+  in Success({ status: x }) then x
+  in Success({ code: 200..300 => x }) then x
+  end
+  ```
+  Read more about pattern matching in Ruby: 
+  - https://medium.com/@baweaver/ruby-2-7-pattern-matching-destructuring-on-point-90f56aaf7b4e
+  - https://bugs.ruby-lang.org/issues/14912
+  
+  Keep in mind this feature is experimental and can be changed by 2.7 release. But it rocks already!
+  
+[Compare v1.2.0...v1.3.0](https://github.com/dry-rb/dry-monads/compare/v1.2.0...v1.3.0)
+
 # v1.2.0 2019-01-12
 
 ## BREAKING CHANGES

data/Gemfile

@@ -5,6 +5,7 @@ gemspec
 group :test do
   gem 'codeclimate-test-reporter', require: false
   gem 'simplecov', require: false
+  gem 'warning'
 end
 
 group :tools do

data/README.md

@@ -1,17 +1,17 @@
 [gitter]: https://gitter.im/dry-rb/chat
 [gem]: https://rubygems.org/gems/dry-monads
-[travis]: https://travis-ci.org/dry-rb/dry-monads
+[travis]: https://travis-ci.com/dry-rb/dry-monads
 [code_climate]: https://codeclimate.com/github/dry-rb/dry-monads
 [inch]: http://inch-ci.org/github/dry-rb/dry-monads
+[chat]: https://dry-rb.zulipchat.com
 
-# dry-monads [![Join the Gitter chat](https://badges.gitter.im/Join%20Chat.svg)][gitter]
+# dry-monads [![Join the chat at https://dry-rb.zulipchat.com](https://img.shields.io/badge/dry--rb-join%20chat-%23346b7a.svg)][chat]
 
 [![Gem Version](https://img.shields.io/gem/v/dry-monads.svg)][gem]
 [![Build Status](https://img.shields.io/travis/dry-rb/dry-monads.svg)][travis]
 [![Code Climate](https://api.codeclimate.com/v1/badges/b0ea4d8023d53b7f0f50/maintainability)][code_climate]
 [![Test Coverage](https://api.codeclimate.com/v1/badges/b0ea4d8023d53b7f0f50/test_coverage)][code_climate]
 [![API Documentation Coverage](http://inch-ci.org/github/dry-rb/dry-monads.svg)][inch]
-![No monkey-patches](https://img.shields.io/badge/monkey--patches-0-brightgreen.svg)
 
 Monads for Ruby.
 
@@ -37,7 +37,7 @@ $ gem install dry-monads
 
 ## Links
 
-* [Documentation](http://dry-rb.org/gems/dry-monads)
+- [Documentation](http://dry-rb.org/gems/dry-monads)
 
 ## Development
 

data/dry-monads.gemspec

@@ -25,7 +25,7 @@ Gem::Specification.new do |spec|
   spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
-  spec.required_ruby_version = ">= 2.3.0"
+  spec.required_ruby_version = ">= 2.4.0"
   spec.add_dependency 'dry-equalizer'
   spec.add_dependency 'dry-core', '~> 0.4', '>= 0.4.4'
   spec.add_dependency 'concurrent-ruby', '~> 1.0'

data/lib/dry/monads.rb

@@ -5,6 +5,7 @@ module Dry
   #
   # @api public
   module Monads
+    # @private
     def self.included(base)
       if all_loaded?
         base.include(*constructors)
@@ -47,7 +48,7 @@ module Dry
       @mixins.fetch_or_store(monads.hash) do
         monads.each { |m| load_monad(m) }
         mixins = monads.map { |m| registry.fetch(m) }
-        Module.new { include(*mixins) }.freeze
+        ::Module.new { include(*mixins) }.freeze
       end
     end
   end

data/lib/dry/monads/do.rb

@@ -1,4 +1,5 @@
 require 'dry/monads/list'
+require 'dry/monads/do/mixin'
 
 module Dry
   module Monads
@@ -6,9 +7,11 @@ module Dry
     #
     # @see Do.for
     module Do
-      # @private
+      extend Mixin
+
+      # @api private
       class Halt < StandardError
-        # @private
+        # @api private
         attr_reader :result
 
         def initialize(result)
@@ -18,126 +21,117 @@ module Dry
         end
       end
 
-      # Generates a module that passes a block to methods
-      # that either unwraps a single-valued monadic value or halts
-      # the execution.
-      #
-      # @example A complete example
-      #
-      #   class CreateUser
-      #     include Dry::Monads::Result::Mixin
-      #     include Dry::Monads::Try::Mixin
-      #     include Dry::Monads::Do.for(:call)
-      #
-      #     attr_reader :user_repo
-      #
-      #     def initialize(:user_repo)
-      #       @user_repo = user_repo
-      #     end
-      #
-      #     def call(params)
-      #       json = yield parse_json(params)
-      #       hash = yield validate(json)
-      #
-      #       user_repo.transaction do
-      #         user = yield create_user(hash[:user])
-      #         yield create_profile(user, hash[:profile])
-      #       end
-      #
-      #       Success(user)
-      #     end
-      #
-      #     private
-      #
-      #     def parse_json(params)
-      #       Try(JSON::ParserError) {
-      #         JSON.parse(params)
-      #       }.to_result
-      #     end
-      #
-      #     def validate(json)
-      #       UserSchema.(json).to_monad
-      #     end
-      #
-      #     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)
-      #       }.to_result
-      #     end
-      #   end
-      #
-      # @param [Array<Symbol>] methods
-      # @return [Module]
-      def self.for(*methods)
-        mod = Module.new do
-          methods.each { |method_name| Do.wrap_method(self, method_name) }
-        end
+      class << self
+        # Generates a module that passes a block to methods
+        # that either unwraps a single-valued monadic value or halts
+        # the execution.
+        #
+        # @example A complete example
+        #
+        #   class CreateUser
+        #     include Dry::Monads::Result::Mixin
+        #     include Dry::Monads::Try::Mixin
+        #     include Dry::Monads::Do.for(:call)
+        #
+        #     attr_reader :user_repo
+        #
+        #     def initialize(:user_repo)
+        #       @user_repo = user_repo
+        #     end
+        #
+        #     def call(params)
+        #       json = yield parse_json(params)
+        #       hash = yield validate(json)
+        #
+        #       user_repo.transaction do
+        #         user = yield create_user(hash[:user])
+        #         yield create_profile(user, hash[:profile])
+        #       end
+        #
+        #       Success(user)
+        #     end
+        #
+        #     private
+        #
+        #     def parse_json(params)
+        #       Try(JSON::ParserError) {
+        #         JSON.parse(params)
+        #       }.to_result
+        #     end
+        #
+        #     def validate(json)
+        #       UserSchema.(json).to_monad
+        #     end
+        #
+        #     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)
+        #       }.to_result
+        #     end
+        #   end
+        #
+        # @param [Array<Symbol>] methods
+        # @return [Module]
+        def for(*methods)
+          mod = ::Module.new do
+            methods.each { |method_name| Do.wrap_method(self, method_name) }
+          end
 
-        Module.new do
-          singleton_class.send(:define_method, :included) do |base|
-            base.prepend(mod)
+          ::Module.new do
+            singleton_class.send(:define_method, :included) do |base|
+              base.prepend(mod)
+            end
           end
         end
-      end
 
-      # @api private
-      def self.included(base)
-        super
+        # @api private
+        def included(base)
+          super
 
-        # Actually mixes in Do::All
-        require 'dry/monads/do/all'
-        base.include All
-      end
-
-      protected
+          # Actually mixes in Do::All
+          require 'dry/monads/do/all'
+          base.include All
+        end
 
-      # @private
-      def self.halt(result)
-        raise Halt.new(result)
-      end
+        # @api private
+        def wrap_method(target, method_name)
+          target.module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+            def #{method_name}(*)
+              if block_given?
+                super
+              else
+                Do.() { super { |*ms| Do.bind(ms) } }
+              end
+            end
+          RUBY
+        end
 
-      # @private
-      def self.coerce_to_monad(monads)
-        return monads if monads.size != 1
+        # @api private
+        def coerce_to_monad(monads)
+          return monads if monads.size != 1
 
-        first = monads[0]
+          first = monads[0]
 
-        case first
-        when Array
-          [List.coerce(first).traverse]
-        when List
-          [first.traverse]
-        else
-          monads
+          case first
+          when ::Array
+            [List.coerce(first).traverse]
+          when List
+            [first.traverse]
+          else
+            monads
+          end
         end
-      end
 
-      # @private
-      def self.wrap_method(target, method_name)
-        target.module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-          def #{ method_name }(*)
-            if block_given?
-              super
-            else
-              super do |*monads|
-                monads = Do.coerce_to_monad(monads)
-                unwrapped = monads.map { |result|
-                  monad = result.to_monad
-                  monad.or { Do.halt(monad) }.value!
-                }
-                monads.size == 1 ? unwrapped[0] : unwrapped
-              end
-            end
-          rescue Halt => e
-            e.result
-          end
-        RUBY
+        # @api private
+        def halt(result)
+          raise Halt.new(result)
+        end
       end
     end
   end

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

@@ -95,15 +95,39 @@ module Dry
           end
         end
 
-        # @private
+        # @api private
         def self.included(base)
           super
 
-          wrappers = Hash.new { |h, k| h[k] = 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(base, m) }
+
+          base.extend(InstanceMixin) unless base.is_a?(::Class)
         end
+
+        # @api private
+        module InstanceMixin
+          # @api private
+          def extended(object)
+            super
+
+            wrapper = ::Module.new
+            object.singleton_class.prepend(wrapper)
+            object.define_singleton_method(:singleton_method_added) do |method|
+              super(method)
+
+              next if method.equal?(:singleton_method_added)
+              Do.wrap_method(wrapper, method)
+            end
+            object.singleton_class.instance_methods(false).each do |m|
+              Do.wrap_method(wrapper, m)
+            end
+          end
+        end
+
+        extend InstanceMixin
       end
     end
 

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

@@ -0,0 +1,56 @@
+module Dry
+  module Monads
+    module Do
+      # Do notation as a mixin.
+      # You can use it in any place in your code, see examples.
+      #
+      # @example class-level mixin
+      #
+      #   class CreateUser
+      #     extend Dry::Monads::Do::Mixin
+      #     extend Dry::Monads[:result]
+      #
+      #     def self.run(params)
+      #       self.call do
+      #         values = bind Validator.validate(params)
+      #         user = bind UserRepository.create(values)
+      #
+      #         Success(user)
+      #       end
+      #     end
+      #   end
+      #
+      # @example using methods defined on Do
+      #
+      #   create_user = proc do |params|
+      #     Do.() do
+      #       values = bind validate(params)
+      #       user = bind user_repo.create(values)
+      #
+      #       Success(user)
+      #     end
+      #   end
+      #
+      # @api public
+      module Mixin
+        # @api public
+        def call
+          yield
+        rescue Halt => e
+          e.result
+        end
+
+        # @api public
+        def bind(monads)
+          monads = Do.coerce_to_monad(Array(monads))
+          unwrapped = monads.map { |result|
+            monad = result.to_monad
+            monad.or { Do.halt(monad) }.value!
+          }
+          monads.size == 1 ? unwrapped[0] : unwrapped
+        end
+      end
+    end
+  end
+end
+

data/lib/dry/monads/errors.rb

@@ -13,5 +13,15 @@ module Dry
         super("Cannot create Failure from #{ failure.inspect }, it doesn't meet the constraints")
       end
     end
+
+    # Improper use of None
+    class ConstructorNotAppliedError < NoMethodError
+      def initialize(method_name, constructor_name)
+        super(
+          "For calling .#{method_name} on #{constructor_name}() build a value "\
+          "by appending parens: #{constructor_name}()"
+        )
+      end
+    end
   end
 end

data/lib/dry/monads/list.rb

@@ -55,6 +55,30 @@ module Dry
             new([value], type)
           end
         end
+
+        # Iteratively builds a new list from a block returning Maybe values
+        #
+        # @see https://hackage.haskell.org/package/base-4.12.0.0/docs/Data-List.html#g:9
+        #
+        # @param state [Object.new] Initial state
+        # @param type [#pure] Type of list element
+        # @return [List]
+        def unfold(state, type = nil)
+          xs = []
+
+          loop do
+            m = yield(state)
+
+            if m.some?
+              state, x = m.value!
+              xs << x
+            else
+              break
+            end
+          end
+
+          new(xs, type)
+        end
       end
 
       extend Dry::Core::Deprecations[:'dry-monads']
@@ -341,6 +365,20 @@ module Dry
         end
       end
 
+      # Pattern matching
+      #
+      # @example
+      #   case List[1, 2, 3]
+      #   in List[1, 2, x] then ...
+      #   in List[Integer, _, _] then ...
+      #   in List[0..2, _, _] then ...
+      #   end
+      #
+      # @api private
+      def deconstruct
+        value
+      end
+
       private
 
       def coerce(other)

data/lib/dry/monads/maybe.rb

@@ -5,6 +5,7 @@ require 'dry/core/deprecations'
 require 'dry/monads/right_biased'
 require 'dry/monads/transformer'
 require 'dry/monads/unit'
+require 'dry/monads/undefined'
 
 module Dry
   module Monads
@@ -88,6 +89,20 @@ module Dry
         include Dry::Equalizer(:value!)
         include RightBiased::Right
 
+        # Shortcut for Some([...])
+        #
+        #  @example
+        #    include Dry::Monads[:maybe]
+        #
+        #    def call
+        #      Some[200, {}, ['ok']] # => Some([200, {}, ['ok']])
+        #    end
+        #
+        # @api public
+        def self.[](*value)
+          new(value)
+        end
+
         def initialize(value = Undefined)
           raise ArgumentError, 'nil cannot be some' if value.nil?
           @value = Undefined.default(value, Unit)
@@ -104,12 +119,17 @@ module Dry
         # @return [Maybe::Some, Maybe::None] Wrapped result, i.e. nil will be mapped to None,
         #                                    other values will be wrapped with Some
         def fmap(*args, &block)
-          self.class.coerce(bind(*args, &block))
+          Maybe.coerce(bind(*args, &block))
         end
+        alias_method :maybe, :fmap
 
         # @return [String]
         def to_s
-          "Some(#{ @value.inspect })"
+          if Unit.equal?(@value)
+            'Some()'
+          else
+            "Some(#{@value.inspect})"
+          end
         end
         alias_method :inspect, :to_s
       end
@@ -119,10 +139,21 @@ module Dry
       # @api public
       class None < Maybe
         include RightBiased::Left
+        include Core::Constants
 
         @instance = new.freeze
         singleton_class.send(:attr_reader, :instance)
 
+        # @api private
+        def self.method_missing(m, *)
+          if (instance.methods(true) - methods(true)).include?(m)
+            raise ConstructorNotAppliedError.new(m, :None)
+          else
+            super
+          end
+        end
+        private_class_method :method_missing
+
         # Line where the value was constructed
         #
         # @return [String]
@@ -180,6 +211,20 @@ module Dry
         def hash
           None.instance.object_id
         end
+
+        # Pattern matching
+        #
+        # @example
+        #   case Some(:foo)
+        #   in Some(Integer) then ...
+        #   in Some(:bar) then ...
+        #   in None() then ...
+        #   end
+        #
+        # @api private
+        def deconstruct
+          EMPTY_ARRAY
+        end
       end
 
       # A module that can be included for easier access to Maybe monads.
@@ -222,6 +267,48 @@ module Dry
 
         include Constructors
       end
+
+      # Utilities for working with hashes storing Maybe values
+      module Hash
+        # Traverses a hash with maybe values. If any value is None then None is returned
+        #
+        # @example
+        #   Maybe::Hash.all(foo: Some(1), bar: Some(2)) # => Some(foo: 1, bar: 2)
+        #   Maybe::Hash.all(foo: Some(1), bar: None())  # => None()
+        #   Maybe::Hash.all(foo: None(), bar: Some(2))  # => None()
+        #
+        # @param hash [::Hash<Object,Maybe>]
+        # @return [Maybe<::Hash>]
+        #
+        def self.all(hash, trace = RightBiased::Left.trace_caller)
+          result = hash.each_with_object({}) do |(key, value), output|
+            if value.some?
+              output[key] = value.value!
+            else
+              return None.new(trace)
+            end
+          end
+
+          Some.new(result)
+        end
+
+        # Traverses a hash with maybe values. Some values are unwrapped, keys with
+        # None values are removed
+        #
+        # @example
+        #   Maybe::Hash.filter(foo: Some(1), bar: Some(2)) # => Some(foo: 1, bar: 2)
+        #   Maybe::Hash.filter(foo: Some(1), bar: None())  # => None()
+        #   Maybe::Hash.filter(foo: None(), bar: Some(2))  # => None()
+        #
+        # @param hash [::Hash<Object,Maybe>]
+        # @return [::Hash]
+        #
+        def self.filter(hash)
+          hash.each_with_object({}) do |(key, value), output|
+            output[key] = value.value! if value.some?
+          end
+        end
+      end
     end
 
     extend Maybe::Mixin::Constructors

data/lib/dry/monads/result.rb

@@ -66,6 +66,20 @@ module Dry
         include RightBiased::Right
         include Dry::Equalizer(:value!)
 
+        # Shortcut for Success([...])
+        #
+        #  @example
+        #    include Dry::Monads[:result]
+        #
+        #    def call
+        #      Success[200, {}, ['ok']] # => Success([200, {}, ['ok']])
+        #    end
+        #
+        # @api public
+        def self.[](*value)
+          new(value)
+        end
+
         alias_method :success, :value!
 
         # @param value [Object] a value of a successful operation
@@ -103,9 +117,25 @@ module Dry
           Success.new(bind(*args, &block))
         end
 
+        # Returns result of applying first function to the internal value.
+        #
+        # @example
+        #   Dry::Monads.Success(1).either(-> x { x + 1 }, -> x { x + 2 }) # => 2
+        #
+        # @param f [#call] Function to apply
+        # @param _ [#call] Ignored
+        # @return [Any] Return value of `f`
+        def either(f, _)
+          f.(success)
+        end
+
         # @return [String]
         def to_s
-          "Success(#{ @value.inspect })"
+          if Unit.equal?(@value)
+            'Success()'
+          else
+            "Success(#{@value.inspect})"
+          end
         end
         alias_method :inspect, :to_s
 
@@ -126,6 +156,20 @@ module Dry
 
         singleton_class.send(:alias_method, :call, :new)
 
+        # Shortcut for Failure([...])
+        #
+        #  @example
+        #    include Dry::Monads[:result]
+        #
+        #    def call
+        #      Failure[:error, :not_found] # => Failure([:error, :not_found])
+        #    end
+        #
+        # @api public
+        def self.[](*value)
+          new(value, RightBiased::Left.trace_caller)
+        end
+
         # Returns a constructor proc
         #
         # @return [Proc]
@@ -200,7 +244,11 @@ module Dry
 
         # @return [String]
         def to_s
-          "Failure(#{ @value.inspect })"
+          if Unit.equal?(@value)
+            'Failure()'
+          else
+            "Failure(#{@value.inspect})"
+          end
         end
         alias_method :inspect, :to_s
 
@@ -225,6 +273,18 @@ module Dry
         def ===(other)
           Failure === other && failure === other.failure
         end
+
+        # Returns result of applying second function to the internal value.
+        #
+        # @example
+        #   Dry::Monads.Failure(1).either(-> x { x + 1 }, -> x { x + 2 }) # => 3
+        #
+        # @param _ [#call] Ignored
+        # @param g [#call] Function to call
+        # @return [Any] Return value of `g`
+        def either(_, g)
+          g.(failure)
+        end
       end
 
       # A module that can be included for easier access to Result monads.
@@ -319,6 +379,34 @@ module Dry
       Result::Fixed[error, **options]
     end
 
+    class Maybe
+      class Some < Maybe
+        # Converts to Sucess(value!)
+        #
+        # @param fail [#call] Fallback value
+        # @param block [Proc] Fallback block
+        # @return [Success<Any>]
+        def to_result(fail = Unit, &block)
+          Result::Success.new(@value)
+        end
+      end
+
+      class None < Maybe
+        # Converts to Failure(fallback_value)
+        #
+        # @param fail [#call] Fallback value
+        # @param block [Proc] Fallback block
+        # @return [Failure<Any>]
+        def to_result(fail = Unit, &block)
+          if block_given?
+            Result::Failure.new(yield)
+          else
+            Result::Failure.new(fail)
+          end
+        end
+      end
+    end
+
     class Task
       # Converts to Result. Blocks the current thread if required.
       #

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

@@ -24,7 +24,8 @@ module Dry::Monads
         end
       end
 
-      # @api private
+      private
+
       def included(base)
         super
 

data/lib/dry/monads/right_biased.rb

@@ -186,6 +186,25 @@ module Dry
           end
         end
 
+        # Pattern matching
+        #
+        # @example
+        #   case Success(x)
+        #   in Success(Integer) then ...
+        #   in Success(2..100) then ...
+        #   in Success(2..200 => code) then ...
+        #   end
+        # @api private
+        def deconstruct
+          if Unit.equal?(@value)
+            []
+          elsif @value.is_a?(::Array)
+            @value
+          else
+            [@value]
+          end
+        end
+
         private
 
         # @api private
@@ -303,6 +322,27 @@ module Dry
         def and(_)
           self
         end
+
+        # Pattern matching
+        #
+        # @example
+        #   case Success(x)
+        #   in Success(Integer) then ...
+        #   in Success(2..100) then ...
+        #   in Success(2..200 => code) then ...
+        #   in Failure(_) then ...
+        #   end
+        #
+        # @api private
+        def deconstruct
+          if Unit.equal?(@value)
+            []
+          elsif @value.is_a?(::Array)
+            @value
+          else
+            [@value]
+          end
+        end
       end
     end
   end

data/lib/dry/monads/task.rb

@@ -128,14 +128,18 @@ module Dry
       def to_s
         state = case promise.state
                 when :fulfilled
-                  "value=#{ value!.inspect }"
+                  if Unit.equal?(value!)
+                    'value=()'
+                  else
+                    "value=#{value!.inspect}"
+                  end
                 when :rejected
                   "error=#{ promise.reason.inspect }"
                 else
                   '?'
                 end
 
-        "Task(#{ state })"
+        "Task(#{state})"
       end
       alias_method :inspect, :to_s
 

data/lib/dry/monads/try.rb

@@ -20,7 +20,7 @@ module Dry
       attr_reader :exception
 
       class << self
-        extend Dry::Core::Deprecations[:'dry-monads']
+        extend Core::Deprecations[:'dry-monads']
 
         # Invokes a callable and if successful stores the result in the
         # {Try::Value} type, but if one of the specified exceptions was raised it stores
@@ -101,7 +101,7 @@ module Dry
         include Dry::Equalizer(:value!, :catchable)
         include RightBiased::Right
 
-        # @private
+        # @return [Array<Exception>] List of exceptions to rescue
         attr_reader :catchable
 
         # @param exceptions [Array<Exception>] list of exceptions to be rescued
@@ -156,7 +156,11 @@ module Dry
 
         # @return [String]
         def to_s
-          "Try::Value(#{ @value.inspect })"
+          if Unit.equal?(@value)
+            'Try::Value()'
+          else
+            "Try::Value(#{@value.inspect})"
+          end
         end
         alias_method :inspect, :to_s
       end
@@ -225,6 +229,7 @@ module Dry
         # @see Dry::Monads::Try
         Try = Try
 
+        # @private
         module Constructors
           # A convenience wrapper for {Monads::Try.run}.
           # If no exceptions are provided it falls back to StandardError.
@@ -234,7 +239,7 @@ module Dry
           # @param exceptions [Array<Exception>]
           # @return [Try]
           def Try(*exceptions, &f)
-            catchable = exceptions.empty? ? Try::DEFAULT_EXCEPTIONS : exceptions.flatten
+            catchable = exceptions.empty? ? DEFAULT_EXCEPTIONS : exceptions.flatten
             Try.run(catchable, f)
           end
         end

data/lib/dry/monads/validated.rb

@@ -120,7 +120,11 @@ module Dry
 
         # @return [String]
         def inspect
-          "Valid(#{ value!.inspect })"
+          if Unit.equal?(@value)
+            "Valid()"
+          else
+            "Valid(#{@value.inspect})"
+          end
         end
         alias_method :to_s, :inspect
 

data/lib/dry/monads/version.rb

@@ -1,6 +1,6 @@
 module Dry
   module Monads
-    # @private
-    VERSION = '1.2.0'.freeze
+    # Gem version
+    VERSION = '1.3.0'.freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dry-monads
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Nikita Shilnikov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-01-15 00:00:00.000000000 Z
+date: 2019-08-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-equalizer
@@ -142,6 +142,7 @@ files:
 - lib/dry/monads/curry.rb
 - lib/dry/monads/do.rb
 - lib/dry/monads/do/all.rb
+- lib/dry/monads/do/mixin.rb
 - lib/dry/monads/either.rb
 - lib/dry/monads/errors.rb
 - lib/dry/monads/lazy.rb
@@ -174,14 +175,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: 2.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.1
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Common monads for Ruby.