Ask HN: Is Lisp Simple?

The loop macro is an interesting example as its pretty much a mini language within Lisp just for looping purposes that doesn't use the normal s-expression based syntax - which is either a bad thing or a great example of how powerful Lisp can be... Personally, when I used to write Common Lisp for a living (a long long time ago) I was very fond of loop.

As for "it's all just lists" - Common Lisp directly supports a variety of different mechanisms for structuring data, including the rather wonderful CLOS.

> I thought everything was suppose to be like: `(left . (left . right) )`.

Could be, but you don't need the "." (or the list as so-called "cons pairs"). (a b c ...) is enough.

> It seems as if there are actually a ton more special case primitives I need to know

You need to know a handful of special forms like and, cond, let etc (corresponding roughly to keywords in other languages). Everything uses those with the same syntax (nested lists), with an exception:

Normally (a b c) means call function a with arguments b c. If you want to treat it as a list you can use the quote "function":

  (quote a b c)

For convenience this can also be written as:

  '(a b c)

> (loop for i in '(1 2 3) when (> i 1) return i)

Loop is a macro, a user-defined syntax that can evaluate its arguments in a special way. It's not part of the core language, even if it comes with it. Rather it is implemented in Lisp itself.

You can just not use it, it's neither core Lisp, nor essential. If you do want to use it, or have to read the code of someone that does use, it's pretty easy to understand. It was created so people can have their familiar for loop in Lisp too.

> How do I read this as an s-expression?

What do you mean? This is already an s-expression. Or it would be, if you actually write an instance of this, this is just an example with placeholders. An instance would be something like:

  (defun double (a) "Doubles a number" (+ a a))

corresponding to the:

defun = special form (similar to "def" or "function" in other languages)

double = name of function we define

(a) = parameter list of a single parameter: a

"Doubles a number" = docstring, similar to the """docstrings" in Python, descriptive metadata string about the function

(+ a a) = add a to a in prefix (operator first) math notation

There's a community version of the spec as well: https://cl-community-spec.github.io/pages/index.html

> I think most special forms do not complicate syntax, as they look like your standard s-expressions

Take LET:

  (let ((a b) (c d) e (f g))
    (declare (type integer a))
    (+ a b c d e f g))

It does not look like (foo arg0 arg1 ... argn).

Instead it takes a binding list, which is not evaluated. Where bindings can take a variable and a value. The value is evaluated, the variable not. The follows a declaration, which is not evaluated either, but which can be used by the compiler... There are lots of declarations forms: allocation, scope, optimization, types, ...

oops, I shouldn't post drunk