@jamashita/lluvia-sequence 2.6.0 → 2.9.0

package/src/ASequence.ts

@@ -3,10 +3,10 @@ import {
   Ambiguous,
   BinaryFunction,
   BinaryPredicate,
-  Catalogue,
+  ForEach,
   isEqualable,
   Kind,
-  Mapper,
+  Mapping,
   Nullable
 } from '@jamashita/anden-type';
 import { Quantity } from '@jamashita/lluvia-collection';
@@ -26,7 +26,7 @@ export abstract class ASequence<V, T extends ASequence<V, T>> extends Quantity<n
 
   public abstract override filter(predicate: BinaryPredicate<V, number>): T;
 
-  public abstract override map<W>(mapper: Mapper<V, W>): Sequence<W>;
+  public abstract override map<W>(mapping: Mapping<V, W>): Sequence<W>;
 
   public abstract remove(key: number): T;
 
@@ -60,38 +60,20 @@ export abstract class ASequence<V, T extends ASequence<V, T>> extends Quantity<n
       return false;
     }
 
-    const ti: Iterator<V> = this.values()[Symbol.iterator]();
-    const oi: Iterator<unknown> = other.values()[Symbol.iterator]();
-    let tr: IteratorResult<V> = ti.next();
-    let or: IteratorResult<unknown> = oi.next();
-
-    while (tr.done !== true && or.done !== true) {
-      if (isEqualable(tr.value) && isEqualable(or.value)) {
-        if (!tr.value.equals(or.value)) {
-          return false;
-        }
-      }
-      else if (tr.value !== or.value) {
-        return false;
-      }
-
-      tr = ti.next();
-      or = oi.next();
-
-      if (tr.done === true && or.done === true) {
+    return this.sequence.every((v: V, i: number) => {
+      if (v === other.sequence[i]) {
         return true;
       }
-    }
+      if (isEqualable(v)) {
+        return v.equals(other.sequence[i]);
+      }
 
-    return false;
+      return false;
+    });
   }
 
   public every(predicate: BinaryPredicate<V, number>): boolean {
-    const found: Ambiguous<V> = this.sequence.find((v: V, i: number) => {
-      return !predicate(v, i);
-    });
-
-    return Kind.isUndefined(found);
+    return this.sequence.every(predicate);
   }
 
   protected filterInternal(predicate: BinaryPredicate<V, number>): Array<V> {
@@ -116,10 +98,8 @@ export abstract class ASequence<V, T extends ASequence<V, T>> extends Quantity<n
     return found;
   }
 
-  public forEach(catalogue: Catalogue<number, V>): void {
-    this.sequence.forEach((v: V, i: number) => {
-      catalogue(v, i);
-    });
+  public forEach(foreach: ForEach<number, V>): void {
+    this.sequence.forEach(foreach);
   }
 
   public get(key: number): Nullable<V> {
@@ -138,6 +118,14 @@ export abstract class ASequence<V, T extends ASequence<V, T>> extends Quantity<n
     }).values();
   }
 
