Further improvements.

Author: yakutovicha

11_functional_programming.ipynb

@@ -68,25 +68,28 @@
     "\n",
     "- The [functools reference](https://docs.python.org/3/library/functools.html) from the Python standard library (text)\n",
     "- The [itertools reference](https://docs.python.org/3/library/itertools.html) from the Python standard library (text)\n",
-    "- [Functional programming howto](https://docs.python.org/3/howto/functional.html) from the Python documentation\n",
+    "- [Functional programming howto](https://docs.python.org/3/howto/functional.html) from the Python documentation (text)\n",
     "- A [good, but old introduction](https://www.youtube.com/watch?v=Ta1bAMOMFOI) of functional programming (video)\n",
     "- A [very high level](https://www.youtube.com/watch?v=Qa8IfEeBJqk) introduction of functional programming (video, advanced). Interesting, but not Python-specific as it refers to Haskell\n",
     "- A [general introduction on functional programming](https://www.youtube.com/watch?v=8z_bUIl_uPo). Very worth watching as it uses Python for the examples (video)\n",
-    "- [Principles of functional programming](https://dev.to/jamesrweb/principles-of-functional-programming-4b7c)\n",
+    "- [Principles of functional programming](https://dev.to/jamesrweb/principles-of-functional-programming-4b7c) (text)\n",
     "\n",
     "# Introduction\n",
     "Functional programming is an approach to programming where programs are built by composing and running functions that perform a series of transformations on data.\n",
     "This contrasts with the approach of *imperative programming*, where programs are written as a series of statements which modify the *state* of the computation environment.\n",
     "Typically, within functional programming, great focus is placed on *composition*, *immutability* and  *purity*.\n",
     "We are going to define these terms in more detail later.\n",
     "\n",
-    "# Why Functional Programming\n",
-    "Why do we choose functional programming? There are a series of advantages to this approach, namely:\n",
+    "# Why Functional Programming?\n",
+    "There are a series of advantages to this approach, namely:\n",
     "- **Debugging** and **testing** are easy: there are no surprises because every function only does one thing and does not affect any other piece of the program.\n",
-    "- **Parallelization** is trivial: functions are just small *boxes* that take one input and produce an output and do not depend on other parts of the code in an implicit manner through global variables or other shared pieces of state. Thus, it's easy to make several functions run in parallel.\n",
+    "- **Parallelization** is trivial: functions are just small *boxes* that take one input and produce an output and do not depend on other parts of the code in an implicit manner through global variables or other shared pieces of state.\n",
+    "  Thus, it's easy to make several functions run in parallel.\n",
     "\n",
     "# The basic principles of functional programming\n",
-    "All modern programming languages have *functions* (or methods, procedures, subroutines, subprograms); these are groups of program statements that perform a certain computation. Functions are defined once for the whole program and can be reused at will throughout the program whenever we need to perform the specific computation they are defined for. Using functions, we can split our code in smaller units that are only responsible for a specific *functionality*; this helps us structuring our code in a clean and understandable form. \n",
+    "All modern programming languages have *functions* (or methods, procedures, subroutines, subprograms); these are groups of program statements that perform a certain computation.\n",
+    "Functions are defined once for the whole program and can be reused at will throughout the program whenever we need to perform the specific computation they are defined for.\n",
+    "Using functions, we can split our code in smaller units that are only responsible for a specific *functionality*; this helps us structuring our code in a clean and understandable form. \n",
     "\n",
     "The main principles we use in functional programming are:\n",
     "\n",
@@ -119,9 +122,11 @@
     "In functional programming, we try to strive for *purity*. We want to define and use functions that only depend on their input, always return the same output for the same inputs and do not have any *side effects*, that is they do not indirectly affect any other part of our program.\n",
     "You can think of these functions as mathematical functions. \n",
     "Some examples of side effects are:\n",
-    "- printing to the program output\n",
-    "- reading or writing files\n",
-    "- generating and using random numbers\n",
+    "\n",
+    "- Printing to the program output\n",
+    "- Reading or writing files\n",
+    "- Generating and using random numbers\n",
+    "\n",
     "To better understand this concept, let us look at the function `my_first_pure_function` we defined below:"
    ]
   },
