Repository navigation
Consider adding LazyIO and friends #525
Description
Activity
LazyIO(x)is basically justIO(lambda: x).But, when talking about composition, we need to give it a helping hand:
Lazy = Callable[[], _ValueType] class LazyIO(...): inner_value: Lazy[IO[_ValueType]] def __init__(self, inner_value: Lazy[IO[_ValueType]]) -> None: ... def __call__(self) -> IO[_ValueType]: ... def map(self, function: Callable[[_ValueType], _NewValueType]) -> LazyIO[_NewValueType]: ... def lazy(inner_value: _ValueType) -> Lazy[_ValueType]: ... def lazy_impure(function: Callable[..., _ValueType]) -> Callable[..., LazyIO[_ValueType]: ...
It is much better than working with
IO(lambda: x)This can be useful to create something like
lazy_condthat accepts lazy objects as the inner values:def example(arg: str) -> Result[int, str]: return lazy_cond(Result, arg.isnumeric(), Lazy(int), 'Is not a number') assert example('42') == Success(42) assert example('string') == Failure('string')
Today is impossible to make something similar and simple
Well, I was wrong.
LazyIOis notIO(lambda: x)it islambda: IO(x)I know the documentation mentions
IOs are not lazy because it would be more familiar to existing python developers and help with using theimpuredecorator. However I am skeptical that this is as useful in practice. Most people using this library I assume are starting with some traditional understanding of theIOmonad.Taking my personal experience as an example, I learned explicitly that the
IOmonad is supposed to be something like a grenade that the caller pulls the pin from when they are ready, and not just a wrapper to tell the user the data came from some nondeterministic world. This common form of IO in my reading has also been used to build on the ideas of functional composition and equational reasoning.In my example I started in earnest with reading https://github.com/MostlyAdequate/mostly-adequate-guide, maybe my experience is not representative of everyone's. I am just not as sure the value of a simple
IOcontainer is compared to the traditional definition. The traditional definition helps more to represent a value is non deterministic but still returns a deterministic value, an IO with some function inside of it.Reacted by sobolevn, Xavier Cho, benwebb and Costas Kotsokalis
The thing about
IOin multiple languages / libraries is that it is lazy.Our
IOis not lazy by design. It is done, so Python developers can use it like so:impure(print)(1) # prints "1"But, we also need to think about other problems as well:
IOone can retry an operation as many times as one wishes:p = impure_lazy(print)(1); p(); p() # prints "1" twiceFuture, currently it is not similar to regularIO, becauseFutures are lazy: they don't run until they are executed properly