Menu
Given this code:
public protocol Selectable {
typealias T
var selected: Bool { get }
static var defaultValue: T { get }
}
public func selected<T: Selectable>(items: [T]) -> T {
if let selected = items.filter({$0.selected}).first {
return selected
}
return T.defaultValue
}
I get an error on the return line: "Cannot convert return expression of type 'T.T' to expected return type 'T'".
Changing it to return T.defaultValue as! T seems to work but that doesn't make any sense to me. Am I missing something or should I file a radar?
344
Swift lets you create properties and methods that belong to a type, rather than to instances of a type. This is helpful for organizing your data meaningfully by storing shared data. Swift calls these shared properties “static properties”, and you create one just by using the static keyword.
Protocols provide a blueprint for Methods, properties and other requirements functionality. It is just described as a methods or properties skeleton instead of implementation. Methods and properties implementation can further be done by defining classes, functions and enumerations.
In Swift, we use the static keyword to create a static method. For example, class Calculator { // static method static func add() { ... } } Here, add() is the static method.
The Static keyword makes it easier to utilize an objects properties or methods without the need of managing instances. Use of the Static keyword in the Singleton pattern can reduce memory leaks by mismanaging instances of classes.
In C and Objective-C, you define static constants and variables associated with a type as global static variables. In Swift, however, type properties are written as part of the type’s definition, within the type’s outer curly braces, and each type property is explicitly scoped to the type it supports.
A Swift property does not have a corresponding instance variable, and the backing store for a property is not accessed directly. This approach avoids confusion about how the value is accessed in different contexts and simplifies the property’s declaration into a single, definitive statement.
Always prefix type property requirements with the static keyword when you define them in a protocol. This rule pertains even though type property requirements can be prefixed with the class or static keyword when implemented by a class: Here’s an example of a protocol with a single instance property requirement:
In Swift, you can choose whether to define a class, structure, or enumeration, and still have the flexibility to define methods on the type you create. Instance methods are functions that belong to instances of a particular class, structure, or enumeration.
You can use Self in the protocol:
public protocol Selectable {
var selected: Bool { get }
static var defaultValue: Self { get }
// ^^^^
}
public func selected<T: Selectable>(items: [T]) -> T {
if let selected = items.filter({$0.selected}).first {
return selected
}
return T.defaultValue
}
OR, if you want to use typealias, you have to:
public protocol Selectable {
typealias Value
var selected: Bool { get }
static var defaultValue: Value { get }
}
public func selected<T: Selectable where T.Value == T>(items: [T]) -> T {
// ^^^^^^^^^^^^^^^^^^
if let selected = items.filter({$0.selected}).first {
return selected
}
return T.defaultValue
}
Building on @rintaro's answer, using Self for the type of defaultValue means the typealias is unnecessary:
public protocol Selectable {
var selected: Bool { get }
static var defaultValue: Self { get }
}
public func selected<T: Selectable >(items: [T]) -> T {
if let selected = items.filter({$0.selected}).first {
return selected
}
return T.defaultValue
}
(I found this as changing defaultValue's type to Self made my implementing class not conform to the protocol anymore—and I noticed I wasn't even referring to the typealias Value; removing that made my implementing class comply again.)
34
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With