Introducci贸n a la programaci贸n Funcional

1

驴Qu茅 es la Programaci贸n Funcional?

Entendiendo las partes de la programaci贸n funcional

2

驴Qu茅 es una funci贸n en Java?

3

Funciones como ciudadanos de primera clase

4

Funciones puras

5

Entendiendo los efectos secundarios

6

Funciones de orden mayor

7

Funciones lambda

8

Inmutabilidad

Functional Programming en Java

9

Repositorio del curso

10

Configuraci贸n del entorno de trabajo

11

Revisando el paquete java.util.function: Function

12

Revisando el paquete java.util.function: Predicate

13

Revisando el paquete java.util.function: Consumer y Supplier

14

Revisando el paquete java.util.function: Operators y BiFunction

15

Entendiendo dos jugadores clave: SAM y FunctionalInterface

16

Operador de Referencia

17

Analizando la inferencia de tipos

18

Comprendiendo la sintaxis de las funciones lambda

19

Usando metodos default en nuestras interfaces

20

D谩ndole nombre a un viejo amigo: Chaining

21

Entendiendo la composici贸n de funciones

Optional y Streams: Datos mas interesantes

22

La clase Optional

23

Entendiendo los Streams

24

驴Qu茅 son los Stream listeners?

25

Operaciones y Collectors

26

Streams de tipo espec铆fico y Paralelismo

27

Operaciones Terminales

28

Operaciones Intermedias

29

Collectors

Todo junto: Proyecto Job-search

30

job-search: Un proyecto para encontrar trabajo

31

Vista r谩pida a un proyecto de Gradle

32

Revisando las opciones para nuestro CLI

33

Librer铆as adicionales para nuestro proyecto

34

Entendiendo la API de jobs

35

Dise帽ando las Funciones Constructoras de nuestro Proyecto

36

Agregando validaciones de datos

37

Dise帽ando las funciones de transformacion de datos

38

Creando flujos extras de transformaci贸n de Datos

Conclusiones

39

Un repaso a lo aprendido

No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Compra acceso a todo Platzi por 1 a帽o

Antes: $249

Currency
$209/a帽o

Paga en 4 cuotas sin intereses

Paga en 4 cuotas sin intereses
Suscr铆bete

Termina en:

16D
13H
48M
41S

Entendiendo la composici贸n de funciones

21/39
Recursos

Aportes 26

Preguntas 0

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

En matem谩ticas f o g = f(g(x) 鈥渇 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:

<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 鈥榶 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鈥檚 first define two simple functions - times2 and squared.

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

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

Next, let鈥檚 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 鈥淎ndThen鈥 y declarar la funci贸n lambda de manera directa no tenemos problemas y el programa corre normal pero cuando queremos hacer esto con 鈥渃ompose鈥 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)