Array & ArrayView

Dynamic Array

Int[] dynamicArrayOfIntegers is an array with dynamic size.

Int[] array = [0, 1, 2]
array[0] = 0
array[1] = 0
array[2] = 0
array[3] = 0  // Runtime error, no compile time bounds check

“Make simple things simple”,
having a short and traditional syntax for dynamic arrays should encourage people to use it.

T[] arr is the short form of cilia::Array<T> arr.

The long form is called Array<T>, not Vector<T>, because

• that’s the more traditional wording,
• by using the word “vector”, the purpose of this class is not immediately clear (especially not for users of many languages other than C++, not even C),
• Vector could too easily collide with the mathematical vector (as used in linear algebra and geometry).

“Raw” C/C++ arrays are handled with T* instead.
std::array is called cilia::StaticArray instead.

In C/C++ T[] means “array of certain (inferred) size”,

• but that can be replaced with T* and T[N].
• Also see https://cplusplus.com/forum/beginner/267321/#msg1150228

Static Array

Int[3] arrayOfThreeIntegers is an array with fixed size (instead of Int arrayOfThreeIntegers[3] in C/C++).

Int[3] array = [0, 1, 2]
array[0] = 0
array[1] = 0
array[2] = 0
array[3] = 0  // Compilation error, due to compile time bounds check

arrayOfThreeIntegers.size() -> 3
is realized as extension function

extension<type T, Int N> T[N] {
    func size() -> Int { return N }
}

Use T+/UniquePtr<T> for “raw” C/C++ arrays of arbitrary size.
But array subscript with Int+ is unsafe.

Int[0]+ array = new Int[3]
unsafe {
    array[0] = 0
    array[1] = 0
    array[2] = 0
    array[3] = 0  // Undefined behaviour, no bounds check at all
}

Using Int* for arrays is possible but generally unsafe.

Int[0]+ uniquePtrToArray = new Int[3]
unsafe {
    Int* array = move(uniquePtrToArray)
    array[0] = 0
    array[1] = 0
    array[2] = 0
    array[3] = 0    // Undefined behaviour, no bounds check at all
    delete[] array  // Array-delete!
}

unsafe {
    Int* array = reinterpretCastTo<Int*>(malloc(3 * sizeof(Int)))
    array[0] = 0
    array[1] = 0
    array[2] = 0
    array[3] = 0  // Undefined behaviour, no bounds check at all
    free(array)
}

Actually this is how to handle pointer to array of Int “properly”:

Int[3]+ arrayPtr = new Int[3]
(*arrayPtr)[0] = 0
(*arrayPtr)[1] = 0
(*arrayPtr)[2] = 0
(*arrayPtr)[3] = 0  // Compilation error, due to compile time bounds check

But raw pointer access is still unsafe:

unsafe {
    Int[3]* arrayPtr = new Int[3]
    (*arrayPtr)[0] = 0
    (*arrayPtr)[1] = 0
    (*arrayPtr)[2] = 0
    (*arrayPtr)[3] = 0  // Compilation error, due to compile time bounds check
    delete[] arrayPtr   // Array-delete!
}

Examples

• Int[] dynamicArrayOfInt
• Int[3] arrayOfThreeInt
• Int[3]& referenceToArrayOfThreeInt
• Int[3]* pointerToArrayOfThreeInt
• Int[3][]& referenceToDynamicArrayOfArrayOfThreeInt
• String*[] dynamicArrayOfPointersToString

ArrayView

AKA Slice AKA Subarray.

• var subarray = array[1..2]
• var subarray = array[1..<3]

Incomplete ranges (need lower and/or upper bounds before use) are typically implemented as inline functions that determine the concrete bounds and then call array[start..end] (or one of the exclusive counterparts).

• var subarray = array[..2]
• var subarray = array[..]

See Rust Slices

Multidimensional Array

• dynamic size
  • Int[,] dynamic2DArray
    • T[,] array is the short form of cilia::MDArray<2, T> array
  • Int[,,] multidimensionalDynamicArray
    • T[,,] array is the short form of cilia::MDArray<3, T> array
  • and so on:
    • cilia::MDArray<N, T>
• static size
  • Int[3, 2, 200]
    • Multidimensional static array

      Int[3, 2, 200] intArray3D
      intArray3D[2, 1, 199] = 1
      

    • cilia::StaticMDArray<Int, 3, 2, 200> intArray3D
• Mixed forms of static and dynamic array
  • Int[3][,] dynamic2DArrayOfArrayOfThreeInt
  • Int[3,4][] dynamicArrayOfThreeByFourArrayOfInt
• MDArrayView

Associative Array

AKA Map (or Dictionary).
TValue[TKey] as short form of Map<TKey, TValue> (as in D).

“Make simple things simple”,
having a short syntax for associative arrays so they are easy to use.

There is no difference between these two forms, but the long form is necessary for other map variants (SortedMap, HashMap, etc.).

Example: ContactInfo[String] contactInfoForID as short form of
Map<String, ContactInfo> contactInfoForID.

Maybe partial template specialization:

• Map<Int, ...> is a HashMap
• Map<String, ...> is a SortedMap