language_syntax.rain

//// Language Syntax
// This is file for showcasing the syntax of my programming language aka. Rain.
// Syntax is inspired from many languages, heavily Jai, Javascript, C++, and Wren.
//
// Enjoy!

/// Main function, everything starts from here:

main :: () {
    println("Hello world!");
}

/// Comments:

// In rain we accept only line comments: `// comment`

/// Variables:

// Mutuable variable
x := 5;

// Constant
y :: 6;

// Specify variable like this:

foo: int = 65;
bar := float(3); // will be turned into 3.0

// You can initliaze more variables in same line:
x := 5, y := 5;

/// Functions:

hello :: (name) {
	println("Hello ${name}!");
}

hello("Sky"); // > "Hello Sky!"

// squared2 :: (x) {
// 	return x ** 2;
// }

// In Rain, same as in Rust, if you want to just straight up return the value (with calculations or not), just write it, and forget the return keyword:
squared :: (x) {
	x ** 2
}
// This could be useful if you want just to return a value
// and that you don't want to run anything before that return statement

println("The squared of 5 is: ${squared(5)}") // > "The squared of 5 is: 25"

// Optional arguments need a default value (like you can see on y argument), and if you want you want specify what return value will be, just add the variable type after parantheses:
squared_by :: (x, y := 2) int {
	return x ** y;
}


/// Arrays:

numbers := [0, 1, 2, 3, 4];

names : string[5] = [];

names[0] = "Evry";
names[1] = "Daniel";
names[2] = "Chandler";
// etc...

/// Objects:

z :: object {
	"foo": 1,
	"bar": x
	"baz": 2
}

/// Structs:

Vector2 :: struct
{
    x: int,
    y: int,
}

a := Vector2 { 6, 5 };

println(a.x); // > 6

println(a); // > Vector2 { x: 6, y: 5 }

// Functions for structs:

Vector2: magnitude: () {
	return int(sqrt(this.x * this.x + this.y * this.y));
}

println(a.magnitude()); // > 7.8

/// Fibers:

// Create a fiber like this:
foo :: fiber {
	return "Fiber called";
}

// And call it:
println(foo.call()); // > "Fiber called!"

// Yielding:

bar :: fiber {
	println("passed to yield: {foo.call()}");
}

foo.yield("hello, world!"); // > "passed to yield: hello, world!"


/// Operators:

// `::`:

// Initializator or `::` can be used to create a function, a struct or an constant that like a struct and function can't be modified after creation.

// You can specify the constants' variable type before the second `:`:
x: int : 5

// It's possible to initialize a function inside of a struct by giving it the function name after the first colon (`:`), and after that

StructName : FuncName : () {
	// do something...
}


// `:=`:

// The second initializator (`:=`) also known as walrus operator, creates a modifiable variable:
x := 5;

// You can specify the variable type before the `=` operator:
x: int = 5;

x: int[] = [];

/// Import and Modules

// in file.rain:

pub foo :: () {
	println("foo");
}

// in main.rain file:
#import "file.rain"

main :: () {
	foo();
}

/// Condtional statements

// If statmenet
x := 5;
y := 3;

if (x == y + 2) {
	println("This is true!");
} else {
	println("This is false");
}


// for statement

// for can be used to loop trought arrays:

number := [0, 1, 2, 3, 4, 5];

for num in numbers {
	println(num);
}

names := ["Sam", "Peter"]

for i, name in names {
	println("{i}) {name}");
	// > 0) Sam
	//   1) Peter
}

// range numbers
for i in 0 .. 5 {
	print(i);
}
// > 01234

// or condtional looping, also known as `while` loop in other languages
sum := 0
i := 0

for i <= 100 {
	sum += i;
	i++;
}
println(sum); // > 5050



/// References and heap

x := 6;