> 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)

  '(a b c)

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))

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

(quote a b c) does not exist in Lisp. QUOTE takes exactly one argument, the object to quote. It's a special operator.

  '(a b c) is (quote (a b c))

DEFUN is not really a form in the standard. It's a operator. It's even not a special operator. It's a macro operator.

A form is something meant to be evaluated. One could evaluate the symbol DEFUN, but by default it has no value.

So are these "specials" being parsed by a grammar?

Would be interesting to see how the interpreter works actually...

I would guess it checks what `defun` is, which is a macro...then expands it, and the expansion should ultimately result in an s-expression, which is then parses? Is this right?

It's quite easy to see, there are interpeters for Lisp in like 20 lines or so.

Here's a good one:

https://norvig.com/lispy.html

(It has the full code in a link towards the bottom)

There's also this:

https://github.com/kanaka/mal

> I would guess it checks what `defun` is, which is a macro...then expands it, and the expansion should ultimately result in an s-expression, which is then parses? Is this right?

Yes, but macros (like special forms, but macros can be user implementable) have some "special" powers regarding controlling the evaluation of the code they produce.

Here's some more discussion with examples:

https://stackoverflow.com/questions/42470940/how-is-the-defu...