Avoid consecutive “if let” declarations in Swift [duplicate]

Answer 1

After some lecture thanks to Martin R, I found an interesting workaround: https://stackoverflow.com/a/26012746/2754218

func unwrap(a:T?, b:U?, handler:((T, U) -> ())?) -> Bool {
    switch (a, b) {
    case let (.Some(a), .Some(b)):
        if handler != nil {
            handler!(a, b)
        }
        return true
    default:
        return false
    }
}

The solution is interesting, but it would be better if the method uses variadic parameters.

I naively started to create such a method:

extension Array
{
    func find(includedElement: T -> Bool) -> Int?
    {
        for (idx, element) in enumerate(self)
        {
            if includedElement(element)
            {
                return idx
            }
        }

        return nil
    }
}

func unwrap(handler:((T...) -> Void)?, a:T?...) -> Bool
{

    let b : [T!] = a.map { $0 ?? nil}

    if b.find({ $0 == nil }) == nil
    {
        handler(b)
    }
}

But I've this error with the compiler: Cannot convert the expression's type '[T!]' to type '((T...) -> Void)?'

Any suggestion for a workaround ?