Typescript can prevent you from using indexes on the wrong array

I think you may be missing the point. The idea of TypeScript is to prevent mistakes. Say you have two arrays of unrelated things:

const hats = ['top hat', 'baseball cap', 'beanie', 'wide brim'];
const plants = ['cactus', 'oak', 'jarrah', 'grass'];

It doesn't matter what they are, as long as they are unrelated. Say you use a function that returns an index into the array, like indexOf

const hatIndex = hats.indexOf('baseball cap');

There is nothing stopping you from using the hatIndex on the array of plants, even though that is completely wrong:

console.log(plants[hatIndex]); // absolute nonsense

The idea behind the original post is to try to prevent that kind of mistake from happening. The original code prevents you from using an index from one array on another array by mistake, even if they have the same type. I used the "special methods" to set and get a value because it was shorter to write than a full class.

That makes a lot of sense. I wonder if you can remove the id on the array too

Haskell does not have rank 2 polymorphism be default, it has to be enabled as a compiler feature. the forall keyword is unavailable until you do so.

Rust does not allow this as structs are unboxed. A method that returns a parameterized type that is not known until runtime is unsized so machine code cannot be generated. A method like that cannot be made into a trait object. These kind of generative types have to be implemented using lifetimes instead.

The id types are given explicitly in the call to withArray. That is, they are not existentials but concrete types Id1 and Id2 (whatever they are defined to be)

You can replace the call with completely inferred types and you'll get the correct error:

withArray((a1) => 
    withArray((a2) => {
        // within this block, indexes can only be used on the array they
        // were created with
        const index1 = push(a1, 5);
        const index2 = push(a2, 3);

        getIndex(a1, index2);       // Error, Id not assignable to Id
        getIndex(a2, index1);       // Error, Id not assignable to Id

        const val1 = getIndex(a1, index1);
        const val2 = getIndex(a2, index2);
    })
);

Argument of type 'Index<Id>' is not assignable to parameter of type 'Index<Id>'. Type 'Id' is not assignable to type 'Id'. Two different types with this name exist, but they are unrelated.

I think you're mistaken, the equivalent code in Haskell is the following:

{-# LANGUAGE Rank2Types #-}

data List id a = List id [a]
data Index id = Index id Int

push :: List id a -> a -> (List id a, Index id)
push (List id xs) x = (List id (x: xs), Index id (length xs))

get :: List id a -> Index id -> a
get (List _ (x: _)) (Index _ 0) = x
get (List id (_: xs)) (Index _ n) = get (List id xs) (Index id (n - 1))

withArray :: (forall id. List id a -> b) -> b
withArray f = f (List () [])

wat = withArray (\a1 -> withArray (\a2 -> let
    (a1', index1) = push a1 5
    (a2', index2) = push a2 3

    -- bad1 = get a1' index2
    -- bad2 = get a2' index1

    val1 = get a1' index1
    val2 = get a2' index2
    in (val1, val2)
    ))

The program will fail to compile when you remove the forall from withArray:

withArray :: (List id a -> b) -> b
withArray f = f (List () [])

The error is:

Couldn't match type ‘id’ with ‘()’