@@ -228,14 +233,16 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "As you see from the output, the function modified the list `x`. Therefore, this function is **not pure**. This leads us to the next principle, **immutability**."
+    "As you see from the output, the function modified the list `x`.\n",
+    "Therefore, this function is **not pure**.\n",
+    "This leads us to the next principle, **immutability**."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Example\n",
+    "### Exercise on pure functions\n",
     "\n",
     "<div class=\"alert alert-block alert-warning\">\n",
     "    <h4><b>Question</b></h4>\n",
@@ -270,8 +277,8 @@
     "    Returns:\n",
     "        - the appended list\n",
     "    \"\"\"\n",
-    "\n",
-    "    return"
+    "    array.append(new_element)\n",
+    "    return array"
    ]
   },
   {
@@ -370,7 +377,8 @@
     "tags": []
    },
    "source": [
-    "Another important aspect of functional programming is `composition`. This means that whenever we want to perform multiple operations, we avoid writing intermediate variables, especially so when these are in the global state of the program.\n",
+    "Another important aspect of functional programming is `composition`.\n",
+    "This means that whenever we want to perform multiple operations, we avoid writing intermediate variables, especially so when these are in the global state of the program.\n",
     "\n",
     "Instead, we design our functions in such a way that one function's output can be directly fed into the next function.\n",
     "\n",
@@ -418,7 +426,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Example\n",
+    "### Exercise on composition\n",
     "\n",
     "<div class=\"alert alert-block alert-warning\">\n",
     "    <h4><b>Question</b></h4>\n",
@@ -475,8 +483,7 @@
    },
    "source": [
     "Another important principle of functional programming is that **functions are values**.\n",
-    "In programming languages (like Python) that support a functional style, we can manipulate functions with the language, we can pass them around in a variable and even use functions as parameters for another function.\n",
-    "\n",
+    "In programming languages that support a functional style (like Python), functions are treated as first-class objects: we can assign them to variables, pass them as arguments to other functions, and manipulate them just like any other value.\n",
     "As an example, consider the function `function_caller`:"
    ]
   },
@@ -507,7 +514,8 @@
     }
    },
    "source": [
-    "This function takes a function `f` and its argument `args` as input and returns the result of calling `f`, while additionally printing a message on the standard output of the program. Let's try this out.\n",
+    "This function takes a function `f` and its argument `args` as input and returns the result of calling `f`, while additionally printing a message on the standard output of the program.\n",
+    "Let's try this out.\n",
     "To do so, we define a new function `add_five`:"
    ]
   },
@@ -558,10 +566,9 @@
    },
    "source": [
     "This example was a bit convoluted, but it shows that in Python we can use functions as values and even pass them as arguments to other functions.\n",
-    "\n",
     "This is useful in many cases; a typical example is numerical optimization, where we want to find the parameters of a function that minimize a certain criterion.\n",
-    "\n",
-    "Other than these specific use cases, there are some common *higher-order functions*, or functions that take other functions as parameters, that are common in most programming languages.We will look at a few of them in a following section."
+    "Other than these specific use cases, there are some common *higher-order functions*, or functions that take other functions as parameters, that are common in most programming languages.\n",
+    "We will look at a few of them in a following section."
    ]
   },
   {
@@ -582,7 +589,8 @@
     "tags": []
    },
    "source": [
-    "Another principle of functional programming is called [**referential transparency**](https://en.wikipedia.org/wiki/Referential_transparency). This complex-sounding name simply means that we can replace any expression with its value without changing the behavior of the program.\n",
+    "Another principle of functional programming is called [**referential transparency**](https://en.wikipedia.org/wiki/Referential_transparency).\n",
+    "This complex-sounding name simply means that we can replace any expression with its value without changing the behavior of the program.\n",
     "\n",
     "Consider the following Python code:"
    ]
