Why is this a retain cycle?

Question

I have basic understanding of ARC but in the following example I suddenly get really confused.

FeedViewController has a strong reference of NetworkHelper , then the NetworkHelper has a function which takes a closure and call it later.

So here's the confusion: the closure is passed from FeedViewController to NetworkHelper , And this block is not being retained inside NetworkHelper , so why does NetworkHelper has a strong reference of NetworkHelper ? this is stated in an article but I just could't figure out why. It makes sense to me only if NetworkHelper keep a strong reference to the block.

class NetworkHelper {
    func getFeed(completion: @escaping ([FeedItem]) -> Void) {
        Alamofire.request(…).responseJSON { (response) in
            if let value = response.result.value {
                if let json = JSON(value)[Constants.items].array {
                    completion(json.flatMap(FeedItem.init))
                }
            }
        }
    }
}

class FeedViewController {
    var tableView: UITableViewController
    var feedItems: [FeedItem]
    var networkHelper: NetworkHelper
    override func viewDidLoad() {
        ...
        networkHelper.getFeed() { items in
            self.feedItems = items
            self.tableView.reloadData()
        }
    }
}

Answer 1

Technically, there is no cycle.

First of all, NetworkHelper never owns anything, it just passes a closure to Alamofire .

Alamofire holds to that closure, which retains a FeedViewController instance (as self ). However, Alamofire is not owned by FeedViewController , therefore there is no cycle.

It's true that while the request is running, FeedViewController cannot be deallocated because the completion callback prevents that, but that could be an expected behavior and there is definitely no ownership cycle.