“I actually have a lot of real work to do, so I had to quit my “opensource-programming” procrastination as fast as possible. That’s why I rushed the release of my Lisp to Javascript “compiler” ParenScript. Compiler is actually a very big word, as ParenScript doesn’t do much more than correctly indent a Lisp expression representing Javascript code (it does a few optimization on the way, though). I had at first written a very hackish implementation of the compiler, with an undefinite intermediary representation somehow consisting of strings and lists of strings. After I got the mess working, I decided to rewrite the compiler in a clean way. ParenScript in the version 0.1.0 actually is a lot cleaner, a few people may even understand its inner workings, but there still is a lot to do. It has been given next to none testing in a real setup. The indentation is a bit weird sometimes, and could be given a lift up. The error handling is very minimal.”

I like how you explained that. Very helpful. Thanks.

(defun all-but-last (a-list)
(if (cdr a-list)
(cons (car a-list) (all-but-last (cdr a-list)))
nil))

I don’t care for Parenthetix because it takes away the promise that ParenScript had: To make JavaScript more like Lisp.

With a few macros on the Lisp side, and a few support functions, you can eliminate many of the situations where ParenScript forces you into imperative programming. For example, the following creates a ParenScript macro that allows you to define functions that behave like Lisp functions (that is, they evaluate to a certain value, without an explicit “return” statement… the -f suffix stands for “functional”):

(defmacro+ps defun-f (name lambda-list &rest body)
`(defun ,name ,lambda-list
,@(reform-body body)))

;; The macro requires this function:

(defun reform-body (body)
(if (= (length body) 1)
`(,(append `(return ,(car body))))
(append (all-but-last body)
`(,(append ‘(return) (last body))))))

;; There’s also a lambda-f, let-f, and progn-f, but I’ll leave them out for brevity.

;; You can also have a genuine Lisp “cond” (expands into
;; a hornet’s nest of if’s, but you get the right semantics):
(defun cond-expand (conditions)
(if conditions
(if (equalp (caar conditions) t)
(cadar conditions)
`(if ,(caar conditions)
,(cadar conditions)
,(cond-expand (cdr conditions))))))

(js:defjsmacro cond (&rest conditions)
(cond-expand conditions))

;; JavaScript has a “random”, and ParenScript uses it,
;; but it has different semantics from the CL function
;; with the same name. This macro fixes that (the
;; random-state argument is ignored):
(js:defjsmacro random (num &optional random-state)
`(*math.floor (* (*math.random) ,num)))

I’ve spent some time trying to get a small CL program I wrote while learning Lisp to compile into runnable JavaScript with ParenScript. Certain CL functions can be implemented in ParenScript itself, such as car, cdr, find-if, nth, nthcdr,
and assoc.

The nth, car, and cdr functions have special semantics when it comes to NIL (namely, (= (nth n nil) nil)
evaluates to true, whereas (= (aref nil n) nil) is an error), and therefore, the AREF function is not equivalent to them.

I’ve written a half-assed version of equalp. At least I _think_ it works.

“ParenScript in the version 0.1.0 actually is a lot cleaner, a few people may even understand its inner workings, but there still is a lot to do. It has been given next to none testing in a real setup. The indentation is a bit weird sometimes, and could be given a lift up. The error handling is very minimal.”

I like how you explained that. Very helpful. Thanks.

?

I’ve put this bug report and the patch at http://www.cliki.net/parenscript