feat(drop): rename skip() to drop()

src/Stream.ts

@@ -3,7 +3,7 @@ import {Producer} from './Producer';
 import {MapOperator} from './operator/MapOperator';
 import {FilterOperator} from './operator/FilterOperator';
 import {TakeOperator} from './operator/TakeOperator';
-import {SkipOperator} from './operator/SkipOperator';
+import {DropOperator} from './operator/DropOperator';
 import {DebugOperator} from './operator/DebugOperator';
 import {FoldOperator} from './operator/FoldOperator';
 import {LastOperator} from './operator/LastOperator';
@@ -143,8 +143,8 @@ export class Stream<T> implements Listener<T> {
     return new Stream<T>(new TakeOperator(amount, this));
   }
 
-  skip(amount: number): Stream<T> {
-    return new Stream<T>(new SkipOperator(amount, this));
+  drop(amount: number): Stream<T> {
+    return new Stream<T>(new DropOperator(amount, this));
   }
 
   debug(spy: (t: T) => void = null): Stream<T> {

src/operator/SkipOperator.ts → src/operator/DropOperator.ts

@@ -5,11 +5,11 @@ import {emptyListener} from '../utils/emptyListener';
 
 export class Proxy<T> implements Listener<T> {
   constructor(public out: Stream<T>,
-              public prod: SkipOperator<T>) {
+              public prod: DropOperator<T>) {
   }
 
   next(t: T) {
-    if (this.prod.skipped++ >= this.prod.max) this.out.next(t);
+    if (this.prod.dropped++ >= this.prod.max) this.out.next(t);
   }
 
   error(err: any) {
@@ -21,9 +21,9 @@ export class Proxy<T> implements Listener<T> {
   }
 }
 
-export class SkipOperator<T> implements Operator<T, T> {
+export class DropOperator<T> implements Operator<T, T> {
   public proxy: Listener<T> = emptyListener;
-  public skipped: number = 0;
+  public dropped: number = 0;
 
   constructor(public max: number,
               public ins: Stream<T>) {

tests/operator/skip.ts → tests/operator/drop.ts

@@ -1,9 +1,9 @@
 import xs from '../../src/index';
 import * as assert from 'assert';
 
-describe('Stream.prototype.skip', () => {
-  it('should allow specifying max amount to skip from input stream', (done) => {
-    const stream = xs.interval(50).skip(4)
+describe('Stream.prototype.drop', () => {
+  it('should allow specifying max amount to drop from input stream', (done) => {
+    const stream = xs.interval(50).drop(4)
     const expected = [4, 5, 6];
     let listener = {
       next: (x: number) => {

tests/stream.ts

@@ -55,7 +55,7 @@ describe('Stream', () => {
     assert.equal(typeof stream.map, 'function');
     assert.equal(typeof stream.filter, 'function');
     assert.equal(typeof stream.take, 'function');
-    assert.equal(typeof stream.skip, 'function');
+    assert.equal(typeof stream.drop, 'function');
     assert.equal(typeof stream.debug, 'function');
     assert.equal(typeof stream.fold, 'function');
     assert.equal(typeof stream.last, 'function');