Exercise 2: A Horizontal ScrollView of Colored Rectangles, and Why LazyHStack — Possible Solution
=========================================================================================================

struct ColorStripView: View {
    let colors: [Color] = [.red, .orange, .yellow, .green, .mint,
                            .teal, .cyan, .blue, .indigo, .purple]

    var body: some View {
        ScrollView(.horizontal) {
            LazyHStack {
                ForEach(0..<colors.count, id: \.self) { index in
                    Rectangle()
                        .fill(colors[index])
                        .frame(width: 80, height: 80)
                        .overlay(Text("\(index + 1)").foregroundStyle(.white))
                }
            }
        }
    }
}

(Note: ForEach(0..<colors.count, id: \.self) is used here since plain
Int values from a range are their own natural, stable identifier - a
real, valid alternative to Identifiable conformance for simple cases
like this.)

WHY LazyHStack IS THE BETTER REAL CHOICE: Per the chapter's own real
laziness comparison, a plain HStack builds every one of its child
views immediately, regardless of how many are actually visible on
screen inside the ScrollView at any given moment - all ten colored
rectangles would be created up front even though only a handful are
ever scrolled into view at once.

LazyHStack, by contrast, creates each child view only as it's about
to scroll into the visible area - exactly the same real, built-in
laziness List already provides automatically, but explicitly opted
into here since a plain ScrollView has no such default. For ten
rectangles the real difference in this specific case is negligible,
but the same LazyHStack correctly and automatically scales to
hundreds or thousands of items with no further changes needed - a
plain HStack would build every single one immediately regardless of
count, genuinely hurting performance well before a plain List's own
comparable, lazy version ever would.

ANSWER: LazyHStack is the better real choice because it creates each
rectangle's view only as it's about to scroll into visibility, rather
than building all of them immediately the way a plain HStack always
does - a difference that's negligible at ten items but becomes a real
performance concern the moment the same code needs to scale to a much
larger real dataset.

WHY THIS WORKS AS AN ANSWER
------------------------------
This correctly builds a horizontal scrollable strip and explains
LazyHStack's real deferred-creation behavior as the concrete reason it
scales better than a plain HStack for larger real datasets.