@staticmethod
fn from_range[start: Int, end: Int, step: Int = 1]() -> Self:
    """Construct from a compile time range using the index as value.

    Parameters:
        start: The start of the range.
        end: The end of the range.
        step: The step of the range.

    Constraints:
        The range must be equal to or less than SIMD size.

    Examples:
    ```mojo
    print(SIMD[DType.uint8, 4].from_range[0, 4]()) # [0, 1, 2, 3]
    print(SIMD[DType.uint8, 4].from_range[3, -1, -1]()) # [3, 2, 1, 0]
    ```
    .
    """

    constrained[
        abs((start - end) // step) <= size,
        "The range must be equal to or less than SIMD size.",
    ]()
    var vec = Self()
    var idx = 0

    @parameter
    for i in range(start, end, step):
        vec[idx] = i
        idx  = 1
    return vec

def test_range_constructor():
    alias INum = SIMD[DType.uint8, 4]
    assert_equal(INum.from_range[0, 4](), INum(0, 1, 2, 3))
    assert_equal(INum.from_range[3, -1, -1](), INum(3, 2, 1, 0))
    alias FNum = SIMD[DType.float16, 4]
    assert_equal(FNum.from_range[0, 4](), FNum(0, 1, 2, 3))
    assert_equal(FNum.from_range[3, -1, -1](), FNum(3, 2, 1, 0))

fn index(self, value: Scalar[T]) -> Optional[Int]:
    alias indices = SIMD[DType.uint16].from_range[size -1, -1, -1]()
    var idx = ((self == value).cast[DType.uint16]() * indices).reduce_max()
    if idx == 0:
        return None
    return size - int(idx)

fn reverse(inout self):
    self = self.shuffle[range(size -1, -1, -1)]()

fn reverse(inout self):
    self = self.shuffle[Self.from_range[size -1, -1, -1]()]()