Entendiendo la composición de funciones

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

Composición de funciones

⠀
La composición de funciones consta en crear dos o más funciones y asignarlas de forma tal que el resultado de una sea tomado como parámetro de otra. Esto sólo es válido con funciones que reciban un solo parámetro, pero la cadena puede tener tantas funciones como sea necesario.
⠀
Por ejemplo, tomando como base las funciones porTres y masUno, es posible componer la función masUnoYPorTres la cual equivale a llamar la función masUno y al resultado aplicarle porTres. Para ello basta con usar el método compose sobre la segunda función, y pasar por parámetro la primera.

Function<Integer, Integer> porTres = x -> x * 3;
Function<Integer, Integer> masUno = x -> x + 1;

Function<Integer, Integer> masUnoYPorTres = porTres.compose(masUno);

Integer resultado = masUnoYPorTres.apply(2); // resultado valdrá 9, ya que ((2 + 1) * 3)

Ya que el orden de las funciones en la composición es importante, también es de utilidad el método andThen.

/// ...
Function<Integer, Integer> porTresYMasUno = porTres.andThen(masUno);

Integer resultado = porTresYMasUno.apply(2); // resultado valdrá 7, ya que ((2 * 3) + 1)

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

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.

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

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

Hay que tener cierto cuidado con las funciones compuestas. En este caso, el rango de f tiene que ser compatible con el dominio de g, es decir, g debe poder aceptar como input válido todos los posibles valores de output de f. Si no es el caso, es necesario limitar el dominio de f para lograr este cometido.

Tanto compose como andThen son composiciones. Solo que andThen es la composición inversa retornada por compose.

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

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.

✅

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

Algo importante a considerar es que si se usa BiFunction solo se puede usar el método andThem, esto es porque no se puede poner el resultado de una función en una función que toma dos argumentos.

Para mejor referencia dejo una lectura.

amo Java

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 );
        }
    }

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)