// supports multi-dimensional arrays
// support row-major and column major order - we can use both on different arrays.
// this is variant type
Dim A(0 to 4, 0 to 3, 1 to 2, -1 to 1) = 1
A(0,0,1,-1)++
Print A(0,0,1,-1)=2
// Arrays are values also
// here we pass a tuple (one dimension array 9 based)
A(4,3,2,1)=(1,2,3,4,5)
Print  A(4,3,2,1)(2)=3
Dim Z(10)
Z(3)=A()
Print Z(3)(4,3,2,1)(2)=3

// We can define type: BigInteger, Complex, Decimal, Currency, Double, Single, Long Long, Long, Byte, Date, Boolean, Object
Dim B(0 to 4, 0 to 3, 1 to 2, -1 to 1) as byte = 255
B(0,0,1,-1)--
Print B(0,0,1,-1)=254
// redim - by default is row-major
Dim B(0 to 5, 0 to 3, 1 to 2, -1 to 1)
Print B(0,0,1,-1)=254
// OLE type are column major
Dim OLE B(0 to 4, 0 to 3, 1 to 2, -1 to 1) as byte = 255
B(0,0,1,-1)--
// redim the last dimension only
Dim B(0 to 4, 0 to 3, 1 to 2, -1 to 5)
Print B(0,0,1,-1)=254
B(4,3,2,5)=253
Print Dimension(B())=4, Dimension(B(),4,1)=5
Print B()#pos(253)=279 ' Zero position (trait like one dimension)
// we can  redim free, but the items change positions..
k=len(B())
' one dimension
DIM B(K)
Print B(279)=253, type$(B(279))="Byte"
// we can get the actual address
Print Varptr(B(279))-Varptr(B(278))=1
// another type of arrays
// there is no dim, we set index and we get resize
Byte z[10]=255
d=lambda->{
	object d[number]
	= d
}
object P[2]=d(0)
p[2]=d(10)
p[1]=d(3)
P[2][1]=z  // we get the pointer
P[2][2]=z[]  // we get the copy
P[1][1]=z  // we get the pointer
P[1][2]=z[]  // we get the copy
p[2][2][2]-=10
? p[2][2][2]=245
? p[1][2][2]=255
DEF TypeVal(x)=type$(x)
// these are the Seven arrays (two of them are z):
Print len(p[0])=1, type$(p, 0)="RefArray"
Print len(p[1])=4, type$(p, 1)="RefArray"
Print len(p[2])=11, type$(p, 2)="RefArray"
Print TypeVal(p[1][1])="RefArray"
Print p[1][1] is z
Print TypeVal(p[1][2])="RefArray"
Print len(p[1][2])=11, TypeVal(p[1][2][0])="Byte"
Print TypeVal(p[2][1])="RefArray"
Print p[2][1] is z
Print p[1][1] is p[2][1]
Print TypeVal(p[2][2])="RefArray"
Print not p[1][1] is p[2][2]
z[6]-=100
Print p[1][1][6]=z[6],  p[2][1][6]=z[6]
Print len(p[2][2])=11, TypeVal(p[2][2][0])="Byte"
byte k[0]
// shallow copy
k=p[]
Print k[2][1] is z
// copy
k[2][1]=k[2][]
// so now array at k[2][1] is a copy, different pointer from z
Print not k[2][1] is z

// Sparse Matrix using a list (has a hash table)
g=list:= 1:=100, 10:=300, 500:=40
if exist(g, 10) then print eval(g)=300
Print g(1)=100, g(10)=300, g(500)=40
Print valid(g(20)) = false
Print valid(g(10)) = true
Append g, 400:=1000
// this is a quicksort
Sort ascending g as number
// Sparse Matrix using a Queue (a list taking same keys)
t=queue:=2,3,4,4,5,10:="A",10:="C",10:="B", 3
// this is a stable sort
sort t as number
// Access same keys using the hash table
if exist(t, 10) then
many=exist(t, 10, 0)
for i=1 to many
	if exist(t, 10, i) then print eval$(t), eval(t!)  ' value and position
next
end if