Functions, closures and lambdas

fun price(base: Double, quantity: Int = 1, discount: Double = 0.0): Double =
    base * quantity * (1 - discount)

val a = price(3.5)                                    // 3.5
val b = price(base = 3.5, quantity = 4, discount = 0.1)  // 12.6

double price(double base, int quantity, double discount) {
    return base * quantity * (1 - discount);
}

double price(double base) {                           // Java has no defaults: overload instead
    return price(base, 1, 0);
}

double a = price(3.5);                                // 3.5
double b = price(3.5, 4, 0.1);                        // 12.6

function price(base: number, quantity = 1, discount = 0): number {
  return base * quantity * (1 - discount);
}

const a = price(3.5);                                 // 3.5
const b = price(3.5, 4, 0.1);                         // 12.6

val prices = listOf(12, 4, 30, 8)

val cheapFirst = prices.sortedBy { it }                // a lambda decides the order
val expensive = prices.filter { price -> price > 10 }  // and which items to keep

val isEven: (Int) -> Boolean = { it % 2 == 0 }         // a lambda stored in a constant
println(isEven(4))                                     // true

List<Integer> prices = List.of(12, 4, 30, 8);

List<Integer> cheapFirst = prices.stream().sorted((a, b) -> Integer.compare(a, b)).toList();
List<Integer> expensive = prices.stream().filter(price -> price > 10).toList();

Predicate<Integer> isEven = n -> n % 2 == 0;           // a lambda stored in a variable
System.out.println(isEven.test(4));                    // true

const prices = [12, 4, 30, 8];

const cheapFirst = [...prices].sort((a, b) => a - b);  // a function decides the order
const expensive = prices.filter((price) => price > 10); // and which items to keep

const isEven = (n: number): boolean => n % 2 === 0;    // a function stored in a constant
console.log(isEven(4));                                // true

fun makeCounter(): () -> Int {
    var count = 0
    return {
        count += 1               // uses and changes count from makeCounter
        count
    }
}

val next = makeCounter()
println("${next()} ${next()} ${next()}")   // 1 2 3

Supplier<Integer> makeCounter() {
    AtomicInteger count = new AtomicInteger();   // a local int couldn't be changed by the lambda
    return () -> count.incrementAndGet();
}

Supplier<Integer> next = makeCounter();
System.out.println(next.get() + " " + next.get() + " " + next.get());   // 1 2 3

function makeCounter(): () => number {
  let count = 0;
  return () => {
    count += 1;                  // uses and changes count from makeCounter
    return count;
  };
}

const next = makeCounter();
console.log(next(), next(), next());   // 1 2 3

fun loadAvatar(user: User, onLoaded: (Bitmap?) -> Unit) {
    // … calls onLoaded later, on another thread
}

loadAvatar(user) { bitmap ->
    avatarView.setImageBitmap(bitmap)        // uses the screen's view: keeps the screen alive
}

void loadAvatar(User user, Consumer<Bitmap> onLoaded) {
    // … calls onLoaded later, on another thread
}

loadAvatar(user, bitmap -> avatarView.setImageBitmap(bitmap));   // keeps the screen alive

function loadAvatar(user: User, onLoaded: (image: Blob | undefined) => void): void {
  fetch(user.avatarUrl).then((r) => r.blob()).then(onLoaded, () => onLoaded(undefined));
}

loadAvatar(user, (image) => {
  if (image) avatarImg.src = URL.createObjectURL(image);   // keeps avatarImg alive until called
});