You already have the optional delimiter #;and ;) More seriously, I’m not a big fan of the commas. You could have a style guide that imposes a newline after each binding?

I think that encouraging newlines makes sense.

this flies in the face of conventional let syntax, but how about changing up the order so the punctuation acts as the delimiter? {let = a 1 = b 2 = c 3 #:in (+ a b c)}

Using the = prefix goes against my goal of having the syntax be easy for new programmers. Also, I instinctively parse that style wrong, which goes against the unofficial goal of having the syntax be easy for me :sweat_smile:

How about {let a 1 let b 2 let c 3 #:in ... } ?

Or even ... in ...

Or ... begin ... ?

But for readability maybe you prefer {let's assume that a is 1 and let's assume that b is 2 and ... then what we're gonna do is we're gonna ... }

The series of let is ok in a single-line context, but feels excessive, when split across several lines.

Regarding the keyword #:in, I chose it since it’s found in other languages. There is exactly one expression following an #:in, so using begin wouldn’t be right.

I’m sorry, I hope that I wasn’t rude in my responses.

what part of your responses could be construed as rude? :smile:

I’m not replying merely because I can’t find anything sensible or funny to say :)

I’m rather shy and have a bad habit of unnecessarily apologizing, for fear of something I may have done.

With this back-and-forth between a = 1, (a 1), = a 1, etc., it occurred to me they all are supposed to mean the same thing, but what changes is the user’s preference. What if the user could keep the meaning but toggle between a = 1, (a 1), = a 1, etc.? I know that’s kind of crazy, but it would be a way for Racket to advertise, sort of, “we have our conventions, but if you have yours, and you want to see the code the way you want to see it, so long as we understand what you meant, we can change the view to your preference, so long as you are consistent.”

How would the toggling happen?

If the user can easily change the style from one sexp to the next, that’s likely going to lead to inconsistent (read: horrible) coding style.

Not necessarily.

If you can convert between styles automatically, why would there be inconsistence?

I’m not talking about the kind of coders who fix their own conventions and stick to it, but the other kind (like me, half of the time) :wink:

or I misunderstand what you’re saying

Let me give an example. Say I write (= a 1) in a file. You then open it with NeoDrRacket, and choose “infix style”, then you would see a = 1.

You then write in the next line b = 1 and save.

When I open the file again, with the “traditional style”, I would see (= a 1) (= b 1)

Ok, so that’s the kind of global option that my assumption was ruling out in my first message. A global style would be fine. But if the style can change from one line to the next, it’s less likely to be fine.

ah, i see.

And now you make me realize I didn’t read @gknauth’s message carefully enough :)

Being able to dynamically reconfigure surface syntax like that would be very interesting, but I assume that macros would complicate it.