Create a list from enum

Question

I'd like to be able to create a List from an enum that conforms to CaseIterable and CustomStringConvertible e.g.

public enum HairColor: Int, Codable, CaseIterable, CustomStringConvertible {
    public var description: String {
        switch self {
        case .black:
            return "Black"
        case .blond:
            return "Blond"
        case .brown:
            return "Brown"
        case .red:
            return "Red"
        case .grey:
            return "Gray"
        case .bald:
            return "Bald"
        }
    }
    case blond, brown, black, red, grey, bald
}
struct ContentView: View {
    var body: some View {
        SwiftUIHelpers.enumToList(HairColor)
    }
}

This is the approach I've tried but I get the error: "Cannot convert value of type 'Text' to closure result type '_"

struct SwiftUIHelpers {
    static func enumToList<T: CaseIterable, RandomAccessCollection>(_ a: T) -> some View {
        List {
            ForEach(a, id: \.rawValue) { (o: CustomStringConvertible) in
                Text(o.description)
            }
        }
    }
}

What is the error on my ways?!?

Answer 1

Here is working solution. Tested with Xcode 11.4 / iOS 13.4.

struct SwiftUIHelpers {
    static func enumToList<T: CaseIterable>(_ t: T.Type) -> some View 
           where T.AllCases: RandomAccessCollection, T: Hashable & CustomStringConvertible {
        List {
            ForEach(t.self.allCases, id: \.self) { o in
                Text(o.description)
            }
        }
    }
}

struct ContentView: View {
    var body: some View {
        SwiftUIHelpers.enumToList(HairColor.self)
    }
}

public enum HairColor: Int, Codable, Hashable, CaseIterable, CustomStringConvertible {
    public var description: String {
        switch self {
        case .black:
            return "Black"
        case .blond:
            return "Blond"
        case .brown:
            return "Brown"
        case .red:
            return "Red"
        case .grey:
            return "Gray"
        case .bald:
            return "Bald"
        }
    }
    case blond, brown, black, red, grey, bald
}

Update: Having played with this more I've found that the following extension can be much more helpful

extension CaseIterable where Self.AllCases: RandomAccessCollection, Self: Hashable & CustomStringConvertible {
    static func toForEach() -> some View  {
        ForEach(Self.allCases, id: \.self) { o in
            Text(o.description).tag(o)
        }
    }
}

because gives wider reuse possibility, like

List { HairColor.toForEach() }

and this

Form { HairColor.toForEach() }

and

struct DemoHairColorPicker: View {
    @State private var hairColor: HairColor = .red
    var body: some View {
        VStack {
            Text("Selected: \(hairColor.description)")
            Picker(selection: $hairColor, label: Text("Hair")) { HairColor.toForEach() }
        }
    }
}

and of course in any stack VStack { HairColor.toForEach() }

Answer 2

Not really an answer to all parts of your question - only the first part - but offered here as an alternative...

Might be worth considering the use of @EnvironmentObject for a @Published property? I used this to populate a sidebar style menu for a macOS target.

Step 1:

Use your enum. My enum is written a little differently to yours but I thought to leave it that way because it provides an alternate construction... but with the same outcome.

(Conforming to CaseIterable here allows us to use the .allCases method in Step 2.)

enum HairColor: Int, CaseIterable {

    case blond = 0, brown, black, red, grey, none

    var description: String {

        switch self {

        case .blond: return "Blond"
        case .brown: return "Brown"
        case .black: return "Black"
        case .red:   return "Red"
        case .grey:  return "Grey"
        case .none:  return "Bald"
        }
    }
}

Step 2:

Create a struct for your model and include a static property that maps all cases of your HairColor enum.

(Conforming to Identifiable here allows us to use the cleaner ForEach syntax in Step 4 - that is - use ForEach(appData.hairColors) in lieu of ForEach(appData.hairColors, id: \.id)).

import SwiftUI

struct Hair: Codable, Hashable, Identifiable {

    var id: Int
    var name: String

    init(id: Int, name: String) {
        self.id = id
        self.name = name
    }

    static var colors: [Hair] {
        return HairColor.allCases.map({ Hair(id: $0.rawValue, name: $0.description ) })
    }
}

Step 3:

Create a class that conforms to ObservableObject and that contains a @Published wrapped property to allow you to broadcast your HairColor via @EnvironmentObject.

import Combine // <- don't forget this framework import!
import SwiftUI

final class AppData: ObservableObject {

    @Published var hairColors = Hair.colors
}

Step 4:

Use in a View.

struct HairList: View {

    @EnvironmentObject var appData: AppData

    @State var selectedHair: Hair?

    var body: some View {

        VStack(alignment: .leading) {

            Text("Select...")
                .font(.headline)

            List(selection: $selectedHair) {

                ForEach(appData.hairColors) { hairColor in

                    Text(hairColor.name).tag(hairColor)
                }
            }
            .listStyle(SidebarListStyle())
        }
        .frame(minWidth: 100, maxWidth: 150)
        .padding()
    }
}

Step 5:

Remember to inject the environment object into the preview to make the preview usable.

struct HairList_Previews: PreviewProvider {

    static var previews: some View {

        HairList(selectedHair: .constant(AppData().hairColors[1]))
            .environmentObject(AppData())
    }
}