Version history¶

Makes _Nothing a singleton

Refactor flow function to be faster

Fixes that assert_trace was not catching containers from @safe-wrapped functions

Fixes typos in documentation

Adds Higher Kinded Types partial support

Breaking: drops python3.6 support

Breaking: makes our mypy plugin not optional, but required!

Breaking: changes all RequiresContext-based type arguments order, previously we used to specify _EnvType as the first type argument, now it is the last one. This is done to respect new HKT rules

Breaking: renames .rescue to .lash

Breaking: removes all old interfaces from primitives/interfaces.py, use new typeclasses instead

Breaking: Maybe is fully reworked to be lawful

Breaking: removes value_or pointfree method, because it is impossible to express with HKT

Breaking: removes .value_or, .unwrap, and .failure methods from FutureResult and RequiresContext-based types, because we do require these methods to raise an exception on failure, but these methods were lazy and did not raise the required exception

Breaking: changes how is_successful is typed: now we allow any Unwrappable interface instances there, including custom ones

Breaking: changes UnwrapFailedError constructor, now it does accept an Unwrappable instance instead of a BaseContainer

Breaking: removes .fix method from all containers, also removes fix pointfree function

Breaking: Removes coalesce function, because it is impossible to properly type it

Breaking: Removes all Context* based types with .ask() method, use new .ask() methods on the Reader-based containers

Breaking: Now Future and FutureResult can be awaited multiple times

Breaking: Removes .unify() method from several containers, use unify() pointfree function instead

Breaking: Removes .from_iterable method from all containers, instead adds better iterables support, we now have returns.iterables module with Fold helper

Breaking: Renames property empty to no_args of all RequiresContext-based classes

Adds new public interfaces: see returns.interfaces

Adds methods package with several helpful things inside

Adds FutureSuccess and FutureFailure unit functions to be similar to Result and IOResult

Adds .swap method to Result, IOResult, FutureResult, and other result based containers

Adds .modify_env method to all RequiresContext* types

Adds .rescue to Maybe

Adds .equals methods to types that can be compared directly: Result, Maybe, IO, IOResult

Adds missing from_requires_context_future_result to RequiresContext

Adds .from_optional and .bind_optional to Maybe container

Adds __slots__ to UnwrapFailedError with halted_container

Changes flatten to work with KindN and any possible container

Adds a helper to test traces to our pytest plugin

Adds cond function to pointfree and methods packages

Adds compose_result HKT method and pointfree function

Adds unify HKT pointfree function

Adds bimap pointfree function

Adds unwrap_or_failure function to methods package

Adds collect_trace helper function for better development experience

Adds hypothesis integration and pre-defined “monad laws as values”

Adds assert_equal method to our pytest plugin

Breaking: fixes serious typing issue and changes how flow works

Breaking: fixes serious typing issue and changes how pipe works, now it has a hard limit of 20 parameters

Fixes that RequiresContextFutureResult was not supported by pytest plugin

Fixes incorrect partial behaviour in an edge case, #618

Fixes that .apply method of IOResult was working incorrectly, it was returning IOFailure(2) as a result of IOFailure(1).apply(IOFailure(2))

Fixes bug that safe(tap(...)) was revealing invalid types sometimes

Adds a lot of new typetests

Checks that now all math laws are checked for all types

Changes docs structure, adds new Interfaces, HKT, and Methods pages

Changed __str__ method in BaseContainer class to __repr__ method

Adds Quickstart guide

Breaking: renames mypy plugin from decorator_plugin to returns_plugin because of a complete rewrite and lots of new features

Breaking: changes @safe, @impure, impure_safe, @maybe semantics: they do not work with async functions anymore; now you are forced to use Future and its helpers to work with async functions

Breaking: renames Maybe.new to Maybe.from_value. Because all our other containers support this protocol. Only Maybe was different, sorry for that!

Breaking: renames .from_success() to .from_value(), there’s no need in two separate methods

Breaking: renames .from_successful_io() to .from_io(), there’s no need in two separate methods

Breaking: renames .from_successful_context() to .from_context(), there’s no need in two separate methods

Breaking: since we now support .apply() method, there’s no more need in *_squash converters, they are removed

Breaking: renamed Instanceable to Applicative

Breaking: changes .from_io and .from_failed_io of IOResult to return Any instead of NoReturn unfilled type

Breaking: removes .lift and .lift_* methods from all containers, use map_, bind_result, bind_io, and other pointfree helpers instead

