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/collector.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, Collector, 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:



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

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:



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

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:



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

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)]]) 


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

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:



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

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:



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

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) 


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

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]) 


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

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:



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

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]) 


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

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]) 


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

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) 


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

def err?; end

#expect!(message) ⇒ OkType

This method is abstract.

Parameters:

  • message (String)

Returns:



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

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:



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

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)]) 


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

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:



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

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:



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

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:



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

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:



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

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)]) 


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

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) 


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

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)]) 


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

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)]) 


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

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)]) 


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

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:



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

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:



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

def tap_err(&block); end

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

This method is abstract.

Parameters:

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

Returns:



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

def tap_ok(&block); end

#unwrap! ⇒ OkType

This method is abstract.

Returns:



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

def unwrap!; end

#unwrap_in(ctx) ⇒ OkType

This method is abstract.

Parameters:

Returns:



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

def unwrap_in(ctx); end

#unwrap_or_raise!(exception) ⇒ OkType

This method is abstract.

Parameters:

  • exception (Exception)

Returns:



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

def unwrap_or_raise!(exception); end

#unwrap_or_raise_inner! ⇒ OkType

This method is abstract.

Returns:



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

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:



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

def unwrap_or_raise_with!(&block); end