monadic_do: final expression joins the list; drop the in separator

Third and last UX pass before shipping. The `in` separator was a vestige
of the `let[]` syntax origins; in a monadic do-block, every line is
morally "one step of the computation" — bindings and the final
expression alike — so they all belong in the same list.

Before:
    with monadic_do[List] as pt:
        [z := r(1, 21),
         x := r(1, z + 1),
         y := r(x, z + 1),
         List.guard(x*x + y*y == z*z)] in List((x, y, z))

After (item-for-item identical to the Haskell do-block it models):
    with monadic_do[List] as pt:
        [z := r(1, 21),
         x := r(1, z + 1),
         y := r(x, z + 1),
         List.guard(x*x + y*y == z*z),
         List((x, y, z))]

Rule: body is a single list literal. All items except the last are
binds (`name := mexpr`, `name << mexpr` legacy, or bare `mexpr` for
sequencing); the last item is the final monadic expression. The
previous empty-bindings shorthand `[] in M.unit(x)` now reads as the
natural single-element list `[M.unit(x)]`.

Also: .gitignore extended to cover stray artifacts (`.coverage`,
`codecov-token`, scratch files) that nearly made it into an earlier
commit.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: Technologicat

.gitignore

@@ -13,3 +13,19 @@ pdm.lock
 *.egg-info
 *.mypy_cache
 .python-version
+
+# Coverage artifacts
+.coverage
+coverage.xml
+htmlcov/
+
+# Secrets — should never be committed
+codecov-token
+*.token
+.env
+
+# Scratch / local-only files
+coverage-notes.md
+test_system_notes.txt
+contidea.py
+unpythonic/tests/mwe.py

README.md

@@ -734,7 +734,8 @@ from unpythonic.monads import Maybe, List
 # Maybe — do-notation threads present values (`Maybe(value)`); any absence (`Maybe(nil)`) short-circuits.
 with monadic_do[Maybe] as result:
     [x := Maybe(10),
-     y := Maybe(x + 1)] in Maybe(x + y)
+     y := Maybe(x + 1),
+     Maybe(x + y)]
 assert result == Maybe(21)
 
 # List — Pythagorean triples via the list monad. Bare `List.guard(...)`
@@ -745,12 +746,13 @@ with monadic_do[List] as pt:
     [z := r(1, 21),
      x := r(1, z + 1),
      y := r(x, z + 1),
-     List.guard(x*x + y*y == z*z)] in List((x, y, z))
+     List.guard(x*x + y*y == z*z),
+     List((x, y, z))]
 assert tuple(sorted(pt)) == ((3, 4, 5), (5, 12, 13), (6, 8, 10),
                              (8, 15, 17), (9, 12, 15), (12, 16, 20))
 ```
 
-Body shape is a single `[bindings] in final_expr` statement: monadic binds on the left of `in` (`name := mexpr` or bare `mexpr` for sequencing), the final monadic expression on the right (any expression of the right type, like the last line of a Haskell `do`). The `as result` on the `with` names the target.
+Body shape is a single list literal. Each item is one line of a Haskell do-block: `name := mexpr` for monadic bind, `name << mexpr` (legacy) for the same, or bare `mexpr` for sequencing-only (matches Haskell's `guard`-style lines). The last item is the final monadic expression. `as result` on the `with` names the target.
 </details>  
 <details><summary>Genuine multi-shot continuations (call/cc).</summary>
 

doc/macros.md

@@ -1816,12 +1816,12 @@ For code using **conditions and restarts**: there is no special integration betw
 
 Monadic do-notation over any of the monads in [`unpythonic.monads`](features.md#monads) (or, for that matter, any object that implements `__rshift__` as monadic bind).
 
-The body of `with monadic_do[M] as result:` must be a single statement of the form `[bindings] in final_expr`. Each binding is one of:
+The body of `with monadic_do[M] as result:` is a single list literal. Each item corresponds to one line of a Haskell do-block:
 
 - `name := mexpr` — **monadic bind**: unwrap the monadic value and bind it to `name` for subsequent lines. Also accepts the legacy `name << mexpr` form that `letdoutil` understands for `let[]`.
 - a bare `mexpr` — **sequencing-only** (Haskell's `do { mx; ... }`): the monadic value is threaded through the chain but its unwrapped value is discarded. Used e.g. for `guard`-style filter lines.
 
-The RHS of `in` is the final monadic expression — any expression of the right monad type, same semantics as Haskell's last-line-of-do (can be a constructor call, a call to a monad-producing function, anything of type `M a`). The `as result` on the `with` tells the macro where to land the computed value.
+The **last item** is the final monadic expression — any expression of the right monad type, same semantics as Haskell's last-line-of-do (a constructor call, a call to a monad-producing function, anything of type `M a`). The `as result` on the `with` tells the macro where to land the computed value.
 
 ```python
 from unpythonic.syntax import macros, monadic_do
