> On 9. Jul 2017, at 21:20, David Baraff <davidbar...@gmail.com> wrote:
> 
> Nice: i hadn’t seen elementsEqual.
> 
>   (1) Why do you have to pass in “by: ==“ ?  is not that the default

There are two versions: One taking an explicit predicate, and another which 
requires sequences of Equatable elements. As observed earlier in this thread, 
an array of tuples is not Equatable.

> 
>   (2) not a big deal, but if the sequence type’s length can be determined a 
> priori (e.g. in the case of an Array, or perhaps a Collection if that has a 
> count member, haven’t checked) does the elementsEqual function short circuit 
> by first checking that the lengths are equal before beginning the loop?

As far as I can tell from the implementation at 
https://github.com/apple/swift/blob/master/stdlib/public/core/SequenceAlgorithms.swift.gyb#L292
 
<https://github.com/apple/swift/blob/master/stdlib/public/core/SequenceAlgorithms.swift.gyb#L292>
 , the length is not checked a-priori, so you might want to add that to your 
code:

    class Tree : Equatable {
        let rootData:Int = 0
        let children:[(String, Tree)] = []
        
        static public func ==(_ lhs:Tree, _ rhs:Tree) -> Bool {
            return lhs.rootData == rhs.rootData &&
                lhs.children.count == rhs.children.count &&
                lhs.children.elementsEqual(rhs.children, by: ==)
        }
    }



> 
> But again, that’s a great one to know.
> 
>> On Jul 9, 2017, at 12:14 PM, Martin R via swift-users <swift-users@swift.org 
>> <mailto:swift-users@swift.org>> wrote:
>> 
>> 
>>> On 9. Jul 2017, at 21:00, Jens Persson via swift-users 
>>> <swift-users@swift.org <mailto:swift-users@swift.org>> wrote:
>>> 
>>> Since Array has .elementsEqual, another workaround (until conditional 
>>> conformance) is:
>>> 
>>> class Tree : Equatable {
>>>     let rootData:Int
>>>     let children:[(String, Tree)]
>>>     
>>>     init(rootData: Int, children: [(String, Tree)]) {
>>>         self.rootData = rootData
>>>         self.children = children
>>>     }
>>>     static public func ==(_ lhs:Tree, _ rhs:Tree) -> Bool {
>>>         return lhs.rootData == rhs.rootData &&
>>>             lhs.children.elementsEqual(rhs.children, by: { (a: (String, 
>>> Tree), b: (String, Tree)) -> Bool in
>>>                 return a.0 == b.0 && a.1 == b.1
>>>             })
>>>     }
>>> }
>> 
>> 
>> Slightly simpler (since == is already defined for the tuples):
>> 
>>     class Tree : Equatable {
>>         let rootData:Int = 0
>>         let children:[(String, Tree)] = []
>>         
>>         static public func ==(_ lhs:Tree, _ rhs:Tree) -> Bool {
>>             return lhs.rootData == rhs.rootData &&
>>                 lhs.children.elementsEqual(rhs.children, by: ==)
>>         }
>>     }
>> 
>> 
>>> 
>>> 
>>> On Sun, Jul 9, 2017 at 8:44 PM, David Sweeris <daveswee...@mac.com 
>>> <mailto:daveswee...@mac.com>> wrote:
>>> 
>>> On Jul 9, 2017, at 10:06, David Baraff via swift-users 
>>> <swift-users@swift.org <mailto:swift-users@swift.org>> wrote:
>>> 
>>>> 
>>>>> On Jul 9, 2017, at 8:27 AM, Jens Persson <j...@bitcycle.com 
>>>>> <mailto:j...@bitcycle.com>> wrote:
>>>>> 
>>>>> (Also, note that your implementation of == uses lhs === rhs thus will 
>>>>> only return true when lhs and rhs are the same instance of SomeClass.)
>>>> Of course — i threw that in just to make a simple example.
>>>> 
>>>> Followup question: what I really wanted to write was an == operator for a 
>>>> tree:
>>>> 
>>>> // silly tree, useful for nothing
>>>> class Tree : Equatable {
>>>>    let rootData:Int
>>>>    let children:[(String, Tree)]
>>>> 
>>>>    static public func ==(_ lhs:Tree, _ rhs:Tree) {
>>>>    return lhs.rootData == rhs.rootData && 
>>>>             lhs.children == rhs.children           // sadly, this doesn’t 
>>>> compile
>>>>    }
>>>> }
>>> 
>>> Right, the `==` func is *defined* for 2-element tuples where both elements 
>>> conform to `Equatable`, but that tuple type doesn't itself *conform* to 
>>> `Equatable`. So the`==` func that's defined on "Array where Element: 
>>> Equatable" can't see it.
>>> 
>>> We'd need both "conditional conformance" and "tuple conformance" in order 
>>> for that to Just Work.
>>> 
>>> - Dave Sweeris 
>>> 
>>> _______________________________________________
>>> swift-users mailing list
>>> swift-users@swift.org <mailto:swift-users@swift.org>
>>> https://lists.swift.org/mailman/listinfo/swift-users 
>>> <https://lists.swift.org/mailman/listinfo/swift-users>
>> _______________________________________________
>> swift-users mailing list
>> swift-users@swift.org <mailto:swift-users@swift.org>
>> https://lists.swift.org/mailman/listinfo/swift-users
> 

_______________________________________________
swift-users mailing list
swift-users@swift.org
https://lists.swift.org/mailman/listinfo/swift-users

Reply via email to