ctl VS LIPS

Well, I do like mine better, which is closer to the STL, and for all containers. https://github.com/rurban/ctl/

search for htable or hashtable in thousands of open source projects. only a minority has worse hashtables than this one (clisp, perl5 e.g.).

For better ones I would point to my linked list implementation: https://github.com/rurban/ctl/blob/master/ctl/unordered_set.... (because it has various security policies, nobody else has)

C Container Template Library, Rurban Variant (CTL) - The page for unordered_map reads "Implementation in work still".

There is also the rurban variant variant of CTL which is more complete.

The prototype of CC used this mechanism to provide a generic API for types instantiated via templates (so basically like other container libraries, but with an extendible-_Generic-based API laid over the top of the generated types). This approach has some significant advantages over the approach CC now uses, but I got a bit obsessed with eliminating the need to manually instantiate templates.

But the most common that I know of is this one: https://github.com/tylov/STC. There's also this one mentioned above https://rurban.github.io/ctl/

I'm also working on a proper one, but got sidetracked. https://github.com/rurban/ctl/blob/hmap/ctl/swisstable.h

Sweet, I'll have to give that a go :)

Another option in browser land is lips[0], which exclusively targets a js backend.

[0] https://lips.js.org

For Scheme implementations there are LIPS and biwascheme. I haven't done more than play around with them, so I can't really give an informed opinion about pros and cons or favorites.

Your example revealed a bug in my Scheme interpreter. This is an example that fails to match:

In my interpreter, LIPS Scheme, vector literal syntax is created using a syntax extension, a token that is mapped to a function or a macro. So you can use things like this:

I'm not sure about other Scheme interpreters but in my interpreter LIPS Scheme, there is (env) function that returns a list of symbols. You can also access environment objects e.g. (current-environment) return object that is used internally. And you can even access the scope chain because the env object has __parent__ property that returns the parent scope.

Few of my Open Source projects: * jQuery terminal * LIPS Scheme * Gaiman * Sysend * Wayne

(define promise (--> '>(fetch "https://lips.js.org/") (then (lambda (res) (res.text))) (then (lambda (text) (. (text.match #/\s*([^>]+?)\s*<\/h1>/) 1)))))

ngl when I first saw the headline my first thought was, “Wait, bring CAR into JavaScript? Make it a Lisp? But hasn't it already been done?”

Languages like Biwa Scheme and LIPS Scheme are good for running Scheme in the browser. But I would prefer compiling Scheme code to JavaScript in the server, then serving the compiled JavaScript image to the browser.