Menu
I'm attempting to create a simple generic node class that conforms to the Comparable protocol so that I can easily compare nodes without accessing their key. When I attempt to write the < and == functions, however, the compiler doesn't seem to like it. The < and == functions expect a type when defining the Node parameters. This was simple in Java where you defined equality and < internally to the class. Swift asks for it globally. Any thoughts ?
Example:
func < (lhs:Node<E:Comparable>, rhs:Node<E:Comparable>) -> Bool {
return lhs.key < rhs.key
}
func == (lhs:Node<E:Comparable>, rhs:Node<E:Comparable>) -> Bool {
return lhs.key == rhs.key
}
class Node<D:Comparable>: Comparable {
var key: D!
var next:Node?
var prev:Node?
init( key:D ) {
self.key = key
}
}
282
The Swift standard library defines a protocol called Equatable , which requires any conforming type to implement the equal to operator ( == ) and the not equal to operator ( != ) to compare any two values of that type. All of Swift's standard types automatically support the Equatable protocol.
To add Comparable conformance to Date , first declare conformance to Comparable and implement the < operator function. This function uses the least specific nonmatching property of the date to determine the result of the comparison.
Comparable interface is a generic type. A String can be compared to other String. But not with objects of a different class. extends, when applied to type parameters, actually means “extends or implements.”
You're close! The Node class already specifies that for Node<D>, D must conform to Comparable. Therefore, Node<E: Comparable> in the decl for == and < is redundant. Instead, you want to restrict the types that the operators can be invoked upon:
func < <E: Comparable>(lhs: Node<E>, rhs: Node<E>) -> Bool {
return lhs.key < rhs.key
}
func == <E: Comparable>(lhs: Node<E>, rhs: Node<E>) -> Bool {
return lhs.key == rhs.key
}
class Node<D: Comparable>: Comparable {
var key: D!
var next: Node?
var prev: Node?
init(key: D) {
self.key = key
}
}
You were very close. Small syntax issue Try this:
class Node<D:Comparable>: Comparable {
var key: D!
var next:Node?
var prev:Node?
init( key:D ) {
self.key = key
}
}
func < <E:Comparable> (lhs:Node<E>, rhs:Node<E>) -> Bool {
return lhs.key < rhs.key
}
func == <E:Comparable> (lhs:Node<E>, rhs:Node<E>) -> Bool {
return lhs.key == rhs.key
}
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
