refactor(functors): `v0.1.3` of `functors` notebook

* restructure the notebook
* replace `f` in the function signatures with `g` to indicate regular functions and distinguish from functors

functional_programming/05_functors.py

@@ -7,8 +7,11 @@
 
 import marimo
 
-__generated_with = "0.12.0"
-app = marimo.App(app_title="Category Theory and Functors")
+__generated_with = "0.12.5"
+app = marimo.App(
+    app_title="Category Theory and Functors",
+    css_file="/Users/chanhuizhihou/Library/Application Support/mtheme/themes/gruvbox.css",
+)
 
 
 @app.cell(hide_code=True)
@@ -37,7 +40,7 @@ def _(mo):
         /// details | Notebook metadata
             type: info
 
-        version: 0.1.2 | last modified: 2025-04-02 | author: [métaboulie](https://github.com/metaboulie)<br/>
+        version: 0.1.3 | last modified: 2025-04-08 | author: [métaboulie](https://github.com/metaboulie)<br/>
         reviewer: [Haleshot](https://github.com/Haleshot)
 
         ///
@@ -77,7 +80,7 @@ def _(mo):
 
         ```python
         from dataclasses import dataclass
-        from typing import Callable, TypeVar
+        from typing import TypeVar
 
         A = TypeVar("A")
         B = TypeVar("B")
@@ -96,9 +99,6 @@ def _(mo):
         ### Mapping Functions Over Wrapped Data
 
         To modify wrapped data while keeping it wrapped, we define an `fmap` method:
-
-
-
         """
     )
     return
@@ -111,14 +111,33 @@ def _(B, Callable, Functor, dataclass):
         value: A
 
         @classmethod
-        def fmap(cls, f: Callable[[A], B], fa: "Wrapper[A]") -> "Wrapper[B]":
-            return Wrapper(f(fa.value))
+        def fmap(cls, g: Callable[[A], B], fa: "Wrapper[A]") -> "Wrapper[B]":
+            return Wrapper(g(fa.value))
     return (Wrapper,)
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(r"""> Try with Wrapper below""")
+    mo.md(
+        r"""
+        /// attention
+
+        To distinguish between regular types and functors, we use the prefix `f` to indicate `Functor`.
+
+        For instance,
+
+        - `a: A` is a regular variable of type `A`
+        - `g: Callable[[A], B]` is a regular function from type `A` to `B`
+        - `fa: Functor[A]` is a *Functor* wrapping a value of type `A`  
+        - `fg: Functor[Callable[[A], B]]` is a *Functor* wrapping a function from type `A` to `B`  
+
+        and we will avoid using `f` to represent a function
+
+        ///
+
+        > Try with Wrapper below
+        """
+    )
     return
 
 
@@ -137,14 +156,14 @@ def _(mo):
         """
         We can analyze the type signature of `fmap` for `Wrapper`:
 
-        * `f` is of type `Callable[[A], B]`
+        * `g` is of type `Callable[[A], B]`
         * `fa` is of type `Wrapper[A]`
         * The return value is of type `Wrapper[B]`
 
         Thus, in Python's type system, we can express the type signature of `fmap` as:
 
         ```python
-        fmap(f: Callable[[A], B], fa: Wrapper[A]) -> Wrapper[B]:
+        fmap(g: Callable[[A], B], fa: Wrapper[A]) -> Wrapper[B]:
         ```
 
         Essentially, `fmap`:
@@ -163,7 +182,7 @@ def _(mo):
 def _(mo):
     mo.md(
         """
-        ## The List Wrapper
+        ## The List Functor
 
         We can define a `List` class to represent a wrapped list that supports `fmap`:
         """
@@ -178,8 +197,8 @@ def _(B, Callable, Functor, dataclass):
         value: list[A]
 
         @classmethod
-        def fmap(cls, f: Callable[[A], B], fa: "List[A]") -> "List[B]":
-            return List([f(x) for x in fa.value])
+        def fmap(cls, g: Callable[[A], B], fa: "List[A]") -> "List[B]":
+            return List([g(x) for x in fa.value])
     return (List,)
 
 
@@ -206,19 +225,19 @@ def _(mo):
         The type signature of `fmap` for `List` is:
 
         ```python
-        fmap(f: Callable[[A], B], fa: List[A]) -> List[B]
+        fmap(g: Callable[[A], B], fa: List[A]) -> List[B]
         ```
 
         Similarly, for `Wrapper`:
 
         ```python
-        fmap(f: Callable[[A], B], fa: Wrapper[A]) -> Wrapper[B]
+        fmap(g: Callable[[A], B], fa: Wrapper[A]) -> Wrapper[B]
         ```
 
         Both follow the same pattern, which we can generalize as:
 
         ```python
-        fmap(f: Callable[[A], B], fa: Functor[A]) -> Functor[B]
+        fmap(g: Callable[[A], B], fa: Functor[A]) -> Functor[B]
         ```
 
         where `Functor` can be `Wrapper`, `List`, or any other wrapper type that follows the same structure.
@@ -256,24 +275,15 @@ def _(mo):
         To define `Functor` in Python, we use an abstract base class:
 
         ```python
-        from dataclasses import dataclass
-        from typing import Callable, TypeVar
-        from abc import ABC, abstractmethod
-
-        A = TypeVar("A")
-        B = TypeVar("B")
-
         @dataclass
         class Functor[A](ABC):
             @classmethod
             @abstractmethod
-            def fmap(f: Callable[[A], B], fa: "Functor[A]") -> "Functor[B]":
+            def fmap(g: Callable[[A], B], fa: "Functor[A]") -> "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.
-
-        Next, let's implement a more complex data structure: [RoseTree](https://en.wikipedia.org/wiki/Rose_tree).
         """
     )
     return
@@ -282,96 +292,106 @@ def _(mo):
 @app.cell(hide_code=True)
 def _(mo):
     mo.md(
-        """
-        ## Case Study: RoseTree
+        r"""
+        ## The Maybe Functor
 
-        A **RoseTree** is a tree where:
+        **`Maybe`** is a functor that can either hold a value (`Just(value)`) or be `Nothing` (equivalent to `None` in Python). 
 
-        - Each node holds a **value**.
-        - Each node has a **list of child nodes** (which are also RoseTrees).
+        - It the value exists, `fmap` applies the function to this value inside the functor.
+        - If the value is `None`, `fmap` simply returns `None`.
 
-        This structure is useful for representing hierarchical data, such as:
+        /// admonition
+        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.
+        ///
 
-        - Abstract Syntax Trees (ASTs)
-        - File system directories
-        - Recursive computations
+        We can implement the `Maybe` functor as: 
+        """
+    )
+    return
 
-        We can implement `RoseTree` by extending the `Functor` class:
 
-        ```python
-        from dataclasses import dataclass
-        from typing import Callable, TypeVar
+@app.cell
+def _(B, Callable, Functor, dataclass):
+    @dataclass
+    class Maybe[A](Functor):
+        value: None | A
 
-        A = TypeVar("A")
-        B = TypeVar("B")
+        @classmethod
+        def fmap(cls, g: Callable[[A], B], fa: "Maybe[A]") -> "Maybe[B]":
+            return cls(None) if fa.value is None else cls(g(fa.value))
 
-        @dataclass
-        class RoseTree[A](Functor):
+        def __repr__(self):
+            return "Nothing" if self.value is None else f"Just({self.value!r})"
+    return (Maybe,)
 
-            value: A
-            children: list["RoseTree[A]"]
 
-            @classmethod
-            def fmap(cls, f: Callable[[A], B], fa: "RoseTree[A]") -> "RoseTree[B]":
-                return RoseTree(
-                    f(fa.value), [cls.fmap(f, child) for child in fa.children]
-                )
+@app.cell
+def _(Maybe, pp):
+    pp(Maybe.fmap(lambda x: x + 1, Maybe(1)))
+    pp(Maybe.fmap(lambda x: x + 1, Maybe(None)))
+    return
 
-            def __repr__(self) -> str:
-                return f"Node: {self.value}, Children: {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.
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        ## More Functor instances (optional)
 
-        > Try using `RoseTree` in the cell below.
+        In this section, we will explore more *Functor* instances to help you build up a better comprehension.
+
+        The main reference is [Data.Functor](https://hackage.haskell.org/package/base-4.21.0.0/docs/Data-Functor.html)
         """
     )
     return
 
 
 @app.cell(hide_code=True)
-def _(B, Callable, Functor, dataclass, mo):
-    @dataclass
-    class RoseTree[A](Functor):
+def _(mo):
+    mo.md(
         """
-        ### Doc: RoseTree
-
-        A Functor implementation of `RoseTree`, allowing transformation of values while preserving the tree structure.
+        ### The [RoseTree](https://en.wikipedia.org/wiki/Rose_tree) Functor
 
-        **Attributes**
-
-        - `value (A)`: The value stored in the node.
-        - `children (list[RoseTree[A]])`: A list of child nodes forming the tree structure.
-
-        **Methods:**
+        A **RoseTree** is a tree where:
 
-        - `fmap(f: Callable[[A], B], fa: "RoseTree[A]") -> "RoseTree[B]"`
+        - Each node holds a **value**.
+        - Each node has a **list of child nodes** (which are also RoseTrees).
 
-            Applies a function to each value in the tree, producing a new `RoseTree[b]` with transformed values.
+        This structure is useful for representing hierarchical data, such as:
 
-        **Implementation logic:**
+        - Abstract Syntax Trees (ASTs)
+        - File system directories
+        - Recursive computations
 
-          - The function `f` is applied to the root node's `value`.
-          - Each child in `children` recursively calls `fmap`, ensuring all values in the tree are mapped.
-          - The overall tree structure remains unchanged.
+        The implementation is: 
         """
+    )
+    return
 
-        value: A
-        children: list["RoseTree[A]"]
+
+@app.cell
+def _(B, Callable, Functor, dataclass):
+    @dataclass
+    class RoseTree[A](Functor):
+        value: A  # The value stored in the node.
+        children: list[
+            "RoseTree[A]"
+        ]  # A list of child nodes forming the tree structure.
 
         @classmethod
-        def fmap(cls, f: Callable[[A], B], fa: "RoseTree[A]") -> "RoseTree[B]":
+        def fmap(cls, g: Callable[[A], B], fa: "RoseTree[A]") -> "RoseTree[B]":
+            """
+            Applies a function to each value in the tree, producing a new `RoseTree[b]` with transformed values.
+
+            1. `g` is applied to the root node's `value`.
+            2. Each child in `children` recursively calls `fmap`.
+            """
             return RoseTree(
-                f(fa.value), [cls.fmap(f, child) for child in fa.children]
+                g(fa.value), [cls.fmap(g, child) for child in fa.children]
             )
 
         def __repr__(self) -> str:
             return f"Node: {self.value}, Children: {self.children}"
-
-
-    mo.md(RoseTree.__doc__)
     return (RoseTree,)
 
 
@@ -402,7 +422,7 @@ def _(mo):
         Translating to Python, we get:
 
         ```python
-        def fmap(func: Callable[[A], B]) -> Callable[[Functor[A]], Functor[B]]
+        def fmap(g: Callable[[A], B]) -> Callable[[Functor[A]], Functor[B]]
         ```
 
         This means that `fmap`:
@@ -412,51 +432,42 @@ def _(mo):
             - Takes a **functor** of type `Functor[A]` as input.
             - Outputs a **functor** of type `Functor[B]`.
 
-        We can implement a similar idea in Python:
-
-        ```python
-        fmap = lambda f, functor: functor.__class__.fmap(f, functor)
-        inc = lambda functor: fmap(lambda x: x + 1, functor)
-        ```
-
-        - **`fmap`**: Lifts an ordinary function (`f`) 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.
+        Inspired by this, we can implement an `inc` function which takes a functor, applies the function `lambda x: x + 1` to every value inside it, and returns a new functor with the updated values.
+        """
+    )
+    return
 
-        ### Applying the `inc` Function to Various Functors
 
-        You can now apply `inc` to any functor like `Wrapper`, `List`, or `RoseTree`:
+@app.cell
+def _():
+    inc = lambda functor: functor.fmap(lambda x: x + 1, functor)
+    return (inc,)
 
-        ```python
-        # Applying `inc` to a Wrapper
-        wrapper = Wrapper(5)
-        inc(wrapper)  # Wrapper(value=6)
 
-        # Applying `inc` to a List
-        list_wrapper = List([1, 2, 3])
-        inc(list_wrapper)  # List(value=[2, 3, 4])
+@app.cell
+def _(flist, inc, pp, rosetree, wrapper):
+    pp(inc(wrapper))
+    pp(inc(flist))
+    pp(inc(rosetree))
+    return
 
-        # 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.
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        /// admonition | exercise
+        Implement other generic functions and apply them to different *Functor* instances.
+        ///
         """
     )
     return
 
 
-@app.cell
-def _(flist, pp, rosetree, wrapper):
-    fmap = lambda f, functor: functor.__class__.fmap(f, functor)
-    inc = lambda functor: fmap(lambda x: x + 1, functor)
-
-    pp(inc(wrapper))
-    pp(inc(flist))
-    pp(inc(rosetree))
-    return fmap, inc
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(r"""# Functor laws and utility functions""")
+    return
 
 
 @app.cell(hide_code=True)
@@ -476,25 +487,20 @@ def _(mo):
         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.mo) as well.
+        - 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.
         ///
+        """
+    )
+    return
 
-        ### Functor Law Verification
-
-        We can define `id` and `compose` in `Python` as below:
-
-        ```python
-        id = lambda x: x
-        compose = lambda f, g: lambda x: f(g(x))
-        ```
-
-        We can add a helper function `check_functor_law` to verify that an instance satisfies the functor laws.
 
-        ```Python
-        check_functor_law = lambda functor: repr(fmap(id, functor)) == repr(functor)
-        ```
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        ### Functor Law Verification
 
-        We can verify the functor we've defined.
+        We can define `id` and `compose` in `Python` as:
         """
     )
     return
