@daiso-tech/core 0.1.1 → 0.1.3

package/dist/esm/collection/iterable-collection/iterable-collection.js

@@ -1,10 +1,10 @@
 import { CollectionError, ItemNotFoundError, MultipleItemsFoundError, IndexOverflowError, UnexpectedCollectionError, } from "../../contracts/collection/_module";
-import { CrossJoinIterable, SlidingIteralbe, ShuffleIterable, EntriesIterable, FilterIterable, ChunkIterable, ChunkWhileIterable, CollapseIterable, CountByIterable, FlatMapIterable, GroupByIterable, InsertAfterIterable, InsertBeforeIterable, MapIterable, MergeIterable, PadEndIterable, PadStartIterable, PartionIterable, SkipIterable, SkipUntilIterable, SortIterable, SplitIterable, TakeIterable, TakeUntilIterable, TapIterable, UniqueIterable, UpdateIterable, WhenIterable, ZipIterable, ReverseIterable, SliceIterable, RepeatIterable, } from "../../collection/iterable-collection/iterable-helpers/_module";
+import { CrossJoinIterable, SlidingIteralbe, ShuffleIterable, EntriesIterable, FilterIterable, ChunkIterable, ChunkWhileIterable, CollapseIterable, CountByIterable, FlatMapIterable, GroupByIterable, InsertAfterIterable, InsertBeforeIterable, MapIterable, MergeIterable, PadEndIterable, PadStartIterable, PartionIterable, SkipIterable, SkipUntilIterable, SortIterable, SplitIterable, TakeIterable, TakeUntilIterable, TapIterable, UniqueIterable, UpdateIterable, WhenIterable, ZipIterable, ReverseIterable, SliceIterable, RepeatIterable, } from "../../collection/iterable-collection/_shared/_module";
 export class IterableCollection {
     iterable;
     static THROW_ON_NUMBER_LIMIT = false;
     static DEFAULT_CHUNK_SIZE = 1024;
-    static makeCollection = (iterable) => {
+    static makeCollection = (iterable = []) => {
         return new IterableCollection(iterable);
     };
     constructor(iterable) {
@@ -22,34 +22,37 @@ export class IterableCollection {
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    iterator() {
+    toIterator() {
         return this[Symbol.iterator]();
     }
-    entries(throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new IterableCollection(new EntriesIterable(this, throwOnNumberLimit));
+    entries(throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return new IterableCollection(new EntriesIterable(this, throwOnIndexOverflow));
     }
-    keys(throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return this.entries(throwOnNumberLimit).map(([key]) => key);
+    keys(throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return this.entries(throwOnIndexOverflow).map(([key]) => key);
     }
     values() {
         return this.entries().map(([_key, value]) => value);
     }
-    filter(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new IterableCollection(new FilterIterable(this, filter, throwOnNumberLimit));
+    filter(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return new IterableCollection(new FilterIterable(this, predicateFn, throwOnIndexOverflow));
     }
-    map(map, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new IterableCollection(new MapIterable(this, map, throwOnNumberLimit));
+    reject(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return this.filter((...arguments_) => !predicateFn(...arguments_), throwOnIndexOverflow);
+    }
+    map(mapFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return new IterableCollection(new MapIterable(this, mapFn, throwOnIndexOverflow));
     }
     reduce(settings) {
         try {
-            const { reduceFn: reduce, initialValue, throwOnNumberLimit, } = settings;
-            if (initialValue === undefined && this.empty()) {
+            const { reduceFn: reduce, initialValue, throwOnIndexOverflow, } = settings;
+            if (initialValue === undefined && this.isEmpty()) {
                 throw new TypeError("Reduce of empty array must be inputed a initial value");
             }
             if (initialValue !== undefined) {
                 let output = initialValue, index = 0;
                 for (const item of this) {
-                    if (throwOnNumberLimit &&
+                    if (throwOnIndexOverflow &&
                         index === Number.MAX_SAFE_INTEGER) {
                         throw new IndexOverflowError("Index has overflowed");
                     }
@@ -61,7 +64,7 @@ export class IterableCollection {
             let output = this.firstOrFail(), index = 0, isFirstIteration = true;
             for (const item of this) {
                 if (!isFirstIteration) {
-                    if (throwOnNumberLimit &&
+                    if (throwOnIndexOverflow &&
                         index === Number.MAX_SAFE_INTEGER) {
                         throw new IndexOverflowError("Index has overflowed");
                     }
@@ -90,7 +93,7 @@ export class IterableCollection {
                     const separator = settings?.seperator ?? ",";
                     return str + separator + item;
                 },
-                throwOnNumberLimit: settings?.throwOnNumberLimit ??
+                throwOnIndexOverflow: settings?.throwOnIndexOverflow ??
                     IterableCollection.THROW_ON_NUMBER_LIMIT,
             });
         }
@@ -105,26 +108,23 @@ export class IterableCollection {
     collapse() {
         return new IterableCollection(new CollapseIterable(this));
     }
-    flatMap(map, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new IterableCollection(new FlatMapIterable(this, map, throwOnNumberLimit));
+    flatMap(mapFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return new IterableCollection(new FlatMapIterable(this, mapFn, throwOnIndexOverflow));
     }
-    update(filter, map, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new IterableCollection(new UpdateIterable(this, filter, map, throwOnNumberLimit));
+    update(predicateFn, mapFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return new IterableCollection(new UpdateIterable(this, predicateFn, mapFn, throwOnIndexOverflow));
     }
     page(settings) {
-        const { page, pageSize, throwOnNumberLimit } = settings;
+        const { page, pageSize, throwOnIndexOverflow } = settings;
         if (page < 0) {
-            return this.skip(page * pageSize, throwOnNumberLimit).take(pageSize, throwOnNumberLimit);
+            return this.skip(page * pageSize, throwOnIndexOverflow).take(pageSize, throwOnIndexOverflow);
         }
-        return this.skip((page - 1) * pageSize, throwOnNumberLimit).take(page * pageSize, throwOnNumberLimit);
+        return this.skip((page - 1) * pageSize, throwOnIndexOverflow).take(page * pageSize, throwOnIndexOverflow);
     }
-    sum(throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+    sum() {
         try {
             let sum = 0;
             for (const item of this) {
-                if (throwOnNumberLimit && sum === Number.MAX_SAFE_INTEGER) {
-                    throw new IndexOverflowError("Sum has overflowed");
-                }
                 if (typeof item !== "number") {
                     throw new TypeError("Item type is invalid must be number");
                 }
@@ -140,16 +140,10 @@ export class IterableCollection {
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    average(throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+    average() {
         try {
             let size = 0, sum = 0;
             for (const item of this) {
-                if (throwOnNumberLimit && sum === Number.MAX_SAFE_INTEGER) {
-                    throw new IndexOverflowError("The sum has overflowed");
-                }
-                if (throwOnNumberLimit && size === Number.MAX_SAFE_INTEGER) {
-                    throw new IndexOverflowError("The size has overflowed");
-                }
                 if (typeof item !== "number") {
                     throw new TypeError("Item type is invalid must be number");
                 }
@@ -166,11 +160,11 @@ export class IterableCollection {
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    median(throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        if (this.empty()) {
+    median(throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        if (this.isEmpty()) {
             return 0;
         }
-        const size = this.size(throwOnNumberLimit);
+        const size = this.size(throwOnIndexOverflow);
         if (size === 0) {
             return 0;
         }
@@ -179,13 +173,13 @@ export class IterableCollection {
                 throw new TypeError("Item type is invalid must be number");
             }
             return item;
-        }, throwOnNumberLimit)
+        }, throwOnIndexOverflow)
             .filter((_item, index) => {
             if (isEven) {
                 return index === size / 2 || index === size / 2 - 1;
             }
             return index === Math.floor(size / 2);
-        }, throwOnNumberLimit)
+        }, throwOnIndexOverflow)
             .toArray();
         if (isEven) {
             const [a, b] = items;
@@ -251,17 +245,17 @@ export class IterableCollection {
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    percentage(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+    percentage(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
         try {
-            if (this.empty()) {
+            if (this.isEmpty()) {
                 return 0;
             }
             let part = 0, total = 0;
             for (const item of this) {
-                if (throwOnNumberLimit && total === Number.MAX_SAFE_INTEGER) {
+                if (throwOnIndexOverflow && total === Number.MAX_SAFE_INTEGER) {
                     throw new IndexOverflowError("The total amount has overflowed");
                 }
-                if (filter(item, total, this)) {
+                if (predicateFn(item, total, this)) {
                     part++;
                 }
                 total++;
@@ -276,14 +270,14 @@ export class IterableCollection {
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    some(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+    some(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
         try {
             let index = 0;
             for (const item of this) {
-                if (throwOnNumberLimit && index === Number.MAX_SAFE_INTEGER) {
+                if (throwOnIndexOverflow && index === Number.MAX_SAFE_INTEGER) {
                     throw new IndexOverflowError("Index has overflowed");
                 }
-                if (filter(item, index, this)) {
+                if (predicateFn(item, index, this)) {
                     return true;
                 }
                 index++;
@@ -298,14 +292,14 @@ export class IterableCollection {
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    every(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+    every(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
         try {
             let index = 0, isTrue = true;
             for (const item of this) {
-                if (throwOnNumberLimit && index === Number.MAX_SAFE_INTEGER) {
+                if (throwOnIndexOverflow && index === Number.MAX_SAFE_INTEGER) {
                     throw new IndexOverflowError("Index has overflowed");
                 }
-                isTrue &&= filter(item, index, this);
+                isTrue &&= predicateFn(item, index, this);
                 if (!isTrue) {
                     break;
                 }
@@ -321,35 +315,35 @@ export class IterableCollection {
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    take(limit, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new IterableCollection(new TakeIterable(this, limit, throwOnNumberLimit));
+    take(limit, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return new IterableCollection(new TakeIterable(this, limit, throwOnIndexOverflow));
     }
-    takeUntil(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new IterableCollection(new TakeUntilIterable(this, filter, throwOnNumberLimit));
+    takeUntil(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return new IterableCollection(new TakeUntilIterable(this, predicateFn, throwOnIndexOverflow));
     }
-    takeWhile(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return this.takeUntil((...arguments_) => !filter(...arguments_), throwOnNumberLimit);
+    takeWhile(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return this.takeUntil((...arguments_) => !predicateFn(...arguments_), throwOnIndexOverflow);
     }
-    skip(offset, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new IterableCollection(new SkipIterable(this, offset, throwOnNumberLimit));
+    skip(offset, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return new IterableCollection(new SkipIterable(this, offset, throwOnIndexOverflow));
     }
-    skipUntil(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new IterableCollection(new SkipUntilIterable(this, filter, throwOnNumberLimit));
+    skipUntil(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return new IterableCollection(new SkipUntilIterable(this, predicateFn, throwOnIndexOverflow));
     }
-    skipWhile(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return this.skipUntil((...arguments_) => !filter(...arguments_), throwOnNumberLimit);
+    skipWhile(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return this.skipUntil((...arguments_) => !predicateFn(...arguments_), throwOnIndexOverflow);
     }
     when(condition, callback) {
         return new IterableCollection(new WhenIterable(this, () => condition, callback));
     }
     whenEmpty(callback) {
-        return new IterableCollection(new WhenIterable(this, () => this.empty(), callback));
+        return new IterableCollection(new WhenIterable(this, () => this.isEmpty(), callback));
     }
     whenNot(condition, callback) {
         return this.when(!condition, callback);
     }
     whenNotEmpty(callback) {
-        return new IterableCollection(new WhenIterable(this, () => this.notEmpty(), callback));
+        return new IterableCollection(new WhenIterable(this, () => this.isNotEmpty(), callback));
     }
     pipe(callback) {
         try {
@@ -369,37 +363,37 @@ export class IterableCollection {
     chunk(chunkSize) {
         return new IterableCollection(new ChunkIterable(this, chunkSize, IterableCollection.makeCollection));
     }
-    chunkWhile(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new IterableCollection(new ChunkWhileIterable(this, filter, throwOnNumberLimit, (iterable) => new IterableCollection(iterable)));
+    chunkWhile(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return new IterableCollection(new ChunkWhileIterable(this, predicateFn, throwOnIndexOverflow, (iterable) => new IterableCollection(iterable)));
     }
-    split(chunkAmount, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new IterableCollection(new SplitIterable(this, chunkAmount, throwOnNumberLimit, IterableCollection.makeCollection));
+    split(chunkAmount, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return new IterableCollection(new SplitIterable(this, chunkAmount, throwOnIndexOverflow, IterableCollection.makeCollection));
     }
-    partition(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new IterableCollection(new PartionIterable(this, filter, throwOnNumberLimit, IterableCollection.makeCollection));
+    partition(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return new IterableCollection(new PartionIterable(this, predicateFn, throwOnIndexOverflow, IterableCollection.makeCollection));
     }
     sliding(settings) {
-        const { chunkSize, step = chunkSize - 1, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT, } = settings;
-        return new IterableCollection(new SlidingIteralbe(this, chunkSize, step, throwOnNumberLimit));
+        const { chunkSize, step = chunkSize - 1, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT, } = settings;
+        return new IterableCollection(new SlidingIteralbe(this, chunkSize, step, throwOnIndexOverflow));
     }
     groupBy(settings) {
-        return new IterableCollection(new GroupByIterable(this, settings?.mapFn, settings?.throwOnNumberLimit ??
+        return new IterableCollection(new GroupByIterable(this, settings?.selectFn, settings?.throwOnIndexOverflow ??
             IterableCollection.THROW_ON_NUMBER_LIMIT, (iterable) => new IterableCollection(iterable)));
     }
     countBy(settings) {
-        return new IterableCollection(new CountByIterable(this, settings?.mapFn, settings?.throwOnNumberLimit ??
+        return new IterableCollection(new CountByIterable(this, settings?.selectFn, settings?.throwOnIndexOverflow ??
             IterableCollection.THROW_ON_NUMBER_LIMIT));
     }
     unique(settings) {
-        return new IterableCollection(new UniqueIterable(this, settings?.mapFn, settings?.throwOnNumberLimit ??
+        return new IterableCollection(new UniqueIterable(this, settings?.selectFn, settings?.throwOnIndexOverflow ??
             IterableCollection.THROW_ON_NUMBER_LIMIT));
     }
-    difference(iterable, map = (item) => item) {
+    difference(iterable, mapFn = (item) => item) {
         const differenceCollection = new IterableCollection(iterable);
         return this.filter((item, index, collection) => {
             return !differenceCollection.some((matchItem, matchIndex, matchCollection) => {
-                return (map(item, index, collection) ===
-                    map(matchItem, matchIndex, matchCollection));
+                return (mapFn(item, index, collection) ===
+                    mapFn(matchItem, matchIndex, matchCollection));
             });
         });
     }
@@ -413,7 +407,7 @@ export class IterableCollection {
         return new IterableCollection(new PadEndIterable(this, maxLength, fillItems, IterableCollection.makeCollection));
     }
     slice(settings) {
-        return new IterableCollection(new SliceIterable(this, settings?.start, settings?.end, settings?.throwOnNumberLimit ??
+        return new IterableCollection(new SliceIterable(this, settings?.start, settings?.end, settings?.throwOnIndexOverflow ??
             IterableCollection.THROW_ON_NUMBER_LIMIT));
     }
     prepend(iterable) {
@@ -422,11 +416,11 @@ export class IterableCollection {
     append(iterable) {
         return new IterableCollection(new MergeIterable(this, iterable));
     }
-    insertBefore(filter, iterable, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new IterableCollection(new InsertBeforeIterable(this, filter, iterable, throwOnNumberLimit));
+    insertBefore(predicateFn, iterable, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return new IterableCollection(new InsertBeforeIterable(this, predicateFn, iterable, throwOnIndexOverflow));
     }
-    insertAfter(filter, iterable, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return new IterableCollection(new InsertAfterIterable(this, filter, iterable, throwOnNumberLimit));
+    insertAfter(predicateFn, iterable, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return new IterableCollection(new InsertAfterIterable(this, predicateFn, iterable, throwOnIndexOverflow));
     }
     crossJoin(...iterables) {
         return new IterableCollection(new CrossJoinIterable(this, iterables, IterableCollection.makeCollection));
@@ -434,11 +428,11 @@ export class IterableCollection {
     zip(iterable) {
         return new IterableCollection(new ZipIterable(this, iterable));
     }
-    sort(compare) {
-        return new IterableCollection(new SortIterable(this, compare));
+    sort(comparator) {
+        return new IterableCollection(new SortIterable(this, comparator));
     }
     reverse(settings) {
-        return new IterableCollection(new ReverseIterable(this, settings?.chunkSize ?? IterableCollection.DEFAULT_CHUNK_SIZE, settings?.throwOnNumberLimit ??
+        return new IterableCollection(new ReverseIterable(this, settings?.chunkSize ?? IterableCollection.DEFAULT_CHUNK_SIZE, settings?.throwOnIndexOverflow ??
             IterableCollection.THROW_ON_NUMBER_LIMIT, (iterable) => new IterableCollection(iterable)));
     }
     shuffle() {
@@ -461,15 +455,15 @@ export class IterableCollection {
     }
     firstOr(settings) {
         try {
-            const throwOnNumberLimit = settings.throwOnNumberLimit ??
+            const throwOnIndexOverflow = settings.throwOnIndexOverflow ??
                 IterableCollection.THROW_ON_NUMBER_LIMIT;
             let index = 0;
-            const filter = settings.filterFn ?? (() => true);
+            const predicateFn = settings.predicateFn ?? (() => true);
             for (const item of this) {
-                if (throwOnNumberLimit && index === Number.MAX_SAFE_INTEGER) {
+                if (throwOnIndexOverflow && index === Number.MAX_SAFE_INTEGER) {
                     throw new IndexOverflowError("Index has overflowed");
                 }
-                if (filter(item, index, this)) {
+                if (predicateFn(item, index, this)) {
                     return item;
                 }
                 index++;
@@ -512,16 +506,16 @@ export class IterableCollection {
     }
     lastOr(settings) {
         try {
-            const throwOnNumberLimit = settings.throwOnNumberLimit ??
+            const throwOnIndexOverflow = settings.throwOnIndexOverflow ??
                 IterableCollection.THROW_ON_NUMBER_LIMIT;
             let index = 0;
-            const filter = settings.filterFn ?? (() => true);
+            const predicateFn = settings.predicateFn ?? (() => true);
             let matchedItem = null;
             for (const item of this) {
-                if (throwOnNumberLimit && index === Number.MAX_SAFE_INTEGER) {
+                if (throwOnIndexOverflow && index === Number.MAX_SAFE_INTEGER) {
                     throw new IndexOverflowError("Index has overflowed");
                 }
-                if (filter(item, index, this)) {
+                if (predicateFn(item, index, this)) {
                     matchedItem = item;
                 }
                 index++;
@@ -550,17 +544,17 @@ export class IterableCollection {
         }
         return item;
     }
-    before(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return this.beforeOr(null, filter, throwOnNumberLimit);
+    before(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return this.beforeOr(null, predicateFn, throwOnIndexOverflow);
     }
-    beforeOr(defaultValue, filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+    beforeOr(defaultValue, predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
         try {
             let beforeItem = null, index = 0;
             for (const item of this) {
-                if (throwOnNumberLimit && index === Number.MAX_SAFE_INTEGER) {
+                if (throwOnIndexOverflow && index === Number.MAX_SAFE_INTEGER) {
                     throw new IndexOverflowError("Index has overflowed");
                 }
-                if (filter(item, index, this) && beforeItem) {
+                if (predicateFn(item, index, this) && beforeItem) {
                     return beforeItem;
                 }
                 index++;
@@ -580,27 +574,27 @@ export class IterableCollection {
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    beforeOrFail(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        const item = this.before(filter, throwOnNumberLimit);
+    beforeOrFail(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        const item = this.before(predicateFn, throwOnIndexOverflow);
         if (item === null) {
             throw new ItemNotFoundError("Item was not found");
         }
         return item;
     }
-    after(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return this.afterOr(null, filter, throwOnNumberLimit);
+    after(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return this.afterOr(null, predicateFn, throwOnIndexOverflow);
     }
-    afterOr(defaultValue, filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+    afterOr(defaultValue, predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
         try {
             let hasMatched = false, index = 0;
             for (const item of this) {
                 if (hasMatched) {
                     return item;
                 }
-                if (throwOnNumberLimit && index === Number.MAX_SAFE_INTEGER) {
+                if (throwOnIndexOverflow && index === Number.MAX_SAFE_INTEGER) {
                     throw new IndexOverflowError("Index has overflowed");
                 }
-                hasMatched = filter(item, index, this);
+                hasMatched = predicateFn(item, index, this);
                 index++;
             }
             if (typeof defaultValue === "function") {
@@ -617,21 +611,21 @@ export class IterableCollection {
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    afterOrFail(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        const item = this.after(filter, throwOnNumberLimit);
+    afterOrFail(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        const item = this.after(predicateFn, throwOnIndexOverflow);
         if (item === null) {
             throw new ItemNotFoundError("Item was not found");
         }
         return item;
     }
-    sole(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+    sole(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
         try {
             let index = 0, matchedItem = null;
             for (const item of this) {
-                if (throwOnNumberLimit && index === Number.MAX_SAFE_INTEGER) {
+                if (throwOnIndexOverflow && index === Number.MAX_SAFE_INTEGER) {
                     throw new IndexOverflowError("Index has overflowed");
                 }
-                if (filter(item, index, this)) {
+                if (predicateFn(item, index, this)) {
                     if (matchedItem !== null) {
                         throw new MultipleItemsFoundError("Multiple items were found");
                     }
@@ -655,14 +649,14 @@ export class IterableCollection {
     nth(step) {
         return this.filter((_item, index) => index % step === 0);
     }
-    count(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+    count(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
         try {
             let size = 0;
             for (const item of this) {
-                if (throwOnNumberLimit && size === Number.MAX_SAFE_INTEGER) {
+                if (throwOnIndexOverflow && size === Number.MAX_SAFE_INTEGER) {
                     throw new IndexOverflowError("Size has overflowed");
                 }
-                if (filter(item, size, this)) {
+                if (predicateFn(item, size, this)) {
                     size++;
                 }
             }
@@ -676,10 +670,10 @@ export class IterableCollection {
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    size(throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
-        return this.count(() => true, throwOnNumberLimit);
+    size(throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        return this.count(() => true, throwOnIndexOverflow);
     }
-    empty() {
+    isEmpty() {
         try {
             for (const _ of this) {
                 return false;
@@ -694,17 +688,17 @@ export class IterableCollection {
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    notEmpty() {
-        return !this.empty();
+    isNotEmpty() {
+        return !this.isEmpty();
     }
-    search(filter, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+    searchFirst(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
         try {
             let index = 0;
             for (const item of this) {
-                if (throwOnNumberLimit && index === Number.MAX_SAFE_INTEGER) {
+                if (throwOnIndexOverflow && index === Number.MAX_SAFE_INTEGER) {
                     throw new IndexOverflowError("Index has overflowed");
                 }
-                if (filter(item, index, this)) {
+                if (predicateFn(item, index, this)) {
                     return index;
                 }
                 index++;
@@ -719,11 +713,34 @@ export class IterableCollection {
             throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
         }
     }
-    forEach(callback, throwOnNumberLimit = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+    searchLast(predicateFn, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
+        try {
+            let index = 0;
+            let matchedIndex = -1;
+            for (const item of this) {
+                if (throwOnIndexOverflow && index === Number.MAX_SAFE_INTEGER) {
+                    throw new IndexOverflowError("Index has overflowed");
+                }
+                if (predicateFn(item, index, this)) {
+                    matchedIndex = index;
+                }
+                index++;
+            }
+            return matchedIndex;
+        }
+        catch (error) {
+            if (error instanceof CollectionError ||
+                error instanceof TypeError) {
+                throw error;
+            }
+            throw new UnexpectedCollectionError(`Unexpected error "${String(error)}" occured`, error);
+        }
+    }
+    forEach(callback, throwOnIndexOverflow = IterableCollection.THROW_ON_NUMBER_LIMIT) {
         try {
             let index = 0;
             for (const item of this) {
-                if (throwOnNumberLimit && index === Number.MAX_SAFE_INTEGER) {
+                if (throwOnIndexOverflow && index === Number.MAX_SAFE_INTEGER) {
                     throw new IndexOverflowError("Index has overflowed");
                 }
                 callback(item, index, this);