fluencelabs/assemblyscript
1
0
Fork 0
mirror of https://github.com/fluencelabs/assemblyscript synced 2025-06-14 23:41:30 +00:00
Code Issues Projects Releases Wiki Activity

consistent naming

Browse Source
This commit is contained in:
dcode
2019-06-01 05:12:30 +02:00
parent e65d875ebc
commit 066ea1fbd2
3 changed files with 227 additions and 227 deletions
Download Patch File Download Diff File Expand all files Collapse all files

48
std/assembly/array.ts
View File

@ -77,14 +77,14 @@ export class Array<T> extends ArrayBufferView {
this.length_ = length;
}
every(callbackfn: (element: T, index: i32, array: Array<T>) => bool): bool {
every(fn: (value: T, index: i32, array: Array<T>) => bool): bool {
for (let index = 0, length = this.length_; index < min(length, this.length_); ++index) {
if (!callbackfn(load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this)) return false;
if (!fn(load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this)) return false;
}
return true;
}
findIndex(predicate: (element: T, index: i32, array: Array<T>) => bool): i32 {
findIndex(predicate: (value: T, index: i32, array: Array<T>) => bool): i32 {
for (let index = 0, length = this.length_; index < min(length, this.length_); ++index) {
if (predicate(load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this)) return index;
}
@ -151,30 +151,30 @@ export class Array<T> extends ArrayBufferView {
return this;
}
includes(searchElement: T, fromIndex: i32 = 0): bool {
return this.indexOf(searchElement, fromIndex) >= 0;
includes(value: T, fromIndex: i32 = 0): bool {
return this.indexOf(value, fromIndex) >= 0;
}
indexOf(searchElement: T, fromIndex: i32 = 0): i32 {
indexOf(value: T, fromIndex: i32 = 0): i32 {
var length = this.length_;
if (length == 0 || fromIndex >= length) return -1;
if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);
var dataStart = this.dataStart;
while (fromIndex < length) {
if (load<T>(dataStart + (<usize>fromIndex << alignof<T>())) == searchElement) return fromIndex;
if (load<T>(dataStart + (<usize>fromIndex << alignof<T>())) == value) return fromIndex;
++fromIndex;
}
return -1;
}
lastIndexOf(searchElement: T, fromIndex: i32 = this.length_): i32 {
lastIndexOf(value: T, fromIndex: i32 = this.length_): i32 {
var length = this.length_;
if (length == 0) return -1;
if (fromIndex < 0) fromIndex = length + fromIndex;
else if (fromIndex >= length) fromIndex = length - 1;
var dataStart = this.dataStart;
while (fromIndex >= 0) {
if (load<T>(dataStart + (<usize>fromIndex << alignof<T>())) == searchElement) return fromIndex;
if (load<T>(dataStart + (<usize>fromIndex << alignof<T>())) == value) return fromIndex;
--fromIndex;
}
return -1;
@ -261,18 +261,18 @@ export class Array<T> extends ArrayBufferView {
return element;
}
forEach(callbackfn: (value: T, index: i32, array: Array<T>) => void): void {
forEach(fn: (value: T, index: i32, array: Array<T>) => void): void {
for (let index = 0, length = this.length_; index < min(length, this.length_); ++index) {
callbackfn(load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this);
fn(load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this);
}
}
map<U>(callbackfn: (value: T, index: i32, array: Array<T>) => U): Array<U> {
map<U>(fn: (value: T, index: i32, array: Array<T>) => U): Array<U> {
var length = this.length_;
var out = changetype<Array<U>>(__allocArray(length, alignof<U>(), idof<Array<U>>())); // retains
var outStart = out.dataStart;
for (let index = 0; index < min(length, this.length_); ++index) {
let result = callbackfn(load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this); // retains
let result = fn(load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this); // retains
if (isManaged<U>()) {
store<usize>(outStart + (<usize>index << alignof<U>()), __retain(changetype<usize>(result)));
} else {
@ -283,33 +283,33 @@ export class Array<T> extends ArrayBufferView {
return out;
}
filter(callbackfn: (value: T, index: i32, array: Array<T>) => bool): Array<T> {
filter(fn: (value: T, index: i32, array: Array<T>) => bool): Array<T> {
var result = changetype<Array<T>>(__allocArray(0, alignof<T>(), idof<Array<T>>())); // retains
for (let index = 0, length = this.length_; index < min(length, this.length_); ++index) {
let value = load<T>(this.dataStart + (<usize>index << alignof<T>()));
if (callbackfn(value, index, this)) result.push(value);
if (fn(value, index, this)) result.push(value);
}
return result;
}
reduce<U>(
callbackfn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array<T>) => U,
fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array<T>) => U,
initialValue: U
): U {
var accum = initialValue;
for (let index = 0, length = this.length_; index < min(length, this.length_); ++index) {
accum = callbackfn(accum, load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this);
accum = fn(accum, load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this);
}
return accum;
}
reduceRight<U>(
callbackfn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array<T>) => U,
fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array<T>) => U,
initialValue: U
): U {
var accum = initialValue;
for (let index = this.length_ - 1; index >= 0; --index) {
accum = callbackfn(accum, load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this);
accum = fn(accum, load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this);
}
return accum;
}
@ -333,14 +333,14 @@ export class Array<T> extends ArrayBufferView {
return element;
}
some(callbackfn: (element: T, index: i32, array: Array<T>) => bool): bool {
some(fn: (value: T, index: i32, array: Array<T>) => bool): bool {
for (let index = 0, length = this.length_; index < min(length, this.length_); ++index) {
if (callbackfn(load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this)) return true;
if (fn(load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this)) return true;
}
return false;
}
unshift(element: T): i32 {
unshift(value: T): i32 {
var newLength = this.length_ + 1;
ensureSize(changetype<usize>(this), newLength, alignof<T>());
var dataStart = this.dataStart;
@ -350,9 +350,9 @@ export class Array<T> extends ArrayBufferView {
<usize>(newLength - 1) << alignof<T>()
);
if (isManaged<T>()) {
store<usize>(dataStart, __retain(changetype<usize>(element)));
store<usize>(dataStart, __retain(changetype<usize>(value)));
} else {
store<T>(dataStart, element);
store<T>(dataStart, value);
}
this.length_ = newLength;
return newLength;

70
std/assembly/set.ts
View File

@ -35,22 +35,22 @@ const BUCKET_SIZE = sizeof<usize>();
/** Computes the alignment of an entry. */
// @ts-ignore: decorator
@inline
function ENTRY_ALIGN<K>(): usize {
function ENTRY_ALIGN<T>(): usize {
// can align to 4 instead of 8 if 32-bit and K is <= 32-bits
const align = (sizeof<K>() > sizeof<usize>() ? sizeof<K>() : sizeof<usize>()) - 1;
const align = (sizeof<T>() > sizeof<usize>() ? sizeof<T>() : sizeof<usize>()) - 1;
return align;
}
/** Computes the aligned size of an entry. */
// @ts-ignore: decorator
@inline
function ENTRY_SIZE<K>(): usize {
const align = ENTRY_ALIGN<K>();
const size = (offsetof<SetEntry<K>>() + align) & ~align;
function ENTRY_SIZE<T>(): usize {
const align = ENTRY_ALIGN<T>();
const size = (offsetof<SetEntry<T>>() + align) & ~align;
return size;
}
export class Set<K> {
export class Set<T> {
// buckets holding references to the respective first entry within
private buckets: ArrayBuffer; // usize[bucketsMask + 1]
@ -70,30 +70,30 @@ export class Set<K> {
const bucketsSize = INITIAL_CAPACITY * <i32>BUCKET_SIZE;
this.buckets = new ArrayBuffer(bucketsSize);
this.bucketsMask = INITIAL_CAPACITY - 1;
const entriesSize = INITIAL_CAPACITY * <i32>ENTRY_SIZE<K>();
const entriesSize = INITIAL_CAPACITY * <i32>ENTRY_SIZE<T>();
this.entries = new ArrayBuffer(entriesSize);
this.entriesCapacity = INITIAL_CAPACITY;
this.entriesOffset = 0;
this.entriesCount = 0;
}
private find(key: K, hashCode: u32): SetEntry<K> | null {
var entry = load<SetEntry<K>>( // unmanaged!
private find(key: T, hashCode: u32): SetEntry<T> | null {
var entry = load<SetEntry<T>>( // unmanaged!
changetype<usize>(this.buckets) + <usize>(hashCode & this.bucketsMask) * BUCKET_SIZE
);
while (entry) {
if (!(entry.taggedNext & EMPTY) && entry.key == key) return entry;
entry = changetype<SetEntry<K>>(entry.taggedNext & ~EMPTY);
entry = changetype<SetEntry<T>>(entry.taggedNext & ~EMPTY);
}
return null;
}
has(key: K): bool {
return this.find(key, HASH<K>(key)) !== null;
has(key: T): bool {
return this.find(key, HASH<T>(key)) !== null;
}
add(key: K): void {
var hashCode = HASH<K>(key);
add(key: T): void {
var hashCode = HASH<T>(key);
var entry = this.find(key, hashCode); // unmanaged!
if (!entry) {
// check if rehashing is necessary
@ -105,9 +105,9 @@ export class Set<K> {
);
}
// append new entry
entry = changetype<SetEntry<K>>(changetype<usize>(this.entries) + this.entriesOffset++ * ENTRY_SIZE<K>());
entry.key = isManaged<K>()
? changetype<K>(__retain(changetype<usize>(key)))
entry = changetype<SetEntry<T>>(changetype<usize>(this.entries) + this.entriesOffset++ * ENTRY_SIZE<T>());
entry.key = isManaged<T>()
? changetype<T>(__retain(changetype<usize>(key)))
: key;
++this.entriesCount;
// link with previous entry in bucket
@ -117,10 +117,10 @@ export class Set<K> {
}
}
delete(key: K): bool {
var entry = this.find(key, HASH<K>(key)); // unmanaged!
delete(key: T): bool {
var entry = this.find(key, HASH<T>(key)); // unmanaged!
if (!entry) return false;
if (isManaged<K>()) __release(changetype<usize>(entry.key)); // exact 'key'
if (isManaged<T>()) __release(changetype<usize>(entry.key)); // exact 'key'
entry.taggedNext |= EMPTY;
--this.entriesCount;
// check if rehashing is appropriate
@ -136,24 +136,24 @@ export class Set<K> {
var newBucketsCapacity = <i32>(newBucketsMask + 1);
var newBuckets = new ArrayBuffer(newBucketsCapacity * <i32>BUCKET_SIZE);
var newEntriesCapacity = <i32>(newBucketsCapacity * FILL_FACTOR);
var newEntries = new ArrayBuffer(newEntriesCapacity * <i32>ENTRY_SIZE<K>());
var newEntries = new ArrayBuffer(newEntriesCapacity * <i32>ENTRY_SIZE<T>());
// copy old entries to new entries
var oldPtr = changetype<usize>(this.entries);
var oldEnd = oldPtr + <usize>this.entriesOffset * ENTRY_SIZE<K>();
var oldEnd = oldPtr + <usize>this.entriesOffset * ENTRY_SIZE<T>();
var newPtr = changetype<usize>(newEntries);
while (oldPtr != oldEnd) {
let oldEntry = changetype<SetEntry<K>>(oldPtr); // unmanaged!
let oldEntry = changetype<SetEntry<T>>(oldPtr); // unmanaged!
if (!(oldEntry.taggedNext & EMPTY)) {
let newEntry = changetype<SetEntry<K>>(newPtr); // unmanaged!
let newEntry = changetype<SetEntry<T>>(newPtr); // unmanaged!
newEntry.key = oldEntry.key;
let newBucketIndex = HASH<K>(oldEntry.key) & newBucketsMask;
let newBucketIndex = HASH<T>(oldEntry.key) & newBucketsMask;
let newBucketPtrBase = changetype<usize>(newBuckets) + <usize>newBucketIndex * BUCKET_SIZE;
newEntry.taggedNext = load<usize>(newBucketPtrBase);
store<usize>(newBucketPtrBase, newPtr);
newPtr += ENTRY_SIZE<K>();
newPtr += ENTRY_SIZE<T>();
}
oldPtr += ENTRY_SIZE<K>();
oldPtr += ENTRY_SIZE<T>();
}
this.buckets = newBuckets;
@ -163,13 +163,13 @@ export class Set<K> {
this.entriesOffset = this.entriesCount;
}
values(): K[] {
values(): T[] {
// FIXME: this is preliminary, needs iterators/closures
var start = changetype<usize>(this.entries);
var size = this.entriesOffset;
var values = Array.create<K>(size);
var values = Array.create<T>(size);
for (let i = 0; i < size; ++i) {
let entry = changetype<SetEntry<K>>(start + <usize>i * ENTRY_SIZE<K>());
let entry = changetype<SetEntry<T>>(start + <usize>i * ENTRY_SIZE<T>());
if (!(entry.taggedNext & EMPTY)) {
values.push(entry.key);
}
@ -186,18 +186,18 @@ export class Set<K> {
@unsafe private __visit_impl(cookie: u32): void {
__visit(changetype<usize>(this.buckets), cookie);
var entries = changetype<usize>(this.entries);
if (isManaged<K>()) {
if (isManaged<T>()) {
let cur = entries;
let end = cur + <usize>this.entriesOffset * ENTRY_SIZE<K>();
let end = cur + <usize>this.entriesOffset * ENTRY_SIZE<T>();
while (cur < end) {
let entry = changetype<SetEntry<K>>(cur);
let entry = changetype<SetEntry<T>>(cur);
if (!(entry.taggedNext & EMPTY)) {
let val = changetype<usize>(entry.key);
if (isNullable<K>()) {
if (isNullable<T>()) {
if (val) __visit(val, cookie);
} else __visit(val, cookie);
}
cur += ENTRY_SIZE<K>();
cur += ENTRY_SIZE<T>();
}
}
__visit(entries, cookie);

336
std/assembly/typedarray.ts
View File

@ -47,37 +47,37 @@ export class Int8Array extends ArrayBufferView {
}
reduce<T>(
callbackfn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,
fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,
initialValue: T,
): T {
return REDUCE<Int8Array, i8, T>(this, callbackfn, initialValue);
return REDUCE<Int8Array, i8, T>(this, fn, initialValue);
}
reduceRight<T>(
callbackfn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,
fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,
initialValue: T,
): T {
return REDUCE_RIGHT<Int8Array, i8, T>(this, callbackfn, initialValue);
return REDUCE_RIGHT<Int8Array, i8, T>(this, fn, initialValue);
}
map(callbackfn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {
return MAP<Int8Array, i8>(this, callbackfn);
map(fn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {
return MAP<Int8Array, i8>(this, fn);
}
findIndex(callbackfn: (value: i8, index: i32, self: Int8Array) => bool): i32 {
return FIND_INDEX<Int8Array, i8>(this, callbackfn);
findIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {
return FIND_INDEX<Int8Array, i8>(this, fn);
}
some(callbackfn: (value: i8, index: i32, self: Int8Array) => bool): bool {
return SOME<Int8Array, i8>(this, callbackfn);
some(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {
return SOME<Int8Array, i8>(this, fn);
}
every(callbackfn: (value: i8, index: i32, self: Int8Array) => bool): bool {
return EVERY<Int8Array, i8>(this, callbackfn);
every(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {
return EVERY<Int8Array, i8>(this, fn);
}
forEach(callbackfn: (value: i8, index: i32, self: Int8Array) => void): void {
FOREACH<Int8Array, i8>(this, callbackfn);
forEach(fn: (value: i8, index: i32, self: Int8Array) => void): void {
FOREACH<Int8Array, i8>(this, fn);
}
reverse(): this {
@ -129,37 +129,37 @@ export class Uint8Array extends ArrayBufferView {
}
reduce<T>(
callbackfn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,
fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,
initialValue: T,
): T {
return REDUCE<Uint8Array, u8, T>(this, callbackfn, initialValue);
return REDUCE<Uint8Array, u8, T>(this, fn, initialValue);
}
reduceRight<T>(
callbackfn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,
fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,
initialValue: T,
): T {
return REDUCE_RIGHT<Uint8Array, u8, T>(this, callbackfn, initialValue);
return REDUCE_RIGHT<Uint8Array, u8, T>(this, fn, initialValue);
}
map(callbackfn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {
return MAP<Uint8Array, u8>(this, callbackfn);
map(fn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {
return MAP<Uint8Array, u8>(this, fn);
}
findIndex(callbackfn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {
return FIND_INDEX<Uint8Array, u8>(this, callbackfn);
findIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {
return FIND_INDEX<Uint8Array, u8>(this, fn);
}
some(callbackfn: (value: u8, index: i32, self: Uint8Array) => bool): bool {
return SOME<Uint8Array, u8>(this, callbackfn);
some(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {
return SOME<Uint8Array, u8>(this, fn);
}
every(callbackfn: (value: u8, index: i32, self: Uint8Array) => bool): bool {
return EVERY<Uint8Array, u8>(this, callbackfn);
every(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {
return EVERY<Uint8Array, u8>(this, fn);
}
forEach(callbackfn: (value: u8, index: i32, self: Uint8Array) => void): void {
FOREACH<Uint8Array, u8>(this, callbackfn);
forEach(fn: (value: u8, index: i32, self: Uint8Array) => void): void {
FOREACH<Uint8Array, u8>(this, fn);
}
reverse(): this {
@ -211,37 +211,37 @@ export class Uint8ClampedArray extends ArrayBufferView {
}
reduce<T>(
callbackfn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,
fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,
initialValue: T,
): T {
return REDUCE<Uint8ClampedArray, u8, T>(this, callbackfn, initialValue);
return REDUCE<Uint8ClampedArray, u8, T>(this, fn, initialValue);
}
reduceRight<T>(
callbackfn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,
fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,
initialValue: T,
): T {
return REDUCE_RIGHT<Uint8ClampedArray, u8, T>(this, callbackfn, initialValue);
return REDUCE_RIGHT<Uint8ClampedArray, u8, T>(this, fn, initialValue);
}
map(callbackfn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {
return MAP<Uint8ClampedArray, u8>(this, callbackfn);
map(fn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {
return MAP<Uint8ClampedArray, u8>(this, fn);
}
findIndex(callbackfn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {
return FIND_INDEX<Uint8ClampedArray, u8>(this, callbackfn);
findIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {
return FIND_INDEX<Uint8ClampedArray, u8>(this, fn);
}
some(callbackfn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {
return SOME<Uint8ClampedArray, u8>(this, callbackfn);
some(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {
return SOME<Uint8ClampedArray, u8>(this, fn);
}
every(callbackfn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {
return EVERY<Uint8ClampedArray, u8>(this, callbackfn);
every(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {
return EVERY<Uint8ClampedArray, u8>(this, fn);
}
forEach(callbackfn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {
FOREACH<Uint8ClampedArray, u8>(this, callbackfn);
forEach(fn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {
FOREACH<Uint8ClampedArray, u8>(this, fn);
}
reverse(): this {
@ -293,37 +293,37 @@ export class Int16Array extends ArrayBufferView {
}
reduce<T>(
callbackfn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,
fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,
initialValue: T,
): T {
return REDUCE<Int16Array, i16, T>(this, callbackfn, initialValue);
return REDUCE<Int16Array, i16, T>(this, fn, initialValue);
}
reduceRight<T>(
callbackfn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,
fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,
initialValue: T,
): T {
return REDUCE_RIGHT<Int16Array, i16, T>(this, callbackfn, initialValue);
return REDUCE_RIGHT<Int16Array, i16, T>(this, fn, initialValue);
}
map(callbackfn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {
return MAP<Int16Array, i16>(this, callbackfn);
map(fn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {
return MAP<Int16Array, i16>(this, fn);
}
findIndex(callbackfn: (value: i16, index: i32, self: Int16Array) => bool): i32 {
return FIND_INDEX<Int16Array, i16>(this, callbackfn);
findIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {
return FIND_INDEX<Int16Array, i16>(this, fn);
}
some(callbackfn: (value: i16, index: i32, self: Int16Array) => bool): bool {
return SOME<Int16Array, i16>(this, callbackfn);
some(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {
return SOME<Int16Array, i16>(this, fn);
}
every(callbackfn: (value: i16, index: i32, self: Int16Array) => bool): bool {
return EVERY<Int16Array, i16>(this, callbackfn);
every(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {
return EVERY<Int16Array, i16>(this, fn);
}
forEach(callbackfn: (value: i16, index: i32, self: Int16Array) => void): void {
FOREACH<Int16Array, i16>(this, callbackfn);
forEach(fn: (value: i16, index: i32, self: Int16Array) => void): void {
FOREACH<Int16Array, i16>(this, fn);
}
reverse(): this {
@ -375,37 +375,37 @@ export class Uint16Array extends ArrayBufferView {
}
reduce<T>(
callbackfn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,
fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,
initialValue: T,
): T {
return REDUCE<Uint16Array, u16, T>(this, callbackfn, initialValue);
return REDUCE<Uint16Array, u16, T>(this, fn, initialValue);
}
reduceRight<T>(
callbackfn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,
fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,
initialValue: T,
): T {
return REDUCE_RIGHT<Uint16Array, u16, T>(this, callbackfn, initialValue);
return REDUCE_RIGHT<Uint16Array, u16, T>(this, fn, initialValue);
}
map(callbackfn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {
return MAP<Uint16Array, u16>(this, callbackfn);
map(fn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {
return MAP<Uint16Array, u16>(this, fn);
}
findIndex(callbackfn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {
return FIND_INDEX<Uint16Array, u16>(this, callbackfn);
findIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {
return FIND_INDEX<Uint16Array, u16>(this, fn);
}
some(callbackfn: (value: u16, index: i32, self: Uint16Array) => bool): bool {
return SOME<Uint16Array, u16>(this, callbackfn);
some(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {
return SOME<Uint16Array, u16>(this, fn);
}
every(callbackfn: (value: u16, index: i32, self: Uint16Array) => bool): bool {
return EVERY<Uint16Array, u16>(this, callbackfn);
every(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {
return EVERY<Uint16Array, u16>(this, fn);
}
forEach(callbackfn: (value: u16, index: i32, self: Uint16Array) => void): void {
FOREACH<Uint16Array, u16>(this, callbackfn);
forEach(fn: (value: u16, index: i32, self: Uint16Array) => void): void {
FOREACH<Uint16Array, u16>(this, fn);
}
reverse(): this {
@ -457,37 +457,37 @@ export class Int32Array extends ArrayBufferView {
}
reduce<T>(
callbackfn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,
fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,
initialValue: T,
): T {
return REDUCE<Int32Array, i32, T>(this, callbackfn, initialValue);
return REDUCE<Int32Array, i32, T>(this, fn, initialValue);
}
reduceRight<T>(
callbackfn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,
fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,
initialValue: T,
): T {
return REDUCE_RIGHT<Int32Array, i32, T>(this, callbackfn, initialValue);
return REDUCE_RIGHT<Int32Array, i32, T>(this, fn, initialValue);
}
map(callbackfn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {
return MAP<Int32Array, i32>(this, callbackfn);
map(fn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {
return MAP<Int32Array, i32>(this, fn);
}
findIndex(callbackfn: (value: i32, index: i32, self: Int32Array) => bool): i32 {
return FIND_INDEX<Int32Array, i32>(this, callbackfn);
findIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {
return FIND_INDEX<Int32Array, i32>(this, fn);
}
some(callbackfn: (value: i32, index: i32, self: Int32Array) => bool): bool {
return SOME<Int32Array, i32>(this, callbackfn);
some(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {
return SOME<Int32Array, i32>(this, fn);
}
every(callbackfn: (value: i32, index: i32, self: Int32Array) => bool): bool {
return EVERY<Int32Array, i32>(this, callbackfn);
every(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {
return EVERY<Int32Array, i32>(this, fn);
}
forEach(callbackfn: (value: i32, index: i32, self: Int32Array) => void): void {
FOREACH<Int32Array, i32>(this, callbackfn);
forEach(fn: (value: i32, index: i32, self: Int32Array) => void): void {
FOREACH<Int32Array, i32>(this, fn);
}
reverse(): this {
@ -539,37 +539,37 @@ export class Uint32Array extends ArrayBufferView {
}
reduce<T>(
callbackfn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,
fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,
initialValue: T,
): T {
return REDUCE<Uint32Array, u32, T>(this, callbackfn, initialValue);
return REDUCE<Uint32Array, u32, T>(this, fn, initialValue);
}
reduceRight<T>(
callbackfn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,
fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,
initialValue: T,
): T {
return REDUCE_RIGHT<Uint32Array, u32, T>(this, callbackfn, initialValue);
return REDUCE_RIGHT<Uint32Array, u32, T>(this, fn, initialValue);
}
map(callbackfn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {
return MAP<Uint32Array, u32>(this, callbackfn);
map(fn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {
return MAP<Uint32Array, u32>(this, fn);
}
findIndex(callbackfn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {
return FIND_INDEX<Uint32Array, u32>(this, callbackfn);
findIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {
return FIND_INDEX<Uint32Array, u32>(this, fn);
}
some(callbackfn: (value: u32, index: i32, self: Uint32Array) => bool): bool {
return SOME<Uint32Array, u32>(this, callbackfn);
some(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {
return SOME<Uint32Array, u32>(this, fn);
}
every(callbackfn: (value: u32, index: i32, self: Uint32Array) => bool): bool {
return EVERY<Uint32Array, u32>(this, callbackfn);
every(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {
return EVERY<Uint32Array, u32>(this, fn);
}
forEach(callbackfn: (value: u32, index: i32, self: Uint32Array) => void): void {
FOREACH<Uint32Array, u32>(this, callbackfn);
forEach(fn: (value: u32, index: i32, self: Uint32Array) => void): void {
FOREACH<Uint32Array, u32>(this, fn);
}
reverse(): this {
@ -621,37 +621,37 @@ export class Int64Array extends ArrayBufferView {
}
reduce<T>(
callbackfn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,
fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,
initialValue: T,
): T {
return REDUCE<Int64Array, i64, T>(this, callbackfn, initialValue);
return REDUCE<Int64Array, i64, T>(this, fn, initialValue);
}
reduceRight<T>(
callbackfn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,
fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,
initialValue: T,
): T {
return REDUCE_RIGHT<Int64Array, i64, T>(this, callbackfn, initialValue);
return REDUCE_RIGHT<Int64Array, i64, T>(this, fn, initialValue);
}
map(callbackfn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {
return MAP<Int64Array, i64>(this, callbackfn);
map(fn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {
return MAP<Int64Array, i64>(this, fn);
}
findIndex(callbackfn: (value: i64, index: i32, self: Int64Array) => bool): i32 {
return FIND_INDEX<Int64Array, i64>(this, callbackfn);
findIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {
return FIND_INDEX<Int64Array, i64>(this, fn);
}
some(callbackfn: (value: i64, index: i32, self: Int64Array) => bool): bool {
return SOME<Int64Array, i64>(this, callbackfn);
some(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {
return SOME<Int64Array, i64>(this, fn);
}
every(callbackfn: (value: i64, index: i32, self: Int64Array) => bool): bool {
return EVERY<Int64Array, i64>(this, callbackfn);
every(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {
return EVERY<Int64Array, i64>(this, fn);
}
forEach(callbackfn: (value: i64, index: i32, self: Int64Array) => void): void {
FOREACH<Int64Array, i64>(this, callbackfn);
forEach(fn: (value: i64, index: i32, self: Int64Array) => void): void {
FOREACH<Int64Array, i64>(this, fn);
}
reverse(): this {
@ -703,37 +703,37 @@ export class Uint64Array extends ArrayBufferView {
}
reduce<T>(
callbackfn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,
fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,
initialValue: T,
): T {
return REDUCE<Uint64Array, u64, T>(this, callbackfn, initialValue);
return REDUCE<Uint64Array, u64, T>(this, fn, initialValue);
}
reduceRight<T>(
callbackfn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,
fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,
initialValue: T,
): T {
return REDUCE_RIGHT<Uint64Array, u64, T>(this, callbackfn, initialValue);
return REDUCE_RIGHT<Uint64Array, u64, T>(this, fn, initialValue);
}
map(callbackfn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {
return MAP<Uint64Array, u64>(this, callbackfn);
map(fn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {
return MAP<Uint64Array, u64>(this, fn);
}
findIndex(callbackfn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {
return FIND_INDEX<Uint64Array, u64>(this, callbackfn);
findIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {
return FIND_INDEX<Uint64Array, u64>(this, fn);
}
some(callbackfn: (value: u64, index: i32, self: Uint64Array) => bool): bool {
return SOME<Uint64Array, u64>(this, callbackfn);
some(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {
return SOME<Uint64Array, u64>(this, fn);
}
every(callbackfn: (value: u64, index: i32, self: Uint64Array) => bool): bool {
return EVERY<Uint64Array, u64>(this, callbackfn);
every(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {
return EVERY<Uint64Array, u64>(this, fn);
}
forEach(callbackfn: (value: u64, index: i32, self: Uint64Array) => void): void {
FOREACH<Uint64Array, u64>(this, callbackfn);
forEach(fn: (value: u64, index: i32, self: Uint64Array) => void): void {
FOREACH<Uint64Array, u64>(this, fn);
}
reverse(): this {
@ -785,37 +785,37 @@ export class Float32Array extends ArrayBufferView {
}
reduce<T>(
callbackfn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,
fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,
initialValue: T,
): T {
return REDUCE<Float32Array, f32, T>(this, callbackfn, initialValue);
return REDUCE<Float32Array, f32, T>(this, fn, initialValue);
}
reduceRight<T>(
callbackfn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,
fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,
initialValue: T,
): T {
return REDUCE_RIGHT<Float32Array, f32, T>(this, callbackfn, initialValue);
return REDUCE_RIGHT<Float32Array, f32, T>(this, fn, initialValue);
}
map(callbackfn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {
return MAP<Float32Array, f32>(this, callbackfn);
map(fn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {
return MAP<Float32Array, f32>(this, fn);
}
findIndex(callbackfn: (value: f32, index: i32, self: Float32Array) => bool): i32 {
return FIND_INDEX<Float32Array, f32>(this, callbackfn);
findIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {
return FIND_INDEX<Float32Array, f32>(this, fn);
}
some(callbackfn: (value: f32, index: i32, self: Float32Array) => bool): bool {
return SOME<Float32Array, f32>(this, callbackfn);
some(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {
return SOME<Float32Array, f32>(this, fn);
}
every(callbackfn: (value: f32, index: i32, self: Float32Array) => bool): bool {
return EVERY<Float32Array, f32>(this, callbackfn);
every(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {
return EVERY<Float32Array, f32>(this, fn);
}
forEach(callbackfn: (value: f32, index: i32, self: Float32Array) => void): void {
FOREACH<Float32Array, f32>(this, callbackfn);
forEach(fn: (value: f32, index: i32, self: Float32Array) => void): void {
FOREACH<Float32Array, f32>(this, fn);
}
reverse(): this {
@ -867,37 +867,37 @@ export class Float64Array extends ArrayBufferView {
}
reduce<T>(
callbackfn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,
fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,
initialValue: T,
): T {
return REDUCE<Float64Array, f64, T>(this, callbackfn, initialValue);
return REDUCE<Float64Array, f64, T>(this, fn, initialValue);
}
reduceRight<T>(
callbackfn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,
fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,
initialValue: T,
): T {
return REDUCE_RIGHT<Float64Array, f64, T>(this, callbackfn, initialValue);
return REDUCE_RIGHT<Float64Array, f64, T>(this, fn, initialValue);
}
map(callbackfn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {
return MAP<Float64Array, f64>(this, callbackfn);
map(fn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {
return MAP<Float64Array, f64>(this, fn);
}
findIndex(callbackfn: (value: f64, index: i32, self: Float64Array) => bool): i32 {
return FIND_INDEX<Float64Array, f64>(this, callbackfn);
findIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {
return FIND_INDEX<Float64Array, f64>(this, fn);
}
some(callbackfn: (value: f64, index: i32, self: Float64Array) => bool): bool {
return SOME<Float64Array, f64>(this, callbackfn);
some(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {
return SOME<Float64Array, f64>(this, fn);
}
every(callbackfn: (value: f64, index: i32, self: Float64Array) => bool): bool {
return EVERY<Float64Array, f64>(this, callbackfn);
every(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {
return EVERY<Float64Array, f64>(this, fn);
}
forEach(callbackfn: (value: f64, index: i32, self: Float64Array) => void): void {
FOREACH<Float64Array, f64>(this, callbackfn);
forEach(fn: (value: f64, index: i32, self: Float64Array) => void): void {
FOREACH<Float64Array, f64>(this, fn);
}
reverse(): this {
@ -971,12 +971,12 @@ function SUBARRAY<TArray extends ArrayBufferView, T>(
@inline
function REDUCE<TArray extends ArrayBufferView, T, TRet>(
array: TArray,
callbackfn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,
fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,
initialValue: TRet
): TRet {
var dataStart = array.dataStart;
for (let i = 0, k = array.length; i < k; i++) {
initialValue = callbackfn(initialValue, load<T>(dataStart + (<usize>i << alignof<T>())), i, array);
initialValue = fn(initialValue, load<T>(dataStart + (<usize>i << alignof<T>())), i, array);
}
return initialValue;
}
@ -985,12 +985,12 @@ function REDUCE<TArray extends ArrayBufferView, T, TRet>(
@inline
function REDUCE_RIGHT<TArray extends ArrayBufferView, T, TRet>(
array: TArray,
callbackfn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,
fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,
initialValue: TRet
): TRet {
var dataStart = array.dataStart;
for (let i = array.length - 1; i >= 0; i--) {
initialValue = callbackfn(initialValue, load<T>(dataStart + (<usize>i << alignof<T>())), i, array);
initialValue = fn(initialValue, load<T>(dataStart + (<usize>i << alignof<T>())), i, array);
}
return initialValue;
}
@ -999,7 +999,7 @@ function REDUCE_RIGHT<TArray extends ArrayBufferView, T, TRet>(
@inline
function MAP<TArray extends ArrayBufferView, T>(
array: TArray,
callbackfn: (value: T, index: i32, self: TArray) => T,
fn: (value: T, index: i32, self: TArray) => T,
): TArray {
var length = array.length;
var dataStart = array.dataStart;
@ -1008,7 +1008,7 @@ function MAP<TArray extends ArrayBufferView, T>(
for (let i = 0; i < length; i++) {
store<T>(
outDataStart + (<usize>i << alignof<T>()),
callbackfn(load<T>(dataStart + (<usize>i << alignof<T>())), i, array)
fn(load<T>(dataStart + (<usize>i << alignof<T>())), i, array)
);
}
return out;
@ -1018,11 +1018,11 @@ function MAP<TArray extends ArrayBufferView, T>(
@inline
function FIND_INDEX<TArray extends ArrayBufferView, T>(
array: TArray,
callbackfn: (value: T, index: i32, array: TArray) => bool,
fn: (value: T, index: i32, array: TArray) => bool,
): i32 {
var dataStart = array.dataStart;
for (let i = 0, k = array.length; i < k; i++) {
if (callbackfn(load<T>(dataStart + (<usize>i << alignof<T>())), i, array)) return i;
if (fn(load<T>(dataStart + (<usize>i << alignof<T>())), i, array)) return i;
}
return -1;
}
@ -1031,11 +1031,11 @@ function FIND_INDEX<TArray extends ArrayBufferView, T>(
@inline
function SOME<TArray extends ArrayBufferView, T>(
array: TArray,
callbackfn: (value: T, index: i32, array: TArray) => bool,
fn: (value: T, index: i32, array: TArray) => bool,
): bool {
var dataStart = array.dataStart;
for (let i = 0, k = array.length; i < k; i++) {
if (callbackfn(load<T>(dataStart + (<usize>i << alignof<T>())), i, array)) return true;
if (fn(load<T>(dataStart + (<usize>i << alignof<T>())), i, array)) return true;
}
return false;
}
@ -1044,11 +1044,11 @@ function SOME<TArray extends ArrayBufferView, T>(
@inline
function EVERY<TArray extends ArrayBufferView, T>(
array: TArray,
callbackfn: (value: T, index: i32, array: TArray) => bool,
fn: (value: T, index: i32, array: TArray) => bool,
): bool {
var dataStart = array.dataStart;
for (let i = 0, k = array.length; i < k; i++) {
if (callbackfn(load<T>(dataStart + (<usize>i << alignof<T>())), i, array)) continue;
if (fn(load<T>(dataStart + (<usize>i << alignof<T>())), i, array)) continue;
return false;
}
return true;
@ -1058,11 +1058,11 @@ function EVERY<TArray extends ArrayBufferView, T>(
@inline
function FOREACH<TArray extends ArrayBufferView, T>(
array: TArray,
callbackfn: (value: T, index: i32, array: TArray) => void,
fn: (value: T, index: i32, array: TArray) => void,
): void {
var dataStart = array.dataStart;
for (let i = 0, k = array.length; i < k; i++) {
callbackfn(load<T>(dataStart + (<usize>i << alignof<T>())), i, array);
fn(load<T>(dataStart + (<usize>i << alignof<T>())), i, array);
}
}