[WIP] Syntax proposal for CompilerV0

[tekknolagi]

It's largely based on Rust but simplified.

Variable declaration

let a : int = 1;

• [x] Done?

or for constants:

const b : string = "hello";

• [x] Done?

Reassignment

let a : int = 2;
a = "hello"; // wrong! type mismatch
a = 5; // sounds good

const b : bool = true;
b = false; // wrong! b is constant

• [x] Done?

Simple math

let a : bool = 1 + 2 == 3;

• [x] Done?

If-statements

if (condition) {
  // code...
}

• [x] Done?

or, with another branch:

if (condition) {
  // code...
} else if (another_condition) {
  // code...
} else {
  // code...
}

• [x] Done?

Switch cases

let num : int = 25;

// can also be written switch num { ...
switch (num) {
  case 25 {
    // do stuff
  }

  case 30, 40 {
    // do stuff if num is 30 or 40
  }

  case (25, 30, 35) {
    // can also use parens
  }

  default {

  }
}

• [ ] Done?

Loops

While

while (true) {
  // do a thing
}

• [x] Done?

For

for (let x : int = 0; x < 10; x += 1) {
 // do a thing
}

• [ ] Done?

Functions

func add_two_numbers (a : int, b : int) : int {
  return a + b;
}

• [x] Done?

Structs

struct Slice {
  buffer : byte*,
  size : int
};

• [ ] Done?

[akkartik]

Tell me what our default language is so that we can minimize such issues :)

[tekknolagi]

@akkartik default language? Do you mean the sort of basis parent language whose syntax we are simplifying?

[akkartik]

Yes, it shall be Rust. :)

[tekknolagi]

I've decided to revert to C-style while and for loops because we do not have iterators or anything fancy that Rust-style "requires".

[KCreate]

Still not hooked on having := as our assignment operator :/

[tekknolagi]

How do you feel about set a = 5;?

[tekknolagi]

Or we could go the route of normal a = 5.

[tekknolagi]

Thoughts on let/const vs let/let mut?

[KCreate]

if (set a = read()) { ... } ??

[tekknolagi]

@KCreate are you suggesting that it should be required in loops to use the word set?

[KCreate]

No, I think requiring set at all is a bad idea

I'd say we'll go for the normal way (a = 5).

Regarding let/const vs let/let mut, I'd prefer let/const. let mut makes mut look like some kind of attribute.

[akkartik]

Does Rust have :=?

[tekknolagi]

No; https://doc.rust-lang.org/book/variable-bindings.html

[akkartik]

Well then, let's follow Rust :)

[akkartik]

I notice your conditional and loop examples above use parens:

if (condition) {
  // code...
} else if (another_condition) {
  // code...
} else {
  // code...
}

Let's just follow Rust exactly:

if condition {
  // code...
} else if another_condition {
  // code...
} else {
  // code...
}

[KCreate]

@akkartik Charly has this too :)

[KCreate]

Just added syntax for a switch statement

[tekknolagi]

How easy do we want this first compiler to be? I don't know how we're weighing that against number of features / ease of implementing another language in this compiled one, but I think that should be discussed at some level of technical detail.

[KCreate]

I'd go for C level simplicity, maybe even less.

[KCreate]

I've added syntax highlighting using the swift tag.

Also some other points:

• Do we want typedefs or should everything be in one namespace?
• Do we want a certain level of oop? (Even if it's just syntax sugar)

[tekknolagi]

I'd say no to the second one but don't know enough / can't think enough at the moment to offer an opinion on namespacing.

[KCreate]

What should be the syntax to create pointer types?

I'd suggest type*

[tekknolagi]

Only if we make it left-associative. I have severe issues with people who write C-style pointers like that:

int* a, b; // misleading! only a is a pointer

[KCreate]

What about making it right-associative?

*int that is.

Are there languages who have a different pointer syntax?

[tekknolagi]

Then it's kind of annoying for dereferencing. I think keeping it C/Rust like in form makes sense, but changing the associativity would be a strong preference.

[KCreate]

Why would that interfere with dereferencing?

BTW, what's rust's pointer syntax?

[tekknolagi]

Since traditionally dereferencing has used that exact syntax. Rust is (very nearly) the same as C.

[KCreate]

Our syntax is context free so I don't think we'll have to worry about that.

How about switching the meaning of * and &?

let foo : *int; // pointer to int
*test; // pointer to variable test
&test; // dereference test

[tekknolagi]

Hard veto on that. Very confusing. We don't have to worry about it at a technical level, sure, but as someone who TAs students quite regularly... they already get confused with the dual meaning of * in C/C++. This would not help.

[KCreate]

I see. I however don't see a problem with using the *int syntax.

We know exactly in our syntax when the type grammar has to kick in, so it can't be confused with the dereference operator.

let a : *int = ...;
        ^
        |
        +- The parser knows it has to parse this expression as a type.

tmp = 5 *int;
        ^
        |
        +- This is "5 times int", where int would be a semantic error as it's a reserved name.

[tekknolagi]

Yeah that's fine, I think; I merged that intro master.