gistfile1.swift

// Two structs
struct One{ }
struct Two{ }

// Overloading the foo function - 
// it should always take two arguments, one of type One; the other of type Two
func foo(x:One,y:Two) {return }
func foo(x:Two,y:One) {return }

// In this example, Swift's type checker figures out that x must have type Two
let bar = {x in
    foo(One(),x)
}

// In this example, we construct a closure with two arguments. Now Swift's type
// checker can no longer figure out what the type of x and y must be. 
// This seems strange...
let baz = {x,y in
    foo(Two(),x)
    foo(Two(),y)
}

This also doesn't type-check:

let baz = {x in
    foo(One(),x)
    foo(One(),x)
}

Neither does this:

let baz = {x in
    return foo(One(),x)
}

To make the case even more concise: It's not even about the structs or using the variable twice in the closure:

func foo(x:String,y:Int) { return }
let bar = {x in
      foo("string",x)
}
let baz = {x in
      foo("string",x)
      let y = 23
}