anchor.diff:  
       [<DataMember(Name = "DefaultDir")>]
       let defaultDir = defaultDir
  +    
  +    let getObjMetadata path = async {
  +        let req = GetObjectMetadataRequest(BucketName = bucketName, Key = path)
  +        return! account.S3Client.GetObjectMetadataAsync(req)
  +                |> Async.AwaitTaskCorrect
  +    }
  +
  +    let listObjects prefix nextMarker = async {
  +        let req = ListObjectsRequest(
  +                    BucketName = bucketName,
  +                    Prefix     = prefix,
  +                    Delimiter  = "/",
  +                    Marker     = nextMarker)
  +        return! account.S3Client.ListObjectsAsync(req) 
  +                |> Async.AwaitTaskCorrect
  +    }
  +
  +    let enumerateDir directory map = async {
  +            let prefix  = normalizeDirPath directory
  +            let results = ResizeArray<string>()            
  +
  +            let rec aux nextMarker = async {
  +                let! res = listObjects prefix nextMarker
  +                map res |> results.AddRange
  +                if res.NextMarker = null then return ()
  +                else return! aux res.NextMarker
  +            }
  +
  +            do! aux null
  +            return Seq.toArray results
  +        }
   
   //    let enumerateFiles directory = async {
   //        let 
  
positive.code:         }
  
          member __.DefaultDirectory = defaultDir
          member this.DeleteDirectory(directory, recursiveDelete) = async {
              
  //            let req = DeleteObjectsRequest(BucketName = bucketName)
  //            req.Objects.Add(new KeyVersion())
  
negative.code:         }
          
          member __.TryGetETag(path) = async {
              let! res = getObjMetadata path |> Async.Catch
              match res with
              | Choice1Of2 res -> return Some res.ETag
              | _ -> return None
          }
  
          member __.UploadFromLocalFile(localSourcePath, cloudTargetPath) = async {
              do! account.S3Client.UploadObjectFromFilePathAsync(
                      bucketName, 
                      cloudTargetPath, 
                      localSourcePath, 
                      Dictionary<string, obj>())
                  |> Async.AwaitTaskCorrect
          }
  
          member __.UploadFromStream(path, stream) = async {
              do! account.S3Client.UploadObjectFromStreamAsync(
                      bucketName,
                      path,
                      stream,
                      Dictionary<string, obj>())
                  |> Async.AwaitTaskCorrect
          }
  
          member this.WriteETag(path, writer) = async {
              let! metaRes = getObjMetadata path
              let! result = async {
                  use stream = new MemoryStream()
                  let! result = writer(stream)
                  do! (this :> ICloudFileStore).UploadFromStream(path, stream)
                  return result
              }
  
              return metaRes.ETag, result
          }
          
          //#endregion
  
  