AttaLambda 0.7.0 — Small Lisp sugar

AttaLambda 0.7.0 — Small Lisp sugar

Linux x86-64 is the only supported public binary download.
The implementation was reviewed through PR #6.

This release adds exactly four presentation conveniences:

• (list expression ...) expands to existing typed cons ending in NIL.
  Empty and nested Lists work; computed elements preserve cons's existing
  evaluation and Error behavior.
• (lambda (x y z) body) expands to nested unary lambdas. One or more
  identifier parameters are required; partial application works normally.
• (let ((x value) (y other-value)) body) expands to sequential nested lets.
  Later values can use earlier bindings. Empty bindings return the body.
• (cond (condition result) ... (else result)) expands to nested typed if.
  The final else is required. Conditions retain Bool checking and Error
  propagation, and unselected results and later conditions are not forced.

#lang attalambda
(def sum = (lambda (x y) (add x y)))
(print (list (sum 2 3) (let ((x 2) (y (add x 4))) y)))
(stdout (cond ((lt 2 3) "small") (else "large")))

The output is [5, 6]small, without a trailing newline. See the
API reference for the complete syntax contract.

Old unary lambda, single-name let, def, rec, and function application forms
retain their behavior. The new names list and cond follow existing lexical
shadowing; generated constructors and conditionals retain their original
bindings. Recursive def and mutual module-binding cycles remain forbidden,
including references hidden inside the new syntax.

All four sugars disappear into existing terms. Object-language computation
remains variables, unary untyped lambdas, and application. No core, effects,
runtime, host, representations, dependencies, or purity exceptions change.
Product version 0.7.0 maps to Racket package version 0.7.

The release also includes the previously merged cleanup from PR #5: correct
relative symlink traversal, cycle rejection while permitting completed-target
revisits, and bounded format-based runner version validation.

AttaLambda 0.6.0 — Generic pure printing

AttaLambda 0.6.0 adds generic pure value rendering and print.

Twelve pure functions convert tagged values to language Strings, including
recursive Lists, Options, Results, Maps, and Errors. print sends that display
through the existing stdout capability, returns its Result, and adds no newline.

#lang attalambda

(print (some (make-ok (cons 1 (cons TRUE NIL)))))
(stdout "\n")

Output:

SOME(OK([1, TRUE]))

Rats retain exact fractions. Strings use quoted byte escapes; Maps retain their
stored order. Display is not a serialization format. Raw functions, including
functions nested inside data, have unspecified rendering behavior. Existing
Error diagnostics, representations, recursion rules, and host capabilities are
preserved. No runtime tag, dependency, reflection, or purity exception was added.

Complete release notes
and public API.

Linux x86-64 download

Download both assets below, verify the checksum, then extract and run:

curl -fLO https://github.com/kserrec/attalambda/releases/download/v0.6.0/attalambda-0.6.0-linux-x86_64.tar.gz
curl -fLO https://github.com/kserrec/attalambda/releases/download/v0.6.0/SHA256SUMS
sha256sum -c SHA256SUMS
tar -xzf attalambda-0.6.0-linux-x86_64.tar.gz
cd attalambda-0.6.0-linux-x86_64
./bin/attalambda --version
./bin/attalambda examples/hello.attl

The archive includes its private Racket CS 9.3 runtime; no Racket installation is
required. Linux x86-64 remains the only supported binary download. macOS and
Windows builds provide internal portability evidence only.

Archive SHA-256:
c3d9ea5263f7ab09e5f9b8d3260b8ead1335d8f1a052c7aba11edd4bf020bb4f.
The exact clean source commit is
dfa5d52a1c9f4a5841bacbba88e06b8eae90e824.

AttaLambda 0.5.0 — Pure recursive definitions

AttaLambda 0.5.0 adds rec for pure self recursion and closes a hole that previously allowed recursion through Racket's module bindings.

Use def for acyclic definitions and rec for self-recursive functions:

#lang attalambda

(rec factorial n =
  (if (eq n 0)
      1
      (mult n (factorial (sub n 1)))))

(stdout (if (eq (factorial 5) 120) "Recursion works.\n" "Unexpected result.\n"))

Migration from 0.4.0: change each self-recursive declaration from def to rec. Direct or indirect recursive module definitions now fail during expansion with status 65 and a specific source diagnostic. Mutual top-level cycles remain invalid, including cycles involving rec; replacing all declarations with rec does not enable mutual recursion. Acyclic forward references, lexical shadowing, currying, partial application, and laziness remain supported.

rec expands through the existing private lambda-calculus fixed-point term. It adds no runtime primitive, public fixed-point function, dependency, representation change, or host capability. The core algorithms and the ten existing host operations are behaviorally unchanged. The bundled HTTP server example uses rec for its decimal formatter.

