Función de trampolín ES6

En este artículo, intentaremos comprender todos y cada uno de los aspectos asociados con la función Trampoline en ES6 de la manera más detallada posible. Primero entendamos lo que realmente salió mal al trabajar con Recursion , luego entendamos el concepto de Tail Recursion y luego entenderemos cuál es la necesidad exacta de introducir otra función llamada función Trampolín en ES6.

¿Qué salió mal con la recursividad?

La recursividad es el fenómeno o un proceso en el que calculamos cualquier valor de resultado a través de la misma función pero haciendo varias llamadas a funciones diferentes que son administradas por/bajo la estructura de datos de Stack. La recursividad en realidad hace que el código sea más simple y para valores más grandes en realidad resuelve el resultado pieza por pieza (es decir, valor por valor).

Ejemplo: veamos el siguiente fragmento de código para comprender la recursividad de una manera mucho más rápida e ineficiente.

let sumCalculation = (num) => {
  let sum = 0;
  return num === 0 ? sum : num + sum + sumCalculation(num - 1);
};
  
console.log(sumCalculation(5));
console.log(sumCalculation(13));

Producción:

15
91

Ejemplo: El fragmento que se muestra a continuación ilustra la ejecución del código recursivo que se muestra arriba.

sumCalculation(5){
    sum = 5
        sumCalculation(4) {
            sum = 5 + 4 
                sumCalculation(3){
                    sum = 5 + 4 + 3
                        sumCalculation(2){
                            sum = 5 + 4 + 3 + 2
                                sumCalculation(1){
                                    sum = sum = 5 + 4 + 3 + 2 + 1
                                        sumCalculation(0){
                                            // Returns sum = 15
                                            // Exist all function calls
                                        }
                                }
                        }
                }
        }
}

Ahora, como se ilustra arriba, se realizarían tantas llamadas a funciones y, por lo tanto, para un tamaño de entrada más grande, la salida de la consola podría aparecer como «Error de rango: se excedió el tamaño máximo de la pila de llamadas».

Ahora, para eliminar este error, entra en escena un concepto importante que es la Recursión de Cola (que se explica a continuación).

Recursión de cola: este es el fenómeno o proceso, que es diferente de la recursión regular, en el que en lugar de pasar una función como operando, pasamos el resultado cambiante en el siguiente paso recursivo. Este proceso en particular ayuda a evitar el desbordamiento de la pila, pero hay un problema más asociado con él que se describirá en la última parte de esta sección.

Ejemplo: el siguiente fragmento de código aclarará las cosas.

let sumCalculation = (num) => {
  let sumRecursiveCalculation = (result, num) => {
    return num === 1 ? result : sumRecursiveCalculation(result + num, num - 1);
  };
  return sumRecursiveCalculation(1, num);
};
  
console.log(sumCalculation(5));
console.log(sumCalculation(15));

Producción:

15
120

Ahora, aquí el problema que existe es que Tail Recursion no es reconocido por JavaScript, por lo tanto, para una entrada más grande, el error seguiría siendo el mismo, que es «Error de rango: existe un tamaño máximo de pila de llamadas», ya que JavaScript tratará Tail Recursion de manera similar. ya que trata la recursividad normal que, por lo tanto, se ejecuta bajo Call Stack.

Función de trampolín:

Esta función de trampolín es en realidad la función auxiliar que se utiliza para implementar Tail Recursion. En esto, convertimos todas las llamadas a funciones anidadas en el número secuencial de llamadas a funciones, lo que nos ayuda a evitar una condición de desbordamiento de pila. 

La función de trampolín básicamente envuelve la función recursiva en el bucle y, por lo tanto, llama a esa función recursiva pieza por pieza hasta que ya no quedan llamadas recursivas presentes.

Las funciones de trampolín son, sin embargo, el mejor ejemplo para mostrar la programación funcional en JavaScript. Esta función nos dará el resultado para valores mucho mayores que en las técnicas mencionadas anteriormente no se ha logrado (ni en la recursión regular ni en la recursión de cola).

Ejemplo: el siguiente fragmento de código aclarará las cosas sobre el funcionamiento de esta función de trampolín:

// Trampoline function Implementation
const trampoline_function = (func) => (...rest_arguments) => {
  let result = func(...rest_arguments);
  while (typeof result === 'function') {
    result = result();
  }
  return result;
};
  
// Sum Calculation Program Implementation
const sumCalculation = (num, sum = 0) => {
  return num === 0 ? sum : () => sumCalculation(num - 1, sum + num);
};
  
// Wrapping function in Trampoline function
// which is implemented above
const sumCalculate = trampoline_function(sumCalculation);
console.log(sumCalculate(5));
console.log(sumCalculate(1000000));

Producción:

15
500000500000