Hacker News Board Hacker News, browsed like a classic message board
Live data from Hacker News

Lisp moving Forth moving Lisp

letoverlambda.com

Post reply on HN
Print view View original

11–20 of 37 posts

Re: Lisp moving Forth moving Lisp

#11

Post by dreamcompiler »

Vohlenzer wrote: post #2

I finished Let Over Lambda recently. I'm not an experienced lisp programmer but it's strangely readable if you allow yourself to not understand every little detail of the Common Lisp code. For example I hadn't read On Lisp. I had read The Little Schemer. It's a wonderful tour of advanced macro concepts. With several of the macros presented I found myself saying "well that's just x language feature in y" but that's mi…

> reminded me of the intertwined nature of DNA, RNA and proteins in Biology

My analogy is how a changing electric field generates a changing magnetic field which generates a changing electric field which ... is light.

Forth is the electric field and Lisp is magnetic (or vice versa). They are two sides of the same coin.

Lisp really is the Maxwell's equations of software.

Re: Lisp moving Forth moving Lisp

#12

Post by dreamcompiler »

LandR wrote: post #10
peheje wrote: post #3

Earlier quoted context omitted.

What are some genuinely useful things macros can do?

Take C#, if you want a new language feature or syntax added you have to propose it to the language design team, they have to decide it's worth implementing then you have to wait on it being implemented and released and your tooling updated. If I want some new syntax in a LISP, I just write a macro. e.g. the following threading macro in clojure (->> x foo bar) Takes x and passes it as the last argument to foo, then th…

And that particular threading macro looks a lot like monadic code in Haskell, which looks a bit like Forth, which looks like a shell command with pipes.

Macros let a domain programmer (as opposed to the compiler writer) in Lisp implement almost any other programming paradigm as a native language feature.

Re: Lisp moving Forth moving Lisp

#13

Post by klibertp »

Vohlenzer wrote: post #8
arvyy wrote: post #6

Earlier quoted context omitted.

all the things, if macro system is sufficiently sophisticated (ie., hygienic with ability to attach metadata to syntax object). Racket is one of languages with such system, and they implemented static typing using them.

Interestingly, Let Over Lambda eschews hygienic macros because they limit the power (and danger) inherent in macro design.

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.

Re: Lisp moving Forth moving Lisp

#14

Post by throw-qqqqq »

peheje wrote: post #3
Vohlenzer wrote: post #2

I finished Let Over Lambda recently. I'm not an experienced lisp programmer but it's strangely readable if you allow yourself to not understand every little detail of the Common Lisp code. For example I hadn't read On Lisp. I had read The Little Schemer. It's a wonderful tour of advanced macro concepts. With several of the macros presented I found myself saying "well that's just x language feature in y" but that's mi…

What are some genuinely useful things macros can do?

Generally, it enables type-safe, ahead-of-time compiled code to perform work at compile time that would require runtime execution in many other languages

Re: Lisp moving Forth moving Lisp

#15

Post by klibertp »

peheje wrote: post #3
Vohlenzer wrote: post #2

I finished Let Over Lambda recently. I'm not an experienced lisp programmer but it's strangely readable if you allow yourself to not understand every little detail of the Common Lisp code. For example I hadn't read On Lisp. I had read The Little Schemer. It's a wonderful tour of advanced macro concepts. With several of the macros presented I found myself saying "well that's just x language feature in y" but that's mi…

What are some genuinely useful things macros can do?

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.

Re: Lisp moving Forth moving Lisp

#16

Post by dreamcompiler »

throw-qqqqq wrote: post #14
peheje wrote: post #3

Earlier quoted context omitted.

What are some genuinely useful things macros can do?

Generally, it enables type-safe, ahead-of-time compiled code to perform work at compile time that would require runtime execution in many other languages

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.

Re: Lisp moving Forth moving Lisp

#17

Post by a-french-anon »

Vohlenzer wrote: post #7
peheje wrote: post #3

Earlier quoted context omitted.

What are some genuinely useful things macros can do?

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-…

CL-PPCRE actually doesn't really do what most people think it does, cf https://applied-langua.ge/posts/omrn-compiler.html#orgd52b4a... (which instead does).

A small tidbit: you don't actually need full syntactic macros to get compile time computation in CL, compiler macros (https://www.lispworks.com/documentation/HyperSpec/Body/03_bb...) suffice.

Re: Lisp moving Forth moving Lisp

#18

Post by klibertp »

dreamcompiler wrote: post #16
throw-qqqqq wrote: post #14

Earlier quoted context omitted.

Generally, it enables type-safe, ahead-of-time compiled code to perform work at compile time that would require runtime execution in many other languages

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.

I don't think that moving the evaluation to compile time is something you can just ignore when discussing macros. It's an important differentiator between macros and Fexprs[1].

IME, the primary use case for macros in Lisps is language extension, a step before a DSL. For every `loop` there are thousands of `with-x` macro implementations. See the macro-writing macros in Alexandria/Serapeum for the most common patterns.

Also, some dynamic languages (Io, Prolog, Groovy) support DSLs through non-macro mechanisms. DSLs in those languages are as easy (or easier) to implement as in Lisps; however, they tend to be less performant. So, again, compile-time macro execution does matter for the DSL use case, too.

[1] https://en.wikipedia.org/wiki/Fexpr

Re: Lisp moving Forth moving Lisp

#20

Post by z0ltan »

peheje wrote: post #3
Vohlenzer wrote: post #2

I finished Let Over Lambda recently. I'm not an experienced lisp programmer but it's strangely readable if you allow yourself to not understand every little detail of the Common Lisp code. For example I hadn't read On Lisp. I had read The Little Schemer. It's a wonderful tour of advanced macro concepts. With several of the macros presented I found myself saying "well that's just x language feature in y" but that's mi…

What are some genuinely useful things macros can do?

[dead]
Post reply on HN