dry-monads 0.3.1 → 0.4.0

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

@@ -0,0 +1,34 @@
+module Dry::Monads
+  class Result
+    # @see Monads#Result
+    # @api private
+    class Fixed < Module
+      def self.[](error, **options)
+        new(error, **options)
+      end
+
+      def initialize(error, **options)
+        @mod = Module.new do
+          define_method(:Failure) do |value|
+            if error === value
+              Failure.new(value)
+            else
+              raise InvalidFailureTypeError.new(value)
+            end
+          end
+
+          def Success(value)
+            Success.new(value)
+          end
+        end
+      end
+
+      # @api private
+      def included(base)
+        super
+
+        base.include(@mod)
+      end
+    end
+  end
+end

data/lib/dry/monads/right_biased.rb

@@ -1,12 +1,25 @@
 require 'dry/core/constants'
+require 'dry/core/deprecations'
+
+require 'dry/monads/errors'
 
 module Dry
   module Monads
     module RightBiased
+      # @api public
       module Right
         include Dry::Core::Constants
 
-        attr_reader :value
+        extend Dry::Core::Deprecations[:'dry-monads']
+
+        # Unwraps the underlying value
+        #
+        # @return [Object]
+        def value!
+          @value
+        end
+
+        deprecate :value, :value!
 
         # Calls the passed in Proc object with value stored in self
         # and returns the result.
@@ -24,10 +37,10 @@ module Dry
         # @return [Object] result of calling proc or block on the internal value
         def bind(*args, **kwargs)
           if args.empty? && !kwargs.empty?
-            vargs, vkwargs = destructure(value)
+            vargs, vkwargs = destructure(@value)
             kw = [kwargs.merge(vkwargs)]
           else
-            vargs = [value]
+            vargs = [@value]
             kw = kwargs.empty? ? EMPTY_ARRAY : [kwargs]
           end
 
@@ -35,7 +48,7 @@ module Dry
             yield(*vargs, *args, *kw)
           else
             obj, *rest = args
-            obj.call(*vargs, *rest, *kw)
+            obj.(*vargs, *rest, *kw)
           end
         end
 
@@ -80,7 +93,33 @@ module Dry
         #
         # @return [Object]
         def value_or(_val = nil)
-          value
+          @value
+        end
+
+        # Applies the stored value to the given argument if the argument has type of Right,
+        # otherwise returns the argument
+        #
+        # @example happy path
+        #   create_user = Dry::Monads::Right(CreateUser.new)
+        #   name = Right("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)
+        #
+        # @return [RightBiased::Left,RightBiased::Right]
+        def apply(val)
+          unless @value.respond_to?(:call)
+            raise TypeError, "Cannot apply #{ val.inspect } to #{ @value.inspect }"
+          end
+          val.fmap { |unwrapped| curry.(unwrapped) }
+        end
+
+        # @param other [RightBiased]
+        # @return [Boolean]
+        def ===(other)
+          self.class == other.class && value! === other.value!
         end
 
         private
@@ -89,11 +128,37 @@ module Dry
         def destructure(*args, **kwargs)
           [args, kwargs]
         end
+
+        # @api private
+        def curry
+          @curried ||=
+            begin
+              func = @value.is_a?(Proc) ? @value : @value.method(:call)
+              seq_args = func.parameters.count { |type, _| type == :req }
+              seq_args += 1 if func.parameters.any? { |type, _| type == :keyreq }
+
+              if seq_args > 1
+                func.curry
+              else
+                func
+              end
+            end
+        end
       end
 
+      # @api public
       module Left
+        extend Dry::Core::Deprecations[:'dry-monads']
+
         attr_reader :value
 
+        deprecate :value, message: '.value is deprecated, use .value! instead'
+
+        # Raises an error on accessing internal value
+        def value!
+          raise UnwrapError.new(self)
+        end
+
         # Ignores the input parameter and returns self. It exists to keep the interface
         # identical to that of {RightBiased::Right}.
         #
@@ -143,7 +208,7 @@ module Dry
 
         # Returns the passed value
         #
-        # @returns [Object]
+        # @return [Object]
         def value_or(val = nil)
           if block_given?
             yield
@@ -151,6 +216,14 @@ module Dry
             val
           end
         end
+
+        # Ignores the input parameter and returns self. It exists to keep the interface
+        # identical to that of {RightBiased::Right}.
+        #
+        # @return [RightBiased::Left]
+        def apply(*)
+          self
+        end
       end
     end
   end

data/lib/dry/monads/try.rb

@@ -1,6 +1,8 @@
 require 'dry/equalizer'
 
 require 'dry/monads/right_biased'
+require 'dry/monads/result'
+require 'dry/monads/maybe'
 
 module Dry
   module Monads
