I've used moonscript a lot, and don't particularly like the \ syntax. However, you get used to it quickly, and it stops seeming like such a big deal.

It would be hard to have both be '.', because of lua semantics: '.' means "get the property from the table", while ':' in lua and '\' in moonscript mean "get the function from this table, with the first parameter for that function bound to the table itself".

Javascript/Coffeescript can get away with both being '.' because of the horrible mess that is implicit 'this'. All functions have an implicit first parameter, that non-method functions usually ignore, and '.' in javascript does the equivalent of ':' and '\' in moonscript (for functions). I find the lua approach much simpler and cleaner, and think it is actually more approachable than the javascript way, because the difference between '.' and ':' or '\' is conceptually simpler than all the rules behind 'this' in javascript.

Programming in Lua explains ':' in http://www.lua.org/pil/16.html , and probably has a better explanation that I wrote :).

Would you recommend learning Lua first before going into moonscript ?

I learned them concurrently, translating lua in Programming in Lua into the equivalent moonscript. It's a pretty strait-forward translation and is definitely doable. I already had experience with a reasonable variety of languages before learning it though, and for people still getting into programming, I think Lua is a simpler and still awesome language.

I don't think it's possible to learn moonscript without learning lua concurrently, since lua makes up so much of the underlying semantics. So I think the choice is either (a) learn lua, or (b) learn lua and moonscript for some nice syntactic sugar.

`.` and `\` in Moonscript map to `.` and `:` in Lua.

In Lua, `foo.bar` is just syntactic sugar for `foo["bar"]`, a table lookup with a string key.

In turn, `foo:bar(baz)` is syntactic sugar for `foo.bar(foo, baz)`.

It is not uncommon to mix things up, and put a dot instead of the column. IIRC, Leafo used the backslash instead because it is more distinct, visually.

    Users\create name: @params.username

is thus equivalent to

    Users.create( Users, name: @params.username )

(adding parens for maximum clarity).