在Swift 1.2

Question

import SwiftyJSON

public typealias FeedItem = JSON

extension FeedItem {
    var id: Int { get { return self["id"].intValue } }
}

public func <(lhs: FeedItem, rhs: FeedItem) -> Bool {
    return lhs.id < rhs.id
}

public func ==(lhs: FeedItem, rhs: FeedItem) -> Bool {
    return lhs.id == rhs.id
}

extension FeedItem:Comparable {}

extension Optional : Comparable {}

public func < <T>(l:T?, r:T?) -> Bool {
    if let a=l,b=r {
        return a < b
    } else if (l==nil) && (r != nil) { return true }
    else { return false }
}

public func == <T>(l:T?, r:T?) -> Bool {
    if let a=l, b=r {
        return a==b
    } else {
        return false
    }
}

首先，它应该是extension Optional<T where T:Comparable>: Comparable，但swift 1.2不允许这样做。无论如何，我可以更明确地表达约束，而不是期望读者通过注意return a < b和return a==b来实现这一事实？

第二个（显然更重要）：上面的代码在我使用<和>时起作用，但minElement和maxElement都返回nil nil出现在他们的输入中，无论如何，min和max都会进入无限递归：

    let items: [FeedItem?] = [ nil, .Some(JSON(["id":2])), .Some(JSON(["id":1])) ]

    println(items[0]?.id) // nil
    println(items[1]?.id) // Optional(2)
    println(items[2]?.id) // Optional(1)
    println(items[0] < items[1]) // true
    println(items[1] < items[2]) // false
    println(items[2] < items[1]) // true
    println(minElement(items)) // nil
    println(maxElement(items)) // nil
    println( min(items[0],items[2]) ) // nil
    println( min(items[2],items[1]) ) // crashes due to infinite recursion

我不是调试（或快速）专家，但我可以从XCode收集的内容中相信

if let a=l,b=r {
    return a < b
}

部分错过了a和b 不 Optional但FeedItem s的观点。我希望a < b应该在<上调用FeedItem运算符而在<{1}}上调用而不是，但显然这正是发生的事情;即Optional解析为从它调用的相同函数（即a < b的{​​{1}}），因此发生递归。我可能错了。

见解？