There seems to be a curious syntax glitch in the capture list syntax in Swift. If I declare multiple captured variables, the capture specifier only applies to the first one:

```
let closure = { [unowned x, y] in … }

```

Now I would expect `y` to be `unowned`, but it doesn’t seem to be the case:

```
class Test {

    var callback: (Void -> Void)?

    init() {
        print("init")
    }

    deinit {
        print("deinit")
    }
}

func makeScope() {
    let x = Test()
    let y = Test()
    y.callback = { [unowned x, y] in
        print(y)
    }
}

makeScope()
print("done")

```

This prints:

```
init
init
deinit
done

```

So `y` seems to be captured strongly and creates a retain cycle, preventing the object from being deallocated. Is that so? If yes, does it make sense to permit an “empty” capture specifier in the list? Or is there a reason `[unowned x, y]` is not treated as `[unowned x, unowned y]`?