Someone need to make lisp without the parentheses, where scoping can also be managed by indentation like in python. Throw in some strong imperative programming so that it's a lisp masquerading as C (because purism sucks), and you'd have one very powerful language
http://www.draketo.de/english/wisp/shakespeare
OpenDylan (I have heard it referred to HN as a Lisp without parens more than once):
And Rebol, not being lispy by the standards of few/some/many, is insane with macros from what I gather. Someone posted Red, a Rebol analogue that is an open source attempt to duplicate its expressiveness out of admiration.
http://www.red-lang.org/2015/12/answers-to-community-questio...
I am confused though because this is says macros are not there. I obviously don't use it, but the last HN thread about it made it sound crazy.
https://news.ycombinator.com/item?id=11364447
Anyway, re the strong imperative thing, someone posted Bone Lisp a couple days back, but this will not please you, it is classic parens Lisp, sans GC (I read but still have no clue how that works).
Dylan was supposed to be used for Apple's Newton handheld, but was too late and basically died in the 1990s. I'm no expert, but I recall it was basically a dumbed down Lisp with OO extensions and module support that was changed to a dumbed down Algol with OO extensions and module support.
It was basically an infix lisp with focus on hygiene (because it was basically a Lisp 1), and the possibility of sealing modules (making it impossible to alter / inherit from them ).
This IIRC; it's a long time ago...
I.e. this
1 to: 5 do: [echo :x]
loop(from=1, to=5, do=lambda x: echo x)
loop(1, 5, lambda x: echo x)
Being smalltalkish, you also get extra characters when a block is used for control structures, but that saves on the need to have two different syntaxes for single and multi-line/expression lambdas or N syntaxes for blocks and control structures.
How do you see that handled in your ideal language?
array at: 1 put: 2 ==> array at:put: 1 2
Thus a keyword call is purely syntactic sugar.
A Python indented Ruby would probably able to do without [ ] but I should think about whether there are some unresolvable ambiguities with that approach. I won't recommend that personally because syntactical spaces introduce bugs. I run into one a few days ago when I moved code around a file and forgot to fix the indentation of a few lines. Luckily this one cost me only five minutes. Many people like Python though.
Overall I like the terseness of
1 to: 5 do: [echo :x]
loop(1, 5, lambda x: echo x) # Python
(1..5).each do { |x| echo x } # Ruby
(1..5).each do |x| # Ruby again
echo x
end
1 to 5 do [echo :x]
And there are so many commonly used languages that use { } to define code blocks and [ ] for arrays. I'd stick with the majority for an easier onboarding of developers.
The possibility of defining pseudo keywords thanks to the infix/suffix arguments is great. That's probably anathema in the Python world (only one way of doing things) and also in Go's. It should be acceptable in Ruby's.
I'd prefer something like this
func (n)to(m)do(blk) {
x = n
...
do blk x
...
}
Is anybody using Spry for real world programs?
func (n)to(m)do(blk) {
x = n
...
do blk x
...
}
Let's see if we can make it work.
func (n)to(m)do(blk) could be syntactic sugar for to:do: funci (n, m, blk). I saw funci in the examples, I didn't investigate if there are other type of function definitions. However, if the definition starts with (arg) it should be easy to map it into a funci. This either solves the problem of name clashes with other libraries, or the problem is unsolved right now.
The block passing is more serious. Maybe we could mark blk in such a way we know it's a block. Ruby uses & as in
func (n)to(m)do(&blk)
What Ruby also does is having a yield keyword that calls an anonymous block passed at the invocation point of the function (a method in Ruby's world). The block is not declared as argument of the function/method. Maybe:
func (n)to(m)do() { # an empty arg is a block
x = n
...
do x
...
}
1 to 5 do { echo x }
So it's a kind of quoting. I haven't pushed these things further yet, and frankly I am not that heavily into macros unless they are really needed. But obviously AST manipulation is easy in Spry.
{1 to 5 (echo x)}
(loop for x from 1 upto 5 do (echo x))
_to_do_
n to m do f =
x := n
...What you describe (interesting syntax) is a way to declare argument names and Spry doesn't declare them. That's a discussion in itself of course, but right now it doesn't.
So why is a standard trope about Lisp that with some acclimation the parentheses disappear? This is something that depends on what you're used to, and in some cases identifiable characteristics of individuals' visual processing, it's not a universal truth.
The parentheses of lisp provide a canonical serialization format. What you're actually asking for is "don't represent lists with brackets." Even Python uses brackets (and commas) for lists.
This actually describes the R programming language pretty well. A lisp with C-like syntax and vectorized primitives.
1. Multi-word lines without leading parens are grouped with later indented lines.
2. Indentation is not sensitive inside parens.
More info, unpacking the implications: https://github.com/akkartik/wart/blob/47e3572a29/004optional...
Infix works by using a disjoint set of 'operator characters' that isn't available to prefix symbols. More info: https://github.com/akkartik/wart/blob/47e3572a29/006infix
There are no statement separators (!) in Spry and the grammar is very, very minimalistic. You could argue in some ways Spry is "a Lisp without parenthesis", and although I like indentation (Nim uses it) for scoping I also find Smalltalk VERY readable.
Also, it's not yet apparent but the syntax/grammar of Spry (and homoiconicity) makes it very suitable for DSL construction, very much similar to Rebol/Red.
Funny, that's an almost exact description of Nim :-)