Also

DATO IMPORTANTE SOBRE SCOPE FUNCTIONS

apply y also devuelve el objeto contexto directamente.
let, run, y with retorna el último valor de la lambda.

La Función also
La función also es otra función de alcance, cuyo objetivo es permitirte añadir acciones adicionales sobre un objeto, a través de una lambda regular como parámetro.

Su uso se traduce a «y también hacer lo siguiente con el objeto».

recibidor.also{
     accionesAdicionales(it)
}

La declaración de su firma es la siguiente:

inline fun <T> T.also(block: (T) -> Unit): T

Al igual que apply, also retorna al objeto recibidor T como resultado y es una función de extensión. Salvo que block es un tipo función regular y usaremos la refenrecia it para T.

Ejemplo Con La Función also
Para ejemplificar el uso de la función also{} podemos tomar como base el ejemplo que vimos en el tutorial de apply, donde inicializábamos un par de zapatos y luego obteníamos su detalle para imprimirlo.

data class Shoe(
    var size: Int = 38,
    var color: String = "Negro",
    var stock: Int = 10
)

fun main() {
    val newShoe = Shoe()

    val shoeDetail = newShoe.apply {
        size = 42
        color = "Rojo"
        stock = 25
    }.toString()

    print(shoeDetail)
}

En este caso podemos añadir la ejecución de print() como parte de la cadena de inicialización con la función also.

fun main() {
    val newShoe = Shoe().apply {
        size = 42
        color = "Rojo"
        stock = 25
    }.also {
        print(it)
    }
}

Debido a que apply retorna la nueva instancia del zapato, es posible encadenar la llamada de also, por lo que la variable newShoe recibe el contenido final y de paso se imprime el mensaje pasando al indicador it.

Todo en una misma cadena de bloques asociados a un contexto que mejora la legibilidad de nuestro código.

FUENTE:https://www.develou.com/funcion-also-en-kotlin/

Si quieren leer más sobre las scope functions, está la documentación de Kotlin: https://kotlinlang.org/docs/scope-functions.html

Por ejemplo, dice que usemos also cuando no queramos sobreescribir la referencia de this de un contexto exterior (el de la clase por ejemplo).

Código de la clase

fun main (args:Array<String>) {
    val moviles = mutableListOf("Samsung A50","Samsung A51","Samsung A52")
            .also { lista -> println("El valor original de la lista es $lista")
            }.asReversed()
    println(moviles)
}

fun main(args: Array<String>) {

		val numbers = mutableListOf("one", "two", "three")
    numbers
        .also { println("The list elements before adding new one: $it") }
        .add("four")

    println(numbers)
		
		// funcion asReversed() para voltear los elementos de la lista.
		val moviles = mutableListOf("Google Pixel 2XL", "Google Pixel 4A", "Hauwei Redmi 9", "Xiamo ni a3")
		.also {  
						lista -> println('El valor original de lista es $lista') 
					}.asReversed()

		println(moviles)
		
}

<fun main(args: Array<String>) {
    val moviles = mutableListOf("Google Pixel 2XL", "Google Pixel 4a", "Huawei Redmi 9", "Xiaomi mi a3").also{
        lista -> println("El valro original de la lista es $lista")
    }.asReversed()
    println(moviles)

}> 

fun main(args: Array<String>) {
    val moviles = mutableListOf("Google Pixel 2XL", "Google Pixel 4a", "Huawei Redmi 9", "Xiaomi mi a3").also{
        lista -> println("El valro original de la lista es $lista")
    }.asReversed()
    println(moviles)

}

Mis Notas de Scope Functions

// Scope Function = let, with, run, apply, also

    // let -> function execute the code only if the nullable variable is not null
    var name: String? = null
    name?.let {
        value -> println("El nombre no es nulo es $value")
    }
    name = "Manu"
    name?.let {
            value -> println("El nombre no es nulo es $value")
    }

    // with -> function give us direct access to the properties of a variable set as parameter
    val colors = listOf("Azul", "Amarillo", "Rojo")
    with(colors) {
        println("Los colores son: $this")
        println("cantidad: $size")
    }

    // run -> Execute operations after init a variable
    val mobiles = mutableListOf("Google Pixel 2XL", "Google Pixel 4a", "Huawaei Redmi 9", "Xiaomi mi a3")
        .run {
            removeIf { mobile -> mobile.contains("google", true)}
            this
        }
    println(mobiles)

    // apply -> very useful to work with safe cases and do not need to return the value with this (run needs that)
    val otherMobiles = mutableListOf("Xiaomi redmi note 7", "Google Pixel 4a", "Huawaei Redmi 9", "Xiaomi mi a3")
        .apply { removeIf { mobile -> mobile.contains("xiaomi", true) } }
    println(otherMobiles)

    val nullableColors: MutableList<String>? = mutableListOf("Amarillo", "Azul", "Rojo")
    nullableColors?.apply {
        println("Nuestros colores son $this")
        println("cantidad de colores es $size")
    }

    // also -> Allow us to obtain a variable then execute a code with that variable an return it to be use
    val appleDevices = mutableListOf("Apple Watch", "iMac", "iPhone", "HomePod", "Airpods", "iPad", "iPod", "MacBook")
        .also { list -> println("the original value of the list is $list") }
        .asReversed()
    println(appleDevices)

Es similar al uso de los flatMap en java 8