with-c-syntax

> but what sub-languages are we talking about? I only see a library with helper functions and macros. That's Common Lisp, not a derivative. If your language is a DSL factory, the line between your language and DSLs naturally blurs. If https://github.com/y2q-actionman/with-c-syntax exists, does it mean that C is a DSL of Common Lisp, given a good enough standard library? If https://github.com/calyau/maxima exists, does it mean that Maxima is just Common Lisp with more maths? If https://github.com/Shen-Language/shen-cl and https://github.com/coalton-lang/coalton/ exist, does it mean that Shen and Coalton are just a fancy way of writing Common Lisp in an immutable way? If https://github.com/froggey/Iota exists and we can play sdlquake on Mezzano, does it mean that LLVM-IR is a dialect of Common Lisp? The above series of questions is not mean

More to the point of how simple (and easy) defmacro is compared to syntax-case and syntax-rules, I like another fare post: https://fare.livejournal.com/189741.html If you're as smart as fare, it "isn't too hard to translate it". Though I concede this case could be analogous to trying to write a Doubly Linked List in Rust, it's not enough to say definitively yea or nay. So I'd more like to see a concrete case you have in mind where the tradeoffs are squarely against CL. Like, the loop macro is more complicated than any I have written myself, but you can break it down, and it's not that bad -- I think Norvig's version is pretty neat to study: https://norvig.com/paip/loop.lisp This project (and it's not the only one!) adding C syntax to CL https://github.com/y2q-actionman/with-c-syntax I think is more complicated than loop, and is sort of wh

It's not easy to get the point across just by reading about it. Id honestly say you should just learn some lisp and implement something cool. > I don't see why this would be any different than defining a function like I normally do. Because with functions you don't define any new syntax or implement a DSL; you don't have access to the compiler during read, compilation, and run time. This allows you to easily extend the language: do you miss list comprehensions from Python? Add it yourself with a macro. Want to generate boilerplate code? Macro. Prolog compiler? Yes. Basically anything in this book: https://github.com/norvig/paip-lisp > But why is this more productive than simply defining a "exponent()" function or something similar? It's not just about defining a new operator, you can basically implement a DSL with C-like syntax if you wan

Lisp has served as an inspiration to so many programming language designs, Javascript included, that saying a language feature isn't really unique to Lisp is a bit like saying that The Lord of the Rings is just a bunch of fantasy clichés. It's true in some sense, but it also conveys a deeply flawed understanding. Here[1] is a fun example of what's possible with a Common Lisp library that would be difficult to do in many other languages without language changes or essentially just giving up and dumping the C style code in a string and calling some sort of eval on it. That is very much not the same thing. [1] https://github.com/y2q-actionman/with-c-syntax/

> The last commit to this project was over 8 years ago. See Jiyuno Megami's repository: https://github.com/jiyunomegami/Vacietis > Any plans on getting this thing moving along again? Yes, sometime in the upcoming decade. > Was there anything learned from this project that can aid development of similar projects? What is a "similar project?" Yokota Yuki's with-c-syntax¹ takes a completely different approach to parsing and runtime representation (it is similar to ScottBurson's ZetaC², which I studied closely before writing Vacietis). I want to use this to run OpenBSD or NetBSD hardware device drivers on a memory-safe Common Lisp operating system runtime. For me a "similar project" is user-space device drivers. ¹ https://github.com/y2q-actionman/with-c-syntax/ ² http://www.bitsavers.org/bits/TI/Explorer/zeta-c/

This was posted today, illustrating the power of Common Lisp read macros (not to be confused with regular macros): https://github.com/y2q-actionman/with-c-syntax