新しい環境に移ってから早2週間が経ちました。
今日は実際開発中のライブラリでも使った、2つのDictionaryを結合するExtensionと演算子を紹介します。
2つのDictionaryを結合する関数を定義する
まずは、結合する関数unionを定義してみます。
public extension Dictionary {
public func union(other: Dictionary) -> Dictionary {
var tmp = self
other.forEach { tmp[$0.0] = $0.1 }
return tmp
}
}
こう定義することで、
let a = ["key1": 1]
let b = ["key2": 2]
let c = a.union(b)
と書くことができます。
もし、 mutating に扱いたい場合は、
public mutating func united(other: Dictionary) {
other.forEach { self[$0.0] = $0.1 }
}
//----
var a = ["key1": 1]
let b = ["key2": 2]
a.united(b) // ["key1": 1, "key2": 2]
と定義してあげるといい感じになります。
演算子 + を定義する
より直感的に使いやすくするために、2つのDictionaryを結合する演算子 + を定義してみます。
public func +<K, V>(lhs: Dictionary<K, V>, rhs: Dictionary<K, V>) -> Dictionary<K, V> {
return lhs.union(rhs)
}
public func +=<K, V>(inout lhs: Dictionary<K, V>, rhs: Dictionary<K, V>) {
lhs = lhs + rhs
}
これで、
let a = ["key1": 1]
let b = ["key2": 2]
let c = a + b // ["key1": 1, "key2": 2]
と書くことができます。
Optionalの場合にも対応してみる
ただ、上記のままでは、どちらかがOptionalなDictionaryだった場合には、そのまま結合することができません。
let a: [String: Int] = ["key1": 1]
let b: [String: Int]? = ["key2": 2]
let c = a + b // error!
なので、Optionalでも問題なく扱えるように 演算子 + をオーバーロードします。
また、今回の結合では、以下のように扱うことにします。
| A \ B | Some(let b) | None (nil) |
|---|---|---|
| Some(let a) | a + b | a |
| None (nil) | b | nil |
この表を基に、演算子を以下のようにオーバーロードして定義します。
public func +<K, V>(lhs: Dictionary<K, V>?, rhs: Dictionary<K, V>?) -> Dictionary<K, V>? {
switch (lhs, rhs) {
case (.Some(let l), .Some(let r)):
return l + r
case (.Some(let l), .None):
return l
case (.None, .Some(let r)):
return r
default:
return nil
}
}
public func +=<K, V>(inout lhs: Dictionary<K, V>?, rhs: Dictionary<K, V>?) {
lhs = lhs + rhs
}
※もし片方がnilのDictionaryだったら、結果としてnilにしたい！という場合条件を変えてあげれば実装できるかと思います。
パターンマッチがいい感じ
左辺、右辺のDictionaryがnilかどうかを見るのに、 if let を使うとあまりスッキリと書けないので、
switch文で、パターンマッチを用いてみました。
Optionalな変数に対して、 .Some(let variable) (値がある)と、 .None (nilである)でパターンマッチをして、 .Some()内で定義した変数名で、アンラップした値を扱うことができます。