Deferred

__init__() -> None

def __init__(self) -> None:
    self._effect: Effect[A, E] | None = None
    self._waiters: list[Callable[[Effect[A, E]], None]] = []

make() -> Effect[Deferred[A, E]]

@classmethod
def make(cls) -> Effect[Deferred[A, E]]:
    """``Deferred[int, MyError].make()``"""
    return _Sync(cls)

wait() -> Effect[A, E]

def wait(self) -> Effect[A, E]:
    """Wait for the result and take it on."""

    def register(resume: Callable[[Effect[A, E]], None]) -> Effect[None] | None:
        if self._effect is not None:
            resume(self._effect)
            return None
        self._waiters.append(resume)
        return _Sync(lambda: self._waiters.remove(resume) if resume in self._waiters else None)

    return _Callback(register)

done(ex) -> Effect[bool]

def done(self, ex: Exit[A, E]) -> Effect[bool]:
    return _Sync(lambda: self.unsafe_done(ex))

succeed(value) -> Effect[bool]

def succeed(self, value: A) -> Effect[bool]:
    return self.done(Success(value))

fail(error) -> Effect[bool]

def fail(self, error: E) -> Effect[bool]:
    return self.done(fail_exit(error))

fail_cause(cause) -> Effect[bool]

def fail_cause(self, cause: Cause[E]) -> Effect[bool]:
    return self.done(Failure(cause))

sync(evaluate) -> Effect[bool]

def sync(self, evaluate: Callable[[], A]) -> Effect[bool]:
    """Succeed with ``evaluate()``, computed when this runs."""
    return _Suspend(lambda: self.succeed(evaluate()))

fail_sync(evaluate) -> Effect[bool]

def fail_sync(self, evaluate: Callable[[], E]) -> Effect[bool]:
    return _Suspend(lambda: self.fail(evaluate()))

fail_cause_sync(evaluate) -> Effect[bool]

def fail_cause_sync(self, evaluate: Callable[[], Cause[E]]) -> Effect[bool]:
    return _Suspend(lambda: self.fail_cause(evaluate()))

die(defect) -> Effect[bool]

def die(self, defect: BaseException) -> Effect[bool]:
    return self.done(die_exit(defect))

die_sync(evaluate) -> Effect[bool]

def die_sync(self, evaluate: Callable[[], BaseException]) -> Effect[bool]:
    return _Suspend(lambda: self.die(evaluate()))

interrupt() -> Effect[bool]

def interrupt(self) -> Effect[bool]:
    """Complete with an interrupt by the current fiber."""
    return _WithFiber(lambda fiber: self.interrupt_with(fiber.id))

interrupt_with(fiber_id) -> Effect[bool]

def interrupt_with(self, fiber_id: int) -> Effect[bool]:
    """Complete with an interrupt by the fiber with id ``fiber_id``."""
    return self.done(interrupt_exit(fiber_id))

complete(eff) -> Effect[bool, Never, R]

def complete[R](self, eff: Effect[A, E, R]) -> Effect[bool, Never, R]:
    """Run ``eff`` and complete with its outcome. Does not run it if
    already completed; an interrupt while it runs completes with that
    interrupt."""
    require_effect(eff, "eff")
    return _Suspend(lambda: _Succeed(False) if self._effect is not None else self.into(eff))

into(eff) -> Effect[bool, Never, R]

def into[R](self, eff: Effect[A, E, R]) -> Effect[bool, Never, R]:
    """Run ``eff`` and complete with its outcome, even if the running
    fiber is interrupted (then with that interrupt). Runs ``eff`` even
    when already completed; ``complete`` does not."""
    require_effect(eff, "eff")
    return uninterruptible_mask(lambda restore: restore(eff).exit().flat_map(self.done))

complete_with(eff) -> Effect[bool]

def complete_with(self, eff: Effect[A, E]) -> Effect[bool]:
    """Complete with ``eff`` itself, unrun: every ``wait()`` runs it."""
    require_effect(eff, "eff")
    return _Sync(lambda: self._settle(eff))

is_done() -> Effect[bool]

def is_done(self) -> Effect[bool]:
    return _Sync(self.unsafe_is_done)

unsafe_is_done() -> bool

def unsafe_is_done(self) -> bool:
    return self._effect is not None

poll() -> Effect[Effect[A, E] | None]

def poll(self) -> Effect[Effect[A, E] | None]:
    """The effect waiters will run, or ``None`` if not completed yet."""
    return _Suspend(lambda: _Succeed(self._effect))

unsafe_done(ex) -> bool

def unsafe_done(self, ex: Exit[A, E]) -> bool:
    """Complete from outside an effect. Call on the fiber's scheduler
    thread (e.g. inside ``sync``)."""
    return self._settle(_FromExit(ex))