Favorite lisp is common lisp. Favorite other is rust. S expression syntax. If rust had the simple syntax and s expressions of lisp… I’d be so happy.

@cadar s-expressions!

1. Common Lisp
2. Haskell I guess
3. defmacro. This would probably involve changing the syntax to list form like axel does.

1. “favorite Lisp dialect”: Scheme (Guile, Gambit, and MIT/GNU)
2. “favorite non-Lisp programming language”: Haskell
3. “favorite standard library function/macro/feature”: homoiconicity, i.e. both code syntax and data structures built from S-expression, which makes features like syntax-case feature possible, and the ability to implement declarative domain specific languages with Haskell-like type checking on large parts of your program at compile time. If every language would like this, my life would be soooo much easier and less stressful.

One thing I hate about other languages is complicated syntax that makes it difficult or impossible to do macro-programming. S-expressions are a minimalist syntax that allows lisp to be well-adapted to most any use case, and features like defmacro or syntax-case are very well designed mechanisms for doing exactly that. Other languages like Python and JavaScript have macro-programming implementations but they are so hacky and not very well designed compared to most Lisps, which have the feature built right into the language.

1. Clojure
2. F#
3. destructuring syntax, e.g. (let [{[{:keys [foo bar]}] :baz} {:baz [{:foo 1 :bar 2}]}] ...)

A please macro, that converts rational statements from other languages into lisp:

 (please 1 + 1)
 > 2

or

 (please "hello" + " there")
 > "hello there"

and best of all

(please "1" + "1")
> "2"

1. Scheme
2. Zig
3. (let loop ((…)) (cond …))

I love how recursive looping reads and unfortunately there aren’t many languages implementing this approach.