Why specializing a generic function explicitly is not allowed?

Question

In Swift, one should use type of parameters or return value to implicitly specialize a generic function. The problem is, when I call function like this:

func serialize<T>(continuation: GenericWithLongName<T, NSError> -> Void) -> Void 

I cannot just write

serialize<SomeType> {
    obj in 
    ...
}

It should be

serialize {
    (obj: GenericWithLongName<SomeType, NSError>) -> Void in
    ...
}

which looks painful.

It seems this "feature" exists for a long time. Is it a design decision? Is there any negative implication from allowing explicitly specialization?

And is there any way to make code above neat and clean without refactoring that generic class?

Answer 1

One way to "specialize" the function is by including the generic type as a function parameter:

func serialize<T>(
    t: T.Type, 
    continuation: GenericWithLongName<T, NSError> -> Void ) -> Void { }

Now you can "specialize" the function like this:

serialize(SomeType.self) { 
    obj in 
    ... 
}

I don't know the answer to why your requested feature is not available. I agree that the feature you recommend would be useful, but in the meantime this works just as well and is almost as concise.