diff --git a/redux-saga/redux-saga-tests.ts b/redux-saga/redux-saga-tests.ts
index 933a397b19..ce05915490 100644
--- a/redux-saga/redux-saga-tests.ts
+++ b/redux-saga/redux-saga-tests.ts
@@ -2,17 +2,26 @@
 
 
 import sagaMiddleware, {
+  storeIO,
+  runSaga,
+  Saga,
+  SagaCancellationException,
+  takeEvery,
+  takeLatest,
+  isCancelError
+} from 'redux-saga'
+
+import {
   take,
   put,
   race,
   call,
+  apply,
   fork,
+  select,
   cancel,
-  storeIO,
-  runSaga,
-  Saga,
-  SagaCancellationException
-} from 'redux-saga'
+} from 'redux-saga/effects'
+
 import {applyMiddleware, createStore} from 'redux';
 
 declare const delay: (ms: number) => Promise<any>;
@@ -47,13 +56,12 @@ namespace GettingStarted {
   }
 }
 
-
 namespace EffectCombinators {
   const fetchPostsWithTimeout:Saga = function* fetchPostsWithTimeout() {
     while( yield take('FETCH_POSTS') ) {
       // starts a race between 2 effects
       const {posts, timeout} = yield race({
-        posts   : call(fetchApi, '/posts'),
+        posts   : call([this, fetchApi], '/posts'),
         timeout : call(delay, 1000)
       })
 
@@ -132,12 +140,12 @@ namespace TaskCancellation {
     try {
       while(true) {
         yield put({type: 'REQUEST_START'})
-        const result = yield call(someApi)
+        const result = yield apply(this, someApi)
         yield put({type: 'REQUEST_SUCCESS', result})
         yield call(delay, 5000)
       }
     } catch(error) {
-      if(error instanceof SagaCancellationException)
+      if(error instanceof SagaCancellationException && isCancelError(error))
         yield put({type: 'REQUEST_FAILURE', message: 'Sync cancelled!'})
     }
   }
@@ -170,3 +178,36 @@ namespace DynamicallyStartingSagasWithRunSaga {
     storeIO(store)
   )
 }
+
+namespace DynamicallyStartingSagasWithMiddleware {
+  function* startupSaga() {
+  }
+
+  function* dynamicSaga() {
+  }
+
+  sagaMiddleware(startupSaga).run(dynamicSaga)
+}
+
+namespace TestHelpers {
+  function* watchAndLog(getState) {
+    yield* takeEvery('*', function* logger(action) {
+      console.log('action', action)
+    })
+  }
+
+  function* fetchUser(action) {
+  }
+
+  function* watchLastFetchUser() {
+    yield* takeLatest('USER_REQUESTED', fetchUser)
+  }
+}
+
+namespace AccessCurrentState {
+  export const getCart = state => state.cart;
+
+  function* checkout() {
+    const cart = yield select(getCart)
+  }
+}
diff --git a/redux-saga/redux-saga.d.ts b/redux-saga/redux-saga.d.ts
index 6573f12452..e68a2a2562 100644
--- a/redux-saga/redux-saga.d.ts
+++ b/redux-saga/redux-saga.d.ts
@@ -1,6 +1,6 @@
-// Type definitions for redux-saga 0.6.0
+// Type definitions for redux-saga 0.9.1
 // Project: https://github.com/yelouafi/redux-saga
-// Definitions by: Daniel Lytkin <https://github.com/aikoven>
+// Definitions by: Daniel Lytkin <https://github.com/aikoven>, Dimitri Rosenberg <https://github.com/rosendi>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
 /// <reference path="../redux/redux.d.ts" />
@@ -9,41 +9,17 @@ declare module 'redux-saga' {
   export class SagaCancellationException {
   }
 
-  export type Effect = {};
-
   export type Saga = <T>(getState?: () => T) => Iterable<any>;
-
-  type Predicate = (action: any) => boolean;
-
-  export function take(pattern?: string|string[]|Predicate): Effect;
-
-  export function put(action: any): Effect;
-
-  export function race(effects: {[key:string]: any}): Effect;
-
-  export function call<T1, T2, T3>(fn: (arg1?: T1, arg2?: T2, arg3?: T3, ...rest: any[]) => any,
-                                   arg1?: T1, arg2?: T2, arg3?: T3, ...rest: any[]): Effect;
-
-
-  export interface Task<T> {
-    name:string;
-    isRunning():boolean;
-    result():T;
-    error():any;
-  }
-
-  export function fork(effect: Effect): Effect;
-  export function fork<T1, T2, T3>(fn: (arg1?: T1, arg2?: T2, arg3?: T3, ...rest: any[]) =>
-    Promise<any>|Iterable<any>,
-                                   arg1?: T1, arg2?: T2, arg3?: T3, ...rest: any[]): Effect;
-
-  export function join(task: Task<any>): Effect;
-
-  export function cancel(task: Task<any>): Effect;
-
+  export type Predicate = (action: any) => boolean;
+  export type Pattern = string | string[] | Predicate;
 
   import {Middleware} from 'redux';
-  export default function (...sagas: Saga[]): Middleware;
+
+  interface SagaMiddleware extends Middleware {
+    run(saga: Saga, ...args: any[]): void;
+  }
+
+  export default function (...sagas: Saga[]): SagaMiddleware;
 
   export {
     CANCEL,
@@ -57,8 +33,59 @@ declare module 'redux-saga' {
 
   export {runSaga, storeIO} from 'redux-saga/lib/runSaga'
 
+  export interface Task<T> {
+    name:string;
+    isRunning():boolean;
+    result():T;
+    error():any;
+    cancel(): void;
+  }
+
+  export function takeEvery(pattern: Pattern, saga: Saga, ...args: any[]): { [Symbol.iterator](): IterableIterator<any> };
+
+  export function takeLatest(pattern: Pattern, saga: Saga, ...args: any[]): { [Symbol.iterator](): IterableIterator<any> };
+
+  export function isCancelError(e: any): boolean;
 }
 
+declare module 'redux-saga/effects' {
+  import {Task} from 'redux-saga';
+  import {Predicate} from 'redux-saga';
+  import {Pattern} from 'redux-saga';
+
+  export type Effect = {};
+
+  type EffectFunction<T1, T2, T3> = (arg1?: T1, arg2?: T2, arg3?: T3, ...rest: any[]) => Promise<any> | Iterable<any>;
+
+  interface EffectFunctionContext<T1, T2, T3> {
+    0: any;
+    1: EffectFunction<T1, T2, T3>;
+  }
+
+  export function take(pattern?: Pattern): Effect;
+
+  export function put(action: any): Effect;
+
+  export function race(effects: {[key:string]: any}): Effect;
+
+  export function call<T1, T2, T3>(fn: EffectFunction<T1, T2, T3>, arg1?: T1, arg2?: T2, arg3?: T3, ...rest: any[]): Effect;
+
+  export function call<T1, T2, T3>(fn: EffectFunctionContext<T1, T2, T3>, arg1?: T1, arg2?: T2, arg3?: T3, ...rest: any[]): Effect;
+
+  export function apply<T1, T2, T3>(context: any, fn: EffectFunction<T1, T2, T3>, arg1?: T1, arg2?: T2, arg3?: T3, ...rest: any[]): Effect;
+
+  export function fork(effect: Effect): Effect;
+
+  export function fork<T1, T2, T3>(fn: EffectFunction<T1, T2, T3>, arg1?: T1, arg2?: T2, arg3?: T3, ...rest: any[]): Effect;
+
+  export function fork<T1, T2, T3>(fn: EffectFunctionContext<T1, T2, T3>, arg1?: T1, arg2?: T2, arg3?: T3, ...rest: any[]): Effect;
+
+  export function join(task: Task<any>): Effect;
+
+  export function select(selector?: (state: any, ...args: any[]) => any, ...args: any[]): Effect;
+
+  export function cancel(task: Task<any>): Effect;
+}
 
 declare module 'redux-saga/lib/proc' {
   import {Task} from 'redux-saga';