Hacker News Reader

Comment by TazeTSchnitzel | Hacker News Reader

Isn't Mathematica very Lispy? It looks like R-expressions.

The syntax looks a lot like M-expressions, but the evaluator is about as far from a normal Lisp as you can get.

Mathematica uses a fixed-point evaluator; that is, expressions continue evaluating until they reach some stable state. Every common Lisp I've seen will only evaluate once unless you explicitly code for it.

While this evaluation behavior is very useful for mathematics, I find that it makes Mathematica a poor general-purpose programming language. It's pretty easy to wind up with confusing evaluation behavior, and controlling evaluation in Mathematica is a very complicated topic. There are myriad language constructs used to do so: Unevaluated, Hold, HoldForm, HoldAllComplete, other Hold*; see http://stackoverflow.com/questions/1616592/mathematica-uneva... and http://library.wolfram.com/infocenter/Conferences/377/ for more information.

Well M-expressions to be more precise. Actually if you ask some they'll tell you that Mathematica is the only Lisp that implemented them.

Or M-LISP. Or Logo for that matter (loosely).

Yeah, I don't really believe the claim that it's the only one, it's probably fair to say it's the most widely used though.

And with good cause, I think. Mathematica syntax (both the verbose form and with the various syntactical sugar) is immensely more readable to the average person than Lisp. Of course, this could have been done on top of Lisp anyways (and wouldn't that be nice?)

Surprise, Macsyma, which is written in Lisp has that syntax. Macsyma is the earlier computer algebra system, which Kent Pitman mentioned in that post. He also mentions that Wolfram knew Macsyma.

Example:

    applysymmetry(exp,opdum,symtype):=block(
      [getdum:get(opdum,symtype),piece,inflag:true,partswitch:true],
      if getdum=false then return(exp),
      subst(lambda([[arglist]],
                   apply('aplsym1,append(getdum,[arglist,opdum]))),
            opdum,exp))$

If you know Lisp, you will recognize typical constructs like IF, RETURN, SUBST, LAMBDA, APPLY, APPEND, ...

And this is an entirely normal usage of lisp: define a domain specific language (DSL) on top of the lisp, to manipulate the natural objects of the domain in a natural way.

I've always thought Mathematica would have been a better system build on top of a "real" lisp, and would have got there faster. I've never heard any of Wolframs statements about the parallels that have made me question that, but I could be missing something.

This still seems more limited than the Mathematica syntax, which includes postfix operators, for example. I also appreciate that parentheses are used only for grouping, not for function calling and such. I'm not saying this couldn't have been done with Macsyma or on top of Lisp more generally (indeed, that would be nice), or that Mathematica wasn't influenced by Macsyma; I'm saying that purely for syntax, I think Mathematica ended up with a better, more extensive, and easier-to-use system than pretty much any other language.

Macsyma also has postfix operators.

> Well M-expressions to be more precise.

M-expressions is what I meant, I think I misremembered the name.

Dylan is a lisp with readable syntax.

Reply on news.ycombinator.com