可以通过结构扩展 Swift 字典吗?
Can one extend a Swift Dictionary by a struct?
我已经尝试了 中的解决方案,但它不会为我编译。
我只是想将字典扩展限制为 struct
类型。有什么方法可以做到这一点吗?
import Cocoa
struct Foo: Hashable {
let bar: String
static let predefinedFoo = Foo(bar: "something")
var hashValue: Int { return bar.hashValue }
public static func ==(lhs: Foo, rhs: Foo) -> Bool {
return lhs.hashValue == rhs.hashValue
}
}
struct Baz {
let isSpecial: Bool
}
extension Dictionary where Key: Foo, Value: Baz { // Note that the == syntax does not compile, either
var hasSpecialPredefined: Bool {
return self[.predefinedFoo]?.isSpecial ?? false
}
}
let test: [Foo: Baz] = [.predefinedFoo: Baz(isSpecial: true)]
test.hasSpecialPredefined
使用上面的代码,我得到两个编译错误:
error: type 'Key' constrained to non-protocol type 'Foo'
error: type 'Value' constrained to non-protocol type 'Baz'
error: '[Foo : Baz]' is not convertible to '<<error type>>'
test.hasSpecialPredefined
^~~~
是否可以通过结构来限制扩展?如果不能,为什么不呢?这似乎非常合理。
Note that Foo
and Bar
, here, are not under my control. They represent structs that are defined in an external module, and the dictionary I want to extend also comes from this module. Answers should assume Foo
will always be a struct
, and that struct will always
be the key type for the dictionary.
试试我的版本
1。代码(带结构)
import Foundation
struct Foo: Hashable {
let bar: String
static let predefinedFoo = Foo(bar: "something")
var hashValue: Int { return bar.hashValue }
static func ==(lhs: Foo, rhs: Foo) -> Bool {
return lhs.hashValue == rhs.hashValue
}
}
struct Baz {
let isSpecial: Bool
init(isSpecial: Bool) {
self.isSpecial = isSpecial
}
}
extension Dictionary where Key: Any, Value: Any {
var hasSpecialPredefined: Bool {
for key in keys {
if let _key = key as? Foo, _key == .predefinedFoo, let value = self[key] as? Baz {
return value.isSpecial
}
}
return false
}
}
let foo1 = Foo(bar: "ddddd")
var test: [Foo: Baz] = [foo1: Baz(isSpecial: true)]
print("\(test), hasSpecialPredefined: \(test.hasSpecialPredefined)")
test[.predefinedFoo] = Baz(isSpecial: true)
print("\(test), hasSpecialPredefined: \(test.hasSpecialPredefined)")
结果
2。代码(类)
import Foundation
class Foo: Hashable {
let bar: String
init(bar:String) {
self.bar = bar
}
static let predefinedFoo = Foo(bar: "something")
var hashValue: Int { return bar.hashValue }
public static func ==(lhs: Foo, rhs: Foo) -> Bool {
return lhs.hashValue == rhs.hashValue
}
}
class Baz: AnyObject {
let isSpecial: Bool
init(isSpecial: Bool) {
self.isSpecial = isSpecial
}
}
extension Dictionary where Key: Foo, Value: Baz {
var hasSpecialPredefined: Bool {
for key in keys {
if key == .predefinedFoo {
return self[key]?.isSpecial ?? false
}
}
return false
}
}
let foo1 = Foo(bar: "ddddd")
var test: [Foo: Baz] = [foo1: Baz(isSpecial: true)]
print ("hasSpecialPredefined: \(test.hasSpecialPredefined)")
test[.predefinedFoo] = Baz(isSpecial: true)
print ("hasSpecialPredefined: \(test.hasSpecialPredefined)")
我已经尝试了
我只是想将字典扩展限制为 struct
类型。有什么方法可以做到这一点吗?
import Cocoa
struct Foo: Hashable {
let bar: String
static let predefinedFoo = Foo(bar: "something")
var hashValue: Int { return bar.hashValue }
public static func ==(lhs: Foo, rhs: Foo) -> Bool {
return lhs.hashValue == rhs.hashValue
}
}
struct Baz {
let isSpecial: Bool
}
extension Dictionary where Key: Foo, Value: Baz { // Note that the == syntax does not compile, either
var hasSpecialPredefined: Bool {
return self[.predefinedFoo]?.isSpecial ?? false
}
}
let test: [Foo: Baz] = [.predefinedFoo: Baz(isSpecial: true)]
test.hasSpecialPredefined
使用上面的代码,我得到两个编译错误:
error: type 'Key' constrained to non-protocol type 'Foo'
error: type 'Value' constrained to non-protocol type 'Baz'
error: '[Foo : Baz]' is not convertible to '<<error type>>'
test.hasSpecialPredefined
^~~~
是否可以通过结构来限制扩展?如果不能,为什么不呢?这似乎非常合理。
Note that
Foo
andBar
, here, are not under my control. They represent structs that are defined in an external module, and the dictionary I want to extend also comes from this module. Answers should assumeFoo
will always be astruct
, and that struct willalways
be the key type for the dictionary.
试试我的版本
1。代码(带结构)
import Foundation
struct Foo: Hashable {
let bar: String
static let predefinedFoo = Foo(bar: "something")
var hashValue: Int { return bar.hashValue }
static func ==(lhs: Foo, rhs: Foo) -> Bool {
return lhs.hashValue == rhs.hashValue
}
}
struct Baz {
let isSpecial: Bool
init(isSpecial: Bool) {
self.isSpecial = isSpecial
}
}
extension Dictionary where Key: Any, Value: Any {
var hasSpecialPredefined: Bool {
for key in keys {
if let _key = key as? Foo, _key == .predefinedFoo, let value = self[key] as? Baz {
return value.isSpecial
}
}
return false
}
}
let foo1 = Foo(bar: "ddddd")
var test: [Foo: Baz] = [foo1: Baz(isSpecial: true)]
print("\(test), hasSpecialPredefined: \(test.hasSpecialPredefined)")
test[.predefinedFoo] = Baz(isSpecial: true)
print("\(test), hasSpecialPredefined: \(test.hasSpecialPredefined)")
结果
2。代码(类)
import Foundation
class Foo: Hashable {
let bar: String
init(bar:String) {
self.bar = bar
}
static let predefinedFoo = Foo(bar: "something")
var hashValue: Int { return bar.hashValue }
public static func ==(lhs: Foo, rhs: Foo) -> Bool {
return lhs.hashValue == rhs.hashValue
}
}
class Baz: AnyObject {
let isSpecial: Bool
init(isSpecial: Bool) {
self.isSpecial = isSpecial
}
}
extension Dictionary where Key: Foo, Value: Baz {
var hasSpecialPredefined: Bool {
for key in keys {
if key == .predefinedFoo {
return self[key]?.isSpecial ?? false
}
}
return false
}
}
let foo1 = Foo(bar: "ddddd")
var test: [Foo: Baz] = [foo1: Baz(isSpecial: true)]
print ("hasSpecialPredefined: \(test.hasSpecialPredefined)")
test[.predefinedFoo] = Baz(isSpecial: true)
print ("hasSpecialPredefined: \(test.hasSpecialPredefined)")