Improve notebook and README as suggested by Haleshot

functional_programming/05_functors.py

@@ -1,3 +1,9 @@
+# /// script
+# requires-python = ">=3.9"
+# dependencies = [
+#     "marimo",
+# ]
+# ///
 import marimo
 
 __generated_with = "0.11.17"
@@ -723,19 +729,24 @@ def _(mo):
     return
 
 
+@app.cell
+def _(Just, Maybe, ftree):
+    mftree = Maybe(Just(ftree))
+    mint = Maybe(Just(1))
+    mnone = Maybe(None)
+    return mftree, mint, mnone
+
+
 @app.cell(hide_code=True)
-def _(Just, Maybe, ftree, inc, mo):
+def _(inc, mftree, mint, mnone, mo):
     with mo.redirect_stdout():
-        mftree = Maybe(Just(ftree))
-        mint = Maybe(Just(1))
-        mnone = Maybe(None)
         print(mftree.check_functor_law())
         print(mint.check_functor_law())
         print(mnone.check_functor_law())
         print(mftree.fmap(inc))
         print(mint.fmap(lambda x: x + 1))
         print(mnone.fmap(lambda x: x + 1))
-    return mftree, mint, mnone
+    return
 
 
 @app.cell(hide_code=True)
@@ -1205,15 +1216,18 @@ def _(mo):
 
 
 @app.cell
-def _(IntAddition, ListConcatentation, length):
+def _(ListConcatentation):
     lista = ListConcatentation([1, 2])
     listb = ListConcatentation([3, 4])
+    return lista, listb
 
 
+@app.cell
+def _(IntAddition, ListConcatentation, length, lista, listb):
     length(ListConcatentation.compose(lista, listb)) == IntAddition.compose(
         length(lista), length(listb)
     )
-    return lista, listb
+    return
 
 
 @app.cell(hide_code=True)
@@ -1248,9 +1262,7 @@ def _(mo):
 @app.cell(hide_code=True)
 def _():
     import marimo as mo
-
-    from marimo import md, mermaid
-    return md, mermaid, mo
+    return (mo,)
 
 
 @app.cell(hide_code=True)
@@ -1263,11 +1275,15 @@ def _():
 def _():
     from dataclasses import dataclass
     from typing import Callable, Generic, TypeVar
+    return Callable, Generic, TypeVar, dataclass
+
 
+@app.cell(hide_code=True)
+def _(TypeVar):
     a = TypeVar("a")
     b = TypeVar("b")
     c = TypeVar("c")
-    return Callable, Generic, TypeVar, a, b, c, dataclass
+    return a, b, c
 
 
 if __name__ == "__main__":

functional_programming/README.md

@@ -1,24 +1,33 @@
-# Functional Programming in Python with Marimo
+# Learn Functional Programming
 
