Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
def eithers(value_strategy=anything()):
lefts = builds(Left, value_strategy)
rights = builds(Right, value_strategy)
return one_of(lefts, rights)
def test_absolve(self):
right = either.Right(1)
left = either.Left('error')
right_effect = effect.success(right)
left_effect = effect.success(left)
assert effect.absolve(right_effect).run(None) == 1
with pytest.raises(Exception):
# todo
effect.absolve(left_effect).run(None)
async def run_e(_) -> Trampoline[Either[OSError, None]]:
try:
with open(path, 'ab+') as f:
f.write(content)
return Done(Right(None))
except OSError as e:
return Done(Left(e))
async def run_e(_) -> Trampoline[Either[OSError, None]]:
try:
with open(path, 'w') as f:
f.write(content)
return Done(Right(None))
except OSError as e:
return Done(Left(e))
async def run_e(r):
return Done(Left(reason))
async def run_e(self):
proc = await asyncio.create_subprocess_shell(
cmd, stdin=stdin, stdout=stdout, stderr=stderr
)
stdout_, stderr_ = await proc.communicate()
if proc.returncode != 0:
return Done(
Left(
CalledProcessError(
proc.returncode, cmd, stdout_, stderr_
)
)
)
return Done(Right((stdout_, stderr_)))
def decorator(*args, **kwargs) -> Either[Exception, A]:
try:
return Right(f(*args, **kwargs))
except Exception as e:
return Left(e)
... return Just(Right('Done'))
... return Just(Left(i - 1))
>>> tail_rec(f, 5000)
Just('Done')
Args:
f: function to run "recursively"
a: initial argument to `f`
Return:
result of `f`
"""
maybe = f(a)
if isinstance(maybe, Nothing):
return maybe
either = maybe.get
while isinstance(either, Left):
maybe = f(either.get)
if isinstance(maybe, Nothing):
return maybe
either = maybe.get
return Just(either.get)
True if other is an `Left` instance and wraps the same \
value as this instance, False otherwise
"""
return isinstance(other, Left) and other.get == self.get
def __bool__(self) -> bool:
return False
def and_then(self, f: Callable[[A], Either[B, C]]) -> Either[B, C]:
return self
def __repr__(self):
return f'Left({repr(self.get)})'
Either = Union[Left[B], Right[A]]
"""
Type-alias for `Union[Left[TypeVar('L')], Right[TypeVar('R')]]`
"""
Either.__module__ = __name__
def either(f: Callable[..., A]) -> Callable[..., Either[A, B]]:
"""
Turn ``f`` into a monadic function in the ``Either`` monad by wrapping
in it a `Right`
Example:
>>> either(lambda v: v)(1)
Right(1)
Args:
from functools import wraps
from typing import Callable, TypeVar, Union
from .either import Eithers, Left, Right, with_effect
A = TypeVar('A')
B = TypeVar('B')
class Ok(Right[A]):
pass
class Error(Left[Exception]):
get: Exception
Result = Union[Error, Ok[A]]
Results = Eithers[Exception, A, B]
with_effect = with_effect
def result(f: Callable[..., B]) -> Callable[..., Result[B]]:
"""
Wrap a function that may raise an exception with a :class:`Result`.
Can also be used as a decorator. Useful for turning
any function into a monadic function