En matemáticas f o g = f(g(x) “f bolita g” 😃
Introducción a la programación Funcional
¿Qué es la Programación Funcional?
Entendiendo las partes de la programación funcional
¿Qué es una función en Java?
Funciones como ciudadanos de primera clase
Funciones puras
Entendiendo los efectos secundarios
Funciones de orden mayor
Funciones lambda
Inmutabilidad
Functional Programming en Java
Repositorio del curso
Configuración del entorno de trabajo
Revisando el paquete java.util.function: Function
Revisando el paquete java.util.function: Predicate
Revisando el paquete java.util.function: Consumer y Supplier
Revisando el paquete java.util.function: Operators y BiFunction
Entendiendo dos jugadores clave: SAM y FunctionalInterface
Operador de Referencia
Analizando la inferencia de tipos
Comprendiendo la sintaxis de las funciones lambda
Usando metodos default en nuestras interfaces
Dándole nombre a un viejo amigo: Chaining
Entendiendo la composición de funciones
Optional y Streams: Datos mas interesantes
La clase Optional
Entendiendo los Streams
¿Qué son los Stream listeners?
Operaciones y Collectors
Streams de tipo específico y Paralelismo
Operaciones Terminales
Operaciones Intermedias
Collectors
Todo junto: Proyecto Job-search
job-search: Un proyecto para encontrar trabajo
Vista rápida a un proyecto de Gradle
Revisando las opciones para nuestro CLI
Librerías adicionales para nuestro proyecto
Entendiendo la API de jobs
Diseñando las Funciones Constructoras de nuestro Proyecto
Agregando validaciones de datos
Diseñando las funciones de transformacion de datos
Creando flujos extras de transformación de Datos
Conclusiones
Un repaso a lo aprendido
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Aportes 26
Preguntas 0
En matemáticas f o g = f(g(x) “f bolita g” 😃
⠀
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:
<h3>g.compose(f) -> (g ∘ f)(x) = g[f(x)] que se lee como -> g compuesta f</h3>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’
<h3>g.andThen(f) -> f[g(x)] que se lee como -> g y después f</h3>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)
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?
o inicia sesión.