@jamashita/lluvia-sequence 2.5.0 → 2.8.0

package/src/ASequence.ts

@@ -12,7 +12,7 @@ import {
 import { Quantity } from '@jamashita/lluvia-collection';
 import { Sequence } from './Sequence';
 
-export abstract class ASequence<V, T extends ASequence<V, T>, N extends string = string> extends Quantity<number, V, N> implements Sequence<V, N> {
+export abstract class ASequence<V, T extends ASequence<V, T>> extends Quantity<number, V> implements Sequence<V> {
   protected sequence: Array<V>;
 
   protected constructor(sequence: Array<V>) {
@@ -20,17 +20,17 @@ export abstract class ASequence<V, T extends ASequence<V, T>, N extends string =
     this.sequence = sequence;
   }
 
-  public abstract add(value: V): Sequence<V, N>;
-
-  public abstract set(key: number, value: V): T;
-
-  public abstract remove(key: number): T;
+  public abstract add(value: V): Sequence<V>;
 
   public abstract duplicate(): T;
 
+  public abstract override filter(predicate: BinaryPredicate<V, number>): T;
+
   public abstract override map<W>(mapper: Mapper<V, W>): Sequence<W>;
 
-  public abstract override filter(predicate: BinaryPredicate<V, number>): T;
+  public abstract remove(key: number): T;
+
+  public abstract set(key: number, value: V): T;
 
   public abstract sort(comparator: BinaryFunction<V, V, number>): T;
 
@@ -60,38 +60,32 @@ export abstract class ASequence<V, T extends ASequence<V, T>, N extends string =
       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 this.sequence.every(predicate);
+  }
+
+  protected filterInternal(predicate: BinaryPredicate<V, number>): Array<V> {
+    const arr: Array<V> = [];
+
+    this.sequence.forEach((v: V, i: number) => {
+      if (predicate(v, i)) {
+        arr.push(v);
+      }
     });
 
-    return Kind.isUndefined(found);
+    return arr;
   }
 
   public find(predicate: BinaryPredicate<V, number>): Nullable<V> {
@@ -105,9 +99,7 @@ export abstract class ASequence<V, T extends ASequence<V, T>, N extends string =
   }
 
   public forEach(catalogue: Catalogue<number, V>): void {
-    this.sequence.forEach((v: V, i: number) => {
-      catalogue(v, i);
-    });
+    this.sequence.forEach(catalogue);
   }
 
   public get(key: number): Nullable<V> {
@@ -126,40 +118,12 @@ export abstract class ASequence<V, T extends ASequence<V, T>, N extends string =
     }).values();
   }
 
-  public serialize(): string {
-    return this.sequence.map<string>((v: V) => {
-      return Objet.identify(v);
-    }).join(', ');
-  }
-
-  public size(): number {
-    return this.sequence.length;
-  }
-
-  public some(predicate: BinaryPredicate<V, number>): boolean {
-    const found: Ambiguous<V> = this.sequence.find(predicate);
-
-    return !Kind.isUndefined(found);
-  }
-
-  public toArray(): Array<V> {
-    return [...this.sequence];
-  }
-
-  public values(): Iterable<V> {
-    return this.toArray();
-  }
-
-  protected filterInternal(predicate: BinaryPredicate<V, number>): Array<V> {
-    const arr: Array<V> = [];
-
-    this.sequence.forEach((v: V, i: number) => {
-      if (predicate(v, i)) {
-        arr.push(v);
-      }
-    });
+  public reduce(reducer: BinaryFunction<V, V, V>, initialValue?: V): V {
+    if (Kind.isUndefined(initialValue)) {
+      return this.sequence.reduce(reducer);
+    }
 
-    return arr;
+    return this.sequence.reduce(reducer, initialValue);
   }
 
   protected removeInternal(key: number): Array<V> {
@@ -173,6 +137,12 @@ export abstract class ASequence<V, T extends ASequence<V, T>, N extends string =
     return [...this.sequence.slice(0, key), ...this.sequence.slice(key + 1)];
   }
 
+  public serialize(): string {
+    return this.sequence.map<string>((v: V) => {
+      return Objet.identify(v);
+    }).join(', ');
+  }
+
   protected setInternal(key: number, value: V): Array<V> {
     if (!Kind.isInteger(key)) {
       return this.sequence;
@@ -183,4 +153,20 @@ export abstract class ASequence<V, T extends ASequence<V, T>, N extends string =
 
     return [...this.sequence.slice(0, key), value, ...this.sequence.slice(key + 1)];
   }
+
+  public size(): number {
+    return this.sequence.length;
+  }
+
+  public some(predicate: BinaryPredicate<V, number>): boolean {
+    return this.sequence.some(predicate);
+  }
+
+  public toArray(): Array<V> {
+    return [...this.sequence];
+  }
+
+  public values(): Iterable<V> {
+    return this.toArray();
+  }
 }

package/src/ImmutableSequence.ts

@@ -2,29 +2,27 @@ import { BinaryFunction, BinaryPredicate, Mapper } from '@jamashita/anden-type';
 import { Collection } from '@jamashita/lluvia-collection';
 import { ASequence } from './ASequence';
 
-export class ImmutableSequence<V> extends ASequence<V, ImmutableSequence<V>, 'ImmutableSequence'> {
-  public readonly noun: 'ImmutableSequence' = 'ImmutableSequence';
-
+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>) {
@@ -32,23 +30,23 @@ export class ImmutableSequence<V> extends ASequence<V, ImmutableSequence<V>, 'Im
   }
 
   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;
     }
 
