lispython 0.5.0__tar.gz → 0.6.0__tar.gz

lispython-0.6.0/CHANGELOG.md

@@ -0,0 +1,447 @@
+# Changelog
+
+All notable changes to lispython are documented here. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and the project
+follows [Semantic Versioning](https://semver.org/).
+
+## [Unreleased]
+
+## [0.6.0] - 2026-11-02
+
+### Added
+
+- The nREPL `eval` op reads the standard `file`, `line` and `column` fields
+  (where the code sits in the editor's buffer, 1-based). Tracebacks and
+  compile errors then name that file with buffer line numbers and print the
+  source line, including for definitions evaluated in earlier requests and
+  for `load-file`.
+- `(raise)` compiles to a bare `raise`, re-raising the exception being
+  handled.
+
+### Changed
+
+- A string opened with `\"` in an f/t-string replacement field must be closed
+  by `\"` (`\"\"\"` for `\"\"\"`): a bare `"` in it, as its close or its
+  content, is a compile error at the opener, where it was accepted before
+  (`f"{(g \"a")}"`). Its `{x=}` echo (and a t-string's expression text) now
+  shows the source as written: `f"{(.get d \"k\")=}"` echoes
+  `(.get d \"k\")=`, where it echoed `(.get d "k")=`.
+- On 3.12 a single-quoted literal's format spec continued after a line
+  break in its text is read as CPython 3.12 reads it: the line break and
+  what follows are no longer part of the spec (`f"{x:ab\n}"` formats with
+  `ab`, where it used `ab\n`), only blanks, comments and replacement fields
+  may follow before the `}`, and any other text there (`f"{x:a\nb}"`, which
+  was accepted) is CPython's "expecting '}', or format specs" error or its
+  tokenizer error.
+- An nREPL eval without `file` is named `<nrepl-N>` (a new N per eval)
+  instead of `<nrepl>`, which can break a client that matches `<nrepl>` in
+  error text.
+- On Python 3.13+, a line break in a single-quoted f/t-string's format spec
+  is a compile error at the break even when the field then closes
+  (`f"{x:ab\n}"`), as CPython 3.13+ refuse it; it compiled before.
+- An invalid `line` or `column` (not an integer from 1 to
+  `NREPL-MAX-POSITION-LINE`, 1,000,000, or `NREPL-MAX-POSITION-COLUMN`,
+  100,000) gets an `error` reply with the request id instead of being
+  accepted.
+- Every name the compiler emits must be a Python name, or it is a compile
+  error at the symbol. Code that compiled and ran before is now refused:
+  a symbol whose mangled text is no Python identifier (`foo!`, `a.`, as in
+  `(= foo! 1)`), an operator whose mangled text is no identifier used as a
+  value (`(f +)`, `(print ~)`), and a hard keyword in any name slot:
+  attributes (`(. a if)`, `(.if x)`), keyword arguments (`(f :if 1)`, class
+  keywords), parameters (`(def f [:if 1] ...)`), type parameters, import
+  names and aliases, match captures and class pattern attributes. CPython
+  compiled such names from the AST, but no Python source spells them, so
+  `l2py` printed code that does not parse. Operators that mangle to a name
+  (`-` is `_`, `is-not` is `is_not`) are names as before.
+- An attribute slot takes one name: `(. a b.c)` and `(.a.b x)` are compile
+  errors; write `(. a b c)` and `(.b x.a)`.
+- `(. a)`, an attribute form with no attribute, is a compile error in every
+  context (value, assignment, `del`, annotated and augmented targets); it
+  used to compile to the plain name `a`. Write `a`, or `(. a b)` for an
+  attribute.
+- A hard keyword called in an expression (`(f (else 1))`) is reported as
+  `else is a Python keyword and cannot be used as a name`, at the keyword,
+  instead of `else is a Python keyword and cannot be called` at the form.
+- Forms that compiled to something other than what they say are compile
+  errors: `(ife a b c d)` (dropped `d`), `(yield a b)`, a comprehension clause
+  with a stray or dangling operand (`[x for y in z if]`, `(x for y in z if a
+  b)`), and a parameter list CPython refuses: a misplaced
+  or repeated `/`, `*` or `**kw` (`[a / /]` dropped `a`, `[*a *b]` made `b`
+  keyword-only), a bare `*` with no keyword-only parameter, and `[a :b 1
+  c]`, which compiled to `def f(a, b, c=1)`. An annotated lambda parameter (`(lambda [a ^int] 1)`, which `l2py`
+  printed as `lambda a: int: 1`) is refused too.
+- Class bases are read as call arguments: `(class A [**kw])` compiles to
+  `class A(**kw)`.
+- A statement form (`do`, `=`, `if`, `return`, ...) in expression position is
+  now a compile error instead of emitting an invalid call such as `do(...)`.
+  A Python function named `do`, `deco`, `async_def`, etc. can no longer be
+  called with lispython call syntax in expression position; they were already
+  unreachable as statements.
+- A Python hard keyword in call position (e.g. `(not a b)`, which used to
+  compile to `not (a, b)`, silently false, or `(else ...)`) is now a compile
+  error.
+- Statement forms that compiled while dropping part of what was written are
+  now compile errors: `(deco d (f))`, whose definition is not a `def`,
+  `async-def`, `class` or `deco` (the decorator was silently dropped);
+  `(assert a b c)` (the third operand was ignored); a form other than
+  `(case ...)` inside `match` (it was read as a case); and def arguments or
+  class bases written as anything but a `[...]` bracket (`(def f (x) ...)`
+  compiled). A `case` with `as` after its guard (`(case 1 if g as y ...)`,
+  which compiled `as y` into the body) is refused: `as` comes before `if`.
+- A `;` ends a symbol or number, so a comment needs no space before it:
+  `a;c` was the symbol `a;c`, now `a` followed by a comment.
+- A Python hard keyword as a symbol name, or as a part of a dotted symbol,
+  is a compile error: `(raise from)`, `(= o.if 1)` (which compiled to an
+  attribute named `if`), and a keyword as a def, class, global, nonlocal,
+  `case ... as` or `except [... as]` name (`(def if [] 1)`,
+  `(case 1 as as ...)`).
+- `~` directly before a closing bracket, a comma, `;` or the end of input
+  (`(f ~)`, `(f ~,a)`, `~;c`) is the symbol `~`, as before a space, instead
+  of an unquote that took the next form or gave "unmatched ')'".
+- A dotted name in a case pattern (`(case Color.RED ...)`) is a value
+  pattern, compared with `==` as in Python. It compiled to a capture pattern
+  that matched every subject, so code that relied on that now falls through
+  to the next case.
+- A `()` in a case pattern whose head is an expression form (`(sub x)`,
+  `(ife a b c)`, `(is-not x)`, `(not-in x)`) is a compile error ("pattern
+  expected") instead of a class pattern on a class of that name.
+- A sign before anything but a number in a case pattern (`(- a)`, `{-a 1}`)
+  reports "pattern can sign only a number literal, got (- a)" with the
+  pattern usage, instead of "only a number literal can be signed in a match
+  pattern".
+- An f/t-string format spec reads braces as CPython does: `}` always ends
+  the spec and `{` opens a nested field, so `{{` and `}}` are no escapes
+  there, except that on 3.12+ `{{` is a literal `{` once a nested field has
+  opened in the spec. `f"{x:{{}}}"`, which formatted `x` with the literal
+  spec `{}`, is now `x` with a spec field holding `{}`, and `f"{x:{y}{{}}}"`,
+  whose spec was `{y}` then `{}`, has the spec `{y}` then `{` followed by a
+  literal `}` on 3.12+ (a spec field `{}` on 3.11).
+- The operand after `^`, `*`, `**` or `:` keeps its own token type, so `*1`,
+  `**1`, `:1` and `^1` read a number `1` instead of a symbol named `1`. A
+  keyword with a number or other non-name after it (`(f :1 x)`, `(def g [:1
+  2] ...)`) is a compile error at it, a bare `:a` or `**x` used as a value
+  (`(= x :a)`, `[**1]`) is a compile error instead of silently the name `a`
+  (or a raw `AttributeError`), and a trailing `:a` with no value in a call,
+  def or class argument list is a compile error instead of a raw `IndexError`.
+- Threading a literal into a call (`(-> 1 (f))`, `(->> 1 (f 2))`,
+  `(-> "a" (f))`, `(-> ... (f))`) compiles to `f(1)`, `f(2, 1)`, `f('a')`
+  and `f(...)` instead of failing with an `AttributeError`, and
+  `(-> None (f))`, which compiled to `f()`, now gives `f(None)`. A macro may
+  put Python values (`None`, booleans, numbers, `...`, str, bytes, and
+  lists and tuples of them) anywhere in the forms it returns, including
+  inside `*`, `**`, `^` and quote forms (`` `(list *~y) ``); each compiles
+  to the same value (including `inf`, `nan`, `-0.0`, complex numbers with a
+  signed zero, `inf` or `nan` part and ints of any size) at the macro
+  call's position, even where `float` or `complex` is rebound or inside a
+  match pattern. Converting nested lists does not recurse, so deep nesting
+  does not hit `RecursionError` there. Any other value (a dict, a set, an
+  object), or a form or list that contains itself (also one unquoted with
+  `~`), is a compile error at the call naming the macro.
+- A str a macro returns keeps its backslashes literally: `"a\\b"` was
+  compiled as `"a\b"` (backspace), and a quote, line ending or control
+  character is kept as written. The same holds for quoted strings and
+  quoted symbols (`'a\b` was `Symbol('a\x08')`); bytes are supported.
+- An assignment, augmented assignment, `del`, `for` or `with ... as` target
+  that Python cannot bind (`(= 1 2)`, `(= (f) 1)`, `(+= [] 1)`, `(del *a)`)
+  is a compile error at the target with CPython's message ("cannot assign to
+  literal"), and so is an annotation anywhere but right after a single
+  target (`(= ^int 1)`, `(= a b ^int 1)`) or a def/class name that is not a
+  name (`(def [] [] 1)`, `(class 1 [])`).
+- A quote, quasiquote or unquote-splice with no form right after it
+  (`(f ' a)`, `(f *' a)`, `(f ~@ a)`, `(f ')`, `',a`) is a compile error at
+  the quote instead of a symbol `'`, `f(*', a)`, an unquote of `@` or
+  "unmatched ')'". `~` alone is still the invert operator.
+- A malformed `match` case pattern is a compile error at the part at fault,
+  quoting the usage of its kind (class, mapping or sequence pattern, `(| ...)`),
+  instead of an `IndexError`, `ValueError` or `AttributeError` or an AST
+  that means something else: a dangling `:attr` (`(P :x)`), a positional
+  pattern after a keyword one (`(P :x 1 2)`, which compiled to `P(2, x=1)`),
+  a mapping key without a pattern (`{"a"}`), `**rest` not last (`{**r 1}`),
+  `**_` (the rest must be a capture name), a key that is no literal or
+  dotted name (`{a 1}`), a second `*rest` (`[*a *b]`), `*rest` outside a
+  sequence (`(case *a ...)`), `(| 1)`, a class pattern head that is no name
+  (`(1)`, `((f) 1)`), a `()` that is no call (`(+ 1 2)`, `(, a b)`,
+  `f"x"`), `...` and a `:x` keyword token as a pattern.
+- A name after `*`, `**` or `:` in a case pattern that is no Python
+  identifier (`[*1a]`, `{**1a}`, `(P :1a 2)`) is a compile error instead of
+  an AST naming `1a`.
+- A malformed dotted name in a case pattern (`.x`, `a..b`, `x.`), as a value
+  pattern, a mapping key or a class pattern head, is a compile error instead
+  of an attribute with an empty name.
+- A string opened with a bare quote inside an f/t-string replacement field
+  reads as Python reads it: `\"` in it is an escaped quote and its
+  backslashes are kept. `f"{(g "a\" b \"c")}"` compiles to
+  `f"{g('a" b "c')}"`; it used to turn every `\"` into `"` before parsing
+  the field, which split the string into `g('a', b, 'c')` or refused it
+  (`f"{(g "say \"hi\"")}"`: "invalid string prefix").
+
+### Deprecated
+
+- Writing a string in an f/t-string replacement field with `\"`
+  (`f"{(.get d \"k\")}"`) is deprecated: each such string emits a
+  `SyntaxWarning` at its opening `\"`, shown by default (as CPython
+  3.12+'s invalid escape sequences are). Write plain quotes
+  (`f"{(.get d "k")}"`), which works on every supported Python. A
+  warnings filter that turns it into an error
+  (`PYTHONWARNINGS=error::SyntaxWarning`) makes it a compile error at the
+  opener.
+
+### Fixed
+
+- A replacement field whose expression starts with a bare `=` (`f"{=}"`,
+  `f"{=x}"`, `f"{=!r}"`, a source ending at `f"{=`) is refused with CPython
+  3.12+'s "valid expression required before '='" at the `=`, as compile() does
+  there. On 3.11 lispython reports that same 3.12+ message for a closed
+  literal, as it does for `f"{}"` (CPython 3.11's own wording differs); a
+  source ending inside the literal gets 3.11's whole-literal error. Before, a
+  closed literal was refused only by the compile step ("= is not a valid
+  Python name") or as a missing conversion (`f"{=!}"`), and on 3.12+ `f"{=`
+  gave "'{' was never closed" and `f"{=}` "unterminated f-string literal".
+  It is now refused when the source is read, so also inside quoted code.
+- On 3.12+ an error after a line break in a single-quoted f/t-string's text
+  (`f"a\n}"`, `f"a\n{x!z}"`, `f"a\n{)`) reports CPython's "unterminated
+  f-string literal (detected at line N)" for that literal, as `compile()`
+  does, whether or not the literal later closes: CPython's tokenizer stops
+  at the break. A multi-line literal with no error still compiles.
+- A comment ends at a lone CR as at LF and CRLF, as in CPython. A CR-only
+  source (`; c\r(f 1)`) used to lose every form after a comment.
+- A source ending inside a string, an f/t-string, a replacement field's
+  expression, a format spec or a conversion reports the error `compile()`
+  raises for that text on the running Python: "unterminated ... literal
+  (detected at line N)" at the literal's prefix, 3.12+'s "'(' was never
+  closed" (or "'{' was never closed") at the innermost bracket or field
+  brace still open,
+  "expecting '}'" for a string whose quote closes the
+  literal it is in, 3.13+'s "newlines are not allowed in format specifiers",
+  3.15's "expecting '}' to close '{' on line N", and 3.11's whole-literal
+  error. A name glued to a quote after `!` reads as a string prefix (`!r"`),
+  and an invalid conversion name is reported at the name, after any error in
+  its field's format spec where CPython checks it only once the field closes.
+- An f/t-string's closing quote inside a format spec (`f"{x:{y}"`) reports
+  CPython 3.12+'s "expecting '}', or format specs" at the quote.
+- An empty replacement field ("valid expression required before '}'") is
+  reported where CPython 3.12+ report it: at the `}`, `!`, `:` or the `=` of
+  `{ = }`, not at the field's `{`. A missing conversion (`f"{x! }"`) is
+  reported at the token after the `!`, not at the `!`.
+- An error in an f/t-string's field (an empty expression, more than one
+  expression, a missing or invalid conversion, a token out of place after
+  `!`) gives way, as in CPython, to a later tokenizer error outside any
+  literal, such as a string that never closes: `f"{x!z}" "b` and
+  `f"{a b}" "c` report "unterminated string literal" at the last string. On
+  3.11 a later f-string that never closes does too. On 3.12+ a closing
+  bracket out of place in a field after the error keeps it (`f"{x!r y)}" "b`),
+  and one right after a conversion is CPython's "f-string: unmatched ')'".
+- Error positions count a lone CR as a line break, as CPython does (CRLF is
+  one break), so a source with CR line endings reports the same line as
+  `compile()`.
+- Parsing no longer spends Python frames per nesting level, so these parse
+  at any depth and from a deep caller stack instead of raising
+  `RecursionError`: f/t-strings nested in each other's fields, format specs
+  nested in format specs, brackets nested deep inside one replacement
+  field, and long prefix chains on one token
+  (`^^^x`, `:::x`, `***x`, `^*^*x`), also glued to a bracket (`^^^a[int]`).
+- Quasiquoting f-strings nested in each other's fields checks each field for
+  an unquote once, linear instead of quadratic in the nesting (4,000 levels
+  took 15 s), and a deep nest of `(do ...)` statements compiles in linear
+  time.
+- Deeply nested forms compile in time linear in their nesting: a nested list
+  (`[[[...]]]`, also inside a macro call such as `when`) was exponential (20
+  levels took seconds) and a form in head position (`((((f))))`) quadratic.
+  Rendering a form and expanding macros no longer recurse, so a form nested
+  past Python's recursion limit renders and expands.
+- A long run of digits that is not a number lexes in linear time instead of
+  quadratic.
+- Forms nested deeper than about 245–330 levels (case patterns about 490)
+  are no longer refused with "form nested too deeply to compile": the
+  compiler and quote expansion no longer spend Python frames per level, so
+  nesting compiles as deep as CPython's compile() takes (about 10,000
+  Python AST levels on 3.12/3.13, more on 3.14+; forms that cost two AST
+  levels per lispython level, such as keyword arguments, starred arguments
+  and method calls, stop near half that). On 3.11 compile() itself still
+  stops near the recursion limit, with the positioned error below. `l2py`
+  still stops at a few hundred levels, because `ast.unparse` recurses: that
+  is the positioned error "form nested too deeply to translate".
+- Nesting past compile()'s own limit is the positioned "form nested too
+  deeply to compile" error from `lpy`, imports, the REPL, nREPL, `defmacro`
+  and `require`, instead of a `RecursionError` traceback, at the bottom of the
+  deepest path in what compile() was given: for `lpy` files and imports the
+  first statement that fails to compile alone (the whole module when each
+  fits alone), the whole form for `defmacro` and `require`, and the statement
+  compile() fails on for `lpy -c`, the REPL and nREPL. Its message names
+  Python's recursion limit only where that is the limit hit (3.11, and
+  `l2py`), since raising it does not move compile()'s limit on 3.12+. A
+  macro's own runaway recursion still raises `RecursionError`.
+- Data a macro puts in its expansion, spliced with `~x` or placed in a
+  form's list, that holds the same Python list or tuple in many places is
+  converted to nodes in time linear in the distinct data, instead of
+  exponential in the depth of the sharing. Compiling such data still emits
+  each shared value where it appears.
+- A malformed expression form is a positioned compile error quoting its
+  usage instead of an IndexError, ValueError or AssertionError, or an AST
+  CPython rejects: `(:=)`, `(:= a ^int 1)`, `(.)`, `(.foo)`, `(ife a)`,
+  `(sub)`, `(lambda [a])`, `(await)`, `(yield-from)`, `(and)`, `(< a)`,
+  `[:]`, `{1 2 3}` and `(x for y)`. Hover and signature help for these forms
+  show the same usage line.
+- `(= (sub a) ^int 1)` records `a` in `__annotations__`, as `(= a ^int 1)`
+  does.
+- `~x` or `~@x` outside a quasiquote is a compile error at it (`~ (unquote)
+  is only allowed inside a quasiquote`) instead of a raw `ValueError`.
+- A comprehension target that cannot be assigned (`[x for 1 in xs]`) and a
+  walrus target that is not a name (`(:= a.b 1)`, `(:= 1 2)`) are compile
+  errors with CPython's messages (`cannot assign to literal`, `cannot use
+  assignment expressions with attribute`) at the target, instead of a raw
+  `ValueError` or `TypeError`.
+- `(case pattern as _ ...)` is a compile error at the `_` (`cannot use '_'
+  as a target`, as in CPython) instead of a raw `ValueError`.
+- A dotted `defmacro` name (`(defmacro a.b ...)`) is refused as
+  `(defmacro ...) expects an undotted name, got a.b`, at the name, instead
+  of an error about the internal `___defmacro_temp___a.b` def.
+- LSP hover and signature help for a statement form show the same usage
+  line as the compiler's error messages (`(def name [args] body...)`,
+  `(for target in iterable body...)`), and now cover the `except`,
+  `except*`, `else`, `finally` and `case` clauses, augmented assignment
+  (`+=` and friends), and `|` as an or-pattern. For `|`, hover and signature
+  help show both the bitwise-OR operator and the or-pattern usage.
+  Completion now also lists the augmented assignment operators and the
+  `except`, `else` and `finally` clauses as special forms (`except*` and
+  `case` were already offered as keywords).
+  Hover text for `defmacro`, `lambda` and `fn` says `[args]`, matching `def`.
+- A complex number a macro returns shows in macroexpand output as `1+2j`
+  instead of `(1+2j)`, which read back as a call, not a number. A negative
+  nan (alone or as a complex part) shows as `(- (float "nan"))` instead of
+  losing its sign.
+- A macro whose expansion puts Python data in a form's list compiles when
+  another attribute also holds that list, and when the form's list is a
+  tuple or deque, instead of failing with `AttributeError: 'int' object has
+  no attribute 'name'`. A form's list of any other type (a dict, a set) is a
+  compile error at the macro call naming the macro.
+- Code a macro builds (from a quasiquote template) takes the position of the
+  macro call, so a traceback or compile error in it points at that call
+  instead of line 0; arguments written by the user keep their own positions.
+- nREPL eval tracebacks no longer include the server's own `nrepl-eval`
+  frame.
+- The nREPL server buffers bytes and decodes each complete line, so a
+  multi-byte UTF-8 character split across two socket reads no longer drops
+  the connection. An unknown op, a malformed request or a failing handler
+  (such as `eval` without `code`) now gets an `error` reply echoing the
+  request id, and the connection keeps serving; a line that is not valid
+  UTF-8 or JSON (or JSON that is not an object, or is nested too deeply to
+  parse) gets an id-less `error` reply. A result that cannot be
+  serialised is an `error` reply too, `(exit)` in an eval is reported as a
+  `SystemExit` eval error, and any socket error ends the connection quietly.
+  A request line over 4 MiB gets one id-less `error` reply and is dropped up
+  to its next newline, so a client that never sends a newline cannot grow the
+  server's memory; the connection keeps serving.
+- `as->` expands to an expression (a tuple of `:=` assignments indexed with
+  `-1`), so it works in expression position such as a `return` value or a
+  call argument instead of emitting an invalid `do(...)` call.
+- `as->` renames only references to the threading name: a keyword-argument
+  name (`(f :x x)` was `f(__x_0=__x_0)`, now `f(x=__x_0)`) and the params
+  and body of a `fn`/`lambda` that binds the same name are left alone (its
+  defaults are still renamed), and `~x` inside a quasiquote now gets the
+  threaded value.
+- `as->` also renames a dotted reference (`x.real` becomes `__x_0.real`) and
+  a reference inside an f-string format spec (`f"{1:{x}}"`).
+- A `for` or `while` with no target, iterable or test, or with no body
+  before its `(else ...)` (`(for x in)`, `(for [x [1]] (print x))`,
+  `(while x)`), is a compile error at the loop instead of an `IndexError`
+  or a loop with an empty body that Python rejects.
+- `^` followed by stars before a bracket or a quote (`^*(`, `^**[`, `^*'`,
+  `^**~`, also with a space after the quote) or alone (`^*`, `^**`) is a
+  compile error at the prefix instead of a `KeyError`, an `AttributeError`
+  or a call such as `f(*', a)`; `^*Ts` and `^**P` are unchanged.
+- Every malformed statement form is a compile error naming the problem and
+  the form's usage, at the form, clause or operand at fault, instead of a
+  `ValueError`, `IndexError`, `AssertionError`, `TypeError` or an AST that
+  Python rejects: `if`, `def`, `class`, `with`, `try` and its clauses,
+  `match` and `case`, `deco`, `raise`, `assert`, `=`, augmented assignment,
+  `del`, `global` and `nonlocal` with missing parts (`(if x)`, `(def f)`,
+  `(with [a])`, `(try (f))`, `(match x (case 1))`, `(= x)`, `(global)`, ...),
+  extra parts (`(raise a b)`, `(= x ^int 1 2)`) or a dangling `as`
+  (`(with [a as] ...)`, `(except [E as] ...)`). A `try` clause out of order
+  (except after else or finally, except mixed with except*, a form after
+  the clauses) is reported at that clause instead of as "except is a Python
+  keyword".
+- An empty `()` is a compile error at it ("use (,) for an empty tuple")
+  instead of an `IndexError`, wherever it appears.
+- Installing lispython no longer puts a `test` command (pytest's entry point)
+  on `PATH`.
+
+## [0.5.0]
+
+### Added
+
+- Python 3.11 through 3.15 support, with each newer AST form gated on the
+  running interpreter and a clear compile error on older ones. A `nox` matrix
+  (`uvx nox -s tests`) runs the suite on every supported version.
+- Type aliases: `(type NAME value)` compiles to a `type NAME = value`
+  statement (3.12+). The three-operand `(type name bases ns)` call is unchanged.
+- Generic definitions: `def`, `async def` and `class` names accept glued type
+  parameters such as `f[T]`, including `ParamSpec`, `TypeVarTuple` and
+  defaults (parameters 3.12+, defaults 3.13+).
+- t-strings compile to `TemplateStr` (3.14+).
+- `lazy-import` and `lazy-from` (3.15+).
+- Comprehension unpacking (3.15+), including `{**d for d dicts}`, which was
+  mistranslated as a dict display; unary plus is gated to 3.15+.
+- Errors the CPython compiler raises on `.lpy` modules, and lispython's own
+  compile errors, are reported with the file, line and caret instead of a
+  traceback by `lpy` (file, `-m`, `-c`), `l2py`, the REPL and nREPL eval.
+- LSP: `textDocument/signatureHelp` and `workspace/symbol`; `(type NAME ...)`
+  aliases are indexed as definitions.
+- nREPL: completion responses carry type kinds, and the server writes
+  `.nrepl-port` in the working directory for editor auto-discovery.
+
+### Changed
+
+- **The REPL and nREPL compile every statement of an input before running any
+  of it**, and `lpy -c` compiles its whole input first. A compile error,
+  lispython's or CPython's, now stops the input before any statement runs
+  (macro expansion still happens first); a `SyntaxError` the program raises
+  at run time keeps its own traceback.
+- **Stricter parsing** rejects input that used to be accepted silently: an
+  unclosed final form or mismatched closing bracket, an unterminated string,
+  an f-string field holding more than one form, a lone `}` in an f-string,
+  non-symbol macro names (`(defmacro m[T] ...)`), `(import "x")`,
+  `(lazy-import "numpy")`, `(return a b)`, and `name[...]` glued under a
+  prefix such as `^list[int]` in a parameter list. Malformed literals such as
+  `09` or `\x4` are reported at their token.
+- **Literal values**: `-1+2j` is now `(-1+2j)` rather than `-(1+2j)`; `\r\n`
+  and lone `\r` become `\n` in f-strings too; a multi-line raw string no
+  longer gains a literal `\n`; backslash-newline continues a string; a lone
+  `"` inside `"""..."""` no longer ends the token.
+- **F-strings follow Python's rules.** An uppercase `F` prefix (and `rf`,
+  `fR`, ...) is a real f-string rather than being evaluated at compile time,
+  `{x=}` echoes the expression text and defaults to `!r`, and format specs
+  may nest replacement fields (`{x:>{w}.{p}}`). Unquotes expand inside
+  f-string and t-string fields.
+- **`(require mod [])` registers no macros**, like an empty import list; only
+  an absent list (`(require mod)`) registers all of them. The LSP follows the
+  same rule in go-to-definition and hover.
+- `lpy -m` puts the current directory on `sys.path` like `python -m`,
+  honouring `PYTHONSAFEPATH`.
+- Requires `pygls` 2.0 or later.
+
+### Fixed
+
+- `(return [])` compiled to a bare `return` (yielding `None`); it now returns
+  the empty list.
+- `(case {})` accepts an empty mapping pattern.
+- Signed literal match patterns: `(case -1 ...)` compiled to `case _(1):`.
+- `(from . [a])` compiles; it raised `IndexError`.
+- Quasiquoted f/t-string fields keep their conversion, spec and `=` text
+  (`f"{x!r:>6}"` used to come back as `{x}`), and `f"{~x}"` with a literal
+  macro argument no longer crashes.
+- `l2py` emits valid Python for t-string interpolations.
+- A lone starred subscript slice compiles to a one-element `Tuple`, like
+  Python's `t[*s]`.
+- LSP: workspace symbols no longer include installed packages or function
+  locals, and report their real kinds; a buffer that is mid-edit keeps
+  working; signature help is not offered inside a quoted form.
+- nREPL: completion kinds treat scope bindings as shadowing builtins, never
+  run user code to classify attributes, and report callables as functions;
+  an unwritable `.nrepl-port` no longer stops the server.
+
+## [0.4.7]
+
+See the `v0.4.7` tag.

{lispython-0.5.0 → lispython-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lispython
-Version: 0.5.0
+Version: 0.6.0
 Summary: Lisp-like Syntax for Python with Lisp-like Macros
 Project-URL: Homepage, https://jetack.github.io/lispython
 Project-URL: Repository, https://github.com/jetack/lispython
@@ -61,6 +61,8 @@ uv sync # install dependencies
 uv pip install -e . # for development
 ```
 
+Contributors using git worktrees: run `git config core.hooksPath .githooks` once in the main checkout; see [`.githooks/README.md`](.githooks/README.md). This replaces `.git/hooks`, so hooks installed there stop running.
+
 ## How to Run LisPython code
 ### Run from source
 ```bash

{lispython-0.5.0 → lispython-0.6.0}/README.md

@@ -31,6 +31,8 @@ uv sync # install dependencies
 uv pip install -e . # for development
 ```
 
+Contributors using git worktrees: run `git config core.hooksPath .githooks` once in the main checkout; see [`.githooks/README.md`](.githooks/README.md). This replaces `.git/hooks`, so hooks installed there stop running.
+
 ## How to Run LisPython code
 ### Run from source
 ```bash

{lispython-0.5.0 → lispython-0.6.0}/docs/macros.md

@@ -65,14 +65,15 @@ Unlike `->` (thread first) and `->>` (thread last), `as->` lets you name the thr
   (str x))     ;; x = "20"
 ```
 
-This expands to:
+This expands to a single expression, a tuple of walrus assignments indexed with `-1`:
 ```python
-x = 0
-x = x + 10
-x = 2 * x
-x = str(x)
+(__x_0 := 0, __x_0 := __x_0 + 10, __x_0 := 2 * __x_0, str(__x_0))[-1]
 ```
 
+Because it is an expression, `as->` works anywhere: as a return value, a call argument, a lambda body, or nested. CPython refuses `:=` in some positions (e.g. a comprehension's iterable, annotations, type-alias values); there it is a loud compile error, so bind the value first.
+
+The name is replaced only where it is read as a variable, not in keyword-argument names, quoted data, or the body of a `fn`/`lambda` that rebinds it.
+
 Useful when the threaded value doesn't always go in the first or last position.
 
 ## gensym

{lispython-0.5.0 → lispython-0.6.0}/docs/syntax/expressions.md

@@ -57,6 +57,9 @@ Python version
 (name := value)
 ```
 
+## Statements are not expressions
+Statement forms (`do`, `=`, `+=`, `if`, `return`, `def`, ...) cannot appear inside an expression; the compiler reports an error. Use `(:= name value)` instead of `=`, `(ife test then else)` instead of `if`, and a tuple `(sub (, a b c) -1)` to sequence expressions.
+
 ## `lambda`
 LisPy version
 ```python
@@ -221,6 +224,12 @@ f"Hello, {2 * name}!"
 ```
 Replacement fields follow Python's rules: `{{`/`}}` are literal braces,
 `!r`/`!s`/`!a` conversions, format specs with nested fields, and `{x=}`.
+A field is ordinary code, so a string in it is written with plain quotes as in
+Python 3.12+ (`f"{(.get d "k")}"`), on every supported Python. The old
+spelling with `\"` (`f"{(.get d \"k\")}"`) is deprecated: it still compiles,
+with a `SyntaxWarning` (shown by default, as for an invalid escape sequence
+in Python 3.12+), and a string opened with `\"` must be closed by
+`\"`.
 LisPy version
 ```python
 f"{{literal}} {x!r:>{width}} {x=}"

{lispython-0.5.0 → lispython-0.6.0}/docs/syntax/statements.md

@@ -365,11 +365,13 @@ match x:
 ## `raise`
 LisPy version
 ```python
+(raise)
 (raise Exception)
 (raise Exception from ValueError)
 ```
 Python version
 ```python
+raise
 raise Exception
 raise Exception from ValueError
 ```

{lispython-0.5.0 → lispython-0.6.0}/docs/version_macro.py

@@ -1,5 +1,6 @@
 import tomllib
 
+
 def define_env(env):
     try:
         with open("pyproject.toml", "rb") as f:
@@ -8,4 +9,4 @@ def define_env(env):
     except Exception:
         version = "dev"
 
-    env.variables["version"] = version
+    env.variables["version"] = version

{lispython-0.5.0 → lispython-0.6.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lispython"
-version = "0.5.0"
+version = "0.6.0"
 description = "Lisp-like Syntax for Python with Lisp-like Macros"
 authors = [{ name = "Jetack", email = "jetack23@gmail.com" }]
 license = { text = "MIT" }
@@ -28,7 +28,6 @@ Repository = "https://github.com/jetack/lispython"
 lpy = "lispy:run"
 l2py = "lispy:l2py"
 lpy-lsp = "lispy.lsp:main"
-test = "pytest:main"
 
 [project.optional-dependencies]
 dev = [
@@ -50,13 +49,34 @@ build-backend = "hatchling.build"
 [tool.hatch.build.targets.wheel]
 packages = ["src/lispy"]
 
+# The sdist ships an explicit list, never "everything .gitignore allows":
+# hatchling drops every .gitignore exclusion when the project root itself
+# matches one, as any checkout under the ignored .claude/worktrees/ does, and
+# the sdist then carried agent symlinks and .claude/settings.local.json.
+[tool.hatch.build.targets.sdist]
+include = [
+  "/src",
+  "/tests",
+  "/docs",
+  "/mkdocs.yml",
+  "/noxfile.py",
+  "/uv.lock",
+  "/README.md",
+  "/LICENSE.md",
+  "/CHANGELOG.md",
+]
+exclude = ["__pycache__", "*.py[cod]"]
+
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 python_files = ["test_*.py"]
 # AST constructor misuse (unknown keywords, missing fields) warns on 3.13/3.14
-# and is a TypeError from 3.15: fail the suite on the warning.
+# and is a TypeError from 3.15: fail the suite on the warning. A SyntaxWarning
+# (the deprecated \" in an f-string field, as CPython's invalid escape
+# sequences) fails it too unless the test expects it.
 filterwarnings = [
     "error::DeprecationWarning",
+    "error::SyntaxWarning",
     # pygls (third-party) calls asyncio.iscoroutinefunction, deprecated in 3.14.
     "ignore:'asyncio.iscoroutinefunction' is deprecated:DeprecationWarning",
 ]
@@ -68,5 +88,22 @@ src = ["src"]
 [tool.ruff.lint]
 select = ["E", "F", "I", "UP"]
 
+[tool.ruff.lint.per-file-ignores]
+# Generated from core_meta_functions.lpy by l2py (tests/test_meta_functions.py checks
+# it byte for byte), so its shape is the transpiler's, not ruff's.
+"src/lispy/core/meta_functions.py" = ["E", "F", "I", "UP"]
+# The compiler modules share one namespace on purpose (`from ... import *`).
+"src/lispy/core/compiler/*.py" = ["F403", "F405"]
+"src/lispy/core/macro.py" = ["F403", "F405"]
+"src/lispy/core/parser.py" = ["F403", "F405"]
+# Package __init__ imports run for their side effects or re-export.
+"src/lispy/__init__.py" = ["F401"]
+"src/lispy/lsp/__init__.py" = ["F401"]
+"src/lispy/macros/__init__.py" = ["F401", "F403"]
+
+[tool.ruff.format]
+# Generated file (see above); the docs' fenced "python" blocks hold LisPython.
+exclude = ["src/lispy/core/meta_functions.py", "docs/**/*.md"]
+
 [tool.ruff.lint.isort]
 known-first-party = ["lispy"]

{lispython-0.5.0 → lispython-0.6.0}/src/lispy/__init__.py

@@ -1,4 +1,4 @@
 import sys
 
 import lispy.core.importer
-from lispy.tools import run, l2py
+from lispy.tools import l2py, run