Hızlı dahili uzantıları iç jeneriklerle yapabilir miyim?

Question

Ben RxSwift ve Diyar birlikte çalışmak yapmak istiyorum ve bana yardım etmek fonksiyonları inşa etmeye çalıştı. Örneğin, yerine (eğer Sonuçları sıralanmış vermek) Sonuçları nesneler üzerinde sıralanmış işlevini kullanarak, ben> gözlemlenebilir üzerinde bunu doğrudan yapmak bir işlev kurmak istiyorum. ObservableType protokolüne sayesinde, genel olmayan nesne üzerinde bunu yapmak başardı ama genel bir şekilde Burada

bunu yapmak için bir yol bulamıyorum sadece belirli Nesne üzerinde çalışır benim gerçek kod şöyledir:

public extension ObservableType where E == Results<MyRealmObject> { 

    public func sorted(key: String, ascending: Bool = true) -> Observable<Results<MyRealmObject>> 
    { 
     return self.map { $0.sorted(key, ascending: ascending) } 

    } 
} 

MyRealmObject öğesini T ile değiştirdiğimde, derleyiciler bana T'nin bildirilmediğini söyler. Birçok sözdizimi denedim ancak hiçbiri çalışmıyor ve mümkün olup olmadığını bilmiyorum.

Answer 1

ben bu çerçeveleri yok ama tipleri aşağıdaki benzer olan tahmin ediyorum: bu durumda deneyebilirsiniz

protocol ObservableType { 
    associatedtype E 
} 

class Observable<T> : ObservableType { 
    typealias E = T 
    init() {} 
} 

enum Results<T> { 
    case None 
    case Some(T) 
} 

...:

extension ObservableType { 

    func sorted <T where Self.E == Results<T>> (/* ... */) -> Observable<Results<T>> { 
     return /* sorted */ Observable() 
    } 
} 

. .. hangisinin:

let o = Observable<Results<Int>>() 
o.sorted() // Observable<Results<Int>> 

... ama optimum olmadığı için:

Eğer tercih ediyorum

let x = Observable<Int>() 
x.sorted() // compile-time error: Generic parameter `T` could not be infered 

10 ... Value of type 'Observable<Int>' has no member 'sorted' söylemek. Ve hata en azından derleme zamanında atılmış olsa da, kendi yaklaşımınızın hala tercih edilebilir olduğunu düşünüyorum. @Denis Laboureyras yorumlarına

benim çözüm çalışıyor iken

Denis self türünü sınırlamak değil extension çünkü döküm olmadan Results<T> olarak tip E değerini erişemedi ama dayalı

Sadece bir sonradan sadece yöntemin parametreleri. Tüm bu sorunlar serbest bir işlev durumunda (bu durumun benim için de ideal olmadığını düşünürsek) ortadan kalkar:

protocol ObservableType { 
    associatedtype E 
    func map <X> (_: E -> X) -> Observable<X> 
} 

class Observable<T> : ObservableType { 
    typealias E = T 
    init() {} 
    func map <X> (f: E -> X) -> Observable<X> { 
     return Observable<X>(/* with f(e) */) 
    } 
} 

class Results<T> { 
    func sort(/* ... */) -> Results<T> { 
     return /* sorted */ self 
    } 
} 

func sort <O: ObservableType, T where O.E == Results<T>> (o: O/* ... */) -> Observable<Results<T>> { 
    return o.map{ $0.sort() } 
} 

let o = Observable<Results<Int>>() 
sort(o) // Observable<Results<Int>>