@@ -507,12 +513,26 @@ def _():
     return compose, id
 
 
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(r"""We can add a helper function `check_functor_law` to verify that an instance satisfies the functor laws:""")
+    return
+
+
 @app.cell
-def _(fmap, id):
-    check_functor_law = lambda functor: repr(fmap(id, functor)) == repr(functor)
+def _(id):
+    check_functor_law = lambda functor: repr(functor.fmap(id, functor)) == repr(
+        functor
+    )
     return (check_functor_law,)
 
 
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(r"""We can verify the functor we've defined:""")
+    return
+
+
 @app.cell
 def _(check_functor_law, flist, pp, rosetree, wrapper):
     for functor in (wrapper, flist, rosetree):
@@ -522,187 +542,82 @@ def _(check_functor_law, flist, pp, rosetree, wrapper):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        And here is an `EvilFunctor`. We can verify it's not a valid `Functor`.
-
-        ```python
-        @dataclass
-        class EvilFunctor[A](Functor):
-            value: list[A]
-
-            @classmethod
-            def fmap(cls, f: Callable[[A], B], fa: "EvilFunctor[A]") -> "EvilFunctor[B]":
-                return (
-                    cls([fa.value[0]] * 2 + list(map(f, fa.value[1:])))
-                    if fa.value
-                    else []
-                )
-        ```
-        """
-    )
+    mo.md("""And here is an `EvilFunctor`. We can verify it's not a valid `Functor`.""")
     return
 
 
 @app.cell
