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/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

Classes: ControlSignal, Err, Ok

Constant Summary collapse

OkType = 
type_member
ErrType = 
type_member

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

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

Parameters:

  • inner (T.type_parameter(:ErrType))

Returns:

  • (Result::Err[T.type_parameter(:OkType), T.type_parameter(:ErrType)]) 


112
113
114
 
# File 'lib/mangrove/result.rb', line 112

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

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

Parameters:

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

Returns:

  • (Result::Err[T.type_parameter(:OkType), T.type_parameter(:ErrType)]) 


117
118
119
 
# File 'lib/mangrove/result.rb', line 117

def err_wt(_t_ok, inner)
  Result::Err[T.type_parameter(:OkType), 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)]]) 


89
90
91
92
93
94
95
96
97
98
99
 
# File 'lib/mangrove/result.rb', line 89

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

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

Parameters:

  • inner (T.type_parameter(:OkType))

Returns:

  • (Result::Ok[T.type_parameter(:OkType), T.type_parameter(:ErrType)]) 


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

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

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

Parameters:

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

Returns:

  • (Result::Ok[T.type_parameter(:OkType), T.type_parameter(:ErrType)]) 


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

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

Instance Method Details

#==(other) ⇒ Boolean

This method is abstract.

Parameters:

  • other (BasicObject)

Returns:

  • (Boolean) 


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

def ==(other); end

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

This method is abstract.

Parameters:

Returns:



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

def and(other); end

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

This method is abstract.

Parameters:

Returns:



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

def and_then(&block); end

#and_then_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(Result[T.type_parameter(:NewOkType), ErrType]))

Returns:



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

def and_then_wt(_t_new_ok, &block); end

#err? ⇒ Boolean

This method is abstract.

Returns:

  • (Boolean) 


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

def err?; end

#expect!(message) ⇒ OkType

This method is abstract.

Parameters:

  • message (String)

Returns:



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

def expect!(message); end

#expect_with!(&block) ⇒ OkType

This method is abstract.

Parameters:

  • block (T.proc.returns(T.type_parameter(:E)))

Returns:



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

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


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

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:



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

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:



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

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:



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

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:



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

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.type_parameter(:NewOkType))
  • _t_new_err (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)]) 


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

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

#ok? ⇒ Boolean

This method is abstract.

Returns:

  • (Boolean) 


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

def ok?; end

#or(other) ⇒ Result[OkType, ErrType]

This method is abstract.

Parameters:

Returns:



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

def or(other); end

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

This method is abstract.

Parameters:

Returns:



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

def or_else(&block); end

#or_else_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(Result[OkType, T.type_parameter(:NewErrType)]))

Returns:



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

def or_else_wt(_t_new_err, &block); end

#unwrap! ⇒ OkType

This method is abstract.

Returns:



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

def unwrap!; end

#unwrap_or_raise!(exception) ⇒ OkType

This method is abstract.

Parameters:

  • exception (Exception)

Returns:



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

def unwrap_or_raise!(exception); end

#unwrap_or_raise_inner! ⇒ OkType

This method is abstract.

Returns:



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

def unwrap_or_raise_inner!; end