I have: ```suspend fun <T> invalidate(block: suspend () -> T = { Unit as T }): T = cache.inv...

# getting-started

[dave08]

I have:

suspend fun <T> invalidate(block: suspend () -> T = { Unit as T }): T =
        cache.invalidate(key to emptyList(), block = block)

// when using this with the default block I need to provide type information... how can I omit it?
cache.invalidate<Unit>()

[CLOVIS]

Use an overload instead of a default value.

suspend fun <T> invalidate(block: suspend () -> T): T = …
suspend fun invalidate(): Unit = invalidate<Unit> {}

This is because { Unit as T } makes no sense: the caller decides what to use as T , so you cannot know if Unit is a legal value of the type they choose.

[CLOVIS]

With your example, consider what happens when running:

cache.invalidate<Int>()

(spoiler: CCE)

[dave08]

Yeah, thanks, I guess it doesn't really make sense, I was just half expecting that since the lambda is the only one using the T parameter and it returns Unit, that it would infer that T can only be Unit... but you're point is good -- since in the end the caller is supposed to decide...

[dave08]

So I guess this is also problematic:

override suspend fun <R> invoke(
        name: String,
        type: KSerializer<R>,
        vararg params: Any,
        saveResultIf: (R) -> Boolean,
        block: suspend () -> R
    ): R {
...
            if (config?.nullPlaceholder != null && result == config.nullPlaceholder)
                null as R
            else
                jsonParser.decodeFromString(type, result)
        }
    }

...

`null as R

[dave08]

But there I can't even use an override... the full code is here: https://github.com/dave08/kacheable/blob/66d4ddf99c3e6fe9abb6fcc7d974f0719fe21340/[…]re/src/main/kotlin/com/github/dave08/kacheable/KacheableImpl.kt

[CLOVIS]

No, this is fine, because <R> is a shorthand for <T : Any?> , so null is a legal value.

[CLOVIS]

Wait no

[CLOVIS]

No it's not, the user could decide to call it with Int , so null would be forbidden

[dave08]

So what could I do there?

[CLOVIS]

Either you return R? , so null is always allowed even if the user used Int

[dave08]

Yeah, well my problem is that the user might want to use it like this:

fun someComputation(...): Foo = cache("some-cache") {
  ... this won't return a null, because it'll only cache computation results which will always not be null in this case
}

[dave08]

I will only have a null there if the result of the computation can have a null

[dave08]

But if not, it will never return null either...

[dave08]

So the cast is logical, and I guess there's no real type-safe way out of this except for your previous TypedKacheable proposition (I'm currently working on... but the default will still be this version that's not typed...)

[dave08]

I guess for invalidate at least, it's a good idea to provide an overload, but for this one I'm not sure.

[dave08]

Thanks a lot for the explanation, at least now I'm much more conscious of what I'm doing in this...!