@@ -12,40 +14,37 @@ module Dry
       attr_reader :exception
 
       # Calls the passed in proc object and if successful stores the result in a
-      # {Try::Success} monad, but if one of the specified exceptions was raised it stores
-      # it in a {Try::Failure} monad.
+      # {Try::Value} monad, but if one of the specified exceptions was raised it stores
+      # it in a {Try::Error} monad.
       #
       # @param exceptions [Array<Exception>] list of exceptions to be rescued
       # @param f [Proc] the proc to be called
-      # @return [Try::Success, Try::Failure]
+      # @return [Try::Value, Try::Error]
       def self.lift(exceptions, f)
-        Success.new(exceptions, f.call)
+        Value.new(exceptions, f.call)
       rescue *exceptions => e
-        Failure.new(e)
+        Error.new(e)
       end
 
-      # Returns true for an instance of a {Try::Success} monad.
-      def success?
-        is_a? Success
+      # Returns true for an instance of a {Try::Value} monad.
+      def value?
+        is_a?(Value)
       end
+      alias_method :success?, :value?
 
-      # Returns true for an instance of a {Try::Failure} monad.
-      def failure?
-        is_a? Failure
+      # Returns true for an instance of a {Try::Error} monad.
+      def error?
+        is_a?(Error)
       end
+      alias_method :failure?, :error?
 
       # Represents a result of a successful execution.
       #
       # @api public
-      class Success < Try
-        include Dry::Equalizer(:value, :catchable)
+      class Value < Try
+        include Dry::Equalizer(:value!, :catchable)
         include RightBiased::Right
 
-        # Using #or is not a good practice, you should process exceptions
-        # explicitly hence we don't offer an easy way to ignore them.
-        # Use Try#to_maybe if you're sure you need `#or` for `Try`.
-        undef :or
-
         attr_reader :catchable
 
         # @param exceptions [Array<Exception>] list of exceptions to be rescued
@@ -55,7 +54,7 @@ module Dry
           @value = value
         end
 
-        alias bind_call bind
+        alias_method :bind_call, :bind
         private :bind_call
 
         # Calls the passed in Proc object with value stored in self
@@ -64,20 +63,20 @@ module Dry
         # If proc is nil, it expects a block to be given and will yield to it.
         #
         # @example
-        #   success = Dry::Monads::Try::Success.new(ZeroDivisionError, 10)
+        #   success = Dry::Monads::Try::Value.new(ZeroDivisionError, 10)
         #   success.bind(->(n) { n / 2 }) # => 5
-        #   success.bind { |n| n / 0 } # => Try::Failure(ZeroDivisionError: divided by 0)
+        #   success.bind { |n| n / 0 } # => Try::Error(ZeroDivisionError: divided by 0)
         #
         # @param args [Array<Object>] arguments that will be passed to a block
         #                             if one was given, otherwise the first
         #                             value assumed to be a Proc (callable)
         #                             object and the rest of args will be passed
         #                             to this object along with the internal value
-        # @return [Object, Try::Failure]
-        def bind(*)
+        # @return [Object, Try::Error]
+        def bind(*args)
           super
         rescue *catchable => e
-          Failure.new(e)
+          Error.new(e)
         end
 
         # Does the same thing as #bind except it also wraps the value
@@ -85,43 +84,43 @@ module Dry
         # chaining of calls.
         #
         # @example
-        #   success = Dry::Monads::Try::Success.new(ZeroDivisionError, 10)
+        #   success = Dry::Monads::Try::Value.new(ZeroDivisionError, 10)
         #   success.fmap(&:succ).fmap(&:succ).value # => 12
         #   success.fmap(&:succ).fmap { |n| n / 0 }.fmap(&:succ).value # => nil
         #
         # @param args [Array<Object>] extra arguments for the block, arguments are being processes
         #                             just as in #bind
-        # @return [Try::Success, Try::Failure]
+        # @return [Try::Value, Try::Error]
         def fmap(*args, &block)
-          Success.new(catchable, bind_call(*args, &block))
+          Value.new(catchable, bind_call(*args, &block))
         rescue *catchable => e
-          Failure.new(e)
+          Error.new(e)
         end
 
         # @return [Maybe]
         def to_maybe
-          Dry::Monads::Maybe(value)
+          Dry::Monads::Maybe(@value)
         end
 
-        # @return [Either::Right]
-        def to_either
-          Dry::Monads::Right(value)
+        # @return [Result::Success]
+        def to_result
+          Dry::Monads::Success(@value)
         end
+        alias_method :to_either, :to_result
 
         # @return [String]
         def to_s
-          "Try::Success(#{value.inspect})"
+          "Try::Value(#{ @value.inspect })"
         end
