Enumerating parts in ForEach – Ole Begemann

Suppose we need to show the contents of an array in a SwiftUI listing. We will do that with ForEach:

struct PeopleList: View {
  var individuals: [Person]

  var physique: some View {
    Record {
      ForEach(individuals) { particular person in
        Textual content(particular person.identify)
      }
    }
  }
}

Particular person is a struct that conforms to the Identifiable protocol:

struct Particular person: Identifiable {
  var id: UUID = UUID()
  var identify: String
}

ForEach makes use of the Identifiable conformance to find out the place parts have been inserted or deleted when the enter array adjustments, so as animate these adjustments accurately.

Now suppose we need to quantity the gadgets within the listing, as on this screenshot:

We would attempt one among these approaches:

• Name enumerated() on the array we go to ForEach, which produces a tuple of the shape (offset: Int, aspect: Factor) for every aspect.

• Alternatively, zip(1..., individuals) produces tuples of the identical form (albeit with out the labels), however permits us to decide on a distinct beginning quantity than 0.

I normally choose zip over enumerated for that reason, so let’s use it right here:

ForEach(zip(1..., individuals)) { quantity, particular person in
  Textual content("(quantity). (particular person.identify)")
}

This doesn’t compile for 2 causes:

1. The gathering handed to ForEach have to be a RandomAccessCollection, however zip produces a Sequence. We will repair this by changing the zipped sequence again into an array.

2. The aspect sort of the numbered sequence, (Int, Particular person), not conforms to Identifiable — and might’t, as a result of tuples can’t conform to protocols.

   This implies we have to use a distinct ForEach initializer, which lets us go in a key path to the aspect’s identifier discipline. The proper key path on this instance is .1.id, the place .1 selects the second aspect within the tuple and .id designates the property of the Particular person sort.

The working code then seems to be like this:

ForEach(Array(zip(1..., individuals)), id: .1.id) { quantity, particular person in
  Textual content("(quantity). (particular person.identify)")
}

It’s not tremendous clear what’s occurring there at a fast look; I notably dislike the .1 in the important thing path, and the Array(…) wrapper is simply noise. To enhance readability on the level of use, I wrote somewhat helper as an extension on Sequence that provides labels to the tuple and hides a number of the internals:

extension Sequence {
  /// Numbers the weather in `self`, beginning with the desired quantity.
  /// - Returns: An array of (Int, Factor) pairs.
  func numbered(startingAt begin: Int = 1) -> [(number: Int, element: Element)] {
    Array(zip(begin..., self))
  }
}

This makes name websites fairly a bit nicer:

ForEach(individuals.numbered(), id: .aspect.id) { quantity, particular person in
  Textual content("(quantity). (particular person.identify)")
}

The important thing path is extra readable, nevertheless it’s unlucky that we will’t depart it out totally. We will’t make the tuple Identifiable, however we may introduce a customized struct that acts because the aspect sort for our numbered assortment:

@dynamicMemberLookup
struct Numbered<Factor> {
  var quantity: Int
  var aspect: Factor

  subscript<T>(dynamicMember keyPath: WritableKeyPath<Factor, T>) -> T {
    get { aspect[keyPath: keyPath] }
    set { aspect[keyPath: keyPath] = newValue }
  }
}

Discover that I added a key-path primarily based dynamic member lookup subscript. This isn’t strictly essential, however it would enable shoppers to make use of a Numbered<Particular person> worth nearly as if it had been a plain Particular person. Many due to Min Kim for suggesting this, it hadn’t occured to me.

Let’s change the numbered(startingAt:) technique to make use of the brand new sort:

extension Sequence {
  func numbered(startingAt begin: Int = 1) -> [Numbered<Element>] {
    zip(begin..., self)
      .map { Numbered(quantity: $0.0, aspect: $0.1) }
  }
}

And now we will conditionally conform the Numbered struct to Identifiable when its aspect sort is Identifiable:

extension Numbered: Identifiable the place Factor: Identifiable {
  var id: Factor.ID { aspect.id }
}

This permits us to omit the important thing path and return to the ForEach initializer we used initially:

ForEach(individuals.numbered()) { numberedPerson in
  Textual content("(numberedPerson.quantity). (numberedPerson.identify)")
}

That is the place the key-path-based member lookup we added above reveals its energy. The numberedPerson variable is of sort Numbered<Particular person>, nevertheless it nearly behaves like a traditional Particular person struct with an added quantity property, as a result of the compiler forwards non-existent discipline accesses to the wrapped Particular person worth in a totally type-safe method. With out the member lookup subscript, we’d have to jot down numberedPerson.aspect.identify. This solely works for accessing properties, not strategies.