@@ -613,7 +621,8 @@
     }
    },
    "source": [
-    "If `transparent_function` is referentially transparent, we can replace its value in the expression `y1 = transparent_function(1) + 5` and we obtain the same value. In other words, the value of `y` does not change if we execute it again, as shown in the code above: we have two expressions `y1` and `y2` that use the same code and because `x` is referentially transparent, their values are equal.\n",
+    "If `transparent_function` is referentially transparent, we can replace its value in the expression `y1 = transparent_function(1) + 5` and we obtain the same value.\n",
+    "In other words, the value of `y` does not change if we execute it again, as shown in the code above: we have two expressions `y1` and `y2` that use the same code and because `x` is referentially transparent, their values are equal.\n",
     "\n",
     "In this case, this is true because the value of `x` is simply 1 and is invariant.\n",
     "\n",
@@ -730,7 +739,8 @@
    "metadata": {},
    "source": [
     "In a language with stricter typing discipline like Java or C++, we would not even be able to compile our program.\n",
-    "Python lacks this strictness. However, there are tools like [mypy](https://mypy-lang.org/) that can be used to check the type consistency of Python programs without running them.\n",
+    "Python lacks this strictness.\n",
+    "However, there are tools like [mypy](https://mypy-lang.org/) that can be used to check the type consistency of Python programs without running them.\n",
     "\n",
     "We can achieve a similar effect using execution-time type checks.\n",
     "To facilitate our work, we first construct a `Person` class that encapsulates the attributes of a person.\n",
@@ -771,7 +781,8 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Because of the `isinstance` check in `__init_`, we aren't able to construct a `Person` if `age` is a string (type `str`). Likewise, we cannot call `greet_better` with a value other than a `Person`.\n"
+    "Because of the `isinstance` check in `__init_`, we aren't able to construct a `Person` if `age` is a string (type `str`).\n",
+    "Likewise, we cannot call `greet_better` with a value other than a `Person`.\n"
    ]
   },
   {
@@ -928,9 +939,10 @@
    },
    "source": [
     "## Filtering\n",
-    "Another basic higher order function is `filter`.\n",
+    "Another basic higher order function (HoF) is `filter`.\n",
     "As the name says, this function is used to filter an `iterable` using a *predicate function*.\n",
-    "This is a function that takes a value and returns `true` or `false`. With `true`, the current element is kept, with `false` it is discarded.\n",
+    "This is a function that takes a value and returns `true` or `false`.\n",
+    "With `true`, the current element is kept, with `false` it is discarded.\n",
     "We now try to write a predicate function that only keeps even numbers.\n",
     "\n",
     "<a name=\"filter-example\"></a>"
@@ -958,7 +970,8 @@
     }
    },
    "source": [
-    "Now we are ready to try `filter` using `is_even`. Because `filter` returns a `filter` object, we wrap it in `list` to directly see the result as a list:"
+    "Now we are ready to try `filter` using `is_even`.\n",
+    "Because `filter` returns a `filter` object, we wrap it in `list` to directly see the result as a list:"
    ]
   },
   {
@@ -984,14 +997,15 @@
    },
    "source": [
     "## Reducing\n",
-    "A third basic HoF is *reduction*.\n",
+    "The third basic HoF is *reduction*.\n",
     "This is a function that takes a function `f(x, y)` of two arguments and an iterable `it` and applies the function to every element in the iterable *cumulatively* to produce one value.\n",
     "It works in the following way:\n",
     "\n",
     "- The first argument of `f`, `x`, is the **current value of the accumulation**. In the beginning, this corresponds to the first element of `it`.\n",
     "- The second argument of `f`, `y`, is the **current element of the iterable**. In the beginning, this corresponds to the second element of `it`.\n",
     "\n",
-    "Because of this behaviour, this function is handy to compute sums or similar aggregations over a list. In Python, this function is available in the [`functools` module](https://docs.python.org/3/library/functools.html), part of Python's standard library.\n",
+    "Because of this behaviour, this function is handy to compute sums or similar aggregations over a list.\n",
+    "In Python, this function is available in the [`functools` module](https://docs.python.org/3/library/functools.html), part of Python's standard library.\n",
     "\n",
     "As an example of using `reduce`, consider the following snippet:\n"
    ]
