feat(endWith): adds endWith operator

spec/asynciterable-operators/endwith-spec.ts

@@ -0,0 +1,12 @@
+import * as Ix from '../Ix';
+import * as test from 'tape';
+const { range } = Ix.asynciterable;
+const { sequenceEqual } = Ix.asynciterable;
+const { endWith } = Ix.asynciterable;
+
+test('AsyncIterable#endWith adds to end', async t => {
+  const e = range(0, 5);
+  const r = endWith(e, 6, 7);
+  t.true(await sequenceEqual(r, range(0, 7)));
+  t.end();
+});

spec/iterable-operators/endwith-spec.ts

@@ -0,0 +1,12 @@
+import * as Ix from '../Ix';
+import * as test from 'tape';
+const { range } = Ix.iterable;
+const { sequenceEqual } = Ix.iterable;
+const { endWith } = Ix.iterable;
+
+test('Iterable#endWith adds to end', t => {
+  const e = range(0, 5);
+  const r = endWith(e, 6, 7);
+  t.true(sequenceEqual(r, range(0, 7)));
+  t.end();
+});

src/add/asynciterable-operators/endwith.ts

@@ -0,0 +1,19 @@
+import { AsyncIterableX } from '../../asynciterable';
+import { endWith } from '../../asynciterable/endwith';
+
+/**
+ * @ignore
+ */
+export function endWithProto<T>(
+    this: AsyncIterableX<T>,
+    ...args: T[]) {
+  return endWith(this, ...args);
+}
+
+AsyncIterableX.prototype.endWith = endWithProto;
+
+declare module '../../asynciterable' {
+  interface AsyncIterableX<T> {
+    endWith: typeof endWithProto;
+  }
+}

src/add/iterable-operators/endwith.ts

@@ -0,0 +1,19 @@
+import { IterableX } from '../../iterable';
+import { endWith } from '../../iterable/endwith';
+
+/**
+ * @ignore
+ */
+export function endWithProto<T>(
+    this: IterableX<T>,
+    ...args: T[]) {
+  return endWith(this, ...args);
+}
+
+IterableX.prototype.endWith = endWithProto;
+
+declare module '../../iterable' {
+  interface IterableX<T> {
+    endWith: typeof endWithProto;
+  }
+}

src/asynciterable/__modules.ts

@@ -27,6 +27,7 @@ import { distinctUntilChanged } from './distinctuntilchanged';
 import { doWhile } from './dowhile';
 import { elementAt } from './elementat';
 import { empty } from './empty';
+import { endWith } from './endwith';
 import { every } from './every';
 import { except } from './except';
 import { expand } from './expand';
@@ -139,6 +140,7 @@ export default {
     doWhile,
     elementAt,
     empty,
+    endWith,
     every,
     except,
     expand,
@@ -220,4 +222,4 @@ export default {
     union,
     _while,
     zip
-};
+};

src/asynciterable/endwith.ts

@@ -0,0 +1,23 @@
+import { AsyncIterableX } from '../asynciterable';
+
+class EndWithAsyncIterable<TSource> extends AsyncIterableX<TSource> {
+  private _source: AsyncIterable<TSource>;
+  private _args: TSource[];
+
+  constructor(source: AsyncIterable<TSource>, args: TSource[]) {
+    super();
+    this._source = source;
+    this._args = args;
+  }
+
+  async *[Symbol.asyncIterator]() {
+    for await (let item of this._source) { yield item; }
+    for (let x of this._args) { yield x; }
+  }
+}
+
+export function endWith<TSource>(
+    source: AsyncIterable<TSource>,
+    ...args: TSource[]): AsyncIterableX<TSource> {
+  return new EndWithAsyncIterable<TSource>(source, args);
+}

src/iterable/__modules.ts

@@ -26,6 +26,7 @@ import { distinctUntilChanged } from './distinctuntilchanged';
 import { doWhile } from './dowhile';
 import { elementAt } from './elementat';
 import { empty } from './empty';
+import { endWith } from './endwith';
 import { every } from './every';
 import { except } from './except';
 import { expand } from './expand';
@@ -128,6 +129,7 @@ export default {
     doWhile,
     elementAt,
     empty,
+    endWith,
     every,
     except,
     expand,
@@ -200,4 +202,4 @@ export default {
     union,
     _while,
     zip
-};
+};

src/iterable/endwith.ts

@@ -0,0 +1,23 @@
+import { IterableX } from '../iterable';
+
+class EndWithIterable<TSource> extends IterableX<TSource> {
+  private _source: Iterable<TSource>;
+  private _args: TSource[];
+
+  constructor(source: Iterable<TSource>, args: TSource[]) {
+    super();
+    this._source = source;
+    this._args = args;
+  }
+
+  *[Symbol.iterator]() {
+    for (let item of this._source) { yield item; }
+    for (let x of this._args) { yield x; }
+  }
+}
+
+export function endWith<TSource>(
+    source: Iterable<TSource>,
+    ...args: TSource[]): IterableX<TSource> {
+  return new EndWithIterable<TSource>(source, args);
+}