Infer return type from function using switch control flow - ios

Question

I've got a set of properties/protocols (back story is here, but I think it's superfluous)
The class types look like this:
struct AdjustmentTypes {
internal class BaseType<T>: Hashable {
static func == (lhs: AdjustmentTypes.BaseType<T>, rhs: AdjustmentTypes.BaseType<T>) -> Bool {
return lhs.name == rhs.name
}
typealias A = T
var hashValue: Int { return name.hashValue }
let name: String
let defaultValue: T
let min: T
let max: T
var value: T
init(name: String, defaultValue: T, min: T, max: T) {
self.name = name
self.defaultValue = defaultValue
self.min = min
self.max = max
self.value = defaultValue
}
}
class FloatType: BaseType<CGFloat> { }
class IntType: BaseType<Int> { }
}
And I'm using type erasure to remove the type so I can store these in a Set, and I've built some helper methods to make my Set tooling simpler:
class AdjustmentsSet {
private var adjustmentsSet: Set<AnyHashable> = []
func insert(_ adjustment: AnyHashable) {
adjustmentsSet.insert(adjustment)
}
func remove(_ adjustment: AnyHashable) {
adjustmentsSet.remove(adjustment)
}
func contains(_ adjustment: AnyHashable) -> Bool {
return adjustmentsSet.contains(adjustment)
}
var count: Int { return adjustmentsSet.count }
}
var adjustmentsSet = AdjustmentsSet()
What I want to do now is add some helpers to my Set management class to be able to retrieve a property with the correct type, e.g. if I do:
let brightness = Brightness().make()
adjustments.get(brightness)
It should return nil, but if I do:
adjustments.insert(brightness)
adjustments.get(brightness)
I should now get the value back, as its correct type, AdjustmentTypes.FloatType.
I'm thinking to so something with a Switch statement like this:
class AdjustmentsSet {
// ...
func get(_ adjustment: AnyHashable) -> Any? {
guard let untyped = adjustmentsSet.first(where: { $0 == adjustment }) else { return nil }
switch adjustment {
case _ as AdjustmentTypes.FloatType: return untyped as! AdjustmentTypes.FloatType
case _ as AdjustmentTypes.IntType: return untyped as! AdjustmentTypes.IntType
default: return nil
}
}
}
However, the fatal flaw of course, is that this returns Any, instead of the intended type.
How can I infer the return value's type and to return the correct type?
Complete example, just drop this into a playground:
// Generic conforming protocol to AnyHashable
protocol AnyAdjustmentProtocol {
func make() -> AnyHashable
}
protocol AdjustmentProtocol: AnyAdjustmentProtocol {
associatedtype A
func make() -> A
}
struct AdjustmentTypes {
internal class BaseType<T>: Hashable {
static func == (lhs: AdjustmentTypes.BaseType<T>, rhs: AdjustmentTypes.BaseType<T>) -> Bool {
return lhs.name == rhs.name
}
typealias A = T
var hashValue: Int { return name.hashValue }
let name: String
let defaultValue: T
let min: T
let max: T
var value: T
init(name: String, defaultValue: T, min: T, max: T) {
self.name = name
self.defaultValue = defaultValue
self.min = min
self.max = max
self.value = defaultValue
}
}
class FloatType: BaseType<CGFloat> { }
class IntType: BaseType<Int> { }
}
struct AnyAdjustmentType<A>: AdjustmentProtocol, Hashable {
static func == (lhs: AnyAdjustmentType<A>, rhs: AnyAdjustmentType<A>) -> Bool {
return lhs.hashValue == rhs.hashValue
}
private let _make: () -> AnyHashable
private let hashClosure:() -> Int
var hashValue: Int {
return hashClosure()
}
init<T: AdjustmentProtocol & Hashable>(_ adjustment: T) where T.A == A {
_make = adjustment.make
hashClosure = { return adjustment.hashValue }
}
func make() -> AnyHashable {
return _make()
}
}
struct Brightness: AdjustmentProtocol, Hashable {
func make() -> AnyHashable {
return AdjustmentTypes.FloatType(name: "Brightness", defaultValue: 0, min: 0, max: 1)
}
}
struct WhiteBalance: AdjustmentProtocol, Hashable {
func make() -> AnyHashable {
return AdjustmentTypes.IntType(name: "White Balance", defaultValue: 4000, min: 3000, max: 7000)
}
}
let brightness = Brightness().make()
let whiteBalance = WhiteBalance().make()
class AdjustmentsSet {
private var adjustmentsSet: Set<AnyHashable> = []
func insert(_ adjustment: AnyHashable) {
adjustmentsSet.insert(adjustment)
}
func remove(_ adjustment: AnyHashable) {
adjustmentsSet.remove(adjustment)
}
func contains(_ adjustment: AnyHashable) -> Bool {
return adjustmentsSet.contains(adjustment)
}
var count: Int { return adjustmentsSet.count }
}
var adjustmentsSet = AdjustmentsSet()

Answer 1

