diff --git a/static_core/plugins/ets/stdlib/escompat/Array.ets b/static_core/plugins/ets/stdlib/escompat/Array.ets
index 1d135fd6638bc336c283c295fd57df3a7357745f..75e87d56f45604de407420204858e10b28a78cc7 100644
--- a/static_core/plugins/ets/stdlib/escompat/Array.ets
+++ b/static_core/plugins/ets/stdlib/escompat/Array.ets
@@ -862,11 +862,11 @@ export class Array<T> implements ReadonlyArray<T>, Iterable<T> {
      *
      * @returns New `Array` instance constructed from `this` with elements filtered using test function `predicate`.
      */
-    public override filter(predicate: (value: T, index: number, array: Array<T>) => boolean): Array<T> {
+    public override filter(predicate: (value: T, index: int, array: Array<T>) => boolean): Array<T> {
         const res = new Array<T>()
         for (let i: int = 0; i < this.actualLength; i++) {
             const val = this.$_get_unsafe(i)
-            if (predicate(val, i.toDouble(), this)) {
+            if (predicate(val, i, this)) {
                 res.push(val)
             }
         }
@@ -982,7 +982,7 @@ export class Array<T> implements ReadonlyArray<T>, Iterable<T> {
      * @return new Array after map and than flat
      */
     // NOTE(ivan-tyulyandin): TBD, flatMap may be not subset, see ReadonlyArray
-    public flatMap<U>(fn: (v: T, k: number, arr: Array<T>) => U): Array<U> {
+    public flatMap<U>(fn: (v: T, k: int, arr: Array<T>) => U): Array<U> {
         let mapped: Array<U> = this.map<U>(fn)
         return mapped.flat<U>()
     }
@@ -1151,7 +1151,7 @@ export class Array<T> implements ReadonlyArray<T>, Iterable<T> {
      *
      * @returns the value of the first element in the array or undefined
      */
-    public override find(predicate: (value: T, index: number, array: Array<T>) => boolean): T | undefined {
+    public override find(predicate: (value: T, index: int, array: Array<T>) => boolean): T | undefined {
         const res = this.findIndex(predicate)
         if (res == -1) {
             return undefined
@@ -1169,9 +1169,9 @@ export class Array<T> implements ReadonlyArray<T>, Iterable<T> {
      *
      * @returns found element index or -1 otherwise
      */
-    public override findIndex(predicate: (value: T, index: number, array: Array<T>) => boolean): number {
+    public override findIndex(predicate: (value: T, index: int, array: Array<T>) => boolean): number {
         for (let i = 0; i < this.actualLength; i++) {
-            if (predicate(this.$_get_unsafe(i), i.toDouble(), this)) {
+            if (predicate(this.$_get_unsafe(i), i, this)) {
                 return i;
             }
         }
@@ -1186,10 +1186,10 @@ export class Array<T> implements ReadonlyArray<T>, Iterable<T> {
      *
      * @returns found element or undefined otherwise
      */
-    public override findLast(predicate: (elem: T, index: number, array: Array<T>) => boolean): T | undefined {
+    public override findLast(predicate: (elem: T, index: int, array: Array<T>) => boolean): T | undefined {
         for (let i = this.actualLength - 1; i >= 0; i--) {
             const val = this.$_get_unsafe(i);
-            if (predicate(val, i.toDouble(), this)) {
+            if (predicate(val, i, this)) {
                 return val;
             }
         }
@@ -1205,10 +1205,10 @@ export class Array<T> implements ReadonlyArray<T>, Iterable<T> {
      *
      * @returns `true` if `predicate` returns a `true` value for every array element. Otherwise, `false`.
      */
-    public override every(predicate: (value: T, index: number, array: Array<T>) => boolean): boolean {
+    public override every(predicate: (value: T, index: int, array: Array<T>) => boolean): boolean {
         let curArrLength = this.actualLength
         for (let i = 0; i < curArrLength && i < this.actualLength; i++) {
-            if (!predicate(this.$_get_unsafe(i), i.toDouble(), this)) {
+            if (!predicate(this.$_get_unsafe(i), i, this)) {
                 return false
             }
         }
@@ -1224,9 +1224,9 @@ export class Array<T> implements ReadonlyArray<T>, Iterable<T> {
      *
      * @returns `true` if `predicate` returns a `true` value for at least one array element. Otherwise, `false`.
      */
-    public override some(predicate: (value: T, index: number, array: Array<T>) => boolean): boolean {
+    public override some(predicate: (value: T, index: int, array: Array<T>) => boolean): boolean {
         for (let i = 0; i < this.actualLength; i++) {
-            if (predicate(this.$_get_unsafe(i), i.toDouble(), this)) {
+            if (predicate(this.$_get_unsafe(i), i, this)) {
                 return true
             }
         }
@@ -1242,9 +1242,9 @@ export class Array<T> implements ReadonlyArray<T>, Iterable<T> {
      *
      * @returns index of first element satisfying to predicate, -1 if no such element
      */
-    public override findLastIndex(predicate: (element: T, index: number, array: Array<T>) => boolean): number {
+    public override findLastIndex(predicate: (element: T, index: int, array: Array<T>) => boolean): number {
         for (let i = this.actualLength - 1; i >= 0; i--) {
-            if (predicate(this.$_get_unsafe(i), i.toDouble(), this)) {
+            if (predicate(this.$_get_unsafe(i), i, this)) {
                 return i
             }
         }
@@ -1258,13 +1258,13 @@ export class Array<T> implements ReadonlyArray<T>, Iterable<T> {
      *
      * @returns a result after applying callbackfn over all elements of the Array
      */
-    public override reduce(callbackfn: (previousValue: T, currentValue: T, index: number, array: Array<T>) => T): T {
+    public override reduce(callbackfn: (previousValue: T, currentValue: T, index: int, array: Array<T>) => T): T {
         if (this.actualLength == 0) {
             throw new TypeError("Reduce of empty array with no initial value")
         }
         let acc: T = this.$_get_unsafe(0);
         for (let i = 1; i < this.actualLength; i++) {
-            acc = callbackfn(acc, this.$_get_unsafe(i), i.toDouble(), this)
+            acc = callbackfn(acc, this.$_get_unsafe(i), i, this)
         }
         return acc
     }
@@ -1278,10 +1278,10 @@ export class Array<T> implements ReadonlyArray<T>, Iterable<T> {
      *
      * @returns a result after applying callbackfn over all elements of the Array
      */
-    public override reduce<U = T>(callbackfn: (previousValue: U, currentValue: T, index: number, array: Array<T>) => U, initialValue: U): U {
+    public override reduce<U = T>(callbackfn: (previousValue: U, currentValue: T, index: int, array: Array<T>) => U, initialValue: U): U {
         let acc = initialValue
         for (let i = 0; i < this.actualLength; i++) {
-            acc = callbackfn(acc, this.$_get_unsafe(i), i.toDouble(), this)
+            acc = callbackfn(acc, this.$_get_unsafe(i), i, this)
         }
         return acc
     }
@@ -1295,10 +1295,10 @@ export class Array<T> implements ReadonlyArray<T>, Iterable<T> {
      *
      * @returns a result after applying callbackfn over all elements of the Array
      */
-    public override reduceRight<U>(callbackfn: (previousValue: U, currentValue: T, index: number, array: Array<T>) => U, initialValue: U): U {
+    public override reduceRight<U>(callbackfn: (previousValue: U, currentValue: T, index: int, array: Array<T>) => U, initialValue: U): U {
         let acc = initialValue
         for (let i = this.actualLength - 1; i >= 0; i--) {
-            acc = callbackfn(acc, this.$_get_unsafe(i), i.toDouble(), this)
+            acc = callbackfn(acc, this.$_get_unsafe(i), i, this)
         }
         return acc
     }
@@ -1308,13 +1308,13 @@ export class Array<T> implements ReadonlyArray<T>, Iterable<T> {
      *
      * @param callbackfn A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array.
      */
-    public override forEach(callbackfn: (value: T, index: number, array: Array<T>) => void): void {
+    public override forEach(callbackfn: (value: T, index: int, array: Array<T>) => void): void {
         const len0 = this.actualLength;
         for (let i = 0; i < len0; i++) {
             if (i >= this.actualLength) {
                 break
             }
-            callbackfn(this.$_get_unsafe(i), i.toDouble(), this)
+            callbackfn(this.$_get_unsafe(i), i, this)
         }
     }
 
@@ -1778,11 +1778,11 @@ export class Array<T> implements ReadonlyArray<T>, Iterable<T> {
      *
      * @returns `Array` instance, constructed from `this` and given function.
      */
-    public override map<U>(callbackfn: (value: T, index: number, array: Array<T>) => U): Array<U> {
+    public override map<U>(callbackfn: (value: T, index: int, array: Array<T>) => U): Array<U> {
         const len = this.actualLength;
         let res : FixedArray<Any> = new Any[len];
         for (let i = 0; i < this.actualLength; i++) {
-            res[i] = callbackfn(this.$_get_unsafe(i), i.toDouble(), this);
+            res[i] = callbackfn(this.$_get_unsafe(i), i, this);
         }
         return new Array<U>(FROM_BUFFER, res);
     }
@@ -1794,14 +1794,14 @@ export class Array<T> implements ReadonlyArray<T>, Iterable<T> {
      *
      * @returns a result after applying callbackfn over all elements of the Array
      */
-    public override reduceRight(callbackfn: (previousValue: T, currentValue: T, index: number, array: Array<T>) => T): T {
+    public override reduceRight(callbackfn: (previousValue: T, currentValue: T, index: int, array: Array<T>) => T): T {
         if (this.actualLength == 0) {
             throw new TypeError("Reduce of empty array with no initial value")
         }
         let acc: T = this.$_get_unsafe(this.actualLength - 1);
         for (let i = this.actualLength - 2; i >= 0; i--) {
             if (this.actualLength > i) {
-                acc = callbackfn(acc, this.$_get_unsafe(i), i.toDouble(), this)
+                acc = callbackfn(acc, this.$_get_unsafe(i), i, this)
             }
         }
         return acc
diff --git a/static_core/plugins/ets/stdlib/escompat/ReadonlyArray.ets b/static_core/plugins/ets/stdlib/escompat/ReadonlyArray.ets
index fea81ac9a95381ae69729215583ecb61108ebcaf..155fb8ef24273ec2f273bb96de26929b07d19484 100644
--- a/static_core/plugins/ets/stdlib/escompat/ReadonlyArray.ets
+++ b/static_core/plugins/ets/stdlib/escompat/ReadonlyArray.ets
@@ -23,17 +23,17 @@ export interface ReadonlyArray<out T> extends ConcatArray<T> {
 
     entries(): IterableIterator<[number, T]>;
 
-    every(predicate: (value: T, index: number, array: ReadonlyArray<T>) => boolean): boolean;
+    every(predicate: (value: T, index: int, array: ReadonlyArray<T>) => boolean): boolean;
 
-    filter(predicate: (value: T, index: number, array: ReadonlyArray<T>) => boolean): Array<T>;
+    filter(predicate: (value: T, index: int, array: ReadonlyArray<T>) => boolean): Array<T>;
 
-    find(predicate: (value: T, index: number, obj: ReadonlyArray<T>) => boolean): T | undefined;
+    find(predicate: (value: T, index: int, obj: ReadonlyArray<T>) => boolean): T | undefined;
 
-    findLast(predicate: (value: T, index: number, obj: ReadonlyArray<T>) => boolean): T | undefined;
+    findLast(predicate: (value: T, index: int, obj: ReadonlyArray<T>) => boolean): T | undefined;
 
-    findIndex(predicate: (value: T, index: number, obj: ReadonlyArray<T>) => boolean): number;
+    findIndex(predicate: (value: T, index: int, obj: ReadonlyArray<T>) => boolean): number;
 
-    findLastIndex(predicate: (value: T, index: number, obj: ReadonlyArray<T>) => boolean): number;
+    findLastIndex(predicate: (value: T, index: int, obj: ReadonlyArray<T>) => boolean): number;
 
     // NOTE(ivan-tyulyandin): TBD, FlatArray is non-subset type
     // flat<A, D extends number = 1>(
@@ -47,7 +47,7 @@ export interface ReadonlyArray<out T> extends ConcatArray<T> {
     //     thisArg?: This,
     // ): U[];
 
-    forEach(action: (value: T, index: number, array: ReadonlyArray<T>) => void): void;
+    forEach(action: (value: T, index: int, array: ReadonlyArray<T>) => void): void;
 
     join(separator?: string): string;
 
@@ -59,19 +59,19 @@ export interface ReadonlyArray<out T> extends ConcatArray<T> {
 
     lastIndexOf(searchElement: T, fromIndex?: int): int;
 
-    map<U>(mapper: (value: T, index: number, array: ReadonlyArray<T>) => U): Array<U>;
+    map<U>(mapper: (value: T, index: int, array: ReadonlyArray<T>) => U): Array<U>;
 
-    reduce(reducer: (previousValue: T, currentValue: T, currentIndex: number, array: ReadonlyArray<T>) => T): T;
+    reduce(reducer: (previousValue: T, currentValue: T, currentIndex: int, array: ReadonlyArray<T>) => T): T;
 
-    reduce<U>(reducer: (previousValue: U, currentValue: T, currentIndex: number, array: ReadonlyArray<T>) => U, initialValue: U): U;
+    reduce<U>(reducer: (previousValue: U, currentValue: T, currentIndex: int, array: ReadonlyArray<T>) => U, initialValue: U): U;
 
-    reduceRight(reducer: (previousValue: T, currentValue: T, currentIndex: number, array: ReadonlyArray<T>) => T): T;
+    reduceRight(reducer: (previousValue: T, currentValue: T, currentIndex: int, array: ReadonlyArray<T>) => T): T;
 
-    reduceRight<U>(reducer: (previousValue: U, currentValue: T, currentIndex: number, array: ReadonlyArray<T>) => U, initialValue: U): U;
+    reduceRight<U>(reducer: (previousValue: U, currentValue: T, currentIndex: int, array: ReadonlyArray<T>) => U, initialValue: U): U;
 
     slice(start?: number, end?: number): Array<T>;
 
-    some(predicate: (value: T, index: number, array: ReadonlyArray<T>) => boolean): boolean;
+    some(predicate: (value: T, index: int, array: ReadonlyArray<T>) => boolean): boolean;
 
     // toLocaleString(): string;
     // All objects in ArkTS have such method, no need to define it here
diff --git a/static_core/plugins/ets/stdlib/escompat/RegExp.ets b/static_core/plugins/ets/stdlib/escompat/RegExp.ets
index 7d176d9d27a492f211c9cce20c2213df5e20f88b..59122da2560fc814862e9a56b13ba3e60d5d33ab 100644
--- a/static_core/plugins/ets/stdlib/escompat/RegExp.ets
+++ b/static_core/plugins/ets/stdlib/escompat/RegExp.ets
@@ -327,7 +327,7 @@ export class RegExpResultArray /*extends Array<String>*/ {
      * Returns elements that meet the condition specified in a callback function.
      */
     public filter(predicate: (value: String, index: number, array: RegExpResultArray) => boolean): Array<String> {
-        return this.result_.filter((value: String, index: number, array: Array<String>) => {
+        return this.result_.filter((value: String, index: int, array: Array<String>) => {
             return predicate(value, index, this)
         })
     }
@@ -336,7 +336,7 @@ export class RegExpResultArray /*extends Array<String>*/ {
      * Returns the value of the first element where predicate is true.
      */
     public find(predicate: (value: String, index: number, array: RegExpResultArray) => boolean): String | undefined {
-        return this.result_.find((value: String, index: number, array: Array<String>) => {
+        return this.result_.find((value: String, index: int, array: Array<String>) => {
             return predicate(value, index, this)
         })
     }
@@ -345,7 +345,7 @@ export class RegExpResultArray /*extends Array<String>*/ {
      * Returns the index of the first element where predicate is true.
      */
     public findIndex(predicate: (value: String, index: number, array: RegExpResultArray) => boolean): number {
-        return this.result_.findIndex((value: String, index: number, array: Array<String>) => {
+        return this.result_.findIndex((value: String, index: int, array: Array<String>) => {
             return predicate(value, index, this)
         })
     }
@@ -354,7 +354,7 @@ export class RegExpResultArray /*extends Array<String>*/ {
      * Returns the value of the last element that satisfies the testing function.
      */
     public findLast(predicate: (elem: String, index: number, array: RegExpResultArray) => boolean): String | undefined {
-        return this.result_.findLast((elem: String, index: number, array: Array<String>) => {
+        return this.result_.findLast((elem: String, index: int, array: Array<String>) => {
             return predicate(elem, index, this)
         })
     }
@@ -363,7 +363,7 @@ export class RegExpResultArray /*extends Array<String>*/ {
      * Returns the index of the last element that satisfies the testing function.
      */
     public findLastIndex(predicate: (element: String, index: number, array: RegExpResultArray) => boolean): number {
-        return this.result_.findLastIndex((element: String, index: number, array: Array<String>) => {
+        return this.result_.findLastIndex((element: String, index: int, array: Array<String>) => {
             return predicate(element, index, this)
         })
     }
@@ -393,7 +393,7 @@ export class RegExpResultArray /*extends Array<String>*/ {
      * Applies flat and then map.
      */
     public flatMap<U>(fn: (v: String, k: number, arr: RegExpResultArray) => U): Array<U> {
-        return this.result_.flatMap<U>((v: String, k: number, arr: Array<String>) => {
+        return this.result_.flatMap<U>((v: String, k: int, arr: Array<String>) => {
             return fn(v, k, this)
         })
     }
@@ -402,7 +402,7 @@ export class RegExpResultArray /*extends Array<String>*/ {
      * Determines whether all members satisfy the specified test.
      */
     public every(predicate: (value: String, index: number, array: RegExpResultArray) => boolean): boolean {
-        return this.result_.every((value: String, index: number, array: Array<String>) => {
+        return this.result_.every((value: String, index: int, array: Array<String>) => {
             return predicate(value, index, this)
         })
     }
@@ -411,7 +411,7 @@ export class RegExpResultArray /*extends Array<String>*/ {
      * Determines whether any element satisfies the specified test.
      */
     public some(predicate: (value: String, index: number, array: RegExpResultArray) => boolean): boolean {
-        return this.result_.some((value: String, index: number, array: Array<String>) => {
+        return this.result_.some((value: String, index: int, array: Array<String>) => {
             return predicate(value, index, this)
         })
     }
@@ -420,7 +420,7 @@ export class RegExpResultArray /*extends Array<String>*/ {
      * Calls the callback function for all elements and accumulates the result.
      */
     public reduce(callbackfn: (previousValue: String, currentValue: String, index: number, array: RegExpResultArray) => String): String {
-        return this.result_.reduce((previousValue: String, currentValue: String, index: number, array: Array<String>) => {
+        return this.result_.reduce((previousValue: String, currentValue: String, index: int, array: Array<String>) => {
             return callbackfn(previousValue, currentValue, index, this)
         })
     }
@@ -429,7 +429,7 @@ export class RegExpResultArray /*extends Array<String>*/ {
      * Calls the callback function for all elements and accumulates the result.
      */
     public reduce<U = String>(callbackfn: (previousValue: U, currentValue: String, index: number, array: RegExpResultArray) => U, initialValue: U): U {
-        return this.result_.reduce<U>((previousValue: U, currentValue: String, index: number, array: Array<String>) => {
+        return this.result_.reduce<U>((previousValue: U, currentValue: String, index: int, array: Array<String>) => {
             return callbackfn(previousValue, currentValue, index, this)
         }, initialValue)
     }
@@ -438,7 +438,7 @@ export class RegExpResultArray /*extends Array<String>*/ {
      * Calls the callback function for all elements in descending order and accumulates the result.
      */
     public reduceRight<U>(callbackfn: (previousValue: U, currentValue: String, index: number, array: RegExpResultArray) => U, initialValue: U): U {
-        return this.result_.reduceRight<U>((previousValue: U, currentValue: String, index: number, array: Array<String>) => {
+        return this.result_.reduceRight<U>((previousValue: U, currentValue: String, index: int, array: Array<String>) => {
             return callbackfn(previousValue, currentValue, index, this)
         }, initialValue)
     }
@@ -447,7 +447,7 @@ export class RegExpResultArray /*extends Array<String>*/ {
      * Calls the callback function for all elements in descending order and accumulates the result.
      */
     public reduceRight(callbackfn: (previousValue: String, currentValue: String, index: number, array: RegExpResultArray) => String): String {
-        return this.result_.reduceRight((previousValue: String, currentValue: String, index: number, array: Array<String>) => {
+        return this.result_.reduceRight((previousValue: String, currentValue: String, index: int, array: Array<String>) => {
             return callbackfn(previousValue, currentValue, index, this)
         })
     }
@@ -456,7 +456,7 @@ export class RegExpResultArray /*extends Array<String>*/ {
      * Performs the specified action for each element.
      */
     public forEach(callbackfn: (value: String, index: number, array: RegExpResultArray) => void): void {
-        this.result_.forEach((value: String, index: number, array: Array<String>) => {
+        this.result_.forEach((value: String, index: int, array: Array<String>) => {
             callbackfn(value, index, this)
         })
     }
@@ -720,7 +720,7 @@ export class RegExpResultArray /*extends Array<String>*/ {
      * Calls a callback function on each element and returns an array with the results.
      */
     public map<U>(callbackfn: (value: String, index: number, array: RegExpResultArray) => U): Array<U> {
-        return this.result_.map<U>((value: String, index: number, array: Array<String>) => {
+        return this.result_.map<U>((value: String, index: int, array: Array<String>) => {
             return callbackfn(value, index, this)
         })
     }
diff --git a/static_core/plugins/ets/stdlib/escompat/json.ets b/static_core/plugins/ets/stdlib/escompat/json.ets
index f1edd9ea51b14a181a44ab3c993bf33aa24ba75c..b1b37e04791a292cb3608699940ea606ea6e2664 100644
--- a/static_core/plugins/ets/stdlib/escompat/json.ets
+++ b/static_core/plugins/ets/stdlib/escompat/json.ets
@@ -1070,13 +1070,11 @@ class JSONWriter {
     }
 
     private checkSameRename(field: Field, fields: Array<[Field, reflect.Value]>): boolean {
-        return fields.some((value: [Field, reflect.Value], index: number, array:Array<[Field, reflect.Value]>)
-            => {return value[0].getName() == field.getName()});
+        return fields.some((value, index, array) => value[0].getName() == field.getName());
     }
 
     private findKeyIndex(field: Field, fields: Array<[Field, reflect.Value]>): number {
-        return fields.findIndex((value: [Field, reflect.Value], index: number, array:Array<[Field, reflect.Value]>)
-            => {return value[0].getName() == field.getName()});
+        return fields.findIndex((value, index, array) => value[0].getName() == field.getName());
     }
 
     private getWritableFields(classType: ClassType, classValue: ClassValue): Array<[Field, reflect.Value]> {
diff --git a/static_core/plugins/ets/stdlib/escompat/taskpool.ets b/static_core/plugins/ets/stdlib/escompat/taskpool.ets
index b8a0048c108f5ef3d1ec2cb0d729ab20b1830165..3265a567a9230ed9f9c99dd80756509ece7b612a 100644
--- a/static_core/plugins/ets/stdlib/escompat/taskpool.ets
+++ b/static_core/plugins/ets/stdlib/escompat/taskpool.ets
@@ -1340,10 +1340,10 @@ export namespace taskpool {
         const Info: TaskPoolInfo = new TaskPoolInfo();
         const taskInfosRes: TaskInfo[] = new TaskInfo[taskInfos.length.toInt()];
         const threadInfosRes: ThreadInfo[] = new ThreadInfo[threadInfos.length.toInt()];
-        taskInfos.forEach((taskInfo: TaskInfo, index: number) => {
+        taskInfos.forEach((taskInfo: TaskInfo, index: int) => {
             taskInfosRes[index.toInt()] = taskInfo;
         });
-        threadInfos.forEach((threadInfo: ThreadInfo, index: number) => {
+        threadInfos.forEach((threadInfo: ThreadInfo, index: int) => {
             threadInfosRes[index.toInt()] = threadInfo;
         });
         Info.taskInfos = taskInfosRes;
diff --git a/static_core/plugins/ets/stdlib/std/core/BuiltinArray.ets b/static_core/plugins/ets/stdlib/std/core/BuiltinArray.ets
index 2816b2e2fd845f5c326b0d945ed230c07fc016e9..7fd159f004d9193ba2c2d50a2a68c77ab974af67 100644
--- a/static_core/plugins/ets/stdlib/std/core/BuiltinArray.ets
+++ b/static_core/plugins/ets/stdlib/std/core/BuiltinArray.ets
@@ -251,7 +251,7 @@ export function fill(self: FixedArray<boolean>, value: boolean, start: int, end:
  *
  * @returns the value of the first element in the array or undefined
  */
-export function find(self: FixedArray<boolean>, predicate: (value: boolean, index: number, array: FixedArray<boolean>) => boolean): Boolean | undefined {
+export function find(self: FixedArray<boolean>, predicate: (value: boolean, index: int, array: FixedArray<boolean>) => boolean): Boolean | undefined {
     const res = findIndex(self, predicate)
     if (res == -1) {
         return undefined
@@ -269,9 +269,9 @@ export function find(self: FixedArray<boolean>, predicate: (value: boolean, inde
  *
  * @returns found element index or -1 otherwise
  */
-export function findIndex(self: FixedArray<boolean>, predicate: (value: boolean, index: number, array: FixedArray<boolean>) => boolean): number {
+export function findIndex(self: FixedArray<boolean>, predicate: (value: boolean, index: int, array: FixedArray<boolean>) => boolean): number {
     for (let i = 0; i < self.length; i++) {
-        if (predicate(self[i], i.toDouble(), self)) {
+        if (predicate(self[i], i, self)) {
             return i;
         }
     }
@@ -286,10 +286,10 @@ export function findIndex(self: FixedArray<boolean>, predicate: (value: boolean,
  *
  * @returns found element or undefined otherwise
  */
-export function findLast(self: FixedArray<boolean>, predicate: (elem: boolean, index: number, array: FixedArray<boolean>) => boolean): Boolean | undefined {
+export function findLast(self: FixedArray<boolean>, predicate: (elem: boolean, index: int, array: FixedArray<boolean>) => boolean): Boolean | undefined {
     for (let i = self.length - 1; i >= 0; i--) {
         const val = self[i];
-        if (predicate(val, i.toDouble(), self)) {
+        if (predicate(val, i, self)) {
             return val;
         }
     }
@@ -305,9 +305,9 @@ export function findLast(self: FixedArray<boolean>, predicate: (elem: boolean, i
  *
  * @returns `true` if `predicate` returns a `true` value for every array element. Otherwise, `false`.
  */
-export function every(self: FixedArray<boolean>, predicate: (value: boolean, index: number, array: FixedArray<boolean>) => boolean): boolean {
+export function every(self: FixedArray<boolean>, predicate: (value: boolean, index: int, array: FixedArray<boolean>) => boolean): boolean {
     for (let i = 0; i < self.length; i++) {
-        if (!predicate(self[i], i.toDouble(), self)) {
+        if (!predicate(self[i], i, self)) {
             return false
         }
     }
@@ -323,9 +323,9 @@ export function every(self: FixedArray<boolean>, predicate: (value: boolean, ind
  *
  * @returns `true` if `predicate` returns a `true` value for at least one array element. Otherwise, `false`.
  */
-export function some(self: FixedArray<boolean>, predicate: (value: boolean, index: number, array: FixedArray<boolean>) => boolean): boolean {
+export function some(self: FixedArray<boolean>, predicate: (value: boolean, index: int, array: FixedArray<boolean>) => boolean): boolean {
     for (let i = 0; i < self.length; i++) {
-        if (predicate(self[i], i.toDouble(), self)) {
+        if (predicate(self[i], i, self)) {
             return true
         }
     }
@@ -341,9 +341,9 @@ export function some(self: FixedArray<boolean>, predicate: (value: boolean, inde
  *
  * @returns index of first element satisfying to predicate, -1 if no such element
  */
-export function findLastIndex(self: FixedArray<boolean>, predicate: (element: boolean, index: number, array: FixedArray<boolean>) => boolean): number {
+export function findLastIndex(self: FixedArray<boolean>, predicate: (element: boolean, index: int, array: FixedArray<boolean>) => boolean): number {
     for (let i = self.length - 1; i >= 0; i--) {
-        if (predicate(self[i], i.toDouble(), self)) {
+        if (predicate(self[i], i, self)) {
             return i
         }
     }
@@ -357,13 +357,13 @@ export function findLastIndex(self: FixedArray<boolean>, predicate: (element: bo
  *
  * @returns a result after applying callbackfn over all elements of the Array
  */
-export function reduce(self: FixedArray<boolean>, callbackfn: (previousValue: boolean, currentValue: boolean, index: number, array: FixedArray<boolean>) => boolean): boolean {
+export function reduce(self: FixedArray<boolean>, callbackfn: (previousValue: boolean, currentValue: boolean, index: int, array: FixedArray<boolean>) => boolean): boolean {
     if (self.length == 0) {
         throw new TypeError("Reduce of empty array with no initial value")
     }
     let acc: boolean = self[0];
     for (let i = 1; i < self.length; i++) {
-        acc = callbackfn(acc, self[i], i.toDouble(), self)
+        acc = callbackfn(acc, self[i], i, self)
     }
     return acc
 }
@@ -377,10 +377,10 @@ export function reduce(self: FixedArray<boolean>, callbackfn: (previousValue: bo
  *
  * @returns a result after applying callbackfn over all elements of the Array
  */
-export function reduce<U = boolean>(self: FixedArray<boolean>, callbackfn: (previousValue: U, currentValue: boolean, index: number, array: FixedArray<boolean>) => U, initialValue: U): U {
+export function reduce<U = boolean>(self: FixedArray<boolean>, callbackfn: (previousValue: U, currentValue: boolean, index: int, array: FixedArray<boolean>) => U, initialValue: U): U {
     let acc = initialValue
     for (let i = 0; i < self.length; i++) {
-        acc = callbackfn(acc, self[i], i.toDouble(), self)
+        acc = callbackfn(acc, self[i], i, self)
     }
     return acc
 }
@@ -394,10 +394,10 @@ export function reduce<U = boolean>(self: FixedArray<boolean>, callbackfn: (prev
  *
  * @returns a result after applying callbackfn over all elements of the Array
  */
-export function reduceRight<U>(self: FixedArray<boolean>, callbackfn: (previousValue: U, currentValue: boolean, index: number, array: FixedArray<boolean>) => U, initialValue: U): U {
+export function reduceRight<U>(self: FixedArray<boolean>, callbackfn: (previousValue: U, currentValue: boolean, index: int, array: FixedArray<boolean>) => U, initialValue: U): U {
     let acc = initialValue
     for (let i = self.length - 1; i >= 0; i--) {
-        acc = callbackfn(acc, self[i], i.toDouble(), self)
+        acc = callbackfn(acc, self[i], i, self)
     }
     return acc
 }
@@ -407,13 +407,13 @@ export function reduceRight<U>(self: FixedArray<boolean>, callbackfn: (previousV
  *
  * @param callbackfn A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array.
  */
-export function forEach(self: FixedArray<boolean>, callbackfn: (value: boolean, index: number, array: FixedArray<boolean>) => void): void {
+export function forEach(self: FixedArray<boolean>, callbackfn: (value: boolean, index: int, array: FixedArray<boolean>) => void): void {
     const len0 = self.length;
     for (let i = 0; i < len0; i++) {
         if (i >= self.length) {
             break
         }
-        callbackfn(self[i], i.toDouble(), self)
+        callbackfn(self[i], i, self)
     }
 }
 
@@ -805,11 +805,11 @@ export function entries(self: FixedArray<boolean>): IterableIterator<[number, bo
  *
  * @returns `Array` instance, constructed from `this` and given function.
  */
-export function map(self: FixedArray<boolean>, callbackfn: (value: boolean, index: number, array: FixedArray<boolean>) => boolean): FixedArray<boolean> {
+export function map(self: FixedArray<boolean>, callbackfn: (value: boolean, index: int, array: FixedArray<boolean>) => boolean): FixedArray<boolean> {
     const len = self.length;
     let res : FixedArray<boolean> = new boolean[len];
     for (let i = 0; i < len; i++) {
-        res[i] = callbackfn(self[i], i.toDouble(), self);
+        res[i] = callbackfn(self[i], i, self);
     }
     return res;
 }
@@ -821,13 +821,13 @@ export function map(self: FixedArray<boolean>, callbackfn: (value: boolean, inde
  *
  * @returns a result after applying callbackfn over all elements of the Array
  */
-export function reduceRight(self: FixedArray<boolean>, callbackfn: (previousValue: boolean, currentValue: boolean, index: number, array: FixedArray<boolean>) => boolean): boolean {
+export function reduceRight(self: FixedArray<boolean>, callbackfn: (previousValue: boolean, currentValue: boolean, index: int, array: FixedArray<boolean>) => boolean): boolean {
     if (self.length == 0) {
         throw new TypeError("Reduce of empty array with no initial value")
     }
     let acc: boolean = self[self.length - 1];
     for (let i = self.length - 2; i >= 0; i--) {
-        acc = callbackfn(acc, self[i], i.toDouble(), self)
+        acc = callbackfn(acc, self[i], i, self)
     }
     return acc
 }
@@ -1177,7 +1177,7 @@ export function fill(self: FixedArray<byte>, value: byte, start: int, end: int):
  *
  * @returns the value of the first element in the array or undefined
  */
-export function find(self: FixedArray<byte>, predicate: (value: byte, index: number, array: FixedArray<byte>) => boolean): Byte | undefined {
+export function find(self: FixedArray<byte>, predicate: (value: byte, index: int, array: FixedArray<byte>) => boolean): Byte | undefined {
     const res = findIndex(self, predicate)
     if (res == -1) {
         return undefined
@@ -1195,9 +1195,9 @@ export function find(self: FixedArray<byte>, predicate: (value: byte, index: num
  *
  * @returns found element index or -1 otherwise
  */
-export function findIndex(self: FixedArray<byte>, predicate: (value: byte, index: number, array: FixedArray<byte>) => boolean): number {
+export function findIndex(self: FixedArray<byte>, predicate: (value: byte, index: int, array: FixedArray<byte>) => boolean): number {
     for (let i = 0; i < self.length; i++) {
-        if (predicate(self[i], i.toDouble(), self)) {
+        if (predicate(self[i], i, self)) {
             return i;
         }
     }
@@ -1212,10 +1212,10 @@ export function findIndex(self: FixedArray<byte>, predicate: (value: byte, index
  *
  * @returns found element or undefined otherwise
  */
-export function findLast(self: FixedArray<byte>, predicate: (elem: byte, index: number, array: FixedArray<byte>) => boolean): Byte | undefined {
+export function findLast(self: FixedArray<byte>, predicate: (elem: byte, index: int, array: FixedArray<byte>) => boolean): Byte | undefined {
     for (let i = self.length - 1; i >= 0; i--) {
         const val = self[i];
-        if (predicate(val, i.toDouble(), self)) {
+        if (predicate(val, i, self)) {
             return val;
         }
     }
@@ -1231,9 +1231,9 @@ export function findLast(self: FixedArray<byte>, predicate: (elem: byte, index:
  *
  * @returns `true` if `predicate` returns a `true` value for every array element. Otherwise, `false`.
  */
-export function every(self: FixedArray<byte>, predicate: (value: byte, index: number, array: FixedArray<byte>) => boolean): boolean {
+export function every(self: FixedArray<byte>, predicate: (value: byte, index: int, array: FixedArray<byte>) => boolean): boolean {
     for (let i = 0; i < self.length; i++) {
-        if (!predicate(self[i], i.toDouble(), self)) {
+        if (!predicate(self[i], i, self)) {
             return false
         }
     }
@@ -1249,9 +1249,9 @@ export function every(self: FixedArray<byte>, predicate: (value: byte, index: nu
  *
  * @returns `true` if `predicate` returns a `true` value for at least one array element. Otherwise, `false`.
  */
-export function some(self: FixedArray<byte>, predicate: (value: byte, index: number, array: FixedArray<byte>) => boolean): boolean {
+export function some(self: FixedArray<byte>, predicate: (value: byte, index: int, array: FixedArray<byte>) => boolean): boolean {
     for (let i = 0; i < self.length; i++) {
-        if (predicate(self[i], i.toDouble(), self)) {
+        if (predicate(self[i], i, self)) {
             return true
         }
     }
@@ -1267,9 +1267,9 @@ export function some(self: FixedArray<byte>, predicate: (value: byte, index: num
  *
  * @returns index of first element satisfying to predicate, -1 if no such element
  */
-export function findLastIndex(self: FixedArray<byte>, predicate: (element: byte, index: number, array: FixedArray<byte>) => boolean): number {
+export function findLastIndex(self: FixedArray<byte>, predicate: (element: byte, index: int, array: FixedArray<byte>) => boolean): number {
     for (let i = self.length - 1; i >= 0; i--) {
-        if (predicate(self[i], i.toDouble(), self)) {
+        if (predicate(self[i], i, self)) {
             return i
         }
     }
@@ -1283,13 +1283,13 @@ export function findLastIndex(self: FixedArray<byte>, predicate: (element: byte,
  *
  * @returns a result after applying callbackfn over all elements of the Array
  */
-export function reduce(self: FixedArray<byte>, callbackfn: (previousValue: byte, currentValue: byte, index: number, array: FixedArray<byte>) => byte): byte {
+export function reduce(self: FixedArray<byte>, callbackfn: (previousValue: byte, currentValue: byte, index: int, array: FixedArray<byte>) => byte): byte {
     if (self.length == 0) {
         throw new TypeError("Reduce of empty array with no initial value")
     }
     let acc: byte = self[0];
     for (let i = 1; i < self.length; i++) {
-        acc = callbackfn(acc, self[i], i.toDouble(), self)
+        acc = callbackfn(acc, self[i], i, self)
     }
     return acc
 }
@@ -1303,10 +1303,10 @@ export function reduce(self: FixedArray<byte>, callbackfn: (previousValue: byte,
  *
  * @returns a result after applying callbackfn over all elements of the Array
  */
-export function reduce<U = byte>(self: FixedArray<byte>, callbackfn: (previousValue: U, currentValue: byte, index: number, array: FixedArray<byte>) => U, initialValue: U): U {
+export function reduce<U = byte>(self: FixedArray<byte>, callbackfn: (previousValue: U, currentValue: byte, index: int, array: FixedArray<byte>) => U, initialValue: U): U {
     let acc = initialValue
     for (let i = 0; i < self.length; i++) {
-        acc = callbackfn(acc, self[i], i.toDouble(), self)
+        acc = callbackfn(acc, self[i], i, self)
     }
     return acc
 }
@@ -1320,10 +1320,10 @@ export function reduce<U = byte>(self: FixedArray<byte>, callbackfn: (previousVa
  *
  * @returns a result after applying callbackfn over all elements of the Array
  */
-export function reduceRight<U>(self: FixedArray<byte>, callbackfn: (previousValue: U, currentValue: byte, index: number, array: FixedArray<byte>) => U, initialValue: U): U {
+export function reduceRight<U>(self: FixedArray<byte>, callbackfn: (previousValue: U, currentValue: byte, index: int, array: FixedArray<byte>) => U, initialValue: U): U {
     let acc = initialValue
     for (let i = self.length - 1; i >= 0; i--) {
-        acc = callbackfn(acc, self[i], i.toDouble(), self)
+        acc = callbackfn(acc, self[i], i, self)
     }
     return acc
 }
@@ -1333,13 +1333,13 @@ export function reduceRight<U>(self: FixedArray<byte>, callbackfn: (previousValu
  *
  * @param callbackfn A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array.
  */
-export function forEach(self: FixedArray<byte>, callbackfn: (value: byte, index: number, array: FixedArray<byte>) => void): void {
+export function forEach(self: FixedArray<byte>, callbackfn: (value: byte, index: int, array: FixedArray<byte>) => void): void {
     const len0 = self.length;
     for (let i = 0; i < len0; i++) {
         if (i >= self.length) {
             break
         }
-        callbackfn(self[i], i.toDouble(), self)
+        callbackfn(self[i], i, self)
     }
 }
 
@@ -1731,11 +1731,11 @@ export function entries(self: FixedArray<byte>): IterableIterator<[number, byte]
  *
  * @returns `Array` instance, constructed from `this` and given function.
  */
-export function map(self: FixedArray<byte>, callbackfn: (value: byte, index: number, array: FixedArray<byte>) => byte): FixedArray<byte> {
+export function map(self: FixedArray<byte>, callbackfn: (value: byte, index: int, array: FixedArray<byte>) => byte): FixedArray<byte> {
     const len = self.length;
     let res : FixedArray<byte> = new byte[len];
     for (let i = 0; i < len; i++) {
-        res[i] = callbackfn(self[i], i.toDouble(), self);
+        res[i] = callbackfn(self[i], i, self);
     }
     return res;
 }
@@ -1747,13 +1747,13 @@ export function map(self: FixedArray<byte>, callbackfn: (value: byte, index: num
  *
  * @returns a result after applying callbackfn over all elements of the Array
  */
-export function reduceRight(self: FixedArray<byte>, callbackfn: (previousValue: byte, currentValue: byte, index: number, array: FixedArray<byte>) => byte): byte {
+export function reduceRight(self: FixedArray<byte>, callbackfn: (previousValue: byte, currentValue: byte, index: int, array: FixedArray<byte>) => byte): byte {
     if (self.length == 0) {
         throw new TypeError("Reduce of empty array with no initial value")
     }
     let acc: byte = self[self.length - 1];
     for (let i = self.length - 2; i >= 0; i--) {
-        acc = callbackfn(acc, self[i], i.toDouble(), self)
+        acc = callbackfn(acc, self[i], i, self)
     }
     return acc
 }
@@ -2103,7 +2103,7 @@ export function fill(self: FixedArray<short>, value: short, start: int, end: int
  *
  * @returns the value of the first element in the array or undefined
  */
-export function find(self: FixedArray<short>, predicate: (value: short, index: number, array: FixedArray<short>) => boolean): Short | undefined {
+export function find(self: FixedArray<short>, predicate: (value: short, index: int, array: FixedArray<short>) => boolean): Short | undefined {
     const res = findIndex(self, predicate)
     if (res == -1) {
         return undefined
@@ -2121,9 +2121,9 @@ export function find(self: FixedArray<short>, predicate: (value: short, index: n
  *
  * @returns found element index or -1 otherwise
  */
-export function findIndex(self: FixedArray<short>, predicate: (value: short, index: number, array: FixedArray<short>) => boolean): number {
+export function findIndex(self: FixedArray<short>, predicate: (value: short, index: int, array: FixedArray<short>) => boolean): number {
     for (let i = 0; i < self.length; i++) {
-        if (predicate(self[i], i.toDouble(), self)) {
+        if (predicate(self[i], i, self)) {
             return i;
         }
     }
@@ -2138,10 +2138,10 @@ export function findIndex(self: FixedArray<short>, predicate: (value: short, ind
  *
  * @returns found element or undefined otherwise
  */
-export function findLast(self: FixedArray<short>, predicate: (elem: short, index: number, array: FixedArray<short>) => boolean): Short | undefined {
+export function findLast(self: FixedArray<short>, predicate: (elem: short, index: int, array: FixedArray<short>) => boolean): Short | undefined {
     for (let i = self.length - 1; i >= 0; i--) {
         const val = self[i];
-        if (predicate(val, i.toDouble(), self)) {
+        if (predicate(val, i, self)) {
             return val;
         }
     }
@@ -2157,9 +2157,9 @@ export function findLast(self: FixedArray<short>, predicate: (elem: short, index
  *
  * @returns `true` if `predicate` returns a `true` value for every array element. Otherwise, `false`.
  */
-export function every(self: FixedArray<short>, predicate: (value: short, index: number, array: FixedArray<short>) => boolean): boolean {
+export function every(self: FixedArray<short>, predicate: (value: short, index: int, array: FixedArray<short>) => boolean): boolean {
     for (let i = 0; i < self.length; i++) {
-        if (!predicate(self[i], i.toDouble(), self)) {
+        if (!predicate(self[i], i, self)) {
             return false
         }
     }
@@ -2175,9 +2175,9 @@ export function every(self: FixedArray<short>, predicate: (value: short, index:
  *
  * @returns `true` if `predicate` returns a `true` value for at least one array element. Otherwise, `false`.
  */
-export function some(self: FixedArray<short>, predicate: (value: short, index: number, array: FixedArray<short>) => boolean): boolean {
+export function some(self: FixedArray<short>, predicate: (value: short, index: int, array: FixedArray<short>) => boolean): boolean {
     for (let i = 0; i < self.length; i++) {
-        if (predicate(self[i], i.toDouble(), self)) {
+        if (predicate(self[i], i, self)) {
             return true
         }
     }
@@ -2193,9 +2193,9 @@ export function some(self: FixedArray<short>, predicate: (value: short, index: n
  *
  * @returns index of first element satisfying to predicate, -1 if no such element
  */
-export function findLastIndex(self: FixedArray<short>, predicate: (element: short, index: number, array: FixedArray<short>) => boolean): number {
+export function findLastIndex(self: FixedArray<short>, predicate: (element: short, index: int, array: FixedArray<short>) => boolean): number {
     for (let i = self.length - 1; i >= 0; i--) {
-        if (predicate(self[i], i.toDouble(), self)) {
+        if (predicate(self[i], i, self)) {
             return i
         }
     }
@@ -2209,13 +2209,13 @@ export function findLastIndex(self: FixedArray<short>, predicate: (element: shor
  *
  * @returns a result after applying callbackfn over all elements of the Array
  */
-export function reduce(self: FixedArray<short>, callbackfn: (previousValue: short, currentValue: short, index: number, array: FixedArray<short>) => short): short {
+export function reduce(self: FixedArray<short>, callbackfn: (previousValue: short, currentValue: short, index: int, array: FixedArray<short>) => short): short {
     if (self.length == 0) {
         throw new TypeError("Reduce of empty array with no initial value")
     }
     let acc: short = self[0];
     for (let i = 1; i < self.length; i++) {
-        acc = callbackfn(acc, self[i], i.toDouble(), self)
+        acc = callbackfn(acc, self[i], i, self)
     }
     return acc
 }
@@ -2229,10 +2229,10 @@ export function reduce(self: FixedArray<short>, callbackfn: (previousValue: shor
  *
  * @returns a result after applying callbackfn over all elements of the Array
  */
-export function reduce<U = short>(self: FixedArray<short>, callbackfn: (previousValue: U, currentValue: short, index: number, array: FixedArray<short>) => U, initialValue: U): U {
+export function reduce<U = short>(self: FixedArray<short>, callbackfn: (previousValue: U, currentValue: short, index: int, array: FixedArray<short>) => U, initialValue: U): U {
     let acc = initialValue
     for (let i = 0; i < self.length; i++) {
-        acc = callbackfn(acc, self[i], i.toDouble(), self)
+        acc = callbackfn(acc, self[i], i, self)
     }
     return acc
 }
@@ -2246,10 +2246,10 @@ export function reduce<U = short>(self: FixedArray<short>, callbackfn: (previous
  *
  * @returns a result after applying callbackfn over all elements of the Array
  */
-export function reduceRight<U>(self: FixedArray<short>, callbackfn: (previousValue: U, currentValue: short, index: number, array: FixedArray<short>) => U, initialValue: U): U {
+export function reduceRight<U>(self: FixedArray<short>, callbackfn: (previousValue: U, currentValue: short, index: int, array: FixedArray<short>) => U, initialValue: U): U {
     let acc = initialValue
     for (let i = self.length - 1; i >= 0; i--) {
-        acc = callbackfn(acc, self[i], i.toDouble(), self)
+        acc = callbackfn(acc, self[i], i, self)
     }
     return acc
 }
@@ -2259,13 +2259,13 @@ export function reduceRight<U>(self: FixedArray<short>, callbackfn: (previousVal
  *
  * @param callbackfn A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array.
  */
-export function forEach(self: FixedArray<short>, callbackfn: (value: short, index: number, array: FixedArray<short>) => void): void {
+export function forEach(self: FixedArray<short>, callbackfn: (value: short, index: int, array: FixedArray<short>) => void): void {
     const len0 = self.length;
     for (let i = 0; i < len0; i++) {
         if (i >= self.length) {
             break
         }
-        callbackfn(self[i], i.toDouble(), self)
+        callbackfn(self[i], i, self)
     }
 }
 
@@ -2657,11 +2657,11 @@ export function entries(self: FixedArray<short>): IterableIterator<[number, shor
  *
  * @returns `Array` instance, constructed from `this` and given function.
  */
-export function map(self: FixedArray<short>, callbackfn: (value: short, index: number, array: FixedArray<short>) => short): FixedArray<short> {
+export function map(self: FixedArray<short>, callbackfn: (value: short, index: int, array: FixedArray<short>) => short): FixedArray<short> {
     const len = self.length;
     let res : FixedArray<short> = new short[len];
     for (let i = 0; i < len; i++) {
-        res[i] = callbackfn(self[i], i.toDouble(), self);
+        res[i] = callbackfn(self[i], i, self);
     }
     return res;
 }
@@ -2673,13 +2673,13 @@ export function map(self: FixedArray<short>, callbackfn: (value: short, index: n
  *
  * @returns a result after applying callbackfn over all elements of the Array
  */
-export function reduceRight(self: FixedArray<short>, callbackfn: (previousValue: short, currentValue: short, index: number, array: FixedArray<short>) => short): short {
+export function reduceRight(self: FixedArray<short>, callbackfn: (previousValue: short, currentValue: short, index: int, array: FixedArray<short>) => short): short {
     if (self.length == 0) {
         throw new TypeError("Reduce of empty array with no initial value")
     }
     let acc: short = self[self.length - 1];
     for (let i = self.length - 2; i >= 0; i--) {
-        acc = callbackfn(acc, self[i], i.toDouble(), self)
+        acc = callbackfn(acc, self[i], i, self)
     }
     return acc
 }
@@ -3029,7 +3029,7 @@ export function fill(self: FixedArray<int>, value: int, start: int, end: int): F
  *
  * @returns the value of the first element in the array or undefined
  */
-export function find(self: FixedArray<int>, predicate: (value: int, index: number, array: FixedArray<int>) => boolean): Int | undefined {
+export function find(self: FixedArray<int>, predicate: (value: int, index: int, array: FixedArray<int>) => boolean): Int | undefined {
     const res = findIndex(self, predicate)
     if (res == -1) {
         return undefined
@@ -3047,9 +3047,9 @@ export function find(self: FixedArray<int>, predicate: (value: int, index: numbe
  *
  * @returns found element index or -1 otherwise
  */
-export function findIndex(self: FixedArray<int>, predicate: (value: int, index: number, array: FixedArray<int>) => boolean): number {
+export function findIndex(self: FixedArray<int>, predicate: (value: int, index: int, array: FixedArray<int>) => boolean): number {
     for (let i = 0; i < self.length; i++) {
-        if (predicate(self[i], i.toDouble(), self)) {
+        if (predicate(self[i], i, self)) {
             return i;
         }
     }
@@ -3064,10 +3064,10 @@ export function findIndex(self: FixedArray<int>, predicate: (value: int, index:
  *
  * @returns found element or undefined otherwise
  */
-export function findLast(self: FixedArray<int>, predicate: (elem: int, index: number, array: FixedArray<int>) => boolean): Int | undefined {
+export function findLast(self: FixedArray<int>, predicate: (elem: int, index: int, array: FixedArray<int>) => boolean): Int | undefined {
     for (let i = self.length - 1; i >= 0; i--) {
         const val = self[i];
-        if (predicate(val, i.toDouble(), self)) {
+        if (predicate(val, i, self)) {
             return val;
         }
     }
@@ -3083,9 +3083,9 @@ export function findLast(self: FixedArray<int>, predicate: (elem: int, index: nu
  *
  * @returns `true` if `predicate` returns a `true` value for every array element. Otherwise, `false`.
  */
-export function every(self: FixedArray<int>, predicate: (value: int, index: number, array: FixedArray<int>) => boolean): boolean {
+export function every(self: FixedArray<int>, predicate: (value: int, index: int, array: FixedArray<int>) => boolean): boolean {
     for (let i = 0; i < self.length; i++) {
-        if (!predicate(self[i], i.toDouble(), self)) {
+        if (!predicate(self[i], i, self)) {
             return false
         }
     }
@@ -3101,9 +3101,9 @@ export function every(self: FixedArray<int>, predicate: (value: int, index: numb
  *
  * @returns `true` if `predicate` returns a `true` value for at least one array element. Otherwise, `false`.
  */
-export function some(self: FixedArray<int>, predicate: (value: int, index: number, array: FixedArray<int>) => boolean): boolean {
+export function some(self: FixedArray<int>, predicate: (value: int, index: int, array: FixedArray<int>) => boolean): boolean {
     for (let i = 0; i < self.length; i++) {
-        if (predicate(self[i], i.toDouble(), self)) {
+        if (predicate(self[i], i, self)) {
             return true
         }
     }
@@ -3119,9 +3119,9 @@ export function some(self: FixedArray<int>, predicate: (value: int, index: numbe
  *
  * @returns index of first element satisfying to predicate, -1 if no such element
  */
-export function findLastIndex(self: FixedArray<int>, predicate: (element: int, index: number, array: FixedArray<int>) => boolean): number {
+export function findLastIndex(self: FixedArray<int>, predicate: (element: int, index: int, array: FixedArray<int>) => boolean): number {
     for (let i = self.length - 1; i >= 0; i--) {
-        if (predicate(self[i], i.toDouble(), self)) {
+        if (predicate(self[i], i, self)) {
             return i
         }
     }
@@ -3135,13 +3135,13 @@ export function findLastIndex(self: FixedArray<int>, predicate: (element: int, i
  *
  * @returns a result after applying callbackfn over all elements of the Array
  */
-export function reduce(self: FixedArray<int>, callbackfn: (previousValue: int, currentValue: int, index: number, array: FixedArray<int>) => int): int {
+export function reduce(self: FixedArray<int>, callbackfn: (previousValue: int, currentValue: int, index: int, array: FixedArray<int>) => int): int {
     if (self.length == 0) {
         throw new TypeError("Reduce of empty array with no initial value")
     }
     let acc: int = self[0];
     for (let i = 1; i < self.length; i++) {
-        acc = callbackfn(acc, self[i], i.toDouble(), self)
+        acc = callbackfn(acc, self[i], i, self)
     }
     return acc
 }
@@ -3155,10 +3155,10 @@ export function reduce(self: FixedArray<int>, callbackfn: (previousValue: int, c
  *
  * @returns a result after applying callbackfn over all elements of the Array
  */
-export function reduce<U = int>(self: FixedArray<int>, callbackfn: (previousValue: U, currentValue: int, index: number, array: FixedArray<int>) => U, initialValue: U): U {
+export function reduce<U = int>(self: FixedArray<int>, callbackfn: (previousValue: U, currentValue: int, index: int, array: FixedArray<int>) => U, initialValue: U): U {
     let acc = initialValue
     for (let i = 0; i < self.length; i++) {
-        acc = callbackfn(acc, self[i], i.toDouble(), self)
+        acc = callbackfn(acc, self[i], i, self)
     }
     return acc
 }
@@ -3172,10 +3172,10 @@ export function reduce<U = int>(self: FixedArray<int>, callbackfn: (previousValu
  *
  * @returns a result after applying callbackfn over all elements of the Array
  */
-export function reduceRight<U>(self: FixedArray<int>, callbackfn: (previousValue: U, currentValue: int, index: number, array: FixedArray<int>) => U, initialValue: U): U {
+export function reduceRight<U>(self: FixedArray<int>, callbackfn: (previousValue: U, currentValue: int, index: int, array: FixedArray<int>) => U, initialValue: U): U {
     let acc = initialValue
     for (let i = self.length - 1; i >= 0; i--) {
-        acc = callbackfn(acc, self[i], i.toDouble(), self)
+        acc = callbackfn(acc, self[i], i, self)
     }
     return acc
 }
@@ -3185,13 +3185,13 @@ export function reduceRight<U>(self: FixedArray<int>, callbackfn: (previousValue
  *
  * @param callbackfn A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array.
  */
-export function forEach(self: FixedArray<int>, callbackfn: (value: int, index: number, array: FixedArray<int>) => void): void {
+export function forEach(self: FixedArray<int>, callbackfn: (value: int, index: int, array: FixedArray<int>) => void): void {
     const len0 = self.length;
     for (let i = 0; i < len0; i++) {
         if (i >= self.length) {
             break
         }
-        callbackfn(self[i], i.toDouble(), self)
+        callbackfn(self[i], i, self)
     }
 }
 
@@ -3583,11 +3583,11 @@ export function entries(self: FixedArray<int>): IterableIterator<[number, int]>
  *
  * @returns `Array` instance, constructed from `this` and given function.
  */
-export function map(self: FixedArray<int>, callbackfn: (value: int, index: number, array: FixedArray<int>) => int): FixedArray<int> {
+export function map(self: FixedArray<int>, callbackfn: (value: int, index: int, array: FixedArray<int>) => int): FixedArray<int> {
     const len = self.length;
     let res : FixedArray<int> = new int[len];
     for (let i = 0; i < len; i++) {
-        res[i] = callbackfn(self[i], i.toDouble(), self);
+        res[i] = callbackfn(self[i], i, self);
     }
     return res;
 }
@@ -3599,13 +3599,13 @@ export function map(self: FixedArray<int>, callbackfn: (value: int, index: numbe
  *
  * @returns a result after applying callbackfn over all elements of the Array
  */
-export function reduceRight(self: FixedArray<int>, callbackfn: (previousValue: int, currentValue: int, index: number, array: FixedArray<int>) => int): int {
+export function reduceRight(self: FixedArray<int>, callbackfn: (previousValue: int, currentValue: int, index: int, array: FixedArray<int>) => int): int {
     if (self.length == 0) {
         throw new TypeError("Reduce of empty array with no initial value")
     }
     let acc: int = self[self.length - 1];
     for (let i = self.length - 2; i >= 0; i--) {
-        acc = callbackfn(acc, self[i], i.toDouble(), self)
+        acc = callbackfn(acc, self[i], i, self)
     }
     return acc
 }
@@ -3955,7 +3955,7 @@ export function fill(self: FixedArray<long>, value: long, start: int, end: int):
  *
  * @returns the value of the first element in the array or undefined
  */
-export function find(self: FixedArray<long>, predicate: (value: long, index: number, array: FixedArray<long>) => boolean): Long | undefined {
+export function find(self: FixedArray<long>, predicate: (value: long, index: int, array: FixedArray<long>) => boolean): Long | undefined {
     const res = findIndex(self, predicate)
     if (res == -1) {
         return undefined
@@ -3973,9 +3973,9 @@ export function find(self: FixedArray<long>, predicate: (value: long, index: num
  *
  * @returns found element index or -1 otherwise
  */
-export function findIndex(self: FixedArray<long>, predicate: (value: long, index: number, array: FixedArray<long>) => boolean): number {
+export function findIndex(self: FixedArray<long>, predicate: (value: long, index: int, array: FixedArray<long>) => boolean): number {
     for (let i = 0; i < self.length; i++) {
-        if (predicate(self[i], i.toDouble(), self)) {
+        if (predicate(self[i], i, self)) {
             return i;
         }
     }
@@ -3990,10 +3990,10 @@ export function findIndex(self: FixedArray<long>, predicate: (value: long, index
  *
  * @returns found element or undefined otherwise
  */
-export function findLast(self: FixedArray<long>, predicate: (elem: long, index: number, array: FixedArray<long>) => boolean): Long | undefined {
+export function findLast(self: FixedArray<long>, predicate: (elem: long, index: int, array: FixedArray<long>) => boolean): Long | undefined {
     for (let i = self.length - 1; i >= 0; i--) {
         const val = self[i];
-        if (predicate(val, i.toDouble(), self)) {
+        if (predicate(val, i, self)) {
             return val;
         }
     }
@@ -4009,9 +4009,9 @@ export function findLast(self: FixedArray<long>, predicate: (elem: long, index:
  *
  * @returns `true` if `predicate` returns a `true` value for every array element. Otherwise, `false`.
  */
-export function every(self: FixedArray<long>, predicate: (value: long, index: number, array: FixedArray<long>) => boolean): boolean {
+export function every(self: FixedArray<long>, predicate: (value: long, index: int, array: FixedArray<long>) => boolean): boolean {
     for (let i = 0; i < self.length; i++) {
-        if (!predicate(self[i], i.toDouble(), self)) {
+        if (!predicate(self[i], i, self)) {
             return false
         }
     }
@@ -4027,9 +4027,9 @@ export function every(self: FixedArray<long>, predicate: (value: long, index: nu
  *
  * @returns `true` if `predicate` returns a `true` value for at least one array element. Otherwise, `false`.
  */
-export function some(self: FixedArray<long>, predicate: (value: long, index: number, array: FixedArray<long>) => boolean): boolean {
+export function some(self: FixedArray<long>, predicate: (value: long, index: int, array: FixedArray<long>) => boolean): boolean {
     for (let i = 0; i < self.length; i++) {
-        if (predicate(self[i], i.toDouble(), self)) {
+        if (predicate(self[i], i, self)) {
             return true
         }
     }
@@ -4045,9 +4045,9 @@ export function some(self: FixedArray<long>, predicate: (value: long, index: num
  *
  * @returns index of first element satisfying to predicate, -1 if no such element
  */
-export function findLastIndex(self: FixedArray<long>, predicate: (element: long, index: number, array: FixedArray<long>) => boolean): number {
+export function findLastIndex(self: FixedArray<long>, predicate: (element: long, index: int, array: FixedArray<long>) => boolean): number {
     for (let i = self.length - 1; i >= 0; i--) {
-        if (predicate(self[i], i.toDouble(), self)) {
+        if (predicate(self[i], i, self)) {
             return i
         }
     }
@@ -4061,13 +4061,13 @@ export function findLastIndex(self: FixedArray<long>, predicate: (element: long,
  *
  * @returns a result after applying callbackfn over all elements of the Array
  */
-export function reduce(self: FixedArray<long>, callbackfn: (previousValue: long, currentValue: long, index: number, array: FixedArray<long>) => long): long {
+export function reduce(self: FixedArray<long>, callbackfn: (previousValue: long, currentValue: long, index: int, array: FixedArray<long>) => long): long {
     if (self.length == 0) {
         throw new TypeError("Reduce of empty array with no initial value")
     }
     let acc: long = self[0];
     for (let i = 1; i < self.length; i++) {
-        acc = callbackfn(acc, self[i], i.toDouble(), self)
+        acc = callbackfn(acc, self[i], i, self)
     }
     return acc
 }
@@ -4081,10 +4081,10 @@ export function reduce(self: FixedArray<long>, callbackfn: (previousValue: long,
  *
  * @returns a result after applying callbackfn over all elements of the Array
  */
-export function reduce<U = long>(self: FixedArray<long>, callbackfn: (previousValue: U, currentValue: long, index: number, array: FixedArray<long>) => U, initialValue: U): U {
+export function reduce<U = long>(self: FixedArray<long>, callbackfn: (previousValue: U, currentValue: long, index: int, array: FixedArray<long>) => U, initialValue: U): U {
     let acc = initialValue
     for (let i = 0; i < self.length; i++) {
-        acc = callbackfn(acc, self[i], i.toDouble(), self)
+        acc = callbackfn(acc, self[i], i, self)
     }
     return acc
 }
@@ -4098,10 +4098,10 @@ export function reduce<U = long>(self: FixedArray<long>, callbackfn: (previousVa
  *
  * @returns a result after applying callbackfn over all elements of the Array
  */
-export function reduceRight<U>(self: FixedArray<long>, callbackfn: (previousValue: U, currentValue: long, index: number, array: FixedArray<long>) => U, initialValue: U): U {
+export function reduceRight<U>(self: FixedArray<long>, callbackfn: (previousValue: U, currentValue: long, index: int, array: FixedArray<long>) => U, initialValue: U): U {
     let acc = initialValue
     for (let i = self.length - 1; i >= 0; i--) {
-        acc = callbackfn(acc, self[i], i.toDouble(), self)
+        acc = callbackfn(acc, self[i], i, self)
     }
     return acc
 }
@@ -4111,13 +4111,13 @@ export function reduceRight<U>(self: FixedArray<long>, callbackfn: (previousValu
  *
  * @param callbackfn A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array.
  */
-export function forEach(self: FixedArray<long>, callbackfn: (value: long, index: number, array: FixedArray<long>) => void): void {
+export function forEach(self: FixedArray<long>, callbackfn: (value: long, index: int, array: FixedArray<long>) => void): void {
     const len0 = self.length;
     for (let i = 0; i < len0; i++) {
         if (i >= self.length) {
             break
         }
-        callbackfn(self[i], i.toDouble(), self)
+        callbackfn(self[i], i, self)
     }
 }
 
@@ -4509,11 +4509,11 @@ export function entries(self: FixedArray<long>): IterableIterator<[number, long]
  *
  * @returns `Array` instance, constructed from `this` and given function.
  */
-export function map(self: FixedArray<long>, callbackfn: (value: long, index: number, array: FixedArray<long>) => long): FixedArray<long> {
+export function map(self: FixedArray<long>, callbackfn: (value: long, index: int, array: FixedArray<long>) => long): FixedArray<long> {
     const len = self.length;
     let res : FixedArray<long> = new long[len];
     for (let i = 0; i < len; i++) {
-        res[i] = callbackfn(self[i], i.toDouble(), self);
+        res[i] = callbackfn(self[i], i, self);
     }
     return res;
 }
@@ -4525,13 +4525,13 @@ export function map(self: FixedArray<long>, callbackfn: (value: long, index: num
  *
  * @returns a result after applying callbackfn over all elements of the Array
  */
-export function reduceRight(self: FixedArray<long>, callbackfn: (previousValue: long, currentValue: long, index: number, array: FixedArray<long>) => long): long {
+export function reduceRight(self: FixedArray<long>, callbackfn: (previousValue: long, currentValue: long, index: int, array: FixedArray<long>) => long): long {
     if (self.length == 0) {
         throw new TypeError("Reduce of empty array with no initial value")
     }
     let acc: long = self[self.length - 1];
     for (let i = self.length - 2; i >= 0; i--) {
-        acc = callbackfn(acc, self[i], i.toDouble(), self)
+        acc = callbackfn(acc, self[i], i, self)
     }
     return acc
 }
@@ -4881,7 +4881,7 @@ export function fill(self: FixedArray<float>, value: float, start: int, end: int
  *
  * @returns the value of the first element in the array or undefined
  */
-export function find(self: FixedArray<float>, predicate: (value: float, index: number, array: FixedArray<float>) => boolean): Float | undefined {
+export function find(self: FixedArray<float>, predicate: (value: float, index: int, array: FixedArray<float>) => boolean): Float | undefined {
     const res = findIndex(self, predicate)
     if (res == -1) {
         return undefined
@@ -4899,9 +4899,9 @@ export function find(self: FixedArray<float>, predicate: (value: float, index: n
  *
  * @returns found element index or -1 otherwise
  */
-export function findIndex(self: FixedArray<float>, predicate: (value: float, index: number, array: FixedArray<float>) => boolean): number {
+export function findIndex(self: FixedArray<float>, predicate: (value: float, index: int, array: FixedArray<float>) => boolean): number {
     for (let i = 0; i < self.length; i++) {
-        if (predicate(self[i], i.toDouble(), self)) {
+        if (predicate(self[i], i, self)) {
             return i;
         }
     }
@@ -4916,10 +4916,10 @@ export function findIndex(self: FixedArray<float>, predicate: (value: float, ind
  *
  * @returns found element or undefined otherwise
  */
-export function findLast(self: FixedArray<float>, predicate: (elem: float, index: number, array: FixedArray<float>) => boolean): Float | undefined {
+export function findLast(self: FixedArray<float>, predicate: (elem: float, index: int, array: FixedArray<float>) => boolean): Float | undefined {
     for (let i = self.length - 1; i >= 0; i--) {
         const val = self[i];
-        if (predicate(val, i.toDouble(), self)) {
+        if (predicate(val, i, self)) {
             return val;
         }
     }
@@ -4935,9 +4935,9 @@ export function findLast(self: FixedArray<float>, predicate: (elem: float, index
  *
  * @returns `true` if `predicate` returns a `true` value for every array element. Otherwise, `false`.
  */
-export function every(self: FixedArray<float>, predicate: (value: float, index: number, array: FixedArray<float>) => boolean): boolean {
+export function every(self: FixedArray<float>, predicate: (value: float, index: int, array: FixedArray<float>) => boolean): boolean {
     for (let i = 0; i < self.length; i++) {
-        if (!predicate(self[i], i.toDouble(), self)) {
+        if (!predicate(self[i], i, self)) {
             return false
         }
     }
@@ -4953,9 +4953,9 @@ export function every(self: FixedArray<float>, predicate: (value: float, index:
  *
  * @returns `true` if `predicate` returns a `true` value for at least one array element. Otherwise, `false`.
  */
-export function some(self: FixedArray<float>, predicate: (value: float, index: number, array: FixedArray<float>) => boolean): boolean {
+export function some(self: FixedArray<float>, predicate: (value: float, index: int, array: FixedArray<float>) => boolean): boolean {
     for (let i = 0; i < self.length; i++) {
-        if (predicate(self[i], i.toDouble(), self)) {
+        if (predicate(self[i], i, self)) {
             return true
         }
     }
@@ -4971,9 +4971,9 @@ export function some(self: FixedArray<float>, predicate: (value: float, index: n
  *
  * @returns index of first element satisfying to predicate, -1 if no such element
  */
-export function findLastIndex(self: FixedArray<float>, predicate: (element: float, index: number, array: FixedArray<float>) => boolean): number {
+export function findLastIndex(self: FixedArray<float>, predicate: (element: float, index: int, array: FixedArray<float>) => boolean): number {
     for (let i = self.length - 1; i >= 0; i--) {
-        if (predicate(self[i], i.toDouble(), self)) {
+        if (predicate(self[i], i, self)) {
             return i
         }
     }
@@ -4987,13 +4987,13 @@ export function findLastIndex(self: FixedArray<float>, predicate: (element: floa
  *
  * @returns a result after applying callbackfn over all elements of the Array
  */
-export function reduce(self: FixedArray<float>, callbackfn: (previousValue: float, currentValue: float, index: number, array: FixedArray<float>) => float): float {
+export function reduce(self: FixedArray<float>, callbackfn: (previousValue: float, currentValue: float, index: int, array: FixedArray<float>) => float): float {
     if (self.length == 0) {
         throw new TypeError("Reduce of empty array with no initial value")
     }
     let acc: float = self[0];
     for (let i = 1; i < self.length; i++) {
-        acc = callbackfn(acc, self[i], i.toDouble(), self)
+        acc = callbackfn(acc, self[i], i, self)
     }
     return acc
 }
@@ -5007,10 +5007,10 @@ export function reduce(self: FixedArray<float>, callbackfn: (previousValue: floa
  *
  * @returns a result after applying callbackfn over all elements of the Array
  */
-export function reduce<U = float>(self: FixedArray<float>, callbackfn: (previousValue: U, currentValue: float, index: number, array: FixedArray<float>) => U, initialValue: U): U {
+export function reduce<U = float>(self: FixedArray<float>, callbackfn: (previousValue: U, currentValue: float, index: int, array: FixedArray<float>) => U, initialValue: U): U {
     let acc = initialValue
     for (let i = 0; i < self.length; i++) {
-        acc = callbackfn(acc, self[i], i.toDouble(), self)
+        acc = callbackfn(acc, self[i], i, self)
     }
     return acc
 }
@@ -5024,10 +5024,10 @@ export function reduce<U = float>(self: FixedArray<float>, callbackfn: (previous
  *
  * @returns a result after applying callbackfn over all elements of the Array
  */
-export function reduceRight<U>(self: FixedArray<float>, callbackfn: (previousValue: U, currentValue: float, index: number, array: FixedArray<float>) => U, initialValue: U): U {
+export function reduceRight<U>(self: FixedArray<float>, callbackfn: (previousValue: U, currentValue: float, index: int, array: FixedArray<float>) => U, initialValue: U): U {
     let acc = initialValue
     for (let i = self.length - 1; i >= 0; i--) {
-        acc = callbackfn(acc, self[i], i.toDouble(), self)
+        acc = callbackfn(acc, self[i], i, self)
     }
     return acc
 }
@@ -5037,13 +5037,13 @@ export function reduceRight<U>(self: FixedArray<float>, callbackfn: (previousVal
  *
  * @param callbackfn A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array.
  */
-export function forEach(self: FixedArray<float>, callbackfn: (value: float, index: number, array: FixedArray<float>) => void): void {
+export function forEach(self: FixedArray<float>, callbackfn: (value: float, index: int, array: FixedArray<float>) => void): void {
     const len0 = self.length;
     for (let i = 0; i < len0; i++) {
         if (i >= self.length) {
             break
         }
-        callbackfn(self[i], i.toDouble(), self)
+        callbackfn(self[i], i, self)
     }
 }
 
@@ -5443,11 +5443,11 @@ export function entries(self: FixedArray<float>): IterableIterator<[number, floa
  *
  * @returns `Array` instance, constructed from `this` and given function.
  */
-export function map(self: FixedArray<float>, callbackfn: (value: float, index: number, array: FixedArray<float>) => float): FixedArray<float> {
+export function map(self: FixedArray<float>, callbackfn: (value: float, index: int, array: FixedArray<float>) => float): FixedArray<float> {
     const len = self.length;
     let res : FixedArray<float> = new float[len];
     for (let i = 0; i < len; i++) {
-        res[i] = callbackfn(self[i], i.toDouble(), self);
+        res[i] = callbackfn(self[i], i, self);
     }
     return res;
 }
@@ -5459,13 +5459,13 @@ export function map(self: FixedArray<float>, callbackfn: (value: float, index: n
  *
  * @returns a result after applying callbackfn over all elements of the Array
  */
-export function reduceRight(self: FixedArray<float>, callbackfn: (previousValue: float, currentValue: float, index: number, array: FixedArray<float>) => float): float {
+export function reduceRight(self: FixedArray<float>, callbackfn: (previousValue: float, currentValue: float, index: int, array: FixedArray<float>) => float): float {
     if (self.length == 0) {
         throw new TypeError("Reduce of empty array with no initial value")
     }
     let acc: float = self[self.length - 1];
     for (let i = self.length - 2; i >= 0; i--) {
-        acc = callbackfn(acc, self[i], i.toDouble(), self)
+        acc = callbackfn(acc, self[i], i, self)
     }
     return acc
 }
@@ -5815,7 +5815,7 @@ export function fill(self: FixedArray<double>, value: double, start: int, end: i
  *
  * @returns the value of the first element in the array or undefined
  */
-export function find(self: FixedArray<double>, predicate: (value: double, index: number, array: FixedArray<double>) => boolean): Double | undefined {
+export function find(self: FixedArray<double>, predicate: (value: double, index: int, array: FixedArray<double>) => boolean): Double | undefined {
     const res = findIndex(self, predicate)
     if (res == -1) {
         return undefined
@@ -5833,9 +5833,9 @@ export function find(self: FixedArray<double>, predicate: (value: double, index:
  *
  * @returns found element index or -1 otherwise
  */
-export function findIndex(self: FixedArray<double>, predicate: (value: double, index: number, array: FixedArray<double>) => boolean): number {
+export function findIndex(self: FixedArray<double>, predicate: (value: double, index: int, array: FixedArray<double>) => boolean): number {
     for (let i = 0; i < self.length; i++) {
-        if (predicate(self[i], i.toDouble(), self)) {
+        if (predicate(self[i], i, self)) {
             return i;
         }
     }
@@ -5850,10 +5850,10 @@ export function findIndex(self: FixedArray<double>, predicate: (value: double, i
  *
  * @returns found element or undefined otherwise
  */
-export function findLast(self: FixedArray<double>, predicate: (elem: double, index: number, array: FixedArray<double>) => boolean): Double | undefined {
+export function findLast(self: FixedArray<double>, predicate: (elem: double, index: int, array: FixedArray<double>) => boolean): Double | undefined {
     for (let i = self.length - 1; i >= 0; i--) {
         const val = self[i];
-        if (predicate(val, i.toDouble(), self)) {
+        if (predicate(val, i, self)) {
             return val;
         }
     }
@@ -5869,9 +5869,9 @@ export function findLast(self: FixedArray<double>, predicate: (elem: double, ind
  *
  * @returns `true` if `predicate` returns a `true` value for every array element. Otherwise, `false`.
  */
-export function every(self: FixedArray<double>, predicate: (value: double, index: number, array: FixedArray<double>) => boolean): boolean {
+export function every(self: FixedArray<double>, predicate: (value: double, index: int, array: FixedArray<double>) => boolean): boolean {
     for (let i = 0; i < self.length; i++) {
-        if (!predicate(self[i], i.toDouble(), self)) {
+        if (!predicate(self[i], i, self)) {
             return false
         }
     }
@@ -5887,9 +5887,9 @@ export function every(self: FixedArray<double>, predicate: (value: double, index
  *
  * @returns `true` if `predicate` returns a `true` value for at least one array element. Otherwise, `false`.
  */
-export function some(self: FixedArray<double>, predicate: (value: double, index: number, array: FixedArray<double>) => boolean): boolean {
+export function some(self: FixedArray<double>, predicate: (value: double, index: int, array: FixedArray<double>) => boolean): boolean {
     for (let i = 0; i < self.length; i++) {
-        if (predicate(self[i], i.toDouble(), self)) {
+        if (predicate(self[i], i, self)) {
             return true
         }
     }
@@ -5905,9 +5905,9 @@ export function some(self: FixedArray<double>, predicate: (value: double, index:
  *
  * @returns index of first element satisfying to predicate, -1 if no such element
  */
-export function findLastIndex(self: FixedArray<double>, predicate: (element: double, index: number, array: FixedArray<double>) => boolean): number {
+export function findLastIndex(self: FixedArray<double>, predicate: (element: double, index: int, array: FixedArray<double>) => boolean): number {
     for (let i = self.length - 1; i >= 0; i--) {
-        if (predicate(self[i], i.toDouble(), self)) {
+        if (predicate(self[i], i, self)) {
             return i
         }
     }
@@ -5921,13 +5921,13 @@ export function findLastIndex(self: FixedArray<double>, predicate: (element: dou
  *
  * @returns a result after applying callbackfn over all elements of the Array
  */
-export function reduce(self: FixedArray<double>, callbackfn: (previousValue: double, currentValue: double, index: number, array: FixedArray<double>) => double): double {
+export function reduce(self: FixedArray<double>, callbackfn: (previousValue: double, currentValue: double, index: int, array: FixedArray<double>) => double): double {
     if (self.length == 0) {
         throw new TypeError("Reduce of empty array with no initial value")
     }
     let acc: double = self[0];
     for (let i = 1; i < self.length; i++) {
-        acc = callbackfn(acc, self[i], i.toDouble(), self)
+        acc = callbackfn(acc, self[i], i, self)
     }
     return acc
 }
@@ -5941,10 +5941,10 @@ export function reduce(self: FixedArray<double>, callbackfn: (previousValue: dou
  *
  * @returns a result after applying callbackfn over all elements of the Array
  */
-export function reduce<U = double>(self: FixedArray<double>, callbackfn: (previousValue: U, currentValue: double, index: number, array: FixedArray<double>) => U, initialValue: U): U {
+export function reduce<U = double>(self: FixedArray<double>, callbackfn: (previousValue: U, currentValue: double, index: int, array: FixedArray<double>) => U, initialValue: U): U {
     let acc = initialValue
     for (let i = 0; i < self.length; i++) {
-        acc = callbackfn(acc, self[i], i.toDouble(), self)
+        acc = callbackfn(acc, self[i], i, self)
     }
     return acc
 }
@@ -5958,10 +5958,10 @@ export function reduce<U = double>(self: FixedArray<double>, callbackfn: (previo
  *
  * @returns a result after applying callbackfn over all elements of the Array
  */
-export function reduceRight<U>(self: FixedArray<double>, callbackfn: (previousValue: U, currentValue: double, index: number, array: FixedArray<double>) => U, initialValue: U): U {
+export function reduceRight<U>(self: FixedArray<double>, callbackfn: (previousValue: U, currentValue: double, index: int, array: FixedArray<double>) => U, initialValue: U): U {
     let acc = initialValue
     for (let i = self.length - 1; i >= 0; i--) {
-        acc = callbackfn(acc, self[i], i.toDouble(), self)
+        acc = callbackfn(acc, self[i], i, self)
     }
     return acc
 }
@@ -5971,13 +5971,13 @@ export function reduceRight<U>(self: FixedArray<double>, callbackfn: (previousVa
  *
  * @param callbackfn A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array.
  */
-export function forEach(self: FixedArray<double>, callbackfn: (value: double, index: number, array: FixedArray<double>) => void): void {
+export function forEach(self: FixedArray<double>, callbackfn: (value: double, index: int, array: FixedArray<double>) => void): void {
     const len0 = self.length;
     for (let i = 0; i < len0; i++) {
         if (i >= self.length) {
             break
         }
-        callbackfn(self[i], i.toDouble(), self)
+        callbackfn(self[i], i, self)
     }
 }
 
@@ -6377,11 +6377,11 @@ export function entries(self: FixedArray<double>): IterableIterator<[number, dou
  *
  * @returns `Array` instance, constructed from `this` and given function.
  */
-export function map(self: FixedArray<double>, callbackfn: (value: double, index: number, array: FixedArray<double>) => double): FixedArray<double> {
+export function map(self: FixedArray<double>, callbackfn: (value: double, index: int, array: FixedArray<double>) => double): FixedArray<double> {
     const len = self.length;
     let res : FixedArray<double> = new double[len];
     for (let i = 0; i < len; i++) {
-        res[i] = callbackfn(self[i], i.toDouble(), self);
+        res[i] = callbackfn(self[i], i, self);
     }
     return res;
 }
@@ -6393,13 +6393,13 @@ export function map(self: FixedArray<double>, callbackfn: (value: double, index:
  *
  * @returns a result after applying callbackfn over all elements of the Array
  */
-export function reduceRight(self: FixedArray<double>, callbackfn: (previousValue: double, currentValue: double, index: number, array: FixedArray<double>) => double): double {
+export function reduceRight(self: FixedArray<double>, callbackfn: (previousValue: double, currentValue: double, index: int, array: FixedArray<double>) => double): double {
     if (self.length == 0) {
         throw new TypeError("Reduce of empty array with no initial value")
     }
     let acc: double = self[self.length - 1];
     for (let i = self.length - 2; i >= 0; i--) {
-        acc = callbackfn(acc, self[i], i.toDouble(), self)
+        acc = callbackfn(acc, self[i], i, self)
     }
     return acc
 }
@@ -6749,7 +6749,7 @@ export function fill(self: FixedArray<char>, value: char, start: int, end: int):
  *
  * @returns the value of the first element in the array or undefined
  */
-export function find(self: FixedArray<char>, predicate: (value: char, index: number, array: FixedArray<char>) => boolean): Char | undefined {
+export function find(self: FixedArray<char>, predicate: (value: char, index: int, array: FixedArray<char>) => boolean): Char | undefined {
     const res = findIndex(self, predicate)
     if (res == -1) {
         return undefined
@@ -6767,9 +6767,9 @@ export function find(self: FixedArray<char>, predicate: (value: char, index: num
  *
  * @returns found element index or -1 otherwise
  */
-export function findIndex(self: FixedArray<char>, predicate: (value: char, index: number, array: FixedArray<char>) => boolean): number {
+export function findIndex(self: FixedArray<char>, predicate: (value: char, index: int, array: FixedArray<char>) => boolean): number {
     for (let i = 0; i < self.length; i++) {
-        if (predicate(self[i], i.toDouble(), self)) {
+        if (predicate(self[i], i, self)) {
             return i;
         }
     }
@@ -6784,10 +6784,10 @@ export function findIndex(self: FixedArray<char>, predicate: (value: char, index
  *
  * @returns found element or undefined otherwise
  */
-export function findLast(self: FixedArray<char>, predicate: (elem: char, index: number, array: FixedArray<char>) => boolean): Char | undefined {
+export function findLast(self: FixedArray<char>, predicate: (elem: char, index: int, array: FixedArray<char>) => boolean): Char | undefined {
     for (let i = self.length - 1; i >= 0; i--) {
         const val = self[i];
-        if (predicate(val, i.toDouble(), self)) {
+        if (predicate(val, i, self)) {
             return val;
         }
     }
@@ -6803,9 +6803,9 @@ export function findLast(self: FixedArray<char>, predicate: (elem: char, index:
  *
  * @returns `true` if `predicate` returns a `true` value for every array element. Otherwise, `false`.
  */
-export function every(self: FixedArray<char>, predicate: (value: char, index: number, array: FixedArray<char>) => boolean): boolean {
+export function every(self: FixedArray<char>, predicate: (value: char, index: int, array: FixedArray<char>) => boolean): boolean {
     for (let i = 0; i < self.length; i++) {
-        if (!predicate(self[i], i.toDouble(), self)) {
+        if (!predicate(self[i], i, self)) {
             return false
         }
     }
@@ -6821,9 +6821,9 @@ export function every(self: FixedArray<char>, predicate: (value: char, index: nu
  *
  * @returns `true` if `predicate` returns a `true` value for at least one array element. Otherwise, `false`.
  */
-export function some(self: FixedArray<char>, predicate: (value: char, index: number, array: FixedArray<char>) => boolean): boolean {
+export function some(self: FixedArray<char>, predicate: (value: char, index: int, array: FixedArray<char>) => boolean): boolean {
     for (let i = 0; i < self.length; i++) {
-        if (predicate(self[i], i.toDouble(), self)) {
+        if (predicate(self[i], i, self)) {
             return true
         }
     }
@@ -6839,9 +6839,9 @@ export function some(self: FixedArray<char>, predicate: (value: char, index: num
  *
  * @returns index of first element satisfying to predicate, -1 if no such element
  */
-export function findLastIndex(self: FixedArray<char>, predicate: (element: char, index: number, array: FixedArray<char>) => boolean): number {
+export function findLastIndex(self: FixedArray<char>, predicate: (element: char, index: int, array: FixedArray<char>) => boolean): number {
     for (let i = self.length - 1; i >= 0; i--) {
-        if (predicate(self[i], i.toDouble(), self)) {
+        if (predicate(self[i], i, self)) {
             return i
         }
     }
@@ -6855,13 +6855,13 @@ export function findLastIndex(self: FixedArray<char>, predicate: (element: char,
  *
  * @returns a result after applying callbackfn over all elements of the Array
  */
-export function reduce(self: FixedArray<char>, callbackfn: (previousValue: char, currentValue: char, index: number, array: FixedArray<char>) => char): char {
+export function reduce(self: FixedArray<char>, callbackfn: (previousValue: char, currentValue: char, index: int, array: FixedArray<char>) => char): char {
     if (self.length == 0) {
         throw new TypeError("Reduce of empty array with no initial value")
     }
     let acc: char = self[0];
     for (let i = 1; i < self.length; i++) {
-        acc = callbackfn(acc, self[i], i.toDouble(), self)
+        acc = callbackfn(acc, self[i], i, self)
     }
     return acc
 }
@@ -6875,10 +6875,10 @@ export function reduce(self: FixedArray<char>, callbackfn: (previousValue: char,
  *
  * @returns a result after applying callbackfn over all elements of the Array
  */
-export function reduce<U = char>(self: FixedArray<char>, callbackfn: (previousValue: U, currentValue: char, index: number, array: FixedArray<char>) => U, initialValue: U): U {
+export function reduce<U = char>(self: FixedArray<char>, callbackfn: (previousValue: U, currentValue: char, index: int, array: FixedArray<char>) => U, initialValue: U): U {
     let acc = initialValue
     for (let i = 0; i < self.length; i++) {
-        acc = callbackfn(acc, self[i], i.toDouble(), self)
+        acc = callbackfn(acc, self[i], i, self)
     }
     return acc
 }
@@ -6892,10 +6892,10 @@ export function reduce<U = char>(self: FixedArray<char>, callbackfn: (previousVa
  *
  * @returns a result after applying callbackfn over all elements of the Array
  */
-export function reduceRight<U>(self: FixedArray<char>, callbackfn: (previousValue: U, currentValue: char, index: number, array: FixedArray<char>) => U, initialValue: U): U {
+export function reduceRight<U>(self: FixedArray<char>, callbackfn: (previousValue: U, currentValue: char, index: int, array: FixedArray<char>) => U, initialValue: U): U {
     let acc = initialValue
     for (let i = self.length - 1; i >= 0; i--) {
-        acc = callbackfn(acc, self[i], i.toDouble(), self)
+        acc = callbackfn(acc, self[i], i, self)
     }
     return acc
 }
@@ -6905,13 +6905,13 @@ export function reduceRight<U>(self: FixedArray<char>, callbackfn: (previousValu
  *
  * @param callbackfn A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array.
  */
-export function forEach(self: FixedArray<char>, callbackfn: (value: char, index: number, array: FixedArray<char>) => void): void {
+export function forEach(self: FixedArray<char>, callbackfn: (value: char, index: int, array: FixedArray<char>) => void): void {
     const len0 = self.length;
     for (let i = 0; i < len0; i++) {
         if (i >= self.length) {
             break
         }
-        callbackfn(self[i], i.toDouble(), self)
+        callbackfn(self[i], i, self)
     }
 }
 
@@ -7303,11 +7303,11 @@ export function entries(self: FixedArray<char>): IterableIterator<[number, char]
  *
  * @returns `Array` instance, constructed from `this` and given function.
  */
-export function map(self: FixedArray<char>, callbackfn: (value: char, index: number, array: FixedArray<char>) => char): FixedArray<char> {
+export function map(self: FixedArray<char>, callbackfn: (value: char, index: int, array: FixedArray<char>) => char): FixedArray<char> {
     const len = self.length;
     let res : FixedArray<char> = new char[len];
     for (let i = 0; i < len; i++) {
-        res[i] = callbackfn(self[i], i.toDouble(), self);
+        res[i] = callbackfn(self[i], i, self);
     }
     return res;
 }
@@ -7319,13 +7319,13 @@ export function map(self: FixedArray<char>, callbackfn: (value: char, index: num
  *
  * @returns a result after applying callbackfn over all elements of the Array
  */
-export function reduceRight(self: FixedArray<char>, callbackfn: (previousValue: char, currentValue: char, index: number, array: FixedArray<char>) => char): char {
+export function reduceRight(self: FixedArray<char>, callbackfn: (previousValue: char, currentValue: char, index: int, array: FixedArray<char>) => char): char {
     if (self.length == 0) {
         throw new TypeError("Reduce of empty array with no initial value")
     }
     let acc: char = self[self.length - 1];
     for (let i = self.length - 2; i >= 0; i--) {
-        acc = callbackfn(acc, self[i], i.toDouble(), self)
+        acc = callbackfn(acc, self[i], i, self)
     }
     return acc
 }
diff --git a/static_core/plugins/ets/stdlib/std/core/Proxy.ets b/static_core/plugins/ets/stdlib/std/core/Proxy.ets
index 3697ed0a2458a6ec181df8e06d68e13dd0989237..10bb69dbdaef9bfce6657caef006e17ce4af2d07 100644
--- a/static_core/plugins/ets/stdlib/std/core/Proxy.ets
+++ b/static_core/plugins/ets/stdlib/std/core/Proxy.ets
@@ -756,7 +756,7 @@ abstract class ArrayProxy<T> extends Array<T> {
                 continue
             }
 
-            const signatureMatch = signature.every((paramType: Type, index: number) => {
+            const signatureMatch = signature.every((paramType, index) => {
                 const param = methodType.getParameter(index.toInt())
                 let tmp = paramType.equals(param.getType())
                 return tmp
diff --git a/static_core/plugins/ets/stdlib/std/core/ReadonlyArrayProxy.ets b/static_core/plugins/ets/stdlib/std/core/ReadonlyArrayProxy.ets
index 4f25265527254b5594c824595401c3de22fea14e..c01a42719433ec253e60208fd193d350e1d4a9a0 100644
--- a/static_core/plugins/ets/stdlib/std/core/ReadonlyArrayProxy.ets
+++ b/static_core/plugins/ets/stdlib/std/core/ReadonlyArrayProxy.ets
@@ -54,31 +54,31 @@ class ReadonlyArrayProxy<T> implements ReadonlyArray<T> {
     	return this.target.entries()
     }
 
-    override every(predicate: (value: T, index: number, array: ReadonlyArray<T>) => boolean): boolean {
+    override every(predicate: (value: T, index: int, array: ReadonlyArray<T>) => boolean): boolean {
     	return this.target.every(predicate)
     }
 
-    override filter(predicate: (value: T, index: number, array: ReadonlyArray<T>) => boolean): Array<T> {
+    override filter(predicate: (value: T, index: int, array: ReadonlyArray<T>) => boolean): Array<T> {
     	return this.target.filter(predicate)
     }
 
-    override find(predicate: (value: T, index: number, obj: ReadonlyArray<T>) => boolean): T | undefined {
+    override find(predicate: (value: T, index: int, obj: ReadonlyArray<T>) => boolean): T | undefined {
     	return this.target.find(predicate)
     }
 
-    override findLast(predicate: (value: T, index: number, obj: ReadonlyArray<T>) => boolean): T | undefined {
+    override findLast(predicate: (value: T, index: int, obj: ReadonlyArray<T>) => boolean): T | undefined {
     	return this.target.findLast(predicate)
     }
 
-    override findIndex(predicate: (value: T, index: number, obj: ReadonlyArray<T>) => boolean): number {
+    override findIndex(predicate: (value: T, index: int, obj: ReadonlyArray<T>) => boolean): number {
     	return this.target.findIndex(predicate)
     }
 
-    override findLastIndex(predicate: (value: T, index: number, obj: ReadonlyArray<T>) => boolean): number {
+    override findLastIndex(predicate: (value: T, index: int, obj: ReadonlyArray<T>) => boolean): number {
     	return this.target.findLastIndex(predicate)
     }
 
-    override forEach(action: (value: T, index: number, array: ReadonlyArray<T>) => void): void {
+    override forEach(action: (value: T, index: int, array: ReadonlyArray<T>) => void): void {
     	return this.target.forEach(action)
     }
 
@@ -102,23 +102,23 @@ class ReadonlyArrayProxy<T> implements ReadonlyArray<T> {
     	return this.target.lastIndexOf(searchElement, fromIndex)
     }
 
-    override map<U>(mapper: (value: T, index: number, array: ReadonlyArray<T>) => U): Array<U> {
+    override map<U>(mapper: (value: T, index: int, array: ReadonlyArray<T>) => U): Array<U> {
     	return this.target.map<U>(mapper)
     }
 
-    override reduce(reducer: (previousValue: T, currentValue: T, currentIndex: number, array: ReadonlyArray<T>) => T): T {
+    override reduce(reducer: (previousValue: T, currentValue: T, currentIndex: int, array: ReadonlyArray<T>) => T): T {
     	return this.target.reduce(reducer)
     }
 
-    override reduce<U>(reducer: (previousValue: U, currentValue: T, currentIndex: number, array: ReadonlyArray<T>) => U, initialValue: U): U {
+    override reduce<U>(reducer: (previousValue: U, currentValue: T, currentIndex: int, array: ReadonlyArray<T>) => U, initialValue: U): U {
     	return this.target.reduce<U>(reducer, initialValue)
     }
 
-    override reduceRight(reducer: (previousValue: T, currentValue: T, currentIndex: number, array: ReadonlyArray<T>) => T): T {
+    override reduceRight(reducer: (previousValue: T, currentValue: T, currentIndex: int, array: ReadonlyArray<T>) => T): T {
     	return this.target.reduceRight(reducer)
     }
 
-    override reduceRight<U>(reducer: (previousValue: U, currentValue: T, currentIndex: number, array: ReadonlyArray<T>) => U, initialValue: U): U {
+    override reduceRight<U>(reducer: (previousValue: U, currentValue: T, currentIndex: int, array: ReadonlyArray<T>) => U, initialValue: U): U {
     	return this.target.reduceRight<U>(reducer, initialValue)
     }
 
@@ -126,7 +126,7 @@ class ReadonlyArrayProxy<T> implements ReadonlyArray<T> {
     	return this.target.slice(start, end)
     }
 
-    override some(predicate: (value: T, index: number, array: ReadonlyArray<T>) => boolean): boolean {
+    override some(predicate: (value: T, index: int, array: ReadonlyArray<T>) => boolean): boolean {
     	return this.target.some(predicate)
     }
 
diff --git a/static_core/plugins/ets/templates/stdlib/Array_code.rb b/static_core/plugins/ets/templates/stdlib/Array_code.rb
index cd7ff15e2bf0c2d47d8636ce9889f1bea84a3faa..10701ce37942f7089a6956df1b4672626892ce34 100644
--- a/static_core/plugins/ets/templates/stdlib/Array_code.rb
+++ b/static_core/plugins/ets/templates/stdlib/Array_code.rb
@@ -16,7 +16,7 @@
 module TemplateData
     def self.get_lambda_data()
         [
-            [2, ", i.toDouble(), #{$ctx.this}", ", index: number, array: #{$ctx.this_type}", ", index, #{$ctx.this}"],
+            [2, ", i, #{$ctx.this}", ", index: int, array: #{$ctx.this_type}", ", index, #{$ctx.this}"],
         ]
     end
 end
diff --git a/static_core/plugins/ets/templates/stdlib/Array_escompat.erb b/static_core/plugins/ets/templates/stdlib/Array_escompat.erb
index 85a70090687d636f66f4896011bf4322ba4014fc..2afd21bed82ef2c7660b77041dc9d7562e20550c 100644
--- a/static_core/plugins/ets/templates/stdlib/Array_escompat.erb
+++ b/static_core/plugins/ets/templates/stdlib/Array_escompat.erb
@@ -841,11 +841,11 @@ export class Array<T> implements ReadonlyArray<T>, Iterable<T> {
      *
      * @returns New `Array` instance constructed from `this` with elements filtered using test function `predicate`.
      */
-    public override filter(predicate: (value: T, index: number, array: Array<T>) => boolean): Array<T> {
+    public override filter(predicate: (value: T, index: int, array: Array<T>) => boolean): Array<T> {
         const res = new Array<T>()
         for (let i: int = 0; i < this.actualLength; i++) {
             const val = this.$_get_unsafe(i)
-            if (predicate(val, i.toDouble(), this)) {
+            if (predicate(val, i, this)) {
                 res.push(val)
             }
         }
@@ -961,7 +961,7 @@ export class Array<T> implements ReadonlyArray<T>, Iterable<T> {
      * @return new Array after map and than flat
      */
     // NOTE(ivan-tyulyandin): TBD, flatMap may be not subset, see ReadonlyArray
-    public flatMap<U>(fn: (v: T, k: number, arr: Array<T>) => U): Array<U> {
+    public flatMap<U>(fn: (v: T, k: int, arr: Array<T>) => U): Array<U> {
         let mapped: Array<U> = this.map<U>(fn)
         return mapped.flat<U>()
     }
diff --git a/static_core/plugins/ets/tests/ets_es_checked/array.yaml b/static_core/plugins/ets/tests/ets_es_checked/array.yaml
index 0ec83096868a350e806e052cfe1c3dd9bc2c7021..bcb4072cbaee9affd81b233efd58b17be730930b 100644
--- a/static_core/plugins/ets/tests/ets_es_checked/array.yaml
+++ b/static_core/plugins/ets/tests/ets_es_checked/array.yaml
@@ -31,9 +31,9 @@ sub:
         - |
           (x: number, y: number): number => x * y
         - |
-          (x: number, y: number, i: number): number => x - y + i
+          (x: number, y: number, i): number => x - y + i
         - |
-          (x: number, y: number, i: number, array: Array<number>): number => y - x + i
+          (x: number, y: number, i, array: Array<number>): number => y - x + i
       reduce_u_lamdbas:
         - |
           (): string => "1234.0"
@@ -42,9 +42,9 @@ sub:
         - |
           (x: string, y: number): string => x + y
         - |
-          (x: string, y: number, i: number): string => x + y + i
+          (x: string, y: number, i): string => x + y + i
         - |
-          (x: string, y: number, i: number, array: Array<number>): string => y + x + i
+          (x: string, y: number, i, array: Array<number>): string => y + x + i
     sub:
       - method: "concat"
         rest:
diff --git a/static_core/plugins/ets/tests/ets_es_checked/array_lambas.yaml b/static_core/plugins/ets/tests/ets_es_checked/array_lambas.yaml
index 04fd1a984e87865f34dabc4dfe7950a6bf758a8b..952e05ae6a4a7fae0c8c6eb413c19e384c3b25df 100644
--- a/static_core/plugins/ets/tests/ets_es_checked/array_lambas.yaml
+++ b/static_core/plugins/ets/tests/ets_es_checked/array_lambas.yaml
@@ -41,24 +41,24 @@ sub:
         - |
           (x: number): boolean => Math.abs(x) == 1
         - |
-          (x: number, i: number, s: Array<number>): boolean => (x + i) > 0
+          (x: number, i, s: Array<number>): boolean => (x + i) > 0
         - |
-          (x: number, i: number, s: Array<number>): boolean => (x + i) % 2 == 0
+          (x: number, i, s: Array<number>): boolean => (x + i) % 2 == 0
         - |
-          (x: number, i: number, s: Array<number>): boolean => i % 2 == 0
+          (x: number, i, s: Array<number>): boolean => i % 2 == 0
         - |
-          (x: number, i: number, s: Array<number>): boolean => (x + i) < 0
+          (x: number, i, s: Array<number>): boolean => (x + i) < 0
         - |
-          (x: number, i: number, s: Array<number>): boolean => (x + i) == 1
+          (x: number, i, s: Array<number>): boolean => (x + i) == 1
       number_lambdas:
         - |
           (): number => 1234.0
         - |
           (x: number): number => x * 2.0
         - |
-          (x: number, i: number): number => x + i
+          (x: number, i): number => x + i
         - |
-          (x: number, i: number, s: Array<number>): number => x + i
+          (x: number, i, s: Array<number>): number => x + i
     sub:
       - method: filter
         params:
@@ -86,13 +86,13 @@ sub:
         params:
           -
             - |
-              (value: number, index: number, array: Array<number>): void => {
+              (value: number, index, array: Array<number>): void => {
                 if (array.length < 15) {
                   array.push(-value)
                 }
               }
             - |
-              (value: number, index: number): void => { value = value + index }
+              (value: number, index): void => { value = value + index }
             - |
               (value: number): void => { value = value + value }
             - |
diff --git a/static_core/plugins/ets/tests/ets_func_tests/escompat/ReadonlyArrayTest.ets b/static_core/plugins/ets/tests/ets_func_tests/escompat/ReadonlyArrayTest.ets
index 9c81e2bf4c92c10cba8650576ad213b73b06e1d2..35474684195765ac97a43b975cfa2eaa50f06044 100644
--- a/static_core/plugins/ets/tests/ets_func_tests/escompat/ReadonlyArrayTest.ets
+++ b/static_core/plugins/ets/tests/ets_func_tests/escompat/ReadonlyArrayTest.ets
@@ -79,24 +79,24 @@ function main(): int {
 const RESULT_SUCCESS: int = 0;
 const RESULT_FAILURE: int = 1;
 
-function filterPositiveElement(elem: Number, index: number, arr: ReadonlyArray<Number>): boolean {
+function filterPositiveElement(elem: Number, index: int, arr: ReadonlyArray<Number>): boolean {
     return arr[index.toInt()] == elem && elem.valueOf() == 12 && index > 0;
 }
 
-function filterNegativeElement(elem: Number, index: number, arr: ReadonlyArray<Number>): boolean {
+function filterNegativeElement(elem: Number, index: int, arr: ReadonlyArray<Number>): boolean {
      return arr[index.toInt()] == elem && elem.valueOf() < 0 && index > 0;
 }
 
-function filterUndefinedElement(elem: Number, index: number, arr: ReadonlyArray<Number>): boolean {
+function filterUndefinedElement(elem: Number, index: int, arr: ReadonlyArray<Number>): boolean {
     return arr[index.toInt()] == elem && elem == undefined && index < 0;
 }
 
-function filterNullElement(elem: Number, index: number, arr: ReadonlyArray<Number>) {
+function filterNullElement(elem: Number, index: int, arr: ReadonlyArray<Number>) {
     return arr[index.toInt()] == elem && elem == null && index > 0;
 }
 
 function findWithFuncArg3ReadonlyArray(): int {
-    const fnNull = (elem: Number, index: number, obj: ReadonlyArray<Number>): boolean => { return obj[index.toInt()] == elem && elem == null && index > 0; };
+    const fnNull = (elem: Number, index: int, obj: ReadonlyArray<Number>): boolean => { return obj[index.toInt()] == elem && elem == null && index > 0; };
 
     const arr: ReadonlyArray<Number> = Arrays.copy(TEST_ARRAY);
     if (arr.find(filterPositiveElement) != 12) return RESULT_FAILURE;
@@ -108,9 +108,9 @@ function findWithFuncArg3ReadonlyArray(): int {
 }
 
 function findIndexFuncArg3ReadonlyArray(): int {
-    let fnNegative = (elem: Number, index: number, obj: ReadonlyArray<Number>): boolean => { return obj[index.toInt()] == elem && elem.valueOf() < 0 && index > 0; };
-    let fnUndefined = (elem: Number, index: number, obj: ReadonlyArray<Number>): boolean => { return obj[index.toInt()] == elem && elem == undefined && index < 0; };
-    let fnNull = (elem: Number, index: number, obj: ReadonlyArray<Number>): boolean => { return obj[index.toInt()] == elem && elem == null && index > 0; };
+    let fnNegative = (elem: Number, index: int, obj: ReadonlyArray<Number>): boolean => { return obj[index.toInt()] == elem && elem.valueOf() < 0 && index > 0; };
+    let fnUndefined = (elem: Number, index: int, obj: ReadonlyArray<Number>): boolean => { return obj[index.toInt()] == elem && elem == undefined && index < 0; };
+    let fnNull = (elem: Number, index: int, obj: ReadonlyArray<Number>): boolean => { return obj[index.toInt()] == elem && elem == null && index > 0; };
 
     const arr: ReadonlyArray<Number> = Arrays.copy(TEST_ARRAY);
     if (arr.findIndex(filterPositiveElement) != 9) return RESULT_FAILURE;
@@ -122,7 +122,7 @@ function findIndexFuncArg3ReadonlyArray(): int {
 }
 
 function mapFuncArg3ReadonlyArray(): int {
-    let mappingFunc = (v: Number, index: number, arr: ReadonlyArray<Number>): Number =>
+    let mappingFunc = (v: Number, index: int, arr: ReadonlyArray<Number>): Number =>
         (index < 4) && (index < arr.length) ? Number.valueOf(arr[index.toInt()] * arr[index.toInt()]) : Number.valueOf(0);
 
     let arrEmpty: ReadonlyArray<Number> = new Array<Number>;
@@ -147,14 +147,14 @@ function everyFuncArg3ReadonlyArray(): int {
     if (!emptyArray.every(filterPositiveElement)) return RESULT_FAILURE;
 
     const testArray: ReadonlyArray<Number> = Arrays.copy(TEST_ARRAY);
-    const everyResult = testArray.every((n: Number, i: number, ns: ReadonlyArray<Number>) => n >= -5 && n <= 237);
+    const everyResult = testArray.every((n: Number, i: int, ns: ReadonlyArray<Number>) => n >= -5 && n <= 237);
 
     if (!everyResult) return RESULT_FAILURE;
     return RESULT_SUCCESS;
 }
 
 function filterFuncArg3ReadonlyArray(): int {
-    let fnTrue = (v: Number, index: number, arr: ReadonlyArray<Number>): boolean => {
+    let fnTrue = (v: Number, index: int, arr: ReadonlyArray<Number>): boolean => {
         return arr[index.toInt()].valueOf() == v.valueOf() && v.valueOf() > -1000;
     }
     let arrEmpty = new Array<Number>;
@@ -165,14 +165,14 @@ function filterFuncArg3ReadonlyArray(): int {
 
     if (!Arrays.equals(res, arr)) return RESULT_FAILURE;
 
-    let fnFalse = (v: Number, index: number, arr: ReadonlyArray<Number>): boolean => {
+    let fnFalse = (v: Number, index: int, arr: ReadonlyArray<Number>): boolean => {
         return arr.at(index) == v && v == undefined;
     }
     if (arr.filter(fnFalse).length != 0) return RESULT_FAILURE;
     return RESULT_SUCCESS;
 }
 
-function reduceFunc(a: Number, b: Number, index: number, arr: ReadonlyArray<Number>): Number {
+function reduceFunc(a: Number, b: Number, index: int, arr: ReadonlyArray<Number>): Number {
     if (index < 0 || index >= arr.length) {
         return Number.valueOf(-1);
     }
@@ -246,7 +246,7 @@ function reduceRightFuncArg4ReadonlyArrayWithInitialValue(): int {
 
 function forEachFuncArg3ReadonlyArray(): int {
     let s = new String;
-    let fn = (a: Number, index: number, arr: ReadonlyArray<Number>): void => {
+    let fn = (a: Number, index: int, arr: ReadonlyArray<Number>): void => {
         if (index < 0 && index >= arr.length) {
             s = "";
         } else {
diff --git a/static_core/plugins/ets/tests/ets_func_tests/std/containers/ArrayMapTest.ets b/static_core/plugins/ets/tests/ets_func_tests/std/containers/ArrayMapTest.ets
index 1a96ad825ddbe9dc76bdec99206bbfd30fdf77d0..73450f69bbd592d1467abb9572e384d171bbadfa 100644
--- a/static_core/plugins/ets/tests/ets_func_tests/std/containers/ArrayMapTest.ets
+++ b/static_core/plugins/ets/tests/ets_func_tests/std/containers/ArrayMapTest.ets
@@ -19,12 +19,12 @@ function main(): int {
     return suite.run(); 
 }
 
-type FuncType = (val: number, index: number, obj: Array<number>) => number;
+type FuncType = (val: number, index: int, obj: Array<number>) => number;
 
 class TestData {
     static callCnt = 0;
     static readonly srcArr: Array<number> = new Array<number>(1, 2, 3, 4, 5);
-    static readonly callbackfn: FuncType = (val: number, index: number, obj: Array<number>): number => {
+    static readonly callbackfn: FuncType = (val: number, index: int, obj: Array<number>): number => {
         TestData.srcArr.length = 2;
         TestData.callCnt++;
         return 1;
diff --git a/static_core/plugins/ets/tests/ets_func_tests/std/containers/ArrayReduceRightTest.ets b/static_core/plugins/ets/tests/ets_func_tests/std/containers/ArrayReduceRightTest.ets
index ae76c65d055a722cac5a85bf74b21114022c8d08..b7cbddd8e2fed26927a965fff311378bd7b61c6f 100644
--- a/static_core/plugins/ets/tests/ets_func_tests/std/containers/ArrayReduceRightTest.ets
+++ b/static_core/plugins/ets/tests/ets_func_tests/std/containers/ArrayReduceRightTest.ets
@@ -20,11 +20,11 @@ function main(): int {
     return suite.run(); 
 }
 
-type FuncType = (prevVal: number, curVal: number, idx: number, obj: Array<number>) => number;
+type FuncType = (prevVal: number, curVal: number, idx: int, obj: Array<number>) => number;
 
 class TestData {
     static arr = new Array<number>(1, 2, 3, 4, 5);
-    static readonly callbackfn: FuncType = (prevVal: number, curVal: number, idx: number, obj: Array<number>): number => {
+    static readonly callbackfn: FuncType = (prevVal: number, curVal: number, idx: int, obj: Array<number>): number => {
         TestData.arr.length = 2;
         return prevVal + curVal;
     }
@@ -33,7 +33,7 @@ class TestData {
 
 class TestData1 {
     static arr = new Array<number>(1, 2, 3, 4, 5);
-    static readonly callbackfn: FuncType = (prevVal: number, curVal: number, idx: number, obj: Array<number>): number => {
+    static readonly callbackfn: FuncType = (prevVal: number, curVal: number, idx: int, obj: Array<number>): number => {
         TestData1.arr.push(6,7,8);
         return prevVal + curVal;
     }
diff --git a/static_core/plugins/ets/tests/interop_js/tests/array/ts_to_ets/test_sts_array.ets b/static_core/plugins/ets/tests/interop_js/tests/array/ts_to_ets/test_sts_array.ets
index 5baf4bce437c1dfff588ce2bc707917d394f26a1..2d630844c0342ae09f941cda150240bed715e915 100644
--- a/static_core/plugins/ets/tests/interop_js/tests/array/ts_to_ets/test_sts_array.ets
+++ b/static_core/plugins/ets/tests/interop_js/tests/array/ts_to_ets/test_sts_array.ets
@@ -63,21 +63,21 @@ let arraySplice4: Array<Number> = arrSplice4 as Array<Number>
 let arrayToSorted: Array<Number> = arrToSorted as Array<Number>
 let arrayUnShift: Array<Number> = arrUnShift as Array<Number>
 
-const funcPredicate1 = (num: number, index: number, array: Array<Number>): boolean => num % 2 === 0
+const funcPredicate1 = (num: number, index: int, array: Array<Number>): boolean => num % 2 === 0
 
-const funcPredicate2 = (num: number, index: number, array: Array<Number>): boolean => num < 6
+const funcPredicate2 = (num: number, index: int, array: Array<Number>): boolean => num < 6
 
-const mapAndFlatten = (num: number, k: number, arr: Array<Number>): Number => num * num
+const mapAndFlatten = (num: number, k: int, arr: Array<Number>): Number => num * num
 
 const flatMapAndFlatten = (num: number): FixedArray<Number> => [num * num]
 
-const processElement = (element: number, index: number, array: Array<Number>): void => result = (element === index + 1)
+const processElement = (element: number, index: int, array: Array<Number>): void => result = (element === index + 1)
 
-const sumReducer = (previousValue: number, currentValue: number, index: number, array: Array<Number>): number => {
+const sumReducer = (previousValue: number, currentValue: number, index: int, array: Array<Number>): number => {
     return previousValue + currentValue
 }
 
-const concatenateReducer = (previousValue: string, currentValue: string, index: number, array: Array<string>): string => {
+const concatenateReducer = (previousValue: string, currentValue: string, index: int, array: Array<string>): string => {
     return previousValue + "" + currentValue
 }
 
diff --git a/static_core/plugins/ets/tests/interop_js/tests/escompat/escompat.ets b/static_core/plugins/ets/tests/interop_js/tests/escompat/escompat.ets
index 8fca70f49cdaa1cd8726dac9088f0141e33f789a..28e170f03f6c1f4b9504329a83a3ab25cb722e71 100644
--- a/static_core/plugins/ets/tests/interop_js/tests/escompat/escompat.ets
+++ b/static_core/plugins/ets/tests/interop_js/tests/escompat/escompat.ets
@@ -94,35 +94,35 @@ function Array_TestJSJoin(arr: Array<FooClass>): void {
 
 function Array_TestJSSome(arr: Array<FooClass>): void {
     let fnTrue: (v: FooClass) => boolean = (v: FooClass): boolean => { return true; }
-    let fn1True: (v: FooClass, k: number) => boolean = (v: FooClass, k: number): boolean => { return true; }
+    let fn1True = (v: FooClass, k: int): boolean => true;
     arktest.assertEQ(arr.some(fnTrue), true);
     arktest.assertEQ(arr.some(fn1True), true);
     let fnFalse: (v: FooClass) => boolean = (v: FooClass): boolean => { return false; }
-    let fn1False: (v: FooClass, k: number) => boolean = (v: FooClass, k: number): boolean => { return k < 0; }
+    let fn1False = (v: FooClass, k: int): boolean => k < 0;
     arktest.assertEQ(!arr.some(fnFalse), true);
     arktest.assertEQ(!arr.some(fn1False), true);
 }
 
 function Array_TestJSEvery(arr: Array<FooClass>): void {
     let fnTrue: (v: FooClass) => boolean = (v: FooClass): boolean => { return true; }
-    let fn1True: (v: FooClass, k: number) => boolean = (v: FooClass, k: number): boolean => { return true; }
+    let fn1True = (v: FooClass, k: int): boolean => true;
     arktest.assertEQ(arr.every(fnTrue), true);
     arktest.assertEQ(arr.every(fn1True), true);
     let fnFalse: (v: FooClass) => boolean = (v: FooClass): boolean => { return false; }
-    let fn1False: (v: FooClass, k: number) => boolean = (v: FooClass, k: number): boolean => { return k < 0; }
+    let fn1False = (v: FooClass, k: int): boolean => k < 0;
     arktest.assertEQ(!arr.every(fnFalse), true);
     arktest.assertEQ(!arr.every(fn1False), true);
 }
 
 function Array_TestJSFilter(arr: Array<FooClass>): void {
     let fnTrue: (v: FooClass) => boolean = (v: FooClass): boolean => { return true; }
-    let fn1True: (v: FooClass, k: number) => boolean = (v: FooClass, k: number): boolean => { return true; }
+    let fn1True = (v: FooClass, k: int): boolean => true;
     let filter = arr.filter(fnTrue);
     let filter1 = arr.filter(fn1True);
     arktest.assertEQ(arr.at(0), filter.at(0));
     arktest.assertEQ(arr.at(0), filter1.at(0));
     let fnFalse: (v: FooClass) => boolean = (v: FooClass): boolean => { return false; }
-    let fn1False: (v: FooClass, k: number) => boolean = (v: FooClass, k: number): boolean => { return k < 0; }
+    let fn1False = (v: FooClass, k: int): boolean => k < 0;
     let filterFalse = arr.filter(fnFalse);
     let filter1False = arr.filter(fn1False);
     arktest.assertNE(arr.at(0), filterFalse.at(0));
diff --git a/static_core/plugins/ets/tests/stdlib-templates/escompat/escompat_Array_single.ets b/static_core/plugins/ets/tests/stdlib-templates/escompat/escompat_Array_single.ets
index e852b8260fc1f3c481e749716f99c3e5e8924945..0e5dbcf1add89eaaeaf765a639851a85acdb658c 100644
--- a/static_core/plugins/ets/tests/stdlib-templates/escompat/escompat_Array_single.ets
+++ b/static_core/plugins/ets/tests/stdlib-templates/escompat/escompat_Array_single.ets
@@ -89,7 +89,7 @@ function testCreateFromString2(): int {
 function testFiltered(): int {
     let src: String = "HHeelllloo";
     let exp: String = "Hello";
-    let test = Array.from(src, (c: string, i: number): string => c).filter((v: String, k: number): boolean => k%2 == 0);
+    let test = Array.from(src, (c: string, i: number): string => c).filter((v: String, k: int): boolean => k%2 == 0);
 
     if(test.length != exp.length) {
         console.println("Array size mismatch");
diff --git a/static_core/plugins/ets/tests/stdlib-templates/std/core/list.std_core_array_foreach.yaml b/static_core/plugins/ets/tests/stdlib-templates/std/core/list.std_core_array_foreach.yaml
index 2ad788da33ff5b63ea2389cfeddba69e73acccb7..03d2ab6995a763e5ddf11ff54e0cc94cdfdd937a 100644
--- a/static_core/plugins/ets/tests/stdlib-templates/std/core/list.std_core_array_foreach.yaml
+++ b/static_core/plugins/ets/tests/stdlib-templates/std/core/list.std_core_array_foreach.yaml
@@ -17,7 +17,7 @@
     result: arr,
     result_nature: array,
     result_type: "FixedArray<boolean>",
-    method_signature: { arr: "FixedArray<boolean>", fn : "(value:boolean,index:number,self:FixedArray<boolean>)=>void" },
+    method_signature: { arr: "FixedArray<boolean>", fn : "(value:boolean,index:int,self:FixedArray<boolean>)=>void" },
     method_throws: "false",
     method_signature_desc: {arr: "boolean_array", fn: "func_boolean_int_boolean_array"},
     method_test_index_data:
@@ -25,12 +25,12 @@
         test1:
           {
             arr: "[false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false]",
-            fn: '(value:boolean,index:number,self:FixedArray<boolean>): void =>  {self[index.toInt()] = !value}',
+            fn: '(value:boolean,index:int,self:FixedArray<boolean>): void =>  {self[index.toInt()] = !value}',
           },
         test2:
           {
             arr: "[]",
-            fn: '(value:boolean,index:number,self:FixedArray<boolean>): void =>  {self[index.toInt()] = !value}',
+            fn: '(value:boolean,index:int,self:FixedArray<boolean>): void =>  {self[index.toInt()] = !value}',
           },
 
       },
@@ -46,7 +46,7 @@
     result: arr,
     result_nature: array,
     result_type: "FixedArray<byte>",
-    method_signature: { arr: "FixedArray<byte>", fn : "(value:byte,index:number,self:FixedArray<byte>)=>void" },
+    method_signature: { arr: "FixedArray<byte>", fn : "(value:byte,index:int,self:FixedArray<byte>)=>void" },
     method_throws: "false",
     method_signature_desc: {arr: "byte_array", fn: "func_byte_int_byte_array"},
     method_test_index_data:
@@ -54,17 +54,17 @@
         test1:
           {
             arr: "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]",
-            fn: '(value:byte,index:number,self:FixedArray<byte>): void =>  {self[index.toInt()] = ((value * 2).toByte())}',
+            fn: '(value:byte,index:int,self:FixedArray<byte>): void =>  {self[index.toInt()] = ((value * 2).toByte())}',
           },
           test2:
           {
             arr: "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]",
-            fn: '(value:byte,index:number,self:FixedArray<byte>): void =>  {self[index.toInt()] = ((value + index.toInt()).toByte())}',
+            fn: '(value:byte,index:int,self:FixedArray<byte>): void =>  {self[index.toInt()] = ((value + index.toInt()).toByte())}',
           },
           test3:
           {
             arr: "[]",
-            fn: '(value:byte,index:number,self:FixedArray<byte>): void =>  {self[index.toInt()] = ((value + index.toInt()).toByte())}',
+            fn: '(value:byte,index:int,self:FixedArray<byte>): void =>  {self[index.toInt()] = ((value + index.toInt()).toByte())}',
           },
       },
       method_expected_data:
@@ -80,7 +80,7 @@
     result: arr,
     result_nature: array,
     result_type: "FixedArray<short>",
-    method_signature: { arr: "FixedArray<short>", fn : "(value:short,index:number,self:FixedArray<short>)=>void" },
+    method_signature: { arr: "FixedArray<short>", fn : "(value:short,index:int,self:FixedArray<short>)=>void" },
     method_throws: "false",
     method_signature_desc: {arr: "short_array", fn: "func_short_int_short_array"},
     method_test_index_data:
@@ -88,17 +88,17 @@
         test1:
           {
             arr: "[0 ,1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]",
-            fn: '(value:short,index:number,self:FixedArray<short>): void =>  {self[index.toInt()] = ((value * 2).toShort())}',
+            fn: '(value:short,index:int,self:FixedArray<short>): void =>  {self[index.toInt()] = ((value * 2).toShort())}',
           },
         test2:
           {
             arr: "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]",
-            fn: '(value:short,index:number,self:FixedArray<short>): void =>  {self[index.toInt()] = ((value + index.toInt()).toShort())}',
+            fn: '(value:short,index:int,self:FixedArray<short>): void =>  {self[index.toInt()] = ((value + index.toInt()).toShort())}',
           },
         test3:
           {
             arr: "[]",
-            fn: '(value:short,index:number,self:FixedArray<short>): void =>  {self[index.toInt()] = ((value + index.toInt()).toShort())}',
+            fn: '(value:short,index:int,self:FixedArray<short>): void =>  {self[index.toInt()] = ((value + index.toInt()).toShort())}',
           },
       },
       method_expected_data:
@@ -114,7 +114,7 @@
     result: arr,
     result_nature: array,
     result_type: "FixedArray<int>",
-    method_signature: { arr: "FixedArray<int>", fn : "(value:int,index:number,self:FixedArray<int>)=>void" },
+    method_signature: { arr: "FixedArray<int>", fn : "(value:int,index:int,self:FixedArray<int>)=>void" },
     method_throws: "false",
     method_signature_desc: {arr: "int_array", fn: "func_int_int_int_array"},
     method_test_index_data:
@@ -122,17 +122,17 @@
         test1:
           {
             arr: "[0 ,1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]",
-            fn: '(value:int,index:number,self:FixedArray<int>): void =>  {self[index.toInt()] = value * 2}',
+            fn: '(value:int,index:int,self:FixedArray<int>): void =>  {self[index.toInt()] = value * 2}',
           },
         test2:
           {
             arr: "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]",
-            fn: '(value:int,index:number,self:FixedArray<int>): void =>  {self[index.toInt()] = value + index.toInt()}',
+            fn: '(value:int,index:int,self:FixedArray<int>): void =>  {self[index.toInt()] = value + index.toInt()}',
           },
         test3:
           {
             arr: "[]",
-            fn: '(value:int,index:number,self:FixedArray<int>): void =>  {self[index.toInt()] = value + index.toInt()}',
+            fn: '(value:int,index:int,self:FixedArray<int>): void =>  {self[index.toInt()] = value + index.toInt()}',
           },
       },
       method_expected_data:
@@ -148,7 +148,7 @@
     result: arr,
     result_nature: array,
     result_type: "FixedArray<long>",
-    method_signature: { arr: "FixedArray<long>", fn : "(value:long,index:number,self:FixedArray<long>)=>void" },
+    method_signature: { arr: "FixedArray<long>", fn : "(value:long,index:int,self:FixedArray<long>)=>void" },
     method_throws: "false",
     method_signature_desc: {arr: "long_array", fn: "func_long_int_long_array"},
     method_test_index_data:
@@ -156,17 +156,17 @@
        test1:
          {
           arr: "[0 ,1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]",
-          fn: '(value:long,index:number,self:FixedArray<long>): void =>  {self[index.toInt()] = value * 2}',
+          fn: '(value:long,index:int,self:FixedArray<long>): void =>  {self[index.toInt()] = value * 2}',
         },
       test2:
           {
             arr: "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]",
-            fn: '(value:long,index:number,self:FixedArray<long>): void =>  {self[index.toInt()] = value + index.toInt()}',
+            fn: '(value:long,index:int,self:FixedArray<long>): void =>  {self[index.toInt()] = value + index.toInt()}',
           },
       test3:
           {
             arr: "[]",
-            fn: '(value:long,index:number,self:FixedArray<long>): void =>  {self[index.toInt()] = value + index.toInt()}',
+            fn: '(value:long,index:int,self:FixedArray<long>): void =>  {self[index.toInt()] = value + index.toInt()}',
           },
       },
       method_expected_data:
@@ -182,7 +182,7 @@
     result: arr,
     result_nature: array,
     result_type: "FixedArray<float>",
-    method_signature: { arr: "FixedArray<float>", fn : "(value:float,index:number,self:FixedArray<float>)=>void" },
+    method_signature: { arr: "FixedArray<float>", fn : "(value:float,index:int,self:FixedArray<float>)=>void" },
     method_throws: "false",
     method_signature_desc: {arr: "float_array", fn: "func_float_int_float_array"},
     method_test_index_data:
@@ -190,17 +190,17 @@
         test1:
           {
             arr: "[0 ,1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]",
-            fn: '(value:float,index:number,self:FixedArray<float>): void =>  {self[index.toInt()] = value * 2}',
+            fn: '(value:float,index:int,self:FixedArray<float>): void =>  {self[index.toInt()] = value * 2}',
           },
         test2:
           {
             arr: "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]",
-            fn: '(value:float,index:number,self:FixedArray<float>): void =>  {self[index.toInt()] = value + index.toInt()}',
+            fn: '(value:float,index:int,self:FixedArray<float>): void =>  {self[index.toInt()] = value + index.toInt()}',
           },
         test3:
           {
             arr: "[]",
-            fn: '(value:float,index:number,self:FixedArray<float>): void =>  {self[index.toInt()] = value + index.toInt()}',
+            fn: '(value:float,index:int,self:FixedArray<float>): void =>  {self[index.toInt()] = value + index.toInt()}',
           },
       },
       method_expected_data:
@@ -216,7 +216,7 @@
     result: arr,
     result_nature: array,
     result_type: "FixedArray<double>",
-    method_signature: { arr: "FixedArray<double>", fn : "(value:double,index:number,self:FixedArray<double>)=>void" },
+    method_signature: { arr: "FixedArray<double>", fn : "(value:double,index:int,self:FixedArray<double>)=>void" },
     method_throws: "false",
     method_signature_desc: {arr: "double_array", fn: "func_double_int_double_array"},
     method_test_index_data:
@@ -224,17 +224,17 @@
         test1:
           {
             arr: "[0 ,1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]",
-            fn: '(value:double,index:number,self:FixedArray<double>): void =>  {self[index.toInt()] = value * 2}',
+            fn: '(value:double,index:int,self:FixedArray<double>): void =>  {self[index.toInt()] = value * 2}',
           },
         test2:
           {
             arr: "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]",
-            fn: '(value:double,index:number,self:FixedArray<double>): void =>  {self[index.toInt()] = value + index.toInt()}',
+            fn: '(value:double,index:int,self:FixedArray<double>): void =>  {self[index.toInt()] = value + index.toInt()}',
           },
         test3:
           {
             arr: "[]",
-            fn: '(value:double,index:number,self:FixedArray<double>): void =>  {self[index.toInt()] = value + index.toInt()}',
+            fn: '(value:double,index:int,self:FixedArray<double>): void =>  {self[index.toInt()] = value + index.toInt()}',
           },
       },
       method_expected_data:
@@ -250,7 +250,7 @@
     result: arr,
     result_nature: array,
     result_type: "FixedArray<char>",
-    method_signature: { arr: "FixedArray<char>", fn : "(value:char,index:number,self:FixedArray<char>)=>void" },
+    method_signature: { arr: "FixedArray<char>", fn : "(value:char,index:int,self:FixedArray<char>)=>void" },
     method_throws: "false",
     method_signature_desc: {arr: "char_array", fn: "func_char_int_char_array"},
       method_test_index_data:
@@ -258,17 +258,17 @@
         test1:
           {
             arr: "[c'\\x00', c'\\x01', c'\\x02', c'\\x03', c'\\x04', c'\\x05', c'\\x06', c'\\x07', c'\\x08', c'\\x09', c'\\x0A', c'\\x0B', c'\\x0C', c'\\x0D', c'\\x0E', c'\\x0F']",
-            fn: '(value:char,index:number,self:FixedArray<char>): void =>  {self[index.toInt()] = (value.toInt() * 2).toChar()}',
+            fn: '(value:char,index:int,self:FixedArray<char>): void =>  {self[index.toInt()] = (value.toInt() * 2).toChar()}',
           },
         test2:
           {
             arr: "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]",
-            fn: '(value:char,index:number,self:FixedArray<char>): void =>  {self[index.toInt()] = (value.toInt() + index.toInt()).toChar()}',
+            fn: '(value:char,index:int,self:FixedArray<char>): void =>  {self[index.toInt()] = (value.toInt() + index.toInt()).toChar()}',
           },
         test3:
           {
             arr: "[]",
-            fn: '(value:char,index:number,self:FixedArray<char>): void =>  {self[index.toInt()] = (value.toInt() + index.toInt()).toChar(0}',
+            fn: '(value:char,index:int,self:FixedArray<char>): void =>  {self[index.toInt()] = (value.toInt() + index.toInt()).toChar(0}',
           },
       },
       method_expected_data:
diff --git a/static_core/plugins/ets/tests/stdlib-templates/std/core/list.std_core_array_map.yaml b/static_core/plugins/ets/tests/stdlib-templates/std/core/list.std_core_array_map.yaml
index df7260a5901d50bcb518a9860d1d71bcd2187d06..5a1907275d18e648fcec57667dc92f50d1f270d9 100644
--- a/static_core/plugins/ets/tests/stdlib-templates/std/core/list.std_core_array_map.yaml
+++ b/static_core/plugins/ets/tests/stdlib-templates/std/core/list.std_core_array_map.yaml
@@ -16,7 +16,7 @@
     method_nature: function,
     result_nature: array,
     result_type: "FixedArray<boolean>",
-    method_signature: { arr: "FixedArray<boolean>", fn : "(value:boolean,index:number,self:FixedArray<boolean>)=>boolean" },
+    method_signature: { arr: "FixedArray<boolean>", fn : "(value:boolean,index:int,self:FixedArray<boolean>)=>boolean" },
     method_throws: "false",
     method_signature_desc: {arr: "boolean_array", fn: "func_boolean_int_boolean_array"},
     method_test_index_data:
@@ -24,12 +24,12 @@
         test1:
           {
             arr: "[true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true]",
-            fn: '(value:boolean,index:number,self:FixedArray<boolean>): boolean =>  {return !value}',
+            fn: '(value:boolean,index:int,self:FixedArray<boolean>): boolean =>  {return !value}',
           },
         test1:
           {
             arr: "[]",
-            fn: '(value:boolean,index:number,self:FixedArray<boolean>): boolean =>  {return !value}',
+            fn: '(value:boolean,index:int,self:FixedArray<boolean>): boolean =>  {return !value}',
           },
       },
     method_expected_data:
@@ -43,7 +43,7 @@
     method_nature: function,
     result_nature: array,
     result_type: "FixedArray<byte>",
-    method_signature: { arr: "FixedArray<byte>", fn : "(value:byte,index:number,self:FixedArray<byte>)=>byte" },
+    method_signature: { arr: "FixedArray<byte>", fn : "(value:byte,index:int,self:FixedArray<byte>)=>byte" },
     method_throws: "false",
     method_signature_desc: {arr: "byte_array", fn: "func_byte_int_byte_array"},
     method_test_index_data:
@@ -51,17 +51,17 @@
         test1:
           {
             arr: "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]",
-            fn: '(value:byte,index:number,self:FixedArray<byte>): byte =>  {return ((value * 2).toByte())}',
+            fn: '(value:byte,index:int,self:FixedArray<byte>): byte =>  {return ((value * 2).toByte())}',
           },
           test2:
           {
             arr: "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]",
-            fn: '(value:byte,index:number,self:FixedArray<byte>): byte =>  {return ((value + index).toByte())}',
+            fn: '(value:byte,index:int,self:FixedArray<byte>): byte =>  {return ((value + index).toByte())}',
           },
           test3:
           {
             arr: "[]",
-            fn: '(value:byte,index:number,self:FixedArray<byte>): byte =>  {return ((value + index).toByte())}',
+            fn: '(value:byte,index:int,self:FixedArray<byte>): byte =>  {return ((value + index).toByte())}',
           },
       },
     method_expected_data:
@@ -76,7 +76,7 @@
     method_nature: function,
     result_nature: array,
     result_type: "FixedArray<short>",
-    method_signature: { arr: "FixedArray<short>", fn : "(value:short,index:number,self:FixedArray<short>)=>short" },
+    method_signature: { arr: "FixedArray<short>", fn : "(value:short,index:int,self:FixedArray<short>)=>short" },
     method_throws: "false",
     method_signature_desc: {arr: "short_array", fn: "func_short_int_short_array"},
     method_test_index_data:
@@ -84,17 +84,17 @@
         test1:
           {
             arr: "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]",
-            fn: '(value:short,index:number,self:FixedArray<short>): short =>  {return ((value * 2).toShort())}',
+            fn: '(value:short,index:int,self:FixedArray<short>): short =>  {return ((value * 2).toShort())}',
           },
         test2:
           {
             arr: "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]",
-            fn: '(value:short,index:number,self:FixedArray<short>): short =>  {return ((value + index).toShort())}',
+            fn: '(value:short,index:int,self:FixedArray<short>): short =>  {return ((value + index).toShort())}',
           },
         test3:
           {
             arr: "[]",
-            fn: '(value:short,index:number,self:FixedArray<short>): short =>  {return ((value + index).toShort())}',
+            fn: '(value:short,index:int,self:FixedArray<short>): short =>  {return ((value + index).toShort())}',
           },
       },
     method_expected_data:
@@ -109,7 +109,7 @@
     method_nature: function,
     result_nature: array,
     result_type: "FixedArray<int>",
-    method_signature: { arr: "FixedArray<int>", fn : "(value:int,index:number,self:FixedArray<int>)=>int" },
+    method_signature: { arr: "FixedArray<int>", fn : "(value:int,index:int,self:FixedArray<int>)=>int" },
     method_throws: "false",
     method_signature_desc: {arr: "int_array", fn: "func_int_int_int_array"},
     method_test_index_data:
@@ -117,17 +117,17 @@
         test1:
           {
             arr: "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]",
-            fn: '(value:int,index:number,self:FixedArray<int>): int =>  {return value * 2}',
+            fn: '(value:int,index:int,self:FixedArray<int>): int =>  {return value * 2}',
           },
         test2:
           {
             arr: "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]",
-            fn: '(value:int,index:number,self:FixedArray<int>): int =>  {return (value + index).toInt()}',
+            fn: '(value:int,index:int,self:FixedArray<int>): int =>  {return (value + index).toInt()}',
           },
         test3:
           {
             arr: "[]",
-            fn: '(value:int,index:number,self:FixedArray<int>): int =>  {return (value + index).toInt()}',
+            fn: '(value:int,index:int,self:FixedArray<int>): int =>  {return (value + index).toInt()}',
           },
 
       },
@@ -143,7 +143,7 @@
     method_nature: function,
     result_nature: array,
     result_type: "FixedArray<long>",
-    method_signature: { arr: "FixedArray<long>", fn : "(value:long,index:number,self:FixedArray<long>)=>long" },
+    method_signature: { arr: "FixedArray<long>", fn : "(value:long,index:int,self:FixedArray<long>)=>long" },
     method_throws: "false",
     method_signature_desc: {arr: "long_array", fn: "func_long_int_long_array"},
     method_test_index_data:
@@ -151,17 +151,17 @@
         test1:
           {
             arr: "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]",
-            fn: '(value:long,index:number,self:FixedArray<long>): long =>  {return value * 2}',
+            fn: '(value:long,index:int,self:FixedArray<long>): long =>  {return value * 2}',
           },
         test2:
           {
             arr: "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]",
-            fn: '(value:long,index:number,self:FixedArray<long>): long =>  {return (value + index).toLong()}',
+            fn: '(value:long,index:int,self:FixedArray<long>): long =>  {return (value + index).toLong()}',
           },
         test3:
           {
             arr: "[]",
-            fn: '(value:long,index:number,self:FixedArray<long>): long =>  {return (value + index).toLong()}',
+            fn: '(value:long,index:int,self:FixedArray<long>): long =>  {return (value + index).toLong()}',
           },
 
       },
@@ -177,7 +177,7 @@
     method_nature: function,
     result_nature: array,
     result_type: "FixedArray<float>",
-    method_signature: { arr: "FixedArray<float>", fn : "(value:float,index:number,self:FixedArray<float>)=>float" },
+    method_signature: { arr: "FixedArray<float>", fn : "(value:float,index:int,self:FixedArray<float>)=>float" },
     method_throws: "false",
     method_signature_desc: {arr: "float_array", fn: "func_float_int_float_array"},
     method_test_index_data:
@@ -185,17 +185,17 @@
         test1:
           {
             arr: "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]",
-            fn: '(value:float,index:number,self:FixedArray<float>): float =>  {return value * 2}',
+            fn: '(value:float,index:int,self:FixedArray<float>): float =>  {return value * 2}',
           },
         test2:
           {
             arr: "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]",
-            fn: '(value:float,index:number,self:FixedArray<float>): float =>  {return (value + index).toFloat()}',
+            fn: '(value:float,index:int,self:FixedArray<float>): float =>  {return (value + index).toFloat()}',
           },
         test3:
           {
             arr: "[]",
-            fn: '(value:float,index:number,self:FixedArray<float>): float =>  {return (value + index).toFloat()}',
+            fn: '(value:float,index:int,self:FixedArray<float>): float =>  {return (value + index).toFloat()}',
           },
 
       },
@@ -211,7 +211,7 @@
     method_nature: function,
     result_nature: array,
     result_type: "FixedArray<double>",
-    method_signature: { arr: "FixedArray<double>", fn : "(value:double,index:number,self:FixedArray<double>)=>double" },
+    method_signature: { arr: "FixedArray<double>", fn : "(value:double,index:int,self:FixedArray<double>)=>double" },
     method_throws: "false",
     method_signature_desc: {arr: "double_array", fn: "func_double_int_double_array"},
     method_test_index_data:
@@ -219,17 +219,17 @@
         test1:
           {
             arr: "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]",
-            fn: '(value:double,index:number,self:FixedArray<double>): double =>  {return value * 2}',
+            fn: '(value:double,index:int,self:FixedArray<double>): double =>  {return value * 2}',
           },
         test2:
           {
             arr: "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]",
-            fn: '(value:double,index:number,self:FixedArray<double>): double =>  {return (value + index)}',
+            fn: '(value:double,index:int,self:FixedArray<double>): double =>  {return (value + index)}',
           },
         test3:
           {
             arr: "[]",
-            fn: '(value:double,index:number,self:FixedArray<double>): double =>  {return (value + index)}',
+            fn: '(value:double,index:int,self:FixedArray<double>): double =>  {return (value + index)}',
           },
       },
     method_expected_data: