Glossary
This glossary provides clear explanations and code examples for the most important symbols and operators in Cadence. Each entry describes the symbol's purpose, usage, and common scenarios, helping both new and experienced developers quickly understand Cadence syntax.
Use this guide as a handy reference to navigate Cadence's unique features and operator behaviors.
To search for a term, press CTRL/⌘ + F and type in the symbol or operator you want to look up.
& (ampersand)
The & (ampersand) symbol has several uses.
Reference
If an expression starts with the & (ampersand) symbol, it creates a reference.
_10let a: String = "hello"_10let refOfA: &String = &a as &String
References may also be authorized if the & symbol is preceded by auth. Otherwise, the reference is unauthorized.
Authorized references have the auth modifier, along with the set of entitlements to which the reference is authorized (i.e., the full syntax is auth(E, F) &T, whereas unauthorized references do not have a modifier).
_10let a: String = "hello"_10let refOfA: auth(X) &String = &a as auth(X) &String
Logical operator
The & (ampersand) symbol can be also used as a logical operator (AND), by appearing twice in succession (i.e., &&):
_10let a = true_10let b = false_10_10let c = a && b // false
@ (at)
The @ (at) symbol before a type is used to annotate whether the type is a resource.
The @ symbol must appear at the beginning of the type, not inside. For example, an array of NFTs is @[NFT], not [@NFT]. This emphasizes that the whole type acts like a resource.
_20// Declare a resource named `SomeResource`_20access(all)_20resource SomeResource {_20 _20 access(all)_20 var value: Int_20_20 init(value: Int) {_20 self.value = value_20 }_20}_20_20// we use the '@' symbol to reference a resource type_20let a: @SomeResource <- create SomeResource(value: 0)_20_20// also in function declarations_20access(all)_20fun use(resource: @SomeResource) {_20 destroy resource_20}
: (colon)
The : (colon) symbol has several uses.
Type declaration
If a : (colon) follows a variable/constant/function declaration, it is used to declare its type.
_10let a: Bool = true // declares variable `a` with type `Bool`_10_10// or_10_10fun addOne(x: Int): Int { // return type of Int_10 return x + 1_10}
Ternary conditional operator
The : (colon) can also be used in ternary operations to represent the "otherwise" section, such as the following:
_10let a = 1 > 2 ? 3 : 4_10// should be read as:_10// "is 1 greater than 2?"_10// "if YES, then set a = 3,_10// "otherwise, set a = 4.
= (equals)
The = (equals) symbol has several uses.
Variable declaration
_10let a = 1 // declares a variable `a` with value `1`
Assignment
_10a = 1 // assigns the value `1` to variable `a `
! (exclamation mark)
The ! (exclamation mark) symbol has a different effect depending on whether it precedes or succeeds a variable.
When it immediately precedes a boolean-type variable, it negates it:
_10let a: Bool = true_10let b: Bool = !a_10_10// b is false
When it immediately succeeds an optional variable, it force unwraps it. Force unwrapping returns the value inside an optional if it contains a value, or panics and aborts the execution if the optional has no value (i.e., the optional value is nil):
_10let a: Int? = nil_10let b: Int? = 3_10_10let c: Int = a! // panics, because = nil_10let d: Int = b! // initialized correctly as 3
/ (forward slash)
The / (forward slash) symbol has several uses.
Division operator
Between two expressions, the forward slash acts as the division operator:
_10let result = 4 / 2
Path separator
In a path, the forward slash separates the domain, storage or public, and the identifier:
_10let storagePath = /storage/path_10storagePath.toString() // is "/storage/path"
<- (lower than, hyphen) (Move operator)
The move operator <- is like the assignment operator =, but must be used when the value is a resource. To make the assignment of resources explicit, the move operator <- must be used when the resource is:
- the initial value of a constant or variable,
- moved to a different variable in an assignment,
- moved to a function as an argument, or
- returned from a function.
_10resource R {}_10_10let a <- create R() // we instantiate a new resource and move it into a
<-! (lower than, hyphen, exclamation mark) (Force-assignment move operator)
The force-assignment move operator <-! moves a resource value to an optional variable. If the variable is nil, the move succeeds. If it is not nil, the program aborts.
_10access(all)_10resource R {}_10_10var a: @R? <- nil_10a <-! create R()
<-> (lower than, hyphen, greater than) (Swap operator)
The swapping operator <-> swaps two resources between the variables to the left and right of it.
+ (plus), - (minus), * (asterisk), % (percentage sign)
These are all typical arithmetic operators:
- Addition:
+ - Subtraction:
- - Multiplication:
* - Remainder:
%
? (question mark)
The ? (question mark) symbol has several uses.
Optional
If a ? (question mark) follows a variable/constant, it represents an optional. An optional can either have a value or nothing at all:
_10// Declare a constant which has an optional integer type_10//_10let a: Int? = nil
Ternary conditional operator
The ? (question mark) can also be used in ternary operations to represent the then section, such as the following:
_10let a = 1 > 2 ? 3 : 4_10// should be read as:_10// "is 1 greater than 2?"_10// "if YES, then set a = 3,_10// "otherwise, set a = 4.
Nil-coalescing operator
The ? (question mark) is also used in the nil-coalescing operator ??.
It returns the value inside the optional if the optional contains a value, or returns an alternative value if the optional has no value (i.e., the optional value is nil):
_15// Declare a constant which has an optional integer type_15//_15let a: Int? = nil_15_15// Declare a constant with a non-optional integer type,_15// which is initialized to `a` if it is non-nil, or 42 otherwise._15//_15let b: Int = a ?? 42_15// `b` is 42, as `a` is nil_15_15_15// Invalid: nil-coalescing operator is applied to a value which has a non-optional type_15// (the integer literal is of type `Int`)._15//_15let c = 1 ?? 2
_ (underscore)
The _ (underscore) symbol has several uses.
Names
The _ (underscore) can be used in names (e.g., in variables and types):
_10let _a = true // used as a variable name_10let another_one = false
Number literals
The _ (underscore) can also be used to split up numerical components:
_10let b = 100_000_000 // used to split up a number (supports all number types, e.g. 0b10_11_01)
Argument labels
The _ (underscore) can also be used to indicate that a parameter in a function has no argument label:
_10// The special argument label _ is specified for the parameter,_10// so no argument label has to be provided in a function call._10_10fun double(_ x: Int): Int {_10 return x * 2_10}_10_10let result = double(4)