Module: Mangrove::Result Abstract

Extended by:
T::Generic, T::Helpers, T::Sig
Includes:
Kernel
Included in:
Err, Ok
Defined in:
lib/mangrove/result.rb,
lib/mangrove/result/ext.rb,
lib/mangrove/result/control_signal.rb

Overview

This module is abstract.

Subclasses must implement the ‘abstract` methods below.

Result is a type that represents either success (‘Ok`) or failure (`Err`).

Defined Under Namespace

Modules: Ext Classes: CollectingContext, ControlSignal, Err, Ok

Constant Summary collapse

OkType = 
type_member
ErrType = 
type_member

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.collecting(_t_ok, _t_err, &block) ⇒ Mangrove::Result[T.type_parameter(:O), T.type_parameter(:E)]

Parameters:

  • _t_ok (T::Class[T.type_parameter(:O)])
  • _t_err (T::Class[T.type_parameter(:E)])
  • block (T.proc.params( do_block: CollectingContext[T.type_parameter(:O), T.type_parameter(:E)] ).returns(Mangrove::Result[T.type_parameter(:O), T.type_parameter(:E)]))

Returns:



176
177
178
179
180
 
# File 'lib/mangrove/result.rb', line 176

def collecting(_t_ok, _t_err, &block)
  catch(:__mangrove_result_collecting_context_return) {
    block.call(CollectingContext[T.type_parameter(:O), T.type_parameter(:E)].new)
  }
end

.err(inner) ⇒ Result::Err[T.type_parameter(:ErrType)]

Parameters:

  • inner (T.type_parameter(:ErrType))

Returns:



155
156
157
 
# File 'lib/mangrove/result.rb', line 155

def err(inner)
  Result::Err[T.type_parameter(:ErrType)].new(inner)
end

.err_wt(_t_ok, inner) ⇒ Result::Err[T.type_parameter(:ErrType)]

Deprecated.

Parameters:

  • _t_ok (T::Class[T.type_parameter(:OkType)])
  • inner (T.type_parameter(:ErrType))

Returns:



161
162
163
 
# File 'lib/mangrove/result.rb', line 161

def err_wt(_t_ok, inner)
  Result::Err[T.type_parameter(:ErrType)].new(inner)
end

.from_results(results) ⇒ Result[T::Enumerable[T.type_parameter(:T)], T::Enumerable[T.type_parameter(:E)]]

Parameters:

  • results (Enumerable<Result[T.type_parameter(:T), T.type_parameter(:E)]>)

Returns:

  • (Result[T::Enumerable[T.type_parameter(:T)], T::Enumerable[T.type_parameter(:E)]]) 


131
132
133
134
135
136
137
138
139
140
141
 
# File 'lib/mangrove/result.rb', line 131

def from_results(results)
  errs = results.filter(&:err?)

  if errs.empty?
    # This is safe as errs is empty.
    Result::Ok[T::Enumerable[T.type_parameter(:T)]].new(results.map { |r| T.cast(r, Result::Ok[T.type_parameter(:T)]).ok_inner })
  else
    # This is safe as errs is results where err? is true
    Result::Err[T::Enumerable[T.type_parameter(:E)]].new(errs.map { |r| T.cast(r, Result::Err[T.type_parameter(:E)]).err_inner })
  end
end

.ok(inner) ⇒ Result::Ok[T.type_parameter(:OkType)]

Parameters:

  • inner (T.type_parameter(:OkType))

Returns:



144
145
146
 
# File 'lib/mangrove/result.rb', line 144

def ok(inner)
  Result::Ok[T.type_parameter(:OkType)].new(inner)
end

.ok_wt(inner, _t_err) ⇒ Result::Ok[T.type_parameter(:OkType)]

Deprecated.

Parameters:

  • inner (T.type_parameter(:OkType))
  • _t_err (T::Class[T.type_parameter(:ErrType)])

Returns:



150
151
152
 
# File 'lib/mangrove/result.rb', line 150

def ok_wt(inner, _t_err)
  Result::Ok[T.type_parameter(:OkType)].new(inner)
end

Instance Method Details

#==(other) ⇒ Boolean

This method is abstract.

Parameters:

  • other (BasicObject)

