Module: Dry::Monads::RightBiased::Right

Included in:
Maybe::Some, Dry::Monads::Result::Success, Try::Value
Defined in:
lib/dry/monads/right_biased.rb

Overview

Right part

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.included(m) ⇒ Object 



12
13
14
15
16
17
18
19
 
# File 'lib/dry/monads/right_biased.rb', line 12

def self.included(m)
  super

  def m.to_proc
    @to_proc ||= method(:new).to_proc
  end
  m.singleton_class.alias_method(:call, :new)
end

Instance Method Details

#===(other) ⇒ Boolean

Parameters:

  • other (Object)

Returns:

  • (Boolean) 


136
137
138
 
# File 'lib/dry/monads/right_biased.rb', line 136

def ===(other)
  other.instance_of?(self.class) && value! === other.value!
end

#and(mb) ⇒ RightBiased::Left, RightBiased::Right

Combines the wrapped value with another monadic value. If both values are right-sided, yields a block and passes a tuple of values there. If no block given, returns a tuple of values wrapped with a monadic structure.

Examples:

include Dry::Monads::Result::Mixin

Success(3).and(Success(5)) # => Success([3, 5])
Success(3).and(Failure(:not_a_number)) # => Failure(:not_a_number)
Failure(:not_a_number).and(Success(5)) # => Failure(:not_a_number)
Success(3).and(Success(5)) { |a, b| a + b } # => Success(8)

Parameters:

Returns:



181
182
183
184
185
186
187
188
189
190
191
 
# File 'lib/dry/monads/right_biased.rb', line 181

def and(mb)
  bind do |a|
    mb.fmap do |b|
      if block_given?
        yield([a, b])
      else
        [a, b]
      end
    end
  end
end

#apply(val = Undefined, &block) ⇒ RightBiased::Left, RightBiased::Right

Applies the stored value to the given argument if the argument has type of Right, otherwise returns the argument.

Examples:

happy path

create_user = Dry::Monads::Success(CreateUser.new)
name = Success("John")
create_user.apply(name) # equivalent to CreateUser.new.call("John")

unhappy path

name = Failure(:name_missing)
create_user.apply(name) # => Failure(:name_missing)

Returns:



126
127
128
129
130
131
132
 
# File 'lib/dry/monads/right_biased.rb', line 126

def apply(val = Undefined, &block)
  unless @value.respond_to?(:call)
    raise TypeError, "Cannot apply #{val.inspect} to #{@value.inspect}"
  end

  Undefined.default(val, &block).fmap { curry.(_1) }
end

#bind(*args, **kwargs) ⇒ Object

Calls the passed in Proc object with value stored in self and returns the result.

If proc is nil, it expects a block to be given and will yield to it.

Examples:

Dry::Monads.Right(4).bind(&:succ) # => 5

Parameters:

  • 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

Returns:

  • (Object) —

    result of calling proc or block on the internal value



42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
 
# File 'lib/dry/monads/right_biased.rb', line 42

def bind(*args, **kwargs)
  if args.empty? && !kwargs.empty?
    vargs, vkwargs = destructure(@value)
    kw = [kwargs.merge(vkwargs)]
  else
    vargs = [@value]
    kw = kwargs.empty? ? EMPTY_ARRAY : [kwargs]
  end

  if block_given?
    yield(*vargs, *args, *kw)
  else
    obj, *rest = args
    obj.(*vargs, *rest, *kw)
  end
end

#deconstruct ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Pattern matching

Examples:

case Success(x)
in Success(Integer) then ...
in Success(2..100) then ...
in Success(2..200 => code) then ...
end


203
204
205
206
207
208
209
210
211
 
# File 'lib/dry/monads/right_biased.rb', line 203

def deconstruct
  if Unit.equal?(@value)
    EMPTY_ARRAY
  elsif !@value.is_a?(::Array)
    [@value]
  else
    @value
  end
end

#deconstruct_keys(keys) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Pattern matching hash values

Examples:

case Success(x)
in Success(code: 200...300) then :ok
in Success(code: 300...400) then :redirect
in Success(code: 400...500) then :user_error
in Success(code: 500...600) then :server_error
end


224
225
226
227
228
229
230
 
# File 'lib/dry/monads/right_biased.rb', line 224

def deconstruct_keys(keys)
  if @value.respond_to?(:deconstruct_keys)
    @value.deconstruct_keys(keys)
  else
    EMPTY_HASH
  end
end

#discard ⇒ RightBiased::Right

Maps the value to Dry::Monads::Unit, useful when you don’t care about the actual value.

Examples:

Dry::Monads::Success(:success).discard
# => Success(Unit)

Returns:



148
149
150
 
# File 'lib/dry/monads/right_biased.rb', line 148

def discard
  fmap { Unit }
end

#flatten ⇒ RightBiased::Right, RightBiased::Left

Removes one level of monad structure by joining two values.

Examples:

include Dry::Monads::Result::Mixin
Success(Success(5)).flatten # => Success(5)
Success(Failure(:not_a_number)).flatten # => Failure(:not_a_number)
Failure(:not_a_number).flatten # => Failure(:not_a_number)

Returns:



161
162
163
 
# File 'lib/dry/monads/right_biased.rb', line 161

def flatten
  bind(&:itself)
end

#fmap ⇒ RightBiased::Right

Abstract method for lifting a block over the monad type. Must be implemented for a right-biased monad.

Returns:

Raises:

  • (NotImplementedError) 


76
77
78
 
# File 'lib/dry/monads/right_biased.rb', line 76

def fmap(*)
  raise NotImplementedError
end

#or ⇒ RightBiased::Right

Ignores arguments and returns self. It exists to keep the interface identical to that of Left.

Returns:



84
85
86
 
# File 'lib/dry/monads/right_biased.rb', line 84

def or(*)
  self
end

#or_fmap ⇒ RightBiased::Right

A lifted version of ‘#or`. For Dry::Monads::RightBiased::Right acts in the same way as `#or`, that is returns itselt.

Returns:



102
103
104
 
# File 'lib/dry/monads/right_biased.rb', line 102

def or_fmap(*)
  self
end

#tee ⇒ RightBiased::Right

Does the same thing as #bind except it returns the original monad when the result is a Right.

Examples:

Dry::Monads.Right(4).tee { Right('ok') } # => Right(4)
Dry::Monads.Right(4).tee { Left('fail') } # => Left('fail')

Parameters:

  • args (Array<Object>) —

    arguments will be transparently passed through to #bind

Returns:



68
69
70
 
# File 'lib/dry/monads/right_biased.rb', line 68

def tee(...)
  bind(...).bind { self }
end

#value! ⇒ Object

Unwraps the underlying value

Returns:

  • (Object) 


24
25
26
 
# File 'lib/dry/monads/right_biased.rb', line 24

def value!
  @value
end

#value_or(_val = nil) ⇒ Object

Returns value. It exists to keep the interface identical to that of RightBiased::Left

Returns:

  • (Object) 


109
110
111
 
# File 'lib/dry/monads/right_biased.rb', line 109

def value_or(_val = nil)
  @value
end

#|(_alt) ⇒ RightBiased::Right

Ignores arguments and returns self. It exists to keep the interface identical to that of Left.

Parameters:

Returns:



94
95
96
 
# File 'lib/dry/monads/right_biased.rb', line 94

def |(_alt)
  self
end