Lorsque vous souhaitez créer un objet à l'aide d'une expression lambda tout en définissant un nouveau type qui fonctionne comme une fonction.

Contexte

En Java, un objet d'interface (= interface fonctionnelle) qui n'a qu'une seule méthode abstraite peut être créé par une expression lambda.

@FunctionalInterface
interface Composable {
    int apply(int v);

    default Composable compose(Composable other) {
        return v -> { return this.apply(other.apply(v)); };
    }
}

class Main {
    public static void main(String[] args) {
        Composable f = v -> { return v + 2; };
        Composable g = v -> { return v * 2; };
        System.out.println(f.compose(g).apply(2));
    }
}

Kotlin fournit également des expressions lambda et des fonctions anonymes que vous pouvez utiliser pour créer des objets fonctionnels. Cependant, cela sert uniquement à créer un objet fonction, et il n'est pas possible de créer quelque chose comme une fonction, par exemple, un objet d'interface qui hérite d'un type de fonction. Par conséquent, le code suivant entraînera une erreur de compilation.

interface Composable {
    fun apply(v: Int): Int

    fun compose(other: Composable): Composable = { this.apply(other.apply(it)) }
}

fun main(args: Array<String>) {
    val f: Composable = { it + 2 }
    val g: Composable = { it * 2 }
    println(f.compose(g).apply(2))
}

au lieu de

object : Composable {
    override fun apply(v: Int): Int { ... }
}

Il est difficile de l'écrire un par un.

Méthode

Définit une fonction qui prend une fonction et renvoie une interface. Le traitement proprement dit est délégué à la fonction reçue.

interface Composable {
    fun apply(v: Int): Int

    fun compose(other: Composable): Composable = composable { this.apply(other.apply(it)) }
}

fun composable(f: (Int) -> Int) = object : Composable {
    override fun apply(v: Int): Int = f(v)
}

fun main(args: Array<String>) {
    val f = composable { it + 2 }
    val g = composable { it * 2 }
    println(f.compose(g).apply(2))
}

Imiter l'interface fonctionnelle de Java avec Kotlin

Contexte

Méthode