refactor

src/functions.ts

@@ -1,19 +1,19 @@
 import { ArrayView } from "./views";
 import { Slice } from "./structs";
-import { ArrayIndexListSelector, ArrayMaskSelector, ArraySliceSelector } from "./selectors";
+import { IndexListSelector, MaskSelector, SliceSelector } from "./selectors";
 
 export function view<T>(source: Array<T> | ArrayView<T>): ArrayView<T> {
   return ArrayView.toView(source);
 }
 
-export function slice(slice: string | Slice): ArraySliceSelector {
-  return new ArraySliceSelector(Slice.toSlice(slice));
+export function slice(slice: string | Slice): SliceSelector {
+  return new SliceSelector(Slice.toSlice(slice));
 }
 
-export function mask(mask: Array<boolean> | ArrayView<boolean>): ArrayMaskSelector {
-  return new ArrayMaskSelector(mask);
+export function mask(mask: Array<boolean> | ArrayView<boolean>): MaskSelector {
+  return new MaskSelector(mask);
 }
 
-export function select(indexes: Array<number> | ArrayView<number>): ArrayIndexListSelector {
-  return new ArrayIndexListSelector(indexes);
+export function select(indexes: Array<number> | ArrayView<number>): IndexListSelector {
+  return new IndexListSelector(indexes);
 }

src/selectors.ts

@@ -2,7 +2,7 @@ import { ArrayCompressView, ArrayIndexListView, ArraySliceView, ArrayView } from
 import { Slice } from "./structs";
 import { SelectorInterface } from "./types";
 
-export abstract class ArraySelector<T> implements SelectorInterface<T> {
+export abstract class Selector<T> implements SelectorInterface {
   public readonly value: T;
 
   public abstract select<U>(source: ArrayView<U>): ArrayView<U>;
@@ -12,7 +12,7 @@ export abstract class ArraySelector<T> implements SelectorInterface<T> {
   }
 }
 
-export class ArrayIndexListSelector extends ArraySelector<Array<number>> {
+export class IndexListSelector extends Selector<Array<number>> {
   public select<T>(source: ArrayView<T>): ArrayIndexListView<T> {
     return new ArrayIndexListView<T>(source, { indexes: this.value });
   }
@@ -22,7 +22,7 @@ export class ArrayIndexListSelector extends ArraySelector<Array<number>> {
   }
 }
 
-export class ArrayMaskSelector extends ArraySelector<Array<boolean>> {
+export class MaskSelector extends Selector<Array<boolean>> {
   public select<T>(source: ArrayView<T>): ArrayCompressView<T> {
     return new ArrayCompressView<T>(source, { mask: this.value });
   }
@@ -32,13 +32,10 @@ export class ArrayMaskSelector extends ArraySelector<Array<boolean>> {
   }
 }
 
-export class ArraySliceSelector extends Slice implements SelectorInterface<Slice> {
-  public readonly value: Slice;
-
+export class SliceSelector extends Slice implements SelectorInterface {
   constructor(slice: Slice | string) {
     const s = Slice.toSlice(slice);
     super(s.start, s.end, s.step);
-    this.value = this;
   }
 
   public select<T>(source: ArrayView<T>): ArraySliceView<T> {

src/types.ts

@@ -1,28 +1,27 @@
-import { ArrayMaskSelector, ArraySelector } from './selectors';
-
 export interface ArrayViewInterface<T> {
   readonly loc: SliceableArray<T>;
   readonly length: number;
+  readonly isReadonly: boolean;
 
   toArray(): Array<T>;
 
   filter(predicate: (value: T) => boolean): ArrayViewInterface<T>;
 
-  is(predicate: (value: T) => boolean): ArrayMaskSelector;
+  is(predicate: (value: T) => boolean): SelectorInterface;
 
-  subview(selector: ArraySelector<unknown> | string): ArrayViewInterface<T>;
+  subview(selector: SelectorInterface | string): ArrayViewInterface<T>;
 
   apply(mapper: (item: T, index: number) => T): void;
 
+  applyWith<U>(data: Array<U> | ArrayViewInterface<U>, mapper: (lhs: T, rhs: U, index: number) => T): ArrayViewInterface<T>;
+
   set(newValues: Array<T> | ArrayViewInterface<T>): void;
 
   [Symbol.iterator](): IterableIterator<T>;
 }
 
-export interface SelectorInterface<T> {
-  readonly value: T;
-
-  select<U>(source: ArrayViewInterface<U>): ArrayViewInterface<U>;
+export interface SelectorInterface {
+  select<T>(source: ArrayViewInterface<T>): ArrayViewInterface<T>;
 }
 
 export type SliceableArray<T> = Array<T> & {

src/views.ts

@@ -1,8 +1,8 @@
-import { ArraySelector, ArrayMaskSelector, ArraySliceSelector } from "./selectors";
+import { MaskSelector, SliceSelector } from "./selectors";
 import { normalizeIndex } from "./utils";
 import { KeyError, LengthError, ReadonlyError } from "./excpetions";
 import { NormalizedSlice, Slice } from "./structs";
-import type { ArrayViewInterface, SliceableArray } from "./types";
+import type { ArrayViewInterface, SelectorInterface, SliceableArray } from "./types";
 
 export class ArrayView<T> implements ArrayViewInterface<T> {
   public readonly loc: SliceableArray<T>;
@@ -32,7 +32,7 @@ export class ArrayView<T> implements ArrayViewInterface<T> {
         }
 
         if (typeof prop === "string" && Slice.isSliceString(prop)) {
-          return this.subview(new ArraySliceSelector(prop)).toArray();
+          return this.subview(new SliceSelector(prop)).toArray();
         }
 
         if (!Number.isInteger(Number(prop))) {
@@ -47,7 +47,7 @@ export class ArrayView<T> implements ArrayViewInterface<T> {
         }
 
         if (typeof prop === "string" && Slice.isSliceString(prop)) {
-          this.subview(new ArraySliceSelector(prop)).set(value);
+          this.subview(new SliceSelector(prop)).set(value);
           return true;
         }
 
@@ -73,14 +73,14 @@ export class ArrayView<T> implements ArrayViewInterface<T> {
     return this.is(predicate).select(this);
   }
 
-  public is(predicate: (value: T) => boolean): ArrayMaskSelector {
-    return new ArrayMaskSelector(this.toArray().map(predicate));
+  public is(predicate: (value: T) => boolean): MaskSelector {
+    return new MaskSelector(this.toArray().map(predicate));
   }
 
-  public subview(selector: ArraySelector<unknown> | string): ArrayView<T> {
-    return (selector instanceof ArraySelector)
-      ? selector.select(this)
-      : (new ArraySliceSelector(selector).select(this));
+  public subview(selector: SelectorInterface | string): ArrayViewInterface<T> {
+    return (typeof selector === 'string')
+      ? (new SliceSelector(selector).select(this))
+      : selector.select(this);
   }
 
   public apply(mapper: (item: T, index: number) => T): ArrayView<T> {

tests/examples.test.ts

@@ -6,18 +6,18 @@ import {
   ArraySliceView,
 } from "../src/views";
 import {
-  ArrayIndexListSelector,
-  ArrayMaskSelector, ArraySliceSelector,
+  IndexListSelector,
+  MaskSelector, SliceSelector,
 } from "../src/selectors";
 import { Slice } from "../src/structs";
 
 it("First example", () => {
   const input = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 
   const view1 = new ArrayView(input);
-  const view2 = view1.subview(new ArrayMaskSelector([true, false, true, false, true, false, true, false, true, false]));
-  const view3 = view2.subview(new ArrayIndexListSelector(new ArrayView([0, 1, 3, 4])));
-  const view4 = view3.subview(new ArraySliceSelector('1:-1:1'));
+  const view2 = view1.subview(new MaskSelector([true, false, true, false, true, false, true, false, true, false]));
+  const view3 = view2.subview(new IndexListSelector(new ArrayView([0, 1, 3, 4])));
+  const view4 = view3.subview(new SliceSelector('1:-1:1'));
 
   view4.toArray();
   // for (let i = 0; i < view3.length; i++) {

tests/views.test.ts

@@ -1,5 +1,5 @@
 import { ArrayView } from "../src/views";
-import { ArrayMaskSelector, ArrayIndexListSelector, ArraySliceSelector } from "../src/selectors";
+import { MaskSelector, IndexListSelector, SliceSelector } from "../src/selectors";
 import {
   dataProviderForSliceInBoundsPythonAutoGeneratedSuccess,
   dataProviderForSliceOutOfBoundsPythonAutoGeneratedSuccess,