diff --git a/src/CoreOperators.ts b/src/CoreOperators.ts
index 7de90bcf65..a6a7bc3279 100644
--- a/src/CoreOperators.ts
+++ b/src/CoreOperators.ts
@@ -18,7 +18,7 @@ export interface CoreOperators<T> {
   concatAll?: () => Observable<T>;
   concatMap?: <R>(project: ((x: T, ix: number) => Observable<any>), projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
   concatMapTo?: <R>(observable: Observable<any>, projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
-  count?: (predicate?: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any) => Observable<number>;
+  count?: (predicate?: (value: T, index: number, source: Observable<T>) => boolean) => Observable<number>;
   dematerialize?: () => Observable<any>;
   debounce?: (durationSelector: (value: T) => Observable<any> | Promise<any>) => Observable<T>;
   debounceTime?: <R>(dueTime: number, scheduler?: Scheduler) => Observable<R>;
diff --git a/src/Observable.ts b/src/Observable.ts
index d47e9b414f..d640f52a58 100644
--- a/src/Observable.ts
+++ b/src/Observable.ts
@@ -180,7 +180,7 @@ export class Observable<T> implements CoreOperators<T>  {
   concatAll: () => Observable<any>;
   concatMap: <R>(project: ((x: T, ix: number) => Observable<any>), projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
   concatMapTo: <R>(observable: Observable<any>, projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
-  count: (predicate?: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any) => Observable<number>;
+  count: (predicate?: (value: T, index: number, source: Observable<T>) => boolean) => Observable<number>;
   dematerialize: () => Observable<any>;
   debounce: (durationSelector: (value: T) => Observable<any> | Promise<any>) => Observable<T>;
   debounceTime: <R>(dueTime: number, scheduler?: Scheduler) => Observable<R>;
diff --git a/src/operator/count.ts b/src/operator/count.ts
index ba3e46ddb2..5a80f11661 100644
--- a/src/operator/count.ts
+++ b/src/operator/count.ts
@@ -5,7 +5,6 @@ import {Subscriber} from '../Subscriber';
 
 import {tryCatch} from '../util/tryCatch';
 import {errorObject} from '../util/errorObject';
-import {bindCallback} from '../util/bindCallback';
 
 /**
  * Returns an observable of a single number that represents the number of items that either:
@@ -23,37 +22,28 @@ import {bindCallback} from '../util/bindCallback';
  */
 export function count<T>(predicate?: (value: T,
                                       index: number,
-                                      source: Observable<T>) => boolean,
-                         thisArg?: any): Observable<number> {
-  return this.lift(new CountOperator(predicate, thisArg, this));
+                                      source: Observable<T>) => boolean): Observable<number> {
+  return this.lift(new CountOperator(predicate, this));
 }
 
 class CountOperator<T, R> implements Operator<T, R> {
   constructor(private predicate?: (value: T, index: number, source: Observable<T>) => boolean,
-              private thisArg?: any,
               private source?: Observable<T>) {
   }
 
   call(subscriber: Subscriber<R>): Subscriber<T> {
-    return new CountSubscriber<T, R>(
-      subscriber, this.predicate, this.thisArg, this.source
-    );
+    return new CountSubscriber<T, R>(subscriber, this.predicate, this.source);
   }
 }
 
 class CountSubscriber<T, R> extends Subscriber<T> {
-  private predicate: Function;
   private count: number = 0;
   private index: number = 0;
 
   constructor(destination: Observer<R>,
-              predicate?: (value: T, index: number, source: Observable<T>) => boolean,
-              private thisArg?: any,
+              private predicate?: (value: T, index: number, source: Observable<T>) => boolean,
               private source?: Observable<T>) {
     super(destination);
-    if (typeof predicate === 'function') {
-      this.predicate = bindCallback(predicate, thisArg, 3);
-    }
   }
 
   _next(value: T): void {