A modern programming language that makes developers happier.

kotlinlang

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>()```

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.

With your example, consider what happens when running:
```cache.invalidate&lt;Int&gt;()```
(spoiler: CCE)

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...

So I guess this is also problematic:
``` override suspend fun &lt;R&gt; invoke(
        name: String,
        type: KSerializer&lt;R&gt;,
        vararg params: Any,
        saveResultIf: (R) -&gt; Boolean,
        block: suspend () -&gt; R
    ): R {
...
            if (config?.nullPlaceholder != null &amp;&amp; result == config.nullPlaceholder)
                null as R
            else
                jsonParser.decodeFromString(type, result)
        }
    }```
...
````null as R```


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

No, this is fine, because `&lt;R&gt;` is a shorthand for `&lt;T : Any?&gt;` , so `null` is a legal value.

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

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

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
}```

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

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

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...)

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

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