lispython 0.4.0__tar.gz → 0.4.2__tar.gz

{lispython-0.4.0 → lispython-0.4.2}/.gitignore

@@ -321,4 +321,15 @@ tags
 
 poetry.lock
 **test.hy
-**temp*
+**temp*
+
+# AI agent instructions (per-user, not committed)
+AGENTS.md
+CLAUDE.md
+GEMINI.md
+
+# Git worktrees
+.worktrees/
+
+# Agent-generated docs (not mkdocs content)
+docs/superpowers/

lispython-0.4.2/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: lispython
+Version: 0.4.2
+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
+Author-email: Jetack <jetack23@gmail.com>
+License: MIT
+License-File: LICENSE.md
+Requires-Python: >=3.11
+Requires-Dist: pygls>=1.0.0
+Provides-Extra: dev
+Requires-Dist: pre-commit>=3.6.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.8.0; extra == 'dev'
+Requires-Dist: toml>=0.10.2; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: mike>=2.1.3; extra == 'docs'
+Requires-Dist: mkdocs-macros-plugin>=1.3.7; extra == 'docs'
+Requires-Dist: mkdocs-material>=9.6.14; extra == 'docs'
+Description-Content-Type: text/markdown
+
+# LisPython
+[![PyPI version](https://badge.fury.io/py/lispython.svg)](https://badge.fury.io/py/lispython)
+
+LisPython is a Lisp-flavored syntax for Python with Lisp-style macros. Source files (`.lpy`) are transpiled to Python and executed on the standard CPython runtime.
+
+## Documentation
+Full documentation lives at [https://jetack.github.io/lispython/](https://jetack.github.io/lispython/).
+
+## Quick Start
+```lisp
+(import math)
+
+(def area [r]
+  (return (* math.pi (** r 2))))
+
+(print (area 3))
+```
+```bash
+lpy example.lpy
+```
+
+## Installation
+### Using pip
+```bash
+pip install lispython
+```
+
+### Manual Installation (for development)
+```bash
+uv sync # install dependencies
+uv pip install -e . # for development
+```
+
+## How to Run LisPython code
+### Run from source
+```bash
+lpy {filename}.lpy
+```
+
+### Run REPL
+```bash
+lpy
+# or
+lpy -t # if you want to print python translation.
+```
+
+### Show translation
+```bash
+l2py {filename}.lpy
+```
+Prints the translated Python to stdout. It does not execute the code.
+
+### Run Tests
+```bash
+# in project root directory
+pytest
+# or
+lpy -m pytest
+```
+
+## LSP Server
+LisPython ships with a language server (`lpy-lsp`) that speaks LSP over stdio. It provides:
+
+- Diagnostics (parse / compile errors)
+- Hover documentation for special forms
+- Document symbols
+- Go-to-definition, including across `.lpy` files in the workspace
+
+### Editor setup
+Point your editor's LSP client at the `lpy-lsp` command for files with the `.lpy` extension. The server speaks LSP over stdio.
+
+#### VSCode
+Install the [LisPython](https://marketplace.visualstudio.com/items?itemName=jetack.vscode-lispython) extension from the VSCode Marketplace.
+
+#### Emacs
+Use [`lpy-mode`](https://github.com/jetack/lpy-mode) for syntax highlighting and LSP integration. For completion, install [`lpy-autocomplete`](https://github.com/jetack/lpy-autocomplete).
+
+## Todo
+### Environment
+- [ ] Test on more python versions
+- [ ] REPL should track history and arrow key navigation
+- [ ] REPL multi-line input support
+- [ ] Better compilation error messages
+### Python AST
+- [ ] `type_comment` never considered. Later, it should be covered
+- [ ] Any missing AST nodes in the version 3.12+

lispython-0.4.2/README.md

@@ -0,0 +1,86 @@
+# LisPython
+[![PyPI version](https://badge.fury.io/py/lispython.svg)](https://badge.fury.io/py/lispython)
+
+LisPython is a Lisp-flavored syntax for Python with Lisp-style macros. Source files (`.lpy`) are transpiled to Python and executed on the standard CPython runtime.
+
+## Documentation
+Full documentation lives at [https://jetack.github.io/lispython/](https://jetack.github.io/lispython/).
+
+## Quick Start
+```lisp
+(import math)
+
+(def area [r]
+  (return (* math.pi (** r 2))))
+
+(print (area 3))
+```
+```bash
+lpy example.lpy
+```
+
+## Installation
+### Using pip
+```bash
+pip install lispython
+```
+
+### Manual Installation (for development)
+```bash
+uv sync # install dependencies
+uv pip install -e . # for development
+```
+
+## How to Run LisPython code
+### Run from source
+```bash
+lpy {filename}.lpy
+```
+
+### Run REPL
+```bash
+lpy
+# or
+lpy -t # if you want to print python translation.
+```
+
+### Show translation
+```bash
+l2py {filename}.lpy
+```
+Prints the translated Python to stdout. It does not execute the code.
+
+### Run Tests
+```bash
+# in project root directory
+pytest
+# or
+lpy -m pytest
+```
+
+## LSP Server
+LisPython ships with a language server (`lpy-lsp`) that speaks LSP over stdio. It provides:
+
+- Diagnostics (parse / compile errors)
+- Hover documentation for special forms
+- Document symbols
+- Go-to-definition, including across `.lpy` files in the workspace
+
+### Editor setup
+Point your editor's LSP client at the `lpy-lsp` command for files with the `.lpy` extension. The server speaks LSP over stdio.
+
+#### VSCode
+Install the [LisPython](https://marketplace.visualstudio.com/items?itemName=jetack.vscode-lispython) extension from the VSCode Marketplace.
+
+#### Emacs
+Use [`lpy-mode`](https://github.com/jetack/lpy-mode) for syntax highlighting and LSP integration. For completion, install [`lpy-autocomplete`](https://github.com/jetack/lpy-autocomplete).
+
+## Todo
+### Environment
+- [ ] Test on more python versions
+- [ ] REPL should track history and arrow key navigation
+- [ ] REPL multi-line input support
+- [ ] Better compilation error messages
+### Python AST
+- [ ] `type_comment` never considered. Later, it should be covered
+- [ ] Any missing AST nodes in the version 3.12+

lispython-0.4.2/docs/macros.md

@@ -0,0 +1,114 @@
+# Macros
+LisPy's macro system is highly inspired by Clojure's macro system.
+You can check out the [Chapter 7](https://www.braveclojure.com/read-and-eval/) and [Chapter 8](https://www.braveclojure.com/writing-macros/) of "Brave Clojure" for more information about Clojure's macro system.
+## Expression Nodes
+These nodes are defined in `src/lispython/core/nodes.py`.
+
+You can check out how to manipulate these nodes in
+
+- the definitions of nodes themselves
+- the definitions of built-in macros in `src/lispython/macros/sugar.lpy`.
+
+## quote
+```python
+'expr
+```
+## syntax-quote
+```python
+`expr
+```
+## unquote
+```python
+~expr
+```
+## unquote-splicing
+```python
+~@expr
+```
+## Macro Definition
+Just change `def` in function definition to `defmacro`. And macros usually return a quoted expression.
+```python
+(defmacro name [args*]
+  body*)
+```
+### Macro Example
+```python
+(defmacro when [pred *body]
+  (return `(if ~pred
+             (do ~@body))))
+
+(defmacro cond [*body]
+  (def recur [*body]
+    (if (< (len body) 4)
+        (return `(if ~@body))
+        (do (= [test then *orelse] body)
+            (return `(if ~test ~then ~(recur *orelse))))))
+  (return (recur *body)))
+
+(defmacro -> [x *fs]
+  (if (== 0 (len fs))
+      (return x))
+  (= [f *rest] fs)
+  (if (isinstance f Paren)
+      (do (f.list.insert 1 x)
+          (return `(-> ~f ~@rest)))
+      (return `(-> (~f ~x) ~@rest))))
+```
+You can find more in `src/lispython/macros/sugar.lpy`.
+
+### `as->`
+Unlike `->` (thread first) and `->>` (thread last), `as->` lets you name the threaded value and place it anywhere in each form:
+```python
+(as-> 0 x
+  (+ x 10)     ;; x = 10
+  (* 2 x)      ;; x = 20
+  (str x))     ;; x = "20"
+```
+
+This expands to:
+```python
+x = 0
+x = x + 10
+x = 2 * x
+x = str(x)
+```
+
+Useful when the threaded value doesn't always go in the first or last position.
+
+## gensym
+`gensym` generates unique symbols to avoid variable name collisions in macros. It is automatically available inside `defmacro` bodies.
+
+```python
+(gensym)          ;; => Symbol("__gensym_0")
+(gensym "tmp")    ;; => Symbol("__tmp_1")
+(gensym 'tmp)     ;; => Symbol("__tmp_2")  (also accepts a quoted Symbol)
+```
+
+The prefix can be a string or a symbol. Each call increments a global counter, so every generated symbol is unique.
+
+### Why gensym?
+Without `gensym`, a macro that introduces a local variable can accidentally shadow a variable in the caller's scope:
+```python
+;; BAD: if the caller has a variable named `tmp`, this breaks
+(defmacro broken-swap [a b]
+  (return `(do (= tmp ~a)
+               (= ~a ~b)
+               (= ~b tmp))))
+```
+
+Using `gensym` prevents this:
+```python
+(defmacro swap [a b]
+  (= tmp (gensym "tmp"))
+  (return `(do (= ~tmp ~a)
+               (= ~a ~b)
+               (= ~b ~tmp))))
+```
+
+Now `(swap x y)` expands to something like:
+```python
+__tmp_0 = x
+x = y
+y = __tmp_0
+```
+The generated name `__tmp_0` won't collide with user variables.

lispython-0.4.2/docs/usage/getting-started.md

@@ -0,0 +1,20 @@
+# Getting Started
+## Simple Web REPL
+You can try LisPy without installing at
+[https://jetack.github.io/lispy-web/](https://jetack.github.io/lispy-web/).
+## Installation
+### Using pip
+```bash
+pip install lispython
+```
+### Manual Installation (for development)
+```bash
+uv sync # install dependencies
+uv pip install -e . # for development
+```
+#### uv
+I recommend using [uv](https://docs.astral.sh/uv/) for development.
+It manages the virtual environment and dependencies from `pyproject.toml` / `uv.lock` automatically.
+```bash
+uv run lpy # run commands inside the project environment
+```

{lispython-0.4.0 → lispython-0.4.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lispython"
-version = "0.4.0"
+version = "0.4.2"
 description = "Lisp-like Syntax for Python with Lisp-like Macros"
 authors = [{ name = "Jetack", email = "jetack23@gmail.com" }]
 license = { text = "MIT" }

lispython-0.4.2/src/lispy/core/builtins.py

@@ -0,0 +1,19 @@
+from lispy.core.nodes import Symbol
+
+_gensym_counter = 0
+
+
+def gensym(prefix="gensym"):
+    global _gensym_counter
+    if isinstance(prefix, Symbol):
+        prefix = prefix.name
+    elif not isinstance(prefix, str):
+        raise TypeError(f"gensym prefix must be a Symbol or string, got {type(prefix).__name__}")
+    sym = Symbol("__" + prefix + "_" + str(_gensym_counter))
+    _gensym_counter += 1
+    return sym
+
+
+def reset_gensym_counter():
+    global _gensym_counter
+    _gensym_counter = 0

{lispython-0.4.0 → lispython-0.4.2}/src/lispy/core/meta_functions.py

@@ -9,6 +9,7 @@ def defmacro_transform(sexp):
     return Paren(
         Symbol("do"),
         Paren(Symbol("from"), Symbol("lispy.core.nodes"), Symbol("*")),
+        Paren(Symbol("from"), Symbol("lispy.core.builtins"), Symbol("*")),
         Paren(Symbol("def"), newname, *body),
         Paren(
             Symbol("="),

{lispython-0.4.0 → lispython-0.4.2}/src/lispy/core_meta_functions.lpy

@@ -6,10 +6,11 @@
 (from lispy.core.nodes *)
 
 (def defmacro-transform [sexp]
-  (= [op macroname *body] sexp.list) 
+  (= [op macroname *body] sexp.list)
   (= macroname (str macroname))
   (= newname (Symbol (+ "___defmacro_temp___" macroname)))
   (return `(do (from lispy.core.nodes *)
+               (from lispy.core.builtins *)
                (def ~newname ~@body)
                (= (sub (.setdefault (globals) "__macro_namespace" {})
                        ~macroname)

{lispython-0.4.0 → lispython-0.4.2}/src/lispy/lsp/server.lpy

@@ -162,6 +162,17 @@
   "Convert a filesystem path to a file:// URI."
   (return (.as-uri (pathlib.Path path))))
 
+(def index-required-modules [tree]
+  "Find all (require module-name ...) forms in tree and index those packages."
+  (for node in tree
+    (if (and (isinstance node Paren)
+             (> (len node) 1)
+             (isinstance node.op Symbol)
+             (== node.op.value "require")
+             (isinstance (sub node 1) Symbol))
+        (do (= module-name (. (sub node 1) value))
+            (index-installed-package module-name)))))
+
 (def index-file [uri]
   "Parse a .lpy file and add its definitions to the workspace index.
    Removes old entries for this URI before re-indexing."
@@ -185,6 +196,9 @@
     (= tree (parse src))
     (= (sub FILE-TREES uri) tree)
     (collect-definitions tree uri :defs WORKSPACE-INDEX)
+    ;; Also eagerly index any packages this file requires so defmacros
+    ;; from required modules are discoverable for go-to-definition.
+    (index-required-modules tree)
     (except [Exception as exc]
       (logger.debug f"Failed to index {fpath}: {exc}"))))
 
@@ -201,19 +215,44 @@
    e.g., 'lispy.tools' -> '/path/to/src/lispy/tools.lpy'"
   (= parts (.split (.replace module-name "-" "_") "."))
   (= rel-path (+ (osp.join *parts) ".lpy"))
-  ;; Search in workspace folders and sys.path-like locations
+  ;; 1. Workspace folders (direct or in src/)
   (for folder in workspace-folders
     (= root (uri-to-path folder.uri))
-    ;; Direct match
     (= candidate (osp.join root rel-path))
     (if (osp.isfile candidate)
         (return candidate))
-    ;; Check in src/ subdirectory
     (= candidate (osp.join root "src" rel-path))
     (if (osp.isfile candidate)
         (return candidate)))
+  ;; 2. Python's sys.path (finds installed packages, including lispython itself)
+  (try
+    (do (import importlib.util)
+        (= spec (importlib.util.find-spec (.replace module-name "-" "_")))
+        (if (and spec spec.origin (.endswith spec.origin ".lpy"))
+            (return spec.origin))
+        ;; Package without __init__.lpy but has submodule files
+        (if (and spec spec.submodule-search-locations)
+            (for search-path in spec.submodule-search-locations
+              (= candidate (osp.join search-path "init.lpy"))
+              (if (osp.isfile candidate)
+                  (return candidate)))))
+    (except [Exception]
+      (pass)))
   (return None))
 
+(def index-installed-package [module-name]
+  "Index all .lpy files in an installed Python package (e.g., lispython).
+   Used to make defmacros in required modules discoverable."
+  (try
+    (do (import importlib.util)
+        (= spec (importlib.util.find-spec (.replace module-name "-" "_")))
+        (if (and spec spec.submodule-search-locations)
+            (for search-path in spec.submodule-search-locations
+              (for fpath in (glob.glob (osp.join search-path "**" "*.lpy") :recursive True)
+                (index-file (path-to-uri fpath))))))
+    (except [Exception]
+      (pass))))
+
 (def find-import-target [node workspace-folders]
   "Given an import/from/require node, resolve where the imported name is defined."
   (= form (. node op value))
@@ -336,10 +375,15 @@
           :source "lpy-lsp"
           :message f"Parse error: {exc}"))
       (return diagnostics)))
-  ;; 2. Compile (best-effort)
+  ;; 2. Compile (best-effort) — reported as warnings, since compile-time
+  ;; macro expansion depends on the runtime environment (imports must
+  ;; actually resolve). Import errors here are often not real problems.
   (try
     (do (from lispy.core.macro [macroexpand-then-compile])
         (macroexpand-then-compile tree))
+    (except [ModuleNotFoundError]
+      ;; Silently ignore — the file may be using modules the LSP can't resolve
+      (pass))
     (except [Exception as exc]
       (= pos (extract-error-position exc source))
       (if (is pos None)
@@ -347,9 +391,9 @@
       (.append diagnostics
         (lsp.Diagnostic
           :range (make-range *pos)
-          :severity lsp.DiagnosticSeverity.Error
+          :severity lsp.DiagnosticSeverity.Warning
           :source "lpy-lsp"
-          :message f"Compile error: {exc}"))))
+          :message f"Compile warning: {exc}"))))
   (return diagnostics))
 
 (def publish-diagnostics [ls uri]

{lispython-0.4.0 → lispython-0.4.2}/src/lispy/macros/sugar.lpy

@@ -28,6 +28,16 @@
           (return `(->> ~f ~@rest)))
       (return `(-> (~f ~x) ~@rest))))
 
+(defmacro as-> [expr name *forms]
+  (if (== 0 (len forms))
+      (return expr))
+  (= stmts [])
+  (stmts.append `(= ~name ~expr))
+  (for f in forms
+    (stmts.append `(= ~name ~f)))
+  (stmts.append name)
+  (return `(do ~@stmts)))
+
 (defmacro fn [*body]
   (return `(lambda ~@body)))
 

lispython-0.4.2/tests/test_as_thread.py

@@ -0,0 +1,36 @@
+from lispy.tools import src_to_python_org
+
+PREAMBLE = "(require lispy.macros *)\n"
+
+
+class TestAsThread:
+    def test_no_forms(self):
+        assert src_to_python_org(PREAMBLE + "(as-> 42 x)") == "42"
+
+    def test_single_form(self):
+        result = src_to_python_org(PREAMBLE + "(as-> 0 x (+ x 1))")
+        assert "x = 0" in result
+        assert "x = x + 1" in result
+
+    def test_multiple_forms(self):
+        result = src_to_python_org(
+            PREAMBLE + "(as-> 0 x (+ x 10) (* 2 x) (str x))"
+        )
+        assert "x = 0" in result
+        assert "x = x + 10" in result
+        assert "x = 2 * x" in result
+        assert "x = str(x)" in result
+
+    def test_method_call(self):
+        result = src_to_python_org(
+            PREAMBLE + '(as-> "hello" s (.upper s))'
+        )
+        assert "s = 'hello'" in result
+        assert "s = s.upper()" in result
+
+    def test_flexible_placement(self):
+        result = src_to_python_org(
+            PREAMBLE + "(as-> 1 x (+ 10 x) (- x 5))"
+        )
+        assert "x = 10 + x" in result
+        assert "x = x - 5" in result

lispython-0.4.2/tests/test_gensym.py

@@ -0,0 +1,78 @@
+from lispy.core.builtins import gensym, reset_gensym_counter
+from lispy.core.nodes import Symbol
+from lispy.tools import src_to_python_org
+
+
+class TestGensym:
+    def setup_method(self):
+        reset_gensym_counter()
+
+    def test_returns_symbol(self):
+        result = gensym()
+        assert isinstance(result, Symbol)
+
+    def test_default_prefix(self):
+        result = gensym()
+        assert result.name == "__gensym_0"
+
+    def test_increments_counter(self):
+        a = gensym()
+        b = gensym()
+        assert a.name == "__gensym_0"
+        assert b.name == "__gensym_1"
+
+    def test_custom_prefix(self):
+        result = gensym("tmp")
+        assert result.name == "__tmp_0"
+
+    def test_custom_prefix_increments(self):
+        a = gensym("x")
+        b = gensym("y")
+        assert a.name == "__x_0"
+        assert b.name == "__y_1"
+
+    def test_unique_across_prefixes(self):
+        a = gensym("a")
+        b = gensym("b")
+        assert a.name != b.name
+
+    def test_symbol_prefix(self):
+        result = gensym(Symbol("tmp"))
+        assert result.name == "__tmp_0"
+
+    def test_rejects_invalid_prefix(self):
+        import pytest
+
+        with pytest.raises(TypeError):
+            gensym(123)
+
+
+class TestGensymInMacro:
+    def setup_method(self):
+        reset_gensym_counter()
+
+    def test_gensym_with_quoted_symbol(self):
+        src = """
+(defmacro test-quoted []
+  (= tmp (gensym 'tmp))
+  (return `(= ~tmp 1)))
+
+(test-quoted)
+"""
+        result = src_to_python_org(src)
+        assert "__tmp_0 = 1" in result
+
+    def test_swap_macro_uses_gensym(self):
+        src = """
+(defmacro swap [a b]
+  (= tmp (gensym "tmp"))
+  (return `(do (= ~tmp ~a)
+               (= ~a ~b)
+               (= ~b ~tmp))))
+
+(swap x y)
+"""
+        result = src_to_python_org(src)
+        assert "__tmp_0 = x" in result
+        assert "x = y" in result
+        assert "y = __tmp_0" in result

{lispython-0.4.0 → lispython-0.4.2}/uv.lock

@@ -260,7 +260,7 @@ wheels = [
 
 [[package]]
 name = "lispython"
-version = "0.3.3"
+version = "0.4.2"
 source = { editable = "." }
 dependencies = [
     { name = "pygls" },

lispython-0.4.0/PKG-INFO

@@ -1,79 +0,0 @@
-Metadata-Version: 2.4
-Name: lispython
-Version: 0.4.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
-Author-email: Jetack <jetack23@gmail.com>
-License: MIT
-License-File: LICENSE.md
-Requires-Python: >=3.11
-Requires-Dist: pygls>=1.0.0
-Provides-Extra: dev
-Requires-Dist: pre-commit>=3.6.0; extra == 'dev'
-Requires-Dist: pytest>=8.0.0; extra == 'dev'
-Requires-Dist: ruff>=0.8.0; extra == 'dev'
-Requires-Dist: toml>=0.10.2; extra == 'dev'
-Provides-Extra: docs
-Requires-Dist: mike>=2.1.3; extra == 'docs'
-Requires-Dist: mkdocs-macros-plugin>=1.3.7; extra == 'docs'
-Requires-Dist: mkdocs-material>=9.6.14; extra == 'docs'
-Description-Content-Type: text/markdown
-
-# LisPython
-[![PyPI version](https://badge.fury.io/py/lispython.svg)](https://badge.fury.io/py/lispython)
-
-# Documentation
-You can find the documentation at [https://jetack.github.io/lispython/](https://jetack.github.io/lispython/).
-
-# Installation
-## Manual Installation (for development)
-```bash
-poetry install --no-root # for dependency
-pip install -e . # for development
-```
-## Using pip
-```bash
-pip install lispython
-```
-
-# How to Run lispy code
-## Run from source
-```bash
-lpy {filename}.lpy
-```
-
-## Run REPL
-```bash
-lpy
-#or
-lpy -t #if you want to print python translation.
-```
-
-## Run translation
-```bash
-l2py {filename}.lpy
-```
-It just displays translation. (don't run it)
-
-## Run Tests
-```bash
-# in project root directory
-python -m unittest
-#or
-lpy -m unittest
-```
-
-
-# Todo
-## Environment
-- [ ] Test on more python versions
-- [ ] REPL should track history and arrow key navigation
-- [ ] REPL multi-line input support
-- [ ] Better compileation error messages
-## Macro System
-- [ ] `as->` macro for syntactic sugar
-- [ ] `gensym` for avoiding name collision
-## Python AST
-- [ ] `type_comment` never considered. Later, it should be covered
-- [ ] Any missing AST nodes in the version 3.12+

lispython-0.4.0/README.md

@@ -1,57 +0,0 @@
-# LisPython
-[![PyPI version](https://badge.fury.io/py/lispython.svg)](https://badge.fury.io/py/lispython)
-
-# Documentation
-You can find the documentation at [https://jetack.github.io/lispython/](https://jetack.github.io/lispython/).
-
-# Installation
-## Manual Installation (for development)
-```bash
-poetry install --no-root # for dependency
-pip install -e . # for development
-```
-## Using pip
-```bash
-pip install lispython
-```
-
-# How to Run lispy code
-## Run from source
-```bash
-lpy {filename}.lpy
-```
-
-## Run REPL
-```bash
-lpy
-#or
-lpy -t #if you want to print python translation.
-```
-
-## Run translation
-```bash
-l2py {filename}.lpy
-```
-It just displays translation. (don't run it)
-
-## Run Tests
-```bash
-# in project root directory
-python -m unittest
-#or
-lpy -m unittest
-```
-
-
-# Todo
-## Environment
-- [ ] Test on more python versions
-- [ ] REPL should track history and arrow key navigation
-- [ ] REPL multi-line input support
-- [ ] Better compileation error messages
-## Macro System
-- [ ] `as->` macro for syntactic sugar
-- [ ] `gensym` for avoiding name collision
-## Python AST
-- [ ] `type_comment` never considered. Later, it should be covered
-- [ ] Any missing AST nodes in the version 3.12+

lispython-0.4.0/docs/macros.md

@@ -1,57 +0,0 @@
-# Macros
-LisPy's macro system is highly inspired by Clojure's macro system.
-You can check out the [Chapter 7](https://www.braveclojure.com/read-and-eval/) and [Chapter 8](https://www.braveclojure.com/writing-macros/) of "Brave Clojure" for more information about Clojure's macro system.
-## Expression Nodes
-These nodes are defined in `src/lispython/core/nodes.py`.
-
-You can check out how to manipulate these nodes in
-
-- the definitions of nodes themselves
-- the definitions of built-in macros in `src/lispython/macros/sugar.lpy`.
-
-## quote
-```python
-'expr
-```
-## syntax-quote
-```python
-`expr
-```
-## unquote
-```python
-~expr
-```
-## unquote-splicing
-```python
-~@expr
-```
-## Macro Definition
-Just change `def` in function definition to `defmacro`. And macros usually return a quoted expression.
-```python
-(defmacro name [args*]
-  body*)
-```
-### Macro Example
-```python
-(defmacro when [pred *body]
-  (return `(if ~pred
-             (do ~@body))))
-
-(defmacro cond [*body]
-  (def recur [*body]
-    (if (< (len body) 4)
-        (return `(if ~@body))
-        (do (= [test then *orelse] body)
-            (return `(if ~test ~then ~(recur *orelse))))))
-  (return (recur *body)))
-
-(defmacro -> [x *fs]
-  (if (== 0 (len fs))
-      (return x))
-  (= [f *rest] fs)
-  (if (isinstance f Paren)
-      (do (f.list.insert 1 x)
-          (return `(-> ~f ~@rest)))
-      (return `(-> (~f ~x) ~@rest))))
-```
-You can find more in `src/lispython/macros/sugar.lpy`.

lispython-0.4.0/docs/usage/getting-started.md

@@ -1,20 +0,0 @@
-# Getting Started
-## Simple Web REPL
-You can try LisPy without installing at
-[https://jetack.github.io/lispy-web/](https://jetack.github.io/lispy-web/).
-## Installation
-### Using pip
-```bash
-pip install lispython
-```
-### Manual Installation (for development)
-```bash
-poetry install --no-root # for dependency
-pip install -e . # for development
-```
-#### Poetry
-I recommend using [Poetry](https://python-poetry.org/) for development.
-And turn off virtual environment creation in Poetry settings.
-```bash
-poetry config virtualenvs.create false
-```