axisofeval

> I'm not entirely convinced of which way to add dynamic scoping to scheme is best I believe the way Kernel[1,2,3] handle this is really great. A `vau` expression is like a `lambda` expression (it's a lexically scoped fexpr actually) except that its operands (~ arguments) are passed in call-by-text and there is an extra argument which is the dynamic environment of the call site. This way you can `eval` the operands in the dynamic environment if you want to, but you can also `eval` quoted symbols or expressions in this same environment, thus achieving dynamic scoping. This is very powerful, `vau` expressions can replace functions and macros altogether (and you have first class macros "for free" for instance). The counterpart is that I don't know if this kind of code can be compiled down to efficient code. [1] http://web.cs.wpi.edu/~jshutt/kernel.html - John N. Shutt's Kernel page. [2] http://klisp.org/ - An implementation of Kernel. [3] http://axisofeval.blogspot.fr/ - a blog which talks a lot about Kernel.

I rather like things like the mobx flow action system based on generators - you yield() promises rather than awaiting them and use yield* to splice other functions following the same approach. You can see a nice example of using that approach standalone here: https://axisofeval.blogspot.com/2024/05/delimited-generators.html

Exceptions as the underpinning of such a lang is interesting, but I think you might be better off with push-prompt, and an implementation of delimited dynamic binding to allow eg. Process migration. Wat is a very small language which does fexprs (vau calculus), delimited continuations, delimited dynamic binding, custom algebraic effects (try catch, fibres) on top of them, modules, types, and has a metacircular VM in a few hundred LOC. It's missing a native implementation but it's very impressive. https://github.com/GiacomoCau/wat-js Links to the formal research are in the readme. http://axisofeval.blogspot.com/?m=1 Has several good discussions on the topics, and are more accessible than the papers.

> I'd say it's probably worth that cost, if used judiciously. Can be said of anything so it really doesn't say anything at all. This is could be a good criticism in theory, in practice you can observe how it works out. Fukamachi uses @ everywhere, attila-lendvai uses his def-star library ej (def (class foo) ...) instead of (defclass foo ...), some people use iterate, etc and all is good. People can write shit code sans macros no problem. I'd rather have them than don't. After all macros embody the whole point of programming[0] [0]: http://axisofeval.blogspot.com/2011/05/why-of-macros.html

I'm sure they keep using it and that's ok, of course. But deepdown you want your projects to be widely adopted. That provides motivation and renewable workforce given that at some point the "elders move to greener pastures". Take Go for example. Its creators helped a lot of people to write easier network software. Maybe they even would have preferred another syntax, but got over that and just used a syntax that most programmers would perceive as familiar and easy to learn. To me there is a lesson in this too. Also this is an interesting text about the subject http://axisofeval.blogspot.com.br/2010/06/letter-to-young-pl-enthusias… (And I love Clojure, Ocaml, Factor, Lisp, Erlang... so really the lesson is for me)

Follow the link on "Compared to Haskell, Lisp is a big hack." - http://axisofeval.blogspot.com/2011/01/why-lisp-is-big-hack-and-haskel… - for a more detailled post.

What I don't like about Clojure is that it leaves out some features which I love about other Lisps. See this post: http://axisofeval.blogspot.com/2010/04/dylan-and-lisp-family-trees-cen…

From what you write about macros, it hints at something like F-expressions and first class environments, though I am not sure if it actually does have it. I find the Kernel programming language to be inspiring. It is based on first class environments and tries to go further in the direction of the philosophy of Scheme : "Programming languages should be designed not by piling feature on top of feature, but by removing the weaknesses and restrictions that make additional features appear necessary." Your post is also in this spirit. A language like this would allow a much greater dynamism and a reflective capability, but compiling it is a research project. (There was also a minor scuffle here on HN, a decade ago, regarding the non-inclusion of eval in ClojureScript in order to enable better optimization.) https://web.cs.wpi.edu/~jshutt/kernel.html https://axisofeval.blogspot.com/2011/09/kernel-underground.html --- Edit: Brief explanation of F-expressions (vau expressions in Kernel) For a function call, the argument expressions are evaluated and the function only receives the values. For a macro, the argument expressions are accessible to the macro, but the macro cant access the environment, so it cant evaluate these expression, but rewrites code into some other code. For a vau expression as in Kernel(analog of lambda), the expression receives not just the argument expressions but also the lexical environment. This means it can genuinely return a result and not just…

I'm not OP, but there are a few I could see some mentioned in the OP's post in passing. * The common lisp condition system [3, 0] is a way better way to do errors. * Tune-able compilers [1] allow you to make better trade offs than even gcc allows for c, let alone Clojure's very opaque compiler. * CLOS [2] is a very powerful object system which clojure does not replicate (they have multi methods, and java classes, but not a meta class system; think python's meta class features but better (because of macros and compiler access) and with multi methods designed in). * Nice native interoperability (Clojure generally being on the JVM, and common lisp capable of direct calls and memory manipulation). That being said. Clojure's unparalleled concurrency features are amazing. I would compare them as: if Clojure is the Java of lisps, then Common Lisp is the C++ of lisps. [0] http://www.gigamonkeys.com/book/beyond-exception-handling-conditions-a… [1] http://franz.com/support/documentation/current/doc/compiling.htm#decl-… [2] http://www.laputan.org/pub/papers/MOP.pdf [3] http://axisofeval.blogspot.com/2011/04/whats-condition-system-and-why-…

