Create new and robust glossary #252
Open
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
|
The latest updates on your projects. Learn more about Vercel for Git ↗︎
|
briandoyle81
reviewed
Aug 5, 2025
docs/language/advanced-glossary.md
Outdated
| } | ||
| ``` | ||
|
|
||
| ### `pub` |
There was a problem hiding this comment.
@latechwriter pub and private are deprecated and are replaced with access(all), etc. Can you please update these two?
There was a problem hiding this comment.
@briandoyle81 — I think we're good to go now! I removed all mentions of pub/priv throughout the article and replaced with access(all).
briandoyle81
reviewed
Aug 8, 2025
briandoyle81
reviewed
Aug 8, 2025
docs/language/advanced-glossary.md
Outdated
|
|
||
| ### `()` (parentheses) | ||
|
|
||
| The `()` (parentheses) symbol has multiple uses in Cadence syntax. They're used to group expressions and control operator precedence in mathematical and logical expressions. Parentheses are required around function parameters and function calls, and they're used to create tuple types and values. They also serve to group conditions in control flow statements and to create type annotations for function types. Parentheses are essential for disambiguating complex expressions and ensuring proper evaluation order. |
There was a problem hiding this comment.
Suggested change
| The `()` (parentheses) symbol has multiple uses in Cadence syntax. They're used to group expressions and control operator precedence in mathematical and logical expressions. Parentheses are required around function parameters and function calls, and they're used to create tuple types and values. They also serve to group conditions in control flow statements and to create type annotations for function types. Parentheses are essential for disambiguating complex expressions and ensuring proper evaluation order. | |
| The `()` (parentheses) symbol has multiple uses in Cadence syntax. They're used to group expressions and control operator precedence in mathematical and logical expressions. Parentheses are required around function parameters in function calls, and they're used to create tuple types and values. They also serve to group conditions in control flow statements and to create type annotations for function types. Parentheses are essential for disambiguating complex expressions and ensuring proper evaluation order. |
RZhang05
reviewed
Aug 12, 2025
| let value: Int = 42 // type annotation | ||
| fun calculate(x: Int, y: Int): Int { return x + y } // parameter and return types | ||
| let result = condition ? value1 : value2 // ternary operator | ||
| access(contract) var privateData: String // access modifier |
There was a problem hiding this comment.
This example is very similar to a type annotation, maybe just remove?
Suggested change
| access(contract) var privateData: String // access modifier |
|
|
||
| ### `+`, `-`, `*`, `%` (arithmetic operators) | ||
|
|
||
| The [arithmetic operators] `+`, `-`, `*`, and `%` perform standard mathematical operations on numeric types in Cadence. The plus operator (`+`) adds two values, the minus operator (`-`) subtracts the right operand from the left, the asterisk operator (`*`) multiplies two values, and the percentage sign (`%`) returns the remainder of division. These operators work with all numeric types including `Int`, `UInt`, `Int8`, `UInt8`, and so on, and follow standard operator precedence rules. Cadence also supports compound assignment operators like `+=`, `-=`, `*=`, and `%=` for more concise code. |
There was a problem hiding this comment.
Maybe its worth mentioning the lack of support for ++ and --?
Suggested change
| The [arithmetic operators] `+`, `-`, `*`, and `%` perform standard mathematical operations on numeric types in Cadence. The plus operator (`+`) adds two values, the minus operator (`-`) subtracts the right operand from the left, the asterisk operator (`*`) multiplies two values, and the percentage sign (`%`) returns the remainder of division. These operators work with all numeric types including `Int`, `UInt`, `Int8`, `UInt8`, and so on, and follow standard operator precedence rules. Cadence also supports compound assignment operators like `+=`, `-=`, `*=`, and `%=` for more concise code. | |
| The [arithmetic operators] `+`, `-`, `*`, and `%` perform standard mathematical operations on numeric types in Cadence. The plus operator (`+`) adds two values, the minus operator (`-`) subtracts the right operand from the left, the asterisk operator (`*`) multiplies two values, and the percentage sign (`%`) returns the remainder of division. These operators work with all numeric types including `Int`, `UInt`, `Int8`, `UInt8`, and so on, and follow standard operator precedence rules. Cadence also supports compound assignment operators like `+=`, `-=`, `*=`, and `%=` for more concise code. Cadence does not support the increment/decrement operators `++`, `--`. |
| fun double(_ x: Int): Int { return x * 2 } // no argument label | ||
| let result = double(5) // no label needed | ||
| ``` | ||
|
|
There was a problem hiding this comment.
Could add a section for semicolon, maybe just port the one from the syntax page:
Suggested change
| ### `;` (semicolon) | |
| The `;` (semicolon) symbol is used as a separator between declarations and statements. A semicolon can be placed after any declaration and statement, but can be omitted between declarations if only one statement appears on the line. | |
| ```cadence | |
| let d = 1; var e = 2 // separate declarations | |
| sum += 1; diff -= 1 // separate statements | |
| ``` | |
|
|
||
| ### `()` (parentheses) | ||
|
|
||
| The `()` (parentheses) symbol has multiple uses in Cadence syntax. They're used to group expressions and control operator precedence in mathematical and logical expressions. Parentheses are required around function parameters in function calls, and they're used to create tuple types and values. They also serve to group conditions in control flow statements and to create type annotations for function types. Parentheses are essential for disambiguating complex expressions and ensuring proper evaluation order. |
There was a problem hiding this comment.
I don't believe cadence supports tuples.
Suggested change
| The `()` (parentheses) symbol has multiple uses in Cadence syntax. They're used to group expressions and control operator precedence in mathematical and logical expressions. Parentheses are required around function parameters in function calls, and they're used to create tuple types and values. They also serve to group conditions in control flow statements and to create type annotations for function types. Parentheses are essential for disambiguating complex expressions and ensuring proper evaluation order. | |
| The `()` (parentheses) symbol has multiple uses in Cadence syntax. They're used to group expressions and control operator precedence in mathematical and logical expressions. Parentheses are required around function parameters in function calls. They also serve to group conditions in control flow statements and to create type annotations for function types. Parentheses are essential for disambiguating complex expressions and ensuring proper evaluation order. |
| ```cadence | ||
| let result = (a + b) * c // expression grouping | ||
| fun calculate(x: Int, y: Int): Int { return x + y } // function parameters | ||
| let tuple = (1, "hello", true) // tuple creation |
There was a problem hiding this comment.
Suggested change
| let tuple = (1, "hello", true) // tuple creation |
| ``` | ||
|
|
||
|
|
||
| ## Keywords and access control |
There was a problem hiding this comment.
Some keywords are missing (like attachment), not sure if the intention is to cover all of them.
| case completed | ||
| case failed(reason: String) | ||
|
|
||
| access(all) fun isActive(): Bool { |
There was a problem hiding this comment.
Enums do not support functions.
| case pending | ||
| case active | ||
| case completed | ||
| case failed(reason: String) |
There was a problem hiding this comment.
This is not supported.
Suggested change
| case failed(reason: String) |
| The `enum` keyword declares enumeration types in Cadence, which define a set of named constant values. Enums can contain simple cases or cases with associated values, and they provide [type safety] by ensuring only valid enum values can be used. Enums are commonly used for representing states, types, or categories in a program, and they can include functions that operate on the enum values. The enum keyword helps create more readable and maintainable code by replacing magic numbers or strings with meaningful named constants. | ||
|
|
||
| ```cadence | ||
| access(all) enum Status { |
There was a problem hiding this comment.
Need to specify the raw type
Suggested change
| access(all) enum Status { | |
| access(all) enum Status: UInt8 { |
|
|
||
| ### `enum` | ||
|
|
||
| The `enum` keyword declares enumeration types in Cadence, which define a set of named constant values. Enums can contain simple cases or cases with associated values, and they provide [type safety] by ensuring only valid enum values can be used. Enums are commonly used for representing states, types, or categories in a program, and they can include functions that operate on the enum values. The enum keyword helps create more readable and maintainable code by replacing magic numbers or strings with meaningful named constants. |
There was a problem hiding this comment.
Remove unsupported enum features.
Suggested change
| The `enum` keyword declares enumeration types in Cadence, which define a set of named constant values. Enums can contain simple cases or cases with associated values, and they provide [type safety] by ensuring only valid enum values can be used. Enums are commonly used for representing states, types, or categories in a program, and they can include functions that operate on the enum values. The enum keyword helps create more readable and maintainable code by replacing magic numbers or strings with meaningful named constants. | |
| The `enum` keyword declares enumeration types in Cadence, which define a set of named constant values. Enums can contain simple cases, and they provide [type safety] by ensuring only valid enum values can be used. Enums are commonly used for representing states, types, or categories in a program. The enum keyword helps create more readable and maintainable code by replacing magic numbers or strings with meaningful named constants. |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
This PR creates a new and completely overhauled glossary.