Shall we unify NDArray's definition and type annotation

[k-ye]

Right now NDArrays's definition and type annotation have two different names:

arr = ti.ndarray(ti.i32, shape=(n, m))

def run(x: ti.any_arr()):
    ...

run(arr)

IIRC, ti.any_arr() was named so in the beginning because we wanted to pass in normal numpy arrays (i.e., Taichi's original external array). Still, this naming inconsistency could be a barrier for promoting the usage of NDArray. I feel like it's OK to just use the term ti.ndarray(), because this is a widely adopted concept. WDYT?

[strongoier]

I agree we should change the name of the type annotation. To make the semantics more clear, I guess the main problem here is to properly encode the following in Python (we only consider scalar ndarrays here to simplify discussion):

template<typename dtype, int dim>
struct any_arr {
    dtype* base_ptr;
    int shape[dim];
};

[k-ye]

So... what's left to be done to properly encode this?

[strongoier]

I mean we should not make them the same name because they are essentially different. The name should contain the information that this parameter is a template parameter like ti.template() does. ti.any_arr() is a name on this way but with bad naming. Here I suggest ti.ndarray_template().

[strongoier]

Of course, we can make a more aggressive plan - treat an incomplete type as a templated type. For example,

@ti.kernel
def run(a: ti.types.ndarray(dtype=ti.i32)):

for

template<int dim>
struct type_of_a {
    i32* base_ptr;
    int shape[dim];
};

and

@ti.kernel
def run(b: ti.types.ndarray(dtype=ti.i32, dim=2)):

for

struct type_of_b{
    i32* base_ptr;
    int shape[2];
};

Then the remaining problem is to distinguish type definition and object constructor:

i32_ndarray_type = ti.types.ndarray(dtype=ti.i32)
a = i32_ndarray_type(shape=(5, 6))  # dim=2 can be inferred from the shape dimensions

[k-ye]

treat an incomplete type as a templated type

This reminds me of C++'s template specialization. I love this idea :-)

[strongoier]

To avoid making the creation of an ndarray too tedious in normal cases, we can make ti.ndarray as an alias of ti.types.ndarray(). That is, ti.ndarray(dtype=ti.i32, shape=(5, 6)) is actually an alias of ti.types.ndarray()(dtype=ti.i32, shape=(5, 6)) (define a type first and then construct an object of it). In this way, the only visible changes to users is around declaring types of kernel arguments (ti.any_arr / ti.ext_arr -> ti.types.ndarray).

[k-ye]

What's the progress on this?