Why doesn't Mojo have predefined arrays/lists?

[MartinStuwe]

It seems like Mojo doesn't have array data types.

I have seen this in the documentation:

struct HeapArray:
    var data: Pointer[Int]
    var size: Int
    var cap: Int

    fn __init__(inout self, size: Int, val: Int):
        self.size = size
        self.cap = size * 2
        self.data = Pointer[Int].alloc(self.cap)
        for i in range(self.size):
            self.data.store(i, val)

    fn __copyinit__(inout self, existing: Self):
        # Deep-copy the existing value
        self.size = existing.size
        self.cap = existing.cap
        self.data = Pointer[Int].alloc(self.cap)
        for i in range(self.size):
            self.data.store(i, existing.data.load(i))
        # The lifetime of `existing` continues unchanged

    fn __del__(owned self):
        # We must free the heap-allocated data, but
        # Mojo knows how to destroy the other fields
        self.data.free()

    fn append(inout self, val: Int):
        # Update the array for demo purposes
        if self.size < self.cap:
            self.data.store(self.size, val)
            self.size += 1
        else:
            print("Out of bounds")

    fn dump(self):
        # Print the array contents for demo purposes
        print_no_newline("[")
        for i in range(self.size):
            if i > 0:
                print_no_newline(", ")
            print_no_newline(self.data.load(i))
        print("]")

So in order to have similar data structures we have to define them like this?
And what is a heap array?
In my CS lectures I only heard about dynamic arrays, and it seems like this is a dynamic array.
Aren't heaps just trees where have the heap properties i.e. have some orders like max/min value at the first node?

Or are the standard Mojo Arrays the SIMD vector data structures?

[Brian-M-J]

Mojo has arrays, but they are called vectors:

• DynamicVector is an array that can change its size at runtime (similar to C++'s std::vector and Java's ArrayList).
• InlineFixedVector is similar to arrays in Java and C++ where the max size is fixed. (e.g.: int[] a = new int[10];)

And what is a heap array?
In my CS lectures I only heard about dynamic arrays, and it seems like this is a dynamic array.
Aren't heaps just trees where have the heap properties i.e. have some orders like max/min value at the first node?

The heap data structure is different from heap memory. By heap array, the author means that the array is stored in heap memory.