Glossary
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, i.e. the full syntax is auth &T,
whereas unauthorized references do not have a modifier.
_10let a: String = "hello"_10let refOfA: &String = &a as auth &String
Logical Operator
It 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 the whole type acts like a resource.
_16// Declare a resource named `SomeResource`_16pub resource SomeResource {_16 pub var value: Int_16_16 init(value: Int) {_16 self.value = value_16 }_16}_16_16// we use the '@' symbol to reference a resource type_16let a: @SomeResource <- create SomeResource(value: 0)_16_16// also in functions declarations_16pub fun use(resource: @SomeResource) {_16 destroy resource_16}
: (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) is 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 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
Inbetween 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 (e.g. storage, private, 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 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.
_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.
_10pub resource R {}_10_10var a: @R? <- nil_10a <-! 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//_10let 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:
_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 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)