Add concept tail-call-recursion (#751)

* add concept

* add exercise

* add some practice exercises

* generate exercise introj

* configlet format

Author: jiegillet

concepts/tail-call-recursion/.meta/config.json

@@ -0,0 +1,7 @@
+{
+  "blurb": "Learn how to optimize tail call recursion in Elm",
+  "authors": [
+    "jiegillet"
+  ],
+  "contributors": []
+}

concepts/tail-call-recursion/about.md

@@ -0,0 +1,64 @@
+# About
+
+A function is [tail-recursive][recursion-tc] if the _last_ thing executed by the function is a call to itself.
+
+Each time any function is called, a _stack frame_ with its local variables and arguments is put on top of [the function call stack][call-stack].
+When a function returns, the stack frame is removed from the stack.
+
+Tail-recursive functions allow for [tail call optimization][tail-call-optimization] (or tail call elimination).
+It's an optimization that allows reusing the last stack frame by the next function call when the previous function is guaranteed not to need it anymore.
+This mitigates concerns of overflowing the function call stack, which is a situation when there are so many frames on the function call stack that there isn't any memory left to create another one.
+
+## Tail Call Optimization in Elm
+
+Under some condition, the Elm compiler is able to automatically performs an a tail call optimization when compiling to JavaScript.
+
+The optimization can happen for a recursive function when the _last_ operation in a branch is done by calling the function itself in a simple function application.
+Let's look at some examples:
+
+```elm
+factorial : Int -> Int
+factorial n =
+  if n <= 1 then
+    n
+  else
+    n * factorial (n-1)
+```
+
+The implementation above is not tail recursive, because the last operation in the `else` branch is a multiplication `n *`.
+
+```elm
+factorial : Int -> Int
+factorial n =
+  factorialHelper n n
+
+factorialHelper : Int -> Int -> Int
+factorialHelper n resultSoFar =
+  if n <= 1 then
+    resultSoFar
+  else
+    factorialHelper (n-1) (n * resultSoFar)
+```
+
+The implementation above is tail recursive and will be optimized, because the last operation in the `else` branch is `factorialHelper` calling itself.
+This would not be possible for a function with the type signature `Int -> Int`, and in practice tail call optimization is often achieved by defining helper functions.
+
+## Edge cases
+
+In some cases, the compiler is not able to optimize recursive functions, let's look at some examples.
+
+While `f x = f (x - 1)` is tail call recursive, `f x = (x - 1) |> f` is not, because the function application `|>` is the last operation and is considered separate from `f`.
+Similarly, functions ending with boolean conditions `f x = x > 0 || f (x - 1)` are not tail recursive.
+
+The function `f x = if f (x - 1) then 1 else 0` is not tail recursive, because the expression in the `if` is not considered to be a branch.
+Similarly, a recursive call in a `case` statement would not be optimized either.
+
+The function `f x = let y = f (x - 1) in y`, is not tail recursive because it calls itself in a `let` statement, which is not considered to be a branch.
+However, in `f x = let g x = g (x - 1) in g x` the function `g` it tail recursive and will be optimized even though it's defined in a `let` statement.
+
+The function `f x = if x > 0 then f (x + 1) else 1 + f x` will be _partially_ optimized: the `then` branch can be optimized but the `else` branch cannot.
+Partial optimization is the best that can be achieved in some situations, such as traversing tree-like structures or defining co-recursive functions.
+
+[recursion-tc]: https://en.wikipedia.org/wiki/Tail_call
+[call-stack]: https://en.wikipedia.org/wiki/Call_stack
+[tail-call-optimization]: https://jfmengels.net/tail-call-optimization/

concepts/tail-call-recursion/introduction.md

@@ -0,0 +1,47 @@
+# Introduction
+
+A function is [tail-recursive][recursion-tc] if the _last_ thing executed by the function is a call to itself.
+
+Each time any function is called, a _stack frame_ with its local variables and arguments is put on top of [the function call stack][call-stack].
+When a function returns, the stack frame is removed from the stack.
+
+Tail-recursive functions allow for [tail call optimization][tail-call-optimization] (or tail call elimination).
+It's an optimization that allows reusing the last stack frame by the next function call when the previous function is guaranteed not to need it anymore.
+This mitigates concerns of overflowing the function call stack, which is a situation when there are so many frames on the function call stack that there isn't any memory left to create another one.
+
+## Tail Call Optimization in Elm
+
+Under some condition, the Elm compiler is able to automatically performs an a tail call optimization when compiling to JavaScript.
+
+The optimization can happen for a recursive function when the _last_ operation in a branch is done by calling the function itself in a simple function application.
+Let's look at some examples:
+
+```elm
+factorial : Int -> Int
+factorial n =
+  if n <= 1 then
+    n
+  else
+    n * factorial (n-1)
+```
+
+The implementation above is not tail recursive, because the last operation in the `else` branch is a multiplication `n *`.
+
+```elm
+factorial : Int -> Int
+factorial n =
+  factorialHelper n n
+
+factorialHelper : Int -> Int -> Int
+factorialHelper n resultSoFar =
+  if n <= 1 then
+    resultSoFar
+  else
+    factorialHelper (n-1) (n * resultSoFar)
+```
+
+The implementation above is tail recursive and will be optimized, because the last operation in the `else` branch is `factorialHelper` calling itself.
+This would not be possible for a function with the type signature `Int -> Int`, and in practice tail call optimization is often achieved by defining helper functions.
+
+[recursion-tc]: https://en.wikipedia.org/wiki/Tail_call
+[call-stack]: https://en.wikipedia.org/wiki/Call_stack

concepts/tail-call-recursion/links.json

@@ -0,0 +1,10 @@
+[
+  {
+    "url": "https://functional-programming-in-elm.netlify.app/recursion/tail-call-elimination.html",
+    "description": "Tail-Call Elimination explained by the creator of Elm"
+  },
+  {
+    "url": "https://jfmengels.net/tail-call-optimization/",
+    "description": "Detailed explanation of tail-call optimization in Elm"
+  }
+]

config.json

@@ -416,6 +416,20 @@
           "pattern-matching"
         ],
         "status": "beta"