-def _(B, Callable, Functor, check_functor_law, dataclass, pp):
+def _(B, Callable, Functor, dataclass):
     @dataclass
     class EvilFunctor[A](Functor):
         value: list[A]
 
         @classmethod
         def fmap(
-            cls, f: Callable[[A], B], fa: "EvilFunctor[A]"
+            cls, g: Callable[[A], B], fa: "EvilFunctor[A]"
         ) -> "EvilFunctor[B]":
             return (
-                cls([fa.value[0]] * 2 + [f(x) for x in fa.value[1:]])
+                cls([fa.value[0]] * 2 + [g(x) for x in fa.value[1:]])
                 if fa.value
                 else []
             )
+    return (EvilFunctor,)
 
 
+@app.cell
+def _(EvilFunctor, check_functor_law, pp):
     pp(check_functor_law(EvilFunctor([1, 2, 3, 4])))
-    return (EvilFunctor,)
+    return
 
 
-@app.cell(hide_code=True)
+@app.cell
 def _(mo):
     mo.md(
-        """
-        ## Final definition of Functor
-
-        We can now draft the final definition of `Functor` with some utility functions.
-
-        ```Python
-            @classmethod
-            @abstractmethod
-            def fmap(cls, f: Callable[[A], B], fa: "Functor[A]") -> "Functor[B]":
-                return NotImplementedError
-
-            @classmethod
-            def const_fmap(cls, fa: "Functor[A]", b: B) -> "Functor[B]":
-                return cls.fmap(lambda _: b, fa)
-
-            @classmethod
-            def void(cls, fa: "Functor[A]") -> "Functor[None]":
-                return cls.const_fmap(fa, None)
-        ```
-        """
-    )
-    return
-
-
-@app.cell(hide_code=True)
-def _(ABC, B, Callable, abstractmethod, dataclass, mo):
-    @dataclass
-    class Functor[A](ABC):
-        """
-        ### Doc: Functor
-
-        A generic interface for types that support mapping over their values.
-
-        **Methods:**
+        r"""
+        ## Utility functions
 
