从 func 获取 Int 或 Double 而不转换

Question

In my app I have a func that either returns int or double. There probably shouldn't be any issue with converting Int to Double but I'm wondering whether there is a way to make it without that particular convert.

I have a following code which I would like to get working but am unable to do so.

struct FuncEquatableView: View {
   let int = 25
   let double = 30.0
   
   var body: some View {
       Text("\(returnEquatable())")
   }

   func returnEquatable<T: Equatable>(returnInt: Bool = true) -> T {
       if returnInt {
           return int as! T
       }
       else {
           return double as! T
       }
   }
}

Answer 1

For the use case you've described, this solution is to return a String:

func returnEquatable(returnInt: Bool = true) -> String {
    if returnInt {
        return "\(int)"
    }
    else {
        return "\(double)"
    }
}

If you have a value that you want to be either an Int or a Double, that's an "or" type (the official name is a "sum type"). That's an enum. This enum may work for your purposes; it has lots of little problems, but it may be sufficient. This form allows you to check for equality or sort a collection of Values. (Remembering that not every Int can be expressed as a Double, so very large Ints will be equal to each other.)

enum Value: Comparable, CustomStringConvertible {
    case int(Int)
    case double(Double)

    // NOTE: This is lossy for non-integers
    var intValue: Int {
        switch self {
        case .int(let x): return x
        case .double(let x): return Int(x)
        }
    }

    // NOTE: This is lossy for large integers
    var doubleValue: Double {
        switch self {
        case .int(let x): return Double(x)
        case .double(let x): return x
        }
    }

    static func == (lhs: Value, rhs: Value) -> Bool {
        // NOTE: This does not work for large integers
        lhs.doubleValue == rhs.doubleValue
    }

    static func < (lhs: Value, rhs: Value) -> Bool {
        // NOTE: This does not work for large integers
        lhs.doubleValue < rhs.doubleValue
    }

    var description: String {
        switch self {
        case .int(let x): return x.description
        case .double(let x): return x.description
        }
    }
}

And then your returnEquatable would be:

func returnEquatable(returnInt: Bool = true) -> Value {
    if returnInt {
        return .int(int)
    }
    else {
        return .double(double)
    }
}

Note that you want verbatim text in this case, not a localized key:

    Text(verbatim: "\(returnEquatable())")

My suspicion is that this is overkill, though, and that your actual problem looks like the first answer, or something even simpler.