Não entendi muito bem a real utilidade do let
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: