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