Move recursion lessons together

4 files changed, 0 insertions, 81 deletions

diff --git a/src/content/chapter1_functions/lesson01_recursion/code.gleam b/src/content/chapter1_functions/lesson01_recursion/code.gleam
deleted file mode 100644
index ee93a6f..0000000
--- a/src/content/chapter1_functions/lesson01_recursion/code.gleam
+++ /dev/null
@@ -1,17 +0,0 @@
-import gleam/io
-
-pub fn main() {
-  io.debug(factorial(5))
-  io.debug(factorial(7))
-}
-
-// A recursive functions that calculates factorial
-pub fn factorial(x: Int) -> Int {
-  case x {
-    // Base case
-    1 -> 1
-
-    // Recursive case
-    _ -> x * factorial(x - 1)
-  }
-}
diff --git a/src/content/chapter1_functions/lesson01_recursion/text.html b/src/content/chapter1_functions/lesson01_recursion/text.html
deleted file mode 100644
index f1585bb..0000000
--- a/src/content/chapter1_functions/lesson01_recursion/text.html
+++ /dev/null
@@ -1,20 +0,0 @@
-<p>
-  Gleam doesn't have loops, instead iteration is done through recursion, that is
-  through top-level functions calling themselves with different arguments.
-</p>
-<p>
-  A recursive function needs to have at least one <em>base case</em> and at
-  least one <em>recursive case</em>. A base case returns a value without calling
-  the function again. A recursive case calls the function again with different
-  inputs, looping again.
-</p>
-<p>
-  The Gleam standard library has functions for various common looping patterns,
-  some of which will be introduced in later lessons, however for more complex
-  loops manual recursion is often the clearest way to write it.
-</p>
-<p>
-  Recursion can seem daunting or unclear at first if you are more familiar with
-  languages that have special looping features, but stick with it! With time
-  it'll become just as familiar and comfortable as any other way of iterating.
-</p>
diff --git a/src/content/chapter1_functions/lesson02_tail_calls/code.gleam b/src/content/chapter1_functions/lesson02_tail_calls/code.gleam
deleted file mode 100644
index d823eec..0000000
--- a/src/content/chapter1_functions/lesson02_tail_calls/code.gleam
+++ /dev/null
@@ -1,21 +0,0 @@
-import gleam/io
-
-pub fn main() {
-  io.debug(factorial(5))
-  io.debug(factorial(7))
-}
-
-pub fn factorial(x: Int) -> Int {
-  // The public function calls the private tail recursive function
-  factorial_loop(x, 1)
-}
-
-fn factorial_loop(x: Int, accumulator: Int) -> Int {
-  case x {
-    1 -> accumulator
-
-    // The last thing this function does is call itself
-    // In the previous lesson the last thing it did was multiple two ints
-    _ -> factorial_loop(x - 1, accumulator * x)
-  }
-}
diff --git a/src/content/chapter1_functions/lesson02_tail_calls/text.html b/src/content/chapter1_functions/lesson02_tail_calls/text.html
deleted file mode 100644
index ec39cda..0000000
--- a/src/content/chapter1_functions/lesson02_tail_calls/text.html
+++ /dev/null
@@ -1,23 +0,0 @@
-<p>
-  When a function is called a new stack frame is created in memory to store the
-  arguments and local variables of the function. If lots of these frames are
-  created during recursion then the program would use a large amount of memory,
-  or even crash the program if some limit is hit.
-</p>
-<p>
-  To avoid this problem Gleam supports <em>tail call optimisation</em>, which
-  allows the compiler to reuse the stack frame for the current function if a
-  function call is the last thing the function does, removing the memory cost.
-</p>
-
-<p>
-  Unoptimised recursive functions can often be rewritten into tail call
-  optimised functions by using an accumulator. An accumulator is a variable that
-  is passed along in addition to the data, similar to a mutable variable in a
-  language with <code>while</code> loops.
-</p>
-<p>
-  Accumulators should be hidden away from the users of your code, they are
-  internal implementation details. To do this write a public function that calls
-  a recursive private function with the initial accumulator value.
-</p>