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