Ref

__init__(value) -> None

def __init__(self, value: A) -> None:
    self._value = value

make(value) -> Effect[Ref[T]]

@staticmethod
def make[T](value: T) -> Effect[Ref[T]]:
    return _Sync(lambda: Ref(value))

unsafe_get() -> A

def unsafe_get(self) -> A:
    return self._value

get() -> Effect[A]

def get(self) -> Effect[A]:
    return _Sync(lambda: self._value)

set(value) -> Effect[None]

def set(self, value: A) -> Effect[None]:
    def run() -> None:
        self._value = value

    return _Sync(run)

set_and_get(value) -> Effect[A]

def set_and_get(self, value: A) -> Effect[A]:
    def run() -> A:
        self._value = value
        return value

    return _Sync(run)

get_and_set(value) -> Effect[A]

def get_and_set(self, value: A) -> Effect[A]:
    def run() -> A:
        old, self._value = self._value, value
        return old

    return _Sync(run)

update(f) -> Effect[None]

def update(self, f: Callable[[A], A]) -> Effect[None]:
    def run() -> None:
        self._value = f(self._value)

    return _Sync(run)

update_and_get(f) -> Effect[A]

def update_and_get(self, f: Callable[[A], A]) -> Effect[A]:
    def run() -> A:
        self._value = f(self._value)
        return self._value

    return _Sync(run)

get_and_update(f) -> Effect[A]

def get_and_update(self, f: Callable[[A], A]) -> Effect[A]:
    def run() -> A:
        old = self._value
        self._value = f(old)
        return old

    return _Sync(run)

update_some(f) -> Effect[None]

def update_some(self, f: Callable[[A], Option[A]]) -> Effect[None]:
    def run() -> None:
        if (new := f(self._value)) is not None:
            self._value = new.value

    return _Sync(run)

update_some_and_get(f) -> Effect[A]

def update_some_and_get(self, f: Callable[[A], Option[A]]) -> Effect[A]:
    def run() -> A:
        if (new := f(self._value)) is not None:
            self._value = new.value
        return self._value

    return _Sync(run)

get_and_update_some(f) -> Effect[A]

def get_and_update_some(self, f: Callable[[A], Option[A]]) -> Effect[A]:
    def run() -> A:
        old = self._value
        if (new := f(old)) is not None:
            self._value = new.value
        return old

    return _Sync(run)

modify(f) -> Effect[B]

def modify[B](self, f: Callable[[A], tuple[B, A]]) -> Effect[B]:
    """Compute a result and a new value from the current one, atomically."""

    def run() -> B:
        result, self._value = f(self._value)
        return result

    return _Sync(run)

modify_some(f) -> Effect[B]

def modify_some[B](self, f: Callable[[A], tuple[B, Option[A]]]) -> Effect[B]:
    """``modify`` whose new value is optional: ``None`` keeps the current one."""

    def run() -> B:
        result, new = f(self._value)
        if new is not None:
            self._value = new.value
        return result

    return _Sync(run)