Improved features and flexibility.

Author: electricessence

.vscode/settings.json

@@ -1,8 +1,17 @@
 {
     "cSpell.words": [
         "camelcase",
+        "copyfiles",
         "electricessence",
+        "Enumerables",
         "Linq",
-        "tsdotnet"
+        "pnpm",
+        "postversion",
+        "precommit",
+        "preversion",
+        "tsdotnet",
+        "typedoc",
+        "xyxyxy",
+        "xyzxyzxyz"
     ]
 }

README.md

@@ -17,32 +17,52 @@ A familiar set of functions that operate on JavaScript iterables (ES2015+) in a
 
 ## API
 
+### `linq<T>` vs `linqExtended<T>`
+
+It is possible to do everything with just `linq` but `linqExtended` offers more functionality for those expecting to use common resolutions like `.count`, `.first`, `.last`, etc.  Using `linq` will save you some bytes when your common use cases do not need resolutions.
+
 ### Iterating
 
 ```typescript
-for(const e of linq(source)
-    .filter(a, b, c)) {
+for(const e of linq(source).filter(a)) {
     // Iterate filtered results.
 }
 ```
 
 ```typescript
 for(const e of linq(source)
-    .filter(a, b, c)
+    .filterWith(a, b, c)
     .transform(x)) {
     // Iterate filtered and then transformed results.
 }
 ```
 
+```typescript
+for(const e of linq(source)
+    .where(predicate)
+    .skip(10).take(10)
+    .select(mapping)) {
+    // Iterate filtered and mapped results.
+}
+```
+
 ### Resolving
 
 ```typescript
 const result = linq(source)
-    .filter(a, b, c)
+    .filterWith(a, b, c)
     .transform(x)
     .resolve(r);
 ```
 
+```typescript
+const firstElement = linqExtended(source)
+    .where(predicate)
+    .select(mapping)
+    .first(r);
+```
+
+
 ## Examples
 
 ### `linq<T>` with imported filters
@@ -65,25 +85,25 @@ for(const o of filtered) {
 }
 ```
 
-### `linqExtended<T>` with simplified imports
+### `linq<T>` with simplified imports
 
 ```typescript
-import {linqExtended, iterables, resolutions} from '@tsdotnet/linq';
+import linq, {iterables, resolutions} from '@tsdotnet/linq';
 
 const source = iterables.range(1,100); // Iterable<number>
-const result = linqExtended(source)
+const result = linq(source)
     .where(n => n%2===1) // odd numbers only
     .resolve(resolutions.sum); // 2500
 ```
 
 or
 
 ```typescript
-import {linqExtended} from '@tsdotnet/linq';
+import linq from '@tsdotnet/linq';
 import {range} from '@tsdotnet/linq/dist/iterables';
 import {sum} from '@tsdotnet/linq/dist/resolutions';
 
-const source = range(1,100); // Iterable<number>
+const source = range(1, 100); // Iterable<number>
 const result = linqExtended(source)
     .where(n => n%2===1) // odd numbers only
     .resolve(sum); // 2500
@@ -112,6 +132,7 @@ See the [docs](https://tsdotnet.github.io/linq/) for a full list.
 ```typescript
 linq(source).filter(a, b);
 linq(source).filter(a).filter(b);
+linq(source).filter(a).where(predicate);
 ```
 
 Any function that receives an `Iterable<T>` and returns an `Iterable<T>` is considered an
@@ -125,6 +146,8 @@ See the [docs](https://tsdotnet.github.io/linq/) for a full list.
 ```typescript
 linq(source).transform(x);
 linq(source).filter(a).transform(x);
+linq(source).where(predicate).transform(x);
+linq(source).where(predicate).select(mapping);
 ```
 
 Any function that receives an `Iterable<T>` and returns an `Iterable<TResult>` is considered an
@@ -138,9 +161,21 @@ See the [docs](https://tsdotnet.github.io/linq/) for a full list.
 ### Resolutions
 
 ```typescript
-linq(source).resolve(r);
-linq(source).transform(x).resolve(r);
-linq(source).filter(a, b).transform(x).resolve(r);
+sequence = linq(source);
+
+sequence.resolve(r);
+sequence.transform(x).resolve(r);
+sequence.filter(a).transform(x).resolve(r);
+sequence.where(predicate).resolve(r);
+sequence.filterWith(a, b).transform(x).resolve(r);
+```
+
+```typescript
+sequence = linqExtended(source);
+
+sequence.any();
+sequence.first();
+sequence.singleOrDefault();
 ```
 
 A resolution is a transform that takes an `Iterable<T>` and returns `TResult`.