Entendiendo la composición de funciones

El método compose en notación matemática de funciones se denota como:

Que simplemente quiere decir, que el valor que me retorna f lo meto en g.
Miren la importancia del orden en la cuál se ejecuta.

Este orden es diferente con el ‘y después’

Supongo que esta es más lógica a la hora de trabajarla, pero hasta dónde sé no tiene un equivalente matemático.

En matemáticas f o g = f(g(x) “f bolita g” 😃

Esta clase abre muchas posibilidades, un gran poder lleva una gran responsabilidad! jejeje 😃

La generacion de la funciones y como se puede concatenar es muy productivo y simple de entender

De lo que me estaba perdiendo con JAVA!!Madre mia

Dado que BiFunction toma dos argumentos, solo ofrece la función andThen. No se puede poner el resultado de una función en una función que toma dos argumentos, de ahí la falta de la función de compose.

Y sigo aprendiendo, no sabia esto.

The difference between compose and andThen is the order they execute the functions. While the compose function executes the caller last and the parameter first, the andThen executes the caller first and the parameter last.
Let’s first define two simple functions - times2 and squared.

Function<Integer, Integer> times2 = e -> e * 2;

Function<Integer, Integer> squared = e -> e * e; 

Next, let’s combine them, using compose and andThen:

times2.compose(squared).apply(4);  
// Returns 32

times2.andThen(squared).apply(4);  
// Returns 64

Ejecutar una función antes de una función -> compose()
Ejecutar una función después de una función -> andThen()

System.out.println(add1.compose(mul3).apply(2));

Buenas forma de poder general flujos, en lugar de usar if anidados que validen la respuesta del paso anterior

A mi me sirvió relacionarlo con algebra.

public static void main(String[] args) {
        Function<Integer, Integer> multiplyBy3 = x -> {
            System.out.println("Multiplying " + x + " by 3"); // Executing second with compose.
            return x * 3;
        };

        // Compose function.
        // f(x) = x * 3, g(x) = x * 1
        // g(f(x)) = g(x+1) =  (x + 1) * 3 = 3x + 3
        Function<Integer, Integer> add1MultiplyBy3 = multiplyBy3.compose(x -> {
            System.out.println("Adding 1 to " + x); // Executing first
            return x + 1;
        });

        // Executing compose
        for (Integer x=0;x<10;x++){
            Integer y = add1MultiplyBy3.apply(x);
            System.out.println( x + ", " + y );
        }

        Function<Integer, Integer> multiplyBy5 = x -> {
            System.out.println("Multiplying " + x + " by 5"); // Executing first with andThen.
            return x * 5;
        };

        // And Then function.
        // f(x) = x * 5 , g(x) = x + 2
        // g(f(x)) = g(x * 5) = (x * 5) + 2 = 5x + 2
        Function<Integer, Integer> add1MultiplyBy5 = multiplyBy5.andThen(x -> {
            System.out.println("Adding 2 to " + x); // Executing second
            return x + 2;
        });

        // Executing andThen
        for (Integer x=0;x<10;x++){
            Integer y = add1MultiplyBy5.apply(x);
            System.out.println( x + ", " + y );
        }
    }

Al usar “AndThen” y declarar la función lambda de manera directa no tenemos problemas y el programa corre normal pero cuando queremos hacer esto con “compose” nos resulta error. Todavía no se el por qué pero ahí te lo dejo para que lo tengas en cuenta… xD

Estupenda clase, debemos tener en cuenta los métodos .compose() y .andThen() al momento de realizar composiciones de funciones, ya sea para alterarlas con otras funciones antes o después de ejecutarlas.

Funciones de orden mayor, es la que toma como parametro una funcion o regresa de resultado una funcion

Gracias

Genial 😃 sorprendido XD

public class MathOperations2 {
    public static void main(String[] args) {
        System.out.println(primerApellido.apply(""));
    }

    static Function<String, String> segundoNombre = x -> {
        System.out.println("Añadiendo el segundo nombre Adolfo a: {" + x + "}");
        return x + " Adolfo";
    };

    static Function<String, String> primerNombre = segundoNombre.compose(y -> {
        System.out.println("Añadiedo el primer nombre Gustavo a: {" + y + "}");
        return y + "Gustavo";
    });

    static Function<String, String> primerApellido = primerNombre.andThen(z -> {
        System.out.println("Añadiendo el primer apellido Cardona a : {" + z + "}");
        return z + " Cardona";
    });
}```

compose: Da prioridad a la lambda, posteriormente a la función, en la ejecución.
<->
andThen: Da prioridad a la función, posteriormente a la lambda, en la ejecución.

-compose: Permite agregar pasos antes de la ejecución de una función( La lambda se ejecuta antes de la función que llama a compose)
-andThen: Permite agregar pasos después de la ejecución de una función( La lambda se ejecuta después de la función que llama a andThen)