l2l

Well I use a parser combinator to build the Lua parser here. https://github.com/meric/l2l/blob/master/l2l/lua.lua#L429 The parser generated is recursive descent.

I couldn't help it. Take a look at map/filter/reduce loop collapsing, and function inlining using AST analysis. It makes the code go really fast in LuaJIT. https://github.com/meric/l2l/#zero-cost That kind of abstraction can be written as an extension module and imported as easily in the language as if it were another Lua module.

You have listed the reasons why I wrote a language that's a superset of Lua and Lisp, allowing lisp style macros to manipulate lua code as data. http://github.com/meric/l2l

The syntax is very simple. I wrote a hybrid lua/lisp language with it https://github.com/meric/l2l, where Lua expressions can be quoted and quasi-quoted seamlessly. Excuse me for the plug. :)

How would I make this project more friendly to newcomers? http://github.com/meric/l2l Is it a matter of documentation?

L2L (http://github.com/meric/l2l) A new programming language that is a superset of Lua and Lisp. You can write code in Lua or Lisp syntax and quasiquote/unquote both Lua and Lisp expressions. The presentation of the project is minimal and off-putting to new contributors. It would be great to change this. A lot of work needs to be done to make it more attractive to contributors, and to make it easy for people to contribute. It requires more documentation, improved documentation, more comments in existing code. I would love some advice as to where and when that documentation and comments be most useful. Can you help?

Hey, while you are trying out parser combinators, what do you think of this one? http://github.com/meric/leftry It's very new and I would like some comments on how to make it easier to use. You can check out http://github.com/meric/l2l, which is a hybrid lisp and lua programming language that relies on the parser combinator library. (See the lua.lua in that project, where the Lua grammar is implemented using Leftry)

I'm developing a language that's a superset of Lua and Lisp. It's still in its infancy, but here's an example of a Lisp/Lua function in a module that can be imported as a (+...) macro that expands into Lua `a + b + c + ...` expression. https://github.com/meric/l2l/blob/rewrite/l2l/macro/arithmet... The idea is programmers will write in Lua whenever readability is prioritised, and when homoiconicity is required, for example in the use of domain specific languages, lisp can be switched to. The lisp part can be used to produce macros that expand into Lua. Would be great to know your thoughts!

I've implemented parsing left recursions with a memoized recursive descent parser generator. It requires hints to tell the generator it is left recursion[1] - but even with this inconvenience, I think it's more convenient than having to refactor a left-recursive grammar into a right recursive one and then flipping the precedence back. I'm still finishing building the first useful parser using it, there may still be bugs. It works by dynamically refactoring the grammar at each recursion. [2] The dynamic refactoring only happens if left recursion is hinted for that rule. [1] See the `left(..)` call in `prefixexp` that tells the parser generator about the left recursion. https://github.com/meric/l2l/blob/parser-generator/l2l/lua.l... [2] https://github.com/meric/l2l/blob/parser-generator/l2l/gramm...

There're lisp to lua solutions like l2l[1] or moonlisp[2] (Shameless plug: I also have a WIP hy[3] inspired lisp->lua compiler hua[4]) [1]: https://github.com/meric/l2l [2]: https://github.com/leafo/moonlisp [3]: http://hylang.org [4]: https://github.com/larme/hua

It's beautiful. There's a strange feeling in my heart. - Someone who built a simplistic lisp->lua compiler a couple of years ago at https://github.com/meric/l2l

Plug https://github.com/meric/l2l "A object-oriented, unicode-enabled lisp that compiles to and runs as fast as Lua. Equipped with macros and compile-time compiler manipulation. Comes with all built-in Lua functions."