Offering a default worth for a SwiftUI Binding – Donny Wals

Generally in SwiftUI apps I’ll discover that I’ve a mannequin with an optionally available worth that I’d wish to cross to a view that requires a non optionally available worth. That is particularly the case once you’re utilizing Core Information in your SwiftUI apps and use auto-generated fashions.

Take into account the next instance:

class SearchService: ObservableObject {
  @Printed var outcomes: [SearchResult] = []
  @Printed var question: String?
}

Let me begin by acknowledging that sure, this object may be written with a question: String = "" as an alternative of an optionally available String?. Sadly, we don’t at all times personal or management the fashions and objects that we’re working with. In these conditions we may be coping with optionals the place we’d fairly have our values be non-optional. Once more, this may be very true when utilizing generated code (like once you’re utilizing Core Information).

Now let’s think about using the mannequin above within the following view:

struct MyView: View {
  @ObservedObject var searchService: SearchService

  var physique: some View {
      TextField("Question", textual content: $searchService.question)
  }
}

This code is not going to compile as a result of we have to cross a binding to a non optionally available string to our textual content area. The compiler will present the next error:

Can not convert worth of sort ‘Binding<String?>’ to anticipated argument sort ‘Binding‘

One of many methods to repair that is to offer a customized occasion of Binding that may present a default worth in case question is nil. Making it a Binding<String> as an alternative of Binding<String?>.

Defining a customized binding

A SwiftUI Binding occasion is nothing greater than a get and set closure which are known as every time someone tries to learn the present worth of a Binding or after we assign a brand new worth to it.

Right here’s how we are able to create a customized binding:

Binding(get: {
  return "Hi there, world"
}, set: { _ in
  // we are able to replace some exterior or captured state right here
})

The instance above basically recreates Binding‘s .fixed which is a binding that can at all times present the identical pre-determined worth.

If we had been to jot down a customized Binding that enables us to make use of $searchService.question to drive our TextField it could look a bit like this:

struct MyView: View {
  @ObservedObject var searchService: SearchService

  var customBinding: Binding<String> {
    return Binding(get: {
      return searchService.question ?? ""
    }, set: { newValue in
      searchService.question = newValue
    })
  }

  var physique: some View {
    TextField("Question", textual content: customBinding)
  }
}

This compiles, and it really works effectively, but when we have now a number of occurrences of this case in our codebase, it could be good if had a greater approach of scripting this. For instance, it could neat if we might write the next code:

struct MyView: View {
  @ObservedObject var searchService: SearchService

  var physique: some View {
    TextField("Question", textual content: $searchService.question.withDefault(""))
  }
}

We are able to obtain this by including an extension on Binding with a technique that’s obtainable on present bindings to optionally available values:

extension Binding {
  func withDefault<T>(_ defaultValue: T) -> Binding<T> the place Worth == Optionally available<T> {
    return Binding<T>(get: {
      self.wrappedValue ?? defaultValue
    }, set: { newValue in
      self.wrappedValue = newValue
    })
  }
}

The withDefault(_:) perform we wrote right here may be known as on Binding cases and in essence it does the very same factor as the unique Binding already did. It reads and writes the unique binding’s wrappedValue. Nonetheless, if the supply Binding has nil worth, we offer our default.

What’s good is that we are able to now create bindings to optionally available values with a fairly simple API, and we are able to use it for any type of optionally available information.