How lazy is converted into a delegated property


Kotlin has the nice functionality to declare a property to be lazily initialized using the delegate pattern and the lazy method:
val myLazyProperty: String by lazy {
    "lazyValue"
}
When looking at the declaration of the lazy function, the return-type is Lazy<T>:
public actual fun <T> lazy(initializer: () -> T): Lazy<T> = SynchronizedLazyImpl(initializer)

The Lazy interface is defined as:
⁄**
 * Represents a value with lazy initialization.
 *
 * To create an instance of [Lazy] use the [lazy] function.
 *⁄
public interface Lazy<out T> {
    ⁄**
     * Gets the lazily initialized value of the current Lazy instance.
     * Once the value was initialized it must not change during the rest of lifetime of this Lazy instance.
     *⁄
    public val value: T

    ⁄**
     * Returns `true` if a value for this Lazy instance has been already initialized, and `false` otherwise.
     * Once this function has returned `true` it stays `true` for the rest of lifetime of this Lazy instance.
     *⁄
    public fun isInitialized(): Boolean
}

Kotlin delegation is defined by implementing either the ReadOnlyProperty (for val) or the ReadWriteProperty interface (for var):
⁄**
 * Base interface that can be used for implementing property delegate of read-only properties.
 *
 * This is provided only for convenience; you don't have to extend this interface
 * as long as your property delegate has methods with the same signatures.
 *
 * @param R the type of object which owns the delegated property.
 * @param T the type of the property value.
 *⁄
public interface ReadOnlyProperty<in R, out T> {
    ⁄**
     * Returns the value of the property for the given object.
     * @param thisRef the object for which the value is requested.
     * @param property the metadata for the property.
     * @return the property value.
     *⁄
    public operator fun getValue(thisRef: R, property: KProperty<*>): T
}

⁄**
 * Base interface that can be used for implementing property delegate of read-write properties.
 *
 * This is provided only for convenience; you don't have to extend this interface
 * as long as your property delegate has methods with the same signatures.
 *
 * @param R the type of object which owns the delegated property.
 * @param T the type of the property value.
 *⁄
public interface ReadWriteProperty<in R, T> {
    ⁄**
     * Returns the value of the property for the given object.
     * @param thisRef the object for which the value is requested.
     * @param property the metadata for the property.
     * @return the property value.
     *⁄
    public operator fun getValue(thisRef: R, property: KProperty<*>): T

    ⁄**
     * Sets the value of the property for the given object.
     * @param thisRef the object for which the value is requested.
     * @param property the metadata for the property.
     * @param value the value to set.
     *⁄
    public operator fun setValue(thisRef: R, property: KProperty<*>, value: T)
}

This led me to the question, how the delegation can work, if the returned type of the lazy method is the  Lazy  interface, which does not implement any of the Property interfaces.
After a longer search than I actually would like to admit, I found the following one-liner extension function below the definition of the Lazy interface:
⁄**
 * An extension to delegate a read-only property of type [T] to an instance of [Lazy].
 *
 * This extension allows to use instances of Lazy for property delegation:
 * `val property: String by lazy { initializer }`
 *⁄
@kotlin.internal.InlineOnly
public inline operator fun <T> Lazy<T>.getValue(thisRef: Any?, property: KProperty<*>): T = value
This public one-liner extension function is the missing construct in the system, which is always applied when using 'by lazy': It implicitly implements the operator function for the ReadOnlyProperty interface, which connects the value field of the Lazy interface to the delegated property.
Another mystery solved.