Comparing enum cases while ignoring associated values

[bdkjones (Bryan)]

I like that a lot. Also fairly natural to grok: “use case let when you care about the associated value and omit the let when you don’t.”

[unike_nutra]

Totally agree — I’ve run into this exact issue multiple times too. Would love a clean way to compare just the case, ignoring associated values. Hope this gets some attention!

[stephencelis]

@tera

This works in basic cases:

func valueBaseName(_ value: Any) -> String {
    var string = "\(value)" // string("hello")
    if let paren = string.range(of: "(") {
        string .removeSubrange(paren.lowerBound...)
        return string
    } else {
        return string
    }
}

print(valueBaseName(Foo.string("hello")))   // "string"
print(valueBaseName(Foo.number(42)))        // "number"
// used like:
valueBaseName(foo) == valueBaseName(bar)

Although it's easy to break it (e.g. by having a CustomStringConvertible implementation that does something else).

---

+1 to having something better built-in, ideally that's O(1) in both time and code size.

Not built-in, but Case Paths has O(1) lookups for this and more:

Foo.allCasePaths[foo] == Foo.allCasePaths[bar]

foo.is(\.string)
bar.is(\.number)

We'd love to retire the library for built-in solutions, but it's been many years since we first released it and there's been no real public movement in the language. So if you do leverage enums in your apps, the Case Paths package may help you write the kind of code you've been wanting to write.

[tera]

Interestingly Error / NSError has the superpowers to know enum's discriminator and by abusing it you could get that out:

protocol EnumWithDiscriminator: Error {
    var discriminator: Int { get }
}
extension EnumWithDiscriminator {
    var discriminator: Int {
        (self as NSError).code
    }
}

Test:

struct Client {}
struct Project {}
struct Job { let name: String }
struct Version {}

enum NavNode {
    case client(Client)
    case project(Project)
    case job(Job)
    case version(Version)
}

extension NavNode: EnumWithDiscriminator {}

let a = NavNode.job(Job(name: "a"))
let b = NavNode.job(Job(name: "b"))
let c = NavNode.project(Project())
precondition(a.discriminator == b.discriminator)
precondition(a.discriminator != c.discriminator)

[gwendal.roue (Gwendal Roué)]

@tera

Interestingly Error / NSError has the superpowers to know enum's discriminator and by abusing it you could get that out:

The implementation is probably there: _swift_stdlib_getDefaultErrorCode(), vw_getEnumTag() (i.e. not publicly available).

[stephencelis]

The runtime metadata is stable and available, but it's not the most straightforward to access. Here's something you can drop into any project, though:

func areCasesEqual<T>(_ lhs: T, _ rhs: T) -> Bool {
  guard
    let lhsTag = enumTag(lhs),
    let rhsTag == enumTag(rhs)
  else { return false }
  return lhsTag == rhsTag
}

func enumTag<Case>(_ `case`: Case) -> UInt32? {
  let metadataPtr = unsafeBitCast(type(of: `case`), to: UnsafeRawPointer.self)
  let kind = metadataPtr.load(as: Int.self)
  let isEnumOrOptional = kind == 0x201 || kind == 0x202
  guard isEnumOrOptional else { return nil }
  let vwtPtr = (metadataPtr - MemoryLayout<UnsafeRawPointer>.size).load(as: UnsafeRawPointer.self)
  let vwt = vwtPtr.load(as: EnumValueWitnessTable.self)
  return withUnsafePointer(to: `case`) { vwt.getEnumTag($0, metadataPtr) }
}

private struct EnumValueWitnessTable {
  let f1, f2, f3, f4, f5, f6, f7, f8: UnsafeRawPointer
  let f9, f10: Int
  let f11, f12: UInt32
  let getEnumTag: @convention(c) (UnsafeRawPointer, UnsafeRawPointer) -> UInt32
  let f13, f14: UnsafeRawPointer
}