Access a raw value for pure enum without using associated type

Where exactly do you get the error message ?

@Claude31 good question... I can't update my original post so I'll add some more information below.

In response to comment by @Claude31, the location of the (second) error message... let test = Taxon(rawValue: nameType) where I am attempting to obtain a reference to one of the values in the enum Taxon. For clarity, this replaces the commented out code - the above noted switch statement in the iteration over setSorted. So eventually with an accessible initialiser, I might develop that line of code to replace the switch statement entirely and it might look something like this... let test = Taxon(rawValue: nameType).formatted(nameComp) although I am not sure that syntax is correct. Also for clarity, the first error message "Enum with raw type cannot have cases with arguments" is against the line that declares the enum Taxon: String {...} (when I attempt to associate a type with the enum).

I do not have the problem. So may be I miss something in your question.

I tested the following (Xcode 13, Playground):

enum Taxon {
    case common(name: String)
    case genus(name: String)
    case species(name: String)
    case subspecies(name: String)
    case group(name: String)
    case cultivar(name: String)
    case variety(name: String)
    case extended(name: String)

    var typeName: String {
        switch self {
        case .common:       return "Common"
        case .genus:        return "Genus"
        case .species:      return "Species"
        case .subspecies:   return "Subspecies"
        case .group:        return "Group"
        case .cultivar:     return "Cultivar"
        case .variety:      return "Variety"
        case .extended:     return "Taxonomny"
        }
    }

    var formatted: String {
        switch self {
        case .common(let name):       return name.capitalized
        case .genus(let name):        return name.capitalized
        case .species(let name):      return name.lowercased()
        case .subspecies(let name):   return String(format: "ssp. %@", name)
        case .group(let name):        return String(format: "(%@ Group)", name)
        case .cultivar(let name):     return String(format: "cv. %@", name)
        case .variety(let name):      return String(format: "var. %@", name)
        case .extended(let name):     return name.capitalized
        }
    }
}
let taxon : Taxon = .common(name: "hello")  // not capitalized
print("taxon", taxon.formatted)

switch taxon {
case .common(let name): print("switch name", name, "formatted", taxon.formatted)
default: break
}

// or equivalent 
if case let .common(name) = taxon {
print("case let", name)
}

I get the expected results:

• taxon Hello
• switch name hello Hello
• case let hello

to provide some additional context to my original post...

Here is another enum for which I can access a raw value for an enum, but it is not pure - it has an associated type NSNumber.

The significant difference to this enum is that is has an associated type NSNumber and so I can set a typealias RawValue = NSNumber.

enum EntityDateFormat: NSNumber, CaseIterable, Identifiable {
    typealias RawValue = NSNumber
    var id: NSNumber? { self.rawValue }

    case dateTime = 0
    case dateOnly
    case monthYear
    case yearOnly

    var template: String {
        switch self {
        case .dateTime:     return Date.templateDDMYHM 
        // e.g. under extension to Date, static let templateDDMYHM: String! = "EEE dd MMM yyyy hh mm"
        case .dateOnly:     return Date.templateDDMY
        case .monthYear:    return Date.templateMY
        case .yearOnly:     return Date.templateY
        }
    }

    var calendarComponent: Calendar.Component {
        switch self {
        case .dateTime:     return .minute
        case .dateOnly:     return .day
        case .monthYear:    return .month
        case .yearOnly:     return .year
        }
    }

    var title: String {
        switch self {
        case .dateTime:     return "Date & Time"
        case .dateOnly:     return "Date Only"
        case .monthYear:    return "Month & Year"
        case .yearOnly:     return "Year Only"
        }
    }

    var prefix: String {
        switch self {
        case .dateTime:     return "At"
        case .dateOnly:     return "On"
        case .monthYear:    return "In"
        case .yearOnly:     return "In"
        }
    }
}

Then I use a function to obtain a formatted string, but I use a parameter format of type NSNumber to reference against the enum and obtain a raw value.

struct EntityDate {
    private let messageError: String = "Error formatting EntityDate"
    func from(_ date: Date, withFormat format: NSNumber) -> String {
        guard
            let calendarComponent = EntityDateFormat(rawValue: format)?.calendarComponent,
            let template = EntityDateFormat(rawValue: format)?.template,
            let prefix = EntityDateFormat(rawValue: format)?.prefix
            else {
                return messageError
        }
        let dateRounded = date.roundDown(to: calendarComponent)
        let dateFormatted = dateRounded.formatAsStringUsing(template: template, forLocale: Locale.current)
        return String("\(prefix) \(dateFormatted)")
    }

Where .roundDown(to:) and formatAsStringUsing(template:, forLocale:) are custom functions under an extension to Date.

So as you can see in this last func, rather than having to run the value for the parameter format through a switch statement to obtain the relevant enum value, (using EntityDateFormat(rawValue: format)?) I have three single lines in a guard statement to determine each value I require for my custom Date functions.

If I understand your question, why don't explore all the cases of the switch, as you did for

var formatted: String

to get the case ?

I did not try to do it inside the enum.

But you could write a wrapper func:

PropertyType would be a list of "calendarComponent", "template", "prefix"

func getEntityItem(rawValue: NSNumber, itemType: PropertyType) {
  // Have the switch here and return the requested property
}

Note: take care, prefix is a reserved word.