CaseEnumeration.swift

func assert(_ cond: @autoclosure () -> Bool) -> String {
    if cond() {
        return "✅"
    } else {
        return "❌"
    }
}

#if !swift(>=4.2)
protocol KnownEnum: RawRepresentable, Hashable where RawValue == String {
    static var allCases: [Self] { get }
}
#else
protocol KnownEnum: RawRepresentable, Hashable, CaseIterable where RawValue == String {

}
#endif

func cases<Enum: KnownEnum>(in flagType: Enum.Type) -> [Enum] {
    let sequence = AnySequence { () -> AnyIterator<Enum> in
        var raw = 0
        return AnyIterator {
            let current: Enum = withUnsafePointer(to: &raw) { $0.withMemoryRebound(to: flagType, capacity: 1) { $0.pointee } }
            dump(current)
            dump(current.hashValue)
            dump(raw)
            guard current.hashValue == raw else {
                return nil
            }
            raw += 1

            return current
        }
    }
    return Array(sequence)
}

enum MyEnum: String, KnownEnum {
    case foo
    case bar

    #if !swift(>=4.2)
    static var allCases: [MyEnum] { return [.foo, .bar] }
    #endif
}

let xs = cases(in: MyEnum.self)
assert(xs.count == 2)
xs.count

let ys = MyEnum.allCases
assert(ys.count == 2)
ys.count