-        - `fmap(f: Callable[[A], B], fa: Functor[A]) -> Functor[B]`
-          Abstract method to apply a function to all values inside a functor.
-
-        - `const_fmap(fa: "Functor[A]", b: B) -> Functor[B]`
+        - `const(fa: "Functor[A]", b: B) -> Functor[B]`
           Replaces all values inside a functor with a constant `b`, preserving the original structure.
 
         - `void(fa: "Functor[A]") -> Functor[None]`
-          Equivalent to `const_fmap(fa, None)`, transforming all values in a functor into `None`.
+          Equivalent to `const(fa, None)`, transforming all values in a functor into `None`.
         """
-
-        @classmethod
-        @abstractmethod
-        def fmap(cls, f: Callable[[A], B], fa: "Functor[A]") -> "Functor[B]":
-            return NotImplementedError
-
-        @classmethod
-        def const_fmap(cls, fa: "Functor[A]", b: B) -> "Functor[B]":
-            return cls.fmap(lambda _: b, fa)
-
-        @classmethod
-        def void(cls, fa: "Functor[A]") -> "Functor[None]":
-            return cls.const_fmap(fa, None)
-
-
-    mo.md(Functor.__doc__)
-    return (Functor,)
-
-
-@app.cell(hide_code=True)
-def _(mo):
-    mo.md("""> Try with utility functions in the cell below""")
+    )
     return
 
 
 @app.cell
 def _(List, RoseTree, flist, pp, rosetree):
-    pp(RoseTree.const_fmap(rosetree, "λ"))
+    pp(RoseTree.const(rosetree, "λ"))
     pp(RoseTree.void(rosetree))
-    pp(List.const_fmap(flist, "λ"))
+    pp(List.const(flist, "λ"))
     pp(List.void(flist))
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md(
-        """
-        ## Functors for Non-Iterable Types
-
-        In the previous examples, we implemented functors for **iterables**, like `List` 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.
-
-        ### The Maybe Functor
-
-        One example is the **`Maybe`** type from Haskell, which is used to represent computations that can either result in a value or no value (`Nothing`). 
-
-        We can define the `Maybe` functor as below:
-        """
-    )
+    mo.md("""# Formal implementation of Functor""")
     return
 
 
 @app.cell