@@ -1831,13 +1831,15 @@ from unpythonic.llist import nil
 # Maybe — happy path
 with monadic_do[Maybe] as result:
     [x := Maybe(10),
-     y := Maybe(x + 1)] in Maybe(x + y)
+     y := Maybe(x + 1),
+     Maybe(x + y)]
 assert result == Maybe(21)
 
 # Maybe — short-circuit. The `y := ...` line is never evaluated.
 with monadic_do[Maybe] as result:
     [x := Maybe(nil),
-     y := Maybe(x + 1)] in Maybe(x + y)
+     y := Maybe(x + 1),
+     Maybe(x + y)]
 assert result == Maybe(nil)
 
 # List — Pythagorean triples. The bare `List.guard(...)` line is a
@@ -1849,12 +1851,13 @@ with monadic_do[List] as pt:
     [z := r(1, 21),
      x := r(1, z + 1),
      y := r(x, z + 1),
-     List.guard(x*x + y*y == z*z)] in List((x, y, z))
+     List.guard(x*x + y*y == z*z),
+     List((x, y, z))]
 assert tuple(sorted(pt)) == ((3, 4, 5), (5, 12, 13), (6, 8, 10),
                              (8, 15, 17), (9, 12, 15), (12, 16, 20))
 ```
 
-Empty bindings are allowed: `[] in M.unit(x)` reduces to `result = M.unit(x)`.
+The no-binds case is just a single-element list: `[M.unit(x)]` reduces to `result = M.unit(x)`.
 
 Expands to a nested lambda-bind chain:
 
@@ -1864,7 +1867,7 @@ result = mx >> (lambda x: my(x) >> (lambda y: final_expr))
 
 Sequencing-only lines (bare `mexpr`) are rewritten to `_ := mexpr` internally and participate in the same chain; their unwrapped value is bound to `_` and ignored.
 
-**Placement in the xmas tree**: `monadic_do` is always the **innermost** `with`. Its body-shape constraint (a single `[bindings] in final_expr` statement) forbids lexically wrapping other `with` blocks inside. Outer two-pass macros (`lazify`, `continuations`, `tco`, `autocurry`, etc.) expand inner macros between their passes, so they will see and edit the expanded bind chain in the right order.
+**Placement in the xmas tree**: `monadic_do` is always the **innermost** `with`. Its body-shape constraint (a single list-literal statement) forbids lexically wrapping other `with` blocks inside. Outer two-pass macros (`lazify`, `continuations`, `tco`, `autocurry`, etc.) expand inner macros between their passes, so they will see and edit the expanded bind chain in the right order.
 
 ```python
 with lazify:

unpythonic/dialects/tests/test_pytkell.py

@@ -248,12 +248,14 @@ def maybe_sqrt(x):
 
         with monadic_do[Maybe] as root4:
             [a := maybe_sqrt(16),
-             b := maybe_sqrt(a)] in Maybe(b)
+             b := maybe_sqrt(a),
+             Maybe(b)]
         test[root4 == Maybe(2.0)]
 
         with monadic_do[Maybe] as bad:
             [a := maybe_sqrt(-1),
-             b := maybe_sqrt(a)] in Maybe(b)
+             b := maybe_sqrt(a),
+             Maybe(b)]
         test[bad == Maybe(nil)]  # noqa: F821 -- `nil` is in the Pytkell dialect
 
         # List — classical Pythagorean triples.
