--- title: Let Over Lambda | daily.dev description: A deep technical exploration of implementing a Forth interpreter in Common Lisp using macro abstractions. The chapter covers Forth's history, abstract... canonical: https://daily.dev/posts/let-over-lambda-1vtzpv5ni twitter:card: summary_large_image twitter:site: @dailydotdev og:type: website og:site_name: daily.dev og:title: Let Over Lambda | daily.dev og:description: A deep technical exploration of implementing a Forth interpreter in Common Lisp using macro abstractions. The chapter covers Forth's history, abstract... og:url: https://daily.dev/posts/let-over-lambda-1vtzpv5ni og:image: https://api.daily.dev/og/posts/1vTzPv5nI.png og:image:alt: Let Over Lambda og:image:width: 1200 og:image:height: 630 og:locale: en --- > ## Documentation Index > Fetch the complete documentation index at: https://daily.dev/llms.txt > Use this file to discover all available pages before exploring further. # Let Over Lambda **[Hacker News](https://daily.dev/sources/hn)** · 60 min read · 0 upvotes · 0 comments ## Summary A deep technical exploration of implementing a Forth interpreter in Common Lisp using macro abstractions. The chapter covers Forth's history, abstract registers, threaded code variants (indirect, direct, token, subroutine, and a novel 'cons threaded' approach), and how Forth's immediacy concept parallels Lisp macros. Key topics include bootstrapping a Forth environment as a closure using let-over-lambda and pandoric macros, defining primitives, implementing a standard library, and the concept of 'duality of syntax' — the idea that good macro abstractions reduce the effort required to evolve programs. The chapter also introduces the 'Flub' concept (languages that only support opaque subroutine-threaded code) and demonstrates how Lisp macros can make Lisp a non-Flub language. ## Full article daily.dev links to this article rather than hosting it. Read it at the original source: ## Community take How the wider developer community reacted, aggregated from 2 discussions and 39 comments across hackernews, lobsters (as of 2026-07-29). **TL;DR:** The community is enthusiastically engaged with the ideas in Let Over Lambda and the relationship between Lisp macros and Forth, with lively discussion about what macros enable (DSLs, compile-time computation, language extension) and some nuanced debate about hygienic vs. unhygienic macro systems. **Sentiment:** 72% positive · 20% mixed · 8% skeptical **The case for** - Macros allow programmers to implement new language features and DSLs without waiting on language designers, as illustrated by threading macros in Clojure. - Macros enable compile-time expansion of things like regex and ORM queries, turning runtime work into compiled code. - Sufficiently sophisticated macro systems (e.g., Racket's syntax-parse) are no less powerful than defmacro and can even implement static typing. - Macros make async/await-style CPS transforms implementable as a library rather than a language feature. **The pushback** - Let Over Lambda's dismissal of hygienic macros is contested — Racket's syntax-parse is argued to be equally powerful with more structure. - CL-PPCRE's macro behavior is noted to be misunderstood by most people; it doesn't do what is commonly claimed. - Forth-based programs can become brittle as they grow, limiting practical appeal. **By community** - hackernews (positive): Commenters are broadly enthusiastic about macro power and the Lisp/Forth connection, with substantive technical debate about hygiene, compile-time evaluation, and DSL design. - lobsters (mixed): No comments were available to assess sentiment. **Hottest debate:** Whether hygienic macro systems (like Racket's syntax-parse) are genuinely as powerful as Common Lisp's defmacro, or whether hygiene inherently limits macro expressiveness as Let Over Lambda argues. **Open questions** - How do fexprs (lazily evaluated function arguments) differ practically from macros, and why are macros generally preferred? - Is the compile-time vs. runtime distinction the primary value of macros, or is DSL creation the more important benefit? **Highlights** > IIRC, the criticism is of syntax-rules and syntax-case kind of macros in Scheme; I don't recall (happy to be proved wrong) LoL directly mentioning syntax-parse that's specific to Racket. syntax-parse is no less powerful than defmacro; it's just (much) more structured and featureful. It's a difference between hand-rolling a recursive-descent parser and using a (really robust) PEG library. Racket's define-syntax/syntax-parse has escape hatches into procedural generation (through which you can easily break the hygiene), and the equivalent of CL's &environment contains more information and allows more operations in Racket. Racket also supports reader extensions but often doesn't need them because it has a macro-based API for module definitions (a feature completely absent from, or even alien to, Common Lisp; OTOH, Elixir borrows some of Racket's ideas in this space). For a practical example, Coalton and Typed Racket implementations show that both systems are capable of large-scale language extensions. I never studied their respective codebases, so I can't say anything about relative ease of introducing those extensions, but they are possible in both cases, at least. > — [klibertp on hackernews](https://news.ycombinator.com/item?id=49096040) > One of the cleanest examples in the book is the CL-PPCRE library for regular expressions. Without macros, regular expressions are strings at compile time and then at runtime objects are created based on the strings to evaluate them. With macros, regular expressions are expanded at compile time into Common Lisp code that implements the evaluation. There's a similar idea with an ORM library. Without macros, the object-relational mapping is defined at compile time and any dynamic SQL is generated at run time. With macros, the object-relational mapping is used at compile time to expand the query macros into Common Lisp code that includes the actual SQL. Then also remember that the compiler is available at runtime in a lisp, so the distinction only matters when comparing it to non-lisps. > — [Vohlenzer on hackernews · 1 comments](https://news.ycombinator.com/item?id=49095661) > That's true but it's not the most important aspect of macros. Macros let you define a new language that describes your problem solution more directly than you can in raw Lisp. In other words they let you create a Domain-Specific Lamguage (DSL). You can create DSLs in other languages too but it's so difficult that it's uncommon. In Lisp it's so easy that DSLs are a primary programming technique. > — [dreamcompiler on hackernews · 2 comments](https://news.ycombinator.com/item?id=49096261) > If your language has macros, you don't need to wait for it to gain async/await (and it was quite a wait even in Python and JS, while Java got its virtual threads very recently); you can just[1] implement a CPS transform as a macro: https://github.com/nim-works/cps/blob/master/docs/cps.svg [1] Yeah, I know, this word is extremely overworked in that sentence. Sorry, that's an exaggeration for effect. In reality, it's not that simple, and not always possible: it depends on the language and macro system. It's still more likely to be implementable in library code if there is a macro system, though. > — [klibertp on hackernews](https://news.ycombinator.com/item?id=49096166) > Forth exposes compilation the way Lisp exposes syntax. That’s the real similarity—not stacks or parentheses. > — [leonmeng on hackernews](https://news.ycombinator.com/item?id=49096699) **Source threads** - [hackernews](https://news.ycombinator.com/item?id=49060363) · 46 points · 39 comments - [lobsters](https://lobste.rs/s/exipox/forth_moving_lisp_moving_forth) · 8 points · 0 comments ## Similar posts on daily.dev - [A road to Lisp: Why Lisp](https://daily.dev/posts/a-road-to-lisp-why-lisp-8ozisgpji) · Hacker News · 0 upvotes · 0 comments - [Ruby And Its Neighbors: Lisp – Noel Rappin Writes Here](https://daily.dev/posts/ruby-and-its-neighbors-lisp-noel-rappin-writes-here-f4hwrudxb) · RUBYLAND · 0 upvotes · 0 comments - [Towards Fearless Macros](https://daily.dev/posts/towards-fearless-macros-90opamu2b) · Lobsters · 1 upvotes · 0 comments - [Ruby and Lisp — What Ruby Borrowed from Lisp’s Spirit](https://daily.dev/posts/ruby-and-lisp-what-ruby-borrowed-from-lisp-s-spirit-jxnfnpyms) · Ruby Flow · 0 upvotes · 0 comments - [A Guide to Typed Lambda Calculus](https://daily.dev/posts/a-guide-to-typed-lambda-calculus-qqejiz4hb) · Serokell · 0 upvotes · 0 comments --- Tags: [#lisp](https://daily.dev/tags/lisp) [View this post on daily.dev](https://daily.dev/posts/let-over-lambda-1vtzpv5ni) ```json {"@context":"https://schema.org","@graph":[{"@type":"Organization","@id":"https://daily.dev/#organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180},"sameAs":["https://twitter.com/dailydotdev","https://github.com/dailydotdev","https://www.linkedin.com/company/daily-dev-ltd"]},{"@type":"WebSite","@id":"https://daily.dev/#website","url":"https://daily.dev","name":"daily.dev","publisher":{"@id":"https://daily.dev/#organization"},"potentialAction":{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https://daily.dev/search?q={search_term_string}"},"query-input":"required name=search_term_string"}}]} {"@context":"https://schema.org","@type":"TechArticle","headline":"Let Over Lambda","url":"https://daily.dev/posts/let-over-lambda-1vtzpv5ni","mainEntityOfPage":{"@type":"WebPage","@id":"https://daily.dev/posts/let-over-lambda-1vtzpv5ni"},"datePublished":"2026-07-29T11:51:41.631Z","dateModified":"2026-07-29T15:52:41.330Z","description":"A deep technical exploration of implementing a Forth interpreter in Common Lisp using macro abstractions. The chapter covers Forth's history, abstract...","image":"https://media.daily.dev/image/upload/s--ZrL_HSsR--/f_auto/v1722860399/public/Placeholder%2006","thumbnailUrl":"https://media.daily.dev/image/upload/s--ZrL_HSsR--/f_auto/v1722860399/public/Placeholder%2006","isAccessibleForFree":true,"articleSection":"Hacker News","inLanguage":"en","publisher":{"@type":"Organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180}},"author":{"@type":"Organization","name":"Hacker News","logo":"https://media.daily.dev/image/upload/t_logo,f_auto/v1/logos/hn","url":"https://daily.dev/sources/hn"},"commentCount":0,"discussionUrl":"https://daily.dev/posts/let-over-lambda-1vtzpv5ni","interactionStatistic":[{"@type":"InteractionCounter","interactionType":{"@type":"LikeAction"},"userInteractionCount":0},{"@type":"InteractionCounter","interactionType":{"@type":"CommentAction"},"userInteractionCount":0}],"keywords":"lisp","timeRequired":"PT60M"} {"@context":"https://schema.org","@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https://daily.dev"},{"@type":"ListItem","position":2,"name":"Hacker News","item":"https://daily.dev/sources/hn"},{"@type":"ListItem","position":3,"name":"Let Over Lambda"}]} ```