Extending a Protocol Where Self: Generic Type in Swift (Requires Arguments in <...>)

Extending a Protocol where Self: Generic Type in Swift (Requires Arguments In ... )

The problem is Collection is a generic class so every where you declare it, you must attached the specialized type, like Collection<T>. However extension to a protocol can't be specified with a generic type so you end up not being able to supply T to Collection.

In your case though, T is constrained to be of type Model so why not use that in the default protocol implementation:

extension Resource where Self: Collection<Model> {
    func fetch() {
        // default implementation
    }
}

Swift 4 extension function on generic protocol which takes a generic function as parameter

You cannot use Source as a concrete return type for map because it is a protocol with an associated type requirement.

To solve this, you can have the map function return Mapping<X, Self>:

extension Source {
    func map<Result>(_ transform: @escaping (T) -> Result) -> Mapping<Result, Self> {
        return Mapping(self, transform)
    }
}

The function now has a Self requirement. The resulting Mapping type has a generic type parameter Self that is replaced by the concrete implementation of Source, e.g. Mapping or TextSource.

Cannot convert value of type 'T?' to expected argument type 'T?'

You need to use an associatedtype in your protocol so all functions/variables in the protocol uses the same type because otherwise each function with a <T> will be using a different type

Example (simplified

protocol PostDataProviderProtocol{
    associatedtype T

    func getItemAt(index:Int)-> T?
    func replaceItemAt(index:Int, item:T?)
}

Then in your class you can use it as

class BaseDataProvider<SomeType> {
    internal var _itemsPerPage:Int = 0
    internal var _page:Int = 0
    internal var _endpoint:String = ""
    internal var cachedData:[SomeType?] = []
}

extension BaseDataProvider: PostDataProviderProtocol {
    typealias T = SomeType

    func hasNext() -> Bool {
        true
    }

    func getItemAt(index: Int) -> T? {
        self.cachedData[index]
    }

    func getItems() -> [T] {
      return self.cachedData as! [T]
    }

 }

Swift - Protocol default implementation in extension with generic superclass constraint

This is because Printer<A> and Printer<B> are different types, even A & B are Printable, so due to possible ambiguity compiler generate error.

You need the following (tested with Xcode 11.4)

extension Press {
  func print<P>() where Self: Printer<P>, P: Printable {
    // Do Something with self.printable.value
  }
}

Result type Generic parameter 'T' could not be inferred swift 5

You'll have to tell the compiler about the type you're expecting.

network.fetchCodable(urlRequest: venuesURLRequest) { (_ result: Result<VenueDetailsSearchResult, Error>) in
    // ...
}

---

Related Topics