This is basically Lua, excluding type annotations. Lua's form of OOP is very strange in that methods aren't bound to a parent context, but instead take the object as a value. For example, `object:method()` is the same as `object.method(object)`, and `function object:method()` is the same as `function object.method(self)` - the only difference being calling the function via `object:method()` is a bit more optimized. There is also a framework with networking, signals, and other cool features called `cqueues` which works based off of coroutines.s You might want to check that out too :)

And the size of the Lua runtime is nothing short of beautiful. I have yet to find a use for Lua though, so I'm still waiting for an opportunity to work on something with it.

I find it's used a lot in places you wouldn't expect. I found it used in a car radio, the modem used in my house, and a few other places. It's lightweight if you want to use it on embedded systems (for example, NodeMCU) if you're into that kind of thing.

Iirc its used on some digital cameras as well.

I'm using it at work to parse SIP messages (with LPeg) for one of our customers (one of the cellphone carriers). Between LPeg for parsing, and coroutines in Lua, the code is pretty easy to read and follow.

I forgot to emphasize that I'm particular about syntax. I amended my comment accordingly. I also don't like the global-by-default bit, but maybe my ideal language could be a syntax layer atop Lua?

Metatables are your friend.

    -- LuaJIT
    
    local oldG = _G
    local newG = setmetatable({}, {
        __index = oldG,
    })
    setmetatable(oldG, {
        __index = function(t, k)
            return rawget(newG, k)
        end,
        __newindex = function()
            error('attempt to assign global variable')
        end,
    })
    _G = newG

If you want to assign a global variable, `x = 5` will error but `_G.x = 5` won't.

If you ignore the class support of moonscript, you can pretty much use it to do what you want. It doesn't have the "global by default" silliness, to start with.

That actually wouldn't be hard to make; just use a custom eslint rules!

If you want implicit returns and really want to disable "fancy features", babel plugins are fairly easy to create – blacklisting certain constructs wouldn't be very difficult, and implicit returns aren't so hard (you can copy my implementation[0] from a JS superset I built called LightScript[1]).

EDIT: bonus of building on babel is that you can get static types for free à la Flow (though typechecking implicit returns may be a pain).

[0] - https://github.com/lightscript/babel-plugin-lightscript/blob...

[1] - http://lightscript.org

Very cool! I can live without implicit returns. Thanks for the info!

Clojure [1] seems to meet all of these criteria. It's a functional language where you can get away with using only a few data types, while also supporting (most of) the rest of the things you mention.

[1] https://clojure.org/

I like the idea, but I want it to be embeddable and since I'll mostly be embedding this in some syntactically C-like language, I would like the scripting syntax to not look so out of place. I updated my previous post to say as much.

Moonscript uses local by default (compiles to Lua). Here is your code in Moonscript:

    foo = {
      x: {1, 2, 3},
      y: (a, b, c) ->
        sum = a + b + c
        sum * sum
    }

Yeah, now just strip away all the other stuff and we'll be good.

Not sure why this was so controversial... I mentioned my requirements in my original post and moonscript clearly doesn't satisfy them. Sorry if that hurts feelings...