feat[next]: Introduce FunctionField

src/gt4py/next/common.py

@@ -330,6 +330,12 @@ def __and__(self, other: Domain) -> Domain:
     def __str__(self) -> str:
         return f"Domain({', '.join(f'{e[0]}={e[1]}' for e in self)})"
 
+    def is_finite(self) -> bool:
+        for _, rng in self:
+            if Infinity.positive() in (abs(rng.start), abs(rng.stop)):
+                return False
+        return True
+
 
 DomainLike: TypeAlias = (
     Sequence[tuple[Dimension, RangeLike]] | Mapping[Dimension, RangeLike]

src/gt4py/next/embedded/common.py

@@ -11,6 +11,7 @@
 # distribution for a copy of the license or check <https://www.gnu.org/licenses/>.
 #
 # SPDX-License-Identifier: GPL-3.0-or-later
+from __future__ import annotations
 
 from typing import Any, Optional, Sequence, cast
 
@@ -37,7 +38,7 @@ def _relative_sub_domain(
 
     expanded = _expand_ellipsis(index, len(domain))
     if len(domain) < len(expanded):
-        raise IndexError(f"Trying to index a `Field` with {len(domain)} dimensions with {index}.")
+        raise embedded_exceptions.IndexOutOfBounds(domain=domain, indices=index)
     expanded += (slice(None),) * (len(domain) - len(expanded))
     for (dim, rng), idx in zip(domain, expanded, strict=True):
         if isinstance(idx, slice):
@@ -64,6 +65,10 @@ def _absolute_sub_domain(
     domain: common.Domain, index: common.AbsoluteIndexSequence
 ) -> common.Domain:
     named_ranges: list[common.NamedRange] = []
+
+    if len(domain) < len(index):
+        raise embedded_exceptions.IndexOutOfBounds(domain=domain, indices=index)
+
     for i, (dim, rng) in enumerate(domain):
         if (pos := _find_index_of_dim(dim, index)) is not None:
             named_idx = index[pos]
@@ -125,3 +130,17 @@ def _find_index_of_dim(
         if dim == d:
             return i
     return None
+
+
+def _broadcast_domain(
+    field: common.Field, new_dimensions: tuple[common.Dimension, ...]
+) -> Sequence[common.NamedRange]:
+    named_ranges = []
+    for dim in new_dimensions:
+        if (pos := _find_index_of_dim(dim, field.domain)) is not None:
+            named_ranges.append((dim, field.domain[pos][1]))
+        else:
+            named_ranges.append(
+                (dim, common.UnitRange(common.Infinity.negative(), common.Infinity.positive()))
+            )
+    return named_ranges

src/gt4py/next/embedded/exceptions.py

@@ -12,27 +12,55 @@
 #
 # SPDX-License-Identifier: GPL-3.0-or-later
 
+from typing import Optional
+
 from gt4py.next import common
 from gt4py.next.errors import exceptions as gt4py_exceptions
 
 
 class IndexOutOfBounds(gt4py_exceptions.GT4PyError):
     domain: common.Domain
     indices: common.AnyIndexSpec
-    index: common.AnyIndexElement
-    dim: common.Dimension
+    index: Optional[common.AnyIndexElement]
+    dim: Optional[common.Dimension]
 
     def __init__(
         self,
         domain: common.Domain,
         indices: common.AnyIndexSpec,
-        index: common.AnyIndexElement,
-        dim: common.Dimension,
+        index: Optional[common.AnyIndexElement] = None,
+        dim: Optional[common.Dimension] = None,
     ):
-        super().__init__(
-            f"Out of bounds: slicing {domain} with index `{indices}`, `{index}` is out of bounds in dimension `{dim}`."
-        )
+        msg = f"Out of bounds: slicing {domain} with index `{indices}`."
+        if index is not None and dim is not None:
+            msg += f" `{index}` is out of bounds in dimension `{dim}`."
+
+        super().__init__(msg)
         self.domain = domain
         self.indices = indices
         self.index = index
         self.dim = dim
+
+
+class EmptyDomainIndexError(gt4py_exceptions.GT4PyError):
+    index: common.AnyIndexSpec
+
+    def __init__(self, cls_name: str):
+        super().__init__(f"Error in `{cls_name}`: Cannot index `{cls_name}` with an empty domain.")
+        self.cls_name = cls_name
+
+
+class FunctionFieldError(gt4py_exceptions.GT4PyError):
+    def __init__(self, cls_name: str, msg: str):
+        super().__init__(f"Error in `{cls_name}`: {msg}.")
+        self.cls_name = cls_name
+        self.msg = msg
+
+
+class InfiniteRangeNdarrayError(gt4py_exceptions.GT4PyError):
+    def __init__(self, cls_name: str, domain: common.Domain):
+        super().__init__(
+            f"Error in `{cls_name}`: Cannot construct an ndarray with an infinite range in domain: `{domain}`."
+        )
+        self.cls_name = cls_name
+        self.domain = domain