Result

The Result monad is useful to express a series of computations that might
return an error object with additional information.

The Result mixin has two type constructors: Success and Failure. The Success
can be thought of as “everything went success” and the Failure is used when
“something has gone wrong”.

Result::Mixin

require 'dry-monads'

class ResultCalculator
  include Dry::Monads::Result::Mixin

  attr_accessor :input

  def calculate
    i = Integer(input)

    Success(i).bind do |value|
      if value > 1
        Success(value + 3)
      else
        Failure("value was less than 1")
      end
    end.bind do |value|
      if value % 2 == 0
        Success(value * 2)
      else
        Failure("value was not even")
      end
    end
  end
end

# ResultCalculator instance
c = ResultCalculator.new

# If everything went success
c.input = 3
result = c.calculate
result # => Success(12)

# If it failed in the first block
c.input = 0
result = c.calculate
result # => Failure("value was less than 1")

# if it failed in the second block
c.input = 2
result = c.calculate
result # => Failure("value was not even")

bind

Use bind for composing several possibly-failing operations:

require 'dry-monads'

M = Dry::Monads

class AssociateUser
  def call(user_id:, address_id:)
    find_user(user_id).bind do |user|
      find_address(address_id).fmap do |address|
        user.update(address_id: address.id)
      end
    end
  end

  private

  def find_user(id)
    user = User.find(id)

    if user
      Sucess(user)
    else
      Failure(:user_not_found)
    end
  end

  def find_address(id)
    address = Address.find(id)

    if address
      Sucess(address)
    else
      Failure(:address_not_found)
    end
  end
end

AssociateUser.new.(user_id: 1, address_id: 2)

fmap

An example of using fmap with Success and Failure.

require 'dry-monads'

M = Dry::Monads

result = if foo > bar
  M.Success(10)
else
  M.Failure("wrong")
end.fmap { |x| x * 2 }

# If everything went success
result # => Success(20)
# If it did not
result # => Failure("wrong")

# #fmap accepts a proc, just like #bind

upcase = :upcase.to_proc

M.Success('hello').fmap(upcase) # => Success("HELLO")

value_or

value_or is a safe and recommended way of extracting values.

M = Dry::Monads

M.Success(10).value_or(0) # => 10
M.Failure('Error').value_or(0) # => 0

value!

If you’re 100% sure you’re dealing with a Success case you might use value! for extracting the value without providing a default. Beware, this will raise an exception if you call it on Failure.

M = Dry::Monads

M.Success(10).value! # => 10

M.Failure('Error').value!
# => Dry::Monads::UnwrapError: value! was called on Failure

or

An example of using or with Success and Failure.

M = Dry::Monads

M.Success(10).or(M.Success(99)) # => Success(10)
M.Failure("error").or(M.Failure("new error")) # => Failure("new error")
M.Failure("error").or { |err| M.Failure("new #{err}") } # => Failure("new error")

failure

Use failure for unwrapping the value from a Failure instance.

M = Dry::Monads

M.Failure('Error').failure # => "Error"

to_maybe

Sometimes it’s useful to turn a Result into a Maybe.

require 'dry-monads'

result = if foo > bar
  Dry::Monads.Success(10)
else
  Dry::Monads.Failure("wrong")
end.to_maybe

# If everything went success
result # => Some(10)
# If it did not
result # => None()

failure? and success?

You can explicitly check the type by calling failure? or success? on a monadic value.