infix

We have macros and LISP is a building material, not a language. One line of code is just enough to get something that works (defmacro infix [a op b] `(~op ~a ~b)) There are libraries for that too. Clojure: https://github.com/rm-hull/infix

In 99% of programming languages, infix operations are only used for arithmetic -- and more than 99% of the programming I do doesn't involve that. Even the numerics software I've written is >90% non-numeric parts. Arithmetic doesn't even look right in programming languages with infix operators. Go to the "Chalk is still one of the primary tools of mathematicians" article here, and try typing the inequality in Java. Mathematicians aren't writing "Math.floor()" and "% 2" on their blackboards. I think you're optimizing for the wrong thing. Arguing that we need infix operations for 1% of our programs, so that arithmetic looks like how we entered it on a TI-81 or Apple II, is a false economy. It was a good tradeoff 25 or 50 years ago, but the majority of programming has moved past writing programs in terms of arithmetic on registers. That

This is better in a sense that the user doesn't need to learn something new except for the language the user is programming in and python (even though theoretically manipulating the AST will be less error prone, etc...). I use javascript everywhere, but I still didn't learn how to make babel plugins/macros because copy/pasting snippets of code two or three times is easier than learning. It's a pity that people still couldn't make a language that has a super intuitive macro system like lisp (homoiconicity, the AST is the language), and a intuitive syntax like python. I actually believe that this is partly because most Lisp users don't like the idea of new syntax and that all major lisps (CL, Clojure, Scheme) doesn't have syntax sugar as default. I would appreciate if a new CL tutorial appears that uses infix notation with reader macros(`#I

Two solutions. Threading macros wherein instead of nested parens like (x (y (z))) one writes ((->> z) y x) In clojure there is an interesting package https://github.com/rplevy/swiss-arrows which allows one to perform successive operations with explicit placement of the result of prior evaluation by placing a <> in the form ((->> (z <>)) (y <> 7) (x <>)) In practice it seems like there is often less need to do so as many similar functions or the same variety have the same ordering and other options like as-> exist too. There is also the idea of processing math expressions infix as expected when desired. https://github.com/rm-hull/infix ($= 3 + 5 * 8) ; => 43

Well, when using clojure and needed to deal with lot of math I usually used some sort of infix macro, i.e. [1]. Otherwise, I wasn't really bothered by the brackets. And most of the time I would be using some sort of threading macro anyway [2], such as -> mthomas suggested in one of the responses. [1] https://github.com/rm-hull/infix [2] https://clojure.org/guides/threading_macros