sonolus.py 0.3.1__py3-none-any.whl → 0.3.3__py3-none-any.whl

sonolus/script/archetype.py

@@ -185,14 +185,14 @@ class _ArchetypeField(SonolusDescriptor):
 def imported(*, name: str | None = None) -> Any:
     """Declare a field as imported.
 
-    Imported fields may be loaded from the level data.
+    Imported fields may be loaded from the level.
 
     In watch mode, data may also be loaded from a corresponding exported field in play mode.
 
     Imported fields may only be updated in the `preprocess` callback, and are read-only in other callbacks.
 
     Usage:
-        ```
+        ```python
         class MyArchetype(PlayArchetype):
             field: int = imported()
             field_with_explicit_name: int = imported(name="field_name")
@@ -207,10 +207,10 @@ def entity_data() -> Any:
     Entity data is accessible from other entities, but may only be updated in the `preprocess` callback
     and is read-only in other callbacks.
 
-    It functions like `imported`, except that it is not loaded from the level data.
+    It functions like `imported` and shares the same underlying storage, except that it is not loaded from a level.
 
     Usage:
-        ```
+        ```python
         class MyArchetype(PlayArchetype):
             field: int = entity_data()
         ```
@@ -226,7 +226,7 @@ def exported(*, name: str | None = None) -> Any:
     Exported fields are write-only.
 
     Usage:
-        ```
+        ```python
         class MyArchetype(PlayArchetype):
             field: int = exported()
             field_with_explicit_name: int = exported(name="#FIELD")
@@ -238,12 +238,13 @@ def exported(*, name: str | None = None) -> Any:
 def entity_memory() -> Any:
     """Declare a field as entity memory.
 
-    Entity memory is private to the entity and is not accessible from other entities.
+    Entity memory is private to the entity and is not accessible from other entities. It may be read or updated in any
+    callback associated with the entity.
 
     Entity memory fields may also be set when an entity is spawned using the `spawn()` method.
 
     Usage:
-        ```
+        ```python
         class MyArchetype(PlayArchetype):
             field: int = entity_memory()
 
@@ -257,10 +258,11 @@ def shared_memory() -> Any:
 
     Shared memory is accessible from other entities.
 
-    Shared memory may only be updated by sequential callbacks such as `preprocess`, `update_sequential`, and `touch`.
+    Shared memory may be read in any callback, but may only be updated by sequential callbacks
+    (`preprocess`, `update_sequential`, and `touch`).
 
     Usage:
-        ```
+        ```python
         class MyArchetype(PlayArchetype):
             field: int = shared_memory()
         ```
@@ -280,7 +282,7 @@ class StandardImport:
     """Standard import annotations for Archetype fields.
 
     Usage:
-        ```
+        ```python
         class MyArchetype(WatchArchetype):
             judgment: StandardImport.JUDGMENT
         ```
@@ -313,7 +315,7 @@ def callback[T: Callable](*, order: int = 0) -> Callable[[T], T]:
     Callbacks are execute from lowest to highest order. By default, callbacks have an order of 0.
 
     Usage:
-        ```
+        ```python
         class MyArchetype(PlayArchetype):
             @callback(order=1)
             def update_sequential(self):
@@ -360,6 +362,8 @@ class ArchetypeSchema(TypedDict):
 class _BaseArchetype:
     _is_comptime_value_ = True
 
+    _removable_prefix: ClassVar[str] = ""
+
     _supported_callbacks_: ClassVar[dict[str, CallbackInfo]]
     _default_callbacks_: ClassVar[set[Callable]]
 
