Source code for stdlibx.option.methods.base

  1from __future__ import annotations
  2
  3from typing import Callable, TypeVar
  4
  5from stdlibx.option import (
  6    Nothing,
  7    Option,
  8    OptionExpectError,
  9    OptionUnwrapError,
 10    Some,
 11    is_none,
 12    is_some,
 13)
 14from typing_extensions import TypeVarTuple, Unpack
 15
 16T = TypeVar("T")
 17U = TypeVar("U")
 18Ts = TypeVarTuple("Ts")
 19
 20

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

 23
 24

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

 27
 28

[docs]
 29def expect(opt: Option[T], msg: str) -> T:
 30    if is_some(opt):
 31        return opt.value
 32    raise OptionExpectError(msg)

 33
 34

[docs]
 35def unwrap(opt: Option[T]) -> T:
 36    if is_some(opt):
 37        return opt.value
 38    raise OptionUnwrapError

 39
 40

[docs]
 41def unwrap_or(opt: Option[T], default: T) -> T:
 42    if is_some(opt):
 43        return opt.value
 44    return default

 45
 46

[docs]
 47def unwrap_or_else(opt: Option[T], func: Callable[[], T]) -> T:
 48    if is_some(opt):
 49        return opt.value
 50    return func()

 51
 52

[docs]
 53def map_(opt: Option[T], func: Callable[[T], U]) -> Option[U]:
 54    if is_some(opt):
 55        return Some(func(opt.value))
 56    return Nothing()

 57
 58

[docs]
 59def inspect(opt: Option[T], func: Callable[[T], None]) -> Option[T]:
 60    if is_some(opt):
 61        func(opt.value)
 62    return opt

 63
 64

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

 69
 70

[docs]
 71def map_or_else(opt: Option[T], default: Callable[[], U], func: Callable[[T], U]) -> U:
 72    if is_some(opt):
 73        return func(opt.value)
 74    return default()

 75
 76

[docs]
 77def and_(opt: Option[T], other: Option[U]) -> Option[U]:
 78    if is_some(opt):
 79        return other
 80    return Nothing()

 81
 82

[docs]
 83def and_then(opt: Option[T], func: Callable[[T], Option[U]]) -> Option[U]:
 84    if is_some(opt):
 85        return func(opt.value)
 86    return Nothing()

 87
 88

[docs]
 89def filter_(opt: Option[T], predicate: Callable[[T], bool]) -> Option[T]:
 90    if is_some(opt) and predicate(opt.value) is True:
 91        return Some(opt.value)
 92    return Nothing()

 93
 94

[docs]
 95def or_(opt: Option[T], default: Option[T]) -> Option[T]:
 96    if is_some(opt):
 97        return Some(opt.value)
 98    return default

 99
100

[docs]
101def or_else(opt: Option[T], default: Callable[[], Option[T]]) -> Option[T]:
102    if is_some(opt):
103        return Some(opt.value)
104    return default()

105
106

[docs]
107def xor(opt: Option[T], other: Option[T]) -> Option[T]:
108    if is_some(opt) and is_none(other):
109        return Some(opt.value)
110    elif is_some(other) and is_none(opt):
111        return Some(other.value)
112    else:
113        return Nothing()

114
115

[docs]
116def flatten(opt: Option[Option[T]]) -> Option[T]:
117    if is_some(opt):
118        return opt.value
119    return Nothing()

120
121

[docs]
122def zipped(
123    opt: Option[tuple[Unpack[Ts]]], func: Callable[[Unpack[Ts]], Option[U]]
124) -> Option[tuple[Unpack[Ts], U]]:
125    if is_some(opt):
126        return map_(func(*opt.value), lambda val: (*opt.value, val))
127    return Nothing()