-_🚧 This collection is a [work in progress](https://github.com/marimo-team/learn/issues/51)._
+_🚧 This collection is a
+[work in progress](https://github.com/marimo-team/learn/issues/51)._
 
-This series of marimo notebooks introduces the powerful paradigm of functional programming through Python. Taking inspiration from Haskell and Category Theory, we'll build a strong foundation in FP concepts that can transform how you approach software development.
+This series of marimo notebooks introduces the powerful paradigm of functional
+programming through Python. Taking inspiration from Haskell and Category Theory,
+we'll build a strong foundation in FP concepts that can transform how you
+approach software development.
 
 ## What You'll Learn
 
-**Using only Python's standard library**, we'll construct functional programming concepts from first principles.
+**Using only Python's standard library**, we'll construct functional programming
+concepts from first principles.
 
 Topics include:
-- Recursion and higher-order functions
-- Category theory fundamentals
-- Functors, applicatives, and monads
-- Composable abstractions for robust code
+
+-   Recursion and higher-order functions
+-   Category theory fundamentals
+-   Functors, applicatives, and monads
+-   Composable abstractions for robust code
 
 ## Timeline & Collaboration
 
-I'm currently studying functional programming and Haskell, estimating about 2 months or even longer to complete this series. The structure may evolve as the project develops.
+I'm currently studying functional programming and Haskell, estimating about 2
+months or even longer to complete this series. The structure may evolve as the
+project develops.
 
-If you're interested in collaborating or have questions, please reach out to me on Discord (@eugene.hs).
+If you're interested in collaborating or have questions, please reach out to me
+on Discord (@eugene.hs).
 
 **Running notebooks.** To run a notebook locally, use
 
@@ -33,51 +42,20 @@ uvx marimo edit https://github.com/marimo-team/learn/blob/main/Functional_progra
 ```
 
 You can also open notebooks in our online playground by appending `marimo.app/`
-to a notebook's URL: [marimo.app/github.com/marimo-team/learn/blob/main/functional_programming/05_functors.py](https://marimo.app/https://github.com/marimo-team/learn/blob/main/functional_programming/05_functors.py).
-
-## Current series structure
-
-
-| Notebook | Description | Status | Author |
-|----------|-------------|--------|--------|
-| Functional Programming Fundamentals | Core FP principles in Python, comparison with imperative programming, and Haskell-inspired thinking patterns | 🚧 | |
-| Higher-Order Functions and Currying | Functions as first-class values, composition patterns, and implementing Haskell-style currying in Python | 🚧 | |
-| Python's Functional Toolkit: functools, itertools and operator | Leveraging Python's built-in functional programming utilities, advanced iterator operations, and function transformations | 🚧 | |
-| Recursion and Tail Recursion | Recursive problem solving, implementing tail-call optimization in Python, and trampoline techniques to avoid stack overflow | 🚧 | |
-| Category Theory and Functors | Introduction to categories, morphisms, functor patterns, and implementing the functor interface and practical use cases | `0.1.0` | |
-| Applicatives and Effectful Programming | Combining independent computations with effects, implementing the applicative interface and practical use cases | 🚧 | |
-| Kleisli Category and Monads | Understanding monadic computation, composing impure functions, and implementing basic monads | 🚧 | |
-| Monad Fail, Transformers and Fix | Error handling with MonadFail, combining monads with transformers, and handling recursive structures | 🚧 | |
-| Monadic Parsing | Building a parser combinator library, implementing recursive descent parsers, and practical text processing | 🚧 | |
-| Semigroups and Monoids | Composable operations, algebraic structures, laws, and practical applications for data aggregation | 🚧 | |
-| Foldables and Traversables | Abstract folding beyond lists, traversing with effects, and implementing these interfaces for custom data types | 🚧 | |
-| Bifunctors | Working with two-parameter type constructors, implementing the bifunctor interface, and practical examples | 🚧 | |
-| Arrows | Arrow abstractions beyond monads, implementing the Arrow interface, and creating arrow-based computations | 🚧 | |
-| Comonads | Understanding dual concepts to monads, implementing Store and Stream comonads, and practical applications | 🚧 | |
-| Design Patterns in Functional Python | Applying FP concepts to solve real-world problems, functional architecture, and testing strategies | 🚧 | |
+to a notebook's URL:
+[marimo.app/github.com/marimo-team/learn/blob/main/functional_programming/05_functors.py](https://marimo.app/https://github.com/marimo-team/learn/blob/main/functional_programming/05_functors.py).
 
 # Description of notebooks
 
-## 05. Category and Functors
-
-In [this notebook](https://github.com/marimo-team/learn/blob/main/Functional_programming/05_functors.py), you would learn:
-
-* Why `len` is the *Functor* from the category of `list concatentation` to the category of `integer addition`
-* How to *lift* an ordinary function to a specific *computation context*
-* How to write an *adpter* between two categories
-
-### References
+Check [here](https://github.com/marimo-team/learn/issues/51) for current series
+structure.
 
-- [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)
-- [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)
+| Notebook                                                                                                          | Description                                                                                                                                                                                            | References                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| ----------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| [05. Category and Functors](https://github.com/marimo-team/learn/blob/main/Functional_programming/05_functors.py) | Learn why `len` is a _Functor_ from `list concatenation` to `integer addition`, how to _lift_ an ordinary function into a _computation context_, and how to write an _adapter_ between two categories. | - [The Trivial Monad](http://blog.sigfpe.com/2007/04/trivial-monad.html) <br> - [Haskellwiki. Category Theory](https://en.wikibooks.org/wiki/Haskell/Category_theory) <br> - [Haskellforall. The Category Design Pattern](https://www.haskellforall.com/2012/08/the-category-design-pattern.html) <br> - [Haskellforall. The Functor Design Pattern](https://www.haskellforall.com/2012/09/the-functor-design-pattern.html) <br> - [Haskellwiki. Functor](https://wiki.haskell.org/index.php?title=Functor) <br> - [Haskellwiki. Typeclassopedia#Functor](https://wiki.haskell.org/index.php?title=Typeclassopedia#Functor) <br> - [Haskellwiki. Typeclassopedia#Category](https://wiki.haskell.org/index.php?title=Typeclassopedia#Category) |
 
 **Authors.**
 
 Thanks to all our notebook authors!
 
-* [métaboulie](https://github.com/metaboulie)
+-   [métaboulie](https://github.com/metaboulie)