def flat_map(self) -> None:
a = 'start'
b = 'end'
Maybe.optional(a).flat_map(
lambda v: Maybe.optional(v + b)).should.contain(a + b)
f = lambda a: Maybe.optional(a).flat_map(lambda c: Monad.fatal(Maybe).
pure(c + b))
f(a).should.contain(a + b)
def optional(self) -> None:
a = 'a'
b = 'b'
Maybe.optional(a).to_maybe.should.just_contain(a)
Empty().to_maybe.should.be.a(Empty)
Maybe.optional(a).to_either(b).should.equal(Right(a))
Empty().to_either(b).should.equal(Left(b))
Empty().to_either(lambda: b).should.equal(Left(b))
def text(element: etree.Element, expr: str) -> Maybe[str]:
return sub(element, expr) // (lambda a: Maybe.optional(a.text))
return dict(
title='',
size=1,
size_str='1',
seeders=5,
magnet_link='',
)
def cons(
rplugins: List[Rplugin] = Nil,
chromatin_rplugin: Rplugin = None,
chromatin_venv: str = None,
venvs: List[str] = Nil,
ready: List[str] = Nil,
active: List[ActiveRpluginMeta] = Nil,
uninitialized: List[ActiveRpluginMeta] = Nil,
triggers: Map[str, List[ActiveRpcTrigger]] = Map(),
errors: List[str] = Nil,
) -> 'Env':
return Env(
rplugins,
Maybe.optional(chromatin_rplugin),
Maybe.optional(chromatin_venv),
venvs,
ready,
active,
uninitialized,
triggers,
errors,
)
def cons(
ident: IdentSpec = None,
state: ViewState = None,
geometry: ViewGeometry = None,
open: bool = False,
cwd: Path = None,
pin: bool = False,
) -> 'SimplePane':
return SimplePane(
ensure_ident_or_generate(ident),
state or ViewState.cons(),
geometry or ViewGeometry.cons(),
Boolean(open),
Maybe.optional(cwd),
Boolean(pin),
)
def parse_row(row: etree.Element) -> Generator:
texts = cell_texts(row)
title = yield texts.head
size_str, seeders_str = yield texts.lift_all(-3, -2)
link = yield sub(row, 'div[@class="tt-name"]/a').head
url = yield Maybe.optional(link.get('href'))
hash_match = yield url_re.search(url).to_maybe
hash = yield hash_match.group('hash').to_maybe
size = yield parse_size(size_str)
seeders = yield Try(int, seeders_str.replace(',', '')).to_maybe
yield Just(
dict(
title=title,
size=size,
size_str=size_str,
seeders=seeders,
magnet_link=magnet(hash),
))
def cons(
name: str = None,
pythonpath: List[str] = None,
debug: bool = None,
interpreter: str = None,
extensions: List[str] = None,
track: bool = True,
) -> 'AddPluginOptions':
return AddPluginOptions(
Maybe.optional(name),
Maybe.optional(pythonpath),
Maybe.optional(debug),
Maybe.optional(interpreter),
Maybe.optional(extensions),
Maybe.optional(track),
)
def optional_ident(spec: IdentSpec) -> Either[str, Maybe[Ident]]:
return Maybe.optional(spec).cata(ensure_ident, Right(Nothing))
def just(self) -> None:
Maybe.optional('value').is_just.should.be.ok
def format_cause(exc: Exception, **kw) -> List[str]:
from amino import Maybe
return Maybe.optional(exc.__cause__) / (lambda a: format_exception(
a, **kw)) / (lambda a: a.cons('Cause:')) | List()
def builtin_type(type_info: TypeInfo) -> Do:
name = yield type_info.names.head.to_either(
f'no name specified for builtin type')
yield (Right(type(None)) if name == 'NoneType' else Maybe.optional(
__builtins__.get(name)).to_either(f'no builtin type named `{name}`'))
def search(self, data: str, *a: Any, **kw: Any) -> Either[str, 'Match']:
return (Maybe.optional(self.rex.search(data, *a, **kw)).to_either(
'`{}` does not contain `{}`'.format(data, self.spec)) /
L(Match)(self, _, data))
def group(self, id: str) -> Either[str, str]:
return (self.group_map.lift(id).flat_map(lambda a: Maybe.optional(
a).to_either_f(lambda: f'group `{id}` did not match')).to_either(
'no group `{}` in {}'.format(id, self)))
def callsite_source(frame: FrameType, pkgs: List[str] = None) -> str:
return Maybe.optional(frame) / (
lambda f: frame_data(frame_callsite(f, pkgs))) / _[1] | '<no source>'
def cons(socket: str = None) -> 'Tmux':
return NativeTmux(Maybe.optional(socket))
def map(self) -> None:
a = 'start'
b = 'end'
Maybe.optional(a).map(_ + b)._get.should.equal(a + b)
(Maybe.optional(a) / (_ + b))._get.should.equal(a + b)
def contains(self) -> None:
a = 'start'
Maybe.optional(a).contains(a).should.be.ok
Maybe.optional(a + a).contains(a).should_not.be.ok
Empty().contains(a).should_not.be.ok
def none(self) -> None:
Maybe.optional(None).is_just.should_not.be.ok
def find(self, fa: List[A], f: Callable[[A], bool]):
return Maybe.optional(_find(fa, f))
def callsite_info(frame: FrameType, pkgs: List[str] = None) -> List[str]:
return Maybe.optional(frame) / L(callsite_traceback_entry)(
_, pkgs) | List(' <no callsite info>')
