

TwinLisp - parenthesis
http://twinlisp.nongnu.org/

======
jrockway
I wonder what the Lisp world would be like if people wrote libraries for CL or
Scheme instead of inventing their own weird-ass "lisp" dialect.

The point of Lisp is that you don't need to invent your own language. Just
"defmacro" and get back to solving your real problem.

~~~
tokipin
CL is pretty ugly. Scheme isn't so hot either. it's the reason i stayed away
from lisp in general for a good half year until Arc came out. it's like these
languages had a chance to be pretty due to lisp's streamlined syntax... but
they ruined it by using excessively verbose names and abusing the parentheses

~~~
jrockway
For every excessively verbose identifier in CL, I can give you another that's
excessively short. I won't defend any of CL's design, it's horrible. But it's
not a major problem for actually using the language, you can rename whatever
function you want, or have your editor type it for you.

As for the parentheses, I don't see any excess.

    
    
        (let (foo bar) ...)
    

and

    
    
       (let ((foo 0)(bar 1)) ...)
    

are both useful. I would hate to have to write:

    
    
       (let (foo nil bar nil) ...)
    

just because you're afraid of a few parentheses. It is easy to type and easy
to read. (foo nil bar nil) is, IMHO, nearly unreadable.

Edited to add: Another reason I like the ((var binding)...) syntax is because
it keeps the core language as unambiguious as possible. If I want to have an
Arc-like binding operator, I can just write one and use that:

    
    
       (my-let (foo 1 bar 2 baz 3) (+ foo bar baz)) ; ==> 6

~~~
tokipin
Arc's is:

    
    
      (let foo 0 ...)
    

(and what rkts wrote, due to Arc autodestructuring things.) the multi-bind is
_with_

certainly things can be renamed, but personally i feel that if you don't go
the extra mile for your users, someone else will, and you probably don't
deserve success

------
rtfa
Excellent: a combination of C's syntax and extensibility with Common Lisp's
speed. That's what I've been waiting for!

~~~
jrockway
When I saw the operator precedence table, I stopped reading and said to
myself, "congratulations, you just missed the whole point of lisp."

And actually, SBCL is nearly as fast as C in many cases. So there's really no
reason to not use CL, unless of course you don't like CL.

~~~
rkts
You don't have to program directly in an AST to do metaprogramming. It's a
trade-off: some people feel it's important to make metaprogramming as easy as
possible, while others feel it's more important to have readable syntax.

Every Lisp dialect has some high-level syntax, e.g. quote, CL reader macros,
and Arc ssyntax. These obscure the relationship between code and the
underlying AST, but the designers felt that the gain in readability was worth
it.

How much syntax should there be? A hard question, but I think it would be good
for Lisp to move in the "more" direction. Readability is one of the big
problems I have with Lisp, and macros, while certainly useful, make up only a
small fraction of my code.

------
logjam
"TwinLisp is a language with C/Java - like syntax, but with internals and
abilities of a Common Lisp"

Um...C/Java syntax <i>and</i> the abilities of Common Lisp....and the webpage
says s-expressions aren't needed to build macros....ummm...ok, could the
author show us a few TwinLisp macros?

~~~
jsmcgd
Here's one:

mac &infinite-loop ( __body) {

`do () { $@body }}

S-expressions are permissible, so maybe it would be best to stick to those
until you wrap your head around this crazy infix notation.

~~~
logjam
I grew up on simpleminded infix notation, and am overjoyed to have moved on.

Perhaps we could see a macro example just slightly more complex.

------
lst
If you want to like to freeze you in a Lisp newbie state, please go for it!

