Find a way to prevent having to check FAILURE after every action

[brodycritchlow]

[brodycritchlow]

While thinking through this, I found some possible solutions. One approach is to create a decorator that automatically creates "unsafe" variants of each function. These unsafe functions, instead of returning Component | Literal[Failure], for example. They will instead always return Component. There is a caveat, though-- they will throw an exception instead when they fail. Knowing the current architecture, our functions are very unlikely to fail. (but there is still technically a chance).

We could very easily make a function say:

def generate_unsafe[**P, R](
    exception_type: type[Exception] = OperationFailedError, error_message: str | None = None
) -> Callable[[Callable[P, R]], Callable[P, R]]:

That would automatically create an "unsafe" version of the function, e.g., world.get_component_unsafe(...). Then we could use the message to show up on the error, with something useful such as: One or more components not found on entity. Although I'm not sure this is the most Pythonic approach. I think my main issue with this approach is the naming scheme choices:

world.get_component_unsafe() # Should we use this naming scheme? It's technically not unsafe, just errors.
world.get_component_or_raise() # Is this too long of a name?

I prefer the latter (world.get_component_or_raise()) as it's clearer on what it's doing. I'm leaning more to this approach than others, such as a config setting or an environment variable, because it is similar to dict.get() vs dict[key]. The latter will error when you try to get a key that does not exist, but the former will return your default (or None if not specified). This concept matches our above generate_unsafe().

Let us at least start with this approach of unsafe generation, but then we can deprecate and slate for removal later on in development when we have a more sound understanding of our architecture.