gambit

Gambit Scheme (https://github.com/gambit/gambit) is a highly performant Scheme implementation (https://ecraven.github.io/r7rs-benchmarks/). Gerbil (https://cons.io) is built on top of it. Both highly recommended.

Uh... Most Schemes don't use linked lists under the hood. That doesn't impact the syntax, just the implementation. Guile uses vectors, for example. [0] Chicken... Is Cheney, so your list disappears entirely, half the time. Gambit uses vectors. [1] [0] https://www.gnu.org/software/guile/manual/html_node/Cheaper-... [1] https://github.com/gambit/gambit/blob/master/gsc/_back.c#L11...

Not to be confused with Gambit (Scheme programming language implementation): https://github.com/gambit/gambit https://gambitscheme.org/

The Ribbit compiler was developed using Gambit but most of the code is portable. I rewrote a few parts with cond-expand to port rsc.scm to older versions of Gambit and also Guile and Chicken. If you pull the latest commit the Ribbit system should work with any of those Scheme systems. The README also contains usage instructions, here is a relevant part: The Ribbit compiler is written in Scheme and can be executed with Gambit, Guile or Chicken. It has been tested with Gambit v4.7.5 and above. For the best experience install Gambit from https://github.com/gambit/gambit . Currently Ribbit supports the target languages C, JavaScript, Python and Scheme which are selectable with the compiler's `-t` option with `c`, `js`, `py`, and `scm` respectively. The compacted RVM code can be obtained with the target `none` which is the default. The `-m

You need to install Gambit HEAD, then you can: % cd src % gsi rsc.scm -m -t py -l max repl-max.scm % python3 repl-max.scm.py > (+ 1 (* 2 3)) 7 or for the C version: % gsi rsc.scm -m -t c -l max repl-max.scm % gcc -DCPROG -o repl-max.scm.exe repl-max.scm.c % ./repl-max.scm.exe > (+ 1 (* 2 3)) 7 To install Gambit follow the instructions here: https://github.com/gambit/gambit

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.

Check out https://github.com/mietek/mit-cadr-system-software Itss a tape dump of the CADR system. Also you could check out OpenGenera, but it's not (legally) available. If you want modern examples, check out SBCL, the Common Lisp compiler https://github.com/sbcl/sbcl While a Scheme and not a Lisp, you can check out Gambit Scheme. https://github.com/gambit/gambit It's written in a functional style and compiles Scheme to C. The generated code is really fast. As an aside, there really should be no difference in performance between a loop and a tail recursive call, assuming the compiler does TCO. So if that's your definition of "functional", then it should have the same performance as any "imperative" language.

Gambit-C [0]. It's a R5RS Scheme, and is near-C level of performance. It compiles to C, so embedding it is fairly easy too. Compiles to static executables, which is easy for distribution. Chez Scheme [1]. It's a R6RS Scheme, so bigger, but Chez has much better embedding support, is backed by Cisco instead of a single dev. Chez doesn't make standalone executables though, because Chez is jitted. It may be the fastest Scheme. It also includes a compiler, a profiler, a great debugger, live memory-introspection, and an enhanced REPL [2] that can dump out it's definitions and any comments into a lovely Scheme file. [0] https://github.com/gambit/gambit [1] https://github.com/cisco/ChezScheme [2] https://cisco.github.io/ChezScheme/csug9.5/use.html#./use:h2

In case of anyone interested a reasonable engineered language that supports Closure Serialization (mentioned as "hard" in last slide), checkout: Gambit Scheme: A fast scheme implementation. http://github.com/gambit/gambit Gerbil Scheme: Provides full module and syntactic tower on top of Gambit Scheme. https://github.com/vyzo/gerbil

Gambit-C. [0] Development is slower than most, because it's mostly a one-man operation, but it's fast, can statically compile, can make tiny binaries and is mostly compliant, and the dev fixes compliance/bugs fairly quickly. Docs can be lacking at times, but the code is fairly clear. [0] https://github.com/gambit/gambit

It can be ineffecient to generate and pass environments around, but it doesn't have to be, nor does it have to be a hack. Compiling with continuations [0] gives you a very efficient output, and a lexical environment that is easily modified, and intuitive to exist. Combine that with Cheney on the MTA, and first class environments are no more costly than a lambda. It is also possible to compile the initial environment [1], which makes it simpler to JIT any functions later linked to the structure. I'm not sure why you think a compiler has to throw away the environment, its certainly not what MIT Scheme does, as environments are special forms that persist as you go down and up the stack. [2] [0] http://matt.might.net/articles/cps-conversion/ [1] https://github.com/gambit/gambit/commit/09284455ae7c7e8dff4a... [2] https://groups.csail.mit.edu/m

F-Expressions are awesome fun. Gambit internals does kind of look like black magic half the time, but the author implemented environments because I asked [0], which is very cool. The more experimental lisps, the better we can make the future. I love how the lispish community views PLT, and always tries out someone's new idea. (Bayes integration in newLISP is cool. LFE is also cool.) [0] https://github.com/gambit/gambit/issues/204

How does Chicken compare to Gambit? http://dynamo.iro.umontreal.ca/wiki/index.php/Main_Page https://github.com/gambit/gambit