Variables

Variables store values. Declare them with var or const, a name, an optional type and an initial value.

request Variables {
    var count: int32 = 0     // explicit type
    var name = "Christopher" // type inferred as string
    const limit = 10         // can't be reassigned
}

Both var and const require an initial value. Use null if you don’t have a value yet:

var result: string = null

var

var declares a mutable variable. Reassign it with =:

request Counter {
    var count: int32 = 0
    count = count + 1
    return count // 1
}

There’s no compound assignment (+=) and no increment operator (++). Write count = count + 1 instead.

const

const declares a variable that can’t be reassigned:

request Constant {
    const limit = 10
    limit = 20 // Error: Cannot assign to 'limit' because it is a const
}

const only prevents rebinding the name. If a const holds an object or list, you can still change its contents:

request MutableContents {
    const car = { color: "red" }
    car.color = "blue" // OK: changes a property, not the binding
    car.doors = 4      // OK: adds a new property
    return car         // { "color": "blue", "doors": 4 }
}

Contract parameters are const variables.

Type inference

When you leave out the type, it’s inferred from the initial value:

Initial value	Inferred type
Whole number that fits in 32 bits, such as `42`	`int32`
Larger whole number, such as `3000000000`	`int64`
Number with a fractional part, such as `9.99`	`decimal`
`"text"`	`string`
`true` or `false`	`boolean`
`{ ... }`	`object`
A list whose elements all have the same type, such as `[1, 2]`	A list of that type, such as `[]int32`
An empty list `[]`, or a list of mixed types such as `[1, "a"]`	A list that accepts elements of any type
`null`	Unconstrained: accepts any value

Declare the type explicitly when the inferred type is too narrow. For example, var total = 0 infers int32, so assigning 9.99 to it later is an error. Write var total: decimal = 0 instead.

Types never change

A variable’s type is fixed when it’s declared. Every reassignment is checked against that type, with numeric promotion applied:

request FixedType {
    var total: decimal = 0
    total = 5      // OK: int32 promoted to decimal
    total = "five" // Error: a string isn't a decimal
}

Assignments to object properties and list elements aren’t type-checked, because object is untyped and list contents can be changed in place:

request ElementAssignment {
    const scores: []int32 = [1, 2]
    scores[0] = 10
    return scores // [10, 2]
}

Assignment targets

You can assign to:

A var variable: name = value
An object property: obj.prop = value. If the property doesn’t exist, it’s added.
A list element: list[i] = value. The index must be an integer within the list’s bounds.

Scope

Each if, else if and else body is its own scope. Variables declared inside a body aren’t visible after it:

request Scope {
    if (true) {
        var inner = 2
    }
    return inner // Error: Unknown variable 'inner'
}

To use a value after the if, declare the variable before it and assign it inside:

request ScopeFixed {
    var label = "small"
    if (true) {
        label = "large"
    }
    return label // "large"
}

No redeclaration or shadowing

A name can only be declared once. This includes shadowing: declaring a name inside an if body that already exists in an enclosing scope is an error.

request NoShadowing {
    var x = 1
    if (true) {
        var x = 2 // Error: Variable 'x' is already declared and cannot be redeclared
    }
}

Get started

Language

Resources

Contracts

Reference

var

const

Type inference

Types never change

Assignment targets

Scope

No redeclaration or shadowing

​var

​const

​Type inference

​Types never change

​Assignment targets

​Scope

​No redeclaration or shadowing

var

const

Type inference

Types never change

Assignment targets

Scope

No redeclaration or shadowing