@@ -440,7 +444,7 @@ class _BaseArchetype:
         """Spawn an entity of this archetype, injecting the given values into entity memory.
 
         Usage:
-            ```
+            ```python
             class MyArchetype(PlayArchetype):
                 field: int = entity_memory()
 
@@ -492,7 +496,7 @@ class _BaseArchetype:
             cls._default_callbacks_ = {getattr(cls, cb_info.py_name) for cb_info in cls._supported_callbacks_.values()}
             return
         if cls.name is None or cls.name in {getattr(mro_entry, "name", None) for mro_entry in cls.mro()[1:]}:
-            cls.name = cls.__name__
+            cls.name = cls.__name__.removeprefix(cls._removable_prefix)
         cls._callbacks_ = []
         for name in cls._supported_callbacks_:
             cb = getattr(cls, name)
@@ -545,11 +549,19 @@ class _BaseArchetype:
                     metadata = _annotation_defaults.get(metadata, metadata)
                 if isinstance(metadata, _ArchetypeFieldInfo):
                     if field_info is not None:
-                        raise TypeError(
-                            f"Unexpected multiple field annotations for '{name}', "
-                            f"expected exactly one of imported, exported, entity_memory, or shared_memory"
-                        )
-                    field_info = metadata
+                        if field_info.storage == metadata.storage and field_info.name is None:
+                            field_info = metadata
+                        elif field_info.storage == metadata.storage and (
+                            metadata.name is None or field_info.name == metadata.name
+                        ):
+                            pass
+                        else:
+                            raise TypeError(
+                                f"Unexpected multiple field annotations for '{name}', "
+                                f"expected exactly one of imported, exported, entity_memory, or shared_memory"
+                            )
+                    else:
+                        field_info = metadata
             if field_info is None:
                 raise TypeError(
                     f"Missing field annotation for '{name}', "
@@ -642,7 +654,7 @@ class PlayArchetype(_BaseArchetype):
     """Base class for play mode archetypes.
 
     Usage:
-        ```
+        ```python
         class MyArchetype(PlayArchetype):
             # Set to True if the entity is a note and contributes to combo and score
             # Default is False
@@ -659,6 +671,8 @@ class PlayArchetype(_BaseArchetype):
         ```
     """
 
+    _removable_prefix: ClassVar[str] = "Play"
+
     _supported_callbacks_ = PLAY_CALLBACKS
 
     is_scored: ClassVar[bool] = False
@@ -808,7 +822,7 @@ class WatchArchetype(_BaseArchetype):
     """Base class for watch mode archetypes.
 
     Usage:
-        ```
+        ```python
         class MyArchetype(WatchArchetype):
             imported_field: int = imported()
             entity_memory_field: int = entity_memory()
@@ -820,6 +834,8 @@ class WatchArchetype(_BaseArchetype):
         ```
     """
 
+    _removable_prefix: ClassVar[str] = "Watch"
+
     _supported_callbacks_ = WATCH_ARCHETYPE_CALLBACKS
 
     def preprocess(self):
@@ -872,7 +888,7 @@ class WatchArchetype(_BaseArchetype):
             case _ArchetypeSelfData():
                 return _deref(ctx().blocks.EntityInfo, 0, WatchEntityInfo)
             case _ArchetypeReferenceData(index=index):
-                return _deref(ctx().blocks.EntityInfoArray, index * WatchEntityInfo._size_(), PlayEntityInfo)
+                return _deref(ctx().blocks.EntityInfoArray, index * WatchEntityInfo._size_(), WatchEntityInfo)
             case _:
                 raise RuntimeError("Info is only accessible from the entity itself")
 
@@ -923,7 +939,7 @@ class PreviewArchetype(_BaseArchetype):
     """Base class for preview mode archetypes.
 
     Usage:
-        ```
+        ```python
         class MyArchetype(PreviewArchetype):
             imported_field: int = imported()
             entity_memory_field: int = entity_memory()
