Hello. I heard about SIMD, Atomics, etc. and they accept as first arguments
"array, index", so because ES6 have spreads, I suggest to make next things:

let array = [0, 2, 3];
let ptr = array{0}; // don't get value, but pair of [array, 0], also this
is proxied which you have setter and getter "value"
let ptr = array.ptr(0); // alternate, functional

ptr.value = 1; // setter
let acceptance = ptr.value; // getter

// also you can just use these pointers without extra indexing
let idx = Atomics.add(...ptr, 1);

It should available for both: typed and regular arrays.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.mozilla.org/pipermail/es-discuss/attachments/20170603/d74d177e/attachment.html>

Hello. I heard about SIMD, Atomics, etc. and they accept as first arguments
"array, index", so because ES6 have spreads, I suggest to make next things:

let array = [0, 2, 3];
let ptr = array{0}; // don't get value, but pair of [array, 0], also this
is proxied which you have setter and getter "value"
let ptr = array.ptr(0); // alternate, functional

ptr.value = 1; // setter
let acceptance = ptr.value; // getter

// also you can just use these pointers without extra indexing
let idx = Atomics.add(...ptr, 1);

It should available for both: typed and regular arrays.

Simular possible with objects, where you can pass to "defineProperty". Main problem - getting through point syntax. I thinking "->" syntax (against C++), but may corrupt compatibilies. But is not cancels obj{'foo'} getting pointers. 

Hello. I heard about SIMD, Atomics, etc. and they accept as first arguments
"array, index", so because ES6 have spreads, I suggest to make next things:

let array = [0, 2, 3];
let ptr = array{0}; // don't get value, but pair of [array, 0], also this
is proxied which you have setter and getter "value"
let ptr = array.ptr(0); // alternate, functional

ptr.value = 1; // setter
let acceptance = ptr.value; // getter

// also you can just use these pointers without extra indexing
let idx = Atomics.add(...ptr, 1);

It should available for both: typed and regular arrays.

Simular possible with objects, where you can pass to "defineProperty". Main problem - getting through point syntax. I thinking "->" syntax (against C++), but may corrupt compatibilies. 

Hello. I heard about SIMD, Atomics, etc. and they accept as first arguments
"array, index", so because ES6 have spreads, I suggest to make next things:

let array = [0, 2, 3];
let ptr = array{0}; // don't get value, but pair of [array, 0], also this
is proxied which you have setter and getter "value"
let ptr = array.ptr(0); // alternate, functional

ptr.value = 1; // setter
let acceptance = ptr.value; // getter

// also you can just use these pointers without extra indexing
let idx = Atomics.add(...ptr, 1);

It should available for both: typed and regular arrays.

Simular possible with objects, where you can pass to "defineProperty". Main problem - getting through point syntax, I thinking "->" syntax (against C++), but may corrupt compatibilies. 

Hello. I heard about SIMD, Atomics, etc. and they accept as first arguments
"array, index", so because ES6 have spreads, I suggest to make next things:

let array = [0, 2, 3];
let ptr = array{0}; // don't get value, but pair of [array, 0], also this
is proxied which you have setter and getter "value"
let ptr = array.ptr(0); // alternate, functional

ptr.value = 1; // setter
let acceptance = ptr.value; // getter

// also you can just use these pointers without extra indexing
let idx = Atomics.add(...ptr, 1);

It should available for both: typed and regular arrays.
Simular possible with objects, where you can pass to "defineProperty". Main problem - getting through point syntax, I thinking "->" syntax (against C++), but may corrupt compatibilies.