def from_result( cls, inner_value: 'Result[_ValueType, _ErrorType]', ) -> 'RequiresContextIOResult[NoDeps, _ValueType, _ErrorType]': """ Creates new container with ``Result`` as a unit value. .. code:: python >>> from returns.context import RequiresContextIOResult >>> from returns.result import Success, Failure >>> from returns.io import IOSuccess, IOFailure >>> deps = RequiresContextIOResult.empty >>> assert RequiresContextIOResult.from_result( ... Success(1), ... )(deps) == IOSuccess(1) >>> assert RequiresContextIOResult.from_result( ... Failure(1), ... )(deps) == IOFailure(1) """ return RequiresContextIOResult( lambda _: IOResult.from_result(inner_value), )
async def awaitable(self) -> IOResult[_ValueType, _ErrorType]: """ Transforms ``FutureResult[a, b]`` to ``Awaitable[IOResult[a, b]]``. Use this method when you need a real coroutine. Like for ``asyncio.run`` calls. Note, that returned value will be wrapped in :class:`returns.io.IOResult` container. .. code:: python >>> import anyio >>> from returns.future import FutureResult >>> from returns.io import IOSuccess >>> assert anyio.run( ... FutureResult.from_value(1).awaitable, ... ) == IOSuccess(1) """ return IOResult.from_result(await self._inner_value)
def from_result_context( cls, inner_value: 'RequiresContextResult[_ValueType, _ErrorType, _EnvType]', ) -> 'RequiresContextIOResult[_ValueType, _ErrorType, _EnvType]': """ Creates new container from ``RequiresContextResult`` as a unit value. .. code:: python >>> from returns.context import RequiresContextResult >>> from returns.io import IOSuccess, IOFailure >>> assert RequiresContextIOResult.from_result_context( ... RequiresContextResult.from_value(1), ... )(...) == IOSuccess(1) >>> assert RequiresContextIOResult.from_result_context( ... RequiresContextResult.from_failure(1), ... )(...) == IOFailure(1) """ return RequiresContextIOResult( lambda deps: IOResult.from_result(inner_value(deps)), )