Declare an array of a generic struct specialized with different types - swift

Question

I know that Swift does not have wildcard types to specialize generic types. I have a problem I would know how to solve using them in a language like Java.
In the following example I'm trying to define a struct Property which encapsulates access to a property of a type T to perform two operations, getting the hash value of the value of that property on an instance of T and comparing the values of the property on two instances of T. To allow this, the struct contains a property getter holding a function which returns the value of the specific property on an instance. Because of this, the struct needs to be generic not only in T but also the type E of the property.
In the struct Test, I would like to define a static property properties holding an array of Property instances, one for each property of Test. I cannot see a way to do that because I don't know what type to use for properties or how to "hide" the type parameter E so that it does not need to be specified in the declaration of properties.
// Struct which represents a property of type T with a value of type E.
// Aside from initialization only T is visible from outside.
public struct Property<T, E: Hashable> {
let getter: (T) -> E
func getMemberHashValue(instance: T) -> Int {
return getter(instance).hashValue
}
func equalsMembers(instance1: T, instance2: T) -> Bool {
return getter(instance1) == getter(instance2)
}
}
struct Test {
// Some properties with different types
let a: Int
let b: Double
// Array of Property instances for all properties of Test.
// Not valid syntax.
let properties: [Property<Test, ?>] = [
Property(getter: { (instance: Test) in instance.a }),
Property(getter: { (instance: Test) in instance.b })]
}
I know that I could in this case substitute AnyHashable for the second type parameter in the declaration of properties as it has no associated types, but I would like to find a general solution I could apply in cases not involving Hashable.
Is there a way to change this example to allow such a property properties to be defined holding multiple Property instances for properties of different types?

Answer 1

Overview:
I am not sure I understood your question correctly.
Might be worth stating why you would like a heterogeneous array, would lose all type safety in the process.
Might be revisiting the design
Option 1:
If it is absolutely required, if so just use an NSArray / NSMutableArray
Option 2:
If you want to access properties of a class / struct / enum dynamically, you could do so with KeyPath.
Code:
struct Test : Hashable {
// Some properties with different types
let a: Int
let b: Double
let c: String
//This function will return any property of Test instance
func property<T>(forKeyPath keyPath: KeyPath<Test, T>) -> T {
return self[keyPath: keyPath]
}
//MARK: Hashable
var hashValue: Int {
return a.hashValue ^ b.hashValue ^ c.hashValue
}
//MARK: Equatable
static func ==(lhs: Test, rhs: Test) -> Bool {
return lhs.a == rhs.a &&
lhs.b == rhs.b &&
lhs.c == rhs.c
}
}
let test1 = Test(a: 10, b: 22.22, c: "aaaa")
let cValue = test1.property(forKeyPath: \.c) //aaaa
let cHashValue = test1.property(forKeyPath: \.c.hashValue) //Hash value of aaaa
let someInt = 10 //This is also Hashable
var mixedArray = [AnyHashable]()
mixedArray.append(test1)
mixedArray.append(someInt)
Refer:
If this matches your requirement, then please read about KeyPath, PartialKeyPath.
Version:
Swift 4