Returns:

  • (Boolean) 


23
 
# File 'lib/mangrove/result.rb', line 23

def ==(other); end

#and(other) ⇒ Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)], Result[T.type_parameter(:NewOkType), ErrType]

This method is abstract.

Parameters:

  • other (Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])

Returns:

  • (Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)], Result[T.type_parameter(:NewOkType), ErrType]) 


80
 
# File 'lib/mangrove/result.rb', line 80

def and(other); end

#and_err_if(new_err_inner, &condition) ⇒ Result[OkType, T.type_parameter(:NewErrType)], Result[OkType, ErrType]

This method is abstract.

Parameters:

  • new_err_inner (T.type_parameter(:NewErrType))
  • condition (T.proc.params(inner: OkType).returns(T::Boolean))

Returns:



99
 
# File 'lib/mangrove/result.rb', line 99

def and_err_if(new_err_inner, &condition); end

#and_then(&block) ⇒ Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)], Result[T.type_parameter(:NewOkType), ErrType]

This method is abstract.

Parameters:

  • block (T.proc.params(this: OkType).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]))

Returns:

  • (Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)], Result[T.type_parameter(:NewOkType), ErrType]) 


83
 
# File 'lib/mangrove/result.rb', line 83

def and_then(&block); end

#and_then_wt(_t_new_ok, &block) ⇒ Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)], Result[T.type_parameter(:NewOkType), ErrType]

This method is abstract.

Parameters:

  • _t_new_ok (T::Class[T.type_parameter(:NewOkType)])
  • block (T.proc.params(this: OkType).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]))

Returns:

  • (Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)], Result[T.type_parameter(:NewOkType), ErrType]) 


86
 
# File 'lib/mangrove/result.rb', line 86

def and_then_wt(_t_new_ok, &block); end

#err? ⇒ Boolean

Deprecated.

Use #is_a?(Result::Err) instead to enable Sorbet to define types statically.

This method is abstract.

Returns:

  • (Boolean) 


32
 
# File 'lib/mangrove/result.rb', line 32

def err?; end

#expect!(message) ⇒ OkType

This method is abstract.

Parameters:

  • message (String)

Returns:



50
 
# File 'lib/mangrove/result.rb', line 50

def expect!(message); end

#expect_with!(&block) ⇒ OkType

This method is abstract.

Parameters:

  • block (T.proc.params(err: ErrType).returns(T.type_parameter(:E)))

Returns:



53
 
# File 'lib/mangrove/result.rb', line 53

def expect_with!(&block); end

#map(&block) ⇒ Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]

This method is abstract.

Parameters:

  • block (T.proc.params(this: Result[OkType, ErrType]).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]))

Returns:

  • (Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]) 


56
 
# File 'lib/mangrove/result.rb', line 56

def map(&block); end

#map_err(&block) ⇒ Result[OkType, T.type_parameter(:NewErrType)]

This method is abstract.

Parameters:

  • block (T.proc.params(this: ErrType).returns(T.type_parameter(:NewErrType)))

Returns:



68
 
# File 'lib/mangrove/result.rb', line 68

def map_err(&block); end

#map_err_wt(_t_new_err, &block) ⇒ Result[OkType, T.type_parameter(:NewErrType)]

This method is abstract.

Parameters:

  • _t_new_err (T::Class[T.type_parameter(:NewErrType)])
  • block (T.proc.params(this: ErrType).returns(T.type_parameter(:NewErrType)))

Returns:



71
 
# File 'lib/mangrove/result.rb', line 71

def map_err_wt(_t_new_err, &block); end

#map_ok(&block) ⇒ Result[T.type_parameter(:NewOkType), ErrType]

This method is abstract.

Parameters:

  • block (T.proc.params(this: OkType).returns(T.type_parameter(:NewOkType)))

Returns:



62
 
# File 'lib/mangrove/result.rb', line 62

def map_ok(&block); end

#map_ok_wt(_t_new_ok, &block) ⇒ Result[T.type_parameter(:NewOkType), ErrType]

This method is abstract.

Parameters:

  • _t_new_ok (T::Class[T.type_parameter(:NewOkType)])
  • block (T.proc.params(this: OkType).returns(T.type_parameter(:NewOkType)))

