console

yield from console.log("hello", 42)
yield from console.with_group(work, label="setup")
yield from console.time("load")        # needs a Scope; logs on close

assert_(condition, *args) -> Effect[None]

def assert_(condition: bool, *args: object) -> Effect[None]:
    """Write ``args`` as an assertion failure unless ``condition``."""
    return _call(lambda c: c.assert_(condition, *args))

console_with(f) -> Effect[A, E, R]

def console_with[A, E, R](f: Callable[[Console], Effect[A, E, R]]) -> Effect[A, E, R]:
    """Run ``f`` with the current console."""
    return _WithFiber(lambda fiber: f(fiber.get_ref(CurrentConsole)))

count(label='default') -> Effect[None]

def count(label: str = "default") -> Effect[None]:
    """Write how many times ``count`` was called with ``label``."""
    return _call(lambda c: c.count(label))

count_reset(label='default') -> Effect[None]

def count_reset(label: str = "default") -> Effect[None]:
    return _call(lambda c: c.count_reset(label))

debug(*args) -> Effect[None]

def debug(*args: object) -> Effect[None]:
    return _call(lambda c: c.debug(*args))

dir(item) -> Effect[None]

def dir(item: object) -> Effect[None]:
    """Write ``item`` pretty-printed."""
    return _call(lambda c: c.dir(item))

error(*args) -> Effect[None]

def error(*args: object) -> Effect[None]:
    return _call(lambda c: c.error(*args))

group(label=None, *, collapsed=False) -> Effect[None, Never, Scope]

def group(label: str | None = None, *, collapsed: bool = False) -> Effect[None, Never, Scope]:
    """Open a console group, closed when the scope closes."""
    return acquire_release(
        _call(_open_group(label, collapsed)), lambda _, _ex: _call(lambda c: c.group_end())
    )

info(*args) -> Effect[None]

def info(*args: object) -> Effect[None]:
    return _call(lambda c: c.info(*args))

log(*args) -> Effect[None]

def log(*args: object) -> Effect[None]:
    return _call(lambda c: c.log(*args))

table(data, properties=None) -> Effect[None]

def table(data: object, properties: Sequence[str] | None = None) -> Effect[None]:
    """Write ``data`` as a table (see ``LiveConsole.table``)."""
    return _call(lambda c: c.table(data, properties))

time(label='default') -> Effect[None, Never, Scope]

def time(label: str = "default") -> Effect[None, Never, Scope]:
    """Start a console timer; the scope's closing writes its time."""
    return acquire_release(
        _call(lambda c: c.time(label)), lambda _, _ex: _call(lambda c: c.time_end(label))
    )

time_log(label='default', *args) -> Effect[None]

def time_log(label: str = "default", *args: object) -> Effect[None]:
    """Write the time since ``time(label)`` started, then ``args``."""
    return _call(lambda c: c.time_log(label, *args))

trace(*args) -> Effect[None]

def trace(*args: object) -> Effect[None]:
    return _call(lambda c: c.trace(*args))

warn(*args) -> Effect[None]

def warn(*args: object) -> Effect[None]:
    return _call(lambda c: c.warn(*args))

with_group(eff, *, label=None, collapsed=False) -> Effect[A, E, R]

def with_group[A, E, R](
    eff: Effect[A, E, R], *, label: str | None = None, collapsed: bool = False
) -> Effect[A, E, R]:
    """Run ``eff`` inside a console group."""
    require_effect(eff, "eff")
    return acquire_use_release(
        _call(_open_group(label, collapsed)),
        lambda _: eff,
        lambda _, _ex: _call(lambda c: c.group_end()),
    )

with_time(eff, label='default') -> Effect[A, E, R]

def with_time[A, E, R](eff: Effect[A, E, R], label: str = "default") -> Effect[A, E, R]:
    """Run ``eff`` and write how long it took."""
    require_effect(eff, "eff")
    return acquire_use_release(
        _call(lambda c: c.time(label)),
        lambda _: eff,
        lambda _, _ex: _call(lambda c: c.time_end(label)),
    )