scats 1.2.0 → 1.3.0

package/README.md

@@ -413,8 +413,8 @@ set.add(1); // true. set = [1]
 set.add(1); // false. set = [1]
 set.clear(); // []]
 set.add(1); // true. set = [1]
-set.remove(2); false. set = [1]
-set.remove(1); true. set = []
-set.addAll([2, 3]); set = [1, 2, 3]
+set.remove(2); // false. set = [1]
+set.remove(1); // true. set = []
+set.addAll([2, 3]); // set = [1, 2, 3]
 set.filterInPlace(x => x > 2); // [3]
 ```

package/dist/collection.d.ts

@@ -47,11 +47,12 @@ export declare const Nil: Collection<any>;
 export declare class ArrayBuffer<T> extends ArrayBackedCollection<T, ArrayBuffer<T>> implements Mappable<T>, Filterable<T, ArrayBuffer<T>> {
     protected readonly items: T[];
     static get empty(): ArrayBuffer<any>;
-    constructor(items: T[]);
+    constructor(items?: T[]);
     static of<T>(...elements: T[]): ArrayBuffer<T>;
     static from<T>(elements: Iterable<T>): ArrayBuffer<T>;
     static fill<A>(len: number): (elem: (idx: number) => A) => ArrayBuffer<A>;
     protected fromArray(array: T[]): ArrayBuffer<T>;
+    private normalized;
     update(index: number, element: T): void;
     set(index: number, element: T): void;
     clear(): void;
@@ -65,6 +66,12 @@ export declare class ArrayBuffer<T> extends ArrayBackedCollection<T, ArrayBuffer
     subtractOne(element: T): this;
     subtractAll(elements: Iterable<T>): this;
     sort(compareFn?: (a: T, b: T) => number): this;
+    filterInPlace(p: (element: T) => boolean): this;
+    dropInPlace(n: number): this;
+    dropRightInPlace(n: number): this;
+    takeInPlace(n: number): this;
+    takeRightInPlace(n: number): this;
+    sliceInPlace(start: number, end: number): this;
     get toCollection(): Collection<T>;
     flatMap<B>(f: (item: T) => ArrayBuffer<B>): ArrayBuffer<B>;
     flatMapOption<B>(f: (item: T) => Option<B>): ArrayBuffer<B>;

package/dist/collection.js

@@ -187,7 +187,7 @@ exports.Collection = Collection;
 Collection.empty = new Collection([]);
 exports.Nil = Collection.empty;
 class ArrayBuffer extends ArrayBackedCollection {
-    constructor(items) {
+    constructor(items = []) {
         super();
         this.items = items;
     }
@@ -217,6 +217,9 @@ class ArrayBuffer extends ArrayBackedCollection {
             return new ArrayBuffer(array);
         }
     }
+    normalized(n) {
+        return Math.min(Math.max(n, 0), this.length);
+    }
     update(index, element) {
         this.checkWithinBounds(index, index + 1);
         this.items[index] = element;
@@ -283,6 +286,45 @@ class ArrayBuffer extends ArrayBackedCollection {
         this.items.sort(compareFn);
         return this;
     }
+    filterInPlace(p) {
+        let i = 0, j = 0;
+        while (i < this.size) {
+            if (p(this.items[i])) {
+                if (i != j) {
+                    this.items[j] = this.items[i];
+                }
+                j += 1;
+            }
+            i += 1;
+        }
+        if (i == j) {
+            return this;
+        }
+        else {
+            return this.takeInPlace(j);
+        }
+    }
+    dropInPlace(n) {
+        this.remove(0, this.normalized(n));
+        return this;
+    }
+    dropRightInPlace(n) {
+        const norm = this.normalized(n);
+        this.remove(this.length - norm, norm);
+        return this;
+    }
+    takeInPlace(n) {
+        const norm = this.normalized(n);
+        this.remove(norm, this.length - norm);
+        return this;
+    }
+    takeRightInPlace(n) {
+        this.remove(0, this.length - this.normalized(n));
+        return this;
+    }
+    sliceInPlace(start, end) {
+        return this.takeInPlace(end).dropInPlace(start);
+    }
     get toCollection() {
         return new Collection(this.items.slice(0));
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scats",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Useful scala classes in typescript",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/collection.ts

@@ -293,7 +293,7 @@ export class ArrayBuffer<T> extends ArrayBackedCollection<T, ArrayBuffer<T>> imp
         return new ArrayBuffer<any>([]);
     }
 
-    constructor(protected readonly items: T[]) {
+    constructor(protected readonly items: T[] = []) {
         super();
     }
 
@@ -323,6 +323,9 @@ export class ArrayBuffer<T> extends ArrayBackedCollection<T, ArrayBuffer<T>> imp
         }
     }
 
+    private normalized(n: number): number {
+        return Math.min(Math.max(n, 0), this.length);
+    }
 
 
     /** Replaces element at given index with a new value.
@@ -477,6 +480,53 @@ export class ArrayBuffer<T> extends ArrayBackedCollection<T, ArrayBuffer<T>> imp
         return this;
     }
 
+
+    filterInPlace(p: (element: T) => boolean): this {
+        let i = 0, j = 0;
+        while (i < this.size) {
+            if (p(this.items[i])) {
+                if (i != j) {
+                    this.items[j] = this.items[i];
+                }
+                j += 1;
+            }
+            i += 1;
+        }
+
+        if (i == j) {
+            return this;
+        } else {
+            return this.takeInPlace(j);
+        }
+
+    }
+
+    dropInPlace(n: number): this {
+        this.remove(0, this.normalized(n));
+        return this;
+    }
+
+    dropRightInPlace(n: number): this {
+        const norm = this.normalized(n);
+        this.remove(this.length - norm, norm);
+        return this;
+    }
+
+    takeInPlace(n: number): this {
+        const norm = this.normalized(n);
+        this.remove(norm, this.length - norm);
+        return this;
+    }
+
+    takeRightInPlace(n: number): this {
+        this.remove(0, this.length - this.normalized(n));
+        return this;
+    }
+
+    sliceInPlace(start: number, end: number): this {
+        return this.takeInPlace(end).dropInPlace(start);
+    }
+
     get toCollection(): Collection<T> {
         return new Collection<T>(this.items.slice(0));
     }