Adding group by

Author: berhalak

.gitpod.yml

@@ -0,0 +1,7 @@
+tasks:
+  - init: yarn install
+
+vscode:
+  extensions:    
+    - [email protected]:9G2nNF/k04qaOhAogmEuMg==
+    

README.md

@@ -1,3 +1,5 @@
+[![Gitpod Ready-to-Code](https://img.shields.io/badge/Gitpod-Ready--to--Code-blue?logo=gitpod)](https://gitpod.io/#https://github.com/berhalak/linq) 
+
 # linq
 
 Linq style using generators

package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@berhalak/linq",
 	"private": false,
-	"version": "0.0.9",
+	"version": "0.0.10",
 	"description": "Typescript linq",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",

src/index.spec.ts

@@ -89,4 +89,30 @@ test("ordered", async () => {
 	expect(from(a).orderByDesc(x => x).first()).toBe(3);
 	expect(from(a).orderBy(x => 3 - x).first()).toBe(3);
 	expect(from(a).orderByDesc(x => 3 - x).first()).toBe(1);
+});
+
+test("groupBy", async () => {
+    const a = [{ name : 'a', val: 10}, {name : 'a', val : 20}];
+    
+    const result = from(a).groupBy(a => a.name).toArray();
+
+    expect(result.length).toBe(1);
+    expect(result[0].count()).toBe(2);
+
+    const sum = from(a).groupBy(a => a.name).map(x=> x.sum(y => y.val)).sum(y => y);
+
+    expect(sum).toBe(30);
+});
+
+test("groupBy", async () => {
+    const a = [{ name : 'a', val: 10}, {name : 'a', val : 20}];
+    
+    const result = from(a).groupBy(a => a.name).toArray();
+
+    expect(result.length).toBe(1);
+    expect(result[0].count()).toBe(2);
+
+    const sum = from(a).groupBy(a => a.name).map(x=> x.sum(y => y.val)).sum(y => y);
+
+    expect(sum).toBe(30);
 });

src/index.ts

@@ -22,6 +22,10 @@ abstract class Enumerable<T> implements Iterable<T> {
         return new Mapped(this, selector);
     }
 
+    groupBy<M>(selector: Selector<T, M>): GroupedEnumerable<T, M> {
+        return new GroupedEnumerable<T, M>(this, selector);
+    }
+
     where(filter: Filter<T>): Enumerable<T> {
         return new Where(this, filter);
     }
@@ -63,10 +67,14 @@ abstract class Enumerable<T> implements Iterable<T> {
         return count;
     }
 
-    sum() {
+    sum(selector?: Selector<T, number>) {
         let sum = 0;
         for (let item of this) {
-            sum += item as any as number;
+            if (selector) {
+                sum += selector(item);
+            } else {
+                sum += item as any as number;
+            }
         }
         return sum;
     }
@@ -96,6 +104,54 @@ abstract class Enumerable<T> implements Iterable<T> {
     }
 }
 
+class Group<V, K> extends Enumerable<V> {
+
+    constructor(public key: K, private buffer: V[]) {
+        super();
+    }
+
+    *[Symbol.iterator](): IterableIterator<V> {
+        for (let item of this.buffer) {
+            yield item;
+        }
+    }
+
+}
+
+class GroupedEnumerable<V, K> extends Enumerable<Group<V, K>> {
+
+    constructor(private list: Enumerable<V>, private selector: Selector<V, K>) {
+        super();
+    }
+
+    *[Symbol.iterator](): IterableIterator<Group<V, K>> {
+        // we expect list to be ordered - for perfomence reason
+        // as this should be as fast as possible
+        let last: K = null;
+        let has = false;
+        let buffer: V[] = [];
+        for (let item of this.list) {
+            has = true;
+            if (last === null) {
+                last = this.selector(item);
+                buffer.push(item);
+                continue;
+            }
+            let current = this.selector(item);
+            if (current != last) {
+                yield new Group<V, K>(last, buffer);
+                buffer = [item];
+                last = current;
+                continue;
+            }
+            buffer.push(item);
+        }
+        if (has) {
+            yield new Group<V, K>(last, buffer);
+        }
+    }
+}
+
 class Except<T> extends Enumerable<T> {
 
     constructor(private list: Iterable<T>, private other: Iterable<T>) {