Class: Mangrove::Result::Err

Inherits:
Object
  • Object
show all
Extended by:
T::Generic, T::Helpers, T::Sig
Includes:
Mangrove::Result
Defined in:
lib/mangrove/result.rb

Constant Summary collapse

OkType = 
type_member { { fixed: T.noreturn } }
ErrType = 
type_member

Instance Method Summary collapse

Methods included from Mangrove::Result

collecting, err, err_wt, from_results, ok, ok_wt

Constructor Details

#initialize(inner) ⇒ void

Parameters:



416
417
418
 
# File 'lib/mangrove/result.rb', line 416

def initialize(inner)
  @inner = inner
end

Instance Method Details

#==(other) ⇒ Boolean

Parameters:

  • other (BasicObject)

Returns:

  • (Boolean) 


421
422
423
424
425
426
427
428
429
430
431
 
# File 'lib/mangrove/result.rb', line 421

def ==(other)
  case other
  when Result::Ok
    false
  when Result::Err
    other.instance_variable_get(:@inner) == @inner
  else # rubocop:disable Lint/DuplicateBranch
    # Because == is defined on BasicObject, we can't be sure that `other` is an Option
    false
  end
end

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

Parameters:

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

Returns:



523
524
525
 
# File 'lib/mangrove/result.rb', line 523

def and(_other)
  self
end

#and_err_if(_new_err_inner, &_condition) ⇒ Result[OkType, ErrType]

Parameters:

  • _new_err_inner (T.type_parameter(:NewErrType))
  • _condition (T.proc.params(inner: OkType).returns(T::Boolean))

Returns:



549
550
551
 
# File 'lib/mangrove/result.rb', line 549

def and_err_if(_new_err_inner, &_condition)
  self
end

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

Parameters:

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

Returns:



528
529
530
 
# File 'lib/mangrove/result.rb', line 528

def and_then(&_block)
  self
end

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

Deprecated.

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:



534
535
536
 
# File 'lib/mangrove/result.rb', line 534

def and_then_wt(_t_new_ok, &_block)
  self
end

#deconstruct ⇒ Array<ErrType>

Returns:



588
589
590
 
# File 'lib/mangrove/result.rb', line 588

def deconstruct
  [@inner]
end

#deconstruct_keys(_keys) ⇒ Hash{Symbol => ErrType}

Parameters:

  • _keys (Array<Symbol>, nil)

Returns:



593
594
595
 
# File 'lib/mangrove/result.rb', line 593

def deconstruct_keys(_keys)
  { inner: @inner }
end

#err? ⇒ Boolean

Deprecated.

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

Returns:

  • (Boolean) 


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

def err? = true

#err_inner ⇒ ErrType

Returns:



434
435
436
 
# File 'lib/mangrove/result.rb', line 434

def err_inner
  @inner
end

#expect!(message) ⇒ OkType

Parameters:

  • message (String)

Returns:

Raises:



464
465
466
 
# File 'lib/mangrove/result.rb', line 464

def expect!(message)
  raise Result::ControlSignal, message
end

#expect_with!(&block) ⇒ OkType

Parameters:

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

Returns:

Raises:



469
470
471
 
# File 'lib/mangrove/result.rb', line 469

def expect_with!(&block)
  raise Result::ControlSignal, block.call(@inner)
end

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

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


482
483
484
 
# File 'lib/mangrove/result.rb', line 482

def map(&block)
  block.call(self)
end

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

Parameters:

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

Returns:



502
503
504
 
# File 'lib/mangrove/result.rb', line 502

def map_err(&block)
  Result::Err[T.type_parameter(:NewErrType)].new(block.call(@inner))
end

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

Parameters:

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

Returns:



507
508
509
 
# File 'lib/mangrove/result.rb', line 507

def map_err_wt(_t_new_err, &block)
  Result::Err[T.type_parameter(:NewErrType)].new(block.call(@inner))
end

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

Parameters:

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

Returns:



492
493
494
 
# File 'lib/mangrove/result.rb', line 492

def map_ok(&_block)
  self
end

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

Parameters:

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

Returns:



497
498
499
 
# File 'lib/mangrove/result.rb', line 497

def map_ok_wt(_t_new_ok, &_block)
  self
end

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

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


487
488
489
 
# File 'lib/mangrove/result.rb', line 487

def map_wt(_t_new_ok, _t_new_err, &block)
  block.call(self)
end

#ok? ⇒ Boolean

Deprecated.

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

Returns:

  • (Boolean) 


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

def ok? = false

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

Parameters:

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

Returns:

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


554
555
556
 
# File 'lib/mangrove/result.rb', line 554

def or(other)
  other
end

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

Parameters:

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

Returns:

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


559
560
561
 
# File 'lib/mangrove/result.rb', line 559

def or_else(&block)
  block.call(@inner)
end

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

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[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]) 


564
565
566
 
# File 'lib/mangrove/result.rb', line 564

def or_else_wt(_t_new_err, &block)
  block.call(@inner)
end

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

Parameters:

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

Returns:



579
580
581
582
583
584
585
 
# File 'lib/mangrove/result.rb', line 579

def or_ok_if(new_ok_inner, &condition)
  if condition.call(@inner)
    Result::Ok[T.type_parameter(:NewOkType)].new(new_ok_inner)
  else
    self
  end
end

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

Parameters:

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

Returns:



517
518
519
520
 
# File 'lib/mangrove/result.rb', line 517

def tap_err(&block)
  block.call(@inner)
  self
end

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

Parameters:

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

Returns:



512
513
514
 
# File 'lib/mangrove/result.rb', line 512

def tap_ok(&_block)
  self
end

#to_s ⇒ String

Returns:

  • (String) 


598
599
600
 
# File 'lib/mangrove/result.rb', line 598

def to_s
  "#{super}: inner=`#{@inner}`"
end

#unwrap! ⇒ OkType

Returns:

Raises:



439
440
441
 
# File 'lib/mangrove/result.rb', line 439

def unwrap!
  raise Result::ControlSignal, @inner
end

#unwrap_in(_ctx) ⇒ T.noreturn

Parameters:

Returns:

  • (T.noreturn) 


459
460
461
 
# File 'lib/mangrove/result.rb', line 459

def unwrap_in(_ctx)
  throw :__mangrove_result_collecting_context_return, self
end

#unwrap_or_raise!(exception) ⇒ OkType

Parameters:

  • exception (Exception)

Returns:



444
445
446
 
# File 'lib/mangrove/result.rb', line 444

def unwrap_or_raise!(exception)
  raise exception
end

#unwrap_or_raise_inner! ⇒ OkType

Returns:



454
455
456
 
# File 'lib/mangrove/result.rb', line 454

def unwrap_or_raise_inner!
  raise T.unsafe(@inner)
end

#unwrap_or_raise_with!(&block) ⇒ OkType

Parameters:

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

Returns:



449
450
451
 
# File 'lib/mangrove/result.rb', line 449

def unwrap_or_raise_with!(&block)
  raise block.call(@inner)
end