cast [ANYOBJECT] zu gattungsgemäßen Art, der nicht eine Sammlung Typ sein können oder auch

Question

Ich habe eine Reihe von AnyObject, und ich möchte es gegossen (oder einem seiner Objekte) auf einen generischen Typ T die gegebenen darf kein Array sein.

Mein erster Versuch:

class MyClass<T> { 

    func someMethod() -> T? { 

     let anyObjectArray: [AnyObject] = // ... array obtained from Objective-C framework 

     if let objectsAsCollection = anyObjectArray as? T { // Cast always fails 
      return objectsAsCollection 
     } else if let firstObject = anyObjectArray.first as? T { 
      return firstObject 
     } else { 
      return nil 
     } 
    } 
} 

Der erste if let Guss schlägt fehl, wenn T ist ein Array (z T.self == Array<SomeObject>.self).

Ich würde so etwas wie dies versuchen, aber es geht irgendwie eine andere generische Parameter einzuführen, so nicht gültig ist, wie geschrieben:

extension MyClass where T == Array<U> { 

    fun someMethod() -> T? { 

     let anyObjectArray: [AnyObject] = // ... array obtained from Objective-C framework 

     if let objectsAsCollection = anyObjectArray.flatMap({ $0 as? U }) { 
      return objectsAsCollection 
     } else if let firstObject = anyObjectArray.first as? T { 
      return firstObject 
     } else { 
      return nil 
     } 
    } 
} 

---

Der Grund für den Wunsch, dies zu tun, ist, dass ich verwende ein Objective-C-Framework (RestKit), um Ergebnisse von einer REST-API zu erhalten. Ich baue eine Schicht auf der Oberseite in Swift, die diese Ergebnisse zurück, als eine bestimmte Art leitet die Anfrage nach, die gemacht wurde, so habe ich eine Result Typ, der etwa wie folgt aussieht:

enum Result<T>: { 
    case Success(T) 
    case Failure(Error) 
} 

Manchmal T ist ein Single Objekt, manchmal ist es ein Array von Objekten, aber das Objective-C-Framework gibt Ergebnisse immer als Array zurück.

Answer 1

Die folgende Syntax wird funktionieren:

class MyClass<T> { 
    func someMethod() -> T? { 
     // let's not convert to [AnyObject] here, keep it as NSArray 
     let anyObjectArray: NSArray = ... 

     // For some reason conversion from [AnyObject] to [T] fails... 
     // However, conversion from NSArray is special 
     if let objectsAsCollection = anyObjectArray as? T { 
      return objectsAsCollection 
     } else if let firstObject = (anyObjectArray as [AnyObject]).first as? T { 
      return firstObject 
     } else { 
      return nil 
     } 
    } 
} 

Es ist aber für einen wahrscheinlichen Fehler nur eine Abhilfe. Wir können das Problem auf die folgende einkochen:

class GenericClass<T> { 
    func someMethod() { 
     let anyObjectArray: [AnyObject] = ["test1", "test2", "test3"] 

     print(T) //Array<String> 
     print(T.self == Array<String>.self) //true 

     print(anyObjectArray is [String]) //true 
     print(anyObjectArray is T) //false - BUG 
    } 
} 

let instance = GenericClass<[String]>() 
instance.someMethod() 

(berichtet: SR-1054)

, die mir wie ein klarer Fehler aussieht. Es sieht tatsächlich wie eine andere Instanz des Fehlers aus, der in Type of optionals cannot be inferred correctly in swift 2.2