# data[].attributes.body
Utiliza la opción Expandir publicación para observar de mejor manera el contenido de cada publicación.
Al pasar el cursor sobre cada publicación aparacerán tres puntitos en la parte superior izquierda, clic y Expandir publicación.

# data[].attributes.body
La programación funcional es un estilo de programación que enfatiza la escritura de aplicaciones usando solo funciones puras y valores inmutables. Como escribió Alvin Alexander en Programación funcional simplificada, en lugar de usar esa descripción, puede ser útil decir que los programadores funcionales tienen un deseo extremadamente fuerte de ver su código como matemático: ver la combinación de sus funciones como una serie de ecuaciones algebraicas. En ese sentido, se podría decir que a los programadores funcionales les gusta pensar en sí mismos como matemáticos. Ese es el deseo que los impulsa a usar solo funciones puras y valores inmutables, porque eso es lo que se usa en álgebra y otras formas de matemáticas.

Tomado de https://docs.scala-lang.org/overviews/scala-book/functional-programming.html

# data[].attributes.body
Hay funciones que pueden tomar  funciones como parámetros y devolver funciones como resultado. Las funciones que hacen ambas cosas o alguna de ellas se conocen como funciones de orden superior.

Son una forma muy potente de resolver problemas y de pensar los programas que codificamos.

Se diferencias de las funciones de primer orden en que éstas actúan sobre tipos de datos simples pero no sobre otras funciones.

# data[].attributes.body
Supongamos que queremos obtener la suma de todos los valores comprendidos entre a y b. Podríamos escribir la función:

def sumBetween(a:Int, b:Int): Int =
   if (a > b) 0
   else a + sumBetween(a + 1, b)

En este ejemplo, sumBetween, toma los límites a y b como parámetros. Entonces miramos, si a es mayor que b no hay nada que sumar. Devolveríamos, pues, el único valor lógico en

este caso, cero. En caso contrario, devolveríamos a más la

llamada recursiva a sumBetween con a + 1 y b.
Este es un ejemplo de función de orden superior porque cumple al menos una condición para serlo, a saber, que devuelve una función como resultado.

Bien, ahora vamos a aumentar la dificultad y vamos a suponer que queremos sumar los cuadrados de los enteros entre a y b. A continuación tenemos la función:

def square(x: Int): Int = x * x

Esta función toma como parámetro un número y devuelve su cuadrado.
Ahora, así se vería la función para sumar los cuadrados:

def sumSqrBetween(a:Int, b:Int): Int =
   if (a > b) 0
   else square(a) + sumSqrBetween(a + 1, b)

La lógica es igual al ejemplo anterior, la función toma los valores límites a y b como parámetros. Compara si a es mayor a b y en ese caso devuelve 0, porque no hay nada que sumar. Y, en caso contrario devuelve el cuadrado de a más una llamada recursiva a sí mismo con a + 1 y b.
Y, como en en ejemplo anterior, también se trata de una función de orden superior porque devuelve como resultado una función.

# data[].attributes.body
Obtener la suma de los factoriales de todos los valores comprendidos entre a y b.

# data[].attributes.body
Bien, por último, vamos a escribir una función en donde recibamos como parámetro una función y devolvamos también como resultado otra función.
Supongamos que queremos obtener la suma de todos los valores comprendidos entre a y b, o de los cuadrados de los valores comprendidos entre a y b, o factoriales de los valores comprendidos entre a y b; todo en una sola función. Pues bien, para ello resulta muy potente usar funciones de orden superior. ¡Vamos a verlo!
Primero escribiremos tres funciones, una que nos devuelvan el mismo valor (para cuando queramos hacer una suma simple), otra el cuadrado de un número y otra el factorial de un valor.

def identical(x: Int): Int = x
def square(x: Int): Int = x * x
def factorial(x: Int): Int =
   if (x == 0) 1
   else x * factorial(x-1)

Ahora vamos a definir la función que recibe como parámetro una función, cualquiera de las que acabamos de crear, y los valores límites a y b.

def sum(f: Int => Int, a:Int, b:Int): Int =
   if (a > b) 0
   else f(a) + sum(f, a+1, b)

La función compara si a es mayor a b y en ese caso decuelve 0, porque la suma no puede hacerse. Caso contrario devuelve la llamada a la función correspondiente (identical, square o factorial) más la llamada recursiva a sí misma con los parámetros de la función en cuestión, a + 1 y b.
Así, por ejemplo podemos obtener la suma de los factoriales comprendidos entre 4 y 10.

scala> sum(factorial, 4, 10)
val res6: Int = 4037904

Ahora, si no queremos pasar directamente la función nosotros, podemos hacer otras funciones que lo hagan por nosotros, así:

def sumInts(a: Int, b: Int): Int = sum(identical, a, b)
def sumSqr(a: Int, b: Int): Int = sum(square, a, b)
def sumFact(a: Int, b: Int): Int = sum(factorial, a, b)