There will be braces in the language, for sure, but they will be more flexible than in your usual programming language.

Python-type block syntax would also be possible. You’d just have to pull out the portion of the reader that skips whitespace and make it turn the whitespace into a symbol if it comes after a newline or something, then keep track of the current indentation.

For the actual list and dictionary literals I was planning on leaving the commas and colons out.

As for conditionals and loops, I was thinking something along the lines of how Ruby does blocks.

As for if .. else if, that’s easy. You just make if always have an else clause, and then for the else clause you just put another if. That’s actually how else if works in languages like C. Perhaps define elseif to be an alias for if so it reads nicely.

[code lang="lisp"] if something do do-some things here end elseif some other thing do do some more stuff end nil [/code]

that nil at the end there is the else condition for the second if.

I don’t see why the commas nad colons should be necessary inside {} and [] leaving it at whitespace separation seems adequate. OK allowing colons for key value pairs might imporove readability a little.

Also How would you handle conditionals and loops. I’ve had a play with it but couldn’t really come up with an intuitive way to express an if else if else structure. especially if each condition might have more then one statement inside it.

Rather than try to explain why I don’t like Rebol, just read this and assume that I pretty much agree with his arguments against even wanting to learn the whole language: http://arcanesentiment.blogspot.com/2008/08/why-i-havent-looked-at-rebol-much.html

LF allows you to generate a program using a very simple API following the factory design pattern, this program can then be translated in Python, ActionScript and JavaScript. You basically just need your parser to invoke the factory to create the program (instead of creating an AST).

My original idea was to make an esoteric language which was purely prefix notation, but in researching how to implement that, it occurred to me that something actually powerful and/or useful could be created with the simple parser and compile-time function system that I’d come up with.

The prefix notation simplifies the parser to the point where it’s really easy to extend and add new syntax, including compile-time functions which have a variable arity. The difference is that it’s up to the compile-time function to decide what arguments it takes, if any. The built-in compiler code doesn’t have to know anything about arity or pulling arguments. Each function can do that on its own as well as temporarily modify the syntax for its own purposes.

I’m already planning on list and dictionary/object literal “syntax” being a standard part of the language, or at least the standard library of the language, so it won’t be as unreadable as some may be imagining here.

1. Lispy & Smalltalkish

   • metaprogramming
   • reflection
   • “live” environment
   • everything is still an object (at least can be treated as one)

2. MLish

   • optional static typing
   • type inference
   • first class functions
   • pattern matching

Other important points: – parallelizable – good and easy to use FFI (for example C-interface) – good performance (very good at least with certain tricks)

The syntactic approach you described sounds really good..

How about implementing it in OCaml on LLVM (http://llvm.org/docs/tutorial/OCamlLangImpl1.html) I’d be very interested in contributing )