functional_programming.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functional Programming"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Table of contents\n",
    "\n",
    "- [Immutability](#Immutability)\n",
    "- [Composition](#Composition)\n",
    "- [Higher Order Functions / Functions as Values](#Higher-Order-Functions-/-Functions-as-Values)\n",
    "- [Referential transparency](#Referential-transparency)\n",
    "- [Type system](#Type-system)\n",
    "- [Filtering](#Filtering)\n",
    "- [Reducing](#Reducing)\n",
    "- [List comprehensions](#List-comprehensions)\n",
    "- [Combinining and splitting iterators](#Combinining-and-splitting-iterators)\n",
    "- [Exercises](#Exercises)\n",
    "    - [Exercise 1: Pure or impure functions? 🌶️](#Exercise-1:-Pure-or-impure-functions?-🌶️)\n",
    "    - [Exercise 2: Keeping only multiples of n 🌶️](#Exercise-2:-Keeping-only-multiples-of-n-🌶️)\n",
    "    - [Exercise 3: Transposing a Matrix 🌶️🌶️](#Exercise-3:-Transposing-a-Matrix-🌶️🌶️)\n",
    "    - [Exercise 4: Flattening list of lists 🌶️🌶️](#Exercise-4:-Flattening-list-of-lists-🌶️🌶️)\n",
    "    - [Exercise 5: Counting initials 🌶️🌶️🌶️](#Exercise-5:-Counting-initials-🌶️🌶️🌶️)\n",
    "    - [Exercise 6: Counting initials frequency 🌶️🌶️🌶️](#Exercise-6:-Counting-initials-frequency-🌶️🌶️🌶️)\n",
    "    - [Exercise 7: Finding palindromes 🌶️🌶️🌶️](#Exercise-7:-Finding-palindromes-🌶️🌶️🌶️)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Important modules\n",
    "import functools\n",
    "import itertools\n",
    "import tutorial.functional_programming as fp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "\n",
    "---\n",
    "\n",
    "\n",
    "## References\n",
    "Here are some additional references to help you in self-learning. Next to each link, we write if this is a video, text or another type of material\n",
    "\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",
    "- 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",
    "\n",
    "\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",
    "- **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",
    "\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",
    "\n",
    "The main principles we use in functional programming are:\n",
    "\n",
    "- *Purity*\n",
    "- *Functions as values* (*higher order functions*)\n",
    "- *Immutability of data*\n",
    "- *Composition*\n",
    "- *Referential transparency*\n",
    "- *Type systems*\n",
    "\n",
    "In the next few sections, we are going to briefly explore these concepts with some examples."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    },
    "tags": []
   },
   "source": [
    "### Pure Functions (Purity)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In functional programming, we try to strive for *purity*, that is 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",
    "Other examples of side effects are:\n",
    "- printing to the program output\n",
    "- reading or writing files\n",
    "- generating and using random numbers\n",
    "To better understand this concept, let us look at the function `my_first_pure_function` we defined below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "def my_first_pure_function(x: int) -> int: \n",
    "    return x + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "Is this a pure function? - Yes, it is!\n",
    "Any time we run it, we get the same  result and running the function does not affect any other part of our program:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "x = 1\n",
    "print(f\"x is {x}\")\n",
    "print(f\"The result of calling the function is {my_first_pure_function(1)}\")\n",
    "print(f\"x is {x}\")\n",
    "print(f\"The result of calling the function is {my_first_pure_function(1)}\")\n",
    "print(f\"x is {x}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "As a rule of thumb, any function that does not modify variables outside of its *scope* and only uses mathematical functions is a pure function.\n",
    "Now, consider this function instead:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "x = [\"short\", \"list\"] \n",
    "def do_something(y: str) -> None:\n",
    "    x.append(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "Is this function pure? \n",
    "\n",
    "Let's try and run it. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "print(x)\n",
    "do_something(\"a\")\n",
    "print(x)"
   ]
  },
  {
   "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**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### Quiz of pure functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import tutorial.functional_programming as fp\n",
    "fp.PureFunctions()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Immutability"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    },
    "tags": []
   },
   "source": [
    "\n",
    "When writing programs in functional style, we usually avoid functions like `do_something`.\n",
    "Instead of modifying existing data (*mutation*), you write functions that transform your data and return new objects.\n",
    "In the case of the function above, we would rewrite it as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "x = [\"short\", \"list\"] \n",
    "def do_something_immutable(x: \"list[str]\", y: str) -> \"list[str]\":\n",
    "    return x + [y]\n",
    "\n",
    "print(x)\n",
    "print(do_something_immutable(x, \"a\"))\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "The output shows that `do_something_immutable` does not change `x`.\n",
    "It also does not reference to `x` outside of the scope but takes it as an argument.\n",
    "Instead of modfying the original `x` list, it returns a new list.\n",
    "When we want to keep immutability, this is the style we work with.\n",
    "If we adopt this style, it is easier to reason about the flow of our program as there are no variable that are being modified *at distance* by other function calls."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Composition"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    },
    "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",
    "\n",
    "Instead, we design our functions in such a way that one functions output can be directly fed into the next function.\n",
    "\n",
    "Additionally – but this is not as useful in Python – we use the associative property of function application:\n",
    "\n",
    "$$\n",
    "f(g(h)) = f \\circ (g \\circ h)\n",
    "$$\n",
    "\n",
    "where we used $\\circ$ to express the composition of functions.\n",
    "\n",
    "In Python, we can do this using a [`lambda` expression](https://docs.python.org/3/tutorial/controlflow.html?#lambda-expressions):\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x: int) -> int:\n",
    "    return x + 4\n",
    "\n",
    "def g(x: int) -> int:\n",
    "    return x * 3\n",
    "\n",
    "fg = lambda x: f(g(x))\n",
    "\n",
    "print(f\"{fg(4)=}, {f(g(4))=}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this way, we can break down a complex calculation in a series of simpler ones.\n",
    "This is useful for many things:\n",
    "\n",
    "- It is easier to find problems in a smaller function\n",
    "- We do our work only once: every time we need the same action, we just call the same function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Higher Order Functions / Functions as Values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    },
    "tags": []
   },
   "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",
    "As an example, consider the function `function_caller`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "from typing import Callable, Any  # for type hints\n",
    "\n",
    "def function_caller(f: Callable[[Any], Any], arg: Any) -> Any:\n",
    "    print(f\"Calling the function {f} with argument {arg}\")\n",
    "    res = f(arg)\n",
    "    print(f\"The result of the call was {res}\")\n",
    "    return res"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "This function takes a function `f` and its argument `args` as input and return the result of calling the function, while additionally printing a message on the standard output of the program. Let's try this out.\n",
    "To do so, we define a new function `add_five`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "def add_five(x: int) -> int:\n",
    "    return x + 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "Now we can call `function_caller` with `add_five` and another number as arguments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "function_caller(add_five, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "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."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Referential transparency"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    },
    "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",
    "\n",
    "Consider the following Python code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "def transparent_function(x: int) -> int:\n",
    "    return x + 1\n",
    "\n",
    "y1 = transparent_function(1) + 5\n",
    "\n",
    "y2 = transparent_function(1) + 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "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",
    "\n",
    "In this case, this is true because the value of `x()` is simply 5 and is invariant.\n",
    "\n",
    "However, consider this other example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "import random   # this is used to generate a random number\n",
    "\n",
    "def non_transparent_function() -> int:\n",
    "    return random.randint(0, 10)\n",
    "\n",
    "\n",
    "# With a lamba we capture the expression x() + 5 in a function,\n",
    "# we get its value when we call it like a function\n",
    "y1 = lambda: non_transparent_function() + 5\n",
    "\n",
    "y2 = lambda: non_transparent_function() + 5\n",
    "\n",
    "y1() == y2()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "In this case, because the function returns a different random number every time we call it, the expression `y1` has a different *value* compared to `y2` even though they both have the same *form*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Type system"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "A typical trait of (modern) functional programming is the heavy use of the *type system*.\n",
    "This provides a set of rules to classify expressions and values in the language into classes called *types*.\n",
    "You encountered some basic types in the introduction, for example, `int`, `str` or `float`.\n",
    "\n",
    "We use type systems to enforce constraints and invariants in our program:\n",
    "\n",
    "- *Making illegal states unpresentable*\n",
    "- Making sure we pass the right input to functions\n",
    "- Checking if we wrote a valid program before it runs\n",
    "\n",
    "Modern (3.6+) Python allows using *type annotation* to mark the type of values, function parameters and class members.\n",
    "\n",
    "For example:\n",
    "\n",
    "```python\n",
    "def fun(a: int) -> str:\n",
    "    return f\"{a}\"\n",
    "```\n",
    "\n",
    "means that `fun` takes integer values and returns strings.\n",
    "Python *does not enforce* this constraint.\n",
    "There are tools, however, which can be used to check the consistency of types in a Python program.\n",
    "\n",
    "As an example, consider this function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This function greets a person by name and age\n",
    "def greet(name: str, age: int):\n",
    "    print(f\"Hello {name}, you are {age} years old\")\n",
    "    \n",
    "greet(\"Simone\", 34)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since Python does not check the type of arguments  at compilation time, we can run this (absurd) code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "greet(\"Simone\", \"age\")"
   ]
  },
  {
   "cell_type": "markdown",
   "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",
    "\n",
    "We can achieve a similar effect using execution-time type checks.\n",
    "To facilitate our work, we first construct a `Person` class tha encapsulates the attributes of a person.\n",
    "We will see more about classes in the object-oriented programming tutorial. For the moment, you can see a class as container of data and related functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This defines a simple class with some helper methods and validations.\n",
    "# In this way, we are sure that when we pass a person to the `greet_better` function,\n",
    "# this person will have all needed attributes\n",
    "\n",
    "class Person:\n",
    "    name: str\n",
    "    age: int\n",
    "    \n",
    "    # This function is called every time we create a new `Person`\n",
    "    def __init__(self, name: str, age: int):\n",
    "        if not isinstance(name, str) or not isinstance(age, int):\n",
    "            raise ValueError(\"Invalid input\")\n",
    "        self.age = age\n",
    "        self.name = name\n",
    "\n",
    "\n",
    "def greet_better(person: Person):\n",
    "    if isinstance(person, Person):\n",
    "        print(f\"Hello {person.name}, you are {person.age} years old\")\n",
    "    else:\n",
    "        raise ValueError(\"Not a person\")"
   ]
  },
  {
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "greet_better(Person(\"Simone\", 34))\n",
    "\n",
    "try:\n",
    "    greet_better(Person(\"Simone\", \"d\"))\n",
    "except ValueError as e:\n",
    "    print(f\"Ooops, it does not work: {e}\")\n",
    "    \n",
    "try:\n",
    "    greet_better((\"Simone\", \"d\"))\n",
    "except ValueError as e:\n",
    "    print(f\"Ooops, it does not work: {e}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because this approach is rather cumbersome, there are specific libraries like [attrs](https://www.attrs.org/en/stable/) or [pydantic](https://docs.pydantic.dev/) to perform these types of checks on user-defined data types at runtime."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Mapping / Iteration "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    },
    "tags": []
   },
   "source": [
    "In this section, we will look at the application of some of the principles stated above in Python.\n",
    "An important application of functional programming in Python is the manipulation of iterables and lists."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using map and filter\n",
    "\n",
    "Python has the `map` built-in used to apply a given function to all the elements of any `iterable`.\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <h4><b>Note</b></h4>\n",
    "    Reminder: an iterable is any object capable of returning its elements <strong>one at a time</strong>\n",
    "</div>\n",
    "\n",
    "Let's see an example of a `map` using the `add_five` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "map(add_five, [1,2,3,4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "The output is a bit confusing! The reason is that `map` does not return a list but a [map](https://docs.python.org/3/library/functions.html#map) object.\n",
    "This object is **lazy**, that means that the values are only generated when we access them, for example by iterating over the `map` object. \n",
    "Fortunately, we can easily convert this into a list by calling the `list` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "list(map(add_five, [1,2,3,4]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "This is equivalent to using a for loop:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "a = []\n",
    "for i in [1,2,3,4]:\n",
    "    a.append(add_five(i))\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "However, as you can see, this former style is not very functional because we mutate an existing list `a` by appending the results of calling `add_five` to it.\n",
    "We will see later that Python offers a syntax called *list comprehension* to express this operation in a more functional style.\n",
    "`map` is useful when we want to apply the same functions to a list of parameters without writing a `for` loop.\n",
    "It makes for more concise code while sacrificing some readability."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    },
    "tags": []
   },
   "source": [
    "#### Filtering\n",
    "Another basic higher order function 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 return `true` or `false`. 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>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "def is_even(x: int) -> bool:\n",
    "    return x % 2 == 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "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:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "list(filter(is_even, [1,2,3,4,5]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    },
    "tags": []
   },
   "source": [
    "#### Reducing\n",
    "A 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",
    "\n",
    "As an example of using `reduce`, consider the following snippet:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "import functools\n",
    "\n",
    "\n",
    "def spy(x: int, y: int) -> int:\n",
    "    val = x * y\n",
    "    print(f\"x: {x}, y:{y}, result: {val}\")\n",
    "    return val\n",
    "\n",
    "result = functools.reduce(spy, [1, 2, 3, 4, 5])\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "As you can see, we are computing the cumulative product of `[1, 2, 3, 4, 5]`, that is the *factorial* of 5, or `5!`.\n",
    "The print statement in `spy` helps us see what goes on inside the function at each step in `reduce`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    },
    "tags": []
   },
   "source": [
    "### List comprehensions\n",
    "Many of the operations in the previous section can be performed in a different (some would say more *pythonic*) way using [list comprehensions](https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions).\n",
    "These look like mini for-loops inside square brackets and are very useful to write programs in a functional style while keeping code more readable than using higher order functions.  \n",
    "\n",
    "For example, if we want to double all integers between 1 and 10 and store the result in a list, we can proceed in the classical imperative way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "# create an empty list\n",
    "doubles = []\n",
    "\n",
    "# every time the loop runs, we add a number to the list\n",
    "for i in range(10):\n",
    "    doubles.append(i * 2)\n",
    "\n",
    "print(f\"The doubles are {doubles}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "Or we can use `map` like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "doubles = map(lambda x: x * 2, range(10))\n",
    "\n",
    "print(list(doubles))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "Again here we wrapped `doubles` in `list` because `map` is lazy and does not return a list immediately but a `map` object which can be converted into a list using `list`. \n",
    "This solution is more elegant and avoids side effects because we do not modify the previously defined `doubles` list, instead we directly produce a new list with the desired result.\n",
    "\n",
    "Now, we solve the same problem using a list comprehensions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "doubles = [i * 2 for i in range(10)]\n",
    "print(doubles)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "This looks a lot like the solution above for the for loop, but it is an *expression* instead of a *statement*.\n",
    "[Expressions](https://www.baeldung.com/cs/expression-vs-statement) in programming are pieces of code that return a value and hence can be composed together to form more complex expressions and used anywhere a value is needed.\n",
    "In functional style, we prefer working with expressions instead of statements because we try to keep [*referential transparency*](https://en.wikipedia.org/wiki/Referential_transparency).\n",
    "\n",
    "Compherensions can do more than iterate over a list.\n",
    "We can use them to filter elements of a list by adding an `if` statement at the end.\n",
    "For example, consider the example of filtering even numbers  from a list [above](#filter-example); we can rewrite this with list comprehensions like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "def is_even(x: int) -> bool:\n",
    "    return x % 2 == 0\n",
    "\n",
    "[i for i in range(5) if is_even(i)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "We can also combine (*nest*) list compherensions. This is equivalent to a nested for loop. For example consider this expression:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "[(i,j) for i in range(5) for j in range(5)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "This returns all the combination of numbers between 0 and 4 as a list of pairs.\n",
    "In the first part of the compherension, we can use any expression instead of just referencing the variable.\n",
    "For example, we can return a description of the pair `i,j` in text:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "[f\"The current pair is {i=}, {j=}\" for i in range(5) for j in range(5)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### Exercises on iteration/mapping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%reload_ext tutorial.tests.testsuite"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Modify the function `solution_filter_even` to filter only the even elements of the list `input_data`. For your solution, you **cannot** use explicit `for` loops."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "\n",
    "def solution_filter_even(input_data: list[int]) -> list[int]:\n",
    "    \"\"\"\n",
    "    Write your solution here\n",
    "    \"\"\"\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Modify the function `solution_add_one` to add the integer number `1` to each element of the list `input_data`. For your solution, you **cannot** use explicit `for` loops."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%ipytest\n",
    "\n",
    "def solution_add_one(input_data: list[int]) -> list[int]:\n",
    "    \"\"\"\n",
    "    Write your solution here\n",
    "    \"\"\"\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "### Combinining and splitting iterators\n",
    "Sometimes, we need to iterate over multiple lists in a special fashion, for example over two lists in parallel or we want to compute all the combinations of elements of two lists etc.\n",
    "We can solve many ot these problems with the use of list compherensions, but sometimes there are more elegant solutions by using the [`itertools`](https://docs.python.org/3/library/itertools.html) module, a part of Python's standard library.\n",
    "\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:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "numbers = [1, 2, 3, 4, 5]\n",
    "words = [\"one\", \"two\", \"three\" , \"four\", \"five\"]\n",
    "[f\"The number {i} is called {j}\" for i, j in zip(numbers, words)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "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:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "import itertools\n",
    "letters = [\"A\", \"B\", \"C\"]\n",
    "list(itertools.permutations(letters, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "a, b = [1, 2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "and extract the two elements in the variables `a` and `b`. If you try the same statement with a three-element list you will get an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    a, b = [1, 2, 3]\n",
    "except ValueError:\n",
    "    print(\"It does not work\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "However, you can extract *all remaining elements* with the star notation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "a, *b = [1, 2, 3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "If we use `*` before an argument in a function call, this will unpack the argument and pass each component to the function separately, as you can see in this example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "def print_variables(a: any, b: any, c: any):\n",
    "    print(f\"a is {a}, b is {b}, c is {c} \")\n",
    "\n",
    "print_variables(*[1, 2, 3])\n",
    "print_variables(1, 2, 3)\n",
    "print_variables(*[[1, 2, 3], [4, 5, 6], [5, 6, 7]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "Be careful, this only works if the list/iterable you unpack is as long as the arguments you want to pass to your function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Exercises"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext tutorial.tests.testsuite"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Exercise 1: Pure or impure functions? 🌶️\n",
    "\n",
    "For each of the functions below, determine whether they are pure or impure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def fun1(a: \"list[str]\") -> None:\n",
    "    a.append(\"b\")\n",
    "\n",
    "\n",
    "def fun2(a: int) -> int:\n",
    "    return a + 2\n",
    "\n",
    "\n",
    "def fun3(a: \"dict[str, str]\") -> None:\n",
    "    a[\"test\"] = \"dest\"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Exercise 2: Keeping only multiples of n 🌶️\n",
    "\n",
    "Given a list `L` of integers, write a function that only keeps the numbers that are multiples of a given constant `k`.\n",
    "\n",
    "- Example 1: given `nums = [1, 2, 3, 4, 5]`, and `k = 2`, the result must be `[2, 4]`\n",
    "\n",
    "- Example 2: given `nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] ` and `k = 5`, the result is `[5, 10]`\n",
    "\n",
    "\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <h4><b>Hints</b></h4>\n",
    "    <ul>\n",
    "        <li>\n",
    "            The operator <code>%</code> (modulo) gives the remainder of division. <code>a % k</code> is 0 when <code>a</code> is a multiple of <code>k</code>. For more information, consult the chapter on basic datatypes. \n",
    "        </li>\n",
    "        <li>\n",
    "            Write your function in the cell below inside of the <code>solution_exercise1</code> function. The function receives a list <code>l</code> as an input and should return another list\n",
    "        </li>\n",
    "    </ul>\n",
    "<div>\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%%ipytest functional_programming\n",
    "\n",
    "def solution_exercise2(l: \"list[int]\", k: int):\n",
    "    \"\"\"\n",
    "    Write your solution here\n",
    "    \"\"\"\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Exercise 3: Transposing a Matrix 🌶️🌶️\n",
    "\n",
    "Consider a matrix `M` represented row-wise as a list of lists `[[1, 2, 3], [4, 5, 6], [7, 8, 8]]`.\n",
    "Write a function  that returns the transpose of `M`, the matrix obtained by exchanging rows and columns\n",
    "\n",
    "- Example 1: given `M=[[1, 0], [0, 1]]`, the result must be `[[1, 0], [0, 1]]`\n",
    "- Example 2: given `M=[[1, 2, 3], [4, 5, 6], [7, 8, 8]]` the result must be `[1, 4, 7], [2, 5, 8], [3, 6, 8]]`\n",
    "\n",
    "\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <h4><b>Hints</b></h4>\n",
    "    <ul>\n",
    "        <li>\n",
    "            Write your function in <code>solution_exercise3</code>\n",
    "        <li>\n",
    "            The <code>zip</code> function behaves similar to a transposition: <code>zip([1,2], [3,4]) = [(1,3), (3,4)])</code>\n",
    "        </li>\n",
    "        <li>\n",
    "            Write your function in the cell below inside of the <code>solution_exercise3</code> function. The function receives a the \"matrix\"  as an input <code>m</code> and should return another list\n",
    "        </li>\n",
    "    </ul>\n",
    "<div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%%ipytest functional_programming\n",
    "\n",
    "def solution_exercise3(m: \"list[list[int]]\") -> \"list[list[int]]\":\n",
    "    \"\"\"\n",
    "    Write your solution here\n",
    "    \"\"\"\n",
    "    pass\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Exercise 4: Flattening list of lists 🌶️🌶️\n",
    "\n",
    "Imagine we receive a list of lists `l` like `[[1, 2], [3, 4]]`. Write a function that converts this list into a `flat` list like `[1, 2, 3, 4]`. \n",
    "\n",
    "To write your function, just complete the code in `solution_exercise4`\n",
    "\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <h4><b>Hints</b></h4>\n",
    "    <ul>\n",
    "        <li>\n",
    "            This is a good exercise to use <code>functools.reduce</code> \n",
    "        </li>\n",
    "        <li>\n",
    "            Write your function in the cell below inside of the <code>solution_exercise4</code> function. The function receives a list <code>l</code> as an input and should return another list\n",
    "        </li>\n",
    "    </ul>\n",
    "<div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%%ipytest functional_programming\n",
    "\n",
    "def solution_exercise4(l: \"list[list[any]]\") -> \"list[any]\":\n",
    "    \"\"\"\n",
    "    Write your solution here\n",
    "    \"\"\"\n",
    "    pass\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Exercise 5: Counting initials 🌶️🌶️🌶️\n",
    "\n",
    "Given a list `w` of English words, write a function that counts how many words begin with each letter of the English alphabet and returns the result as an **alphabetically sorted** list of tuples `(letter, count)`. We do not distinguish between uppercase and lowercase letters (\"A\" and \"a\" are considered the same).  \n",
    "\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <h4><b>Hints</b></h4>\n",
    "    <ul>\n",
    "        <li>\n",
    "            Consider the functions <code>sorted</code> and <code>itertools.groupby</code> from the Python standard library.\n",
    "        </li>\n",
    "        <li>\n",
    "            Write your function in the cell below inside of the <code>solution_exercise5</code> function. The function receives a list <code>w</code> as an input and should return another list\n",
    "        </li>\n",
    "        <li>\n",
    "            To ensure consistent capitalization you can use the <code>lower()</code> method of <code>str</code>\n",
    "        </li>\n",
    "    </ul>\n",
    "<div>\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%%ipytest functional_programming\n",
    "\n",
    "def solution_exercise5(w: list[str]) -> list[(str, int)]:\n",
    "    \"\"\"\n",
    "    Write your solution here\n",
    "    \"\"\"\n",
    "    pass\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Exercise 6: Counting initials frequency 🌶️🌶️🌶️\n",
    "If you could solve the previous exercise, you now have a list `l` of the form `[('a', 20), ('b', 30), ...]`.\n",
    "If you cannot, do not worry: you will receive the correct input automatically as `l` inside the function `solution_exercise6`\n",
    "\n",
    "\n",
    "Write a function that computes the *relative frequency* of each letter in the list `l`. \n",
    "\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <h4><b>Hints</b></h4>\n",
    "    <ul>\n",
    "        <li>\n",
    "            The relative frequence of a value <code>a</code> in a list is simply the number of time it appears in that\n",
    "            list over the total lenght of the list\n",
    "        </li>\n",
    "        <li>\n",
    "            Write your function in the cell below inside of the <code>solution_exercise6</code> function. The function receives a list <code>l</code> as an input and should return another list\n",
    "        </li>\n",
    "    </ul>\n",
    "<div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%%ipytest functional_programming\n",
    "\n",
    "def solution_exercise6(l: \"list[(str, int)]\") -> \"list[(str, float)]\":\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Exercise 7: Finding palindromes 🌶️🌶️🌶️\n",
    "Consider again the `words` list of strings. Write a function  that returns the list of all *palindromes*. A *palindrome* is a word (any string longer than 1) that reads the same left-to-right and right-to-left.\n",
    "\n",
    "For example:\n",
    "- rotator\n",
    "- wow\n",
    "- noon\n",
    "- radar\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <h4><b>Hints</b></h4>\n",
    "    <ul>\n",
    "        <li>\n",
    "            A single character does not count as a palindrome.\n",
    "        </li>\n",
    "        <li>\n",
    "            The words are available as the input <code>words</code> to <code>solution_exercise7</code>.\n",
    "        </li>\n",
    "    </ul>\n",
    "<div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%%ipytest functional_programming\n",
    "\n",
    "def solution_exercise7(words: \"list[str]\") -> \"list[str]\":\n",
    "    pass"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.3"
  },
  "vscode": {
   "interpreter": {
    "hash": "2b2b08c237e7c74caf82ad6490346743fce9bd812859047e307c1031e538ab1c"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}