From d5b9d1170b62b9277769e72134cba158f0d5b4b3 Mon Sep 17 00:00:00 2001
From: Ben Lesh <blesh@netflix.com>
Date: Mon, 28 Mar 2016 17:13:05 -0700
Subject: [PATCH] refactor(using): update subscription types for using

- now using will support objects that duck-type as subscriptions
---
 src/observable/UsingObservable.ts | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/observable/UsingObservable.ts b/src/observable/UsingObservable.ts
index 08071d217c..ad0750fa1c 100644
--- a/src/observable/UsingObservable.ts
+++ b/src/observable/UsingObservable.ts
@@ -1,6 +1,6 @@
 import {Observable, SubscribableOrPromise} from '../Observable';
 import {Subscriber} from '../Subscriber';
-import {Subscription} from '../Subscription';
+import {AnonymousSubscription, TeardownLogic} from '../Subscription';
 
 import {subscribeToResult} from '../util/subscribeToResult';
 import {OuterSubscriber} from '../OuterSubscriber';
@@ -11,23 +11,23 @@ import {OuterSubscriber} from '../OuterSubscriber';
  */
 export class UsingObservable<T> extends Observable<T> {
 
-  static create<T>(resourceFactory: () => Subscription | void,
-                   observableFactory: (resource: Subscription) => SubscribableOrPromise<T> | void): Observable<T> {
+  static create<T>(resourceFactory: () => AnonymousSubscription | void,
+                   observableFactory: (resource: AnonymousSubscription) => SubscribableOrPromise<T> | void): Observable<T> {
     return new UsingObservable<T>(resourceFactory, observableFactory);
   }
 
-  constructor(private resourceFactory: () => Subscription | void,
-              private observableFactory: (resource: Subscription) => SubscribableOrPromise<T> | void) {
+  constructor(private resourceFactory: () => AnonymousSubscription | void,
+              private observableFactory: (resource: AnonymousSubscription) => SubscribableOrPromise<T> | void) {
     super();
   }
 
-  protected _subscribe(subscriber: Subscriber<T>): Subscription | Function | void {
+  protected _subscribe(subscriber: Subscriber<T>): TeardownLogic {
     const { resourceFactory, observableFactory } = this;
 
-    let resource: Subscription;
+    let resource: AnonymousSubscription;
 
     try {
-      resource = <Subscription>resourceFactory();
+      resource = <AnonymousSubscription>resourceFactory();
       return new UsingSubscriber(subscriber, resource, observableFactory);
     } catch (err) {
       subscriber.error(err);
@@ -37,8 +37,8 @@ export class UsingObservable<T> extends Observable<T> {
 
 class UsingSubscriber<T> extends OuterSubscriber<T, T> {
   constructor(destination: Subscriber<T>,
-              private resource: Subscription,
-              private observableFactory: (resource: Subscription) => SubscribableOrPromise<T> | void) {
+              private resource: AnonymousSubscription,
+              private observableFactory: (resource: AnonymousSubscription) => SubscribableOrPromise<T> | void) {
     super(destination);
     destination.add(resource);
     this.tryUse();