V2: Not re-computing when state doesn't change

[pauleveritt]

First: Sorry for the colossally-dumb world[] vs. world.get questions. Also: Moving general V2 questions off that huge PR conversation.

I have a simple example using state:

@state
def counter(previous: int | None) -> int:
    return (previous or 0) + 1


@inject
def greeting(
    count: int = inject[counter],
) -> str:
    """Return a greeting."""
    return f"({count}): Hello!"


def main() -> None:
    """Process a greeting."""
    # return greeting()
    # Each time you call it, the count is the same. In fact, `greeting`
    # doesn't even get called the second time.
    assert greeting() == "(1): Hello!"
    assert greeting() == "(1): Hello!"

    # But when you update the state, it recomputes.
    counter.update()
    assert greeting() == "(2): Hello!"

I had the impression @Inject would not even execute if its dependencies hadn't changed. In the debugger, if I set a breakpoint in greeting, it stops 3 times. I only expected twice.

[Finistere]

@inject will indeed re-execute as it doesn't cache anything. Using @lazy(scope='deterministic') will work. You do need to go through world though.

from antidote import state, inject, lazy, world


@state
def counter(previous: int | None) -> int:
    return (previous or 0) + 1


@lazy(scope='deterministic')
def greeting(
    count: int = inject[counter],
) -> str:
    """Return a greeting."""
    return f"({count}): Hello!"


def main() -> None:
    """Process a greeting."""
    # return greeting()
    # Each time you call it, the count is the same. In fact, `greeting`
    # doesn't even get called the second time.
    assert world[greeting()] == "(1): Hello!"
    assert world[greeting()] == "(1): Hello!"

    # But when you update the state, it recomputes.
    counter.update()
    assert world[greeting()] == "(2): Hello!"

[Finistere]

And depending on your needs, in the V2 you can also retrieve the function as a dependency. Caching will work in the exact same way. You can also inject it with inject[greeting].

def main() -> None:
    """Process a greeting."""
    # return greeting()
    # Each time you call it, the count is the same. In fact, `greeting`
    # doesn't even get called the second time.
    g = world[greeting]
    assert g() == "(1): Hello!"
    assert g() == "(1): Hello!"

    # But when you update the state, it recomputes.
    counter.update()
    assert g() == "(2): Hello!"

[pauleveritt]

It's a little artifact of my book-writing strategy. I realize it seems pointless, might refactor it out.

[Finistere]

First: Sorry for the colossally-dumb world[] vs. world.get questions. Also: Moving general V2 questions off that huge PR conversation.

No worries, it happens to everyone. :) You're right it's probably better.