Returns:



65
 
# File 'lib/mangrove/result.rb', line 65

def map_ok_wt(_t_new_ok, &block); end

#map_wt(_t_new_ok, _t_new_err, &block) ⇒ Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]

This method is abstract.

Parameters:

  • _t_new_ok (T::Class[T.type_parameter(:NewOkType)])
  • _t_new_err (T::Class[T.type_parameter(:NewErrType)])
  • block (T.proc.params(this: Result[OkType, ErrType]).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]))

Returns:

  • (Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]) 


59
 
# File 'lib/mangrove/result.rb', line 59

def map_wt(_t_new_ok, _t_new_err, &block); end

#ok? ⇒ Boolean

Deprecated.

Use #is_a?(Result::Ok) instead to enable Sorbet to define types statically. This method will be removed in future versions.

This method is abstract.

Returns:

  • (Boolean) 


28
 
# File 'lib/mangrove/result.rb', line 28

def ok?; end

#or(other) ⇒ Result[OkType, T.type_parameter(:NewErrType)], Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]

This method is abstract.

Parameters:

  • other (Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])

Returns:

  • (Result[OkType, T.type_parameter(:NewErrType)], Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]) 


102
 
# File 'lib/mangrove/result.rb', line 102

def or(other); end

#or_else(&block) ⇒ Result[OkType, T.type_parameter(:NewErrType)], Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]

This method is abstract.

Parameters:

  • block (T.proc.params(this: ErrType).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]))

Returns:

  • (Result[OkType, T.type_parameter(:NewErrType)], Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]) 


105
 
# File 'lib/mangrove/result.rb', line 105

def or_else(&block); end

#or_else_wt(_t_new_err, &block) ⇒ Result[OkType, T.type_parameter(:NewErrType)], Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]

This method is abstract.

Parameters:

  • _t_new_err (T::Class[T.type_parameter(:NewErrType)])
  • block (T.proc.params(this: ErrType).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]))

Returns:

  • (Result[OkType, T.type_parameter(:NewErrType)], Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]) 


108
 
# File 'lib/mangrove/result.rb', line 108

def or_else_wt(_t_new_err, &block); end

#or_ok_if(new_ok_inner, &condition) ⇒ Result[T.type_parameter(:NewOkType), ErrType], Result[OkType, ErrType]

This method is abstract.

Parameters:

  • new_ok_inner (T.type_parameter(:NewOkType))
  • condition (T.proc.params(inner: ErrType).returns(T::Boolean))

Returns:



121
 
# File 'lib/mangrove/result.rb', line 121

def or_ok_if(new_ok_inner, &condition); end

#tap_err(&block) ⇒ Result[OkType, ErrType]

This method is abstract.

Parameters:

  • block (T.proc.params(this: ErrType).void)

Returns:



77
 
# File 'lib/mangrove/result.rb', line 77

def tap_err(&block); end

#tap_ok(&block) ⇒ Result[OkType, ErrType]

This method is abstract.

Parameters:

  • block (T.proc.params(this: OkType).void)

Returns:



74
 
# File 'lib/mangrove/result.rb', line 74

def tap_ok(&block); end

#unwrap! ⇒ OkType

This method is abstract.

Returns:



35
 
# File 'lib/mangrove/result.rb', line 35

def unwrap!; end

#unwrap_in(ctx) ⇒ OkType

This method is abstract.

Parameters:

Returns:



47
 
# File 'lib/mangrove/result.rb', line 47

def unwrap_in(ctx); end

#unwrap_or_raise!(exception) ⇒ OkType

This method is abstract.

Parameters:

  • exception (Exception)

Returns:



41
 
# File 'lib/mangrove/result.rb', line 41

def unwrap_or_raise!(exception); end

#unwrap_or_raise_inner! ⇒ OkType

This method is abstract.

Returns:



44
 
# File 'lib/mangrove/result.rb', line 44

def unwrap_or_raise_inner!; end

#unwrap_or_raise_with!(&block) ⇒ OkType

This method is abstract.

Parameters:

  • block (T.proc.params(err: ErrType).returns(Exception))

Returns:



38
 
# File 'lib/mangrove/result.rb', line 38

def unwrap_or_raise_with!(&block); end