@@ -264,14 +266,16 @@ def r(lo, hi):
             [z := r(1, 21),
              x := r(1, z + 1),
              y := r(x, z + 1),
-             List.guard(x * x + y * y == z * z)] in List((x, y, z))
+             List.guard(x * x + y * y == z * z),
+             List((x, y, z))]
         test[tuple(sorted(pt)) == ((3, 4, 5), (5, 12, 13), (6, 8, 10),
                                    (8, 15, 17), (9, 12, 15), (12, 16, 20))]
 
         # Writer — logged computation.
         with monadic_do[Writer] as w:
             [a := Writer(10, "start; "),
-             b := Writer(a + 1, "+1; ")] in Writer(b * 2, "doubled; ")
+             b := Writer(a + 1, "+1; "),
+             Writer(b * 2, "doubled; ")]
         value, log = w.data
         test[value == 22]
         test[log == "start; +1; doubled; "]

unpythonic/syntax/monadic_do.py

@@ -6,37 +6,33 @@
     with monadic_do[M] as result:
         [x := mx,
          y := my(x),
-         M.guard(...)] in M.unit(x + y)
+         M.guard(...),
+         M.unit(x + y)]
 
-Expands to::
+The body is a single list literal. Each item corresponds to one line of
+a Haskell do-block. The **last item** is the final monadic expression
+(any expression of type ``M a``, matching Haskell's last-line-of-do).
+All **earlier items** are binds:
 
-    result = mx >> (lambda x: my(x) >> (lambda _: M.guard(...) >> (lambda _: M.unit(x + y))))
-
-The bindings list on the left of ``in`` uses the same ``:=`` / ``<<``
-binding syntax that ``let`` uses, parsed by ``letdoutil.canonize_bindings``.
+- ``name := mexpr`` — monadic bind: the unwrapped value is bound to
+  ``name`` for subsequent lines.
+- ``name << mexpr`` — legacy alternative for ``:=`` (same shapes
+  ``letdoutil`` recognizes for ``let[]``).
+- a bare ``mexpr`` — sequencing-only (Haskell's ``do { mx; ... }``): the
+  result is threaded but discarded. The short-circuit behavior of the
+  monad still applies (``Maybe(nil)``, ``Left``, empty ``List`` all
+  cancel the rest of the chain).
 
-- A ``name := mexpr`` entry introduces a monadic bind: the ``name`` is
-  bound to the unwrapped value for subsequent lines.
-- A bare ``mexpr`` entry (no ``:=``) is a sequencing-only line — matches
-  Haskell do-notation's bare-expression form, used e.g. for ``guard``:
-  the result is threaded through the chain but discarded, so the whole
-  shape short-circuits for monads that do (Maybe's ``Nothing``, List's
-  empty, Either's ``Left``, etc.).
+Expands to a nested lambda-bind chain::
 
-The RHS of ``in`` is simply the final monadic expression — same
-semantics as Haskell, where the last line of a ``do`` block is any
-monadic value (``return (...)``, a direct constructor call, or a call
-to a monad-producing function). No specific form required.
-
-Empty bindings shorthand is supported: ``[] in M.unit(x)`` expands to
-just ``result = M.unit(x)``.
+    result = mx >> (lambda x: my(x) >> (lambda _: M.guard(...) >> (lambda _: M.unit(x + y))))
 
 **Placement in the xmas tree**: always the innermost ``with``. Its body
-shape (a single ``[bindings] in final_expr`` statement) forbids
-lexically wrapping other ``with`` blocks inside it, and outer two-pass
-macros (``lazify``, ``continuations``, ``tco``, ``autocurry``, etc.)
-expand inner macros between their two passes, which means they will
-correctly see and edit the expanded bind chain.
+shape (a single list-literal statement) forbids lexically wrapping other
+``with`` blocks inside it, and outer two-pass macros (``lazify``,
+``continuations``, ``tco``, ``autocurry``, etc.) expand inner macros
+between their two passes, which means they will correctly see and edit
+the expanded bind chain.
 
 **Always in its own nested ``with``** — unlike the other xmas-tree
 macros which chain in one ``with`` for brevity, ``monadic_do[M] as result``
@@ -46,7 +42,7 @@
 
 __all__ = ["monadic_do"]
 
-from ast import Compare, In, List, Name, NamedExpr, BinOp, LShift, Expr, Assign, Store, arg, expr
+from ast import List, Name, NamedExpr, BinOp, LShift, Expr, Assign, Store, arg, expr
 
 from mcpyrate.quotes import macros, q, a, n  # noqa: F401
 
@@ -91,47 +87,37 @@ def _monadic_do(block_body: list, monad_type: expr, result_name: str) -> list:
     # Expand inner macros first (outside-in), just like `forall` and `autoref` do.
     block_body = dyn._macro_expander.visit_recursively(block_body)
 
-    # Body must be exactly one statement, an Expr wrapping a Compare(In).
+    # Body must be exactly one statement, an Expr wrapping a List literal.
     if len(block_body) != 1:
         raise SyntaxError(
-            f"monadic_do body must be a single statement of the form "
-            f"`[bindings] in final_expr`, got {len(block_body)} statements"
+            f"monadic_do body must be a single list-literal statement, got {len(block_body)} statements"
         )  # pragma: no cover
     stmt = block_body[0]
-    if type(stmt) is not Expr:
+    if type(stmt) is not Expr or type(stmt.value) is not List:
         raise SyntaxError(
-            "monadic_do body must be a single expression statement "
-            "`[bindings] in final_expr`"
-        )  # pragma: no cover
-    compare = stmt.value
-    if not (type(compare) is Compare and
-            len(compare.ops) == 1 and
-            type(compare.ops[0]) is In):
-        raise SyntaxError(
-            "monadic_do body must have the form `[bindings] in final_expr`"
+            "monadic_do body must be a single list literal `[bind, ..., final_expr]`"
         )  # pragma: no cover
 
-    bindings_node = compare.left
-    final_expr = compare.comparators[0]
-
-    # Bindings: must be a List literal.
-    if type(bindings_node) is not List:
+    items = stmt.value.elts
+    if not items:
         raise SyntaxError(
-            "monadic_do bindings must be a list literal `[x := mx, ...]`"
+            "monadic_do body list must have at least one item (the final monadic expression)"
         )  # pragma: no cover
 
-    # Wrap bare expressions as `_ := expr` so they look like sequencing-only
-    # bindings to `canonize_bindings`. This mirrors Haskell's do-notation
-    # where a bare expression line is sequence-only (>>, not >>=).
-    normalized_elts = [
+    # Split: all but the last are binds; the last is the final monadic expression.
+    *binding_items, final_expr = items
+
+    # Normalize bare expressions in the binds as synthetic `_ := expr` so they
+    # look like sequencing-only bindings to `canonize_bindings`. Matches Haskell's
+    # do-notation where a bare expression line is sequence-only (>>, not >>=).
+    normalized = [
         item if _is_binding_form(item) else NamedExpr(target=Name(id="_", ctx=Store()), value=item)
-        for item in bindings_node.elts
+        for item in binding_items
     ]
 
-    # Parse via letdoutil — accepts := and << for each binding, and []/() for the list shape
-    # (we already unpacked the outer List).
-    if normalized_elts:
-        canonical = canonize_bindings(normalized_elts)  # [Tuple(elts=[Name(k), v]), ...]
+    # Parse via letdoutil — accepts := and <<.
+    if normalized:
+        canonical = canonize_bindings(normalized)  # [Tuple(elts=[Name(k), v]), ...]
         pairs = [(t.elts[0].id, t.elts[1]) for t in canonical]
     else:
         pairs = []