Array indexing with non purely Int type

[lbartworks]

Hi
I have the following simple PoC of the issue.
The code creates a 2D struct and when accessing the indices with a SIMD int type (instead of the pure Int) the compiler throws the error at the bottom. It runs on the Playground.

Could you help me understand what is wrong? I assume is not a compiler bug

Thanks
luis

struct Matrix2D[dtype: DType = DType.float32, is_row_major: Bool=True]():
    var _matPtr: DTypePointer[dtype]
    var rows: Int
    var cols: Int

    @always_inline  
    fn __init__(inout self, rows: Int, cols:Int):
        self._matPtr = DTypePointer[dtype].alloc(rows*cols)
        self.rows = rows
        self.cols = cols
        memset_zero[dtype](self._matPtr, self.rows*self.cols)
        
    @always_inline
    fn __getitem__(self, x: Int, y: Int) -> SIMD[dtype,1]:
        return self._matPtr.load(x * self.cols + y)

    @always_inline
    fn __getitem__(self, x: SIMD[DType.uint16], y: SIMD[DType.uint16]) -> SIMD[dtype,1]:
        return self._matPtr.load(x * self.cols + y)      
      
def main():
    var example1=Matrix2D[DType.float32](3,3)

    var index=0
    var index2:SIMD[DType.uint16 ,1]=0
    #works well
    print(example1[index,index])

    #compiler error
    print(example1[index2,index2])       

---

ERROR:
/__w/modular/modular/Kernels/mojo/stdlib/builtin/_startup.mojo:136:4: error: function instantiation failed
/__w/modular/modular/Kernels/mojo/stdlib/builtin/_startup.mojo:136:4: note: call expansion failed - no concrete specializations
/__w/modular/modular/Kernels/mojo/stdlib/builtin/_startup.mojo:119:4: note: function instantiation failed
/__w/modular/modular/Kernels/mojo/stdlib/builtin/_startup.mojo:131:57: note: call expansion failed - no concrete specializations
/__w/modular/modular/Kernels/mojo/stdlib/builtin/_startup.mojo:91:4: note: function instantiation failed
/__w/modular/modular/Kernels/mojo/stdlib/builtin/_startup.mojo:107:18: note: call expansion failed - no concrete specializations
/__w/modular/modular/Kernels/mojo/stdlib/builtin/_startup.mojo:128:8: note: function instantiation failed
/__w/modular/modular/Kernels/mojo/stdlib/builtin/_startup.mojo:129:22: note: call expansion failed - no concrete specializations
/source/prog.mojo:25:5: note: function instantiation failed
def main():
^
/source/prog.mojo:34:19: note: call expansion failed - no concrete specializations
print(example1[index2,index2])
^
/source/prog.mojo:22:8: note: function instantiation failed
fn getitem(self, x: SIMD[DType.uint16], y: SIMD[DType.uint16]) -> SIMD[dtype,1]:
^
/__w/modular/modular/Kernels/mojo/stdlib/memory/unsafe.mojo:530:56: note: call expansion failed - no concrete specializations
/__w/modular/modular/Kernels/mojo/stdlib/builtin/int.mojo:133:4: note: function instantiation failed
/__w/modular/modular/Kernels/mojo/stdlib/builtin/int.mojo:145:25: note: call expansion failed - no concrete specializations
/__w/modular/modular/Kernels/mojo/stdlib/builtin/simd.mojo:115:8: note: function instantiation failed
/__w/modular/modular/Kernels/mojo/stdlib/builtin/constrained.mojo:34:6: note: constraint failed: expected a scalar type
mojo: error: failed to run the pass manager

[soraros]

    @always_inline
    fn __getitem__(self, 
        x: SIMD[DType.uint16, 1],  # not SIMD[DType.uint16]
        ...,
    ) -> Scalar[dtype]:
        ...

[lbartworks]

Thanks so much. The fact is that the size parameter defaults to
struct SIMD[type: DType, size: Int = simdwidthof[type]()](

and that happens to be the max number of elements of such type that can be fit on a SIMD register (16 in my case).
Nevertheless the compiler message could be better

[soraros]

If you'd like to, maybe you could make an PR improving the error message here:

mojo/stdlib/src/builtin/simd.mojo

Lines 581 to 584 in b00ed64

	constrained[size == 1, "expected a scalar type"]()
	return __mlir_op.`pop.cast`[_type = __mlir_type.`!pop.scalar<index>`](
	rebind[Scalar[type]](self).value
	)

[remorses]

You can also use Intable trait to accept anything that can be turned into an Int

[lbartworks]

SIMD is already Intable

[soraros]

Only SIMD[T, 1] is Intable. We don't have conditional conformance, so it's enforced by constrained[size ==1]() right now.

[remorses]

I meant something like this

@always_inline
    fn __getitem__[intable: Intable](self, x: intable, y: intable) -> SIMD[dtype, 1]:
        return self._matPtr.load(int(x) * self.cols + int(y))

Unfortunately you can't use traits as types here, you have to create a parameter

[lbartworks]

Only SIMD[T, 1] is Intable. We don't have conditional conformance, so it's enforced by constrained[size ==1]() right now.

If that is the case how can an indexing operation can be vectorized? What I mean is that the index is a vector