Breaking: removes @pipeline function. It was a mistake: it does not work with mixed container types, it does not type failures properly, it does not work with IO and Future, it enforces to write imperative code in a functional codebase. Use flow instead

Adds typed partial and curry mypy plugins!

Adds typed flow plugin, now it can accept any number of arguments, it now also has excellent type inference

Adds typed pipe plugin, now it can accept any number of arguments, it now also has good type inference

Adds managed pipeline function that is useful for working with stateful computations

Adds typed map_, fix, and alt pointfree functions

Adds typed bind_result, bind_io, bind_ioresult, bind_context, bind_context_result, bind_future, bind_async, and bind_awaitable pointfree functions

Adds typed bind_async_future and bind_async_future_result pointfree functions

Adds typed unify pointfree function

Adds typed apply pointfree function

Adds typed value_or pointfree function

Adds pytest plugin with the ability to tests error handling

Adds Future container to easily work with async functions

Adds FutureResult container to easily work with async function that might fail

Adds RequiresContextFutureResult container

Adds ReaderFutureResult alias for RequiresContextFutureResult

Adds RequiresContextFutureResultE and ReaderFutureResultE aliases

Adds Future, FutureResult and RequiresContextFutureResult support for all existing pointfree functions

Adds bind_io method to IOResult

Adds bind_io method to RequiresContextIOResult

Adds or_else method to Maybe

Adds .from_io and .from_failed_io to RequiresContextIOResult

Syncs naming in from_* methods, now all parameters are named inner_value

Adds not_ composition helper

Adds flatten support for Future, FutureResult and RequiresContextFutureResult

Adds __copy__ and __deepcopy__ magic methods to Immutable class

Speeds up is_successful function

Makes all Context context helpers abstract, so you cannot create new instances of this class, also adds __slots__ to these classes

Improves RequiresContext* types with NoDeps where it is logically true

Fixes that @safe decorator was generating incorrect signatures for functions with Any

Fixes that .rescue() of RequiresContextResult was returning Any

Fixes that .rescue() of RequiresContextIOResult was returning Any

Fixes that RequiresContextResult and RequiresContextIOResult were not final

Fixes that ImmutableStateError was not a subclass of AttributeError

Fixes that IOResult was not showing str representation of wrapped inner_value

Replaces pytest-asyncio with anyio plugin, now we test compatibility with any IO stack: asyncio, trio, curio

Updates lots of dependencies

Adds lots of new tests

Updates lots of docs

Removes “IO marker” name from docs in favor for “IO container”, it is not special at all. Why would we call it differently?

Breaking: renames join to flatten, sorry!

Breaking: renames box to bind and moves it to returns.pointfree

Breaking: removes Maybe.rescue and Maybe.fix methods

Breaking: renames io_squash to squash_io and moves it to returns.converters

Breaking: moves all interfaces from returns.primitives.container to returns.primitives.interfaces

Adds rescue pointfree function

Adds ResultE alias for Result[..., Exception]

Adds RequiresContext container and Context helper class

Adds RequiresContext support for bind pointfree function

Adds RequiresContext support for flatten function

Adds RequiresContextResult container

Adds RequiresContextResultE alias

Adds ReaderResult and ReaderResultE aliases for RequiresContextResult[..., ..., Exception]

Adds RequiresContextResult support for bind and rescue

Adds RequiresContextResult support for flatten

Adds IOResult helper to work better with IO[Result[a, b]]

Adds IOResultE alias for IOResult[a, Exception]

Adds IOResult support for bind

Adds IOResult support for flatten

Adds IOResult support for @pipeline

Adds IOResult support for coalesce

Adds IOResult support for is_successful

Adds RequiresContextIOResult container

Adds RequiresContextIOResultE alias

Adds ReaderIOResult and ReaderIOResultE aliases for RequiresContextIOResult[..., ..., Exception]

Adds RequiresContextIOResult support for bind and rescue

Adds RequiresContextIOResult support for flatten

Adds Result.lift, Maybe.lift, RequiresContext.lift, and RequiresContextResult.lift functions in addition to IO.lift

Adds Immutable primitive type

Adds Unitable protocol and .from_success() and .from_failure() methods for all Result related classes

Adds Instanceable protocol and .from_value() method for IO and RequiresContext

Adds flow function, which is similar to pipe

Adds swap converter for Result and IOResult

Adds squash_context function to squash RequiresContext similar to IO

Now Success and Failure (both io and pure) return Any and not NoReturn

Fixes how flatten works, also adds more tests and docs about Failure case

Fixes Unwrappable type being parametrized with only one TypeVar

