function with optionals, generics and comparable does satisfy compiler requirements - swift

Question

Im reading up on some algorithms and im working on a binary search tree. I have made the following
class TreeNode<T: Comparable>{
var value: T
var parent: TreeNode?
var leftChild: TreeNode?
var rightChild: TreeNode?
init(value: T) {
self.value = value
}
// ... more stuff ...
Which works fine. I have search, insert and print up and running, however when im trying to implement isSame, to se if two trees are the same, the compiler wont accept any of my function declarations:
First i try:
func isSame(leftNode: TreeNode?, rightNode: TreeNode?) -> Bool {
Compiler tells me "Reference to generic type 'TreeNode' requires arguments"
and suggests adding , which i then do, but now the compiler wants me to insert a ',' after the last parameter
func isSame(leftNode: TreeNode?, rightNode: TreeNode<T: Comparable>?) -> Bool {
if I do, it suggest i add another :D
resulting in something like
func isSame(leftNode: TreeNode?, rightNode: TreeNode<T: Comparable>?,,,) -> Bool {
Compiler, I have obeyed your every command. What more do you want from me?
I can get around this by stripping the function of the generic part like this:
func isSame(leftNode: TreeNode<Int>?, rightNode: TreeNode<Int>?) -> Bool {
But im curious to what I have to do to make the function work with generic types?
TLDR: How do I make an isSame function accept these two generic arguments?
Full code:
import UIKit
class TreeNode<T: Comparable>{
var value: T
var parent: TreeNode?
var leftChild: TreeNode?
var rightChild: TreeNode?
init(value: T) {
self.value = value
}
convenience init(array: [T]){
precondition(array.count > 0) // test denne
self.init(value: array.first!)
for item in array.dropFirst(){
self.insert(item)
}
}
func insert(_ newValue: T){
if newValue < self.value {
if leftChild == nil {
leftChild = TreeNode(value: newValue)
leftChild?.parent = self
} else {
leftChild!.insert(newValue)
}
}
else {
if rightChild == nil {
rightChild = TreeNode(value: newValue)
rightChild?.parent = self
} else {
rightChild!.insert(newValue)
}
}
}
func search(_ targetValue: T) -> Bool{
if targetValue < self.value{
if let leftChild = leftChild{
return leftChild.search(targetValue)
}
}
if targetValue > self.value{
if let rightChild = rightChild{
return rightChild.search(targetValue)
}
}
if targetValue == value{
print("found \(targetValue)")
return true
}
print("did not find \(targetValue)")
return false
}
}
// MARK: - Extensions
extension TreeNode: CustomStringConvertible{
var description: String {
var s = ""
if let left = self.leftChild {
s += "(\(left.description)) <-"
}
s += " \(value) "
if let right = self.rightChild {
s += "-> (\(right.description))"
}
return s
}
}
// isSame
func isSame(leftNode: TreeNode<Int>?, rightNode: TreeNode<Int>?) -> Bool {
if ((leftNode != nil && rightNode == nil) || (rightNode == nil && leftNode != nil)){
print("xor check returned false")
return false
}
if leftNode?.value != rightNode?.value {
return false
}
if isSame(leftNode: leftNode?.leftChild, rightNode: rightNode?.leftChild){
return isSame(leftNode: leftNode?.rightChild, rightNode: rightNode?.rightChild)
} else {
return false
}
}
// MARK: - Testing
var smallTree: TreeNode<Int> = TreeNode(value: 13)
var rootNodeFromArray = TreeNode(array: [7, 2, 5, 10, 9, 1])
// isSame test
let treeA: TreeNode<Int> = TreeNode(array: [7, 2, 5, 10, 9, 1])
let treeB: TreeNode<Int> = TreeNode(array: [7, 2, 5, 10, 9, 1])

Answer 1

If the function is a global function, you can make it a generic function:
func isSame<T>(leftNode: TreeNode<T>?, rightNode: TreeNode<T>?) -> Bool {
This is exactly how the Equatable protocol can be implemented:
func == <T: Equatable>(lhs: TreeNode<T>, rhs: TreeNode<T>) -> Bool {
return lhs.value == rhs.value
&& lhs.leftChild == rhs.leftChild
&& lhs.rightChild == rhs.rightChild
}
Note that the Equatable protocol doesn't need optional parameters. The comparison with nil is handled automatically.
Then you can simply compare using leftNode == rightNode.

Answer 2

You could put the isSame function inside the class like this:
class TreeNode<T: Comparable> {
// code here
class func isSame(leftNode: TreeNode<T>?, rightNode: TreeNode<T>?) -> Bool {
// code here
return true
}
}