Hi everyone,

I just posted the following on comp.lang.lisp; it's about a new feature (in development) to support mixed Lisp/Python syntax. Hope you find it interesting.

http://groups.google.nl/group/comp.lang.lisp/browse_frm/thread/1861e201b6eab... (copied below; I've shortened the irrelevant long path names in the output)

- Willem

- - - On Aug 2, 9:10 pm, Oxide Scrubber jharri...@hatlop.de wrote:

vippstar wrote:

...

With CL macros you can have any embedded language expanding to lisp code, but the embedded language can't have a language feature that CL does not, that's the only limitation.

Balderdash. Any language feature that can be implemented by a Turing machine can be included, using a suitable macro to implement it.

And don't forget reader macros: they gives you _complete_ control over syntax. Python and Ruby source code can be supported directly, with the right readtable. CLPython defines a readtable that dispatches every input character to the Python parser, and Python source files are then compiled using basically:

(let ((*readtable* *python-parsing-readtable*)) (compile-file "source.py"))

Even more interesting is a mixed-syntax Python/Lisp readtable. It's in development, here is a preview:

clpython(213): (.parser::enter-mixed-lisp-python-syntax) ; The mixed Lisp/Python syntax mode is now enabled; Lispy *readtable* is now set. clpython(214): range(100)[98:2:-2] #(98 96 94 92 90 88 86 84 82 80 ...) clpython(215): import os #<module `os' :src #P"/System/Library/Frameworks/.../python2.5/os.py" :binary #P"/Users/willem/.fasl/.../2.5/lib/python2.5/os.fasl" :src-time 3400632679 :bin-time 3457618461 @ #x121964e2> clpython(216): os.urandom(1) "M" clpython(217): (funcall ~os.urandom 1) "¹" clpython(218): (format nil "OS is a ~A, and its source file is ~A" (type-of ~os) (module-src-pathname ~os)) "OS is a module, and its source file is /System/..../python2.5/os.py"

Compiling and running a mixed-syntax file, using the normal compile- file and load functions:

- - - foo.lispy - - - (in-package :cl-user) (clpython.parser::enter-mixed-lisp-python-syntax)

def pyfact(x): if x <= 1: return 1 else: return x * lispfact(x-1)

(defun lispfact (x) (if (<= x 1) 1 (* x (clpython:py-call ~pyfact (1- x)))))

(trace lispfact) print pyfact(10) - - -

clpython(203): :cf ;;; Compiling file foo.lispy ; The mixed Lisp/Python syntax mode is now enabled; Lispy *readtable* is now set. ;;; Writing fasl file foo.fasl ;;; Fasl write complete clpython(204): :ld ; Fast loading foo.fasl 0[2]: (lispfact 9) 1[2]: (lispfact 7) 2[2]: (lispfact 5) 3[2]: (lispfact 3) 4[2]: (lispfact 1) 4[2]: returned 1 3[2]: returned 6 2[2]: returned 120 1[2]: returned 5040 0[2]: returned 362880 3628800

With the right set of macros you could probably give your embedded language first-class continuations, for instance.

Good guess... CLPython has a Python CPS convertor, to support generator expressions.

The macros will essentially compile it to CL the way GCC compiles C to assembly.

Yeah, Common Lisp makes an excellent implementation language for Python, and probably Ruby too. It's almost cheating.

- Willem