wip(ch3): Rewrite of description of functions

Author: oraqlle

src/ch03-common-concepts/functions.md

@@ -1,13 +1,8 @@
 # Functions
 
-```admonish warning
-🚧 Page Under Construction! 🏗️
-```
-
 Functions are fundamental to programming as they allow us to write reusable pieces of
 code. We have already been using a function in the examples we have shown so far, that
-is the `main()` function which is called by our OS to start the program. We have also
-seen a function in `constexpr` example.
+is the `main()` function which is called by our OS to start the program.
 
 Functions are defined by introducing a type (or `auto`) followed by the functions name,
 a(n optional) comma-seperated list of parameters surrounded in parenthesis followed by
@@ -16,51 +11,46 @@ suffixing parenthesis to it.
 
 ```cpp
 $#include <iostream>
-// --snip--
-
-auto another_one() {
+$
+auto foo() -> void {
     std::cout << "Another one!\n";
+    return;
 }
 
 auto main() -> int {
     std::cout << "Main function!\n";
 
-    another_one();
+    foo();
+$
 $    return 0;
-// --snip--
 }
 ```
 
 ```admonish abstract
 A function must be declared before it can be used as the compiler has to know the
 function symbol (name + parameter and return types) exists however, it does not have to
-defined. Note that the return type must be explicitly stated so the return type can be
-deduced.
+defined.
 
 ~~~cpp
 $#include <iostream>
-// --snip--
-
+$
 // declaration
-auto another_one() -> void;
+auto foo() -> void;
 
 auto main() -> int {
     std::cout << "Main function!\n";
 
-    another_one();
+    foo();
+$
 $    return 0;
-// --snip--
 }
 
 // definition
-auto another_one() -> void {
+auto foo() -> void {
     std::cout << "Another one!\n";
+    return;
 }
 ~~~
-This mechanism is a result of how C and thus C++ code was and still is compiled and
-linked together. It allows you to state a symbol existed in a public header (declare)
-but define it later in a source file which was usually built into a binary library with
-the linker then connected the calls to the function to the location in the library.
 ```
 
 ## Parameters
@@ -71,27 +61,22 @@ be specified, using the same syntax we saw to declare a variable
 
 ```cpp
 $#include <iostream>
-// --snip--
+$
 
-auto another_one(int const x, int const y) {
+auto foo(const int x, const int y) -> void {
     std::cout << "x: " << x << ", y: " << y << "\n";
+    return;
 }
 
 auto main() -> int {
     std::cout << "Main function!\n";
 
-    another_one(7, 6);
+    foo(7, 6);
+$
 $    return 0;
-// --snip--
 }
 ```
 
-```admonish tip
-As we saw in the `constexpr` example from the previous page, function parameters may also
-be declared with `auto` but this can sometimes make hard to know what the type of the
-parameter is supposed to be.
-```
-
 ## Return Values
 
 Functions can also return values using the `return` keyword. The type of the return value
@@ -103,9 +88,8 @@ like we've been using for `main()`. When a function doesn't a value, it's return
 $#include <iostream>
 $#include <sstream>
 $#include <string>
-// --snip--
-
-auto another_one(int const x, int const y) -> std::string {
+$
+auto foo(int const x, int const y) -> std::string {
     auto ss = std::stringstring{};
     ss << "x: " << x << ", y: " << y << "\n";
     return ss.str();
@@ -115,11 +99,17 @@ auto main() -> int {
     std::cout << "Main function!\n";
 
     std::cout << another_one(7, 6);
+$
 $    return 0;
-// --snip--
 }
 ```
 
+```admonish tip
+Previously, 
+The empty `return` statement can be omitted if the function
+```
+
+
 ## Overloading
 
 In C++ you can overload functions of the same name to have different implementations