Não entendi muito bem a real utilidade do let

o LET, diferente do const pode variar...

Let é usado de forma análoga ao operador pipe de linguagens como F#, Erlang e Elixir, permitindo compor funções redirecionando a saída de uma à entrada da outra. Haskell possui uma outra notação para o mesmo fim, usando um ponto. Em Kotlin, dadas 3 funções, f, g e h, temos que f(g(h(x))) é o mesmo que h(x).let(::g).let(::f).

Observe que nem sempre é possível encadear as funções de forma tão direta, e precisamos de uma transformação intermediária. Nestas horas, usamos let associado a uma expressão lambda fazendo o papel de um adapter.

É particularmente útil, ainda que não se limite a, quando se faz uso de interfaces derivadas de Iterable. Outro uso comum é quando trabalhamos com tuplas, e precisamos fazer declarações desestruturantes.

private inline fun <T : Number, M : Number, R> template(
    whatIs: String,
    onValues: Iterable<T>,
    crossinline mapBy: (T) -> M,
    crossinline aggregate: (Iterable<M>) -> M,
    crossinline andThen: (M) -> R
): R = onValues.map(mapBy)
    .also { print("Dado x, soma dos elementos de $it, ") }
    .let(aggregate)
    .let(andThen)
    .also { println("$whatIs $it") }

fun main() {
    fun Iterable<Double>.alternating(): Iterable<Double> {
        tailrec fun weights(max: Int, index: Int = 0 , acc: List<Double> = listOf()): List<Double> =
            if (index >= max) acc else weights(max, index + 1, acc + (-1.0).pow(index))

        return zip(weights(count())).map { (value, signal) -> value * signal }
    }

    fun expr(a: Int, b: Int) = "$a^2 = $b"

    val str = (2 to 4).let { (value, square) -> expr(value, square) }

    println(str)

    template(
        "a raiz quadrada de x é",
        0..10,
        { it.toDouble().pow(2.0) },
        Iterable<Double>::sum,
        Math::sqrt
    )

    template(
        "a raiz quarta de x / 2 é",
        (0..10).map(Int::toDouble).alternating(),
        { it.pow(3.0) },
        Iterable<Double>::sum,
        { (it / 2.0).pow(.25) }
    )
}

A diferença das funções run, with, let, also e apply tem haver com o escopo e retorno. Para detalhes, recomendo:

https://medium.com/mobile-app-development-publication/mastering-kotlin-standard-functions-run-with-let-also-and-apply-9cd334b0ef84