PL syntax theorizing

I'd just like to theorize for a moment.

1. What is the point of having 3 or 4 different braces in your language? In my opinion, if you have to use so much different symbols, your grammar is shit and you must be ashamed. The only valid reason I see for it is to differentiate between literals of different collection types (lists, arrays, dicts, sets etc). However, there is simply no reason to differentiate between operator() for functions and operator[] for collections. Just assume that function cannot be indexed and collection cannot be called.

2. Why can't we have multiword function names? Does getElementsByClassName(x) really more readable than ``get elements by class name (x)''? Also, how come so many languages still use case-sensitive identifiers? I thought case sensitivity was an artifact of olden days where you could not spare computational resources to normalize case of your identifiers. It is an antipattern and it gives you nothing whatsoever. Why keep it, C? Python? Javascript? Haskell? OCaml? (OK Haskell differentiating on first letter is cool, but keeping track of case of the remaining letters is fucking silly)

Not a fucking lisp troll if anything

IMHO ;; is better than //, much easier to type. -- is about equal. # and % in perl and prolog are a fucking joke

As for multiline: Ocaml's (* *) is horrible, horrible horrible.. C's /* */ is the standard but kinda shitty. don't get me started on #ifdef

1. what is the point of having 3 or 4 different types of punctuation and capitalisation in your language. in my opinion. if you have to use so much different symbols. your grammar is shit and you must be ashamed. the only valid reason i see for it is to differentiate between literals of different collection types .lists. arrays. dicts. sets etc.. however. there is simply no reason to differentiate between operator.. for functions and operator.. for collections. just assume that function cannot be indexed and collection cannot be called.

2.
DO5I=1,10
DO5I=1.10

See also: http://c2.com/cgi/wiki?SyntacticallySignificantWhitespaceConsideredHarmful

And case-sensitivity is for both simplicity and readability.

>>4
Was going to rage until I realized that

And case-sensitivity is for both simplicity and readability.

IHBT

Ada is case insensitive.

>>6
Ada is an overall great language.

All arguments are named keyword arguments (like in Python and OCaml). You can use abbreviated versions, e. g. int shitfunc(int dick = 0, int shits, int pumpkins = 3) which can be called like int a = shitfunc(d=0, s=1, p=10)

>>1
1. You are right. Even in Racket, I use only the round braces. Clojure is fucking non-Lisp piece of shit, by the way, because of its ugly and unusable parenthetical zoo.
2. Already available. E.g. in Racket you can name your function |hax anus|.
You're right about case sensitivity though. It's one of the biggest things I hate about Linux. And you're right about Haskell too. I wish Racket was case-insensitive. It's probably possible to do with some renaming transformers, too.

>>9
2. But typing |some function| is fucking tedious. When I proposed true multi-word identifiers, I wanted to make typing readable identifiers with less effort (no shift pressing and no underscores).

Common Lisp
Scheme
Clojure

That is all.

>>11
Clojure has too much

>>10
Then how can you tell if (+ x y) isn't a call to the function + x or a call to the function + x y? Whitespace is too valuable to waste it in function names.

In 1976, still back in the USSR, I got a very serious case
of food poisoning from eating raw fish. While in the hospital, in the state
of delirium, I suddenly realized that the ability to add numbers in parallel
depends on the fact that addition is associative. (So, putting it simply,
STL is the result of a bacterial infection.)

>>14
Then systemd is probably the result of a Veneric disease because it spreads so fucking quickly.
Mac OS is the result of AIDS - ostensibly full of shit, but actually not very dangerous as it spreads only among gays.

I would fucking forbid octal. Leading zero octal literals are fucking nasty and treacherous shits.

>>> 08
File "<stdin>", line 1
08
^
SyntaxError: invalid token

>>16
go away pythonista

>>13
Here is an idea:
(+ x y) calls + on x and y
("+ x y") calls + x y
("+ x" y) calls + x on y

>>18
In Racket that would be

(+ x y)
(|+ x y|)
(|+ x| y)

A whole lot of fucking difference there, aye. In fact, Racket's variant is better because it doesn't make functions confusable with strings.

>>19
That wouldn't be a big problem because LISP type systems are a joke anyway.

>>18-19
Pig disgusting. Do you really like typing in those "s and |s?
Lose the sex-p notation altogether. It is trivial to convert expressions such as

suck metadick factory(config(param one), param two)

to your beloved application form like

(|suck metadick factory| (getitem 'config |param one|) |param two|)

Lisp has little to do with parsing. Lisp is an approach to evaluation. You can have decent syntax with lisp. Or a shitty language with lispy paren syntax (NewLisp).

^check _'em ^dubz

>>21
Have an idea, structures such as keyvalues and lists can be implemented as functions that yield a desired element on application to a key (or set of keys). Since in a good language structures are locally immutable, linear types or otherwise, you can avoid implementing code that modifies them in place.

>>22
While checking your dubs I realized that I want to play an artillery game which features ammunition that leaps upon hitting flat ground. Any suggestions?
Or should we write our own /prog/ one, perhaps in Symta or BBCode?

>>21

You can have decent syntax with lisp

Yep, all Lisps have decent syntax. Because s-exps rule and anyone who says otherwise just has a shitty text editor.

>>21

pig-disgusting parentheses around arguments

Even Haskell and SML don't require that shit. Go back to Algol and its clones, faggot.

>>26
While I do too consider parens around arguments in function application pig disgusting, to me having it and multiword identifiers beats not having MWI and no PD parens.
I. e. I would prefer Haskell to have parens and MWI to the current unsafeThrowOSRuntimeErrorIfNot1.

>>27
The thing is, even if you put parentheses around arguments, you still have to separate them with spaces. And if there are spaces in the function name and between the arguments, they get visually confusing. The current scheme is more function-centric: make the function tight and monolith, and the arguments shall cluster behind it loosely. See, in functional programming functions should be the elite, and all the rest should be their servants.

|this notation| came from common lisp which predates racket.

>>1
Complexity with parsing

Complexity with Parsee!

>>28
Just use PD commas then?

Damn, it is for real.

Prototype is written in C, while primary implementation will be written in ATS.

ATS, the language compared to which C is a rapid prototyping language.

https://github.com/bbarker/M-N-K-Tic-Tac-Toe

>>33
Little to no type checking? Check. REPL? Check. Opinionated? Check.

Sounds like a prototyping language to me.

I'm just making stuff up, but the first two are srs.

sounds like you want forth OP

>>34

REPL? Check.

How could that be a bad thing?

>>36
that isn't a list of "bad things"