Show HN: Superset of Lisp and Lua Programming Language, a la JSX
github.com
github.com
It just feels and reads a lot worse than doing it in say Python. So you could make a program clearer by writing the functional parts in one syntax and the imperative parts in another syntax.
Also, I'd like second the other posters suggestion that most Lisps have many ways of writing imperative code and that it really is no different than your average C-like in that respect.
Do you have any other examples of a production quality parser done with parser combinators?
The Lisp parser I was thinking about was Julia, which is bootstrapped in femtolisp. It looks like straight imperative code in Lisp to me.
I'm mainly concerned large parsers, like bash, Julia, Ruby, or C. You can write a small parser with any technology. FWIW I have a lot of posts about parsing here, towards the beginning of the blog: http://www.oilshell.org/blog/
EDIT: What's the benefit of parser combinators over recursive descent in Python or say Java? Is it just that it's point-free so you don't have to explicitly pass the input around?
I suppose if I saw the same parser written in parser combinators and recursive descent it would be easy to tell what the benefit is, if any.
https://github.com/meric/l2l/blob/master/l2l/lua.lua#L429
The parser generated is recursive descent.
This will sound like a nit-pick, but I don't intend any real criticism here: the syntax does not look good to me. I have lots of Common Lisp and Scheme experience, and also a few years of using Clojure. It is easy for me to switch between reading and writing code in those three languages, but I would need a while to get used to this language's syntax.
What are the syntax features most jarring to you? I suspect it's the ones that's been ported from Lua but I'm not sure.
It is just a cosmetic thing,but it bormthers my otherwise so paren-friendly eyes.
In my own Lisp you go like
(let a 42)
(let b (+ a 1))
(blorgle a b)They go out of scope at the end of a scope block, as usual; but conditionals introduce subscopes for the different branches. There's a (hide ...) macro I use occasionally.
To bind multiple things at once, there's the pattern matching, e.g.
(let `(,x ,y) point)
It's always bugged me in Scheme how binding forms are repeated, one type like DEFINE and another like LET, and DEFINE behaving not quite the same at top level vs. internally.
(Added: Another little nit that to me grew over the years is that Scheme is just kind of verbose. You don't want to see shorter, clearer code in Python.)
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.