That's a weird language. At first glance it looks like a hyper-imperative lisp (except turns out it doesn't Process LISts).
It's also not dogmatic. You can use mutable and immutable versions of the same data structure.
Docs are concise: https://janet-lang.org/docs/index.html
Full API is here: https://janet-lang.org/api/index.html
[edit] I fully agree that "getting started" on Clojure is easier than used to be. Anyway I still think there is room for improvement.
- click here[0]
- click on SSO provider
More information here[1]. Of course, it'd be better to just use the Calva plugin with VSCode. That's a bit more than 2 clicks, maybe about 5.
On another hand, I don't mean to say that it's easy to start programming on Clojure, merely that it's now easy to try it out. There's a steeper learning curve than python or JavaScript, specially on the tooling side.
[0] https://gitpod.io/#https://github.com/PEZ/get-started-with-c...
However from their description and the complexity promises it looks like the immutable collections are literally just the mutable ones without mutation ability (similar to Java's immutable* wrappers) which greatly limits their effective usefulness.
> Full API is here: https://janet-lang.org/api/index.html
Sadly even worse than clojure's which is already not great.
Interesting
Why?
And what’s the alternative implementation?
I can absolutely understand not using them if the implementation is intended to be simple or the systems it's running on is resource limited, but simply removing the mutation bits of mutable collections is quite limiting as it incurs large overhead when actually working with them (you have to copy the entire thing every time you want to update anything).
Unless the collections are always kept quite small: modern architectures are very good at dense arrays, so modern immutable data structures are trees of small-ish arrays (usually a small number of dozens, IIRC Clojure uses 32-wide nodes).
I thought Clojure's immutable collections were generally considered good. What else would you consider "great"?
Edit: or was that a complaint about the quality of the documentation, not the quality of the immutable collections?
Yes, sorry if that wasn't clear.
I think, however, that scala raised the bar with RRB trees over the trie-based immutable vectors. And using java strings is pretty sad...
Working with Janet has deepened my knowledge of the Win32 APIs, for example, because it makes writing small bits of C for interacting with them about as easy as that can be.
I also like how it makes data structures and functions look the same in terms of access, and how it handles nil.