@@ -1033,7 +1047,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Examples: Iteration and Mapping"
+    "### Exercises on Iteration and Mapping"
    ]
   },
   {
@@ -1282,7 +1296,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Example: Keeping only multiples of n\n",
+    "### Exercise: Keeping only multiples of `n`\n",
     "\n",
     "<div class=\"alert alert-block alert-warning\">\n",
     "    <h4><b>Question</b></h4>\n",
@@ -1321,7 +1335,7 @@
    "source": [
     "%%ipytest\n",
     "\n",
-    "def solution_multiples_of_n(l: \"list[int]\", k: int):\n",
+    "def solution_multiples_of_n(my_list: \"list[int]\", k: int) -> \"list[int]\":\n",
     "    \"\"\"A function that keeps only the multiples of k from a given list.\n",
     "\n",
     "    Args:\n",
@@ -1331,7 +1345,7 @@
     "        - the filtered list\n",
     "    \"\"\"\n",
     "\n",
-    "    return"
+    "    return [a for a in my_list if a % k == 0]"
    ]
   },
   {
@@ -1348,9 +1362,11 @@
     "\n",
     "Lets see some example of problems we can solve by using these tools.\n",
     "\n",
-    "- Iterating over two lists in parallel: \n",
-    "    consider the two lists `numbers = [1, 2, 3, 4, 5]` and `words = [\"one\", \"two\", \"three\" , \"four\", \"five\"]`. We want to produce a list of strings consisting of the content of `numbers` and `words`, such that each number in `numbers` corresponds to the right word in `words`. We can do this by using the `zip` buil-in function:\n",
-    "`zip` takes a number of `iterables` as an input and returns a list of tuples. The i-th element of this list is a tuple with the i-th element of each iterable, proceeding until the shortes iterable is exhausted. Using `zip`, we solve our problem like this:"
+    "- Iterating over two lists in parallel: consider the two lists `numbers = [1, 2, 3, 4, 5]` and `words = [\"one\", \"two\", \"three\" , \"four\", \"five\"]`.\n",
+    "  We want to produce a list of strings consisting of the content of `numbers` and `words`, such that each number in `numbers` corresponds to the right word in `words`.\n",
+    "  We can do this by using the `zip` buil-in function: `zip` takes a number of `iterables` as an input and returns a list of tuples.\n",
+    "  The `i-th` element of this list is a tuple with the `i-th` element of each iterable, proceeding until the shortes iterable is exhausted.\n",
+    "  Using `zip`, we solve our problem like this:"
    ]
   },
   {
@@ -1376,10 +1392,10 @@
     }
    },
    "source": [
-    "-  Producing permutations of elements.\n",
-    "    Suppose we have a list containing the letters `[\"A\", \"B\", \"C\", \"D\", \"E\"]` and we want to produce all four letter words from them.\n",
-    "    We can use   `itertools.permutations`.\n",
-    "    Once again, we wrap the operation in `list` to obtain a list as output:"
+    "- Producing permutations of elements.\n",
+    "  Suppose we have a list containing the letters `[\"A\", \"B\", \"C\", \"D\", \"E\"]` and we want to produce all four letter words from them.\n",
+    "  We can use `itertools.permutations`.\n",
+    "  Once again, we wrap the operation in `list` to obtain a list as output:"
    ]
   },
   {
@@ -1405,7 +1421,9 @@
     }
    },
    "source": [
-    "Another useful trick to know when working with lists is [**unpacking**](https://docs.python.org/3/tutorial/controlflow.html#tut-unpacking-arguments). In Python, we can extract elements from a list using the assignment statement.  For example, if we have a two-element list, we can write"
+    "- [**Unpacking**](https://docs.python.org/3/tutorial/controlflow.html#tut-unpacking-arguments) is another useful trick to know when working with lists. \n",
+    "  In Python, we can extract elements from a list using the assignment statement.\n",
+    "  For example, if we have a two-element list, we can write"
    ]
   },
   {
@@ -1795,7 +1813,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.3"
+   "version": "3.12.10"
   },
   "vscode": {
    "interpreter": {

tutorial/tests/test_11_functional_programming.py

@@ -16,8 +16,7 @@
 
 
 def reference_pure_function(array, new_element):
-    array.append(new_element)
-    return array
+    return array + [new_element]
 
 
 @pytest.mark.parametrize(
@@ -28,9 +27,9 @@ def reference_pure_function(array, new_element):
     ],
 )
 def test_pure_function(array, new_element, function_to_test):
-    assert function_to_test(array, new_element) == reference_pure_function(
-        array, new_element
-    )
+    output_array = function_to_test(array, new_element)
+    assert id(output_array) != id(array), "The arrays must be different objects."
+    assert output_array == reference_pure_function(array, new_element)
 
 
 #