Revert "quitando ejemplos no vistos en clase"

This reverts commit 8d3ed9a.

Author: MartinFiorde

modules/src/main/java/com/platzi/functional/_01_pure/PureFunctions.java

@@ -0,0 +1,75 @@
+package com.platzi.functional._01_pure;
+
+public class PureFunctions {
+    /**
+     * Aunque hoy dia conocemos a los metodos estaticos como metodos de clase o simplemente metodos estaticos,
+     * en realidad un metodo puede ser considerado o visto como una funcion.
+     * <p>
+     * Basandonos en nuestra definicion de funcion, sabemos que para cada X genera una Y. En este caso,
+     * nuestra "x" es en realidad el par (x, y) y nuestra "y" sera el resultado de sumarlas.
+     * <p>
+     * Habra algun cambio en el resultado si yo ejecuto 90 veces sum(3,5)?
+     * <p>
+     * La respuesta es: NO.
+     * <p>
+     * Una funcion pura no depende de estados exteriores (propiedades, objetos, variables
+     * externas a su definicion, etc.) ni ve afectado su resultado por agentes externos.
+     */
+    public static int sum(int x, int y) {
+        return x + y;
+    }
+
+
+    /**
+     * Imagina que la siguiente clase es parte de un sistema financiero
+     */
+    static class Person {
+        //Nos enfocaremos solo en esta propiedad por ahora…
+        private double balance;
+
+        public Person(double balance) {
+            this.balance = balance;
+        }
+
+        public double getBalance() {
+            return balance;
+        }
+
+        public void setBalance(double balance) {
+            this.balance = balance;
+        }
+    }
+
+    /**
+     * Teniendo esta funcion, se le puede considerar pura?
+     */
+    public static boolean hasAvailableFunds(double funds) {
+        return funds > 0.0;
+    }
+
+
+    /**
+     * La respuesta es: Si!
+     * <p>
+     * porque la funcion revisa unicamente si un numero es mayor a 0, no importa la referencia de donde vengan
+     * los fondos, mientras esos fondos sean menores o iguales a 0, la respuesta siempre sera false.
+     * <p>
+     * Por otro lado, cuando una persona consigue fondos en su cuenta, la funcion en realidad no ve ese cambio.
+     * Para la funcion la respuesta cambiara hasta que le den un nuevo valor a evaluar. La funcion no depende
+     * de la presencia de los datos en ningun lugar o de un contexto.
+     * <p>
+     * Mira el ejemplo abajo:
+     */
+    public static void main(String[] args) {
+        Person sinuhe = new Person(-20.00);
+        //False, Sinuhe esta endeudado hasta los dientes
+        System.out.println(hasAvailableFunds(sinuhe.getBalance()));
+
+        Person ricardo = new Person(1300.00);
+        //True, Ricardo tiene dinero disponible!
+        System.out.println(hasAvailableFunds(ricardo.getBalance()));
+
+        //La funcion es evaluada al momento y no depende de que objeto es quien la manda a invocar,
+        //es por ello que se considera pura.
+    }
+}

modules/src/main/java/com/platzi/functional/_02_sideeffects/SideEffects.java

@@ -0,0 +1,73 @@
+package com.platzi.functional._02_sideeffects;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+
+public class SideEffects {
+
+    /**
+     * Funcion impura, el resultado de ejecutarla puede ser observado desde fuera
+     * del codigo. Por ejemplo en una consola.
+     */
+    static void helloWorld() {
+        System.out.println("Hello World!");
+    }
+
+
+
+
+
+
+
+
+    
+    /**
+     * Funcion impura, depende de la existencia y el estado de un archivo,
+     * eso provoca que sea no determinista
+     * Que sucede si esta funcion se ejecuta en mi computadora y en tu computadora?
+     * - Podemos determinar la salida en ambos casos?
+     * - Como nos aseguramos que nadie mas este modificando el archivo?
+     */
+    static boolean containsMexico(File file) {
+        try (BufferedReader bfReader = new BufferedReader(new FileReader(file))) {
+            String line;
+            while ((line = bfReader.readLine()) != null) {
+                if (line.contains("Mexico")) {
+                    return true;
+                }
+            }
+        } catch (IOException ignored) {
+            return false;
+        }
+
+        return false;
+    }
+
+
+
+
+
+
+
+
+
+
+
+
+
+    /**
+     * Funcion impura. Aunque el codigo no esta implementado, con entender lo que hace
+     * sabemos que es no determinista y que no podemos garantizar los resultados para
+     * un cierto parametro
+     */
+    static String getLastNameForGivenName(String name) {
+        //Obtener una conexion a la Base de datos
+        //Ejecutar un query en la base de datos
+        //Revisar los resultados del query…
+        //retornar el valor del lastName o un valor por default en caso de ausencia
+        //...
+        return "";
+    }
+}