dry-monads

The Validated monad represents the outcome of a validation process. It is similar to Result, but with a key difference in how it handles errors during composition:

• Error Accumulation: Unlike Result, which short-circuits on the first error, Validated implements #apply in a way that concatenates errors.
• Requirement: For error concatenation to work, the error type must implement the + method (it must be a semigroup), such as an Array or List.
• No Monadic Binding: Validated does not implement bind (or flat_map) because doing so would violate monad laws in the context of error accumulation. It is used for parallel validation rather than sequential dependency.

When using List<Validated>#traverse, the errors are automatically wrapped in a list, so you don't have to manually manage the collection of errors.

# Example: Error accumulation with List
# If you have multiple invalid results, Validated concatenates the errors.
List::Validated[Valid('London'), Invalid(:name_missing), Invalid(:email_missing)]
# => Invalid(List[:name_missing, :email_missing])

# Example: Successful results
List::Validated[Valid('London'), Valid('John')]
# => Valid(List['London', 'John'])

Including Dry::Monads::Do::All in a class automatically wraps all defined methods with an unwrapping block. This allows you to use yield inside your methods to unwrap monadic values (like Success or Failure). If a method returns a Failure, the execution of the calling method is automatically halted.

Key behaviors:

• Automatic Wrapping: Every method defined in the class is wrapped, so you don't need to list them explicitly as you would with Do.for(...).
• Precedence: If you explicitly pass a block to a method call (e.g., method { ... }), that block takes precedence over the automatic unwrapping logic.
• Visibility Preservation: The wrapper respects the original visibility (public, protected, or private) of the methods.

require 'dry/monads/do/all'
require 'dry/monads/result'

class CreateUser
  include Dry::Monads::Do::All
  include Dry::Monads::Result::Mixin

  def call(params)
    # If `validate` returns Failure, the execution will be halted
    values = yield validate(params)
    
    user = create_user(values)

    # An explicitly passed block takes precedence over the unwrapping block
    safely_subscribe(values[:email]) { puts "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)
    # This method is wrapped, but we don't use the yielded block here
    UserRepo.new.add(user)
  end

  def safely_subscribe(email)
    repo = SubscriptionRepo.new

    if repo.subscribed?(email)
       # This calls the block explicitly passed from `call` via `yield`
       yield
    else
       repo.subscribe(email)
    end
  end
end

The Dry::Monads::Do.for method allows you to use yield within a method to unwrap monadic values (like Success or Failure) sequentially. If a method returns a failure, the execution of the workflow halts immediately and returns that failure. This avoids deeply nested if/else or case statements when chaining multiple monadic operations.

To use it, call include Dry::Monads::Do.for(:method_name, ...) in your class, specifying the methods you want to wrap with Do-notation logic.

class CreateUser
  include Dry::Monads::Result::Mixin
  include Dry::Monads::Try::Mixin
  # Specify which methods should support 'yield' to unwrap monads
  include Dry::Monads::Do.for(:call)

  def call(params)
    # If parse_json returns a Failure, the method halts here and returns the Failure
    json = yield parse_json(params)
    
    # If validate returns a Failure, the method halts here
    hash = yield validate(json)

    # You can also use yield inside blocks like transactions
    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