pyfun-lang 0.0.1__tar.gz

pyfun_lang-0.0.1/.github/workflows/wheels.yml

@@ -0,0 +1,122 @@
+# Build platform wheels for `pyfun-lang` and publish to PyPI on a version tag.
+#
+# Publishing uses PyPI Trusted Publishing (OIDC) — there is NO API token to manage.
+# One-time setup before the first release: on PyPI, add a Trusted Publisher for this
+# repo pointing at workflow `wheels.yml` and environment `pypi`
+# (https://docs.pypi.org/trusted-publishers/). Until that exists, the build jobs still
+# run on every push/PR; only the final `release` job needs it, and it runs only on tags.
+#
+# The wheel matrix is deliberately lean (the common student/dev platforms). Any platform
+# without a wheel falls back to the sdist and builds from source (needs Rust). To widen
+# coverage, regenerate the full skeleton with:  maturin generate-ci github
+name: wheels
+
+on:
+  push:
+    branches: [main]
+    tags: ['*']
+  pull_request:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: wheels-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  linux:
+    runs-on: ubuntu-22.04
+    strategy:
+      matrix:
+        target: [x86_64, aarch64]
+    steps:
+      - uses: actions/checkout@v6
+      - name: Build wheels
+        uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          args: --release --out dist
+          sccache: ${{ !startsWith(github.ref, 'refs/tags/') }}
+          manylinux: auto
+      - uses: actions/upload-artifact@v6
+        with:
+          name: wheels-linux-${{ matrix.target }}
+          path: dist
+
+  windows:
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v6
+      - name: Build wheels
+        uses: PyO3/maturin-action@v1
+        with:
+          target: x64
+          args: --release --out dist
+          sccache: ${{ !startsWith(github.ref, 'refs/tags/') }}
+      - uses: actions/upload-artifact@v6
+        with:
+          name: wheels-windows-x64
+          path: dist
+
+  macos:
+    runs-on: ${{ matrix.runner }}
+    strategy:
+      matrix:
+        include:
+          - runner: macos-15-intel
+            target: x86_64
+          - runner: macos-latest
+            target: aarch64
+    steps:
+      - uses: actions/checkout@v6
+      - name: Build wheels
+        uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          args: --release --out dist
+          sccache: ${{ !startsWith(github.ref, 'refs/tags/') }}
+      - uses: actions/upload-artifact@v6
+        with:
+          name: wheels-macos-${{ matrix.target }}
+          path: dist
+
+  sdist:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - name: Build sdist
+        uses: PyO3/maturin-action@v1
+        with:
+          command: sdist
+          args: --out dist
+      - uses: actions/upload-artifact@v6
+        with:
+          name: wheels-sdist
+          path: dist
+
+  release:
+    name: Publish to PyPI
+    runs-on: ubuntu-latest
+    if: startsWith(github.ref, 'refs/tags/')
+    needs: [linux, windows, macos, sdist]
+    environment: pypi
+    permissions:
+      id-token: write       # OIDC token for Trusted Publishing
+      attestations: write   # sign the build artifacts
+      contents: read
+    steps:
+      - uses: actions/download-artifact@v7
+        with:
+          pattern: wheels-*
+          path: dist
+          merge-multiple: true
+      - name: Generate artifact attestation
+        uses: actions/attest-build-provenance@v2
+        with:
+          subject-path: 'dist/*'
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: dist

pyfun_lang-0.0.1/.gitignore

