 private func dataLoaderWithCachedResultBinder<Identifier, DataLoadContext>(
     ignoreFreshDataLoadFail: Bool,
     dataLoader             : AsyncStream<(DataLoadContext, NSData), AnyObject, NSError>,
-    loadDataIdentifier     : Identifier) -> AsyncTypes2<NSError, (DataRequestContext<DataLoadContext>, NSData), NSError>.AsyncBinder
+    loadDataIdentifier     : Identifier) -> NSError -> AsyncStream<(DataRequestContext<DataLoadContext>, NSData), AnyObject, NSError>
 {
-    return { (bindError: NSError) -> AsyncTypes<(DataRequestContext<DataLoadContext>, NSData), NSError>.Async in
+    return { (bindError: NSError) -> AsyncStream<(DataRequestContext<DataLoadContext>, NSData), AnyObject, NSError> in
 
         let dataLoader = dataLoader.map({ value -> (DataRequestContext<DataLoadContext>, NSData) in
 

            return .Failure(error)
        })

        return dataLoader.toAsync()
    }
}

private func loadFreshCachedDataWithUpdateDate<DataLoadContext>(
    key: String,
    cachedDataLoader: AsyncStream<(date: NSDate, data: NSData), AnyObject, NSError>,
    cacheDataLifeTimeInSeconds: NSTimeInterval) -> AsyncTypes<(DataRequestContext<DataLoadContext>, NSData), NSError>.Async {

    let validateByDateResultBinder = { (cachedData: (date: NSDate, data: NSData)) -> AsyncTypes<(DataRequestContext<DataLoadContext>, NSData), NSError>.Async in

        let newDate = cachedData.0.dateByAddingTimeInterval(cacheDataLifeTimeInSeconds)
        if newDate.compare(NSDate()) == .OrderedDescending {

            let cachedResult = (DataRequestContext<DataLoadContext>.CacheUpdateDate(cachedData.0), cachedData.1)
            return async(value: cachedResult)
        }

        let error = ErrorNoFreshData(cachedData: cachedData)
        return async(error: error)
    }

    return bindSequenceOfAsyncs(cachedDataLoader.toAsync(), validateByDateResultBinder)
}

            dataLoader        : dataLoader,
            loadDataIdentifier: loadDataIdentifier)

        return loadCachedData.flatMapError { dataLoaderBinder($0) }.observe(observer: observer)
    }

    let analyzer = { (response: (DataRequestContext<DataLoadContext>, NSData)) -> AsyncStream<Result, AnyObject, NSError> in
