You're trying too hard to map Mathematica onto Lisp. Hold is actually the easiest kind of quote to understand: it simply persists, visibly, until some rewrite (usually performed by ReleaseHold) removes it. You don't need this persistence in Lisp, because of its "evaluate once" nature. The closest thing to Lisp ' is probably Unevaluated. Once its purpose of injecting a literal expression into a rewritten expression is accomplished, it disappears. But, of course, in Mathematica this leaves the result exposed to the evaluator, so the result is generally different from Lisp '.

Thanks for the replies.

To me it is looking like Defer[] is the Wolfram version of LISP-quote.

For anyone curious, if you removed everything from Mathematica except Evaluate[], Apply, Function[], and Defer[], you would essentially have LISP left over.

... you can use any construction that doesn't have a rule that applies as a quote.

I don't understand what you're contemplating here, but sometimes I want to quote an expression that does have applicable rules, hence my search for a LISP-quote analog. An undefined symbol as function-head does not emulate LISP-quote / Defer[]; this demonstrates their difference:

{undefinedSymbol[1 + 1], Defer[1 + 1]}

Mathematica can, with suitable rewrite rules, imitate functions and procedures. You can, however, confuse yourself if you take this imitation too seriously.

Coming to Mathematica from LISP, I have found the similarities clarifying, not confusing. I understood LISP once I understood its Apply, Eval, Lambda, and Quote forms. It is simple enough that I was able to implement a small LISP in Java quickly. Without knowing how LISP works, I would be baffled by Mathematica, even after studying the docs.

Edited to add: When I'm debugging my Mathematica code, I guess it helps me to think of Mathematica as an imperative functional programming language, so I can pin down what process is happening to what data in what order.

Thanks.

I appreciate the warnings not to infer too much about Mathematica from LISP. If you're a programmer who didn't start using Mathematica until version 11 like me, it is not easy to get off the ground to where you're writing Mathematica programs with as much ease as you write LISP programs (even after reading Wolfram's introduction-for-programmers). The choice in practice is do I (1) try to leverage off of my C++ and LISP experience to get Mathematica working for me, or do I (2) keep reading Wolfram's description of their evaluation process over and over trying to understand it, but at the end of the day I still do not understand it, and the work I've wanted to do still is not done. Or maybe other new users have done better than I, but this is my story.

(2) wasn't working for me, so now I'm doing (1), and I have results to show for it. The replies here will be very helpful as I learn more about the differences between LISP and Mathematica; thank again to all respondents.

Edited to add:

the Lisp evaluator evaluates an expression once when invoked

Lisp includes something called "special forms" that are like Lisp functions except that when they are called, the argument's aren't evaluated before being passed to the special form. The body of a special form may explicitly evaluate the input arguments, at any time and in any order. Special forms are similar to Mathematica's HoldAll functionality, though you all may school me about the differences. If you wanted to implement Mathematica in Lisp, you could make a special form that evaluates input according to the Mathematica evaluation-process.

Defer is useful but very often omitted in topics about 'holding' functions. I don't have experience with LISP either but here is what should explain it to you.

Let's take a trip from an input to the output (I will ignore not related steps):

• Input: Column[{1 + 1}]

  • What it really is, in a notebook, is a cell expression RowBox[{"Column", "[", RowBox[{"{", RowBox[{"1", "+", "1"}], "}"}], "]"}] but FrontEnd renders it for you and you see Column[{1 + 1}], when sent to the evaluation RowBox will be parsed and the Kernel will know it really is Column[{1+1}]

(* Parsing step ignored*)

• Evaluation: ends up with Column[{ 2 }]

(* Formatting step ignored *)

• Typesetting: MakeBoxes applied to out Column produces TagBox[GridBox[{{"2"}}, ...], "Column"]

• Rendering: FrontEnd renders our GridBox so that you can see a grid with number 2.

Hold for example, affects Evaluation step by preventing its contents from evaluation.

Defer too, but it is also special for typesetting, MakeBoxes[Defer[x_], _] will be reduced to MakeBoxes[x_, _].

You can use it when composing a notebook from expressions, e.g. ExpressionCell[Defer[1+1], "Input"] will be ready to evaluate it while with Hold the Hold wrapper would still be there.

Thank you. I have had little success comprehending the docs for those functions though.