You don’t need continuations to implement resumable errors. The trick is simply to not unwind the stack when an error happens. http://axisofeval.blogspot.com/2011/04/whats-condition-system-and-why-…

oh, reading his previous blog article I see that J. Shutt (he made kernel, reviving fexpr in a way) commented https://axisofeval.blogspot.com/2011/08/notes-on-delimited-continuatio… and that he has a blogger (last entry in 2020 though) https://fexpr.blogspot.com/

There's a partial list of Kernel implementations (the lisp described in the paper) that I'm aware of: https://axisofeval.blogspot.com/2011/09/kernel-underground.html

Agreed wholeheartedly. Take this blog post, replace “Lisp” with “C++”, “Haskell” with “Rust”, and “type system” with “lifetime system”: http://axisofeval.blogspot.com/2011/01/why-lisp-is-big-hack-and-haskel… “C++, as it stands, can't do any of that, and won't be able to do any of that. That's simply a fact. Why? Because it's coming at the problem from the wrong direction. Trying to graft an interesting lifetime system or verification onto C++ is simply too heroic and ill-specified a task. C++ starts with ultimate freedom/unsafety, and you can't constrain it. Rust starts with ultimate bondage/safety, and then, piece by piece, adds that freedom back. On a theoretically well-founded basis.” This summarizes C++'s safety woes.

In pursuit of a mathematically derived Scheme, you might be interested in John Shutt's Kernel [0], based on his formal theory of F-exprs called the Vau Calculus [1]. [0] http://axisofeval.blogspot.com/2011/09/kernel-underground.html [1] http://lambda-the-ultimate.org/node/4093

@lispm see the reference I made to FEXPRs in reply below (http://axisofeval.blogspot.co.id/2011/07/meaning-of-forms.html) You seem to be a lot more knowledgeable than I on Lisp. It seems there's a divide on FEXPRs and macros when I look into further references. What's your take on it aside from the Pitman paper you cited? Is is possible something useful was thrown away from CL, or Pitman's argument holds? PicoLisp seems to implement FEXPRs a bit from my limited knowledge. I am currently in a death spiral of LFE, Chez Scheme, PicoLisp, Extempore (xtlang), and Shen, not to mention my necessary forays into elisp, since I use spacemacs! I need to choose one, only one. Thanks.

Webpage: http://web.cs.wpi.edu/~jshutt/kernel.html An implementation: http://klisp.org/ Others: http://axisofeval.blogspot.fr/2011/09/kernel-underground.html

This reminds me of this quote from [1]: "In this mythical, not yet-existing, but clearly on-the-horizon "Haskell", you'll be able to choose how much safety you want. You'll have "knobs" for increasing or decreasing compile-time checks for any property and invariant you desire." It might not be "Haskellish" or safe in the way that I or some others are used to, but it does seem to be a clear increase in the expressiveness of the language. [1] http://axisofeval.blogspot.com/2011/01/why-lisp-is-big-hack-and-haskel…

This is an implementation of (as the name suggests!) Scheme without special forms, inspired by John Shutt's Kernel language. See http://web.cs.wpi.edu/~jshutt/kernel.html, http://lambda-the-ultimate.org/node/1680, and http://fexpr.blogspot.com for more discussion, and http://axisofeval.blogspot.com/2011/09/kernel-underground.html for implementations.

John Shutt's Kernel language [1], decomposes lambda into unevaluated operands, a lexical environment, and the function body: '(λ args body) can be expressed as: ($vau args env body) [2] Interestingly, because $vau does not evaluate `args` and explicitly recieves a lexical binding, macros are not necessary in Kernel, and hygiene is a simple matter of (eval)ing with the right environment. Arguably then, Kernel is more fundamental than Lisp. [1]: http://web.cs.wpi.edu/~jshutt/kernel.html [2]: Manuel Simoni has a short overview of $vau here: http://axisofeval.blogspot.com/2012/03/i-want-to-understand-vau.html

Here's a good explanation using pseudo-Java: http://axisofeval.blogspot.com/2011/04/whats-condition-system-and-why-…

He argues that some features - e.g., dependent typing (http://axisofeval.blogspot.com/2010/10/notes-on-dependent-types.html) - won't emerge from Lisp, because they approach the problem from the wrong angle; no safety towards more safe vs. Haskell (and others') reverse approach.

Touche. On the other hand he calls Common Lisp one of "the few acceptable dynamic languages." http://axisofeval.blogspot.com/2010/07/c-40-industrial-response-to-lis… In other words: CL sucks but all the other dynamic languages suck more. My semantics don't label that as "detraction" but yours may differ.

> Still, the basic eval command looks remarkably similar in lisp vs TCL. The primary difference is whether arguments are evaluated before (Scheme/Lisp) or after (Tcl) being sent to the function/command. The deferred evaluation is what allows you to do things that you need macros for in other languages. (ie. you need deferred evaluation or macros to implement short-circuit operators, for example) However, early Lisps had FEXPRs which also deferred evaluation. The late John Shutt built and entire Lisp called "Kernel" around the idea: http://web.cs.wpi.edu/~jshutt/kernel.html I strongly recommend a read through his PhD thesis: https://www.wpi.edu/Pubs/ETD/Available/etd-090110-124904/ Unfortunately, his implementation isn't anywhere near as good as his conception. Other people have implemented it better. http://axisofeval.blogspot.com/search/label/kernel http://axisofeval.blogspot.com/2011/09/kernel-underground.html The Oh Unix shell grabs some of the core Kernel concepts and runs with them in a useful package: https://github.com/michaelmacinnis/oh