+      },
+      {
+        "slug": "pipers-pie",
+        "name": "Piper's Pie",
+        "uuid": "1f54e219-3f76-4df8-996a-9308ce9d6458",
+        "concepts": [
+          "tail-call-recursion"
+        ],
+        "prerequisites": [
+          "let",
+          "recursion",
+          "basics-2"
+        ],
+        "status": "beta"
       }
     ],
     "practice": [
@@ -881,9 +895,11 @@
         "name": "Collatz Conjecture",
         "uuid": "0edd5fa2-f1db-4572-9810-55a2c6729753",
         "practices": [
-          "result"
+          "tail-call-recursion"
         ],
         "prerequisites": [
+          "recursion",
+          "tail-call-recursion",
           "result",
           "booleans"
         ],
@@ -894,11 +910,12 @@
         "name": "Binary Search",
         "uuid": "5c859d35-f2fe-455c-a7d7-df9398355403",
         "practices": [
-          "comparison",
+          "tail-call-recursion",
           "array"
         ],
         "prerequisites": [
           "comparison",
+          "tail-call-recursion",
           "array",
           "maybe"
         ],
@@ -929,17 +946,16 @@
         "name": "Pascal's Triangle",
         "uuid": "b7e456d7-e383-4e03-9126-c9b57c1287e1",
         "practices": [
-          "lists"
+          "tail-call-recursion"
         ],
         "prerequisites": [
           "lists",
           "booleans",
-          "let"
+          "let",
+          "recursion",
+          "tail-call-recursion"
         ],
-        "difficulty": 4,
-        "topics": [
-          "recursion"
-        ]
+        "difficulty": 4
       },
       {
         "slug": "roman-numerals",
@@ -1750,6 +1766,11 @@
       "uuid": "651a2eba-41d2-4b80-a861-7291536cad5c",
       "slug": "recursion",
       "name": "Recursion"
+    },
+    {
+      "uuid": "edf8ab39-7e08-4dec-ae86-f1a14112e022",
+      "slug": "tail-call-recursion",
+      "name": "Tail Call Recursion"
     }
   ],
   "key_features": [

exercises/concept/pipers-pie/.docs/hints.md

@@ -0,0 +1,28 @@
+# Hints
+
+## General
+
+- You can read about [Tail Call Elimination][tail-call-elimination] from the creator of Elm
+- In tail recursive functions, the _last_ operation in a branch calls itself in a simple function application
+- You will need to define tail recursive helper functions
+
+## 1. Factorial
+
+- You will need to define a tail recursive helper function
+- The factorial of 0 is 1
+- Use recursion to reduce `n` to its base case, while keeping track of the product
+
+## 2. Double Factorial
+
+- You will need to define a tail recursive helper function
+- The double factorial of 0 is 1
+- The double factorial of 1 is 1
+- Use recursion to reduce `n`, two by two, to its base case, while keeping track of the product
+
+## 3. Newton/Euler Convergence Transformation
+
+- You will need to define a tail recursive helper function
+- Using `factorial` and `doubleFactorial` directly is discouraged, as it is not the most efficient way to create the terms of the sum
+- You can pass as many arguments as you wish to the helper function
+
+[tail-call-elimination]: https://functional-programming-in-elm.netlify.app/recursion/tail-call-elimination.html

exercises/concept/pipers-pie/.docs/instructions.md

@@ -0,0 +1,83 @@
+# Instructions
+
+Piper is an avid pie baker.
+
+No one knows if she picked pie baking because of her name, or if she changed her name to match her hobby.
+At a glance, the latter doesn't seem very likely, but you see, Piper is absolutely fascinated by pies.
+She's always tinkering in the kitchen, tweaking her recipes, improving her craft, to the absolute delight of her friends.
+
+Her latest interest?
+Baking pies as circular as possible, to the point of mathematical perfection, with the help of her favorite number, you guessed it: π.
+
+Piper found a delightful formula to calculate π iteratively, the Newton/Euler Convergence Transformation:
+
+```
+π / 2 = sum for k from 0 to infinity of ( k! ) / ( 2 * k + 1 )!!
+```
+
+Help Piper bake her mathematically perfect pie by calculating π.
+
+## 1. Factorial
+
+Let's warm up first.
+The factorial operator, usually written `!`, is defined as
+
+```
+0! = 1
+n! = 1 * 2 * 3 * ... * n
+```
+
+Define the `factorial` function which will compute the factorial in a tail recursive manner.
+
+```elm
+factorial 4
+    -- 24
+```
+
+## 2. Double Factorial
+
+The double factorial operator, usually written `!!`, is defined as
+
+```
+0!! = 1
+n!! = 1 * 3 * 5 * ... * n (for odd n)
+n!! = 2 * 4 * 6 * ... * n (for even n)
+```
+
+Define the `doubleFactorial` function which will compute the factorial in a tail recursive manner.
+
+```elm
+factorial 5
+    -- 15
+factorial 6
+    -- 48
+```
+
+## 3. Newton/Euler Convergence Transformation
+
+Define the `pipersPi` function, which will approximate π using a set number of terms from the Newton/Euler Convergence Transformation formula in a tail recursive manner.
+
+```
+π / 2 = sum for k from 0 to infinity of ( k! ) / ( 2 * k + 1 )!!
+```
+
+Let's compute the first term together.
+For an upper limit of `0` (instead of infinity), we get:
+
+```
+π / 2 ≈ Sum for k from 0 to 0 of ( k! ) / ( 2 * k + 1 )!!
+π / 2 ≈ ( 0! ) / ( 2 * 0 + 1 )!!
+π / 2 ≈ 0! / 0!!
+π / 2 ≈ 1 / 1
+π / 2 ≈ 1
+π ≈ 2
+```
+
+Each extra term will improve the approximation.
+
+```elm
+pipersPi 0
+    -- 2.0
+pipersPi 1
+    -- 2.6666666
+```

exercises/concept/pipers-pie/.docs/introduction.md

@@ -0,0 +1,49 @@
+# Introduction
+
+## Tail Call Recursion
+
+A function is [tail-recursive][recursion-tc] if the _last_ thing executed by the function is a call to itself.
+
+Each time any function is called, a _stack frame_ with its local variables and arguments is put on top of [the function call stack][call-stack].
+When a function returns, the stack frame is removed from the stack.
+
+Tail-recursive functions allow for [tail call optimization][tail-call-optimization] (or tail call elimination).
+It's an optimization that allows reusing the last stack frame by the next function call when the previous function is guaranteed not to need it anymore.
+This mitigates concerns of overflowing the function call stack, which is a situation when there are so many frames on the function call stack that there isn't any memory left to create another one.
+
+### Tail Call Optimization in Elm
+
+Under some condition, the Elm compiler is able to automatically performs an a tail call optimization when compiling to JavaScript.
+
+The optimization can happen for a recursive function when the _last_ operation in a branch is done by calling the function itself in a simple function application.
+Let's look at some examples:
+
+```elm
+factorial : Int -> Int
+factorial n =
+  if n <= 1 then
+    n
+  else
+    n * factorial (n-1)
+```
+
+The implementation above is not tail recursive, because the last operation in the `else` branch is a multiplication `n *`.
+
+```elm
+factorial : Int -> Int
+factorial n =
+  factorialHelper n n
+
+factorialHelper : Int -> Int -> Int
+factorialHelper n resultSoFar =
+  if n <= 1 then
+    resultSoFar
+  else
+    factorialHelper (n-1) (n * resultSoFar)
+```
+
+The implementation above is tail recursive and will be optimized, because the last operation in the `else` branch is `factorialHelper` calling itself.
+This would not be possible for a function with the type signature `Int -> Int`, and in practice tail call optimization is often achieved by defining helper functions.
+
+[recursion-tc]: https://en.wikipedia.org/wiki/Tail_call
+[call-stack]: https://en.wikipedia.org/wiki/Call_stack

exercises/concept/pipers-pie/.docs/introduction.md.tpl

@@ -0,0 +1,3 @@
+# Introduction
+
+%{concept: tail-call-recursion}