It compiles a major subset of Apple's Dylan (http://lispm.dyndns.org/documentation/prefix-dylan/book.anno...) to JavaScript, both for use on a CommonJS implementation and in the browser. A bootstrapping compiler is implemented in JS, but the same compiler is also available in Ralph itself and features define-macro (Cl-like). The whole runtime is defined in Ralph as well and provides a single-inheritance object system (including next-method): https://github.com/turbolent/ralph/blob/master/src/runtime/c...

Almost all of the features are shown in https://github.com/turbolent/ralph/blob/master/src/tests/run... and I'm using it a project now. To build HTML5 apps, there's a small toolbox: https://github.com/turbolent/toolbox

Maybe it's useful to someone else. Cheers

The current one is single-inheritance, because it uses the prototype chain. It's a compromise between speed and usefulness. I'd prefer having multimethods (and maybe also multiple inheritance), but speed is a bit more important, as JavaScript is already quite slow.

So far I'm quite pleased with the single-inheritance and single dispatch solution, which basically works like that: https://gist.github.com/866506

As I needed a name, I just chose "Ralph" as that was the original code-name of Dylan (see http://en.wikipedia.org/wiki/History_of_the_Dylan_programmin...). I'm currently implementing a web-based IDE for the OpenDylan compiler (http://www.opendylan.org/), called "Hula" (original code-name of Apple's IDE, see http://wiki.opendylan.org/wiki/view.dsp?title=AppleDylanScre...). The work-in-progress is at https://github.com/turbolent/hula.

If you're interested in a demo, let me know.

  > (+ 1 1 1 1)
  => 2

  > (* 3 4 5 6)
  => 12

https://github.com/jcoglan/fargo/blob/master/source/fargo/li...

Other than being obviously new, this is pretty cool.

Edit: Would there be a better way to fix it than to add functions like this?

  function adder() {
    var args = Array.prototype.slice.call(arguments);
    return args.reduce(function(a, b){return a + b})
  }

  function subtractor() {
    var args = Array.prototype.slice.call(arguments);
    return args.reduce(function(a, b){return a - b})
  }

  function multiplier() {
    var args = Array.prototype.slice.call(arguments);
    return args.reduce(function(a, b){return a * b})
  }

  function divider() {
    var args = Array.prototype.slice.call(arguments);
    return args.reduce(function(a, b){return a / b})
  }

Someone has actually already submitted a pull request doing just this:

https://github.com/jcoglan/fargo/pull/3

    (define (count x)
      (let loop ((x x) (sum 0))
        (if (zero ? x)
          sum
          (loop  (- x 1) (+ sum x)))))
    
    (count 100000) ; ==> 5000050000 (doesn't blow up)

http://sibilantjs.info/#welcome

(cdr ()) makes it explode. What's nil? null nil don't exist

I do really like this. I was hoping for something like this where it would allow me to write lisp instead of javascript.

  > (cdr '())
  => ()
  > (cdr (list­))
  => ()

They also require the user to explicitly start a fiber. This means when you're not in a fiber you can use a faster stackless engine because you don't need to track the state of the current continuation.

Fair point.

BTW what's interesting about yield based versus lazy evaluation (functional stream) based sequence generation? Advantages of the latter are that they can easily be understood as sequences and thus further processed by lazy versions of the known sequence processing functions (map etc.), also they can be re-read multiple times, which you just made impossible for yield by not basing it on call/cc :).

It is expected to be released very soon for Javascript (and Scheme).

[1]: http://news.ycombinator.com/item?id=1921347

[2]: https://groups.google.com/group/qilang/msg/bd474d815479b50a?...

Although, I don't know that those things make it more practical than Scheme. Just more desirable to a subset of people who like that sort of thing.

Yeah, it might be mostly the functional bias. I was just reimplemting persistent immutable hast tables when I said, well dammit, why not try Clojure. And well, despite that I don't particularly like many things like lacking TCO, no continuations, and mostly probably the Scheme macro system, there is a lot of things that they did better.

I really like the data-structure access syntax (no more list-ref), I like that I have generic operations that work on any datastructure supporting the seq abstraction, I can see the point of reducing the number of parents in forms, I truly love that partial/curry is really part of the language, not in some implementation specific extension, I just love the -> 'operator'. Clojure is for me like Python, with much the functional programming support that Python did only get recently, with a community focus on this paradigm. Oh and with a great active helpful community in #clojure unlike the divided community of #scheme.

Before someone wonders: yeah, most can be implemented on top of Scheme, the point is that Clojure did it, and they are popular. Give me a Scheme with all the great things from Clojure and I'll never look back.