Functional Programming.md

Functional Programming

• Esta de moda (hipe)
• Inmutabilidad
• Funciones Puras
  • Con un mismo input va tener SIEMPRE el mismo output
  • No tiene efectos secundarios
    • Modificar cualquier variable o propiedad de un objeto
    • loggear en la consola
    • escribir en archivos o en internet
    • disparar cualquier proceso externo
    • llamar otra función con efectos secundarios
• No hay estados compartidos
  • No utiliza variables externas
  • Dentro y fuera de cualquier scope
  • No estados mutados
• Composición
  • Combinar funciones para devolver un valor
• Hacer pequñas funciones y reutilizarla
• First class and high order functions
• Recursión
• Fácil de Testear
• Opuesto a Programación orientada a objetos

Estado no Compartido

const x = { value: 1  }

const addOne = () => x.value += 1;

const mult2 = () => x.value *= 2;



mult2();
addOne();


console.log(x.value);


mult2();
addOne();
console.log(x.value);


/// functional Programming


const y = { value: 1 }

const addOne = (y) =>  Object.assign({}, y, { value : y.value + 1 });

const mult2 = (y) =>  Object.assign({}, y, { value : y.value * 2 });

mult2(y);
addOne(y);


console.log(addOne(mult2(y)));

Aplicación Parcial

const partial = (fn, arg1) => {
  return (arg2) => {
    return fn(arg1, arg2);
  };
};


const add = (a, b) => a + b;

const add2 = partial(add, 2);

const add5 = partial(add, 5);


console.log(add2(5));

Compocisión

const compositionAnd = (fn1, fn2) => (arg) => fn1(arg) && fn2(arg);

const isPositive = (x) => x >= 0;

const isEven = (x) => !(x % 2);

const isPositiveAndEven = compositionAnd(isPositive, isEven);

isPositiveAndEven(-4);


const addOne = (num) => num + 1;

const mult5 = (num) => num * 5;


const addOneAndMultBy5 = compose(addOne, mult5);

console.log(addOneAndMultBy5(3))

const doubleMap = (arr) => {
  const arr2 = [];
  for (let i = 0; i < arr.length; i++) {
    arr2.push(arr[i] * 2);
  } 
  return arr2;
}

const double = (n) => n * 2;

const doubleMap2 = (arr) => arr.map(double);



console.log(doubleMap2([3,4,5]))



const map = (arr, fn) => {
  const arr2  = [];
  arr.forEach((elem) => {
    arr2.push(fn(elem))
  });
  return arr2;
}

const concat = (...arrs) => {
  const arr2 = [];
  arrs.forEach(arr => {
    arr.forEach(elem => {
      arr2.push(elem);
    })
  })
  return arr2;
}



const users = [{
 hobbies: ['correr', 'ver pelis'],
}, {
  hobbies: ['dormir', 'programar'],
}, {
  hobbies: ['Jugar al fifa', 'comer'],
}
]

const compose = (fn1 , fn2) => (...args) => fn2(fn1(...args))



const concatMap = compose(map, (arrs) => concat(...arrs));

const hobbies = concatMap(users, (user) => user.hobbies);

console.log(hobbies);


const result = doubleMap(arr.filter(isPositiveAndEven)).reduce((memo, num) => num + memo);

console.log(result);