Download support: Linux x86-64 only. The archive includes its private Racket CS 9.3 runtime; no Racket installation or source checkout is required. Download both assets, verify the archive with SHA256SUMS, extract it, and follow GETTING_STARTED.md.

Verification covers all 41 source test files and 14,210 assertions, the 32-module expanded purity check, the full repository boundary inventory, and the isolated Linux archive consumer. The consumer checks the public API including recursive partial application, help/version, guide workflow, file/TCP/HTTP examples, process statuses, and relocation without an installed Racket or source checkout. macOS and Windows CI remain internal portability evidence.

Source commit: d770b8335a06a8ec6e5925030c4a92cde88e85d8 (PR #3).

AttaLambda 0.4.0

AttaLambda 0.4.0 completes the public API and List library update while preserving absolute object-language purity.

Changes and migration

• Public callable names are lowercase: ADD becomes add, STRING-APPEND becomes string-append, and MAP-LOOKUP becomes map-lookup. Old uppercase callables are removed without aliases. Constants such as TRUE, NIL, NONE, and HTTP-STATUS-OK retain their names. Error metadata uses the lowercase operation names.
• Use ASCII Char literals such as #\a, #\A, #\7, #\space, and #\newline. The 85 named Char bindings are removed, so a, x, n, and m are ordinary identifiers. Direct literals accept ASCII 0–127; make-char still accepts byte values 0–255, and Strings retain their UTF-8 byte encoding.
• The List API now has 25 functions: cons, head, tail, is-nil, len, take, drop, nth, take-while, drop-while, append, reverse, zip, concat, flatten, map, filter, reduce, any?, all?, find, find-index, contains?, range, and repeat. Reduction is left to right; searches stop when their answer is known; callback Errors propagate; indices and counts use Rat; nth and searches return Option where specified.
• Map remains Map, with its existing map-* operations alongside List map.
• This release also includes the source changes since 0.3.0: explicit program-chosen (exit 0) / (exit 1), incremental bounded HTTP request accumulation, and simplification of the codec, host, runner, and verification code.

All object-language computation remains variables, unary lambdas, and application after expansion. Existing representations, the generalized type checker, and the single host boundary remain intact. The API/List update adds no dependency or host capability.

The complete public API reference documents the signatures and behavior.

Verification

The release was built from clean merged commit bd1dd56925765f8d8359609a49e333ba570bcfc6, whose file tree is identical to the CI-verified final PR revision. All 41 local suites passed with 14,100 assertions, the expanded purity proof passed for 32 production modules, and the complete boundary inventory passed. All ten PR CI jobs passed with Racket CS 9.3 and native build/consumer checks. Automated review of the language implementation completed without findings.

This exact Linux archive passed the isolated Ubuntu 24.04 consumer with no Racket installation, source checkout, or external network. Checks covered all 25 List functions, Char literals and ordinary identifiers, Map, laziness, the getting-started workflow, stdout, file/TCP/HTTP behavior, exit statuses, and relocation.

attalambda-0.4.0-linux-x86_64.tar.gz — 14,016,817 bytes — SHA-256 29728792d17843c7c09faf5f9be0cb4b215e13a43113a7b65d83d909dd37ac8b.

Supported download

Linux x86-64 remains the only supported binary download. The archive includes its runtime; no Racket installation is needed. macOS and Windows builds remain internal portability checks and are not public downloads.

curl -LO https://github.com/kserrec/attalambda/releases/download/v0.4.0/attalambda-0.4.0-linux-x86_64.tar.gz
curl -LO https://github.com/kserrec/attalambda/releases/download/v0.4.0/SHA256SUMS
sha256sum -c SHA256SUMS
tar -xzf attalambda-0.4.0-linux-x86_64.tar.gz
cd attalambda-0.4.0-linux-x86_64
./bin/attalambda --version
./bin/attalambda examples/foundations.attl

AttaLambda 0.3.0

AttaLambda 0.3.0 is the language's second public release, delivering Milestone 4: exact rational numbers and foundational values.

What's new

• Rat is the only number type. Exact rationals — a reduced signed numerator over a positive denominator on normalized binary digit Lists — replace the former public Nat surface entirely. Arithmetic is exact; integer and fraction literals like -7/3 lower directly to canonical values, and inexact numbers are rejected at expansion.
• Unit, Byte, Option, and Map join Bool, List, Result, Char, String, and Error as lambda-encoded types. Byte sequences are List Byte, and file and TCP payloads now cross the host boundary as bytes. Map is persistent and built entirely from lambdas.
• The retired Nat surface is enforced by a repository-wide gate scan, the expanded compile-level purity proof now covers all 29 core and effects modules, and the error-kind space is pinned collision-free.

Verification for this exact artifact: 12,298 assertions across 38 test files, the 29-module structural purity proof, a zero-finding boundary inventory, and an independent consumer acceptance in a fresh Ubuntu 24.04 container with no Racket installation (checksum verification, the full getting-started workflow, and relocation; ~360 ms startup).

Supported download

Linux x86-64 is the only supported binary distribution. Users should not have to bypass operating-system security protections to try a language, so macOS builds without Apple signing and notarization and Windows builds without Authenticode signing are not distributed.

Download, verify, extract, and run:

curl -LO https://github.com/kserrec/attalambda/releases/download/v0.3.0/attalambda-0.3.0-linux-x86_64.tar.gz
curl -LO https://github.com/kserrec/attalambda/releases/download/v0.3.0/SHA256SUMS
sha256sum -c SHA256SUMS
tar -xzf attalambda-0.3.0-linux-x86_64.tar.gz
cd attalambda-0.3.0-linux-x86_64
./bin/attalambda --version
./bin/attalambda examples/foundations.attl

attalambda-0.3.0-linux-x86_64.tar.gz — 13,938,743 bytes — SHA-256 7adc7343720b0a1d6ed86af47059f031f571ab93649a314303c56d6b8a3d7870

Running from source needs only Racket: see the repository README.

AttaLambda 0.2.0

AttaLambda 0.2.0 is the first self-contained release. Its supported public
binary distribution is Linux x86-64. It provides direct
attalambda FILE.attl execution; the canonical .attl and
#lang attalambda source contract; and stdout, whole-file, blocking TCP, and
minimal HTTP examples through the single language-visible host boundary.

Download both manual assets, verify the archive before extraction, and follow
the repository README:

• attalambda-0.2.0-linux-x86_64.tar.gz
• SHA256SUMS

The Linux archive is exactly 13,728,716 bytes with SHA-256
86f980d696b45b42c251b78e6a66b9cd875f649217bfb09731cf6b47c66b00ac.
The original 410-byte SHA256SUMS has SHA-256
7786bf553caac0087ab22f3636d546a1fe00f89a446611c1516cc58f411f6f7f.

GitHub's automatically generated Source code ZIP and tarball are source
snapshots, not the self-contained Linux archive.

Withdrawn desktop artifacts

The two macOS archives were withdrawn after a real public download
demonstrated that Gatekeeper blocks the unsigned, unnotarized executables.
AttaLambda does not ask users to bypass that operating-system protection.

The Windows archive was also withdrawn. Its executable is Authenticode
NotSigned. Microsoft's current SmartScreen developer guidance says an
unsigned download receives “Windows protected your PC,” requires “Run
anyway,” and can be non-bypassable under enterprise policy. Windows 11 Smart
App Control can block unsigned files outright.

https://learn.microsoft.com/en-us/windows/apps/package-and-deploy/smartscreen-reputation

https://support.microsoft.com/en-us/windows/security/threat-malware-protection/smart-app-control-frequently-asked-questions

The Release originally contained macOS arm64, macOS x86-64, and Windows
x86-64 archives. Their exact entries remain in the unchanged SHA256SUMS as
historical publication evidence; those entries are not current downloads or
support claims.

The retained Linux archive is byte-for-byte unchanged, so its embedded
GETTING_STARTED.md still contains the original four-target release-note
paragraph. This Release page and the current repository README supersede only
that historical platform-availability statement. The Linux verification and
run commands remain current.

Authority and safety

AttaLambda does not sandbox programs. A program runs with the launching
process's authority. It can write terminal output, read accessible files,
create, truncate, or replace accessible files without prompting or making a
backup, connect to reachable TCP hosts, and listen on permitted local ports.
Inspect and trust an .attl program before running it.

Demonstrated system

The public Linux archive passed the complete no-Racket consumer in a
digest-pinned Ubuntu 24.04 container. It was also downloaded again from this
public Release in a fresh Ubuntu 24.04 Docker userspace on x86-64: checksum
verification reported OK, Racket was absent, attalambda --version printed
AttaLambda 0.2.0, and the bundled hello program printed
Hello from AttaLambda.

This is an exact observation, not a minimum compatibility guarantee or a
claim for other distributions, processor architectures, or Linux versions.

Signing and limitations

No AttaLambda identity-backed or detached cryptographic signature accompanies
the Linux archive or SHA256SUMS.

• There is no installer, automatic PATH configuration, REPL, program-argument
  API, package manager, updater, formatter, debugger, or editor integration.
• Programs receive no sandbox, permission prompt, backup, timeout, or
  concurrency layer.
• Networking is blocking TCP plus the documented minimal HTTP/1.1 subset. It
  does not provide TLS, UDP, asynchronous serving, or a general HTTP
  framework.
• Linux x86-64 is the only supported public binary target. No compatibility
  floor or long-term support schedule is promised.

Source and license

The Linux archive was built from commit
42ff0a7810ebeced445ab23561433a2dc423e433. AttaLambda is licensed under
Apache License 2.0. The archive includes the exact approved notices and
complete license texts for its bundled Racket CS 9.3 runtime components.