Entry

__init__(request, *, context, complete_unsafe, uninterruptible=False) -> None

def __init__(
    self,
    request: Q_co,
    *,
    context: Context,
    complete_unsafe: Callable[[Exit[Any, Any]], None],
    uninterruptible: bool = False,
) -> None:
    self._request = request
    self._context = context
    self._complete = complete_unsafe
    self.uninterruptible = uninterruptible

complete_unsafe(ex) -> None

def complete_unsafe[A, E](self: Entry[Request[A, E, Any]], ex: Exit[A, E], /) -> None:
    """Complete the request now with ``ex``."""
    self._complete(ex)

complete(ex) -> Effect[None]

def complete[A, E](self: Entry[Request[A, E, Any]], ex: Exit[A, E], /) -> Effect[None]:
    """The effect that completes the request with ``ex``."""
    return _Sync(lambda: self._complete(ex))

complete_effect(eff) -> Effect[None, Never, R]

def complete_effect[A, E, R](
    self: Entry[Request[A, E, Any]], eff: Effect[A, E, R], /
) -> Effect[None, Never, R]:
    """Run ``eff`` and complete the request with its value or typed
    error. Defects and interruptions are not caught."""
    require_effect(eff, "eff")
    complete = self._complete

    def done(ex: Exit[Any, Any]) -> Effect[None]:
        complete(ex)
        return _VOID

    return eff.match_effect(
        on_failure=lambda e: done(exit_fail(e)), on_success=lambda a: done(Success(a))
    )

succeed(value) -> Effect[None]

def succeed[A](self: Entry[Request[A, Any, Any]], value: A, /) -> Effect[None]:
    return _Sync(lambda: self._complete(Success(value)))

fail(error) -> Effect[None]

def fail[E](self: Entry[Request[Any, E, Any]], error: E, /) -> Effect[None]:
    return _Sync(lambda: self._complete(exit_fail(error)))

fail_cause(cause) -> Effect[None]

def fail_cause[E](self: Entry[Request[Any, E, Any]], cause: Cause[E], /) -> Effect[None]:
    return _Sync(lambda: self._complete(Failure(cause)))