swift protocol 'weak' cannot be applied to non-class type

swift protocol extension
swift protocol vs interface
swift protocol default implementation
swift protocol bank
swift protocol delegate
swift protocol inheritance
swift protocol: class
swift - protocol-oriented programming

I'm a bit confused. What's the difference between protocol A : class { ... } and protocol A{ ... }, and which one we should use in swift?

PS: we got an error when we wrote like this

protocol A{ ... }

weak var delegate: A

error : 'weak' cannot be applied to non-class type

protocol A : class { ... }

defines a "class-only protocol": Only class types (and not structures or enumerations) can adopt this protocol.

Weak references are only defined for reference types. Classes are reference types, structures and enumerations are value types. (Closures are reference types as well, but closures cannot adopt a protocol, so they are irrelevant in this context.)

Therefore, if the object conforming to the protocol needs to be stored in a weak property then the protocol must be a class-only protocol.

Here is another example which requires a class-only protocol:

protocol A { 
    var name : String { get set }
}

func foo(a : A) {
    a.name = "bar" // error: cannot assign to property: 'a' is a 'let' constant
}

This does not compile because for instances of structures and enumerations, a.name = "bar" is a mutation of a. If you define the protocol as

protocol A : class { 
    var name : String { get set }
}

then the compiler knows that a is an instance of a class type to that a is a reference to the object storage, and a.name = "bar" modifies the referenced object, but not a.

So generally, you would define a class-only protocol if you need the types adopting the protocol to be reference types and not value types.

Swift - Protocols, Swift - Protocols - Protocols provide a blueprint for Methods, properties and other Protocol is used to specify particular class type property or instance property. So, according to the creators of the Swift language, protocols are a good way to define a set of required functionality that other types can adopt. When I think of protocols, I like to think that protocols provide information about what a type can do, not necessarily what it is.

You can make the protocol derive from any class type like NSObject, or AnyObject. e.g :

protocol TopNewsTableDelegate  : AnyObject{
  func topNewsTableDidLoadedStories()
}

Swift Protocols: Tips and Tricks – Hacking with Swift, At their core, Swift's protocols are a way of letting us define functionality and optionally provide default implementations where needed. Protocol in Swift with Practical Examples. Agoi Abel. Jan 19, 2018 · 4 min read. A protocol defines a blueprint of methods, properties, and other requirements that suit a particular task or piece

Or you can type like this

@objc protocol A { ... }

then you can make a weak delegate reference

Protocol in Swift with Practical Examples | by Agoi Abel, A protocol defines a blueprint of methods, properties, and other requirements that suit a particular task or piece of functionality. The protocol can� A protocol defines a blueprint of methods, properties, and other requirements. The protocol can then be adopted by a class, structure, or enumeration to provide an actual implementation of those requirements. But there would be a time when you want to restrict protocols to be adopted by a specific class. In Swift 5, you can do just that. Syntax #

If you are using Swift 4 and later

protocol A : AnyObject { ... }

Protocols In Swift Explained (How To) – LearnAppMaking, What makes Swift's protocols so powerful? In this article you'll learn how to work with protocols and why they are useful for practical iOS� In this protocol-oriented programming tutorial, you’ll learn about extensions, default implementations and other techniques to add abstraction to your code.

protocol CustomProtocolName : NSObjectProtocol{ .... }

Protocol-oriented Programming in Swift, Protocols are used to define a “blueprint of methods, properties, and other requirements that suit a particular task or piece of functionality.” Swift checks for protocol� In Swift, protocols contain multiple abstract members. Classes, structs and enums can conform to multiple protocols and the conformance relationship can be established retroactively. All that enables some designs that aren't easily expressible in Swift using subclassing.

The different categories of Swift protocols, Swift's many protocols can, in general, be split up into four main categories. Let's go through them, and how keeping them in mind can help us� Although protocols are not by any means a new thing, Swift specifically encourages the developers to use it over inheritance. Not that Objective-C didn’t make use of protocols, but due to the dynamic nature of Objective-C Runtime one would be tempted to put chunks of common declarations in a superclass instead.

Protocols, What makes Swift a protocol-oriented language, and how can protocols be used to create abstractions and to enable code reuse? That's what� Swift supports the concept of protocol extensibility, an extensibility system that can be applied to types, structs and classes, which Apple promotes as a real change in programming paradigms they term "protocol-oriented programming" (similar to traits). Swift was introduced at Apple's 2014 Worldwide Developers Conference (WWDC).

Protocol-Oriented Programming Tutorial in Swift 5.1: Getting Started , The difference between object-oriented and protocol-oriented programming. Protocols with default implementations. Extending the Swift standard� SWIFT is a messaging network that financial institutions use to securely transmit information and instructions through a standardized system of codes. SWIFT assigns each financial organization a

Comments
  • In your code example you said 'a' is a 'let' constant. I'm a little confused. What makes a a constant here?
  • @Suragch: Function parameters – as the a in func foo(a : A) – are by default constants.
  • "Therefore, if your protocol defines a weak property" - Protocols don't define weak or strong properties (only get and get set); shouldn't it read: "Therefore, if the object that conforms to the protocol needs to be stored in a weak property..."?