@@ -0,0 +1,20 @@
+# Rust / Cargo
+/target
+# Secondary target dir used while the LSP server holds a lock on /target.
+/target-test
+
+# Cargo.lock is committed for binaries (this crate ships a `pyfun` bin).
+
+# Python packaging (maturin wheels + build artifacts)
+/dist
+*.egg-info/
+
+# Editor / OS
+*.swp
+.DS_Store
+.vscode/
+
+# VS Code extension client (installed locally, not vendored)
+editors/vscode/node_modules/
+editors/vscode/*.vsix
+.claude/worktrees/

pyfun_lang-0.0.1/CLAUDE.md

@@ -0,0 +1,106 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## What Pyfun is (one paragraph)
+
+**Pyfun is an F#-inspired, functional-first language for the Python ecosystem** — immutable-by-default,
+expression-oriented, type-inferred ADTs, exhaustive matching, **curried functions + pipe `|>`**,
+**first-class effect tracking**, plus two F# showcase features: **computation expressions**
+(`async {}`/`seq {}`/`result {}`) and **units of measure** — whose **compiler is written in Rust**
+and **compiles to readable Python**, interoperating with the Python ecosystem directly. Safety is
+F#-level because **the Rust compiler is the gatekeeper**: all type/effect/exhaustiveness/immutability/
+unit checks run before any Python is emitted (the TypeScript/Elm model). Full rationale, semantics,
+and the interop model are in `DESIGN.md`.
+
+## Status
+
+MVP showcase complete and runnable (`pyfun run`). Implemented:
+
+- **Core FP:** ADTs, records, tuples, exhaustive `match` (deep/Maranget usefulness with concrete
+  witnesses), curried functions, `|>`/`<|`/`>>`/`<<`, operator sections, HM type inference with
+  let-generalization, implicit + mutual recursion.
+- **F# showcase:** computation expressions (`async`/`seq`/`result` + user-defined builders); units of
+  measure (derived-measure aliases, unit-aware `sqrt`/`cbrt`); first-class **inferred** effects
+  (`let pure` assertion, multi-label `io`/`async`, `->{label}` annotations on declared arrows).
+- **Mutation:** blocks (`let mut`/`<-`), immutable-by-default, closure capture via `nonlocal`/`global`.
+- **Python interop:** general `extern` FFI (effectful-by-default boundary); `try e : Result a Exception`.
+- **Stdlib (module-qualified):** `List`/`Set`/`Map`/`Option`/`Result`/`Seq`/`String`.
+- **Strings/literals:** `f"..."` interpolation, raw `r"..."`, triple-quoted, escapes; scientific
+  notation, digit separators, hex/octal/binary, `**`, `%`, `//`, unary minus, chained comparisons.
+- **Advanced patterns:** active patterns, list/sequence patterns, or/as-patterns, guards, typed holes.
+- **Modules:** file-based projects (`import`, cross-module ADTs/records/externs/measures) + in-file `module`.
+- **Tooling:** full LSP (`pyfun lsp` — diagnostics, hover type/effect, go-to-def, find-refs, rename,
+  completion, document/workspace symbols; cross-file; fingerprint-cached, resilient), VS Code client, REPL.
+
+**Design mechanics and rationale live in `DESIGN.md` — the source of truth; read it before any
+language/compiler work. The remaining backlog and sequencing live in `ROADMAP.md`. What landed when
+is in git history.** Keep those three current; do not turn this Status section back into a changelog.
+
+## Non-negotiables when working here
+
+- **Read `DESIGN.md` first** for any compiler/language change; keep it the source of truth and
+  update it when design decisions change.
+- **Do not fork CPython.** Pyfun is a front end targeting Python.
+- **Scope creep is the #1 risk.** The MVP showcase set was *fixed*: effects, **three built-in** CEs
+  (`async`/`seq`/`result`), and a **small** units set. Post-MVP, **user-defined CE builders have
+  landed** (module-based, desugared — `DESIGN.md` §8.1); still deferred: unit polymorphism beyond what
+  shipped, macros, and a package manager (`DESIGN.md` §8, §11). Syntax is cheap; spend effort on
+  parser quality, error quality, and predictable lowering.
+- **Lower to a Python-AST IR in Rust, then emit readable Python** — not by string-splicing.
+  CEs desugar (`async`→`async`/`await`, `seq`→generators, `result`→`Result` short-circuit) and
+  units **erase** to plain Python numerics (`DESIGN.md` §8).
+- **Currying is curried-in-types, n-ary-in-output.** Functions curry by default, but fully-applied
+  calls collapse to direct `f(a, b)` — closures only for real partial application; the Python
+  boundary stays n-ary (`DESIGN.md` §5, §6). `|>` is pure lowering-time sugar.
+- **Effects, CEs, and units are checked in the type-checking phase** alongside HM inference
+  (see `DESIGN.md` §4, §8, §10).
+- **Naming:** `Pyfun` in prose, lowercase `pyfun` for crate/CLI/package, `.pyfun` extension.
+
+## Project layout
+
+Dependency-free Rust crate. See `DESIGN.md` §9 for the full module breakdown and build order.
+`src/lexer/` (tokenizer), `src/parser/` (recursive descent; `parser/ast.rs` holds the span-carrying
+AST), `src/ast/` (pretty-printer), `src/types/` (HM inference + ADTs + effects + units), `src/desugar.rs`
+(CE builders, sections, composition), `src/diagnostics/` (rustc-style span rendering), `src/lowering/`
+(Pyfun AST → Python IR), `src/python_emitter/` (Python IR + source emitter), `src/project/` (module
+graph), `src/lsp/` (language server), `src/repl.rs`, `src/main.rs` (CLI), `tests/` (roundtrip +
+typecheck + compile/e2e + lsp + repl), `examples/`. Favor snapshot/golden tests for parser, checker,
+and codegen. AST nodes carry a `NodeSpan` that compares equal unconditionally, so structural
+equality (and the roundtrip tests) ignore spans while diagnostics still have real locations.
+
+## Commands
+
+Toolchain is pinned to **Rust 1.96** (`rust-toolchain.toml`); edition 2024, MSRV 1.96. rustup
+auto-selects it inside the repo.
+
+```bash
+cargo build                               # build
+cargo test                                # all tests (lexer + roundtrip + compile/e2e)
+cargo test parse_print                    # single test (substring match on test name)
+cargo clippy --all-targets                # lint (currently clean)
+cargo fmt                                 # format Rust sources
+cargo run -- check examples/hello.pyfun   # type-check, rustc-style diagnostics
+cargo run -- compile examples/hello.pyfun # type-check then lower to Python (stdout)
+cargo run -- compile foo.pyfun -o foo.py  # write Python to a file
+cargo run -- run examples/hello.pyfun     # compile then execute via python/python3
+cargo run -- parse examples/hello.pyfun   # canonical Pyfun pretty-print
+cargo run -- repl                         # interactive read-eval-print loop
+```
+
+> **Windows note:** the VS Code LSP client keeps `target/debug/pyfun.exe` locked, so `cargo build`/`run`
+> can fail with "Access is denied (os error 5)". Kill the stray process first
+> (`Get-Process pyfun | Stop-Process -Force`), or build to a separate dir (`CARGO_TARGET_DIR=target-test`).
+
+The **REPL** (`src/repl.rs`, a binary-crate module over the `pyfun` lib) keeps session *definitions*
+as accumulated source; each entry is type-checked via `analyze` against them — a `let`/`type`/`extern`
+is remembered and echoes its inferred type, an expression is compiled (accumulated defs + `print (e)`,
+or bare for a `unit` expr) and run once through Python. Commands: `:type`, `:{ … :}` (multi-line, e.g.
+mutually-recursive defs), `:reset`, `:help`, `:quit`. Single-line entries (outside `:{`); defs re-run
+each eval, so pure state feels persistent but top-level effects / `let mut` don't carry across entries.
+
+The end-to-end tests in `tests/compile.rs` run the emitted Python through `python`/`python3`; they
+**skip** (not fail) if no interpreter is on PATH. **Pyfun targets Python 3.12+** (emitted code uses
+`match`/`case` and PEP 701 f-strings); the dev/test machine runs **3.14.6**. If `python` on PATH is
+older (e.g. a Windows Store 3.11 shim), the f-string nested-quote e2e test will *fail* rather than
+skip — put a 3.12+ interpreter first on PATH.

pyfun_lang-0.0.1/Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "pyfun"
+version = "0.0.1"

pyfun_lang-0.0.1/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "pyfun"
+version = "0.0.1"
+edition = "2024"
+rust-version = "1.96"
+description = "An F#-inspired, functional-first language that compiles to readable Python."
+authors = ["Simon Treanor"]
+license = "Apache-2.0"
+repository = "https://github.com/simontreanor/Pyfun"
+readme = "README.md"
+
+# Phase 1 is intentionally dependency-free (pure std): lexer + parser + AST + pretty-printer.
+# clap (CLI), an LSP crate, etc. arrive in later phases — see DESIGN.md.
+[dependencies]
+
+[[bin]]
+name = "pyfun"
+path = "src/main.rs"
+
+[lib]
+name = "pyfun"
+path = "src/lib.rs"