Why can't I use .reduce() in a one-liner Swift closure with a variadic, anonymous argument?

Question

The first closure works. However, as soon as I take out the dummy assignment, the closure stops working (addUpClosureRedFlagged). Anyone knows why?

let addUpClosureWorking: (Int ...) -> Int = {
  let dummy = "Anything"  // Comment out and wait for the error...
  return $0.reduce(0, combine: +)
}

let addUpClosureRedFlagged: (Int ...) -> Int = {
  return $0.reduce(0, combine: +)   // Should work, but doesn't!
}


addUpClosureWorking(1, 2, 3, 4, 5) // 15

Answer 1

As of current Swift (2.1), the type inference of closures can behave a bit strange when containing only a single line, see e.g. this somewhat related issue; expecting explicit inclusion of the function type signature within the closure.

This (compiler) "bug"/closure limitation is present (at least) for variadiac as well as inout arguments:

// variadiac argument example
let fooErr1: (Int ...) -> Int = {
    return $0.reduce(0, combine: +)
} 
// or: let fooErr1: (Int ...) -> Int = { $0.reduce(0, combine: +) }
   /*  error: cannot convert value of type '(_) -> Int' 
              to specified type '(Int...) -> Int'       */

// inout argument example
let fooErr2: (inout _: Int) -> Int = {
    return $0
}
// or: let fooErr2: (inout _: Int) -> Int = { $0 } 
   /* error: cannot convert value of type '_ -> Int' 
             to specified type '(inout Int) -> Int'     */

This can be avoided by explicitly including the function:s type signature in the closure, or including any statement prior to the return statement (in so extending the closure to contain more than a single line).

/* Avoiding fooErr1:
   - explicitly state function type signature in closure    */
let foo: (Int ...) -> Int = {
    (bar: Int ...) -> Int in
    return bar.reduce(0, combine: +)
}

/* - include any kind of statment prior to return statement */
let foo2: (Int ...) -> Int = {
    (); return $0.reduce(0, combine: +)
}

/* Avoiding fooErr2:
   - explicitly state function type signature in closure    */
let foo3: (inout _: Int) -> Int = {
    (inout bar: Int) -> Int in 
    return bar
}

/* - include any kind of statment prior to return statement */
let foo4: (inout _: Int) -> Int = {
    (); return $0
}

Why? I've written "bug" above, but perhaps more of a current limitation in the type inference of closures by the compiler; as Pradeep K writes in his answer, this is most likely due to some intricacies of the Swift compiler, failing type inference in these cases.