Add notebook 05_functors (version 0.1.0) for the functional programming course

functional_programming/05_functors.py

@@ -5,112 +5,113 @@ app = marimo.App(app_title="Category Theory and Functors", css_file="")
 
 
 @app.cell(hide_code=True)
-def _(md):
-    md("""
-    # Category Theory and Functors
+def _(mo):
+    mo.md(
+        """
+        # Category Theory and Functors
 
-    In this notebook, you will learn:
+        In this notebook, you will learn:
 
-    * Why `length` is a *functor* from the category of `list concatenation` to the category of `integer addition`
-    * How to *lift* an ordinary function into a specific *computational context*
-    * How to write an *adapter* between two categories
+        * Why `length` is a *functor* from the category of `list concatenation` to the category of `integer addition`
+        * How to *lift* an ordinary function into a specific *computational context*
+        * How to write an *adapter* between two categories
 
-    In short, a mathematical functor is a **mapping** between two categories in category theory. In practice, a functor represents a type that can be mapped over.
+        In short, a mathematical functor is a **mapping** between two categories in category theory. In practice, a functor represents a type that can be mapped over.
 
-    /// admonition | Intuitions 
+        /// admonition | Intuitions 
 
-    - A simple intuition is that a `Functor` represents a **container** of values, along with the ability to apply a function uniformly to every element in the container.
-    - Another intuition is that a `Functor` represents some sort of **computational context**.
-    - Mathematically, `Functors` generalize the idea of a container or a computational context.
-    ///
+        - A simple intuition is that a `Functor` represents a **container** of values, along with the ability to apply a function uniformly to every element in the container.
+        - Another intuition is that a `Functor` represents some sort of **computational context**.
+        - Mathematically, `Functors` generalize the idea of a container or a computational context.
+        ///
 
-    We will start with intuition, introduce the basics of category theory, and then examine functors from a categorical perspective.
-    """)
-    return
+        We will start with intuition, introduce the basics of category theory, and then examine functors from a categorical perspective.
 
+        /// details | Notebook metadata
+            type: info
 
-@app.cell(hide_code=True)
-def _(md):
-    md("""
-    # Functor as a Computational Context
+        version: 0.1.0 | last modified: 2025-03-13 | author: [métaboulie](https://github.com/metaboulie)
 
-    A [**Functor**](https://wiki.haskell.org/Functor) is an abstraction that represents a computational context with the ability to apply a function to every value inside it without altering the structure of the context itself. This enables transformations while preserving the shape of the data.
+        ///
+        """
+    )
+    return
 
-    To understand this, let's look at a simple example.
 
-    ## [The One-Way Wrapper Design Pattern](http://blog.sigfpe.com/2007/04/trivial-monad.html)
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        """
+        # Functor as a Computational Context
 
-    Often, we need to wrap data in some kind of context. However, when performing operations on wrapped data, we typically have to:
+        A [**Functor**](https://wiki.haskell.org/Functor) is an abstraction that represents a computational context with the ability to apply a function to every value inside it without altering the structure of the context itself. This enables transformations while preserving the shape of the data.
 
-    1. Unwrap the data.
-    2. Modify the unwrapped data.
-    3. Rewrap the modified data.
+        To understand this, let's look at a simple example.
 
-    This process is tedious and inefficient. Instead, we want to wrap data **once** and apply functions directly to the wrapped data without unwrapping it.
+        ## [The One-Way Wrapper Design Pattern](http://blog.sigfpe.com/2007/04/trivial-monad.html)
 
-    /// admonition | Rules for a One-Way Wrapper
+        Often, we need to wrap data in some kind of context. However, when performing operations on wrapped data, we typically have to:
 
-    1. We can wrap values, but we cannot unwrap them.
-    2. We should still be able to apply transformations to the wrapped data.
-    3. Any operation that depends on wrapped data should itself return a wrapped result.
-    ///
+        1. Unwrap the data.
+        2. Modify the unwrapped data.
+        3. Rewrap the modified data.
 
-    Let's define such a `Wrapper` class:
+        This process is tedious and inefficient. Instead, we want to wrap data **once** and apply functions directly to the wrapped data without unwrapping it.
 
-    ```python
-    from dataclasses import dataclass
-    from typing import Callable, Generic, TypeVar
+        /// admonition | Rules for a One-Way Wrapper
 
-    a = TypeVar("a")
-    b = TypeVar("b")
+        1. We can wrap values, but we cannot unwrap them.
+        2. We should still be able to apply transformations to the wrapped data.
+        3. Any operation that depends on wrapped data should itself return a wrapped result.
+        ///
 
-    @dataclass
-    class Wrapper(Generic[a]):
-        value: a
-    ```
+        Let's define such a `Wrapper` class:
 
-    Now, we can create an instance of wrapped data:
+        ```python
+        from dataclasses import dataclass
+        from typing import Callable, Generic, TypeVar
 
-    ```python
-    wrapped = Wrapper(1)
-    ```
+        a = TypeVar("a")
+        b = TypeVar("b")
 
-    ### Mapping Functions Over Wrapped Data
+        @dataclass
+        class Wrapper(Generic[a]):
+            value: a
+        ```
 
-    To modify wrapped data while keeping it wrapped, we define an `fmap` method:
+        Now, we can create an instance of wrapped data:
 
-    ```python
-    @dataclass
-    class Wrapper(Generic[a]):
-        value: a
+        ```python
+        wrapped = Wrapper(1)
+        ```
 
-        def fmap(self, func: Callable[[a], b]) -> "Wrapper[b]":
-            return Wrapper(func(self.value))
-    ```
+        ### Mapping Functions Over Wrapped Data
 
-    Now, we can apply transformations without unwrapping:
+        To modify wrapped data while keeping it wrapped, we define an `fmap` method:
 
-    ```python
-    >>> wrapped.fmap(lambda x: x + 1)
-    Wrapper(value=2)
+        ```python
+        @dataclass
+        class Wrapper(Generic[a]):
+            value: a
 
-    >>> wrapped.fmap(lambda x: [x])
-    Wrapper(value=[1])
-    ```
+            def fmap(self, func: Callable[[a], b]) -> "Wrapper[b]":
+                return Wrapper(func(self.value))
+        ```
 
-    > Try using the `Wrapper` in the cell below.
-    """)
-    return
+        Now, we can apply transformations without unwrapping:
 
+        ```python
+        >>> wrapped.fmap(lambda x: x + 1)
+        Wrapper(value=2)
 
-@app.cell
-def _():
-    from dataclasses import dataclass
-    from typing import Callable, Generic, TypeVar
+        >>> wrapped.fmap(lambda x: [x])
+        Wrapper(value=[1])
+        ```
 
-    a = TypeVar("a")
-    b = TypeVar("b")
-    return Callable, Generic, TypeVar, a, b, dataclass
+        > Try using the `Wrapper` in the cell below.
+        """
+    )
+    return
 
 
 @app.cell
@@ -131,38 +132,42 @@ def _(Callable, Functor, Generic, a, b, dataclass):
 
 
 @app.cell(hide_code=True)
-def _(md):
-    md("""
-    We can analyze the type signature of `fmap` for `Wrapper`:
+def _(mo):
+    mo.md(
+        """
+        We can analyze the type signature of `fmap` for `Wrapper`:
 
-    * `self` is of type `Wrapper[a]`
-    * `func` is of type `Callable[[a], b]`
-    * The return value is of type `Wrapper[b]`
+        * `self` is of type `Wrapper[a]`
+        * `func` is of type `Callable[[a], b]`
+        * The return value is of type `Wrapper[b]`
 
-    Thus, in Python's type system, we can express the type signature of `fmap` as:
+        Thus, in Python's type system, we can express the type signature of `fmap` as:
 
-    ```python
-    def fmap(self: Wrapper[a], func: Callable[[a], b]) -> Wrapper[b]:
-    ```
+        ```python
+        def fmap(self: Wrapper[a], func: Callable[[a], b]) -> Wrapper[b]:
+        ```
 
-    Essentially, `fmap`:
+        Essentially, `fmap`:
 
-    1. Takes a `Wrapper[a]` instance and a function `Callable[[a], b]` as input.
-    2. Applies the function to the value inside the wrapper.
-    3. Returns a new `Wrapper[b]` instance with the transformed value, leaving the original wrapper and its internal data unmodified.
+        1. Takes a `Wrapper[a]` instance and a function `Callable[[a], b]` as input.
+        2. Applies the function to the value inside the wrapper.
+        3. Returns a new `Wrapper[b]` instance with the transformed value, leaving the original wrapper and its internal data unmodified.
 
-    Now, let's examine `list` as a similar kind of wrapper.
-    """)
+        Now, let's examine `list` as a similar kind of wrapper.
+        """
+    )
     return
 
 
 @app.cell(hide_code=True)
-def _(md):
-    md("""
-    ## The List Wrapper
+def _(mo):
+    mo.md(
+        """
+        ## The List Wrapper
 
-    We can define a `ListWrapper` class to represent a wrapped list that supports `fmap`:
-    """)
+        We can define a `ListWrapper` class to represent a wrapped list that supports `fmap`:
+        """
+    )
     return
 
 
@@ -192,131 +197,137 @@ def _(ListWrapper, mo):
 
 
 @app.cell(hide_code=True)
-def _(md):
-    md("""
-    ### Extracting the Type of `fmap`
+def _(mo):
+    mo.md(
+        """
+        ### Extracting the Type of `fmap`
 
-    The type signature of `fmap` for `ListWrapper` is:
+        The type signature of `fmap` for `ListWrapper` is:
 
-    ```python
-    def fmap(self: ListWrapper[a], func: Callable[[a], b]) -> ListWrapper[b]
-    ```
+        ```python
+        def fmap(self: ListWrapper[a], func: Callable[[a], b]) -> ListWrapper[b]
+        ```
 
-    Similarly, for `Wrapper`:
+        Similarly, for `Wrapper`:
 
-    ```python
-    def fmap(self: Wrapper[a], func: Callable[[a], b]) -> Wrapper[b]
-    ```
+        ```python
+        def fmap(self: Wrapper[a], func: Callable[[a], b]) -> Wrapper[b]
+        ```
 
-    Both follow the same pattern, which we can generalize as:
+        Both follow the same pattern, which we can generalize as:
 
-    ```python
-    def fmap(self: Functor[a], func: Callable[[a], b]) -> Functor[b]
-    ```
+        ```python
+        def fmap(self: Functor[a], func: Callable[[a], b]) -> Functor[b]
+        ```
 
-    where `Functor` can be `Wrapper`, `ListWrapper`, or any other wrapper type that follows the same structure.
+        where `Functor` can be `Wrapper`, `ListWrapper`, or any other wrapper type that follows the same structure.
 
-    ### Functors in Haskell (optional)
+        ### Functors in Haskell (optional)
 
-    In Haskell, the type of `fmap` is:
+        In Haskell, the type of `fmap` is:
 
-    ```haskell
-    fmap :: Functor f => (a -> b) -> f a -> f b
-    ```
+        ```haskell
+        fmap :: Functor f => (a -> b) -> f a -> f b
+        ```
 
-    or equivalently:
+        or equivalently:
 
-    ```haskell
-    fmap :: Functor f => (a -> b) -> (f a -> f b)
-    ```
+        ```haskell
+        fmap :: Functor f => (a -> b) -> (f a -> f b)
+        ```
 
-    This means that `fmap` **lifts** an ordinary function into the **functor world**, allowing it to operate within a computational context.
+        This means that `fmap` **lifts** an ordinary function into the **functor world**, allowing it to operate within a computational context.
 
-    Now, let's define an abstract class for `Functor`.
-    """)
+        Now, let's define an abstract class for `Functor`.
+        """
+    )
     return
 
 
 @app.cell(hide_code=True)
-def _(md):
-    md("""
-    ## Defining Functor
+def _(mo):
+    mo.md(
+        """
+        ## Defining Functor
 
-    Recall that, a **Functor** is an abstraction that allows us to apply a function to values inside a computational context while preserving its structure. 
+        Recall that, a **Functor** is an abstraction that allows us to apply a function to values inside a computational context while preserving its structure. 
 
-    To define `Functor` in Python, we use an abstract base class:
+        To define `Functor` in Python, we use an abstract base class:
 
-    ```python
-    from dataclasses import dataclass
-    from typing import Callable, Generic, TypeVar
-    from abc import ABC, abstractmethod
+        ```python
+        from dataclasses import dataclass
+        from typing import Callable, Generic, TypeVar
+        from abc import ABC, abstractmethod
 
-    a = TypeVar("a")
-    b = TypeVar("b")
+        a = TypeVar("a")
+        b = TypeVar("b")
 
-    @dataclass
-    class Functor(ABC, Generic[a]):
-        @abstractmethod
-        def fmap(self, func: Callable[[a], b]) -> "Functor[b]":
-            raise NotImplementedError
-    ```
+        @dataclass
+        class Functor(ABC, Generic[a]):
+            @abstractmethod
+            def fmap(self, func: Callable[[a], b]) -> "Functor[b]":
+                raise NotImplementedError
+        ```
 
-    We can now extend custom wrappers, containers, or computation contexts with this `Functor` base class, implement the `fmap` method, and apply any function.
+        We can now extend custom wrappers, containers, or computation contexts with this `Functor` base class, implement the `fmap` method, and apply any function.
 
-    Next, let's implement a more complex data structure: [RoseTree](https://en.wikipedia.org/wiki/Rose_tree).
-    """)
+        Next, let's implement a more complex data structure: [RoseTree](https://en.wikipedia.org/wiki/Rose_tree).
+        """
+    )
     return
 
 
 @app.cell(hide_code=True)
-def _(md):
-    md("""
-    ## Case Study: RoseTree
+def _(mo):
+    mo.md(
+        """
+        ## Case Study: RoseTree
 
-    A **RoseTree** is a tree where:
+        A **RoseTree** is a tree where:
 
-    - Each node holds a **value**.
-    - Each node has a **list of child nodes** (which are also RoseTrees).
+        - Each node holds a **value**.
+        - Each node has a **list of child nodes** (which are also RoseTrees).
 
-    This structure is useful for representing hierarchical data, such as:
-    - Abstract Syntax Trees (ASTs)
-    - File system directories
-    - Recursive computations
+        This structure is useful for representing hierarchical data, such as:
+        - Abstract Syntax Trees (ASTs)
+        - File system directories
+        - Recursive computations
 
-    We can implement `RoseTree` by extending the `Functor` class:
+        We can implement `RoseTree` by extending the `Functor` class:
 
-    ```python
-    from dataclasses import dataclass
-    from typing import Callable, Generic, TypeVar
+        ```python
+        from dataclasses import dataclass
+        from typing import Callable, Generic, TypeVar
 
-    a = TypeVar("a")
-    b = TypeVar("b")
+        a = TypeVar("a")
+        b = TypeVar("b")
 
-    @dataclass
-    class RoseTree(Functor, Generic[a]):
-        value: a
-        children: list["RoseTree[a]"]
+        @dataclass
+        class RoseTree(Functor, Generic[a]):
+            value: a
+            children: list["RoseTree[a]"]
 
-        def fmap(self, func: Callable[[a], b]) -> "RoseTree[b]":
-            return RoseTree(
-                func(self.value), [child.fmap(func) for child in self.children]
-            )
+            def fmap(self, func: Callable[[a], b]) -> "RoseTree[b]":
+                return RoseTree(
+                    func(self.value), [child.fmap(func) for child in self.children]
+                )
 
-        def __repr__(self) -> str:
-            return f"RoseNode({self.value}, {self.children})"
-    ```
+            def __repr__(self) -> str:
+                return f"RoseNode({self.value}, {self.children})"
+        ```
 
-    - The function is applied **recursively** to each node's value.
-    - The tree structure **remains unchanged**.
-    - Only the values inside the tree are modified.
+        - The function is applied **recursively** to each node's value.
+        - The tree structure **remains unchanged**.
+        - Only the values inside the tree are modified.
 
-    > Try using `RoseTree` in the cell below.
-    """)
+        > Try using `RoseTree` in the cell below.
+        """
+    )
     return
 
 
 @app.cell(hide_code=True)
-def _(Callable, Functor, Generic, a, b, dataclass, md):
+def _(Callable, Functor, Generic, a, b, dataclass, mo):
     @dataclass
     class RoseTree(Functor, Generic[a]):
         """
@@ -358,7 +369,7 @@ def _(Callable, Functor, Generic, a, b, dataclass, md):
             return f"RoseNode({self.value}, {self.children})"
 
 
-    md(RoseTree.__doc__)
+    mo.md(RoseTree.__doc__)
     return (RoseTree,)
 
 
@@ -374,66 +385,68 @@ def _(RoseTree, mo):
 
 
 @app.cell(hide_code=True)
-def _(md):
-    md("""
-    ## Generic Functions that can be Used with Any Functor
+def _(mo):
+    mo.md(
+        """
+        ## Generic Functions that can be Used with Any Functor
 
-    One of the powerful features of functors is that we can write **generic functions** that can work with any functor.
+        One of the powerful features of functors is that we can write **generic functions** that can work with any functor.
 
-    Remember that in Haskell, the type of `fmap` can be written as:
+        Remember that in Haskell, the type of `fmap` can be written as:
 
-    ```haskell
-    fmap :: Functor f => (a -> b) -> (f a -> f b)
-    ```
+        ```haskell
+        fmap :: Functor f => (a -> b) -> (f a -> f b)
+        ```
 
-    Translating to Python, we get:
+        Translating to Python, we get:
 
-    ```python
-    def fmap(func: Callable[[a], b]) -> Callable[[Functor[a]], Functor[b]]
-    ```
+        ```python
+        def fmap(func: Callable[[a], b]) -> Callable[[Functor[a]], Functor[b]]
+        ```
 
-    This means that `fmap`:
+        This means that `fmap`:
 
-    - Takes an **ordinary function** `Callable[[a], b]` as input.
-    - Outputs a function that:
-        - Takes a **functor** of type `Functor[a]` as input.
-        - Outputs a **functor** of type `Functor[b]`.
+        - Takes an **ordinary function** `Callable[[a], b]` as input.
+        - Outputs a function that:
+            - Takes a **functor** of type `Functor[a]` as input.
+            - Outputs a **functor** of type `Functor[b]`.
 
-    We can implement a similar idea in Python:
+        We can implement a similar idea in Python:
 
-    ```python
-    # fmap(func: Callable[[a], b]) -> Callable[[Functor[a]], Functor[b]]
-    fmap = lambda func: lambda f: f.fmap(lambda x: func(x))
+        ```python
+        # fmap(func: Callable[[a], b]) -> Callable[[Functor[a]], Functor[b]]
+        fmap = lambda func: lambda f: f.fmap(lambda x: func(x))
 
-    # inc([Functor[a]) -> Functor[b]
-    inc = fmap(lambda x: x + 1)
-    ```
+        # inc([Functor[a]) -> Functor[b]
+        inc = fmap(lambda x: x + 1)
+        ```
 
-    - **`fmap`**: Lifts an ordinary function (`lambda x: func(x)`) to the functor world, allowing the function to operate on the wrapped value inside the functor.
-    - **`inc`**: A specific instance of `fmap` that operates on any functor. It takes a functor, applies the function `lambda x: x + 1` to every value inside it, and returns a new functor with the updated values.
+        - **`fmap`**: Lifts an ordinary function (`lambda x: func(x)`) to the functor world, allowing the function to operate on the wrapped value inside the functor.
+        - **`inc`**: A specific instance of `fmap` that operates on any functor. It takes a functor, applies the function `lambda x: x + 1` to every value inside it, and returns a new functor with the updated values.
 
-    Thus, **`fmap`** transforms an ordinary function into a **function that operates on functors**, and **`inc`** is a specific case where it increments the value inside the functor.
+        Thus, **`fmap`** transforms an ordinary function into a **function that operates on functors**, and **`inc`** is a specific case where it increments the value inside the functor.
 
-    ### Applying the `inc` Function to Various Functors
+        ### Applying the `inc` Function to Various Functors
 
-    You can now apply `inc` to any functor like `Wrapper`, `ListWrapper`, or `RoseTree`:
+        You can now apply `inc` to any functor like `Wrapper`, `ListWrapper`, or `RoseTree`:
 
-    ```python
-    # Applying `inc` to a Wrapper
-    wrapper = Wrapper(5)
-    inc(wrapper)  # Wrapper(value=6)
+        ```python
+        # Applying `inc` to a Wrapper
+        wrapper = Wrapper(5)
+        inc(wrapper)  # Wrapper(value=6)
 
-    # Applying `inc` to a ListWrapper
-    list_wrapper = ListWrapper([1, 2, 3])
-    inc(list_wrapper)  # ListWrapper(value=[2, 3, 4])
+        # Applying `inc` to a ListWrapper
+        list_wrapper = ListWrapper([1, 2, 3])
+        inc(list_wrapper)  # ListWrapper(value=[2, 3, 4])
 
-    # Applying `inc` to a RoseTree
-    tree = RoseTree(1, [RoseTree(2, []), RoseTree(3, [])])
-    inc(tree)  # RoseTree(value=2, children=[RoseTree(value=3, children=[]), RoseTree(value=4, children=[])])
-    ```
+        # Applying `inc` to a RoseTree
+        tree = RoseTree(1, [RoseTree(2, []), RoseTree(3, [])])
+        inc(tree)  # RoseTree(value=2, children=[RoseTree(value=3, children=[]), RoseTree(value=4, children=[])])
+        ```
 
-    > Try using `fmap` in the cell below.
-    """)
+        > Try using `fmap` in the cell below.
+        """
+    )
     return
 
 
@@ -449,47 +462,49 @@ def _(ftree, list_wrapper, mo, wrapper):
 
 
 @app.cell(hide_code=True)
-def _(md):
-    md("""
-    ## Functor laws
+def _(mo):
+    mo.md(
+        """
+        ## Functor laws
 
-    In addition to providing a function `fmap` of the specified type, functors are also required to satisfy two equational laws:
+        In addition to providing a function `fmap` of the specified type, functors are also required to satisfy two equational laws:
 
-    ```haskell
-    fmap id = id                    -- fmap preserves identity
-    fmap (g . h) = fmap g . fmap h  -- fmap distributes over composition
-    ```
+        ```haskell
+        fmap id = id                    -- fmap preserves identity
+        fmap (g . h) = fmap g . fmap h  -- fmap distributes over composition
+        ```
 
-    1. `fmap` should preserve the **identity function**, in the sense that applying `fmap` to this function returns the same function as the result.
-    2. `fmap` should also preserve **function composition**. Applying two composed functions `g` and `h` to a functor via `fmap` should give the same result as first applying `fmap` to `g` and then applying `fmap` to `h`.
+        1. `fmap` should preserve the **identity function**, in the sense that applying `fmap` to this function returns the same function as the result.
+        2. `fmap` should also preserve **function composition**. Applying two composed functions `g` and `h` to a functor via `fmap` should give the same result as first applying `fmap` to `g` and then applying `fmap` to `h`.
 
-    /// admonition | 
-    - Any `Functor` instance satisfying the first law `(fmap id = id)` will automatically satisfy the [second law](https://github.com/quchen/articles/blob/master/second_functor_law.md) as well.
-    ///
+        /// admonition | 
+        - Any `Functor` instance satisfying the first law `(fmap id = id)` will automatically satisfy the [second law](https://github.com/quchen/articles/blob/master/second_functor_law.mo) as well.
+        ///
 
-    ### Functor Law Verification
+        ### Functor Law Verification
 
-    We can add a helper function `check_functor_law` in the `Functor` class to verify that an instance satisfies the functor laws.
+        We can add a helper function `check_functor_law` in the `Functor` class to verify that an instance satisfies the functor laws.
 
-    ```Python
-    id = lambda x: x
+        ```Python
+        id = lambda x: x
 
-    @dataclass
-    class Functor(ABC, Generic[a]):
-        @abstractmethod
-        def fmap(self, func: Callable[[a], b]) -> "Functor[b]":
-            return NotImplementedError
+        @dataclass
+        class Functor(ABC, Generic[a]):
+            @abstractmethod
+            def fmap(self, func: Callable[[a], b]) -> "Functor[b]":
+                return NotImplementedError
 
-        def check_functor_law(self):
-            return repr(self.fmap(id)) == repr(self)
+            def check_functor_law(self):
+                return repr(self.fmap(id)) == repr(self)
 
-        @abstractmethod
-        def __repr__(self):
-            return NotImplementedError
-    ```
+            @abstractmethod
+            def __repr__(self):
+                return NotImplementedError
+        ```
 
-    We can verify the functor we've defined.
-    """)
+        We can verify the functor we've defined.
+        """
+    )
     return
 
 
@@ -510,10 +525,8 @@ def _(ftree, list_wrapper, mo, wrapper):
 
 
 @app.cell(hide_code=True)
-def _(md):
-    md("""
-    And here is an `EvilFunctor`. We can verify it's not a valid `Functor`.
-    """)
+def _(mo):
+    mo.md("""And here is an `EvilFunctor`. We can verify it's not a valid `Functor`.""")
     return
 
 
@@ -542,38 +555,40 @@ def _(EvilFunctor):
 
 
 @app.cell(hide_code=True)
-def _(md):
-    md("""
-    ## Final defination of Functor
+def _(mo):
+    mo.md(
+        """
+        ## Final defination of Functor
 
-    We can now draft the final defination of `Functor` with some utility functions.
+        We can now draft the final defination of `Functor` with some utility functions.
 
-    ```Python
-    @dataclass
-    class Functor(ABC, Generic[a]):
-        @abstractmethod
-        def fmap(self, func: Callable[[a], b]) -> "Functor[b]":
-            return NotImplementedError
+        ```Python
+        @dataclass
+        class Functor(ABC, Generic[a]):
+            @abstractmethod
+            def fmap(self, func: Callable[[a], b]) -> "Functor[b]":
+                return NotImplementedError
 
-        def check_functor_law(self) -> bool:
-            return repr(self.fmap(id)) == repr(self)
+            def check_functor_law(self) -> bool:
+                return repr(self.fmap(id)) == repr(self)
 
-        def const_fmap(self, b) -> "Functor[b]":
-            return self.fmap(lambda _: b)
+            def const_fmap(self, b) -> "Functor[b]":
+                return self.fmap(lambda _: b)
 
-        def void(self) -> "Functor[None]":
-            return self.const_fmap(None)
+            def void(self) -> "Functor[None]":
+                return self.const_fmap(None)
 
-        @abstractmethod
-        def __repr__(self):
-            return NotImplementedError
-    ```
-    """)
+            @abstractmethod
+            def __repr__(self):
+                return NotImplementedError
+        ```
+        """
+    )
     return
 
 
 @app.cell(hide_code=True)
-def _(ABC, Callable, Generic, a, abstractmethod, b, dataclass, id, md):
+def _(ABC, Callable, Generic, a, abstractmethod, b, dataclass, id, mo):
     @dataclass
     class Functor(ABC, Generic[a]):
         """
@@ -624,15 +639,13 @@ def _(ABC, Callable, Generic, a, abstractmethod, b, dataclass, id, md):
             return NotImplementedError
 
 
-    md(Functor.__doc__)
+    mo.md(Functor.__doc__)
     return (Functor,)
 
 
 @app.cell(hide_code=True)
-def _(md):
-    md("""
-    > Try with utility functions in the cell below
-    """)
+def _(mo):
+    mo.md("""> Try with utility functions in the cell below""")
     return
 
 
@@ -647,20 +660,22 @@ def _(ftree, list_wrapper, mo):
 
 
 @app.cell(hide_code=True)
-def _(md):
-    md("""
-    ## Functors for Non-Iterable Types
+def _(mo):
+    mo.md(
+        """
+        ## Functors for Non-Iterable Types
 
-    In the previous examples, we implemented functors for **iterables**, like `ListWrapper` and `RoseTree`, which are inherently **iterable types**. This is a natural fit for functors, as iterables can be mapped over.
+        In the previous examples, we implemented functors for **iterables**, like `ListWrapper` and `RoseTree`, which are inherently **iterable types**. This is a natural fit for functors, as iterables can be mapped over.
 
-    However, **functors are not limited to iterables**. There are cases where we want to apply the concept of functors to types that are not inherently iterable, such as types that represent optional values, computations, or other data structures.
+        However, **functors are not limited to iterables**. There are cases where we want to apply the concept of functors to types that are not inherently iterable, such as types that represent optional values, computations, or other data structures.
 
-    ### The Maybe Functor
+        ### The Maybe Functor
 
-    One example is the **`Maybe`** type from Haskell, which is used to represent computations that can either result in a value (`Just a`) or no value (`Nothing`). 
+        One example is the **`Maybe`** type from Haskell, which is used to represent computations that can either result in a value (`Just a`) or no value (`Nothing`). 
 
-    We can define the `Maybe` functor as below:
-    """)
+        We can define the `Maybe` functor as below:
+        """
+    )
     return
 
 
@@ -694,15 +709,17 @@ def _(Callable, Functor, Generic, a, b, dataclass):
 
 
 @app.cell(hide_code=True)
-def _(md):
-    md("""
-    - **`Just`** is a wrapper that holds a value. We use it to represent the presence of a value.
-    - **`Maybe`** is a functor that can either hold a `Just` value or be `Nothing` (equivalent to `None` in Python). The `fmap` method applies a function to the value inside the `Just` wrapper, if it exists. If the value is `None` (representing `Nothing`), `fmap` simply returns `Nothing`.
+def _(mo):
+    mo.md(
+        """
+        - **`Just`** is a wrapper that holds a value. We use it to represent the presence of a value.
+        - **`Maybe`** is a functor that can either hold a `Just` value or be `Nothing` (equivalent to `None` in Python). The `fmap` method applies a function to the value inside the `Just` wrapper, if it exists. If the value is `None` (representing `Nothing`), `fmap` simply returns `Nothing`.
 
-    By using `Maybe` as a functor, we gain the ability to apply transformations (`fmap`) to potentially absent values, without having to explicitly handle the `None` case every time.
+        By using `Maybe` as a functor, we gain the ability to apply transformations (`fmap`) to potentially absent values, without having to explicitly handle the `None` case every time.
 
-    > Try using `Maybe` in the cell below.
-    """)
+        > Try using `Maybe` in the cell below.
+        """
+    )
     return
 
 
@@ -722,274 +739,290 @@ def _(Just, Maybe, ftree, inc, mo):
 
 
 @app.cell(hide_code=True)
-def _(md):
-    md("""
-    ## Limitations of Functor
+def _(mo):
+    mo.md(
+        """
+        ## Limitations of Functor
 
-    Functors abstract the idea of mapping a function over each element of a structure. Suppose now that we wish to generalise this idea to allow functions with any number of arguments to be mapped, rather than being restricted to functions with a single argument. More precisely, suppose that we wish to define a hierarchy of `fmap` functions with the following types:
+        Functors abstract the idea of mapping a function over each element of a structure. Suppose now that we wish to generalise this idea to allow functions with any number of arguments to be mapped, rather than being restricted to functions with a single argument. More precisely, suppose that we wish to define a hierarchy of `fmap` functions with the following types:
 
-    ```haskell
-    fmap0 :: a -> f a
+        ```haskell
+        fmap0 :: a -> f a
 
-    fmap1 :: (a -> b) -> f a -> f b
+        fmap1 :: (a -> b) -> f a -> f b
 
-    fmap2 :: (a -> b -> c) -> f a -> f b -> f c
+        fmap2 :: (a -> b -> c) -> f a -> f b -> f c
 
-    fmap3 :: (a -> b -> c -> d) -> f a -> f b -> f c -> f d
-    ```
+        fmap3 :: (a -> b -> c -> d) -> f a -> f b -> f c -> f d
+        ```
 
-    And we have to declare a special version of the functor class for each case.
+        And we have to declare a special version of the functor class for each case.
 
-    We will learn how to resolve this problem in the next notebook on `Applicatives`.
-    """)
+        We will learn how to resolve this problem in the next notebook on `Applicatives`.
+        """
+    )
     return
 
 
 @app.cell(hide_code=True)
-def _(md):
-    md("""
-    # Introduction to Categories
+def _(mo):
+    mo.md(
+        """
+        # Introduction to Categories
 
-    A [category](https://en.wikibooks.org/wiki/Haskell/Category_theory#Introduction_to_categories) is, in essence, a simple collection. It has three components: 
+        A [category](https://en.wikibooks.org/wiki/Haskell/Category_theory#Introduction_to_categories) is, in essence, a simple collection. It has three components: 
 
-    - A collection of **objects**.
-    - A collection of **morphisms**, each of which ties two objects (a _source object_ and a _target object_) together. If $f$ is a morphism with source object $C$ and target object $B$, we write $f : C → B$.
-    - A notion of **composition** of these morphisms. If $g : A → B$ and $f : B → C$ are two morphisms, they can be composed, resulting in a morphism $f ∘ g : A → C$.
+        - A collection of **objects**.
+        - A collection of **morphisms**, each of which ties two objects (a _source object_ and a _target object_) together. If $f$ is a morphism with source object $C$ and target object $B$, we write $f : C → B$.
+        - A notion of **composition** of these morphisms. If $g : A → B$ and $f : B → C$ are two morphisms, they can be composed, resulting in a morphism $f ∘ g : A → C$.
 
-    ## Category laws
+        ## Category laws
 
-    There are three laws that categories need to follow. 
+        There are three laws that categories need to follow. 
 
-    1. The composition of morphisms needs to be **associative**. Symbolically, $f ∘ (g ∘ h) = (f ∘ g) ∘ h$
+        1. The composition of morphisms needs to be **associative**. Symbolically, $f ∘ (g ∘ h) = (f ∘ g) ∘ h$
 
-        - Morphisms are applied right to left, so with $f ∘ g$ first $g$ is applied, then $f$. 
+            - Morphisms are applied right to left, so with $f ∘ g$ first $g$ is applied, then $f$. 
 
-    2. The category needs to be **closed** under the composition operation. So if $f : B → C$ and $g : A → B$, then there must be some morphism $h : A → C$ in the category such that $h = f ∘ g$. 
+        2. The category needs to be **closed** under the composition operation. So if $f : B → C$ and $g : A → B$, then there must be some morphism $h : A → C$ in the category such that $h = f ∘ g$. 
 
-    3. Given a category $C$ there needs to be for every object $A$ an **identity** morphism, $id_A : A → A$ that is an identity of composition with other morphisms. Put precisely, for every morphism $g : A → B$: $g ∘ id_A = id_B ∘ g = g$
+        3. Given a category $C$ there needs to be for every object $A$ an **identity** morphism, $id_A : A → A$ that is an identity of composition with other morphisms. Put precisely, for every morphism $g : A → B$: $g ∘ id_A = id_B ∘ g = g$
 
-    /// attention | The definition of a category does not define: 
+        /// attention | The definition of a category does not define: 
 
-    - what `∘` is,
-    - what `id` is, or
-    - what `f`, `g`, and `h` might be. 
+        - what `∘` is,
+        - what `id` is, or
+        - what `f`, `g`, and `h` might be. 
 
-    Instead, category theory leaves it up to us to discover what they might be.
-    ///
-    """)
+        Instead, category theory leaves it up to us to discover what they might be.
+        ///
+        """
+    )
     return
 
 
 @app.cell(hide_code=True)
-def _(md):
-    md("""
-    ## The Python category
-
-    The main category we'll be concerning ourselves with in this part is the Python category, or we can give it a shorter name: `Py`. `Py` treats Python types as objects and Python functions as morphisms. A function `def f(a: A) -> B` for types A and B is a morphism in Python.
-
-    Remember that we defined the `id` and `compose` function above as:
-
-    ```Python
-    def id(x: Generic[a]) -> Generic[a]:
-        return x
-
-    def compose(f: Callable[[b], c], g: Callable[[a], b]) -> Callable[[a], c]:
-        return lambda x: f(g(x))  
-    ```
-
-    We can check second law easily. 
-
-    For the first law, we have:
-
-    ```python
-    # compose(f, g) = lambda x: f(g(x))
-    f ∘ (g ∘ h) 
-    = compose(f, compose(g, h)) 
-    = lambda x: f(compose(g, h)(x))
-    = lambda x: f(lambda y: g(h(y))(x))
-    = lambda x: f(g(h(x)))
-
-    (f ∘ g) ∘ h 
-    = compose(compose(f, g), h)
-    = lambda x: compose(f, g)(h(x))
-    = lambda x: lambda y: f(g(y))(h(x))
-    = lambda x: f(g(h(x)))
-    ```
-
-    For the third law, we have: 
-
-    ```python
-    g ∘ id_A 
-    = compose(g: Callable[[a], b], id: Callable[[a], a]) -> Callable[[a], b]
-    = lambda x: g(id(x))
-    = lambda x: g(x) # id(x) = x
-    = g
-    ```
-    the similar proof can be applied to $id_B ∘ g =g$.
-
-    Thus `Py` is a valid category.
-    """)
-    return
+def _(mo):
+    mo.md(
+        """
+        ## The Python category
 
+        The main category we'll be concerning ourselves with in this part is the Python category, or we can give it a shorter name: `Py`. `Py` treats Python types as objects and Python functions as morphisms. A function `def f(a: A) -> B` for types A and B is a morphism in Python.
 
-@app.cell(hide_code=True)
-def _(md):
-    md("""
-    # Functors, again
+        Remember that we defined the `id` and `compose` function above as:
 
-    A functor is essentially a transformation between categories, so given categories $C$ and $D$, a functor $F : C → D$:
+        ```Python
+        def id(x: Generic[a]) -> Generic[a]:
+            return x
 
-    - Maps any object $A$ in $C$ to $F ( A )$, in $D$.
-    - Maps morphisms $f : A → B$ in $C$ to $F ( f ) : F ( A ) → F ( B )$ in $D$.
+        def compose(f: Callable[[b], c], g: Callable[[a], b]) -> Callable[[a], c]:
+            return lambda x: f(g(x))  
+        ```
 
-    > Endofunctors are functors from a category to itself.
-    """)
-    return
+        We can check second law easily. 
 
+        For the first law, we have:
 
-@app.cell(hide_code=True)
-def _(md):
-    md("""
-    ## Functors on the category of Python
+        ```python
+        # compose(f, g) = lambda x: f(g(x))
+        f ∘ (g ∘ h) 
+        = compose(f, compose(g, h)) 
+        = lambda x: f(compose(g, h)(x))
+        = lambda x: f(lambda y: g(h(y))(x))
+        = lambda x: f(g(h(x)))
 
-    Remember that a functor has two parts: it maps objects in one category to objects in another and morphisms in the first category to morphisms in the second. 
+        (f ∘ g) ∘ h 
+        = compose(compose(f, g), h)
+        = lambda x: compose(f, g)(h(x))
+        = lambda x: lambda y: f(g(y))(h(x))
+        = lambda x: f(g(h(x)))
+        ```
 
-    Functors in Python are from `Py` to `func`, where `func` is the subcategory of `Py` defined on just that functor's types. E.g. the RoseTree functor goes from `Py` to `RoseTree`, where `RoseTree` is the category containing only RoseTree types, that is, `RoseTree[T]` for any type `T`. The morphisms in `RoseTree` are functions defined on RoseTree types, that is, functions `RoseTree[T] -> RoseTree[U]` for types `T`, `U`.
+        For the third law, we have: 
 
-    Recall the definition of `Functor`:
+        ```python
+        g ∘ id_A 
+        = compose(g: Callable[[a], b], id: Callable[[a], a]) -> Callable[[a], b]
+        = lambda x: g(id(x))
+        = lambda x: g(x) # id(x) = x
+        = g
+        ```
+        the similar proof can be applied to $id_B ∘ g =g$.
 
-    ```Python
-    @dataclass
-    class Functor(ABC, Generic[a])
-    ```
-
-    And RoseTree: 
+        Thus `Py` is a valid category.
+        """
+    )
+    return
 
-    ```Python
-    @dataclass
-    class RoseTree(Functor, Generic[a])
-    ```
 
-    **Here's the key part:** the _type constructor_ `RoseTree` takes any type `T` to a new type, `RoseTree[T]`. Also, `fmap` restricted to `RoseTree` types takes a function `a -> b` to a function `RoseTree[a] -> RoseTree[b]`.
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        """
+        # Functors, again
 
-    But that's it. We've defined two parts, something that takes objects in `Py` to objects in another category (that of `RoseTree` types and functions defined on `RoseTree` types), and something that takes morphisms in `Py` to morphisms in this category. So `RoseTree` is a functor. 
+        A functor is essentially a transformation between categories, so given categories $C$ and $D$, a functor $F : C → D$:
 
-    To sum up:
+        - Maps any object $A$ in $C$ to $F ( A )$, in $D$.
+        - Maps morphisms $f : A → B$ in $C$ to $F ( f ) : F ( A ) → F ( B )$ in $D$.
 
-    - We work in the category **Py** and its subcategories.  
-    - **Objects** are types (e.g., `int`, `str`, `list`).  
-    - **Morphisms** are functions (`Callable[[A], B]`).  
-    - **Things that take a type and return another type** are type constructors (`RoseTree[T]`).  
-    - **Things that take a function and return another function** are higher-order functions (`Callable[[Callable[[A], B]], Callable[[C], D]]`).  
-    - **Abstract base classes (ABC)** and duck typing provide a way to express polymorphism, capturing the idea that in category theory, structures are often defined over multiple objects at once.
-    """)
+        > Endofunctors are functors from a category to itself.
+        """
+    )
     return
 
 
 @app.cell(hide_code=True)
-def _(md):
-    md("""
-    ## Functor laws, again
+def _(mo):
+    mo.md(
+        """
+        ## Functors on the category of Python
 
-    Once again there are a few axioms that functors have to obey. 
+        Remember that a functor has two parts: it maps objects in one category to objects in another and morphisms in the first category to morphisms in the second. 
 
-    1. Given an identity morphism $id_A$ on an object $A$, $F ( id_A )$ must be the identity morphism on $F ( A )$, i.e.: ${\displaystyle F(\operatorname {id} _{A})=\operatorname {id} _{F(A)}}$
-    2. Functors must distribute over morphism composition, i.e. ${\displaystyle F(f\circ g)=F(f)\circ F(g)}$
-    """)
-    return
+        Functors in Python are from `Py` to `func`, where `func` is the subcategory of `Py` defined on just that functor's types. E.g. the RoseTree functor goes from `Py` to `RoseTree`, where `RoseTree` is the category containing only RoseTree types, that is, `RoseTree[T]` for any type `T`. The morphisms in `RoseTree` are functions defined on RoseTree types, that is, functions `RoseTree[T] -> RoseTree[U]` for types `T`, `U`.
 
+        Recall the definition of `Functor`:
 
-@app.cell(hide_code=True)
-def _(md):
-    md("""
-    Remember that we defined the `fmap` (not the `fmap` in `Functor` class) and `id` as 
-    ```python
-    # fmap :: Callable[[a], b] -> Callable[[Functor[a]], Functor[b]]
-    fmap = lambda func: lambda f: f.fmap(func)
-    id = lambda x: x
-    compose = lambda f, g: lambda x: f(g(x))
-    ```
+        ```Python
+        @dataclass
+        class Functor(ABC, Generic[a])
+        ```
 
-    Let's prove that `fmap` is a functor.
+        And RoseTree: 
 
-    First, let's define a `Category` for a specific `Functor`. We choose to define the `Category` for the `Wrapper` as `WrapperCategory` here for simplicity, but remember that `Wrapper` can be any `Functor`(i.e. `ListWrapper`, `RoseTree`, `Maybe` and more):
+        ```Python
+        @dataclass
+        class RoseTree(Functor, Generic[a])
+        ```
 
-    **Notice that** in this case, we can actually view `fmap` as:
-    ```python
-    # fmap :: Callable[[a], b] -> Callable[[Wrapper[a]], Wrapper[b]]
-    fmap = lambda func: lambda wrapper: wrapper.fmap(func)
-    ```
+        **Here's the key part:** the _type constructor_ `RoseTree` takes any type `T` to a new type, `RoseTree[T]`. Also, `fmap` restricted to `RoseTree` types takes a function `a -> b` to a function `RoseTree[a] -> RoseTree[b]`.
 
-    We define `WrapperCategory` as:
+        But that's it. We've defined two parts, something that takes objects in `Py` to objects in another category (that of `RoseTree` types and functions defined on `RoseTree` types), and something that takes morphisms in `Py` to morphisms in this category. So `RoseTree` is a functor. 
 
-    ```python
-    @dataclass
-    class WrapperCategory():
-        @staticmethod
-        def id() -> Callable[[Wrapper[a]], Wrapper[a]]:
-            return lambda wrapper: Wrapper(wrapper.value)
+        To sum up:
 
-        @staticmethod
-        def compose(
-            f: Callable[[Wrapper[b]], Wrapper[c]],
-            g: Callable[[Wrapper[a]], Wrapper[b]],
-        )   -> Callable[[Wrapper[a]], Wrapper[c]]:
-            return lambda wrapper: f(g(Wrapper(wrapper.value)))
-    ```
+        - We work in the category **Py** and its subcategories.  
+        - **Objects** are types (e.g., `int`, `str`, `list`).  
+        - **Morphisms** are functions (`Callable[[A], B]`).  
+        - **Things that take a type and return another type** are type constructors (`RoseTree[T]`).  
+        - **Things that take a function and return another function** are higher-order functions (`Callable[[Callable[[A], B]], Callable[[C], D]]`).  
+        - **Abstract base classes (ABC)** and duck typing provide a way to express polymorphism, capturing the idea that in category theory, structures are often defined over multiple objects at once.
+        """
+    )
+    return
 
-    And `Wrapper` is:
 
-    ```Python
-    @dataclass
-    class Wrapper(Generic[a]):
-        value: a
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        """
+        ## Functor laws, again
 
-        def fmap(self, func: Callable[[a], b]) -> "Wrapper[b]":
-            return Wrapper(func(self.value))
-    ```
-    """)
+        Once again there are a few axioms that functors have to obey. 
+
+        1. Given an identity morphism $id_A$ on an object $A$, $F ( id_A )$ must be the identity morphism on $F ( A )$, i.e.: ${\displaystyle F(\operatorname {id} _{A})=\operatorname {id} _{F(A)}}$
+        2. Functors must distribute over morphism composition, i.e. ${\displaystyle F(f\circ g)=F(f)\circ F(g)}$
+        """
+    )
     return
 
 
 @app.cell(hide_code=True)
-def _(md):
-    md("""
-    notice that
-
-    ```python
-    fmap(f)(wrapper) = wrapper.fmap(f)
-    ```
-
-    We can get:
-
-    ```python
-    fmap(id)
-    = lambda wrapper: wrapper.fmap(id)
-    = lambda wrapper: Wrapper(id(wrapper.value))
-    = lambda wrapper: Wrapper(wrapper.value)
-    = WrapperCategory.id()
-    ```
-    And:
-    ```python
-    fmap(compose(f, g))
-    = lambda wrapper: wrapper.fmap(compose(f, g))
-    = lambda wrapper: Wrapper(compose(f, g)(wrapper.value))
-    = lambda wrapper: Wrapper(f(g(wrapper.value)))
-
-    WrapperCategory.compose(fmap(f), fmap(g))
-    = lambda wrapper: fmap(f)(fmap(g)(wrapper))
-    = lambda wrapper: fmap(f)(wrapper.fmap(g))
-    = lambda wrapper: fmap(f)(Wrapper(g(wrapper.value)))
-    = lambda wrapper: Wrapper(g(wrapper.value)).fmap(f)
-    = lambda wrapper: Wrapper(f(Wrapper(g(wrapper.value)).value))
-    = lambda wrapper: Wrapper(f(g(wrapper.value)))
-    = fmap(compose(f, g))
-    ```
-
-    So our `Wrapper` is a valid `Functor`.
-
-    > Try validating functor laws for `Wrapper` below.
-    """)
+def _(mo):
+    mo.md(
+        """
+        Remember that we defined the `fmap` (not the `fmap` in `Functor` class) and `id` as 
+        ```python
+        # fmap :: Callable[[a], b] -> Callable[[Functor[a]], Functor[b]]
+        fmap = lambda func: lambda f: f.fmap(func)
+        id = lambda x: x
+        compose = lambda f, g: lambda x: f(g(x))
+        ```
+
+        Let's prove that `fmap` is a functor.
+
+        First, let's define a `Category` for a specific `Functor`. We choose to define the `Category` for the `Wrapper` as `WrapperCategory` here for simplicity, but remember that `Wrapper` can be any `Functor`(i.e. `ListWrapper`, `RoseTree`, `Maybe` and more):
+
+        **Notice that** in this case, we can actually view `fmap` as:
+        ```python
+        # fmap :: Callable[[a], b] -> Callable[[Wrapper[a]], Wrapper[b]]
+        fmap = lambda func: lambda wrapper: wrapper.fmap(func)
+        ```
+
+        We define `WrapperCategory` as:
+
+        ```python
+        @dataclass
+        class WrapperCategory():
+            @staticmethod
+            def id() -> Callable[[Wrapper[a]], Wrapper[a]]:
+                return lambda wrapper: Wrapper(wrapper.value)
+
+            @staticmethod
+            def compose(
+                f: Callable[[Wrapper[b]], Wrapper[c]],
+                g: Callable[[Wrapper[a]], Wrapper[b]],
+            )   -> Callable[[Wrapper[a]], Wrapper[c]]:
+                return lambda wrapper: f(g(Wrapper(wrapper.value)))
+        ```
+
+        And `Wrapper` is:
+
+        ```Python
+        @dataclass
+        class Wrapper(Generic[a]):
+            value: a
+
+            def fmap(self, func: Callable[[a], b]) -> "Wrapper[b]":
+                return Wrapper(func(self.value))
+        ```
+        """
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        """
+        notice that
+
+        ```python
+        fmap(f)(wrapper) = wrapper.fmap(f)
+        ```
+
+        We can get:
+
+        ```python
+        fmap(id)
+        = lambda wrapper: wrapper.fmap(id)
+        = lambda wrapper: Wrapper(id(wrapper.value))
+        = lambda wrapper: Wrapper(wrapper.value)
+        = WrapperCategory.id()
+        ```
+        And:
+        ```python
+        fmap(compose(f, g))
+        = lambda wrapper: wrapper.fmap(compose(f, g))
+        = lambda wrapper: Wrapper(compose(f, g)(wrapper.value))
+        = lambda wrapper: Wrapper(f(g(wrapper.value)))
+
+        WrapperCategory.compose(fmap(f), fmap(g))
+        = lambda wrapper: fmap(f)(fmap(g)(wrapper))
+        = lambda wrapper: fmap(f)(wrapper.fmap(g))
+        = lambda wrapper: fmap(f)(Wrapper(g(wrapper.value)))
+        = lambda wrapper: Wrapper(g(wrapper.value)).fmap(f)
+        = lambda wrapper: Wrapper(f(Wrapper(g(wrapper.value)).value))
+        = lambda wrapper: Wrapper(f(g(wrapper.value)))
+        = fmap(compose(f, g))
+        ```
+
+        So our `Wrapper` is a valid `Functor`.
+
+        > Try validating functor laws for `Wrapper` below.
+        """
+    )
     return
 
 
@@ -1024,18 +1057,20 @@ def _(WrapperCategory, compose, fmap, id, mo, wrapper):
 
 
 @app.cell(hide_code=True)
-def _(md):
-    md("""
-    ## Length as a Functor
+def _(mo):
+    mo.md(
+        """
+        ## Length as a Functor
 
-    Remember that a functor is a transformation between two categories. It is not only limited to a functor from `Py` to `func`, but also includes transformations between other mathematical structures.
+        Remember that a functor is a transformation between two categories. It is not only limited to a functor from `Py` to `func`, but also includes transformations between other mathematical structures.
 
-    Let’s prove that **`length`** can be viewed as a functor. Specifically, we will demonstrate that `length` is a functor from the **category of list concatenation** to the **category of integer addition**.
+        Let’s prove that **`length`** can be viewed as a functor. Specifically, we will demonstrate that `length` is a functor from the **category of list concatenation** to the **category of integer addition**.
 
-    ### Category of List Concatenation
+        ### Category of List Concatenation
 
-    First, let’s define the category of list concatenation:
-    """)
+        First, let’s define the category of list concatenation:
+        """
+    )
     return
 
 
@@ -1058,21 +1093,25 @@ def _(Generic, a, dataclass):
 
 
 @app.cell(hide_code=True)
-def _(md):
-    md("""
-    - **Identity**: The identity element is an empty list (`ListConcatenation([])`).
-    - **Composition**: The composition of two lists is their concatenation (`this.value + other.value`).
-    """)
+def _(mo):
+    mo.md(
+        """
+        - **Identity**: The identity element is an empty list (`ListConcatenation([])`).
+        - **Composition**: The composition of two lists is their concatenation (`this.value + other.value`).
+        """
+    )
     return
 
 
 @app.cell(hide_code=True)
-def _(md):
-    md("""
-    ### Category of Integer Addition
+def _(mo):
+    mo.md(
+        """
+        ### Category of Integer Addition
 
-    Now, let's define the category of integer addition:
-    """)
+        Now, let's define the category of integer addition:
+        """
+    )
     return
 
 
@@ -1093,21 +1132,25 @@ def _(dataclass):
 
 
 @app.cell(hide_code=True)
-def _(md):
-    md("""
-    - **Identity**: The identity element is `IntAddition(0)` (the additive identity).
-    - **Composition**: The composition of two integers is their sum (`this.value + other.value`).
-    """)
+def _(mo):
+    mo.md(
+        """
+        - **Identity**: The identity element is `IntAddition(0)` (the additive identity).
+        - **Composition**: The composition of two integers is their sum (`this.value + other.value`).
+        """
+    )
     return
 
 
 @app.cell(hide_code=True)
-def _(md):
-    md("""
-    ### Defining the Length Functor
+def _(mo):
+    mo.md(
+        """
+        ### Defining the Length Functor
 
-    We now define the `length` function as a functor, mapping from the category of list concatenation to the category of integer addition:
-    """)
+        We now define the `length` function as a functor, mapping from the category of list concatenation to the category of integer addition:
+        """
+    )
     return
 
 
@@ -1118,23 +1161,23 @@ def _(IntAddition):
 
 
 @app.cell(hide_code=True)
-def _(md):
-    md("""
-    This function takes an instance of `ListConcatenation`, computes its length, and returns an `IntAddition` instance with the computed length.
-    """)
+def _(mo):
+    mo.md("""This function takes an instance of `ListConcatenation`, computes its length, and returns an `IntAddition` instance with the computed length.""")
     return
 
 
 @app.cell(hide_code=True)
-def _(md):
-    md("""
-    ### Verifying Functor Laws
+def _(mo):
+    mo.md(
+        """
+        ### Verifying Functor Laws
 
-    Now, let’s verify that `length` satisfies the two functor laws.
+        Now, let’s verify that `length` satisfies the two functor laws.
 
-    #### 1. **Identity Law**:
-    The identity law states that applying the functor to the identity element of one category should give the identity element of the other category.
-    """)
+        #### 1. **Identity Law**:
+        The identity law states that applying the functor to the identity element of one category should give the identity element of the other category.
+        """
+    )
     return
 
 
@@ -1145,19 +1188,19 @@ def _(IntAddition, ListConcatentation, length):
 
 
 @app.cell(hide_code=True)
-def _(md):
-    md("""
-    This ensures that the length of an empty list (identity in the `ListConcatenation` category) is `0` (identity in the `IntAddition` category).
-    """)
+def _(mo):
+    mo.md("""This ensures that the length of an empty list (identity in the `ListConcatenation` category) is `0` (identity in the `IntAddition` category).""")
     return
 
 
 @app.cell(hide_code=True)
-def _(md):
-    md("""
-    #### 2. **Composition Law**:
-    The composition law states that the functor should preserve composition. Applying the functor to a composed element should be the same as composing the functor applied to the individual elements.
-    """)
+def _(mo):
+    mo.md(
+        """
+        #### 2. **Composition Law**:
+        The composition law states that the functor should preserve composition. Applying the functor to a composed element should be the same as composing the functor applied to the individual elements.
+        """
+    )
     return
 
 
@@ -1174,41 +1217,31 @@ def _(IntAddition, ListConcatentation, length):
 
 
 @app.cell(hide_code=True)
-def _(md):
-    md("""
-    This ensures that the length of the concatenation of two lists is the same as the sum of the lengths of the individual lists.
-    """)
+def _(mo):
+    mo.md("""This ensures that the length of the concatenation of two lists is the same as the sum of the lengths of the individual lists.""")
     return
 
 
 @app.cell(hide_code=True)
-def _(md):
-    md("""
-    # Exercises
-
-    todo
-    """)
-    return
-
-
-@app.cell(hide_code=True)
-def _(md):
-    md("""
-    # Further reading
+def _(mo):
+    mo.md(
+        """
+        # Further reading
 
-    - [The Trivial Monad](http://blog.sigfpe.com/2007/04/trivial-monad.html)
-    - [Haskellwiki. Category Theory](https://en.wikibooks.org/wiki/Haskell/Category_theory)
-    - [Haskellforall. The Category Design Pattern](https://www.haskellforall.com/2012/08/the-category-design-pattern.html)
-    - [Haskellforall. The Functor Design Pattern](https://www.haskellforall.com/2012/09/the-functor-design-pattern.html)
+        - [The Trivial Monad](http://blog.sigfpe.com/2007/04/trivial-monad.html)
+        - [Haskellwiki. Category Theory](https://en.wikibooks.org/wiki/Haskell/Category_theory)
+        - [Haskellforall. The Category Design Pattern](https://www.haskellforall.com/2012/08/the-category-design-pattern.html)
+        - [Haskellforall. The Functor Design Pattern](https://www.haskellforall.com/2012/09/the-functor-design-pattern.html)
 
-        /// attention | ATTENTION 
-        The functor design pattern doesn't work at all if you aren't using categories in the first place. This is why you should structure your tools using the compositional category design pattern so that you can take advantage of functors to easily mix your tools together. 
-        ///
+            /// attention | ATTENTION 
+            The functor design pattern doesn't work at all if you aren't using categories in the first place. This is why you should structure your tools using the compositional category design pattern so that you can take advantage of functors to easily mix your tools together. 
+            ///
 
-    - [Haskellwiki. Functor](https://wiki.haskell.org/index.php?title=Functor)
-    - [Haskellwiki. Typeclassopedia#Functor](https://wiki.haskell.org/index.php?title=Typeclassopedia#Functor)
-    - [Haskellwiki. Typeclassopedia#Category](https://wiki.haskell.org/index.php?title=Typeclassopedia#Category)
-    """)
+        - [Haskellwiki. Functor](https://wiki.haskell.org/index.php?title=Functor)
+        - [Haskellwiki. Typeclassopedia#Functor](https://wiki.haskell.org/index.php?title=Typeclassopedia#Functor)
+        - [Haskellwiki. Typeclassopedia#Category](https://wiki.haskell.org/index.php?title=Typeclassopedia#Category)
+        """
+    )
     return
 
 
@@ -1227,9 +1260,14 @@ def _():
 
 
 @app.cell(hide_code=True)
-def _(TypeVar):
+def _():
+    from dataclasses import dataclass
+    from typing import Callable, Generic, TypeVar
+
+    a = TypeVar("a")
+    b = TypeVar("b")
     c = TypeVar("c")
-    return (c,)
+    return Callable, Generic, TypeVar, a, b, c, dataclass
 
 
 if __name__ == "__main__":

functional_programming/CHANGELOG.md

@@ -3,3 +3,7 @@
 ## 2025-03-11
 
 * Demo version of notebook `05_functors.py`
+
+## 2025-03-13
+
+* `0.1.0` version of notebook `05_functors`