Composición de Funciones en Programación Funcional

Clase 21 de 39 • Curso de Programación Funcional con Java SE

Resumen

¿Qué son las funciones de orden mayor?

Las funciones de orden mayor son una parte fascinante y esencial de la programación funcional. Este tipo de funciones puede tomar como parámetro otra función o devolver una función como resultado. También pueden darse ambos casos a la vez. Esto nos permite crear composiciones de funciones, donde podemos combinar múltiples funciones para realizar tareas más complejas.

¿Cómo se implementan las funciones de orden mayor en un ejemplo concreto?

Para ilustrar el poder de las funciones de orden mayor, iniciaremos creando una función para multiplicar un número. Supongamos que tenemos la siguiente función:

fun multiplicarPorTres(numero: Int): Int {
    return numero * 3
}

Esta función multiplicarPorTres toma un número y lo multiplica por tres. Es sencillo, sin embargo, podemos aprovechar el concepto de funciones de orden mayor para ampliar esta operación.

¿Cómo se combinan funciones utilizando composición?

La composición de funciones nos permite crear cadenas de funciones, donde el resultado de una función se convierte en la entrada de otra. Considera el siguiente ejemplo:

fun sumarUnoYMultiplicarPorTres(numero: Int): Int {
    return multiplicarPorTres(numero + 1)
}

En este caso, primero se agrega uno al número, y luego el resultado se multiplica por tres usando la función multiplicarPorTres. Así hemos creado una función combinada llamada sumarUnoYMultiplicarPorTres.

Para monitorear los pasos de ejecución, podemos imprimir mensajes en consola usando println:

fun sumarUnoYMultiplicarConDebug(numero: Int): Int {
    println("Agregando uno a $numero")
    val resultado = multiplicarPorTres(numero + 1)
    println("Multiplicando el resultado por tres")
    return resultado
}

Al ejecutar la función, se imprime cada paso, permitiendo un seguimiento detallado del proceso.

¿Es posible extender una función con pasos adicionales?

No solo podemos componer funciones para ejecutar pasos antes de una función, sino también realizar acciones adicionales después de su ejecución. Supongamos que deseamos elevar al cuadrado el resultado de sumarUnoYMultiplicarPorTres:

fun elevarAlCuadradoDespues(numero: Int): Int {
    val resultado = sumarUnoYMultiplicarPorTres(numero)
    println("Elevando $resultado al cuadrado")
    return resultado * resultado
}

Al usar esta función, primero se ejecuta la composición de funciones que hemos visto antes, y después se realiza la operación adicional de elevar al cuadrado.

Al ejecutar la función con un número, por ejemplo, 3, el orden de ejecución será:

Agregar uno a 3, obteniendo 4.
Multiplicar 4 por 3, obteniendo 12.
Finalmente, elevar 12 al cuadrado para obtener 144.

Este flujo demuestra cómo podemos usar funciones de orden mayor y composición para crear secuencias de operaciones complejas y personalizadas.

¿Por qué es importante el uso de funciones de orden mayor y composición?

Las funciones de orden mayor y la composición son fundamentales para escribir código más limpio y modular. Permiten:

Reutilización del código: Al desglosar lógicas complejas en pequeñas funciones, es fácil reutilizar y combinar estas funciones en diferentes contextos.
Mantenimiento y legibilidad del código: Las funciones claras y específicas hacen que el código sea más fácil de leer y mantener.
Escalabilidad: Podemos agregar o modificar funcionalidades sin reescribir todo el código.

Así, estas técnicas son herramientas poderosas para cualquier desarrollador que busque escribir un código eficiente y escalable. ¡Sigue explorando las posibilidades de las funciones de orden mayor y descubre cómo pueden transformar tu manera de programar!

Juan José Álvarez Pérez

student•

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)

DIANA MARCELA LOZADA GARCIA

student•

Te he venido siguiendo todas tus notas cada clase. Son las mejores! Muchas gracias!

Charbel Pinto

student•

Yo también amigo, simplificas y aclaras muy bien. Muchas gracias

Arturo Juárez Sánchez

student•

En matemáticas f o g = f(g(x) "f bolita g" :)

Mario Enrique Ascencio Garcia

student•

Exacto, esta es la mejor definición.

Sebastian Rodas

student•

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

Ossman O. C.

student•

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

g.compose(f) -> (g ∘ f)(x) = g[f(x)] que se lee como -> g compuesta f

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'

g.andThen(f) -> f[g(x)] que se lee como -> g y después f

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

Daniel Avila Cardenas

student•

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

William Schnaider Torres Bermon

student•

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&lt;Integer, Integer&gt; times2 = e -&gt; e * 2;

Function&lt;Integer, Integer&gt; squared = e -&gt; 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

Jean Nuñez

student•

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

Esteban Fleitas

student•

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

Sebastián Ospino

student•

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.

José Rodrigo Álvarez Herrera

student•

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

Diego Alfaro

student•

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.

Miguel Angel Martheyn Berbesi

student•

Y sigo aprendiendo, no sabia esto.

Elvis Salvatierra

student•

package com.platzi.functional._11_composition;

import java.util.function.Function;

public class MathOperation2 {
    public static void main(String[] args) {
        Function<Integer,Integer>  multiplyTree = x -> {
            int result = x * 3;
            System.out.println("Resultado:"+ x + "\nMultiplicado  x 3 = " + result);
            return result;
        };
        Function<Integer,Integer> ADDone =
                multiplyTree.compose(y -> {
                 System.out.println("le agrego 1 a: " + y );
                 return y +1;
                });
      ADDone.apply(5);
    }
}

ANDRES ALFONSO MIRA MEJIA

student•

✅

Mayk Edison Perez Arzapalo

student•

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

Mayk Edison Perez Arzapalo

student•

Vengo del futuro xD.

Para esta linea de código.

System.out.println(times2.andThen(n-> n * 2).apply(4));

Se puede ejecutar un lambda dentro de andThen() porque primero se ejcuta times2.apply(4) retornando un dato tipo Integer y pasa a la lambda de andThen y se ejecuta sin problemas.

Para esta línea de código.

System.out.println(times2.compose(m-> m * m).apply(4))

Lo primero que se ejecuta es la lambda dentro de compose con apply(4), como se ejecuta primero, el parametro que toma “m” que se ingreso por apply(4) java lo toma como un int (dato primitivo) y por definición una función lambda solo trabaja con Objetos y para el caso de recibir un entero sería con Integer. Entonces la solución sería indicar el tipo de dato para “m”, de tipo Integer.

System.out.println(times2.compose((Integer m)-> m * m).apply(4));

Omar Juarez

student•

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.

Rodrigo Andrés Moreno Pertúz

student•

amo Java

mario fernando robayo restrepo

student•

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

Juan Diego Mamani

student•

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

Luis Fernando Zarazua Aguilar

student•

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