Do away with weak, unowned self-access if you're not mutating self in itself.

DispatchQ — Tue, 21 Jan 2020 11:36:41 +0000

Do away with weak, unowned self access if you're not mutating self in itself. Capture interested properties of self in the closure.

Example:

// 1
let closure = { [weak self] in
  self?.navigationItem.rightBarButtonItems = [...]
}

or 

// 2
let anotherClosure = { [weak self] in
    let identifier = self?.identifier ?? "" // identifier is non-optional in SELF scope.
    let request = APIRequest(.../identifier)
  request.perform(...) { _ in

  }
}

In snippet 1 - the self is optionally chained. In snippet 2 - identifier is not optional in the normal self scope.

But just because the self is marked weak it's properties are also needed to chained optionally and results in many optional checks.

Another clean approach is just capture the interested properties of self in closures.

The snippet 1 could be re-written as

let closure = { [navItem = navigationItem] in // could just capture as `[navigationItem] in` also
        navItem.rightBarButtonItems = nil // no self access and no ugly optional checks
}

most importantly accessing it through the local scoped navItem - you'll always get the initial state of the property you're capturing. Attached a Swift playground demoing this powerful feature. Check out!

and the snippet 2 could be written as

let anotherClosure = { [identifier] in
let request = APIRequest(.../identifier)
request.perform(...) { _ in ... }
}

Note: If you really need to mutate self then neccessay closure scoping (weak, unowned) is needed. This example shows clean way to act on properties of self .

Another tip when calling functions of `self` from inside the closures is to keep a local copy of self before the closure.

func doSomethingWithSelf() {
    let localSelf = self

        let closure = { [localSelf] in
        ...
    }
}

This way the localSelf over the closure is destroyed when the function returns control.

You can also send `self` as an argument to the closure. This way no capturing/copying is needed. You still can act on `self`.

func perform<T: AnyObject>(_ reference: T, closure: @escaping (T) -> Void) {
    { [weak reference] in
        guard let strongReference = reference else { return }
        closure(strongReference)
    }()
}

and at the call site no weak self is needed since everything is handled inside the function and the weak, strong casting is done in one place only.

At the call site this looks like:

perform(self) { (reference) in
    reference.doSometing()
}

No more weak self dancing and un-neccessary nil checks. 🎉

Infer return type with generic Where clause in protocol and extensions.

DispatchQ — Mon, 13 Jan 2020 14:45:17 +0000

Let's look at the code:

extension UIView {
    class func loadFromNib<T: UIView>() -> T {
        guard let nib = Bundle(for: T.self)
            .loadNibNamed(String(describing: T.self), owner: nil, options: nil)?.first as? T else {
            fatalError("Missing nib for class.")
        }
        return nib
    }
}

The code gets the job done, it loads an UIView from xib file and returns the view.

But at the call site, the return type is not inferred, we'll have to specify UIView Type like this

let view: ActionView = ActionView.loadFromNib()

to access the properties of ActionView. While swift can infer the type, I don't want to do this.

Instead the same function could be written as a protocol with Where Clause this enables swift to auto infer type.

protocol NibLoadable where Self: UIView {
    static func loadFromNib() -> Self
}

extension NibLoadable {
    static func loadFromNib() -> Self {
        guard let nib = Bundle(
            for: Self.self).loadNibNamed(
            String(describing: Self.self),
            owner: nil,
            options: nil
        )?.first as? Self else {
            fatalError("Missing nib for class.")
        }
        return nib
    }
}

Just conform to this protocol and you'll get the function with automatic type inferring.

With this implementation, the view type is auto inferred by swift.

let view = ActionView.loadFromNib() // view's type is auto inferred.

DEV Community: DispatchQ

Do away with weak, unowned self-access if you're not mutating self in itself.

Another tip when calling functions of self from inside the closures is to keep a local copy of self before the closure.

You can also send self as an argument to the closure. This way no capturing/copying is needed. You still can act on self.

Infer return type with generic Where clause in protocol and extensions.

Another tip when calling functions of `self` from inside the closures is to keep a local copy of self before the closure.

You can also send `self` as an argument to the closure. This way no capturing/copying is needed. You still can act on `self`.