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

Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Entendiendo la composición de funciones

21/39
Recursos

Aportes 20

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

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.

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)