Source code for stdlibx.option.methods.base

  1from __future__ import annotations
  2
  3from typing import TYPE_CHECKING, Callable, TypeVar
  4
  5from stdlibx.option._errors import OptionExpectError, OptionUnwrapError
  6from stdlibx.option._option import is_none, is_some, nothing, some
  7from typing_extensions import TypeVarTuple, Unpack
  8
  9if TYPE_CHECKING:
 10    from stdlibx.option.types import Option
 11
 12T = TypeVar("T")
 13U = TypeVar("U")
 14Ts = TypeVarTuple("Ts")
 15
 16

[docs]
 17def is_some_and(opt: Option[T], func: Callable[[T], bool]) -> bool:
 18    return is_some(opt) and func(opt.value)

 19
 20

[docs]
 21def is_none_or(opt: Option[T], func: Callable[[T], bool]) -> bool:
 22    return is_none(opt) or (is_some(opt) and func(opt.value))

 23
 24

[docs]
 25def expect(opt: Option[T], msg: str) -> T:
 26    if is_some(opt):
 27        return opt.value
 28    raise OptionExpectError(msg)

 29
 30

[docs]
 31def unwrap(opt: Option[T]) -> T:
 32    if is_some(opt):
 33        return opt.value
 34    raise OptionUnwrapError

 35
 36

[docs]
 37def unwrap_or(opt: Option[T], default: T) -> T:
 38    if is_some(opt):
 39        return opt.value
 40    return default

 41
 42

[docs]
 43def unwrap_or_else(opt: Option[T], func: Callable[[], T]) -> T:
 44    if is_some(opt):
 45        return opt.value
 46    return func()

 47
 48

[docs]
 49def map_(opt: Option[T], func: Callable[[T], U]) -> Option[U]:
 50    if is_some(opt):
 51        return some(func(opt.value))
 52    return nothing()

 53
 54

[docs]
 55def inspect(opt: Option[T], func: Callable[[T], None]) -> Option[T]:
 56    if is_some(opt):
 57        func(opt.value)
 58    return opt

 59
 60

[docs]
 61def map_or(opt: Option[T], default: U, func: Callable[[T], U]) -> U:
 62    if is_some(opt):
 63        return func(opt.value)
 64    return default

 65
 66

[docs]
 67def map_or_else(opt: Option[T], default: Callable[[], U], func: Callable[[T], U]) -> U:
 68    if is_some(opt):
 69        return func(opt.value)
 70    return default()

 71
 72

[docs]
 73def and_(opt: Option[T], other: Option[U]) -> Option[U]:
 74    if is_some(opt):
 75        return other
 76    return nothing()

 77
 78

[docs]
 79def and_then(opt: Option[T], func: Callable[[T], Option[U]]) -> Option[U]:
 80    if is_some(opt):
 81        return func(opt.value)
 82    return nothing()

 83
 84

[docs]
 85def filter_(opt: Option[T], predicate: Callable[[T], bool]) -> Option[T]:
 86    if is_some(opt) and predicate(opt.value) is True:
 87        return some(opt.value)
 88    return nothing()

 89
 90

[docs]
 91def or_(opt: Option[T], default: Option[T]) -> Option[T]:
 92    if is_some(opt):
 93        return some(opt.value)
 94    return default

 95
 96

[docs]
 97def or_else(opt: Option[T], default: Callable[[], Option[T]]) -> Option[T]:
 98    if is_some(opt):
 99        return some(opt.value)
100    return default()

101
102

[docs]
103def xor(opt: Option[T], other: Option[T]) -> Option[T]:
104    if is_some(opt) and is_none(other):
105        return some(opt.value)
106    elif is_some(other) and is_none(opt):
107        return some(other.value)
108    else:
109        return nothing()

110
111

[docs]
112def flatten(opt: Option[Option[T]]) -> Option[T]:
113    if is_some(opt):
114        return opt.value
115    return nothing()

116
117

[docs]
118def zipped(
119    opt: Option[tuple[Unpack[Ts]]], func: Callable[[Unpack[Ts]], Option[U]]
120) -> Option[tuple[Unpack[Ts], U]]:
121    if is_some(opt):
122        return map_(func(*opt.value), lambda val: (*opt.value, val))
123    return nothing()