Defining type of optional generic closure parameter

Question

I want to create an interface, that can be invoked with a generic and a non generic parameter used in the Result type.

The API would look like the following:

struct NonGenericParameter {}

func taskPreparation<T: Decodable>(onTypedComplete: ((Result<T, Error>) -> Void)?, 
                                   onTyplessComplete: ((Result<NonGenericParameter, Error>) -> Void)?) {
    // Do the neccessery preparation...
    
    if let onComplete = onTypedComplete {
        task(onComplete: onComplete)
    }
    
    if let onComplete = onTyplessComplete {
        task(onComplete: onComplete)
    }
}

func task<T: Decodable>(onComplete: @escaping (Result<T, Error>) -> Void) {
    // do task...
}

func task(onComplete: @escaping (Result<NonGenericParameter, Error>) -> Void) {
    // do task...
}

However, when i try to invoke the taskPreparation API, specifying onTyplessComplete as nil

taskPreparation(onTypedComplete: nil, 
                onTyplessComplete: { result in // Do something ... })

I receive the error

Generic parameter 'T' could not be inferred.

I understand, i have to specify the type of the generic parameter. I have tried to create a dummy decodable parameter, and pass it to the closure.

struct DummyDecodable: Decodable {}
taskPreparation(onTypedComplete: { (result: Result<DummyDecodable, Error>) in },
                onTyplessComplete: { result in // Do something ... })

But obviously, in this case the onTypedComplete closure is not nil .

Does someone have an idea how could I specify a nil closure and satisfy the type inference too?

Answer 1

You would still need the DummyDecodable for this, which is kind of ugly, but at least you are passing a nil value:

Simply pass ((Result<DummyDecodable, Error>) -> Void)?.none . nil is in fact just a syntactic sugar for Optional<WhateverType>.none .

struct DummyDecodable: Decodable {}
taskPreparation(onTypedComplete: ((Result<DummyDecodable, Error>) -> Void)?.none,
                onTyplessComplete: { result in /* Do something ...*/ })