Neden x olarak Float vakasının Herhangi bir değişkende bir anahtarda eşleşmemesine izin verelim?

Question

Böyle künyelenen değerler için enum (bu bir oyuncak Şeması tercüman projesinden ise) vardır: Value(3) döner çağıran önüne aldığımızda

init?(value:Any) { 
    switch v { 
    case let v as Int: self = .int(v) 
    case let v as Float: self = .float(v) 
    case let v as Bool: self = .bool(v) 
    ... 
    default: return nil 
    } 
} 

:

enum Value { 
    case int(Int) 
    case float(Float) 
    case bool(Bool) 
    ... 
} 

bunun için bir başlatıcı yazdı beklendiği gibi bir (isteğe bağlı) Value.int (3). Bool's ve diğer tipler de çalışıyor.

Ancak Value(0.1) varsayılan durumu vurur ve nil değerini döndürür.

(doğruluğu ve tavsiye edilen stil için düzenlenmiştir. Bu sorunları işaret için herkese teşekkürler.)

Answer 1

nokta sabitlerini yüzen için varsayılan olayla tip Double değil Float olduğunu. Hızlı standart kitaplık tarafından burada tanımlanmıştır: derleyici tarafından bilinen FloatLiteralType typealias.

Answer 2

type inference dokümantasyonu diyor ki:

Swift hep seçer Double kayan noktalı sayıların türünü çıkarım alması (Float yerine).

Eğer Float kullanmak istiyorsanız, açıkça kullanması gerekiyor literal:

enum Value { 
    case Int(Int) 
    case Float(Float) 
    case Bool(Bool) 
    case Double(Double) 
    init?(v:Any) { 
     switch v { 
     case let v as Int: self = .Int(v) 
     case let v as Float: self = .Float(v) 
     case let v as Bool: self = .Bool(v) 
     case let v as Double: self = .Double(v) 
     default: return nil 
     } 
    } 
} 


Value(v: 0.1) //Infer Double > Result: Double(0.10000000000000001) 
Value(v: Float(0.0002)) //Specify Float > Result: Float(0.000199999995) 

Answer 3

Btw, sen değişmezleri ile Value türünü init edebilmek istiyorum gibi görünüyor, bu nedenle uygun deneyebilirsiniz türünüzü ExpressibleBy* protokollerine.

gibi:

extension Value: ExpressibleByIntegerLiteral { 
    init(integerLiteral value: Int) { 
     self = .int(value) 
    } 
} 

let v1: Value = 42 // v1 == Value.int(42) 

extension Value: ExpressibleByBooleanLiteral { 
    init(booleanLiteral value: Bool) { 
     self = .bool(value) 
    } 
} 

let v2: Value = true // v2 == Value.bool(true) 

extension Value: ExpressibleByFloatLiteral { 
    init(floatLiteral value: Float) { 
     self = .float(value) 
    } 
} 

let v3: Value = 0.5 // v3 == Value.float(0.5)