You need to rewrite the method as a generic and call it with sufficient type information, i.e. you need to know in advance what type you expect the method to return.
I'm also not sure passing around AnyHashables is ideal anyway. Nothing stops you from adding Strings, Ints and other random types that are hashable to your adjustment set.
var adjustmentsSet = AdjustmentsSet()
adjustmentsSet.insert("1") // compiles just fine!
Alternatively, you could use and pass around your AdjustmentTypes and rewrite the AdjustmentsSet class with generic methods:
class AdjustmentsSet {
private var adjustmentsSet: Set<AnyHashable> = []
func insert<T>(_ adjustment: AdjustmentTypes.BaseType<T>) {
adjustmentsSet.insert(adjustment)
}
func remove<T>(_ adjustment: AdjustmentTypes.BaseType<T>) {
adjustmentsSet.remove(adjustment)
}
func contains<T>(_ adjustment: AdjustmentTypes.BaseType<T>) -> Bool {
return adjustmentsSet.contains(adjustment)
}
func get<T>(_ adjustment: AdjustmentTypes.BaseType<T>) -> AdjustmentTypes.BaseType<T>? {
return (adjustmentsSet.compactMap { $0 as? AdjustmentTypes.BaseType<T> }).first(where: { $0 == adjustment })
}
var count: Int { return adjustmentsSet.count }
}
Next, your make() methods should be more strongly typed as well, since you are not passing around AnyHashables. I implemented brightness and white balance like this:
extension AdjustmentTypes {
static let Brightness = AdjustmentTypes.FloatType(name: "Brightness", defaultValue: 0, min: 0, max: 1)
static let WhiteBalance = AdjustmentTypes.IntType(name: "White Balance", defaultValue: 4000, min: 3000, max: 7000)
}
And also took advantage of type aliases and structs in Swift, to make your adjustment type system behave with value semantics:
struct AdjustmentTypes {
struct BaseType<T>: Hashable {
static func == (lhs: AdjustmentTypes.BaseType<T>, rhs: AdjustmentTypes.BaseType<T>) -> Bool {
return lhs.name == rhs.name
}
typealias A = T
var hashValue: Int { return name.hashValue }
let name: String
let defaultValue: T
let min: T
let max: T
var value: T
init(name: String, defaultValue: T, min: T, max: T) {
self.name = name
self.defaultValue = defaultValue
self.min = min
self.max = max
self.value = defaultValue
}
}
typealias FloatType = BaseType<CGFloat>
typealias IntType = BaseType<Int>
}
Finally, you are able to use the adjustment set as intended:
var brightness = AdjustmentTypes.Brightness
brightness.value = 0.5
var adjustmentsSet = AdjustmentsSet()
adjustmentsSet.insert(brightness)
let retrievedBrightness = adjustmentsSet.get(AdjustmentTypes.Brightness)! // strongly typed!
retrievedBrightness.value // 0.5
AdjustmentTypes.Brightness.value // 0.0
The entire playground:
struct AdjustmentTypes {
struct BaseType<T>: Hashable {
static func == (lhs: AdjustmentTypes.BaseType<T>, rhs: AdjustmentTypes.BaseType<T>) -> Bool {
return lhs.name == rhs.name
}
typealias A = T
var hashValue: Int { return name.hashValue }
let name: String
let defaultValue: T
let min: T
let max: T
var value: T
init(name: String, defaultValue: T, min: T, max: T) {
self.name = name
self.defaultValue = defaultValue
self.min = min
self.max = max
self.value = defaultValue
}
}
typealias FloatType = BaseType<CGFloat>
typealias IntType = BaseType<Int>
}
extension AdjustmentTypes {
static let Brightness = AdjustmentTypes.FloatType(name: "Brightness", defaultValue: 0, min: 0, max: 1)
static let WhiteBalance = AdjustmentTypes.IntType(name: "White Balance", defaultValue: 4000, min: 3000, max: 7000)
}
class AdjustmentsSet {
private var adjustmentsSet: Set<AnyHashable> = []
func insert<T>(_ adjustment: AdjustmentTypes.BaseType<T>) {
adjustmentsSet.insert(adjustment)
}
func remove<T>(_ adjustment: AdjustmentTypes.BaseType<T>) {
adjustmentsSet.remove(adjustment)
}
func contains<T>(_ adjustment: AdjustmentTypes.BaseType<T>) -> Bool {
return adjustmentsSet.contains(adjustment)
}
func get<T>(_ adjustment: AdjustmentTypes.BaseType<T>) -> AdjustmentTypes.BaseType<T>? {
return (adjustmentsSet.compactMap { $0 as? AdjustmentTypes.BaseType<T> }).first(where: { $0 == adjustment })
}
var count: Int { return adjustmentsSet.count }
}
var brightness = AdjustmentTypes.Brightness
brightness.value = 0.5
var adjustmentsSet = AdjustmentsSet()
adjustmentsSet.insert(brightness)
let retrievedBrightness = adjustmentsSet.get(AdjustmentTypes.Brightness)! // strongly typed!
retrievedBrightness.value // 0.5
AdjustmentTypes.Brightness.value // 0.0
Hope this helps, good luck with your project!