12

What are lisp dialects that compile to short, readable and modifiable JS, using JS's own types?

itsbruce
  • 4,825
  • 26
  • 35
MaiaVictor
  • 51,090
  • 44
  • 144
  • 286
  • 6
    have the Bad Idea Bears come to town? Modifying the compiled output is going to cause you serious pain when you need to maintain it. I'm sure it is possible (e.g. with ClojureScript) but *don't do it if you value your sanity*. You should only modify the original source, and look at the compiled output only if needed for debugging purposes. – mikera Oct 29 '12 at 02:50
  • 1
    I never said I want to modify it, but compiling to readable JS means it has no/little overhead (ClojureScript has around 12k lines overhead) and you can hope engines are optimized for linguistic JS. – MaiaVictor Nov 16 '12 at 00:05
  • 2
    @Viclib I realise this is years late, but I wrote [eslisp](https://github.com/anko/eslisp) to address this exact problem. Having the mapping to generated JavaScript be obvious and easily editable is a major design priority. No overhead. It's just JavaScript with an S-expression syntax and a macro system. Should I add an answer? – Anko - inactive in protest Nov 25 '15 at 19:44
  • @Anko yes, go ahead. I could accept it. – MaiaVictor Nov 25 '15 at 23:56

6 Answers6

9

Here's an extensive list of compilers for programming languages that compile to JavaScript, including several Lisp/Scheme dialects. Regarding the "short, readable and modifiable" part, that's a bit subjective ... you can test a couple of the compilers listed, and decide which one works best for you.

From the "Lisp, Scheme" section of the list [with minor formatting changes to the sub-section headers]:

Lisp, Scheme

Clojure-like

  • ClojureScript Clojure to JS, the official version. Supports the majority of Clojure including persistent datastructures.
  • ClojureJS Subset of Clojure to JS.
  • Chlorinejs A fork of ClojureJS with a port of clojure.core library.
  • wisp A homoiconic JavaScript dialect with Clojure syntax, S-expressions and macros. Aims to be rich subset of Clojure(Script) that seamlessly interops with both Clojure(Script) and JavaScript. ○
  • Scriptjure Library for generating JavaScript from Clojure forms.
  • ki Clojure-like syntax, mori's immutable data structures in a few sweet.js macros. Can be intermixed with JavaScript. ○

Scheme-like

  • BiwaScheme Scheme(R6RS) in JavaScript
  • Fargo Scheme in JavaScript
  • Moby Scheme A Scheme running in JS.
  • nconc Scheme interpreter in JavaScript with stack-friendly tail calls and full call/cc
  • scheme2js Scheme to JavaScript.
  • Spock A Scheme to JavaScript compiler that uses Henry Baker's Cheney-on-the-MTA compilation strategy
  • Whalesong Racket to JS compiler

Other

  • eslisp An S-expression syntax for ECMAScript/JavaScript, with Lisp-like hygienic macros that are just JS functions. Aims to be very close to JS, and highly experimental.
  • EdgeLisp A Lisp in the tradition of Common Lisp
  • Parenscript Subset of Common Lisp to JS.
  • Ralph Lisp-1 dialect that compiles to JavaScript, inspired by Dylan
  • Oppo A JavaScripter’s lisp. Inspired by JavaScript, Clojure and CoffeeScript. Compiler built using Jison.
  • LispyScript A JavaScript with Lispy syntax and Macros. ○
  • Outlet A simple Lisp that supports CPS and in-browser stepping debugging, and other things. In development.
  • Hot Cocoa Lisp A Lisp-like language that compiles to JavaScript. ○
  • Sibilant JavaScript with a lisp. ○
  • jisp A JS-native and axiomatic Lisp that focuses on the core ideas of code-as-data, S-expressions, and macros, introducing as few new concepts as possible. ○
Community
  • 1
  • 1
Óscar López
  • 232,561
  • 37
  • 312
  • 386
5

Parenscript is pretty lightweight and readable. And you use a superior interactive environment for it with slime-proxy.

Vsevolod Dyomkin
  • 9,343
  • 2
  • 31
  • 36
4

I think one of the most advanced is ClojureScript. It a very complet implmentation of clojure that compiles to readable or minified JS.

https://github.com/clojure/clojurescript

Maybe check out this if you want to get started: http://clojurescriptone.com/

nickik
  • 5,809
  • 2
  • 29
  • 35
2

LispyScript, Sibilant do it nicely. Parenscript, as suggested by Vsevolod Dyomkin, too, but you need Common Lisp. Óscar López's answer provides a list of other possibilities.

MaiaVictor
  • 51,090
  • 44
  • 144
  • 286
1

The stated design goals of Wisp match OP's requirements exactly.

It is Clojure-like but has JS semantics and very little overhead. Great if ClojureScript's approach of preserving Clojure semantics even with the cost of 12k lines of overhead is a bad match for you.

nilern
  • 156
  • 2
0

This is a bit of an esoteric answer, but you can have a Haskell-like lisp compile to JS via a combination of Lisk and Fay.

I, for one, really like the idea of Lisk, but it's not very popular in the Haskell community, let alone maintained. Fay, on the other hand, is moving along quite nicely, and one of its main goals is to compile to readable JS. Both were authored by Chris Done.

Dan Burton
  • 53,238
  • 27
  • 117
  • 198