Class: Mangrove::Result::Ok

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
ErrType = 
type_member { { fixed: T.noreturn } }

Instance Method Summary collapse

Methods included from Mangrove::Result

collecting, err, err_wt, from_results, ok, ok_wt

Constructor Details

#initialize(inner) ⇒ void

Parameters:



215
216
217
 
# File 'lib/mangrove/result.rb', line 215

def initialize(inner)
  @inner = inner
end

Instance Method Details

#==(other) ⇒ Boolean

Parameters:

  • other (BasicObject)

Returns:

  • (Boolean) 


220
221
222
223
224
225
226
227
228
229
230
 
# File 'lib/mangrove/result.rb', line 220

def ==(other)
  case other
  when Result::Ok
    other.instance_variable_get(:@inner) == @inner
  when Result::Err
    false
  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), 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)]) 


324
325
326
 
# File 'lib/mangrove/result.rb', line 324

def and(other)
  other
end

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

Parameters:

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

Returns:



350
351
352
353
354
355
356
 
# File 'lib/mangrove/result.rb', line 350

def and_err_if(new_err_inner, &condition)
  if condition.call(@inner)
    Result::Err[T.type_parameter(:NewErrType)].new(new_err_inner)
  else
    self
  end
end

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

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


329
330
331
 
# File 'lib/mangrove/result.rb', line 329

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

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

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:

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


335
336
337
 
# File 'lib/mangrove/result.rb', line 335

def and_then_wt(_t_new_ok, &block)
  block.call(@inner)
end

#deconstruct ⇒ Array<OkType>

Returns:



390
391
392
 
# File 'lib/mangrove/result.rb', line 390

def deconstruct
  [@inner]
end

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

Parameters:

  • _keys (Array<Symbol>, nil)

Returns:



395
396
397
 
# File 'lib/mangrove/result.rb', line 395

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) 


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

def err? = false

#expect!(_message) ⇒ OkType

Parameters:

  • _message (String)

Returns:



263
264
265
 
# File 'lib/mangrove/result.rb', line 263

def expect!(_message)
  @inner
end

#expect_with!(&_block) ⇒ OkType

Parameters:

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

Returns:



268
269
270
 
# File 'lib/mangrove/result.rb', line 268

def expect_with!(&_block)
  @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)]) 


281
282
283
 
# File 'lib/mangrove/result.rb', line 281

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:



302
303
304
 
# File 'lib/mangrove/result.rb', line 302

def map_err(&_block)
  self
end

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

Because sorbet does not deduct types from return values well. This method takes a type of new inner values.

Parameters:

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

Returns:



308
309
310
 
# File 'lib/mangrove/result.rb', line 308

def map_err_wt(_t_new_err, &_block)
  self
end

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

Parameters:

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

Returns:



291
292
293
 
# File 'lib/mangrove/result.rb', line 291

def map_ok(&block)
  Result::Ok[T.type_parameter(:NewOkType)].new(block.call(@inner))
end

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

Because sorbet does not deduct types from return values well. This method takes a type of new inner values.

Parameters:

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

Returns:



297
298
299
 
# File 'lib/mangrove/result.rb', line 297

def map_ok_wt(_t_new_ok, &block)
  Result::Ok[T.type_parameter(:NewOkType)].new(block.call(@inner))
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)]) 


286
287
288
 
# File 'lib/mangrove/result.rb', line 286

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) 


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

def ok? = true

#ok_inner ⇒ OkType

Returns:



233
234
235
 
# File 'lib/mangrove/result.rb', line 233

def ok_inner
  @inner
end

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

Parameters:

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

Returns:



359
360
361
 
# File 'lib/mangrove/result.rb', line 359

def or(_other)
  self
end

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

Parameters:

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

Returns:



364
365
366
 
# File 'lib/mangrove/result.rb', line 364

def or_else(&_block)
  self
end

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

Deprecated.

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:



370
371
372
 
# File 'lib/mangrove/result.rb', line 370

def or_else_wt(_t_new_err, &_block)
  self
end

#or_ok_if(_new_ok_inner, &_condition) ⇒ Result[OkType, ErrType]

Parameters:

  • _new_ok_inner (T.type_parameter(:NewOkType))
  • _condition (T.proc.params(inner: ErrType).returns(T::Boolean))

Returns:



385
386
387
 
# File 'lib/mangrove/result.rb', line 385

def or_ok_if(_new_ok_inner, &_condition)
  self
end

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

Parameters:

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

Returns:



319
320
321
 
# File 'lib/mangrove/result.rb', line 319

def tap_err(&_block)
  self
end

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

Parameters:

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

Returns:



313
314
315
316
 
# File 'lib/mangrove/result.rb', line 313

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

#to_s ⇒ String

Returns:

  • (String) 


400
401
402
 
# File 'lib/mangrove/result.rb', line 400

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

#unwrap! ⇒ OkType

Returns:



238
239
240
 
# File 'lib/mangrove/result.rb', line 238

def unwrap!
  @inner
end

#unwrap_in(_ctx) ⇒ OkType

Parameters:

Returns:



258
259
260
 
# File 'lib/mangrove/result.rb', line 258

def unwrap_in(_ctx)
  @inner
end

#unwrap_or_raise!(_exception) ⇒ OkType

Parameters:

  • _exception (Exception)

Returns:



243
244
245
 
# File 'lib/mangrove/result.rb', line 243

def unwrap_or_raise!(_exception)
  @inner
end

#unwrap_or_raise_inner! ⇒ OkType

Returns:



253
254
255
 
# File 'lib/mangrove/result.rb', line 253

def unwrap_or_raise_inner!
  @inner
end

#unwrap_or_raise_with!(&_block) ⇒ OkType

Parameters:

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

Returns:



248
249
250
 
# File 'lib/mangrove/result.rb', line 248

def unwrap_or_raise_with!(&_block)
  @inner
end