==Control flow statements==

These statements control execution flow of a program.

=== If-Else ===
The If-Else statement executes a //main-expression// branch if a specified condition is true. 
If the condition is false, //alternative-expression// branch will be executed.

SYNTAX:  if (//condition//):: //type//
{
	[//declaration//. [ //declaration//.]... ]
	//main-expression//
} else {
	[//declaration//. [ //declaration//.]... ]
	//alternative-expression//
}

//condition//
Bool type expression(see [[types]]) in order to decide which branch of IF-ELSE statement should be executed.

//main expression//
Executed if condition yelds ##true##

//alternative expression//
Executed if condition yelds ##false##					

Example: 
		x = if (y<0) :: num 
		{-1} else {1}
		
===Switch===
Executes one of the given branches depending on condition.

SYNTAX: switch (//condition//) :: //type-of-switch//
[case //variant//  {
  	[declaration. [ declaration.]... ]
	//transformation-expression//
}]...

//condition//
Expression to determing which case branch should be executed

//type-of-switch//
Type of switch result

//variant//
Expression to compare against //condition//.  
If the //condition// evaluation result corresponds to the //variant// then a relevant branch is executed.
Special label **default** is allowed and designates default branch executed if no other branches  are selected.

//transformation-expression//
Determines result of a switch statement if relevant branch is selected based on //condition//. 

Example:
		x = 2:: num.
		
		y = switch (x) ::string 
			case 0 {"zero"}
			case 1 {"one"}
			case 2 {"two"}
			case default  {"unknown"}



===Map loop===
Iterates over input collection and stores result in another collection. 
Every input collection's value transformed using //transformation-expression//.  

SYNTAX: loop map ( //input-collection// -> //alias// :: //type-of-element//) :: //type-of-collection// 
{
	[declaration. [ declaration.]... ]
	//transformation-expression//
}

//input-collection//
Variable or expression to designate collection for transformation

//alias//
Variable name to designate current collection element in scope of inner code block

//type-of-element//
Type of collection's element

//type-of-collection//
Type of resulting transformed collection

//transformation-expression//
Transformation applied to an every collection element

Example:
		input = [1..10].
		twice = loop map (input -> x:: num):: [num]
		{ 2 * x }

===Fold loop===
Iterates over input collection  in order to accumulate result by applying //transformation-expression// to each element and intermediate accumulator.

SYNTAX: loop fold (//input-collection// -> //alias// :: //type-of-element//, //accumulator//->//accumulator-alias//)  :: //type-of-accumulator//
{
	[declaration. [ declaration.]... ]
	//transformation-expression//	
}

//input-collection//
Variable or expression to designate collection

//alias//
Variable name to designate current collection element in scope of inner code block

//type-of-element//
Type of collection's element

//accumulator//
Expression to evaluate initial value of accumulator

//accumulator-alias//
Variable name to designate current value of accumulator in scope of inner code block

//type-of-accumulator//
Type of folding result

//transformation-expression//
Expression applied to an every collection's element and current state of accumulator in order to
calculate accumulator value for next step of iteration.

This is an example:

		numbers = [1..10] :: [num].
		sumOfNumbers = loop fold(numbers->x; 0->result)
		{result + x}