# Compile Time Constant¶

A compile time constant (CTC) is a value that can be computed at compile time. There are four types of compile time constants.

• literals
• induction variables
• static constant properties of a contract, initialized with a literal
• static constant function parameters

There are several cases where only compile time constants are allowed.

• loop bound
• array size
• write to an array element using index operator
• function parameters that are declared as static const [1] such as size in reverseBytes(bytes b, static const int size) and repeat(T e, static const int size)
contract CTC {
static const int N = 4;
static const int LOOPCOUNT = 30;

// A is not a CTC because the right hand size is an expression, not a literal
static const int A = 2 + 1;
// B is not a CTC because it is not static
const int B;

// FC is a CTC declared in function parameters
// it can be used within this function, including parameters after it & return type
function incArr(static const int FC, int[FC] x) : int[FC] {
loop(FC): i {
x[i] += i; // induction variable CTC
}
return x;
}

public function unlock(int y) {
int[N] arr0 = [1, 2, 3, 4];
// use N to initialize CTC parameter FC of function incArr
int[N] arr1 = this.incArr(N, repeat(1, N));
loop(N) : i {
require(arr0[i] == arr1[i]);
}

int z = 0;
loop (LOOPCOUNT)
{
if (z<y) z += 4;
}
require(y == 1);
}
}

 [1] Note: the order is important: const static is not allowed when declaring a function parameter, but allowed when declaring a property.