@@ -935,6 +951,8 @@ class PreviewArchetype(_BaseArchetype):
         ```
     """
 
+    _removable_prefix: ClassVar[str] = "Preview"
+
     _supported_callbacks_ = PREVIEW_CALLBACKS
 
     def preprocess(self):
@@ -1078,7 +1096,7 @@ class EntityRef[A: _BaseArchetype](Record):
     May be used with `Any` to reference an unknown archetype.
 
     Usage:
-        ```
+        ```python
         class MyArchetype(PlayArchetype):
             ref_1: EntityRef[OtherArchetype] = imported()
             ref_2: EntityRef[Any] = imported()
@@ -1096,10 +1114,20 @@ class EntityRef[A: _BaseArchetype](Record):
         """Return a new reference with the given archetype type."""
         return EntityRef[archetype](index=self.index)
 
+    @meta_fn
     def get(self) -> A:
         """Get the entity."""
+        if ref := getattr(self, "_ref_", None):
+            return ref
         return self.archetype().at(self.index)
 
+    @meta_fn
+    def get_as(self, archetype: type[_BaseArchetype]) -> _BaseArchetype:
+        """Get the entity as the given archetype type."""
+        if getattr(archetype, "_ref_", None):
+            raise TypeError("Using get_as in level data is not supported.")
+        return self.with_archetype(archetype).get()
+
     def archetype_matches(self) -> bool:
         """Check if entity at the index is precisely of the archetype."""
         return self.index >= 0 and self.archetype().is_at(self.index)
@@ -1107,7 +1135,7 @@ class EntityRef[A: _BaseArchetype](Record):
     def _to_list_(self, level_refs: dict[Any, str] | None = None) -> list[DataValue | str]:
         ref = getattr(self, "_ref_", None)
         if ref is None:
-            return [self.index]
+            return Num._accept_(self.index)._to_list_()
         else:
             if ref not in level_refs:
                 raise KeyError("Reference to entity not in level data")

sonolus/script/array.py

@@ -1,4 +1,3 @@
-# ruff: noqa: A005
 from __future__ import annotations
 
 from collections.abc import Iterable
@@ -6,7 +5,7 @@ from typing import Any, Self, final
 
 from sonolus.backend.ir import IRConst, IRSet
 from sonolus.backend.place import BlockPlace
-from sonolus.script.array_like import ArrayLike
+from sonolus.script.array_like import ArrayLike, get_positive_index
 from sonolus.script.debug import assert_unreachable
 from sonolus.script.internal.context import ctx
 from sonolus.script.internal.error import InternalError
@@ -16,14 +15,22 @@ from sonolus.script.internal.value import BackingSource, DataValue, Value
 from sonolus.script.num import Num
 
 
+class ArrayMeta(type):
+    @meta_fn
+    def __pos__[T](cls: type[T]) -> T:
+        """Create a zero-initialized array instance."""
+        return cls._zero_()
+
+
 @final
-class Array[T, Size](GenericValue, ArrayLike[T]):
+class Array[T, Size](GenericValue, ArrayLike[T], metaclass=ArrayMeta):
     """A fixed size array of values.
 
     Usage:
         ```python
         array_1 = Array(1, 2, 3)
         array_2 = Array[int, 0]()
