Cannot get protocol with typealias to work in Swift - swift

Question

Just trying to build a proof-of-concept lib in Swift with the following code:
import Foundation
protocol Resolver {
typealias ResolvedType
func get() -> ResolvedType
}
class FunctionResolver<T>: Resolver {
typealias ResolvedType = T
private var _resolver: () -> ResolvedType
init(resolver: () -> ResolvedType) {
_resolver = resolver
}
func get() -> ResolvedType {
return _resolver()
}
}
func singleton<T, U: Resolver where U.ResolvedType == T>(instance: T) -> U {
return FunctionResolver({ () -> T in instance }) as U
}
class TestObject {
init() { }
}
let obj = TestObject()
let r = singleton(obj)
However the last line fails with:
playground466.swift:30:9: error: cannot convert the expression's type 'TestObject' to type 'Resolver'
let r = singleton(obj)
^~~~~~~~~
Why is Swift trying to convert obj to a Resolver? I am not quite sure what I am missing there. I think this should work since all the type information is available inside the singleton method.
Am I introducing some kind of loops in the inferrencing system? How can I fix this so the last line works as intended (a resolver that resolves to same instance of obj)?
I am on the latest Xcode available on the dev portal.
EDIT: I tried simplifying it, still does not work:
func singleton<T: Resolver>(instance: T.ResolvedType) -> T {
return FunctionResolver(resolver: { () -> T.ResolvedType in instance }) as T
}

Answer 1

The problem is that in this function:
func singleton<T, U>(instance: T) -> U {
return FunctionResolver({ () -> T in instance }) as U
}
U cannot be inferred as an input parameter - instead it's the type of the variable you assign its return value used to infer the type. If you write:
let r = singleton(obj)
you are not providing enough info to determine what U is. So you should explicitly specify its type:
let r: FunctionResolver<TestObject> = singleton(obj)
I know... the error message doesn't help much :) As a general rule, if it doesn't make sense, the problem is elsewhere.

Answer 2

Looks like you're pushing the type inference system past it's limits.
singleton() function is parametrised with generic type and returns a value of that generic type. There is never any information about what type T actually is.
The easiest fix, since Swift doesn't support explicitly providing values for generics in function, is to determine the return type.
let obj = TestObject()
let r : FunctionResolver = singleton(obj)
Works properly.
But what if you doesn't want to specify the exact type, just that r is Resolver?
Tough luck. Swift doesn't support that. Protocols with associated types can be used only as a generic constrains, as the compiler error states.