Skip to main content
Version: 1.0

Glossary

tip

Tip: 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.


_10
let a: String = "hello"
_10
let 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.


_10
let a: String = "hello"
_10
let refOfA: auth(X) &String = &a as auth(X) &String

Logical Operator

It can be also used as a logical operator (AND), by appearing twice in succession (i.e. &&):


_10
let a = true
_10
let b = false
_10
_10
let 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 the whole type acts like a resource.


_20
// Declare a resource named `SomeResource`
_20
access(all)
_20
resource 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
_20
let a: @SomeResource <- create SomeResource(value: 0)
_20
_20
// also in functions declarations
_20
access(all)
_20
fun 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.


_10
let a: Bool = true // declares variable `a` with type `Bool`
_10
_10
// or
_10
_10
fun addOne(x: Int): Int { // return type of Int
_10
return x + 1
_10
}

Ternary Conditional Operator

The : (colon) is also be used in ternary operations to represent the "otherwise" section, such as the following:


_10
let 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


_10
let a = 1 // declares a variable `a` with value `1`

Assignment


_10
a = 1 // assigns the value `1` to variable `a `

! (exclamation mark)

The ! (exclamation mark) symbol has a different effect whether it precedes or succeeds a variable.

When it immediately precedes a boolean-type variable, it negates it.


_10
let a: Bool = true
_10
let 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.


_10
let a: Int? = nil
_10
let b: Int? = 3
_10
_10
let c: Int = a! // panics, because = nil
_10
let d: Int = b! // initialized correctly as 3

/ (forward slash)

The / (forward slash) symbol has several uses.

Division Operator

Inbetween two expressions, the forward slash acts as the division operator.


_10
let result = 4 / 2

Path separator

In a path, the forward slash separates the domain, storage or public, and the identifier.


_10
let storagePath = /storage/path
_10
storagePath.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 assignment of resources explicit, the move operator <- must be used when:

  • The resource is the initial value of a constant or variable,
  • The resource is moved to a different variable in an assignment,
  • The resource is moved to a function as an argument
  • The resource is returned from a function.

_10
resource R {}
_10
_10
let 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.


_10
access(all)
_10
resource R {}
_10
_10
var a: @R? <- nil
_10
a <-! create R()

<-> (lower than, hyphen, greater than) (Swap operator)

The swapping operator <-> swaps two resource 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
//
_10
let a: Int? = nil

Ternary Conditional Operator

The ? (question mark) is also be used in ternary operations to represent the "then" section, such as the following:


_10
let 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
//
_15
let 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
//
_15
let 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
//
_15
let c = 1 ?? 2

_ (underscore)

The _ (underscore) symbol has several uses.

Names

The _ (underscore) can be used in names, e.g. in variables and types.


_10
let _a = true // used as a variable name
_10
let another_one = false

Number Literals

The _ (underscore) can also be used to split up numerical components.


_10
let 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 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
_10
fun double(_ x: Int): Int {
_10
return x * 2
_10
}
_10
_10
let result = double(4)