HOME_EXAM.md

Program = {FuncDef} ;

Statement =
	Keyword, Statement
	| Keyword ;

Keyword =
	"let", Assign, ";"
	| "if", IfStatement
	| "while", WhileStatement
	| AssignValue, ";"
	| Return, ";"
	| FuncCall, ";"
	| Print, ";" ;

FuncDef = "fn", Identifier, "(", FuncParams, ")", ["->", LitType], "{", Statement, "}" ;

FuncCall = Identifier, "(", FuncArgs, ")" ;

FuncArgs = VectorizeComma<Expr> ;

FuncParams = VectorizeComma<Param> ;

(* Creates vector of comma-seperated list of type T *)
VectorizeComma<T> = {T, ","}, [T] ;

Param = ["mut"], Var, ":", LitType ;

Return = "return", Expr ;

(* Used for debugging *)
Print = "print(", Expr, ")" ;

WhileStatement = "(", Expr, ")", "{", Statement, "}" ;

IfStatement =
	"(", Expr, ")", "{", Statement, "}"
	| "(", Expr, ")", "{", Statement, "} else {", Statement, "}"
	| "(", Expr, ")", "{", Statement, "} else if", IfStatement ;

(* Updating a variable *)
AssignValue = Var, "=", Expr ;

(* Declaring a new variable *)
Assign = AssignBinding, Expr ;

AssignBinding = ["mut"], Var, ":", LitType, "=" ;

Expr =
	Expr, ExprOp, Factor
	| Expr, ExprRelOp, Factor
	| Factor ;

Factor =
	Factor, FactorOp, Term
	| Factor, FactorLogOp, Term
	| UnaryOp, Term
	| Term ;

Term =
	Num
	| Var
	| Bool
	| _String
	| FuncCall
	| "(", Expr, ")" ;

ExprOp = "+" | "-" ;

ExprRelOp = "==" | "!=" | ">" | "<" | ">=" | "<=" ;

FactorLogOp = "&&" | "||" ;

FactorOp = "*" | "/" ;

UnaryOp = "-" ;

LitType = "bool" | "i32" ;

(* Used to help with printing when debugging *)
_String = """, Identifier, """ ;

Bool = "true" | "false" ;

Var = Identifier ;

Identifier: = [a-zA-Z][a-zA-Z0-9_]* ;

Num = [0-9]+ ;
fn fibonacci(n: i32) -> i32 {
	if (n == 0) {
		return 0;
	} else if (n == 1) {
		return 1;
	} else {
		return fibonacci(n - 2) + fibonacci(n - 1);
	}
	return 0;
}

fn main() {
	let fib_20: i32 = fibonacci(20);
	if (fib_20 == 6765) {
		print("fib_20_is_6765");
	}

	if (fib_20 > 7000) {
		print("fib_20_LT_7000");
	} else {
		print("fib_20_GT_7000");
	}

	let mut and_res: bool = and_op(true, true);

	while (and_res) {
		and_res = false;
	}
	print("and_res_after_while_loop");
	print(and_res);

	let unary_res: i32 = unary_op(1);
	if (unary_res == -1) {
		print("unary_ok");
	} else {
		print("unary_failed");
	}

	let prec_test: i32 = prec_test();
	if (prec_test == 27) {
		print("prec_ok");
	} else {
		print("prec_failed");
	}
}

fn and_op(a: bool, b: bool) -> bool {
	return a && b;
}

fn unary_op(x: i32) -> i32 {
	return -x;
}

fn prec_test() -> i32 {
	return 2 * 10 - 3 + 2 * 5;
}
let x: i32 = true + false;
"Left or right part of number expression not a number found: left = Value(Bool(true)) and right = Value(Bool(false))"
5 + 5	// ok
true + 5	// error
true + false	// error
true && false	// ok
true && 4	// error

true || false 	// ok
5 || false	// error

4 < 3 // ok
4 < true	// error
true < false	// error

4 > 3 	// ok
4 > true 	// error
true > false 	// error

4 <= 3 	// ok
4 <= true 	// error
true <= false 	// error

4 >= 3	// ok
4 >= true	// error
true >= false 	// error

4 == 3 // ok
false == true	// ok
5 == false 	// error

4 != 3 // ok
false != true	// ok
5 != false 	// error
x = 10 // ok
x = y // ok
x = true  // error
let x: i32 = 10; 	// ok
let x: i32 = true; 	// error
let y: bool = true; // ok
let y: bool = 5; 	// error
while(true) {	// ok
	...
}

while(5) {	// error
	...
}
if (true) {	// ok
	...
}

if (5) {	// error
	...
}

if (false) {
	...
} else if (true) {	// ok
	...
}

if (false) {
	...
} else if (123) {	// error
	...
}
fn int_func() -> i32 {	// ok
	return 4;
}

fn int_func() -> i32 {	// error
	return true;
}

fn bool_func() -> bool {	// ok
	return false;
}

fn bool_func() -> bool {	// error
	return 5;
}
fn param_func(a: i32, b: bool) {
	...
}

param_func(5, true);	// ok
param_func(true, true);	// error
param_func(5, 5);	// error
param_func(true, 4);	// error
param_func(4);	// error
let a: bool = 5 + 5;
let b: bool = a && true;
let c: i32 =  b + 1;
Error: Mismatched type for variable 'a'
    		Note: expected bool, found i32
Error: Binary operation '+' cannot be applied to type 'bool'