Functional based library to support monads and other functional programming concepts
Project description
Pynction 🐍
Functional based library to support haskell monads like Either, Maybe in a scala fashion style. The library also contains Try monad inspired from vavr and a Stream class which is pretty similar to scala and java stream API
Inspired in: VΛVR
Why should you use it ?
Probably if you have reached this library you already know something about functional programming and Monads.
Well this library is another one that empowers your imperative code to start using functional programming concepts. This type of programming makes your code declarative as long as give you support to the most famous monads like Maybe
and Either
.
These monads make your interfaces explicit for error handling so paraphrasing If it compiles, it works
this time it is If mypy is happy, your code works
Basic examples
Stream examples
from pynction import stream_of, stream
foo = (
stream_of([1, 2, 3, 4])
.map(lambda a: a + 1)
.filter(lambda n: n % 2 == 0)
.flat_map(lambda n: [n, n * 2])
.to_list
)
# foo => [2, 4, 4, 8]
bar = (
stream("example", "e", "something")
.take_while(lambda s: s.startswith("e"))
.to_list
)
# bar => ["example", "e"]
Maybe examples
from pynction import maybe, nothing
def divide_10_by(n: int) -> Maybe[int]:
if n == 0:
return nothing
return maybe(10 / n)
result = divide_10_by(2).get_or_else_get(-1)
# result => 5
result = divide_10_by(0).get_or_else_get(-1)
# result => -1
Try examples
from pynction import try_of
def add_10(n: int) -> int:
if n > 10:
raise Exception("n must be less than 10")
return n + 10
try_example_1 = try_of(lambda: add_10(11)).map(lambda a: a + 1)
try_example_1.on(
on_success=lambda a: print(f"Result: {a}"),
on_failure=lambda e: print(f"Error: {e}"),
)
# ==> Will print "Error: n must be less than 10"
try_example_2 = try_of(lambda: add_10(9)).map(lambda a: a + 1)
try_example_2.on(
on_success=lambda a: print(f"Result: {a}"),
on_failure=lambda e: print(f"Error: {e}"),
)
# ==> Will print "Result: 20"
Either examples
from pynction import left, right, Either
LESS_THAN_10_LETTERS = Literal["LESS_THAN_10_LETTERS"]
GREATER_THAN_100 = Literal["GREATER_THAN_100"]
WordTransformationError = Literal[LESS_THAN_10_LETTERS, GREATER_THAN_100]
def make_upper_case_first_n_letters(word: str, number: int) -> Either[WordTransformationError, str]:
if len(word) < 10:
return left("LESS_THAN_10_LETTERS")
elif number > 100:
return left("GREATER_THAN_100")
else:
return right(word.upper()[0:number])
result = make_upper_case_first_n_letters("example", 10)
print(result) # ==> Will be Left("LESS_THAN_10_LETTERS")
API
Stream
Factory methods
stream(*args: T) -> Stream[T]
stream_of(elems: Iterable[T]) -> Stream[T]
Stream api
map(f: Callable[[T], S]) -> Stream[S]
filter(condition: Callable[[T], bool]) -> Stream[T]
flat_map(f: Callable[[T], Iterable[S]]) -> Stream[S]
take_while(condition: Callable[[T], bool]) -> Stream[T]
to_list() -> List[T]
to_set() -> Set[T]
Maybe
Factory methods
maybe(elem: Optional[T]) -> Maybe[T]
just(elem: T) -> Just[T]
nothing
: It is a global instance of Nothing
Maybe api
is_empty -> bool
map(f: Callable[[T], V]) -> Maybe[V]
flat_map(f: Callable[[T], Maybe[V]]) -> Maybe[V]
get_or_else(default: T) -> T
to_either(error: L) -> Either[L, T]
Either
Factory methods
right(elem: T) -> Either[Any, T]
left(elem: T) -> Either[T, Any]
Either api
is_left -> bool
is_right -> bool
map(f: Callable[[R], R1]) -> Either[L, R1]
filter_or_else(predicate: Callable[[R], bool], leftValue: L) -> Either[L, R]
get_or_else_get(f: Callable[[L], R]) -> R
Try
Factory methods
try_of(f: Callable[[], T]) -> Try[T]
Try api
map(f: Callable[[T], S]) -> Try[S]
flat_map(f: Callable[[T], Try[S]]) -> Try[S]
get_or_else_get(self, default: Callable[[Exception], T]) -> T
on( on_success: Callable[[T], None] = None, on_failure: Callable [[Exception], None] = None ) -> Try[T]
catch(f: Callable[[Exception], T]) -> Try[T]
and_finally(f: Callable[[], None]) -> Try[T]
to_either() -> Either[Exception, T]
Do notation
The following functions are python decorators that enables your decoratee function to use the do
notation way of programming like Haskell or Scala. To better understand this decorators let's take a look at 2 quick examples
do_either
@do_either
def example_with_union() -> DoEither[str, Union[int, str], str]:
name = yield get_eihter_name()
age = yield right(25)
lastname = yield right("wick")
return f"{name} {lastname} with age {age}"
result: Either[str, str] = example_with_union()
do_maybe
@do_maybe
def do_maybe_example() -> DoMaybe[Union[str, int], str]:
name = yield get_maybe_name()
age = yield get_maybe_age()
return f"{name} {age}"
result: Maybe[str] = do_maybe_example()
Project details
Release history Release notifications | RSS feed
Download files
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.