I'm testing in playground this code (I'm using UnsafeMutablePointers to simulate deinitialization): 

```
class TestClassA {

    func returnFive() -> Int {
        return 5
    }

    deinit {
        println("Object TestClassA is destroyed!") //this way deinit is not called
    }
}

class TestClassB {

    let closure: () -> Int

    init(closure: () -> Int) {
        self.closure = closure
    }

    deinit {
        println("Object TestClassB is destroyed!")
    }
}

let p1 = UnsafeMutablePointer<TestClassA>.alloc(1)
p1.initialize(TestClassA())

let p2 = UnsafeMutablePointer<TestClassB>.alloc(1)
p2.initialize(TestClassB(closure: p1.memory.returnFive))

p2.memory.closure()
p1.memory.returnFive()

p1.destroy()

```

However, when I change the initialization of TestClassB as:

```
p2.initialize(TestClassB(closure: {p1.memory.returnFive()}))

```

now TestClassA can be deinitialized. 

So can someone tell me, what is the difference between

```
TestClassB(closure: p1.memory.returnFive)

```

and

```
TestClassB(closure: {p1.memory.returnFive()})

```

and why in the second case there is no strong reference to TestClassA so it can be deinitalized?