@@ -56,7 +54,7 @@ export class ImmutableSequence<V> extends ASequence<V, ImmutableSequence<V>, 'Im
   }
 
   public map<W>(mapper: Mapper<V, W>): ImmutableSequence<W> {
-    return ImmutableSequence.ofArray<W>(this.sequence.map<W>(mapper));
+    return ImmutableSequence.ofArray(this.sequence.map(mapper));
   }
 
   public remove(key: number): ImmutableSequence<V> {
@@ -66,7 +64,7 @@ export class ImmutableSequence<V> extends ASequence<V, ImmutableSequence<V>, 'Im
       return this;
     }
 
-    return ImmutableSequence.ofArray<V>(sequence);
+    return ImmutableSequence.ofArray(sequence);
   }
 
   public set(key: number, value: V): ImmutableSequence<V> {
@@ -76,7 +74,7 @@ export class ImmutableSequence<V> extends ASequence<V, ImmutableSequence<V>, 'Im
       return this;
     }
 
-    return ImmutableSequence.ofArray<V>(sequence);
+    return ImmutableSequence.ofArray(sequence);
   }
 
   public sort(comparator: BinaryFunction<V, V, number>): ImmutableSequence<V> {
@@ -84,6 +82,6 @@ export class ImmutableSequence<V> extends ASequence<V, ImmutableSequence<V>, 'Im
 
     arr.sort(comparator);
 
-    return ImmutableSequence.ofArray<V>(arr);
+    return ImmutableSequence.ofArray(arr);
   }
 }

package/src/MutableSequence.ts

@@ -2,54 +2,52 @@ import { BinaryFunction, BinaryPredicate, Mapper } from '@jamashita/anden-type';
 import { Collection } from '@jamashita/lluvia-collection';
 import { ASequence } from './ASequence';
 
-export class MutableSequence<V> extends ASequence<V, MutableSequence<V>, 'MutableSequence'> {
-  public readonly noun: 'MutableSequence' = 'MutableSequence';
-
-  public static empty<VT>(): MutableSequence<VT> {
-    return MutableSequence.ofArray<VT>([]);
+export class MutableSequence<V> extends ASequence<V, MutableSequence<V>> {
+  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));
+    return MutableSequence.ofArray(this.sequence.map(mapper));
   }
 
-  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;
@@ -60,6 +58,6 @@ export class MutableSequence<V> extends ASequence<V, MutableSequence<V>, 'Mutabl
 
     arr.sort(comparator);
 
-    return MutableSequence.ofArray<V>(arr);
+    return MutableSequence.ofArray(arr);
   }
 }

package/src/ReadonlySequence.ts

@@ -1,13 +1,15 @@
 import { BinaryFunction, BinaryPredicate, Cloneable, Mapper } from '@jamashita/anden-type';
 import { Collection } from '@jamashita/lluvia-collection';
 
-export interface ReadonlySequence<V, N extends string = string> extends Collection<number, V, N>, Cloneable<ReadonlySequence<V>> {
+export interface ReadonlySequence<V> extends Collection<number, V>, Cloneable<ReadonlySequence<V>> {
   filter(predicate: BinaryPredicate<V, number>): ReadonlySequence<V>;
 
   iterator(): IterableIterator<[number, V]>;
 
   map<W>(mapper: Mapper<V, W>): ReadonlySequence<W>;
 
+  reduce(reducer: BinaryFunction<V, V, V>, initialValue?: V): V;
+
   sort(comparator: BinaryFunction<V, V, number>): ReadonlySequence<V>;
 
   toArray(): Array<V>;

package/src/Sequence.ts

@@ -1,7 +1,7 @@
 import { BinaryPredicate, Mapper } from '@jamashita/anden-type';
 import { ReadonlySequence } from './ReadonlySequence';
 
-export interface Sequence<V, N extends string = string> extends ReadonlySequence<V, N> {
+export interface Sequence<V> extends ReadonlySequence<V> {
   add(value: V): Sequence<V>;
 
   filter(predicate: BinaryPredicate<V, number>): Sequence<V>;