// variable
// variable definition (full version)
variableName : Type = value;
constantName : Type : value;

// i.e.
myInt : Int = 23;
myConstInt : Int : 23;
myFloat : Float = 23.0;

// multiple variable definition (full version)
variableName0, ... : TypeForAllOfThem = value0, ...;

// i.e.
myInt, yourInt : Int = 23 , 54;

// variable definition (compiler knows types)
variableName := value;
constantName :: value;

// i.e.
myInt := 23;
myConstInt :: 23;
myFloat := 23.0;

// multiple variable definition (compiler knows types)
variableName0, ... := value0, ...;

// i.e.
myInt, yourInt := 23, 54; // all values must have the same type

// variable definition (without initialization) constants can't be defined this way 
variableName : Type;

// i.e.
myInt : Int;
myFloat : Float;

// multiple variable definition (without initialization)
variableName0, ... : TypeForAllOfThem;

// i.e.
myInt, yourInt : Int;

// pointers
// pointers will be initialized to undefined

// definition of a pointer which can't be null
pointerName : *Type = value;

// i.e.
myPointer : *Int = new Int;

// definition of a pointer which can be null
myPointer : nullable*Type = value;

// i.e.
myPointer : nullable*Int = null;

// arrays
arrayName : [size]Type = [size]Type{value,...};

// i.e.
myArray : [4]Int = [4]Int{11,2,23,4};
myArray2 := [4]Int{11,2,23,4}; // identical to the last one
myArray3 : [4]Int;

// function
// function definition
functionName :: (paramName:ParamType, ...) -> ReturnType {
  // body
}

// i.e.
foo :: () {
  // no param no returning (void)
}
bar :: (myInt: Int,myFloat:Float) -> Int {
  // 2 param Int , Float and Int return Type
}
boo :: (myInt: Int) -> Int, Int {
  // this is the way to return multiple values
  return myInt, myInt;
}

// function calling
functionName(paramters, ...);

// i.e
foo();
retValue := bar(myInt,myFloat);
retValue0,retValue2 := boo(myInt);

// lambdas
// lambdas are just functions that have been assigned to variables

// structs (classes)
// definition
StructName :: struct {
  // field
  fieldName : Type;
  
  // constant field
  constantFiledName : Type : value;

  // method (has this pointer)
  methodName :: (paramName:ParamType, ...) -> ReturnType {
    // body
  }

  #static
  staticFieldName : Type = value;

  // static method (has no this pointer)
  #static
  staticMethodName :: (paramName:ParamType, ...) -> ReturnType {
    // body
  }
}

// instancing
instanceName : StructName = StructName {
  .fieldName = value,
  ...
};

// instancing as a pointer
pointerInstance := new StructName{
  .fieldName = value,
  ...
}

// with undefined value
pointerInstance := new StructName;

// if
if (condition) {
  // body
}

// while
while (condition) {
  // body
}

// for
for ( definition ; condition ; step ) {
  // body
}

// i.e.
for (i := 0;i < 10;++i){
  // body
}

// for each
for ( variableName in iteratorName ){
  // body
}