無限ループにおけるジェネリック医薬品の結果を使用してOptionalsためのオーバーライド/オペレータ

Question

次のコードスニペットを見てみましょう：

func/<T>(lhs: T?,rhs: T?) throws -> T? { 
    switch (lhs,rhs) { 
     case let (l?,r?): 
      return try l/r 
     default: 
      return nil 
    } 
} 

let x : Double? = 2 
let y : Double? = 2 

let z = try! x/y 

私は2つのオプションのパラメータを期待する汎用関数を作成しました。このコードを実行すると無限ループにつながります。を試してみてくださいfunc/<T>(lhs: T?,rhs: T?)を使用して値を分割してください。誰も2つのnoneオプションのdouble値を分割すると、私が書いたメソッドに関数呼び出しを行い、デフォルトではないと説明することができます/演算子の定義double？

私はすべてが魔法のように動作し、そのクラスの/静的オペレータを必要と拡張子によってダブルを拡張する場合：

protocol Dividable { 
    static func /(lhs: Self, rhs: Self) -> Self 
} 

extension Double: Dividable {} 

func/<T:Dividable>(lhs: T?,rhs: T?) throws -> T? { 
    switch (lhs,rhs) { 
     case let (l?,r?): 
      return l/r 
     default: 
      return nil 
    } 
} 

let x : Double? = 2 
let y : Double? = 2 

let z = try! x/y 

Answer 1

あなたの関数のシグネチャは、コンパイラがについて何も知らせていませんlhsとrhsのタイプは、同じタイプではありません。 （この場合はStringで）同じ型の2つのパラメータにかかる/と呼ばれるコンパイラが知っている唯一の方法があるので、これは無限ループになります

let str1 = "Left string" 
let str2 = "Right string" 
let result = try? str1/str2 

：たとえば、あなたはこのようにあなたのメソッドを呼び出すことができますあなたが宣言したものreturn try l/rは、あなたのfunc/<T>(lhs: T?,rhs: T?) throws -> T?メソッドを何度も繰り返し呼び出すでしょう。

あなたの質問で言及したように、パラメータが準拠しなければならないプロトコルが必要です。残念ながらthere is no existing Number or Dividable protocol that would fit your needsなので、自分で作る必要があります。分母が0であり、あなたはそれがあるように、あなたの関数からthrowsキーワードを削除することができるはずですので、エラーをスローしないとき部門がクラッシュすること

注：

func/<T:Dividable>(lhs: T?, rhs: T?) -> T?

編集さらに明確にする

コンパイラがその時点で何を知っているか考えてみると、もっと意味があると思います。コンパイラが知っている関数の中に入ると、lhsとrhsはTとオプションです。 何がTであるか、またはそのプロパティまたは機能のいずれかがわからないが、どちらもタイプがTであることのみを知っている。一度値をアンラップすると、はまだで、どちらもタイプがTで、オプションではないことがわかります。 でもT（この例では）はDoubleであることがわかりますが、これはString（上記の例のとおり）です。これは、コンパイラがすべての可能なクラスと構造体を反復して、あなたのメソッドシグニチャ（この場合はfunc/(lhs: Double, rhs: Double) -> Double）をサポートするものを見つけることを必要とします。これは単に妥当な時間内にはできず、予測できないコードにつながります。このグローバルメソッドを追加した後に、/が既存のもの（例えばFloat(10)/Float(5)など）に使用されるたびに、メソッドが呼び出されるたびに、かなり面倒で混乱することがありました。

Answer 2

たとえば、DoubleコンクリートDoubleタイプを使用して実装されていませんが、FloatingPointに準拠したタイプのためではなく、デフォルトとして、一般的な実装：カスタム/機能のブロック内の

• swift/stdlib/public/core/FloatingPoint.swift.gyb

は、コンパイラがあることを知りません。タイプホルダーTはFloatingPointに準拠しており、l/rのオーバーロード解像度はメソッド自体に解決されます（FloatingPointの実装はより具体的ですがより一般的な非制約型カスタム実装ではTと入力してください）。

独自のカスタム方法にも型制約としてFloatingPointを追加することでこの問題を回避できます。

は

func /<T: FloatingPoint>(lhs: T?, rhs: T?) throws -> T? { 
    switch (lhs, rhs) { 
     case let (l?, r?): 
      return try l/r 
     default: 
      return nil 
    } 
} 

同様に、整数型のバイナリ算術を内部に準拠したタイプに制限デフォルトの一般的な実装として実装されていますプロトコル_IntegerArithmetic、これには公開プロトコルIntegerArithmeticが準拠しています。

• swift/stdlib/public/core/IntegerArithmetic.swift.gyb

あなたは整数型に対してカスタム演算子関数のオーバーロードを実装するために、後者のパブリックプロトコルを使用することができます。

func /<T: IntegerArithmetic>(lhs: T?, rhs: T?) throws -> T? { 
    switch (lhs, rhs) { 
     case let (l?, r?): 
      return try l/r 
     default: 
      return nil 
    } 
} 

最後に、この機能をスローする理由を考えてみるとよいでしょう。両方の場合にのみ操作したい2つのオプションの値を扱うときは、実装を簡素化する方法があります。nil。例えば：あなたは簡潔上のセマンティクスを好む場合の

func /<T: FloatingPoint>(lhs: T?, rhs: T?) -> T? { 
    return lhs.flatMap { l in rhs.map{ l/$0 } } 
} 

func /<T: IntegerArithmetic>(lhs: T?, rhs: T?) -> T? { 
    return lhs.flatMap { l in rhs.map{ l/$0 } } 
} 

、それはおそらく以来、原因あなたのreturn文で `try`に再帰につながる単一if文で

func /<T: FloatingPoint>(lhs: T?, rhs: T?) -> T? { 
    if case let (l?, r?) = (lhs, rhs) { 
     return l/r 
    } 
    return nil 
} 

func /<T: IntegerArithmetic>(lhs: T?, rhs: T?) -> T? { 
    if case let (l?, r?) = (lhs, rhs) { 
     return l/r 
    } 
    return nil 
}