Changes Success and Failure to return Any instead of NoReturn

Updates poetry version in travis

Improves pipe docs with lambda and Generic problem

Improves docs in several places

Now examples in docs tries to be docstests where possible

Changes how tests are checked with mypy in CI

Breaking: now @pipeline requires a container type when created: @pipeline(Result) or @pipeline(Maybe)

Maybe and Result now has success_type and failure_type aliases

Adds Result.unify utility method for better error type composition

We now support dry-python/classes as a first-class citizen

Adds io_squash to squash several IO containers into one container with a tuple inside, currently works with 9 containers max at a time

Adds untap function which does convert return type to None

Fixes that containers were not usable with multiprocessing

Changes the inheritance order, now BaseContainer is the first child

Fixes that Nothing had incorrect docstrings

Now generated package is protected

Updates poetry to 1.0

Breaking: now pipe() does not require argument to be the first value, instead it is required to use: pipe(f1, f2, f3, f4)(value)

Breaking: dropped everything from returns/__init__.py, because we now have quite a lot of stuff

Breaking: dropped support of zero argument functions for Nothing.fix

Breaking: dropped support of zero argument functions for Nothing.rescue

Maybe now has .failure() to match the same API as Result

Adds identity function

Adds tap function

Now pipe allows to pipe 8 steps

Adds coalesce_result and coalesce_maybe converters

Fixes that code inside .fix and .rescue of Maybe might be called twice

Now all methods have doctests

Updates docs about Success and _Success, Failure and _Failure

Updates docs about @pipeline

Typechecks async functions and decorators inside typesafety/ tests

Breaking: python>=3.7,<=3.7.2 are not supported anymore, because of a bug inside typing module

Breaking: Now bind does not change the type of an error

Breaking: Now rescue does not change the type of a value

Breaking: Renames map_failure to alt

Adds box() function with the ability to box function for direct container composition like: a -> Container[b] to Container[a] -> Container[b]

Adds IO.lift() function to lift a -> a to IO[a] -> IO[a]

Adds pipe() function to pipeline.py

Adds __hash__() magic methods to all containers

Changes Any to NoReturn in Success and Failure

Now all type parameters in Result, Maybe, and IO are covariant

Massive docs rewrite

Updates mypy version

Updates wemake-python-styleguide and introduces nitpick

Updates pytest-plugin-mypy, all tests now use yml

Provides a bunch of primitive interfaces to write your own containers

Adds .map_failure() method

Adds flatten() function to join nested containers

Fixes type of Maybe.fix and Maybe.rescue to work with both lambda: 1 and lambda _: 1

Improves README

Reintroduces the Maybe container, typed!

Introduces converters from one type to another

Adds mypy plugin to type decorators

Complete rewrite of Result types

Partial API change, now Success and Failure are not types, but functions

New internal types introduced: FixableContainer and ValueUnwrapContainer

Fixes issue when you could return IO container from Result.bind

Fixes @pipeline return type

Reapplied all types to .py files

Improved docs about IO and Container concept

Adds docs about container composition

Moves from Alpha to Beta

Adds IO container

Adds unsafe module with unsafe functions

Changes how functions are located inside the project

Fixes container type in @pipeline

Now is_successful is public

Now raise_exception is public

Changes how str() function works for container types

Total rename to “container” in the source code

safe and pipeline now supports asyncio

is_successful now returns Literal types if possible

Adds compose helper function

Adds public API to import returns

Adds raise_exception helper function

Adds full traceback to .unwrap()

Updates multiple dev-dependencies, including mypy

Now search in the docs is working again

Relicenses this project to BSD

Fixes copyright notice in the docs

Moves all types to .pyi files

Renames all classes according to new naming pattern

HUGE improvement of types

Renames fmap to map

Renames do_notation to pipeline, moves it to functions.py

Renames ebind to rescue

Renames efmap to fix

Renames container to Container

Removes Maybe container, since typing does not have NonNullable type

Adds py.typed file to be PEP561 compatible

Adds .pyi files for all modules, to enable mypy support for 3rd party users

Adds Maybe container

Adds immutability and __slots__ to all containers

Adds methods to work with failures

Adds safe decorator to convert exceptions to Result container

Adds is_successful() function to detect if your result is a success

Adds failure() method to unwrap values from failed containers

Changes the type of .bind method for Success container

Changes how equality works, so now Failure(1) != Success(1)

Changes how new instances created on unused methods

Improves docs

Changes how PyPI renders package’s page

Improves README with new badges and installation steps