Ios Swift闭包：无法使用参数列表调用函数

我正在使用闭包编写一个Swift函数。应该是可编译的代码示例如下所示

import Foundation

typealias PKSynchronizeProgressBlock = (Double) -> Void
typealias PKSynchronizeCompletionBlock = (Bool, NSError?) -> Void

class X {

func synchronizeAppDataWithProgress(
    progress: PKSynchronizeProgressBlock?, 
    completion: PKSynchronizeCompletionBlock?) {
        dispatch_async(dispatch_get_main_queue(), {

                // Do a lot of downloading, and during the process
                // {
                // If progress is updated
                if (progress != nil) {
                    progress!(Double(0))
                }
                //
                // If something goes wrong
                if (completion != nil) {
                    completion!(false, nil)
                }
                // }
                dispatch_async(dispatch_get_main_queue(), {
                    if (completion != nil) {
                        completion!(true, nil)
                    }
                })
        })
}


func foo() {
    self.synchronizeAppDataWithProgress({ (progress: Double) -> Void in
        self.launchProgressBar.progress = progress
    }, completion: { (success: Bool, error: NSError?) -> Void in
        if success {
            self.launchProgressBar.progress = 1.0
        }
        else {
            print("Failed to synchronize app data with error %@", error!)
        }
    })
}

}

但是，此代码不编译。Xcode说

无法使用参数列表调用“synchronizeAppDataWithProgress” “（进度：（双）->无效，完成：（Bool，n错误？->Void）”

我该怎么办？我的代码有没有犯什么愚蠢的错误

---

更新：

感谢@Mario Zannone。我修复了上面代码中的前两个错误。那就是：（1）我在函数调用中插入了一个冗余的

progress:

。我已经把它去掉了。（2） 我在主线程以外的线程中更新了UI

但是，如果我不注释掉

foo（）

中的以下一行，代码仍然不起作用

---

你知道为什么吗？

Xcode有时会对闭包中参数的列出方式很挑剔。我发现最好不要使用这种类型。还要确保使用捕获列表来避免闭包中的强引用循环

使用依赖关系，我重写了上面的代码，并编译了它

import Alamofire

typealias ProgressBlock = (Double) -> Void
typealias CompletionBlock = (Bool, ErrorType?) -> Void

class ExampleDataSource {
    func fetchData(progress: ProgressBlock?, completion: CompletionBlock?) {
        // Here we use the Alamofire Dependency for progress reporting simplicity.
        Alamofire.request(.GET, "https://www.myexampledomain.com")
            .progress { bytesRead, totalBytesRead, totalBytesExpectedToRead in
                // bytesRead, totalBytesRead, and totalBytesExpectedToRead are Int64
                // so we must perform unit conversion
                let progressPercentage = Double(totalBytesRead) / Double(totalBytesExpectedToRead)
                // here we optionally call the ProgressBlock 'progress' and pass it the progressPercentage
                progress?(progressPercentage)
            }
            .response { request, response, data, error in
                // here we usually parse the data, but for simplicity we'll
                // simply check to see if it exists.
                let completionFlag = (data != nil)
                // note that NSError? is interchangable with ErrorType?
                completion?(completionFlag, error)
        }
    }
    func performTasks() {
        // first we'll set up our closures...
        let progressBlock: ProgressBlock = { progress in
            // here we update the UI or whatever 
            // the nice thing about the Alamofire dependency is
            // that it's thread-safe :]
        }
        let completionBlock: CompletionBlock = { success, error in
            // here we do whatever we need to do when the
            // network operation finishes, or handle the 
            // errors appropriately
        }
        // then we'll pass them into our fetchData method
        fetchData(progressBlock, completion: completionBlock)
    }
}

import Alamofire

typealias ProgressBlock = (Double) -> Void
typealias CompletionBlock = (Bool, ErrorType?) -> Void

class ExampleDataSource {
    func fetchData(progress: ProgressBlock?, completion: CompletionBlock?) {
        // Here we use the Alamofire Dependency for progress reporting simplicity.
        Alamofire.request(.GET, "https://www.myexampledomain.com")
            .progress { bytesRead, totalBytesRead, totalBytesExpectedToRead in
                // bytesRead, totalBytesRead, and totalBytesExpectedToRead are Int64
                // so we must perform unit conversion
                let progressPercentage = Double(totalBytesRead) / Double(totalBytesExpectedToRead)
                // here we optionally call the ProgressBlock 'progress' and pass it the progressPercentage
                progress?(progressPercentage)
            }
            .response { request, response, data, error in
                // here we usually parse the data, but for simplicity we'll
                // simply check to see if it exists.
                let completionFlag = (data != nil)
                // note that NSError? is interchangable with ErrorType?
                completion?(completionFlag, error)
        }
    }
    func performTasks() {
        // first we'll set up our closures...
        let progressBlock: ProgressBlock = { progress in
            // here we update the UI or whatever 
            // the nice thing about the Alamofire dependency is
            // that it's thread-safe :]
        }
        let completionBlock: CompletionBlock = { success, error in
            // here we do whatever we need to do when the
            // network operation finishes, or handle the 
            // errors appropriately
        }
        // then we'll pass them into our fetchData method
        fetchData(progressBlock, completion: completionBlock)
    }
}