정리하다 정리하다

Here is the definition of all 5 functions:

inline fun <T, R> with(receiver: T, block: T.() -> R): R {
    return receiver.block()
}
inline fun <T> T.also(block: (T) -> Unit): T {
    block(this)
    return this
}
inline fun <T> T.apply(block: T.() -> Unit): T {
    block()
    return this
}
inline fun <T, R> T.let(block: (T) -> R): R {
    return block(this)
}
inline fun <T, R> T.run(block: T.() -> R): R {
    return block()
}

using apply

val peter = Person().apply {
    // only access properties in apply block!
    name = "Peter"
    age = 18
}

The equivalent code without apply() would look like this:

val clark = Person()
clark.name = "Clark"
clark.age = 18

using also

class Book(author: Person) {
    val author = author.also {
      requireNotNull(it.age)
      print(it.name)
    }
}

The equivalent code without also() would look like this:

class Book(val author: Person) {
    init {
      requireNotNull(author.age)
      print(author.name)
    }
}

using let

getNullablePerson()?.let {
    // only executed when not-null
    promote(it)
}
val driversLicence: Licence? = getNullablePerson()?.let {
    // convert nullable person to nullable driversLicence
    licenceService.getDriversLicence(it) 
}
val person: Person = getPerson()
getPersonDao().let { dao -> 
    // scope of dao variable is limited to this block
    dao.insert(person)
}

The equivalent code without let() would look like this:

val person: Person? = getPromotablePerson()
if (person != null) {
  promote(person)
}
val driver: Person? = getDriver()
val driversLicence: Licence? = if (driver == null) null else
    licenceService.getDriversLicence(it)
val person: Person = getPerson()
val personDao: PersonDao = getPersonDao()
personDao.insert(person)

using with

val person: Person = getPerson()
with(person) {
    print(name)
    print(age)
}

The equivalent code without with() looks like this:

val person: Person = getPerson()
print(person.name)
print(person.age)

using run

val inserted: Boolean = run {
    val person: Person = getPerson()
    val personDao: PersonDao = getPersonDao()
    personDao.insert(person)
}
fun printAge(person: Person) = person.run {
    print(age)
}

The equivalent code without run() would look like:

val person: Person = getPerson()
val personDao: PersonDao = getPersonDao()
val inserted: Boolean = personDao.insert(person)
fun printAge(person: Person) = {
    print(person.age)
}

ref : medium.com/@fatihcoskun/kotlin-scoping-functions-apply-vs-with-let-also-run-816e4efb75f5