`weak` references don&#39;t seem to work in Swift unless a `protocol` is declared as `@objc`, which I don&#39;t want in a pure Swift app.

This code gives a compile error (`weak` cannot be applied to non-class type `MyClassDelegate`):

    class MyClass {
      weak var delegate: MyClassDelegate?
    }
    
    protocol MyClassDelegate {
    }

I need to prefix the protocol with `@objc`, then it works.

Question: What is the &#39;pure&#39; Swift way to accomplish a `weak` `delegate`?


How can I make a weak protocol reference in &#39;pure&#39; Swift (without @objc)

Is it possible in Swift? If not then is there a workaround to do it?

How to define optional methods in Swift protocol?

I have a protocol RequestType and it has associatedType Model as below.

    public protocol RequestType: class {
    
        associatedtype Model
        var path: String { get set }
           
    }

    public extension RequestType {
        
        public func executeRequest(completionHandler: Result&lt;Model, NSError&gt; -&gt; Void) {
            request.response(rootKeyPath: rootKeyPath) { [weak self] (response: Response&lt;Model, NSError&gt;) -&gt; Void in
                completionHandler(response.result)
                guard let weakSelf = self else { return }
                if weakSelf.logging { debugPrint(response) }
            }
        }
        
    }

Now I am trying to make a queue of all failed requests.

    public class RequestEventuallyQueue {
        
        static let requestEventuallyQueue = RequestEventuallyQueue()
        let queue = [RequestType]()
        
    }

But I get the error on line `let queue = [RequestType]()` that Protocol RequestType can only be used as a generic constraint because it has Self or associatedType requirements.


Protocol can only be used as a generic constraint because it has Self or associatedType requirements

I want to create a class that can store objects conforming to a certain protocol.  The objects should be stored in a typed array. According to the Swift documentation protocols can be used as types:&amp;nbsp;

&gt; Because it is a type, you can use a protocol in many places where other types are allowed, including:
&gt;
&gt; - As a parameter type or return type in a function, method, or initializer
&gt; - As the type of a constant, variable, or property
&gt; - As the type of items in an array, dictionary, or other container

However the following generates compiler errors: 
&gt; Protocol &#39;SomeProtocol&#39; can only be used as a generic constraint because it has Self or associated type requirements

How are you supposed to solve this:

    protocol SomeProtocol: Equatable {
        func bla()
    }
    
    class SomeClass {
        
        var protocols = [SomeProtocol]()
        
        func addElement(element: SomeProtocol) {
            self.protocols.append(element)
        }
        
        func removeElement(element: SomeProtocol) {
            if let index = find(self.protocols, element) {
                self.protocols.removeAtIndex(index)
            }
        }
    }

Usage of protocols as array types and function parameters in swift

Why doesn&#39;t this Swift code compile?

    protocol P { }
    struct S: P { }
    
    let arr:[P] = [ S() ]
    
    extension Array where Element : P {
        func test&lt;T&gt;() -&gt; [T] {
            return []
        }
    }
    
    let result : [S] = arr.test()