+  public reduce(reducer: BinaryFunction<V, V, V>, initialValue?: V): V {
+    if (Kind.isUndefined(initialValue)) {
+      return this.sequence.reduce(reducer);
+    }
+
+    return this.sequence.reduce(reducer, initialValue);
+  }
+
   protected removeInternal(key: number): Array<V> {
     if (!Kind.isInteger(key)) {
       return this.sequence;
@@ -171,9 +159,7 @@ export abstract class ASequence<V, T extends ASequence<V, T>> extends Quantity<n
   }
 
   public some(predicate: BinaryPredicate<V, number>): boolean {
-    const found: Ambiguous<V> = this.sequence.find(predicate);
-
-    return !Kind.isUndefined(found);
+    return this.sequence.some(predicate);
   }
 
   public toArray(): Array<V> {

package/src/ImmutableSequence.ts

@@ -1,28 +1,28 @@
-import { BinaryFunction, BinaryPredicate, Mapper } from '@jamashita/anden-type';
+import { BinaryFunction, BinaryPredicate, Mapping } from '@jamashita/anden-type';
 import { Collection } from '@jamashita/lluvia-collection';
 import { ASequence } from './ASequence';
 
 export class ImmutableSequence<V> extends ASequence<V, ImmutableSequence<V>> {
   private static readonly EMPTY: ImmutableSequence<unknown> = new ImmutableSequence<unknown>([]);
 
-  public static empty<VT>(): ImmutableSequence<VT> {
-    return ImmutableSequence.EMPTY as ImmutableSequence<VT>;
+  public static empty<V>(): ImmutableSequence<V> {
+    return ImmutableSequence.EMPTY as ImmutableSequence<V>;
   }
 
-  public static of<VT>(collection: Collection<number, VT>): ImmutableSequence<VT> {
-    return ImmutableSequence.ofInternal<VT>([...collection.values()]);
+  public static of<V>(collection: Collection<number, V>): ImmutableSequence<V> {
+    return ImmutableSequence.ofInternal([...collection.values()]);
   }
 
-  public static ofArray<VT>(array: ReadonlyArray<VT>): ImmutableSequence<VT> {
-    return ImmutableSequence.ofInternal<VT>([...array]);
+  public static ofArray<V>(array: ReadonlyArray<V>): ImmutableSequence<V> {
+    return ImmutableSequence.ofInternal([...array]);
   }
 
-  private static ofInternal<VT>(array: Array<VT>): ImmutableSequence<VT> {
+  private static ofInternal<V>(array: Array<V>): ImmutableSequence<V> {
     if (array.length === 0) {
-      return ImmutableSequence.empty<VT>();
+      return ImmutableSequence.empty();
     }
 
-    return new ImmutableSequence<VT>(array);
+    return new ImmutableSequence(array);
   }
 
   protected constructor(sequence: Array<V>) {
@@ -30,31 +30,31 @@ export class ImmutableSequence<V> extends ASequence<V, ImmutableSequence<V>> {
   }
 
   public add(value: V): ImmutableSequence<V> {
-    return ImmutableSequence.ofArray<V>([...this.sequence, value]);
+    return ImmutableSequence.ofArray([...this.sequence, value]);
   }
 
   public duplicate(): ImmutableSequence<V> {
     if (this.isEmpty()) {
-      return ImmutableSequence.empty<V>();
+      return ImmutableSequence.empty();
     }
 
-    return ImmutableSequence.ofArray<V>([...this.sequence]);
+    return ImmutableSequence.ofArray([...this.sequence]);
   }
 
   public filter(predicate: BinaryPredicate<V, number>): ImmutableSequence<V> {
-    return ImmutableSequence.ofArray<V>(this.filterInternal(predicate));
+    return ImmutableSequence.ofArray(this.filterInternal(predicate));
   }
 
   public override isEmpty(): boolean {
-    if (this === ImmutableSequence.empty<V>()) {
+    if (this === ImmutableSequence.empty()) {
       return true;
     }
 
     return super.isEmpty();
   }
 
-  public map<W>(mapper: Mapper<V, W>): ImmutableSequence<W> {
-    return ImmutableSequence.ofArray<W>(this.sequence.map<W>(mapper));
+  public map<W>(mapping: Mapping<V, W>): ImmutableSequence<W> {
+    return ImmutableSequence.ofArray(this.sequence.map(mapping));
   }
 
   public remove(key: number): ImmutableSequence<V> {
@@ -64,7 +64,7 @@ export class ImmutableSequence<V> extends ASequence<V, ImmutableSequence<V>> {
       return this;
     }
 
-    return ImmutableSequence.ofArray<V>(sequence);
+    return ImmutableSequence.ofArray(sequence);
   }
 
   public set(key: number, value: V): ImmutableSequence<V> {
@@ -74,7 +74,7 @@ export class ImmutableSequence<V> extends ASequence<V, ImmutableSequence<V>> {
       return this;
     }
 
-    return ImmutableSequence.ofArray<V>(sequence);
+    return ImmutableSequence.ofArray(sequence);
   }
 
   public sort(comparator: BinaryFunction<V, V, number>): ImmutableSequence<V> {
@@ -82,6 +82,6 @@ export class ImmutableSequence<V> extends ASequence<V, ImmutableSequence<V>> {
 
     arr.sort(comparator);
 
-    return ImmutableSequence.ofArray<V>(arr);
+    return ImmutableSequence.ofArray(arr);
   }
 }

package/src/MutableSequence.ts

@@ -1,53 +1,53 @@
-import { BinaryFunction, BinaryPredicate, Mapper } from '@jamashita/anden-type';
+import { BinaryFunction, BinaryPredicate, Mapping } from '@jamashita/anden-type';
 import { Collection } from '@jamashita/lluvia-collection';
 import { ASequence } from './ASequence';
 
 export class MutableSequence<V> extends ASequence<V, MutableSequence<V>> {
-  public static empty<VT>(): MutableSequence<VT> {
-    return MutableSequence.ofArray<VT>([]);
+  public static empty<V>(): MutableSequence<V> {
+    return MutableSequence.ofArray([]);
   }
 
-  public static of<VT>(collection: Collection<number, VT>): MutableSequence<VT> {
-    return MutableSequence.ofInternal<VT>([...collection.values()]);
+  public static of<V>(collection: Collection<number, V>): MutableSequence<V> {
+    return MutableSequence.ofInternal([...collection.values()]);
   }
 
-  public static ofArray<VT>(array: ReadonlyArray<VT>): MutableSequence<VT> {
-    return MutableSequence.ofInternal<VT>([...array]);
+  public static ofArray<V>(array: ReadonlyArray<V>): MutableSequence<V> {
+    return MutableSequence.ofInternal([...array]);
   }
 
-  private static ofInternal<VT>(array: Array<VT>): MutableSequence<VT> {
-    return new MutableSequence<VT>(array);
+  private static ofInternal<V>(array: Array<V>): MutableSequence<V> {
+    return new MutableSequence(array);
   }
 
   protected constructor(sequence: Array<V>) {
     super(sequence);
   }
 
-  public add(value: V): MutableSequence<V> {
+  public add(value: V): this {
     this.sequence.push(value);
 
     return this;
   }
 
   public duplicate(): MutableSequence<V> {
-    return MutableSequence.ofArray<V>([...this.sequence]);
+    return MutableSequence.ofArray([...this.sequence]);
   }
 
   public filter(predicate: BinaryPredicate<V, number>): MutableSequence<V> {
-    return MutableSequence.ofArray<V>(this.filterInternal(predicate));
+    return MutableSequence.ofArray(this.filterInternal(predicate));
   }
 
-  public map<W>(mapper: Mapper<V, W>): MutableSequence<W> {
-    return MutableSequence.ofArray<W>(this.sequence.map<W>(mapper));
+  public map<W>(mapping: Mapping<V, W>): MutableSequence<W> {
+    return MutableSequence.ofArray(this.sequence.map(mapping));
   }
 
-  public remove(key: number): MutableSequence<V> {
+  public remove(key: number): this {
     this.sequence = this.removeInternal(key);
 
     return this;
   }
 
-  public set(key: number, value: V): MutableSequence<V> {
+  public set(key: number, value: V): this {
     this.sequence = this.setInternal(key, value);
 
     return this;
@@ -58,6 +58,6 @@ export class MutableSequence<V> extends ASequence<V, MutableSequence<V>> {
 
     arr.sort(comparator);
 
-    return MutableSequence.ofArray<V>(arr);
+    return MutableSequence.ofArray(arr);
   }
 }

package/src/ReadonlySequence.ts

@@ -1,4 +1,4 @@
-import { BinaryFunction, BinaryPredicate, Cloneable, Mapper } from '@jamashita/anden-type';
+import { BinaryFunction, BinaryPredicate, Cloneable, Mapping } from '@jamashita/anden-type';
 import { Collection } from '@jamashita/lluvia-collection';
 
 export interface ReadonlySequence<V> extends Collection<number, V>, Cloneable<ReadonlySequence<V>> {
@@ -6,7 +6,9 @@ export interface ReadonlySequence<V> extends Collection<number, V>, Cloneable<Re
 
   iterator(): IterableIterator<[number, V]>;
 
-  map<W>(mapper: Mapper<V, W>): ReadonlySequence<W>;
+  map<W>(mapping: Mapping<V, W>): ReadonlySequence<W>;
+
+  reduce(reducer: BinaryFunction<V, V, V>, initialValue?: V): V;
 
   sort(comparator: BinaryFunction<V, V, number>): ReadonlySequence<V>;
 

package/src/Sequence.ts

@@ -1,4 +1,4 @@
-import { BinaryPredicate, Mapper } from '@jamashita/anden-type';
+import { BinaryPredicate, Mapping } from '@jamashita/anden-type';
 import { ReadonlySequence } from './ReadonlySequence';
 
 export interface Sequence<V> extends ReadonlySequence<V> {
@@ -6,7 +6,7 @@ export interface Sequence<V> extends ReadonlySequence<V> {
 
   filter(predicate: BinaryPredicate<V, number>): Sequence<V>;
 
-  map<W>(mapper: Mapper<V, W>): Sequence<W>;
+  map<W>(mapping: Mapping<V, W>): Sequence<W>;
 
   remove(key: number): Sequence<V>;