 
         let cacheBinder = { (analyzedData: Result) -> AsyncStream<Result, AnyObject, NSError> in
 
-            let resultLoader: AsyncTypes<Result, NSError>.Async = async(value: analyzedData)
+            let resultLoader = AsyncStream<Result, AnyObject, NSError>.succeeded(with: analyzedData)
 
             switch response.0 {
             case .Outside:
-                let loader = cache.loaderToSetData(response.1, forKey:cacheKey).toAsync()
-                return asyncToStream(sequenceOfAsyncs(loader, resultLoader))
+                let loader = cache.loaderToSetData(response.1, forKey:cacheKey)
+                return loader.flatMap(.Latest, transform: { _ in resultLoader })
             case .CacheUpdateDate:
-                return asyncToStream(resultLoader)
+                return resultLoader
             }
         }
 

            dataLoader        : dataLoader,
            loadDataIdentifier: loadDataIdentifier)

        let loader = bindTrySequenceOfAsyncs(loadCachedData, dataLoaderBinder)
        return asyncToStream(loader).observe(observer: observer)
    }

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


import Foundation

import iAsync_utils
import iAsync_reactiveKit

