En Swift, ¿es posible convertir una cadena en una enumeración?

Si tengo una enumeración con los casos a, b, c, d, ¿puedo convertir la cadena "a" como enumeración?

Por supuesto. Las enumeraciones pueden tener un valor bruto. Para citar los documentos:

Los valores brutos pueden ser cadenas, caracteres o cualquiera de los tipos de números enteros o de punto flotante

- Extracto de: Apple Inc. "El lenguaje de programación Swift". iBooks. https://itun.es/us/jEUH0.l ,

Entonces puedes usar un código como este:

enum StringEnum: String 
{
  case one = "one"
  case two = "two"
  case three = "three"
}

let anEnum = StringEnum(rawValue: "one")!

print("anEnum = \"\(anEnum.rawValue)\"")

Nota: No es necesario escribir = "uno", etc. después de cada caso. Los valores de cadena predeterminados son los mismos que los nombres de los casos, por lo que la llamada .rawValuesolo devolverá una cadena

EDITAR

Si necesita que el valor de la cadena contenga elementos como espacios que no son válidos como parte de un valor de caso, entonces debe establecer explícitamente la cadena. Entonces,

enum StringEnum: String 
{
  case one
  case two
  case three
}

let anEnum = StringEnum.one
print("anEnum = \"\(anEnum)\"")

da

anEnum = "uno"

Pero si desea case onemostrar el "valor uno", deberá proporcionar los valores de cadena:

enum StringEnum: String 
{
  case one   = "value one"
  case two   = "value two"
  case three = "value three"
}

Todo lo que necesitas es:

enum Foo: String {
   case a, b, c, d
}

let a = Foo(rawValue: "a")
assert(a == Foo.a)

let 💩 = Foo(rawValue: "💩")
assert(💩 == nil)

En Swift 4.2, el protocolo CaseIterable se puede usar para una enumeración con rawValues, pero la cadena debe coincidir con las etiquetas de caso de enumeración:

enum MyCode : String, CaseIterable {

    case one   = "uno"
    case two   = "dos"
    case three = "tres"

    static func withLabel(_ label: String) -> MyCode? {
        return self.allCases.first{ "\($0)" == label }
    }
}

uso:

print(MyCode.withLabel("one")) // Optional(MyCode.one)
print(MyCode(rawValue: "uno"))  // Optional(MyCode.one)

En caso de que tenga una enumeración con tipo Int, puede hacerlo así:

enum MenuItem: Int {
    case One = 0, Two, Three, Four, Five //... as much as needs

    static func enumFromString(string:String) -> MenuItem? {
        var i = 0
        while let item = MenuItem(rawValue: i) {
            if String(item) == string { return item }
            i += 1
        }
        return nil
    }
}

Y use:

let string = "Two"
if let item = MenuItem.enumFromString(string) {
    //in this case item = 1 
    //your code
} 

Ampliando la respuesta de Duncan C

extension StringEnum: StringLiteralConvertible {

    init(stringLiteral value: String){
        self.init(rawValue: value)!
    }

    init(extendedGraphemeClusterLiteral value: String) {
        self.init(stringLiteral: value)
    }

    init(unicodeScalarLiteral value: String) {
        self.init(stringLiteral: value)
    }
}

Rápido 4.2:

public enum PaymentPlatform: String, CaseIterable {
    case visa = "Visa card"
    case masterCard = "Master card"
    case cod = "Cod"

    var nameEnum: String {
        return Mirror(reflecting: self).children.first?.label ?? String(describing: self)
    }

    func byName(name: String) -> PaymentPlatform {
        return PaymentPlatform.allCases.first(where: {$0.nameEnum.elementsEqual(name)}) ?? .cod
    }
}

Para Int enum y su representación de cadena, declaro enum de la siguiente manera:

enum OrderState: Int16, CustomStringConvertible {

    case waiting = 1
    case inKitchen = 2
    case ready = 3

    var description: String {
        switch self {
        case .waiting:
            return "Waiting"
        case .inKitchen:
            return "InKitchen"
        case .ready:
            return "Ready"
        }
    }

    static func initialize(stringValue: String)-> OrderState? {
        switch stringValue {
        case OrderState.waiting.description:
            return OrderState.waiting
        case OrderState.inKitchen.description:
            return OrderState.inKitchen
        case OrderState.ready.description:
            return OrderState.ready

        default:
            return nil
        }
    }
}

Uso:

order.orderState = OrderState.waiting.rawValue

let orderState = OrderState.init(rawValue: order.orderState)
let orderStateStr = orderState?.description ?? ""
print("orderStateStr = \(orderStateStr)")