The compiler says: &quot;Type `P` does not conform to protocol `P`&quot; (or, in later versions of Swift, &quot;Using &#39;P&#39; as a concrete type conforming to protocol &#39;P&#39; is not supported.&quot;).

Why not? This feels like a hole in the language, somehow. I realize that the problem stems from declaring the array `arr` as an array _of a protocol type_, but is that an unreasonable thing to do? I thought protocols were there exactly to help supply structs with something like a type hierarchy?


Protocol doesn&#39;t conform to itself?

I am trying to create a Dictionary (actually a [HashSet][2]) keyed on a custom protocol in Swift, but it is giving me the error in the title:

 &gt; Protocol &#39;myProtocol&#39; can only be used as a generic constraint because it has Self or associated type requirements

and I can&#39;t make heads nor tails of it.

    protocol Observing: Hashable { }

    var observers = HashSet&lt;Observing&gt;()


  [2]: https://gist.github.com/devios1/d8914833912c1aae15e2

What does &quot;Protocol ... can only be used as a generic constraint because it has Self or associated type requirements&quot; mean?

#Overview:
- I have a protocol P1 which provides a default implementation of one of the Objective-C optional functions.
- When I provide a default implementation of the optional function there is a warning

#Compiler Warning:

    Non-&#39;@objc&#39; method &#39;presentationController(_:viewControllerForAdaptivePresentationStyle:)&#39; does not satisfy optional requirement of &#39;@objc&#39; protocol &#39;UIAdaptivePresentationControllerDelegate&#39;

#Version:
- Swift: 3
- Xcode: 8 (public release)

#Attempts made:
- Tried adding `@objc` but doesn&#39;t help

#Question:
- How do I resolved this ?
- Is there a work around ?



#Code:


    @objc protocol P1 : UIAdaptivePresentationControllerDelegate {
        
    }
    
    extension P1 where Self : UIViewController {
        
        func presentationController(_ controller: UIPresentationController, viewControllerForAdaptivePresentationStyle style: UIModalPresentationStyle) -&gt; UIViewController? {
            return UIViewController()
        }
    }
    
    
    class A : UIViewController, P1 {
        
    }


Non-&#39;@objc&#39; method does not satisfy optional requirement of &#39;@objc&#39; protocol

Is there a standard way to make a &quot;pure virtual function&quot; in Swift, ie. one that **must** be overridden by every subclass, and which, if it is not, causes a compile time error?

Swift - class method which must be overridden by subclass

In Swift I can explicitly set the type of a variable by declaring it as follows:

    var object: TYPE_NAME

If we want to take it a step further and declare a variable that conforms to multiple protocols we can use the `protocol` declarative:

    var object: protocol&lt;ProtocolOne,ProtocolTwo&gt;//etc

What if I would like to declare an object that conforms to one or more protocols and is also of a specific base class type? The Objective-C equivalent would look like this:

    NSSomething&lt;ABCProtocolOne,ABCProtocolTwo&gt; * object = ...;

In Swift I would expect it to look like this:

    var object: TYPE_NAME,ProtocolOne//etc

This gives us the flexibility of being able to deal with the implementation of the base type as well as the added interface defined in the protocol.

Is there another more obvious way that I might be missing?

## Example

As an example, say I have a `UITableViewCell` factory that is responsible for returning cells conforming to a protocol. We can easily setup a generic function that returns cells conforming to a protocol:

    class CellFactory {
        class func createCellForItem&lt;T: UITableViewCell where T:MyProtocol &gt;(item: SpecialItem,tableView: UITableView) -&gt; T {
            //etc
        }
    }

later on I want to dequeue these cells whilst leveraging both the type and the protocol

    var cell: MyProtocol = CellFactory.createCellForItem(somethingAtIndexPath) as UITableViewCell

This returns an error because a table view cell does not conform to the protocol...

I would like to be able to specify that cell is a `UITableViewCell` and conforms to the `MyProtocol` in the variable declaration?

## Justification
If you are familiar with the [Factory Pattern][1] this would make sense in the context of being able to return objects of a particular class that implement a certain interface.

Just like in my example, sometimes we like to define interfaces that make sense when applied to a particular object. My example of the table view cell is one such justification.

Whilst the supplied type does not exactly conform to the mentioned interface, the object the factory returns does and so I would like the flexibility in interacting with both the base class type and the declared protocol interface


  [1]: http://en.wikipedia.org/wiki/Factory_method_pattern

In Swift, how can I declare a variable of a specific type that conforms to one or more protocols?

Swift documentation says that *classes*, *structs*, and *enums* can all conform to protocols, and I can get to a point where they all conform. But I can&#39;t get the *enum* to behave quite like the *class* and *struct* examples:

    protocol ExampleProtocol {
        var simpleDescription: String { get set }
        mutating func adjust()
    }
    
    class SimpleClass: ExampleProtocol {
        var simpleDescription: String = &quot;A very simple class.&quot;
        var anotherProperty: Int = 69105
        
        func adjust() {
            simpleDescription += &quot; Now 100% adjusted.&quot;
        }
    }
    
    var a = SimpleClass()
    a.adjust()
    let aDescription = a.simpleDescription
    
    struct SimpleStructure: ExampleProtocol {
        var simpleDescription: String = &quot;A simple structure&quot;
        
        mutating func adjust() {
            simpleDescription += &quot; (adjusted)&quot;
        }
    }

    var b = SimpleStructure()
    b.adjust()
    let bDescription = b.simpleDescription
    
    enum SimpleEnum: ExampleProtocol {
        case Base
        
        var simpleDescription: String {
            get {
                return &quot;A Simple Enum&quot;
            }
            set {
                newValue
            }
        }
        
        mutating func adjust() {
            self.simpleDescription += &quot;, adjusted&quot;
        }
    }

    var c = SimpleEnum.Base
    c.adjust()
    let cDescription = c.simpleDescription

I haven&#39;t figured out how to get the `simpleDescription` to change as a result of calling `adjust()`.  My example obviously won&#39;t do that because the *getter* has a value hard-coded, but how can I set a value for the `simpleDescription` while still conforming to the `ExampleProtocol`?

How to make an enum conform to a protocol in Swift?

I have declared a Swift protocol:

    protocol Option {
        var name: String { get }
    }

I declare multiple implementations of this protocol—some classes, some enums.

I have a view controller with a property declared as so:

    var options: [Option] = []

When I try and set this property to an array of objects that implement the `Option` protocol in another VC&#39;s `prepareForSegue`, I get a runtime error:

    fatal error: array cannot be bridged from Objective-C

Why doesn&#39;t this work? The compiler has all the information it needs, and I don&#39;t understand what Objective-C has to do with it at all—my project contains only Swift files, and these arrays aren&#39;t coming in or out of any framework methods that would necessitate them being bridged to `NSArray`.

&quot;fatal error: array cannot be bridged from Objective-C&quot;—Why are you even trying, Swift?

I have a protocol P that returns a copy of the object:

    protocol P {
        func copy() -&gt; Self
    }

and a class C that implements P:

    class C : P {
        func copy() -&gt; Self {
            return C()
        }
    }

However, whether I put the return value as `Self` I get the following error: 

&gt; Cannot convert return expression of type &#39;C&#39; to return type &#39;Self&#39;

I also tried returning `C`.  


    class C : P {
        func copy() -&gt; C  {
            return C()
        }
    }

That resulted in the following error: 
&gt; Method &#39;copy()&#39; in non-final class &#39;C&#39; must return `Self` to conform
&gt; to protocol &#39;P&#39;

Nothing works except for the case where I prefix `class C` with `final` ie do: 

    final class C : P {
        func copy() -&gt; C  {
            return C()
        }
    }


However if I want to subclass C then nothing would work. Is there any way around this?

Protocol func returning Self

I have a doubt about protocols in Swift about the use of **var** and the **keywords { get set }**.

From [Apple documentation][1]:

&gt; If a protocol requires a property to be gettable and settable, that
&gt; property requirement cannot be fulfilled by a constant stored property
&gt; or a read-only computed property. If the protocol only requires a
&gt; property to be gettable, the requirement can be satisfied by any kind
&gt; of property, and it is valid for the property to be also settable if
&gt; this is useful for your own code.
&gt; 
&gt; Property requirements are always declared as variable properties,
&gt; prefixed with the var keyword. Gettable and settable properties are
&gt; indicated by writing { get set } after their type declaration, and
&gt; gettable properties are indicated by writing { get }.

I can&#39;t understand why I can&#39;t use **let**. A **var** in a protocol with only **get** isn&#39;t just a **let**?

Something like this:

    protocol someProtocol 
    {
       var someProperty: String { get }
    }

it would not be just:

    protocol someProtocol 
    {
       let someProperty: String
    }

I&#39;m missing something?

  [1]: https://developer.apple.com/library/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Protocols.html

Why I can&#39;t use let in protocol in Swift?

When I try to implement my protocol this way:

    protocol Serialization {
        func init(key keyValue: String, jsonValue: String)
    }

I get an error saying: **Expected identifier in function declaration.** 

Why am I getting this error?

Can I have an init func in a protocol?

I&#39;ve been playing around with arrays of generic classes with different types. It&#39;s easiest to explain my problem with some sample code:

    // Obviously a very pointless protocol...
    protocol MyProtocol {
        var value: Self { get }
    }
    
    extension Int   : MyProtocol {  var value: Int    { return self } }
    extension Double: MyProtocol {  var value: Double { return self } }
    
    class Container&lt;T: MyProtocol&gt; {
        var values: [T]
        
        init(_ values: T...) {
            self.values = values
        }
   
        func myMethod() -&gt; [T] {
            return values
        }
    }
   

Now if I try to create an array of containers like so:

    var containers: [Container&lt;MyProtocol&gt;] = []

I get the error:

&gt; Protocol &#39;MyProtocol&#39; can only be used as a generic constraint because it has Self or associated type requirements.

To fix this I can use `[AnyObject]`:

    let containers: [AnyObject] = [Container&lt;Int&gt;(1, 2, 3), Container&lt;Double&gt;(1.0, 2.0, 3.0)]
    // Explicitly stating the types just for clarity.

But now another &#39;problem&#39; emerges when enumerating through `containers`:

    for container in containers {
        if let c = container as? Container&lt;Int&gt; {
            println(c.myMethod())
        
        } else if let c = container as? Container&lt;Double&gt; {
            println(c.myMethod())
        }
    }

As you can see in the code above, after determining the type of `container` the same method is called in both cases. My question is: 

**Is there a better way to get the `Container` with the correct type than casting to every possible type of `Container`? Or is there something else I&#39;ve overlooked?**

All Swift Protocols Solutions on Gang of Coders

Total of 15 Swift Protocols Solutions

How can I make a weak protocol reference in 'pure' Swift (without @objc)

How to define optional methods in Swift protocol?

Protocol can only be used as a generic constraint because it has Self or associatedType requirements

Usage of protocols as array types and function parameters in swift

Protocol doesn't conform to itself?

What does "Protocol ... can only be used as a generic constraint because it has Self or associated type requirements" mean?

Non-'@objc' method does not satisfy optional requirement of '@objc' protocol

Swift - class method which must be overridden by subclass

In Swift, how can I declare a variable of a specific type that conforms to one or more protocols?

How to make an enum conform to a protocol in Swift?

"fatal error: array cannot be bridged from Objective-C"—Why are you even trying, Swift?

Protocol func returning Self

Why I can't use let in protocol in Swift?

Can I have an init func in a protocol?

Arrays of Generics in Swift