# Fuzzy Equatable protocol

**URL:** <https://forums.swift.org/t/fuzzy-equatable-protocol/74295>\
**Category:** Using Swift\
**Tags:** equatable\
**Created:** [August 31, 2024, 12:55pm UTC](https://forums.swift.org/t/fuzzy-equatable-protocol/74295 "2024-08-31T12:55:17Z")\
**Posts on this page:** 1\
**Page:** 1

<div class="post-metadata">

**Author:** ![ibex](https://sea2.discourse-cdn.com/swift/user_avatar/forums.swift.org/ibex/32/30439_2.png) [@ibex](https://forums.swift.org/u/ibex)\
**Post date:** [August 31, 2024, 12:55pm UTC](https://forums.swift.org/t/fuzzy-equatable-protocol/74295/1 "2024-08-31T12:55:17Z")

</div>

What does the protocol for fuzzy equality look like?

Here is my tinkering with it for reference types. 🙂

```swift
enum Fuzzy {
    case yes, no, maybe (probability: Double)
    
    protocol Equatable: AnyObject {
        func isEqual (to: AnyObject) -> Fuzzy
    }
}

```

```swift
@main
enum Test {
    static func main () async {
        let u = A ()
        print (u.isEqual (to: u)) // yes
        print (u.isEqual (to: A ())) // yes
        print (u.isEqual (to: B ())) // no
        print (u.isEqual (to: B (v: u.u))) // maybe

        let v = u
        print (v.isEqual (to: u)) // yes
        print (u.isEqual (to: v)) // yes
        
        class C {
        }
        print (u.isEqual (to: C ())) // no
    }
}

enum Fuzzy {
    case yes, no, maybe (probability: Double)
    
    protocol Equatable: AnyObject {
        func isEqual (to: AnyObject ) -> Fuzzy
    }
}

class U: Fuzzy.Equatable {
    let u: Int
    
    init (u: Int) {
        self.u = u
    }
    
    func isEqual (to it: AnyObject) -> Fuzzy {
        guard let it = it as? U else {
            return .no
        }
        
        if it === self {
            return .yes
        }
        else {
            return is_equal (to: it)
        }
    }
    
    // Subclasses to override
    func is_equal (to it: U) -> Fuzzy {
        .no
    }
}

class A: U {
    init (v: Int = 2) {
        super.init (u: v)
    }
    
    override func is_equal (to it: U) -> Fuzzy {
        return self.u == it.u ? (((it as? Self) != nil) ? .yes : .maybe (probability: 0.5)) : .no
    }
}

class B: U {
    init (v: Int = 3) {
        super.init(u: v)
    }
    
    override func is_equal (to it: U) -> Fuzzy {
        return self.u == it.u ? ((it as? Self) != nil ? .yes : .maybe (probability: 0)) : .no
    }
}

```

How would you write this protocol for all nominal types (reference types and value types)?