-def _(B, Callable, Functor, dataclass):
+def _(ABC, B, Callable, abstractmethod, dataclass):
     @dataclass
-    class Maybe[A](Functor):
-        value: None | A
-
+    class Functor[A](ABC):
         @classmethod
-        def fmap(cls, f: Callable[[A], B], fa: "Maybe[A]") -> "Maybe[B]":
-            return cls(None) if fa.value is None else cls(f(fa.value))
-
-        def __repr__(self):
-            return "Nothing" if self.value is None else repr(self.value)
-    return (Maybe,)
-
-
-@app.cell(hide_code=True)
-def _(mo):
-    mo.md(
-        """
-        **`Maybe`** is a functor that can either hold a value or be `Nothing` (equivalent to `None` in Python). The `fmap` method applies a function to the value inside the functor, if it exists. If the value is `None` (representing `Nothing`), `fmap` simply returns `None`.
-
-        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.
-        """
-    )
-    return
-
+        @abstractmethod
+        def fmap(cls, g: Callable[[A], B], fa: "Functor[A]") -> "Functor[B]":
+            return NotImplementedError
 
-@app.cell
-def _(Maybe, pp):
-    mint = Maybe(1)
-    mnone = Maybe(None)
+        @classmethod
+        def const(cls, fa: "Functor[A]", b: B) -> "Functor[B]":
+            return cls.fmap(lambda _: b, fa)
 
-    pp(Maybe.fmap(lambda x: x + 1, mint))
-    pp(Maybe.fmap(lambda x: x + 1, mnone))
-    return mint, mnone
+        @classmethod
+        def void(cls, fa: "Functor[A]") -> "Functor[None]":
+            return cls.const(fa, None)
+    return (Functor,)
 
 
 @app.cell(hide_code=True)
@@ -851,7 +766,7 @@ def _(mo):
 
         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. 
 
-        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 `Callable[[RoseTree[T]], RoseTree[U]]` for types `T`, `U`.
+        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 `Callable[[RoseTree[T]], RoseTree[U]]` for types `T`, `U`.
 
         Recall the definition of `Functor`:
 
