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.

It's simpler than most languages that have a generative grammar.

If you really want to understand it I'd suggest reading this

https://groups.csail.mit.edu/mac/ftpdir/scheme-7.4/doc-html/...

and reading it again, thinking about it, writing some code, reading it again and such. It is astonishing short for a specification for a real programming language and will become clear to you if you live with it. I count 30 "special forms" in there

https://groups.csail.mit.edu/mac/ftpdir/scheme-7.4/doc-html/...

and 24 in the Common Lisp spec

https://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node59.html

although this claims the minimum is 9

https://stackoverflow.com/questions/3482389/how-many-primiti...

See also

http://www.paulgraham.com/rootsoflisp.html

> it's all just lists. Yes, Lisp code is made up of lists.

> But it seems like there are so many special constructs and macros, that make it hard to read.

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

Common Lisp is a "programmable programming language" meaning that it's possible to make macros like the loop macro that aren't even what many consider "Lispy" - lots of people who otherwise like Common Lisp dislike the loop macro. But, it's a good example of a DSL and how far you can go with making one. Of course, there are other ways to do iteration besides loop, both standard built-in forms such as do or dolist, and even 3rd party libraries like series or iterate.

Also, when macros are expanded they resolve to lists - even the loop macro.

OTOH, something like MIT Scheme which was used in SICP is a much simpler Lisp compared to CL.

If you are using Common Lisp, the HyperSpec is an awesome resource:

http://www.lispworks.com/documentation/HyperSpec/Front/index...

> (defun <name> (list of arguments) > "docstring" > (function body))

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

It's still a list.

You can re-write it as:

    (let ((my-list '(defun <name> (list of arguments) "docstring" (function body))))
     (print (first my-list))
     (print (second my-list))
     (print (third my-list))
     (print (fourth my-list)))

It will print:

    DEFUN
    <NAME>
    (LIST OF ARGUMENTS)
    "docstring"

If "docstring" appears twice when you run the above, that's because it's the value produced by the final form in the block, so it shows up as the return value of the block.

> 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

> It seems as if there are actually a ton more special case primitives I need to know, when I could get away with a lot less syntax in other languages to be productive.

I think most special forms do not complicate syntax, as they look like your standard s-expressions, they just have differing semantics from regular functions.

If you look at Common Lisp, I feel like you got a point. It is a huge and complicated language, and while it embodies many of the nice Lisp characteristics, I feel like minimalism certainly is not one of them. But there are other Lisps/Schemes that are much smaller, with a lot less special forms.

> I thought Lisp was suppose to be simple in that: it's all just lists.

"Lisp is simple" is mainly an ignorant meme that is used to belittle the interests of people who work in, or on, some kind of Lisp. There are simple aspects, but the aspects are numerous and the combination is complex.

Lisp has kept bright minds busy for sixty years and continues to do so.

Making a production Lisp from scratch is a pretty big undertaking.