[stdlib] Parameterize __getitem__ and __setitem__ in stdlib types

stdlib/src/builtin/bool.mojo

@@ -59,7 +59,12 @@ trait Boolable:
 @value
 @register_passable("trivial")
 struct Bool(
-    Stringable, CollectionElement, Boolable, EqualityComparable, Intable
+    Stringable,
+    CollectionElement,
+    Boolable,
+    EqualityComparable,
+    Intable,
+    Indexer,
 ):
     """The primitive Bool scalar value used in Mojo."""
 
@@ -324,6 +329,15 @@ struct Bool(
         """
         return __mlir_op.`index.casts`[_type = __mlir_type.index](self.value)
 
+    @always_inline("nodebug")
+    fn __index__(self) -> Int:
+        """Convert this Bool to an integer for indexing purposes
+
+        Returns:
+            Bool as Int
+        """
+        return self.__int__()
+
 
 # ===----------------------------------------------------------------------=== #
 #  bool

stdlib/src/builtin/builtin_list.mojo

@@ -146,16 +146,19 @@ struct VariadicList[type: AnyRegType](Sized):
         return __mlir_op.`pop.variadic.size`(self.value)
 
     @always_inline
-    fn __getitem__(self, index: Int) -> type:
+    fn __getitem__[indexer: Indexer](self, idx: indexer) -> type:
         """Gets a single element on the variadic list.
 
+        Parameters:
+            indexer: The type of the indexing value.
+
         Args:
-            index: The index of the element to access on the list.
+            idx: The index of the element to access on the list.
 
         Returns:
             The element on the list corresponding to the given index.
         """
-        return __mlir_op.`pop.variadic.get`(self.value, index.value)
+        return __mlir_op.`pop.variadic.get`(self.value, index(idx).value)
 
     @always_inline
     fn __iter__(self) -> Self.IterType:
@@ -358,18 +361,21 @@ struct VariadicListMem[
     # TODO: Fix for loops + _VariadicListIter to support a __nextref__ protocol
     # allowing us to get rid of this and make foreach iteration clean.
     @always_inline
-    fn __getitem__(self, index: Int) -> Self.reference_type:
+    fn __getitem__[indexer: Indexer](self, idx: indexer) -> Self.reference_type:
         """Gets a single element on the variadic list.
 
+        Parameters:
+            indexer: The type of the indexing value.
+
         Args:
-            index: The index of the element to access on the list.
+            idx: The index of the element to access on the list.
 
         Returns:
             A low-level pointer to the element on the list corresponding to the
             given index.
         """
         return Self.reference_type(
-            __mlir_op.`pop.variadic.get`(self.value, index.value)
+            __mlir_op.`pop.variadic.get`(self.value, index(idx).value)
         )
 
     @always_inline

stdlib/src/builtin/builtin_slice.mojo

@@ -149,16 +149,19 @@ struct Slice(Sized, Stringable, EqualityComparable):
         return len(range(self.start, self.end, self.step))
 
     @always_inline
-    fn __getitem__(self, idx: Int) -> Int:
+    fn __getitem__[indexer: Indexer](self, idx: indexer) -> Int:
         """Get the slice index.
 
+        Parameters:
+            indexer: The type of the indexing value.
+
         Args:
             idx: The index.
 
         Returns:
             The slice index.
         """
-        return self.start + idx * self.step
+        return self.start + index(idx) * self.step
 
     @always_inline("nodebug")
     fn _has_end(self) -> Bool:

stdlib/src/builtin/int.mojo

@@ -205,6 +205,7 @@ struct Int(
     Roundable,
     Stringable,
     Truncable,
+    Indexer,
 ):
     """This type represents an integer value."""
 

stdlib/src/builtin/int_literal.mojo

@@ -29,6 +29,7 @@ struct IntLiteral(
     Roundable,
     Stringable,
     Truncable,
+    Indexer,
 ):
     """This type represents a static integer literal value with
     infinite precision.  They can't be materialized at runtime and

stdlib/src/builtin/range.mojo

@@ -82,8 +82,8 @@ struct _ZeroStartingRange(Sized, ReversibleRange):
         return self.curr
 
     @always_inline("nodebug")
-    fn __getitem__(self, idx: Int) -> Int:
-        return idx
+    fn __getitem__[indexer: Indexer](self, idx: indexer) -> Int:
+        return index(idx)
 
     @always_inline("nodebug")
     fn __reversed__(self) -> _StridedRangeIterator:
@@ -113,8 +113,8 @@ struct _SequentialRange(Sized, ReversibleRange):
         return self.end - self.start if self.start < self.end else 0
 
     @always_inline("nodebug")
-    fn __getitem__(self, idx: Int) -> Int:
-        return self.start + idx
+    fn __getitem__[indexer: Indexer](self, idx: indexer) -> Int:
+        return self.start + index(idx)
 
     @always_inline("nodebug")
     fn __reversed__(self) -> _StridedRangeIterator:
@@ -185,8 +185,8 @@ struct _StridedRange(Sized, ReversibleRange):
         return _div_ceil_positive(abs(self.start - self.end), abs(self.step))
 
     @always_inline("nodebug")
-    fn __getitem__(self, idx: Int) -> Int:
-        return self.start + idx * self.step
+    fn __getitem__[indexer: Indexer](self, idx: indexer) -> Int:
+        return self.start + index(idx) * self.step
 
     @always_inline("nodebug")
     fn __reversed__(self) -> _StridedRangeIterator:

stdlib/src/builtin/simd.mojo

@@ -139,6 +139,7 @@ struct SIMD[type: DType, size: Int = simdwidthof[type]()](
     Sized,
     Stringable,
     Truncable,
+    Indexer,
 ):
     """Represents a small vector that is backed by a hardware vector element.
 
@@ -483,6 +484,22 @@ struct SIMD[type: DType, size: Int = simdwidthof[type]()](
             rebind[Scalar[type]](self).value
         )
 
+    @always_inline("nodebug")
+    fn __index__(self) -> Int:
+        """Returns the value as an int if it is an integral value
+
+        Contraints:
+            Must be an integral value
+
+        Returns:
+            The value as an integer
+        """
+        constrained[
+            type.is_integral() or type.is_bool(),
+            "expected integral or bool type",
+        ]()
+        return self.__int__()
+
     @always_inline
     fn __str__(self) -> String:
         """Get the SIMD as a string.
@@ -1731,9 +1748,12 @@ struct SIMD[type: DType, size: Int = simdwidthof[type]()](
     # ===-------------------------------------------------------------------===#
 
     @always_inline("nodebug")
-    fn __getitem__(self, idx: Int) -> Scalar[type]:
+    fn __getitem__[indexer: Indexer](self, idx: indexer) -> Scalar[type]:
         """Gets an element from the vector.
 
+        Parameters:
+            indexer: The type of the indexing value.
+
         Args:
             idx: The element index.
 
@@ -1742,32 +1762,44 @@ struct SIMD[type: DType, size: Int = simdwidthof[type]()](
         """
         return __mlir_op.`pop.simd.extractelement`[
             _type = __mlir_type[`!pop.scalar<`, type.value, `>`]
-        ](self.value, idx.value)
+        ](self.value, index(idx).value)
 
     @always_inline("nodebug")
-    fn __setitem__(inout self, idx: Int, val: Scalar[type]):
+    fn __setitem__[
+        indexer: Indexer
+    ](inout self, idx: indexer, val: Scalar[type]):
         """Sets an element in the vector.
 
+        Parameters:
+            indexer: The type of the indexing value.
+
         Args:
             idx: The index to set.
             val: The value to set.
         """
         self.value = __mlir_op.`pop.simd.insertelement`(
-            self.value, val.value, idx.value
+            self.value, val.value, index(idx).value
         )
 
     @always_inline("nodebug")
-    fn __setitem__(
-        inout self, idx: Int, val: __mlir_type[`!pop.scalar<`, type.value, `>`]
+    fn __setitem__[
+        indexer: Indexer
+    ](
+        inout self,
+        idx: indexer,
+        val: __mlir_type[`!pop.scalar<`, type.value, `>`],
     ):
         """Sets an element in the vector.
 
+        Parameters:
+            indexer: The type of the indexing value.
+
         Args:
             idx: The index to set.
             val: The value to set.
         """
         self.value = __mlir_op.`pop.simd.insertelement`(
-            self.value, val, idx.value
+            self.value, val, index(idx).value
         )
 
     fn __hash__(self) -> Int:

stdlib/src/builtin/string.mojo

@@ -798,21 +798,25 @@ struct String(
         """
         return len(self) > 0
 
-    fn __getitem__(self, idx: Int) -> String:
+    fn __getitem__[indexer: Indexer](self, idx: indexer) -> String:
         """Gets the character at the specified position.
 
+        Parameters:
+            indexer: The type of the indexing value.
+
         Args:
             idx: The index value.
 
         Returns:
             A new string containing the character at the specified position.
         """
-        if idx < 0:
-            return self.__getitem__(len(self) + idx)
+        var index_val = index(idx)
+        if index_val < 0:
+            return self.__getitem__(len(self) + index_val)
 
-        debug_assert(0 <= idx < len(self), "index must be in range")
+        debug_assert(0 <= index_val < len(self), "index must be in range")
         var buf = Self._buffer_type(capacity=1)
-        buf.append(self._buffer[idx])
+        buf.append(self._buffer[index_val])
         buf.append(0)
         return String(buf^)
 

stdlib/src/builtin/value.mojo

@@ -203,3 +203,37 @@ trait BoolableKeyElement(Boolable, KeyElement):
     """
 
     pass
+
+
+trait Indexer:
+    """This trait denotes a type that can be used to index a container that
+    handles integral index values.
+
+    This solves the issue of being able to index data structures such as `List` with the various
+    integral types without being too broad and allowing types that should not be used such as float point
+    values.
+    """
+
+    fn __index__(self) -> Int:
+        """Return the index value
+
+        Returns:
+            The index value of the object
+        """
+        ...
+
+
+@always_inline("nodebug")
+fn index[indexer: Indexer](idx: indexer) -> Int:
+    """Returns the value of `__index__` for the given value.
+
+    Parameters:
+        indexer: The type of the given value.
+
+    Args:
+        idx: The value.
+
+    Returns:
+        An int respresenting the index value.
+    """
+    return idx.__index__()

stdlib/src/collections/inline_list.mojo

@@ -71,19 +71,22 @@ struct InlineList[ElementType: CollectionElement, capacity: Int = 16](Sized):
 
     @always_inline
     fn __refitem__[
-        IntableType: Intable,
-    ](self: Reference[Self, _, _], index: IntableType) -> Reference[
+        indexer: Indexer
+    ](self: Reference[Self, _, _], idx: indexer) -> Reference[
         Self.ElementType, self.is_mutable, self.lifetime
     ]:
         """Get a `Reference` to the element at the given index.
 
+        Parameters:
+            indexer: The inferred type of the indexer.
+
         Args:
-            index: The index of the item.
+            idx: The index of the item.
 
         Returns:
             A reference to the item at the given index.
         """
-        var i = int(index)
+        var i = index(idx)
         debug_assert(
             -self[]._size <= i < self[]._size, "Index must be within bounds."
         )