Racketscript: Racket to JavaScript Compiler | Hacker News Reader

Racketscript: Racket to JavaScript Compiler

github.com

I see this is a WIP without support for the Scheme numerical tower, tail calls, continuations, etc. If you're looking for such features, Gambit Scheme can compile to JS with those features working and comes at ~600kb gzipped (for the _whole_ system). You can see it in action at https://try.gambitscheme.org but I don't know if it's the latest version.

> I see this is a WIP

Great, then we know at least two people know how to read :)

From the README: "RacketScript is an ___experimental____ lightweight Racket to JavaScript"

> https://try.gambitscheme.org/

For some folks who'd like me to trust their web knowledge, having an expired certificate certainly doesn't give me any more trust than I already had.

More on topic: I wonder how the REPL story is with Racketscript? Nothing seems to be mentioned in the README nor in the repository which would make this project a non-starter for the people who got used to ClojureScript and similar efforts.

That is a bummer about the expired certificate. You can access the site using http instead of https if you are comfortable doing so. I have never seen this live REPL before and have just used their Github repo to get the latest: https://github.com/gambit/gambit

I think it is great someone is trying to get Racket compiling to Javascript again. I also agree with you about the REPL; while it is interesting to compile Racket to JS, having a REPL, a live environment and all the features of something like ClojureScript has much more utility.

Sorry about the certificate... I hadn't noticed it had expired. That is fixed now and you can visit https://try.gambitscheme.org/ to try it out (don't type anything in the REPL and you will get an automatic demo).

The last part of the demo shows how to use threads in the browser and also the JavaScript FFI. The FFI based on an infix syntax is explained in greater detail in this ELS'21 paper: http://www.iro.umontreal.ca/~feeley/papers/BelangerFeeleyELS... . The paper contains several examples. Here's a simple one you can type at the REPL:

(define message "<h1 id=\"title\">hello!</h1>")

\document.body.insertAdjacentHTML("afterbegin", `message)

\document.getElementById("title").innerText=`(object->string (expt 2 100))

Basically a backslash switches to JavaScript (with infix syntax) and a backquote switches back to Scheme (with prefix syntax).

The whole Gambit system fits in a 640KB gzipped JavaScript file, so it is reasonably fast to load.

If you are interested in a really tiny Scheme implementation in JavaScript that supports tail-calls and call/cc and an incremental Scheme compiler and a REPL and most of the R4RS procedures, you might want to try out the Ribbit Scheme implementation which is just under 6 KB of (non-gzipped) JavaScript: https://udem-dlteam.github.io/ribbit/repl-max.html . That implementation is described in a paper at the VMIL'21 workshop (presentation on October 19).

Tip, you should probably setup auto-renewal with Certbot.

Implementing the numerical tower is not too difficult. There may be some problems to ensure fixnums are singletons and bignums are efficient, but it looks possible.

Tail calls and continuations are more difficult if you want them to be efficient.

I didn't know Gambit compiled to Javascript. Can you call Javascript foreign functions? Can you use "advanced" Javascript libraries like React?

Sadly "I didn't know Gambit could do X" seems to be a frequent sentiment considering the project's documentation. The configure script hints at many a feature that isn't described anywhere.

Gambit has some syntax to call functions in the host language (C/Python/Ruby/etc). That syntax is what is used to call Javascript functions that exist in the context where the compiled script is executed (window/node). As far as using stuff like ES6 style imports and the like, there is a project on Github called gambscript but it isn't complete as far as I can see. Someone out there can get closer but I know it isn't me.

Yep, basically. I looked into Racketscript a while ago, seems like it was a graduate thesis project that heavily built off of a similar python project iirc. It's based on a very old version of rkt, pre-chez, and probably would need a huge investment just to work with the newer ecosystem.

Iirc, an interesting bullet-point in their backend rework to make the move to chez meant that doing things like targeting js might be easier now than ever. I would absolutely love a js backend for rkt, it seems like it would be a huge boon to the ecosystem.

The transition to the Chez Scheme back end is almost bug compatible [1], so if it worked in the old version, it should work in the new one.

One advantage or migrating it to the Chez Scheme version is that some tricky functions (like print or display that have like a million of corner cases) are implemented in Racket or in Chez Scheme, so it's not necessary to write them again in JavaScript.

[1] For example in the old version, only the small chars were interned and in the new version all are interned, so code like (eq? #\λ (integer->char (char->integer #\λ))) may have a different result. It's true in the new version, but in the old version it may be false if the optimizer is not aggressive enough with the constant folding.

On a similar note, there is a branch in the guile git repo that aims at compiling to JS. It does a pretty nifty compilation pass that constructs a kind of minimal CPS where all calls are tail calls, giving instant support for delimited continuations and very simple (yet not fantastically fast) tail calls even in hosts that doesnt support it (using a trampoline).

Meaning, hopefully, full guile in the browser.

Is there a Scheme targeting Webassembly yet?

There is a WIP unofficial project from developers at Google called Schism [1].

[1] https://github.com/schism-lang/schism

The scheme standard mandates things that are not in the wasm spec yet (tail calls and GC being probably the most notable ones, being available only in chrome).

There are quite a few open questions regarding RnRS schemes on webassembly. Currently it seems that the ones available are either discouraged by the limitations of wasm, or are implemented to specifically test non-standard proposals of wasm.

In other words: no fun at all.

Grain is a fully functional language that exclusively targets WebAssmebly. It isn’t a Scheme though. It’s already a very mature project with some external funding.

https://grain-lang.org/

How is Grain "very mature"? Is there a package manager? A language server? A complete standard library? An ecosystem of libraries?

I've had some fun with BiwaScheme (a javascript scheme) https://www.biwascheme.org/ which is pretty painless to use for some purposes. I embedded minikanren in my blog using it for example https://www.philipzucker.com/aop-minikanren/

Biwascheme has some weird scoping bugs that makes me a litte afraid of using it for serious stuff. It seems nixe and all, but this: https://github.com/biwascheme/biwascheme/issues/125 is not very confidemce inspiring.

There is another schemey language that compiles to JS that accepts things like this:

    (when (start-are-aligned?)
       (define wtf 5))

    wtf ; may or may not be bound.

The ick-factor is high.

No continuations? Booo

Reply on news.ycombinator.com