+        array_3 = +Array[int, 3]  # Create a zero-initialized array
         ```
     """
 
@@ -66,7 +73,7 @@ class Array[T, Size](GenericValue, ArrayLike[T]):
         else:
             return parameterized_cls._with_value([value._copy_() for value in values])
 
-    def __init__(self, *_args: T):
+    def __init__(self, *args: T):
         super().__init__()
 
     @classmethod
@@ -180,7 +187,7 @@ class Array[T, Size](GenericValue, ArrayLike[T]):
 
     @meta_fn
     def __getitem__(self, index: Num) -> T:
-        index: Num = Num._accept_(index)
+        index: Num = Num._accept_(get_positive_index(index, self.size()))
         if index._is_py_() and 0 <= index._as_py_() < self.size():
             const_index = index._as_py_()
             if isinstance(const_index, float) and not const_index.is_integer():
@@ -224,7 +231,7 @@ class Array[T, Size](GenericValue, ArrayLike[T]):
 
     @meta_fn
     def __setitem__(self, index: Num, value: T):
-        index: Num = Num._accept_(index)
+        index: Num = Num._accept_(get_positive_index(index, self.size()))
         value = self.element_type()._accept_(value)
         if ctx():
             if isinstance(self._value, list):
@@ -289,10 +296,15 @@ class Array[T, Size](GenericValue, ArrayLike[T]):
         if isinstance(self._value, BlockPlace) or callable(self._value):
             return f"{type(self).__name__}({self._value}...)"
         else:
-            return f"{type(self).__name__}({", ".join(str(self[i]) for i in range(self.size()))})"
+            return f"{type(self).__name__}({', '.join(str(self[i]) for i in range(self.size()))})"
 
     def __repr__(self):
         if isinstance(self._value, BlockPlace) or callable(self._value):
             return f"{type(self).__name__}({self._value}...)"
         else:
-            return f"{type(self).__name__}({", ".join(repr(self[i]) for i in range(self.size()))})"
+            return f"{type(self).__name__}({', '.join(repr(self[i]) for i in range(self.size()))})"
+
+    @meta_fn
+    def __pos__(self) -> Self:
+        """Return a copy of the array."""
+        return self._copy_()

sonolus/script/array_like.py

@@ -1,10 +1,12 @@
 from __future__ import annotations
 
 import random
-from abc import ABC, abstractmethod
-from collections.abc import Callable, Sequence
+from abc import abstractmethod
+from collections.abc import Callable
 from typing import Any
 
+from sonolus.script.internal.context import ctx
+from sonolus.script.internal.impl import meta_fn
 from sonolus.script.iterator import SonolusIterator
 from sonolus.script.num import Num
 from sonolus.script.record import Record
@@ -13,7 +15,7 @@ from sonolus.script.values import copy
 # Note: we don't use Range in this file because Range itself inherits from ArrayLike
 
 
-class ArrayLike[T](Sequence, ABC):
+class ArrayLike[T]:
     """Mixin for array-like objects.
 
     Inheritors must implement `__len__`, `__getitem__`, and `__setitem__`.
@@ -32,6 +34,8 @@ class ArrayLike[T](Sequence, ABC):
         ```
     """
 
+    _allow_instance_check_ = True
+
     @abstractmethod
     def __len__(self) -> int:
         """Return the length of the array."""
@@ -300,3 +304,26 @@ class _ArrayEnumerator[V: ArrayLike](Record, SonolusIterator):
 
     def advance(self):
         self.i += 1
+
+
+@meta_fn
+def get_positive_index(index: Num, length: Num) -> Num:
+    """Get the positive index for the given index in the array of the given length.
+
+    This is used to convert negative indixes relative to the end of the array to positive indices.
+
+    Args:
+        index: The index to convert.
+        length: The length of the array.
+
+    Returns:
+        The positive index.
+    """
+    if not ctx():
+        return index if index >= 0 else index + length
+    index = Num._accept_(index)
+    length = Num._accept_(length)
+    if index._is_py_() and length._is_py_():
+        return Num._accept_(index._as_py_() + length._as_py_() if index._as_py_() < 0 else index._as_py_())
+    else:
+        return index + (index < 0) * length

sonolus/script/containers.py

@@ -2,15 +2,16 @@ from __future__ import annotations
 
 from sonolus.backend.visitor import compile_and_call
 from sonolus.script.array import Array
-from sonolus.script.array_like import ArrayLike
+from sonolus.script.array_like import ArrayLike, get_positive_index
 from sonolus.script.debug import error
 from sonolus.script.internal.context import ctx
 from sonolus.script.internal.impl import meta_fn
+from sonolus.script.interval import clamp
 from sonolus.script.iterator import SonolusIterator
 from sonolus.script.num import Num
 from sonolus.script.pointer import _deref
 from sonolus.script.record import Record
-from sonolus.script.values import alloc, copy
+from sonolus.script.values import copy, zeros
 
 
 class Box[T](Record):
@@ -104,7 +105,7 @@ class VarArray[T, Capacity](Record, ArrayLike[T]):
         """Create a new empty array."""
         element_type = cls.type_var_value(T)
         capacity = cls.type_var_value(Capacity)
-        return cls(0, alloc(Array[element_type, capacity]))
+        return cls(0, zeros(Array[element_type, capacity]))
 
     def __len__(self) -> int:
         """Return the number of elements in the array."""
@@ -140,11 +141,11 @@ class VarArray[T, Capacity](Record, ArrayLike[T]):
             assert p == Pair(5, 6)  # The value of p has changed
             ```
         """