@@ -892,8 +807,8 @@ def _(mo):
 
         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)}$
+        1. Given an identity morphism $id_A$ on an object $A$, $F ( id_A )$ must be the identity morphism on $F ( A )$, i.e.: $F({id} _{A})={id} _{F(A)}$
+        2. Functors must distribute over morphism composition, i.e. $F(f\circ g)=F(f)\circ F(g)$
         """
     )
     return
@@ -903,22 +818,22 @@ def _(mo):
 def _(mo):
     mo.md(
         """
-        Remember that we defined the `fmap`, `id` and `compose` as 
+        Remember that we defined the `id` and `compose` as 
         ```python
-        fmap = lambda f, functor: functor.__class__.fmap(f, functor)  
         id = lambda x: x
         compose = lambda f, g: lambda x: f(g(x))
         ```
 
-        Let's prove that `fmap` is a functor.
+        We can define `fmap` as: 
 
-        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. `List`, `RoseTree`, `Maybe` and more):
-
-        **Notice that** in this case, we can actually view `fmap` as:
         ```python
-        fmap = lambda f, functor: functor.fmap(f, functor)  
+        fmap = lambda g, functor: functor.fmap(g, functor)  
         ```
 
+        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. `List`, `RoseTree`, `Maybe` and more):
+
         We define `WrapperCategory` as:
 
         ```python
@@ -945,8 +860,8 @@ def _(mo):
             value: A
 
             @classmethod
-            def fmap(cls, f: Callable[[A], B], a: "Wrapper[A]") -> "Wrapper[B]":
-                return Wrapper(f(a.value))
+            def fmap(cls, g: Callable[[A], B], fa: "Wrapper[A]") -> "Wrapper[B]":
+                return Wrapper(g(fa.value))
         ```
         """
     )
@@ -1009,8 +924,8 @@ def _(A, B, C, Callable, Wrapper, dataclass):
 
 
 @app.cell
-def _(WrapperCategory, fmap, id, pp, wrapper):
-    pp(fmap(id, wrapper) == WrapperCategory.id(wrapper))
+def _(WrapperCategory, id, pp, wrapper):
+    pp(wrapper.fmap(id, wrapper) == WrapperCategory.id(wrapper))
     return
 
 
@@ -1020,7 +935,7 @@ def _(mo):
         """
         ## 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**.
 
@@ -1136,18 +1051,20 @@ def _(mo):
 
         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.
+        **Identity Law**
 
-        ```python
-        > length(ListConcatenation.id()) == IntAddition.id()
-        True
-        ```
+        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
 
 
+@app.cell
+def _(IntAddition, ListConcatenation, length, pp):
+    pp(length(ListConcatenation.id()) == IntAddition.id())
+    return
+
+
 @app.cell(hide_code=True)
 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).""")
@@ -1158,31 +1075,16 @@ def _(mo):
 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.
+        **Composition Law**
 
-        ```python
-        > lista = ListConcatenation([1, 2])
-        > listb = ListConcatenation([3, 4])
-        > length(ListConcatenation.compose(lista, listb)) == IntAddition.compose(
-        >     length(lista), length(listb)
-        > )
-        True
-        ```
+        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
 
 
-@app.cell(hide_code=True)
-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
 def _(IntAddition, ListConcatenation, length, pp):
-    pp(length(ListConcatenation.id()) == IntAddition.id())
     lista = ListConcatenation([1, 2])
     listb = ListConcatenation([3, 4])
     pp(
@@ -1192,6 +1094,12 @@ def _(IntAddition, ListConcatenation, length, pp):
     return lista, listb
 
 
+@app.cell(hide_code=True)
+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 _(mo):
     mo.md(
@@ -1199,17 +1107,17 @@ def _(mo):
         # 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)
+        - [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. 
             ///
 
-        - [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)
+        - [Haskellwiki: Category Theory](https://en.wikibooks.org/wiki/Haskell/Category_theory)
         """
     )
     return

functional_programming/CHANGELOG.md

@@ -1,8 +1,17 @@
 # Changelog of the functional-programming course
 
+## 2025-04-08
+
+**functors.py**
+
+* restructure the notebook
+* replace `f` in the function signatures with `g` to indicate regular functions and distinguish from functors
+
 ## 2025-04-02
 
-+ Migrate to `python3.13` for `05_functors`
+**functors.py**
+
++ Migrate to `python3.13`
 
     + Replace all occurrences of