Trick to Use Covariant (out) Type in Contravariant (in) Position in Kotlin

KotlinVarianceTrick.kt

sealed class Option<out A>(open val value: A?) {
    fun <B> fold(ifNone: () -> B, ifSome: (A) -> B): B =
        when (this) {
            is None -> ifNone()
            is Some -> ifSome(this.value)
        }
    
    // This doesn't compile because `out` type A is in `in` position
    fun getOrElseThatWontWork(default: () -> A): A =
        when (this) {
            is None -> default()
            is Some -> this.value
        }
}

data class None<A>: Option<A>(null)
data class Some<A>(override val value: A): Option<A>(value)

// But this works even though A is in `in` position here!
// 
// This is an inlined extension function with a reified type A with no variance restrictions on its definition.
// So we are free to use A in `in` position.

inline fun <reified A> Option<A>.getOrElse(crossinline default: () -> A): A = fold({ default() }, { a -> a })