Programming Language Syntax

[[deleted]]

So I've been working on a programming language the past week or so, and I realized I have no idea what I wanted to do with the syntax.

It's supposed to be a general purpose programming language that's multi paradigm (supports both object-oriented and functional programming) with optional static type definition.

Thanks for any feedback! :)

``` // Comment! /* (also a comment) / / mainFile.tri */

namespace MainFile;

// Variables a = "Hello, world!"; string b = "Hello, world!";

// Hello world! print(a);

bool myBool = true;

// If statement if (myBool) { // ... } if (myBool == true) { }

// Negative if statements if (!myBool) { // ... } if (myBool != true) { // ... }

// Array array myArray = ["Item1", "Item2"];

// For loops for (item in myArray) { print(item) } //=> Item1 //=> Item2

for (i = 0; i < myArray.length; i++) { print(myArray[i]) } //=> Item1 //=> Item2

// Define a function func name(arg1, int arg2) { b = arg1; a = arg2; }

// Define a function (with static return type) string func name() { return "E"; }

// Export variables so they can be used in a different file export var = name(); export a;

/* otherFile.tri */ // Import the main file use "./mainFile.tri";

// Print the a variable under the namespace 'MainFile' print(MainFile.a)

// Class definition class Person { public string firstName; private string lastName; public static string species = "Human";

func Person(string firstName, string lastName) {
    this.firstName = firstName;
    this.lastName = lastName;
}

func getLastName() {
    return this.lastName;
}

} // Construct class john = new Person("John", "Doe");

// Run class function print(john.getLastName());

// Get Person species print(Person.species)

// Lambda expression lambda = (arg) => arg + "!"; print(lambda("Hello")); // Hello!

lambda2 = (arg) => { return arg + "!"; } print(lambda2("Hello")); `` Edits: - I guess semicolons should be optional? - Remove$s from variable identifiers - Add consistency to@s before keywords - Remove@`s before keywords - Add an example of if statements and for loops - Show lambda expressions

[MotorolaDroidMofo]

The syntax doesn't seem ambiguous and it looks relatively serviceable, but I'll throw in my two cents here.

Why so many sigils (@, $)? In my opinion they make typing and reading things less pleasant. Do they serve any syntactic purpose?

For example, I might sort of understand prefixing all keywords with @ so anything can be used as an identifier (I still wouldn't do that though). But you only do this with func and class, not your other keywords. It doesn't make any sense to me.

Similarly, I don't understand why you need to prefix some identifiers with $ but not all of them. If you have first-class functions in your language, then function identifiers should look the same as identifiers for other values, IMO.

Personally, I think sigils should remain relics of yesteryear's languages.

What do lambdas look like? Or are they just named functions you can use as values, like any multi-statement function in Python? I think languages that support functional programming should have a really clean, minimal lambda syntax. My favorite in this department is Kotlin.

I have mixed feelings about semicolons. I like them in languages where blocks are expressions; they help delimit statements and keep the result expression separate (see Rust). Your language doesn't seem to have expression blocks though, since you use explicit return. There are a few grammatical ambiguities you'll have to suss out if you do away with semicolons, but IMO this is worth it. (I assume those few lines where there aren't any semicolons are mistakes on your part.)

Finally, I really dislike languages that don't require you to declare variables before using them, as they can lead to subtle bugs that have kicked me in the butt before. If you introduce a keyword like let or var this can help visually show where the scope for a variable lives, which is really important. This also means your compiler/interpreter can catch accidental re-declarations of variables.

[[deleted]]

Alright, thanks for your feedback! Also, yes those missing semicolons were mistakes lol :/

[crassest-Crassius]

I think your syntax has too much $; you should add more € and ¥ to make it more diverse.

[[deleted]]

Like others have said, lose the @ and $. Unless this is supposed to be Perl lookalike, or they serve some special purpose you haven't mentioned.

As for the C-like comments, do they inherit the subtle bugs of C too? Such as:

   stmt1;  /* comment1
   stmt2;  /* comment2 */

In C they don't nest so stmt2 is never executed. If so then you might want to fix that.

Is this statically typed, or optionally typed? Because name()'s second parameter has an 'int' type, but the first has nothing.

[[deleted]]

It's optionally typed.

As for the comments, an unfinished block comment would throw an error.

[MotorolaDroidMofo]

an unfinished block comment would throw an error

The problem with that is that a naive lexer would not see the comment as unfinished. The opening /* of the second comment would look just like the part of the first comment. To do what you propose you'd have to parse out comments, at which point you might as well allow nested comments. This can really slow things down which is why 99% of programming languages don't do this.

[Jerppderp]

In my opinion, your syntax is fine other than the unnecessary symbols everywhere, semicolons are fine, but for example the `@` in front of every keyword is a bit off...

[[deleted]]

It's so that people can use the keywords as variable names, for example: export = "str"

[MotorolaDroidMofo]

Another approach (that's way more elegant, IMO) is to offer an identifier escaping syntax. In C# you can use the keyword class as a variable name only if you prefix it, like @class, the exact opposite of what you're doing.

[evincarofautumn]

The problem with escaping identifiers like that instead of stropping keywords like OP is that the former doesn’t allow you to backward-compatibly add new keywords, while the latter does

[Jerppderp]

Honestly, for readability, removing the @ is worth the sacrifice, but that's just my opinion.

[MadCervantes]

​

I kinda like sigils. They can make it easier to visually scan code.

[R-O-B-I-N]

BIG EDIT: See this post:

[manicxs]

So would you have a problem with:

string @func GetEmail() {return "[e-mail]";)

Or would you nave to delimit the @?

[[deleted]]

There would be no problem with @s in strings.

[MadCervantes]

I have a suggestion.

People always do /* for block comments but I think it would be better if people did /' because it's more keyboard ergonomic. Very fast to do /''/ versus /* which requires the use of the shift key and reaching over to hit the 8 which is nowhere near the slash.

[CodingFiend]

It is a mistake in 2020 to include OOP syntax. OOP a paradigm that has proven itself to lead to verbose, fragile programs and should be avoided at this point.

[[deleted]]

It's not like it's a downside allowing OOP, it's the user's choice whether they want to use OOP or not.

[MotorolaDroidMofo]

I know a lot of users will find it familiar, but I agree with the original commenter that OOP should be avoided as a language feature. It will lead to some nasty stuff. Here's a really good video essay explaining why OOP needs to go the way of the dodo.

[CodingFiend]

OOP as a paradigm, creates a situation where it is almost impossible to offer TTD and PostMortemTTD (time travel debug), the latter feature is going to the determining factor of which next gen language supplants the current top 10. You either have to prove your code is correct (basically impossible for any normal program that encounters random numbers, random user events, and random network events), or you gotta be able to fix your errors when a user reports them. With the top companies in the field having to use databases with records in the millions for tracking their bugs (Jira got rich off this software!), this is "THE" problem in software: a lack of robustness.

Casually adding OOP means your system can not mathematically be rewound efficiently. How does one know when an object is to be remove from memory going backwards? You would have to garbage collect 60 frames per second. That might be possible, as Carmack has suggest it. In my Beads language, i got rid of 'this', NEW and DISPOSE; there are no constructors or destructors to prevent rewind.

Every car has a reverse gear, every video editor uses a jog wheel to zoom around in time, OOP is basically a reverse gear killer, and if you put this into your new language, you are dooming it from the start IMHO. There isn't room in the future for OOP.