-        alias inspect to_s
+        alias_method :inspect, :to_s
       end
 
       # Represents a result of a failed execution.
       #
       # @api public
-      class Failure < Try
+      class Error < Try
         include Dry::Equalizer(:exception)
         include RightBiased::Left
-        undef :or
 
         # @param exception [Exception]
         def initialize(exception)
@@ -133,16 +132,41 @@ module Dry
           Dry::Monads::None()
         end
 
-        # @return [Either::Left]
-        def to_either
-          Dry::Monads::Left(exception)
+        # @return [Result::Failure]
+        def to_result
+          Dry::Monads::Failure(exception)
         end
+        alias_method :to_either, :to_result
 
         # @return [String]
         def to_s
-          "Try::Failure(#{exception.class}: #{exception.message})"
+          "Try::Error(#{ exception.class }: #{ exception.message })"
+        end
+        alias_method :inspect, :to_s
+
+        # If a block is given passes internal value to it and returns the result,
+        # otherwise simply returns the first argument.
+        #
+        # @example
+        #   Try(ZeroDivisionError) { 1 / 0 }.or { "zero!" } # => "zero!"
+        #
+        # @param args [Array<Object>] arguments that will be passed to a block
+        #                             if one was given, otherwise the first
+        #                             value will be returned
+        # @return [Object]
+        def or(*args)
+          if block_given?
+            yield(exception, *args)
+          else
+            args[0]
+          end
+        end
+
+        # @param other [Try]
+        # @return [Boolean]
+        def ===(other)
+          Error === other && exception === other.exception
         end
-        alias inspect to_s
       end
 
       # A module that can be included for easier access to Try monads.
@@ -165,14 +189,34 @@ module Dry
 
         DEFAULT_EXCEPTIONS = [StandardError].freeze
 
-        # A convenience wrapper for {Try.lift}.
+        # A convenience wrapper for {Monads::Try.lift}.
         # If no exceptions are provided it falls back to StandardError.
         # In general, relying on this behaviour is not recommended as it can lead to unnoticed
         # bugs and it is always better to explicitly specify a list of exceptions if possible.
+        #
+        # @param exceptions [Array<Exception>]
         def Try(*exceptions, &f)
           catchable = exceptions.empty? ? DEFAULT_EXCEPTIONS : exceptions.flatten
           Try.lift(catchable, f)
         end
+
+        def Value(value = Undefined, exceptions = DEFAULT_EXCEPTIONS, &block)
+          if value.equal?(Undefined)
+            raise ArgumentError, 'No value given' if block.nil?
+            Try::Value.new(exceptions, block)
+          else
+            Try::Value.new(exceptions, value)
+          end
+        end
+
+        def Error(error = Undefined, &block)
+          if error.equal?(Undefined)
+            raise ArgumentError, 'No value given' if block.nil?
+            Try::Error.new(block)
+          else
+            Try::Error.new(error)
+          end
+        end
       end
     end
   end

data/lib/dry/monads/version.rb

@@ -1,5 +1,5 @@
 module Dry
   module Monads
-    VERSION = '0.3.1'.freeze
+    VERSION = '0.4.0'.freeze
   end
 end

data/lib/json/add/dry/monads/maybe.rb

@@ -19,7 +19,7 @@ module Dry
       def as_json(*)
         {
           JSON.create_id => self.class.name,
-          value: value
+          value: none? ? nil : @value
         }
       end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dry-monads
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Nikita Shilnikov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-03-17 00:00:00.000000000 Z
+date: 2017-11-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-equalizer
@@ -28,16 +28,22 @@ dependencies:
   name: dry-core
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.3.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.3.3
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -80,6 +86,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: dry-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.12'
 description: Common monads for Ruby.
 email:
 - fg@flashgordon.ru
@@ -91,7 +111,9 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
+- ".yardopts"
 - CHANGELOG.md
+- CONTRIBUTING.md
 - Gemfile
 - LICENSE
 - README.md
@@ -102,13 +124,17 @@ files:
 - lib/dry-monads.rb
 - lib/dry/monads.rb
 - lib/dry/monads/either.rb
+- lib/dry/monads/errors.rb
 - lib/dry/monads/list.rb
 - lib/dry/monads/maybe.rb
+- lib/dry/monads/result.rb
+- lib/dry/monads/result/fixed.rb
 - lib/dry/monads/right_biased.rb
 - lib/dry/monads/transformer.rb
 - lib/dry/monads/try.rb
 - lib/dry/monads/version.rb
 - lib/json/add/dry/monads/maybe.rb
+- log/.gitkeep
 homepage: https://github.com/dry-rb/dry-monads
 licenses:
 - MIT
@@ -122,7 +148,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.1.0
+      version: 2.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -130,7 +156,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.10
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Common monads for Ruby.