apl

https://github.com/JohnEarnest/ok https://github.com/ngn/apl

The original has more recent commits: https://github.com/ngn/apl

But there are: k variants: kona (C, interpreter): https://github.com/kevinlawler/kona klong (C, interpreter): http://t3x.org/klong/ kuc (C++, JITted): http://althenia.net/kuc oK (JS, interpreter): https://github.com/JohnEarnest/ok (see also iKe by John Earnest) cousins: J (C, interpreter) http://jsoftware.com/ A+ (C, interpreter, unmaintained): http://www.aplusdev.org/index.html Gnu APL (C, interpreter): https://www.gnu.org/software/apl/ apl.js (JS, interpreter): https://github.com/ngn/apl There's also NARS2000 and a few other APL interpreters related: Numpy and R provide similar functionality, albeit with more verbose (and less fluent) composability. They are usually slower.

The BrainFuck interpreter doesn't seem to work properly. For example, I tried ++++++++++[->+++++++<]. Which multiplies 10x7 and should print "F" (ascii 70). Nothing appears to print. I have a K interpreter[1] that could be adapted fairly easy to a system like this. Other good candidates include JSForth[2] and NGN APL[3]. [1] https://github.com/JohnEarnest/ok [2] http://home.diphi.com/users/jeffr/forth/jsforth.html [3] https://github.com/ngn/apl

Check out J[1]. It's basically ASCII-APL though it lacks a toy modern implementation (in case you don't know, APL has one[2]). What really annoyed me about array languages is that idiomatic code is nearly impossible to follow after a month, so I ended up aliasing many of the commands to more verbose alternatives and using longer traditional constructs like IF-THEN-ELSE. That pretty much turned the language into weird-C-limited-to-binary-functions-with-an-array-stdlib, which kind of defeated the point. [1] http://www.jsoftware.com/ [2] https://github.com/ngn/apl

for anyone interested in "modern APL" check out https://github.com/ngn/apl/ runs in node/browser and has good interop functionality so you can use APL where it makes sense.

I have been contributing to the strange cousin of the macro which is the notion of inline DSL fragment. https://github.com/ngn/coffee-subscript In essence you get latex looking (\dsl) syntax to enter what ever DSL (which is just a standard node module). So this could be something as simple as an annotation style approach in which you consume the next chunk of coffee-script and simply wrap it - or something more involved like an entirely different language (this originally stemmed from the desire to have inline APL ala https://github.com/ngn/apl - which provides \apl and \apl.fn respectively). http://github.com/shaunxcode/jsedn and http://github.com/shaunxcode/swedn also work currently. Right now they are naive e.g they just emit a call to parse at runtime, when I get the time they will actually be more clever and, well, actually compile a