-        return self._array[item]
+        return self._array[get_positive_index(item, len(self))]
 
     def __setitem__(self, key: int, value: T):
         """Update the element at the given index."""
-        self._array[key] = value
+        self._array[get_positive_index(key, len(self))] = value
 
     def __delitem__(self, key: int):
         """Remove the element at the given index."""
@@ -190,6 +191,7 @@ class VarArray[T, Capacity](Record, ArrayLike[T]):
         """
         if index is None:
             index = self._size - 1
+        index = get_positive_index(index, len(self))
         assert 0 <= index < self._size
         value = copy(self._array[index])
         self._size -= 1
@@ -207,7 +209,7 @@ class VarArray[T, Capacity](Record, ArrayLike[T]):
             index: The index at which to insert the value. Must be in the range [0, size].
             value: The value to insert.
         """
-        assert 0 <= index <= self._size
+        index = clamp(get_positive_index(index, len(self)), 0, self._size)
         assert self._size < len(self._array)
         self._size += 1
         for i in range(self._size - 1, index, -1):
@@ -329,6 +331,7 @@ class ArrayPointer[T](Record, ArrayLike[T]):
 
     @meta_fn
     def _get_item(self, item: int) -> T:
+        item = get_positive_index(item, self.size)
         if not ctx():
             raise TypeError("ArrayPointer values cannot be accessed outside of a context")
         return _deref(
@@ -457,7 +460,7 @@ class ArrayMap[K, V, Capacity](Record):
         key_type = cls.type_var_value(K)
         value_type = cls.type_var_value(V)
         capacity = cls.type_var_value(Capacity)
-        return cls(0, alloc(Array[_ArrayMapEntry[key_type, value_type], capacity]))
+        return cls(0, zeros(Array[_ArrayMapEntry[key_type, value_type], capacity]))
 
     def __len__(self) -> int:
         """Return the number of key-value pairs in the map."""
@@ -536,6 +539,23 @@ class ArrayMap[K, V, Capacity](Record):
         self._array[self._size] = _ArrayMapEntry(key, value)
         self._size += 1
 
+    def __delitem__(self, key: K):
+        """Remove the key-value pair associated with the given key.
+
+        Must be called with a key that is present in the map.
+
+        Args:
+            key: The key to remove
+        """
+        for i in range(self._size):
+            entry = self._array[i]
+            if entry.key == key:
+                self._size -= 1
+                if i < self._size:
+                    self._array[i] = self._array[self._size]
+                return
+        error()
+
     def __contains__(self, key: K) -> bool:
         """Return whether the given key is present in the map.
 

sonolus/script/debug.py

@@ -1,15 +1,25 @@
 from collections.abc import Callable, Sequence
 from contextvars import ContextVar
-from typing import Any, Never
+from typing import Any, Literal, Never
 
 from sonolus.backend.mode import Mode
 from sonolus.backend.ops import Op
+from sonolus.backend.optimize.constant_evaluation import SparseConditionalConstantPropagation
+from sonolus.backend.optimize.copy_coalesce import CopyCoalesce
+from sonolus.backend.optimize.dead_code import (
+    AdvancedDeadCodeElimination,
+    DeadCodeElimination,
+    UnreachableCodeElimination,
+)
 from sonolus.backend.optimize.flow import cfg_to_mermaid
+from sonolus.backend.optimize.inlining import InlineVars
 from sonolus.backend.optimize.passes import CompilerPass, run_passes
-from sonolus.backend.optimize.simplify import CoalesceFlow
-from sonolus.script.internal.context import GlobalContextState, ctx, set_ctx
+from sonolus.backend.optimize.simplify import CoalesceFlow, NormalizeSwitch, RewriteToSwitch
+from sonolus.backend.optimize.ssa import FromSSA, ToSSA
+from sonolus.script.internal.context import GlobalContextState, ReadOnlyMemory, ctx, set_ctx
 from sonolus.script.internal.impl import meta_fn, validate_value
 from sonolus.script.internal.native import native_function
+from sonolus.script.internal.simulation_context import SimulationContext
 from sonolus.script.num import Num
 
 debug_log_callback = ContextVar[Callable[[Num], None]]("debug_log_callback")
@@ -93,12 +103,60 @@ def terminate():
         raise RuntimeError("Terminated")
 
 
-def visualize_cfg(fn: Callable[[], Any], passes: Sequence[CompilerPass] | None = None) -> str:
+def visualize_cfg(
+    fn: Callable[[], Any] | Callable[[type], Any],
+    /,
+    *,
+    mode: Mode = Mode.PLAY,
+    archetype: type | None = None,
+    archetypes: list[type] | None,
+    passes: Sequence[CompilerPass] | Literal["minimal", "basic", "standard"] = "basic",
+) -> str:
     from sonolus.build.compile import callback_to_cfg
 
-    if passes is None:
-        passes = [CoalesceFlow()]
-
-    cfg = callback_to_cfg(GlobalContextState(Mode.PLAY), fn, "")
+    match passes:
+        case "minimal":
+            passes = [
+                CoalesceFlow(),
+            ]
+        case "basic":
+            passes = [
+                CoalesceFlow(),
+                UnreachableCodeElimination(),
+                AdvancedDeadCodeElimination(),
+                CoalesceFlow(),
+            ]
+        case "standard":
+            passes = [
+                CoalesceFlow(),
+                UnreachableCodeElimination(),
+                DeadCodeElimination(),
+                ToSSA(),
+                SparseConditionalConstantPropagation(),
+                UnreachableCodeElimination(),
+                DeadCodeElimination(),
+                CoalesceFlow(),
+                InlineVars(),
+                DeadCodeElimination(),
+                RewriteToSwitch(),
+                FromSSA(),
+                CoalesceFlow(),
+                CopyCoalesce(),
+                AdvancedDeadCodeElimination(),
+                CoalesceFlow(),
+                NormalizeSwitch(),
+            ]
+
+    global_state = GlobalContextState(
+        mode,
+        {a: i for i, a in enumerate(archetypes)} if archetypes is not None else None,
+        ReadOnlyMemory(),
+    )
+
+    cfg = callback_to_cfg(global_state, fn, "", archetype=archetype)
     cfg = run_passes(cfg, passes)
     return cfg_to_mermaid(cfg)
+
+
+def simulation_context() -> SimulationContext:
+    return SimulationContext()

sonolus/script/globals.py

@@ -5,6 +5,7 @@ from sonolus.backend.blocks import Block, PlayBlock, PreviewBlock, TutorialBlock
 from sonolus.backend.mode import Mode
 from sonolus.script.internal.descriptor import SonolusDescriptor
 from sonolus.script.internal.generic import validate_concrete_type
+from sonolus.script.internal.simulation_context import sim_ctx
 from sonolus.script.internal.value import Value
 
 
@@ -27,6 +28,11 @@ class _GlobalField(SonolusDescriptor):
         if instance is None:
             return self
 
+        if sim_ctx():
+            from sonolus.script.values import zeros
+
+            return sim_ctx().get_or_put_value((instance, self), lambda: zeros(self.type))
+
         from sonolus.script.internal.context import ctx
 
         info = owner._global_info_
@@ -38,6 +44,12 @@ class _GlobalField(SonolusDescriptor):
     def __set__(self, instance, value):
         from sonolus.script.internal.context import ctx
 
+        if sim_ctx():
+            from sonolus.script.values import zeros
+
+            sim_ctx().set_or_put_value((instance, self), lambda: zeros(self.type), value)
+            return
+
         info = instance._global_info_
         if not ctx():
             raise RuntimeError("Global field access outside of compilation")
@@ -64,6 +76,11 @@ class _GlobalPlaceholder:
         base = ctx().get_global_base(self)
         return self.type._from_place_(base)
 
+    def _get_sim_replacement_(self):
+        from sonolus.script.values import zeros
+
+        return sim_ctx().get_or_put_value(self, lambda: zeros(self.type))
+
 
 def _create_global(cls: type, blocks: dict[Mode, Block], offset: int | None):
     if issubclass(cls, Value):

sonolus/script/internal/builtin_impls.py

@@ -1,7 +1,7 @@
-from abc import ABC
 from collections.abc import Iterable
 from typing import overload
 
+from sonolus.script.array import Array
 from sonolus.script.array_like import ArrayLike
 from sonolus.script.internal.context import ctx
 from sonolus.script.internal.dict_impl import DictImpl
@@ -32,7 +32,7 @@ def _isinstance(value, type_):
         return isinstance(value, TupleImpl)
     if type_ in {_int, _float, _bool}:
         raise TypeError("Instance check against int, float, or bool is not supported, use Num instead")
-    if not (isinstance(type_, type) and issubclass(type_, Value | ABC)):
+    if not (isinstance(type_, type) and (issubclass(type_, Value) or getattr(type_, "_allow_instance_check_", False))):
         raise TypeError(f"Unsupported type: {type_} for isinstance")
     return validate_value(isinstance(value, type_))
 
@@ -87,7 +87,7 @@ def _zip(*iterables):
     if any(isinstance(iterable, TupleImpl) for iterable in iterables):
         if not all(isinstance(iterable, TupleImpl) for iterable in iterables):
             raise TypeError("Cannot mix tuples with other types in zip")
-        return TupleImpl._accept_(tuple(zip(*(iterable._as_py_() for iterable in iterables), strict=False)))
+        return TupleImpl._accept_(tuple(zip(*(iterable.value for iterable in iterables), strict=False)))
     iterators = [compile_and_call(iterable.__iter__) for iterable in iterables]
     if not all(isinstance(iterator, SonolusIterator) for iterator in iterators):
         raise TypeError("Only subclasses of SonolusIterator are supported as iterators")
@@ -130,6 +130,8 @@ def _max(*args, key: callable = _identity):
         (iterable,) = args
         if isinstance(iterable, ArrayLike):
             return compile_and_call(iterable._max_, key=key)
+        elif isinstance(iterable, TupleImpl) and all(_is_num(v) for v in iterable.value):
+            return compile_and_call(Array(*iterable.value)._max_, key=key)
         else:
             raise TypeError(f"Unsupported type: {type(iterable)} for max")
     else:
@@ -170,6 +172,8 @@ def _min(*args, key: callable = _identity):
         (iterable,) = args
         if isinstance(iterable, ArrayLike):
             return compile_and_call(iterable._min_, key=key)
+        elif isinstance(iterable, TupleImpl) and all(_is_num(v) for v in iterable.value):
+            return compile_and_call(Array(*iterable.value)._min_, key=key)
         else:
             raise TypeError(f"Unsupported type: {type(iterable)} for min")
     else:
@@ -222,12 +226,12 @@ def _float(value=0.0):
     return value
 
 
-@meta_fn
 def _bool(value=False):
-    value = validate_value(value)
-    if not _is_num(value):
-        raise TypeError("Only numeric arguments to bool() are supported")
-    return value != 0
+    # Relies on the compiler to perform the conversion in a boolean context
+    if value:  # noqa: SIM103
+        return True
+    else:
+        return False
 
 
 _int._type_mapping_ = Num