One way to rephrase objections to "all those parens" of Lisp is that the most common style of using it makes it necessary to "write boring code 'in AST'", if you will, and not even in a very nice, commonly accepted 2-dimensional tree notation.
I always wonder how different the history of prog.langs would be if early on one of the many indent/offside rule based 2-D notations had become popular with "boring code" writers in Lisp and not eschewed by "fancy macro writers" in Lisp.
That sounds interesting but is hard to search for, have you got an example?
http://srfi.schemers.org/srfi-119/srfi-119.html
EDIT: To elaborate on my `quote do:`, this is a little macro to avoid doing many tedious code repetitions:
macro strp(sVars: varargs[untyped]): untyped =
result = newStmtList() # strip some string vars; Assume new-scope
for sV in sVars: result.add(quote do: (let `sV` = `sV`.strip))
strp sTm,sUs,sSy,sUt,sRS,sIn,sOu,mjF,mnF,swp,vsw,isw,isr,ixr,idr,nsg,msn,mrc
let sTm = sTm.strip
let sUs = sUs.strip
...
The static typing of Nim (rather than gradual typing defaults like Lisp or Cython) tends to make beginner programs less "performance cringe" (as long as they compile with `-d:release -d:lto`!).
As someone who loves both Lisp and Pascal, I really need to revisit Nim.
We all know about memoize, but let's say I want to define a global hash-map, where the keys are actual pieces of code and the value the result that would be evaluated when executed. Something like this:
Which can then be used like this in a trivial way, just passing code because code is data: Sure, something like this is possible in other languages, but having done macros in languages such as Rust and Nim, it involves such a verbose and syntax soupy way of dealing with the AST that I don't feel like reaching for those abstractions that often. I'd rather just write boring code, and most consider this a feature.