     loadDataIdentifier     : Identifier) -> AsyncTypes2<NSError, (DataRequestContext<DataLoadContext>, NSData), NSError>.AsyncBinder
 {
     return { (bindError: NSError) -> AsyncTypes<(DataRequestContext<DataLoadContext>, NSData), NSError>.Async in
-        
+
         let finishCallbackHook = { (result: AsyncResult<(DataLoadContext, NSData), NSError>, doneCallback: AsyncTypes<(DataRequestContext<DataLoadContext>, NSData), NSError>.DidFinishAsyncCallback?) -> () in
-            
+
             switch result {
             case .Success(let value):
                 let newResult = (DataRequestContext<DataLoadContext>.Outside(value.0), value.1)
-                
+
                 doneCallback?(result: .Success(newResult))
             case .Failure(let error):
                 //TODO test [bindError isKindOfClass:[JFFErrorNoFreshData class]] issue, here it can got - not data in cache error !!!
                 if ignoreFreshDataLoadFail {
                     if let noFreshDataError = bindError as? ErrorNoFreshData {
-                    
+
                         let newResult = (DataRequestContext<DataLoadContext>.CacheUpdateDate(noFreshDataError.cachedData.0), noFreshDataError.cachedData.1)
-                        
+
                         doneCallback?(result: .Success(newResult))
                         return
                     }
                 }
-                
+
                 doneCallback?(result: .Failure(error))
             case .Interrupted:
                 doneCallback?(result: .Interrupted)

    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()) == NSComparisonResult.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, validateByDateResultBinder)
}

    let cacheKeyForIdentifier      = args.cacheKeyForIdentifier
    let cacheDataLifeTimeInSeconds = args.cacheDataLifeTimeInSeconds
    let ignoreFreshDataLoadFail    = args.ignoreFreshDataLoadFail

    let key = cacheKeyForIdentifier(loadDataIdentifier: loadDataIdentifier)

    let cachedDataLoader = { (progressCallback: AsyncProgressCallback?,
                              stateCallback   : AsyncChangeStateCallback?,
                              finishCallback  : AsyncTypes<(DataRequestContext<DataLoadContext>, NSData), NSError>.DidFinishAsyncCallback?) -> AsyncHandler in

        let loadCachedData: AsyncTypes<(DataRequestContext<DataLoadContext>, NSData), NSError>.Async = loadFreshCachedDataWithUpdateDate(
            key,
            cachedDataLoader          : cache.cachedDataLoaderForKey(key),
            cacheDataLifeTimeInSeconds: cacheDataLifeTimeInSeconds)

        let dataLoaderBinder = dataLoaderWithCachedResultBinder(
            ignoreFreshDataLoadFail,
            dataLoaderForIdentifier: dataLoaderForIdentifier,
            loadDataIdentifier     : loadDataIdentifier)

        let loader = bindTrySequenceOfAsyncs(loadCachedData, dataLoaderBinder)

        return loader(
            progressCallback: progressCallback,
            stateCallback   : stateCallback,
            finishCallback  : finishCallback)
    }

    let analyzer = { (response: (DataRequestContext<DataLoadContext>, NSData)) -> AsyncTypes<Result, NSError>.Async in

        let binder = analyzerForData(loadDataIdentifier: loadDataIdentifier)

        let analyzer = binder(response)

        let cacheBinder = { (analyzedData: Result) -> AsyncTypes<Result, NSError>.Async in

            let resultLoader: AsyncTypes<Result, NSError>.Async = async(value: analyzedData)

            switch response.0 {
            case .Outside:
                let loader = cache.loaderToSetData(response.1, forKey:key)
