Explain how to use the 'with' and 'let' functions in Kotlin.

with and let are standard library functions in Kotlin designed for more convenient object handling, especially when performing multiple operations on the same object.

with

• with takes an object (receiver) and a lambda as arguments.
• Inside the lambda, this refers to the receiver object.
• It returns the result of the last expression in the lambda.

// Example of using with
class Person(var name: String, var age: Int)

fun main() {
    val person = Person("Alice", 30)

    val description = with(person) {
        // this refers to person
        this.age += 1 // can omit this
        "Name: $name, New age: $age" // this string is returned
    }

    println(description) // Output: Name: Alice, New age: 31
}

Used when multiple operations need to be performed on a single object without the need to return the object itself. Convenient for configuring objects.

let

• let is called on an object (receiver) as an extension function and takes a lambda as an argument.
• Inside the lambda, it (or a user-defined name) refers to the receiver object.
• It returns the result of the last expression in the lambda.

// Example of using let
fun main() {
    val name: String? = "Bob"

    val length = name?.let {
        // it refers to name
        println("The name is not null: $it")
        it.length // returns the length of the string
    }

    println("Length: $length") // Output: The name is not null: Bob, Length: 3

    val nullName: String? = null
    val lengthOfNull = nullName?.let {
        // This block will not be executed because nullName == null
        it.length
    }

    println("Length of null: $lengthOfNull") // Output: Length of null: null
}

Used when operations need to be performed on a non-null object (often in conjunction with the safe call operator ?.) or when a new scope with a local variable for the object needs to be introduced (it).

Key differences:

• Invocation method: with is called as a function, let as an extension function.
• Reference variable inside lambda: with uses this, let uses it (or a user-defined name).
• Primary purpose: with is mainly used for configuration, let is often used for operations on potentially null objects and creating local scopes.

	with	let
Call	Function: with(object) { ... }	Extension function: object.let { ... }
Reference	this	it (or user-defined name)
Returns	Result of the last expression in lambda	Result of the last expression in lambda
Main use	Configuring an object, grouping operations	Null check (?.let), local scope creation