Move

https://move-book.com
Admin
Move is a programming language designed for writing safe smart contracts and digital assets on the...
Tokens:158,459
Snippets:1,833
Trust Score:8
Update:4 months ago
Show doc for...
Tokens:
Raw
### Method Call Examples

Source: https://move-book.com/reference/method-syntax

Demonstrates concrete examples of method calls in Move. The first example calls a function 'value' on 'coin', and the second modifies a borrowed mutable value.

```move
coin.value();
```

```move
*nums.borrow_mut(i) = 5;
```

--------------------------------

### Install Sui using suiup

Source: https://move-book.com/before-we-begin/install-sui

Use `suiup` to install the Sui binary. This is the recommended method for managing different Sui versions.

```bash
suiup install sui
```

--------------------------------

### Install and Run Speedscope

Source: https://move-book.com/testing/gas-profiling

Install Speedscope globally using npm and open the generated gas profile JSON file to visualize performance data.

```bash
npm install -g speedscope
speedscope gas_profile_<TRACE_FILE>.json
```

--------------------------------

### Example Application Module

Source: https://move-book.com/testing/extend-foreign-module

This module demonstrates a dependency on Pyth Network's PriceInfoObject for executing trades.

```move
module app::trading;

use pyth::price_info::PriceInfoObject;
use pyth::price::{Self, Price};

/// Execute a trade using the current price from Pyth oracle
public fun execute_trade(/* ... */ price_info: &PriceInfoObject, amount: u64): u64 {
    let price = get_price(price_info);
    // ... trading logic using the price
    amount * price / 1_000_000
}

fun get_price(price_info: &PriceInfoObject): u64 {
    // Extract price from the oracle object
    // ...
    0 // placeholder
}

```

--------------------------------

### Install MVR using suiup

Source: https://move-book.com/before-we-begin/install-move-registry-cli

Use this command to install the Move Registry CLI (MVR) via the suiup tool. After installation, the binary will be available as 'mvr'.

```bash
suiup install mvr
```

--------------------------------

### Install Sui using Chocolatey (Windows)

Source: https://move-book.com/before-we-begin/install-sui

Install Sui on Windows using the Chocolatey package manager.

```bash
choco install sui
```

--------------------------------

### Start Sui Local Network

Source: https://move-book.com/your-first-move/hello-sui

Run a local Sui network for development and testing. This command starts the network with a faucet and forces a genesis regeneration.

```bash
RUST_LOG="off,sui_node=info" sui start --with-faucet --force-regenesis
```

--------------------------------

### Example Function Declaration

Source: https://move-book.com/reference/functions?highlight=native

Illustrates a concrete example of a function declaration with generic type parameters and a tuple return type.

```move
fun foo<T1, T2>(x: u64, y: T1, z: T2): (T2, T1, u64) { (z, y, x) }  
```

--------------------------------

### Example Module Definition

Source: https://move-book.com/reference/modules

Illustrates a complete Move module with a constant, a struct, and a public function.

```move
module 0::test;

use std::debug;

const ONE: u64 = 1;

public struct Example has copy, drop {
    i: u64
}

public fun print(x: u64) {
    let sum = x + ONE;
    let example = Example { i: sum };
    debug::print(&sum)
}
```

--------------------------------

### Method Call Syntax Example

Source: https://move-book.com/reference/method-syntax

Illustrates the basic syntax for calling a function as a method. The expression on the left of the '.' is the first argument to the function.

```text
<expression> . <identifier> <[type_arguments],*> ( <arguments> )
```

--------------------------------

### Basic Abort Examples

Source: https://move-book.com/reference/abort-and-assert

Demonstrates the basic usage of the 'abort' expression, with and without an abort code.

```move
abort
abort 42
```

--------------------------------

### Build Sui from Source using Cargo

Source: https://move-book.com/before-we-begin/install-sui

Build and install Sui locally using Cargo. Ensure you have Rust installed and updated.

```bash
cargo install --git https://github.com/MystenLabs/sui.git sui --branch mainnet
```

```bash
rustup update stable
```

--------------------------------

### Install Sui using Homebrew (macOS)

Source: https://move-book.com/before-we-begin/install-sui

Install Sui on macOS using the Homebrew package manager.

```bash
brew install sui
```

--------------------------------

### Example Constant Declaration

Source: https://move-book.com/reference/constants

An example of declaring an address constant and using it in a function to check permissions.

```move
module a::example;

const MY_ADDRESS: address = @a;

public fun permissioned(addr: address) {
    assert!(addr == MY_ADDRESS, 0);
}
```

--------------------------------

### Create and Freeze a Config Object

Source: https://move-book.com/storage/storage-functions

Example of creating a `Config` object and then freezing it to make it immutable. This demonstrates how to manage configuration data that should not be altered after creation.

```move
/// Some `Config` object that the admin can `create_and_freeze`.
public struct Config has key {
    id: UID,
    message: String
}

/// Creates a new `Config` object and freezes it.
public fun create_and_freeze(
    _: &AdminCap,
    message: String,
    ctx: &mut TxContext
) {
    let config = Config {
        id: object::new(ctx),
        message
    };

    // Freeze the object so it becomes immutable.
    transfer::freeze_object(config);
}

/// Returns the message from the `Config` object.
/// Can access the object by immutable reference!
public fun message(c: &Config): String { c.message }
```

--------------------------------

### Move Constant Pattern Example

Source: https://move-book.com/reference/control-flow/pattern-matching

Demonstrates the use of a constant value as a pattern.

```move
MyConstant
```

--------------------------------

### Install MVR using Cargo

Source: https://move-book.com/before-we-begin/install-move-registry-cli

Install and build the MVR locally using Cargo. This requires Rust to be installed on your system. The --locked flag ensures reproducible builds.

```bash
cargo install --locked --git https://github.com/mystenlabs/mvr --branch release mvr
```

--------------------------------

### Move Variable Pattern Example

Source: https://move-book.com/reference/control-flow/pattern-matching

Demonstrates the use of a variable as a pattern, which binds to the matched value.

```move
x
```

--------------------------------

### Hello World Move Module

Source: https://move-book.com/your-first-move/hello-world

Defines a simple Move module with a function that returns the string 'Hello, World!'. This is the core logic for the example.

```move
/// The module `hello_world` under named address `hello_world`.
/// The named address is set in the `Move.toml`.
module hello_world::hello_world;

// Imports the `String` type from the Standard Library
use std::string::String;

/// Returns the "Hello World!" as a `String`.
public fun hello_world(): String {
    b"Hello, World!".to_string()
}
```

--------------------------------

### Valid Address Example

Source: https://move-book.com/concepts/address

Demonstrates the format of a valid 32-byte address, prefixed with '0x' and represented as a 64-character hexadecimal string.

```move
0xe51ff5cd221a81c3d6e22b9e670ddf99004d71de4f769b0312b68c7c4872e2f1
```

--------------------------------

### Type Constraint Enforcement Example

Source: https://move-book.com/move-basics/generics

Demonstrates the enforcement of type parameter constraints. The commented-out code shows examples that would fail compilation because `NoAbilities` does not meet the `drop` or `copy + drop` requirements.

```move
/// Type without any abilities.
public struct NoAbilities {}

#[test] 
fun test_constraints() {
    // Fails - `NoAbilities` does not have the `drop` ability
    // let droppable = Droppable<NoAbilities> { value: 10 };

    // Fails - `NoAbilities` does not have the `copy` and `drop` abilities
    // let copyable_droppable = CopyableDroppable<NoAbilities> { value: 10 };
}
```

--------------------------------

### Check Sui Client Version

Source: https://move-book.com/your-first-move/hello-world

Run this command to verify your Sui installation and check the client version.

```bash
sui client --version
```

--------------------------------

### CounterWithDisplay Struct Example

Source: https://move-book.com/programmability/display

An example of a Move struct that attempts to standardize object structure for display by including fields like 'name' and 'description'. This approach has limitations regarding data duplication and client-side complexity.

```move
/// An attempt to standardize the object structure for display.
public struct CounterWithDisplay has key {
    id: UID,
    /// If this field is present it will be displayed in the UI as `name`.
    name: String,
    /// If this field is present it will be displayed in the UI as `description`.
    description: String,
    // ...
    image: String,
    /// Actual fields of the object.
    counter: u64,
    // ...
}
```

--------------------------------

### Module Extension Syntax Example

Source: https://move-book.com/reference/extensions

Illustrates the general syntax for defining module extensions in Move, including the 'extend' keyword and mode attributes.

```move
#[mode(name1, name2, ...)]      // or #[test_only]
extend module <address>::<identifier> {
    (<use> | <type> | <function> | <constant>)*
}
```

--------------------------------

### Example Account Object Details

Source: https://move-book.com/your-first-move/hello-sui

An example of an object's details as displayed by `sui client objects`. It shows the objectId, version, digest, and objectType.

```table
╭  ...                                                                                  ╮
│ ╭────────────┬──────────────────────────────────────────────────────────────────────╮ │
│ │ objectId   │  0x20e0bede16de8a728ab25e228816b9059b45ebea49c8ad384e044580b2d3e553  │ │
│ │ version    │  22                                                                  │ │
│ │ digest     │  /DUEiCLkaNSgzpZSq2vSV0auQQEQhyH9occq9grMBZM=                        │ │
│ │ objectType │  0x468d..29fe::todo_list::TodoList                                   │ │
│ ╰────────────┴──────────────────────────────────────────────────────────────────────╯ │
|  ...                                                                                  |
```

--------------------------------

### Compute Sum with Macros

Source: https://move-book.com/reference/control-flow/loops

Achieves the same sum calculation as the 'while' loop example but uses macros for a more concise and readable approach.

```move
fun sum(n: u64): u64 {
    vector::tabulate!(n, |i| i + 1).fold!(0, |sum, num| sum + num)
}
```

--------------------------------

### Reserved Address Example (Standard Library)

Source: https://move-book.com/concepts/address

Illustrates how shorter reserved addresses, like the Standard Library's '0x1', are zero-padded to the full 32-byte length.

```move
0x1 = 0x0000000000000000000000000000000000000000000000000000000000000001
```

--------------------------------

### Basic Pattern Matching Example

Source: https://move-book.com/reference/control-flow/pattern-matching

Demonstrates a simple `match` expression that returns a value based on the input `u64`. The arms cover specific literals and a catch-all case.

```move
fun run(x: u64): u64 {
    match (x) {
        1 => 2,
        2 => 3,
        x => x,
    }
}

run(1); // returns 2
run(2); // returns 3
run(3); // returns 3
run(0); // returns 0
```

--------------------------------

### Move Literal Pattern Example

Source: https://move-book.com/reference/control-flow/pattern-matching

Demonstrates the use of a literal value as a pattern.

```move
1
```

--------------------------------

### Basic Abort Example

Source: https://move-book.com/reference/abort-and-assert

Demonstrates a simple abort statement within a Move module. The VM will report the module and the specified abort code upon execution.

```move
module 0x2::example {
    public fun aborts() {
        abort 42
    }
}

module 0x3::invoker {
    public fun always_aborts() {
        0x2::example::aborts()
    }
}
```

--------------------------------

### Example Transaction Structure

Source: https://move-book.com/concepts/what-is-a-transaction

Illustrates the basic components of a Move transaction, including sender, commands, inputs, and gas details.

```pseudocode
Inputs:
- sender = 0xa11ce

Commands:
- payment = SplitCoins(Gas, [ 1000 ])
- item = MoveCall(0xAAA::market::purchase, [ payment ])
- TransferObjects(item, sender)
```

--------------------------------

### Non-Loop Lambda Usage Examples

Source: https://move-book.com/reference/functions/macros

Demonstrates using `inspect`, `is_some_and`, and `map` macros with Option types for conditional printing, checking values, and type transformation.

```move
fun examples(opt: Option<u64>) {
    // print the value if it exists
    inspect!(&opt, |x| std::debug::print(x));

    // check if the value is 0
    let is_zero = is_some_and!(&opt, |x| *x == 0);

    // upcast the u64 to a u256
    let str_opt = map!(opt, |x| x as u256);
}
```

--------------------------------

### Lambda type syntax examples

Source: https://move-book.com/reference/functions/macros

Illustrates the syntax for defining lambda types, including those with multiple arguments and explicit return types, as well as those with implicit unit return types.

```text
|u64, u64| -> u128 // a lambda that takes two u64s and returns a u128
|&mut vector<u8>| -> &mut u8 // a lambda that takes a &mut vector<u8> and returns a &mut u8
```

```text
// the following are equivalent
|&mut vector<u8>, u64|
|&mut vector<u8>, u64| -> ()
```

--------------------------------

### Move.lock [move.package] Dependency Source Examples

Source: https://move-book.com/reference/packages

This section details the location of resolved dependencies, including Git repositories with subdirectories and revisions, or local paths.

```toml
[[move.package]]
name = "A"
source = { git = "https://github.com/b/c.git", subdir = "e/f", rev = "a1b2c3" }
```

```toml
[[move.package]]
name = "B"
source = { local = "../local-dep" }
```

--------------------------------

### Mutable Vector Iteration Examples

Source: https://move-book.com/reference/functions/macros

Demonstrates usage of the `for_mut` macro for incrementing elements, swapping elements, and setting the maximum element to zero.

```move
fun mut_examples(v: &mut vector<u64>) {
    // increment each element
    for_mut!(v, |x| *x = *x + 1);

    // set each element to the previous value, and the first to last value
    let mut prev = v[v.length() - 1];
    for_mut!(v, |x| {
        let tmp = *x;
        *x = prev;
        prev = tmp;
    });

    // set the max element to 0
    let mut max = &mut 0;
    for_mut!(v, |x| if (*x > *max) max = x);
    *max = 0;
}
```

--------------------------------

### Fresh UID Generation Example

Source: https://move-book.com/storage/uid-and-id

Demonstrates the creation and immediate deletion of a fresh UID using the object::new function and TxContext. This illustrates the lifecycle of a UID within a transaction.

```move
public fun uid(ctx: &mut TxContext) {
  let id = object::new(ctx); // Create a fresh UID from TxContext. 
  id.delete(); // Delete the UID.
}
```

--------------------------------

### Get Epoch Start Timestamp

Source: https://move-book.com/programmability/epoch-and-time

Retrieves the Unix timestamp (in milliseconds) of the current epoch's start from the transaction context.

```move
public fun current_epoch_start(ctx: &TxContext) {
    let epoch_start = ctx.epoch_timestamp_ms();
    // ...
}
```

--------------------------------

### Get Active Sui Address

Source: https://move-book.com/your-first-move/hello-sui

Verify your account setup by retrieving the active Sui address. This command outputs the public address associated with your configured keypair.

```bash
$ sui client active-address
0x....
```

--------------------------------

### Initialize Sui Client Configuration

Source: https://move-book.com/your-first-move/hello-sui

Configure the Sui CLI to connect to your local network. This involves specifying the network URL and choosing a key scheme for your account.

```bash
$ sui client
Config file ["/path/to/home/.sui/sui_config/client.yaml"] doesn't exist, do you want to connect to a Sui Full node server [y/N]?
> y
Sui Full node server URL (Defaults to Sui Testnet if not specified) :
> http://127.0.0.1:9000
Environment alias for [http://127.0.0.1:9000] :
> localnet
Select key scheme to generate keypair (0 for ed25519, 1 for secp256k1, 2: for secp256r1):
> 0
```

--------------------------------

### Valid and Invalid Variable Names

Source: https://move-book.com/reference/variables

Provides examples of valid and invalid variable names according to Move's naming conventions. Valid names include underscores, letters, and digits, starting with an underscore or lowercase letter.

```move
// all valid
let x = e;
let _x = e;
let _A = e;
let x0 = e;
let xA = e;
let foobar_123 = e;

// all invalid
// highlight-error-start
let X = e; // ERROR!
let Foo = e; // ERROR!
// highlight-error-end
```

--------------------------------

### Move.lock [move.toolchain-version] Section Example

Source: https://move-book.com/reference/packages

This section, often added by external tools like the Sui package manager, stores toolchain version information for build verification.

```toml
[move.toolchain-version]
compiler-version = <string> # The version of the Move compiler used to build the package, e.g. "1.21.0"
edition = <string> # The edition of the Move language used to build the package, e.g. "2024.alpha"
flavor = <string> # The flavor of the Move compiler used to build the package, e.g. "sui"
```

--------------------------------

### Create and Navigate to a New Move Test Package

Source: https://move-book.com/reference/unit-testing

Initialize a new Move package for testing and change the current directory into it.

```bash
$ sui move new test_example; cd test_example
```

--------------------------------

### Creating All System Objects with Test Scenario

Source: https://move-book.com/testing/using-system-objects

Initialize a test scenario and create all system objects (Clock, Random, DenyList) at once using `scenario.create_system_objects()`. This simplifies test setup by providing common shared objects.

```move
use sui::clock::Clock;
use sui::random::Random;
use sui::deny_list::DenyList;
use sui::test_scenario;

#[test]
fun test_with_all_system_objects() {
    let mut scenario = test_scenario::begin(@0xA);

    // Creates Clock, Random, and DenyList as shared objects
    scenario.create_system_objects();
    scenario.next_tx(@0xA);

    // Take objects by type
    let clock = scenario.take_shared<Clock>();
    let random = scenario.take_shared<Random>();
    let deny_list = scenario.take_shared<DenyList>();

    // ... use the objects

    // Return them when done
    test_scenario::return_shared(clock);
    test_scenario::return_shared(random);
    test_scenario::return_shared(deny_list);

    scenario.end();
}
```

--------------------------------

### Character Object Lifecycle Example

Source: https://move-book.com/storage/uid-and-id

Illustrates the lifecycle of a Character object, including its instantiation with a new UID, unpacking to access the UID, and subsequent deletion of the UID.

```move
public struct Character has key {
    id: UID
}

public fun character(ctx: &mut TxContext) {
    // Instantiate `Character` object.
    let char = Character { id: object::new(ctx) };

    // Unpack object to get its UID.
    let Character { id } = char;

    // Delete the UID.
    id.delete();
}
```

--------------------------------

### Declare and Initialize Local Variables

Source: https://move-book.com/reference/variables

Introduces local variables using the `let` keyword and assigns them initial values. Demonstrates basic arithmetic operations on these variables.

```move
let x = 1;
let y = x + x;
```

--------------------------------

### Standard Package Manifest with Dependencies and Addresses

Source: https://move-book.com/reference/packages

A comprehensive Move.toml example including package metadata, address declarations, local and Git dependencies with address substitutions, and development-specific addresses.

```toml
[package]
name = "AName"
license = "Apache 2.0"

[addresses]
address_to_be_filled_in = "_"
specified_address = "0xB0B"

[dependencies]
# Local dependency
LocalDep = { local = "projects/move-awesomeness", addr_subst = { "std" = "0x1" } }
# Git dependency
MoveStdlib = { git = "https://github.com/MystenLabs/sui.git", subdir = "crates/sui-framework/packages/move-stdlib", rev = "framework/mainnet" }

[dev-addresses] # For use when developing this module
address_to_be_filled_in = "0x101010101"
```

--------------------------------

### Creating and Using Option Values

Source: https://move-book.com/move-basics/option

Shows how to create Option values using `option::some` and `option::none`, check their state with `is_some` and `is_none`, borrow the inner value, and extract it.

```move
// `option::some` creates an `Option` value with a value.
let mut opt = option::some(b"Alice");

// `option::none` creates an `Option` without a value. We need to specify the
// type since it can't be inferred from context.
let empty : Option<u64> = option::none();

// `option.is_some()` returns true if option contains a value.
assert_eq!(opt.is_some(), true);
assert_eq!(empty.is_none(), true);

// internal value can be `borrow`ed and `borrow_mut`ed.
assert_ref_eq!(opt.borrow(), &b"Alice");

// `option.extract` takes the value out of the option, leaving the option empty.
let inner = opt.extract();

// `option.is_none()` returns true if option is None.
assert_eq!(opt.is_none(), true);
```

--------------------------------

### Instantiate and Use Generic Container

Source: https://move-book.com/move-basics/generics

Demonstrates three equivalent ways to create and use a `Container<u8>` instance. Type inference is shown, highlighting the need to specify the type for numeric literals when ambiguous.

```move
#[test]
fun test_container() {
    // these three lines are equivalent
    let container: Container<u8> = new(10); // type inference
    let container = new<u8>(10); // create a new `Container` with a `u8` value
    let container = new(10u8);

    assert_eq!(container.value, 10);

    // Value can be ignored only if it has the `drop` ability.
    let Container { value: _ } = container;
}
```

--------------------------------

### User Creation with Capability

Source: https://move-book.com/programmability/capability

This function shows how to create a new user using an `AdminCap` capability. The capability object itself grants the permission, making the function signature more descriptive.

```move
/// Grants the owner the right to create new users in the system.
public struct AdminCap {}

/// Creates a new user in the system. Requires the `AdminCap` capability to be
/// passed as the first argument.
public fun new(_: &AdminCap, ctx: &mut TxContext): User {
    User { id: object::new(ctx) }
}
```

--------------------------------

### Infinite `loop` example

Source: https://move-book.com/move-basics/control-flow

Illustrates an infinite `loop` statement, which is equivalent to a `while(true)` loop. This example will also lead to an out-of-gas error if executed without a termination condition.

```move
#[test, expected_failure(out_of_gas, location=Self)]
fun test_infinite_loop() {
    let mut x = 0;

    // This will loop forever.
    loop {
        x = x + 1;
    };

    // This line will never be executed.
    assert_eq!(x, 5);
}
```

--------------------------------

### Get Current Time from Clock

Source: https://move-book.com/programmability/epoch-and-time

Accesses the `timestamp_ms` function from the `Clock` object to get the current time in milliseconds since the Unix Epoch. The `Clock` must be passed as an immutable reference.

```move
use sui::clock::Clock;

/// Clock needs to be passed as an immutable reference.
public fun current_time(clock: &Clock) {
    let time = clock.timestamp_ms();
    // ...
}
```

--------------------------------

### Init Function Signatures

Source: https://move-book.com/programmability/module-initializer

Illustrates the valid function signatures for the `init` function, which can optionally include a One Time Witness and must include a `TxContext`.

```move
fun init(ctx: &mut TxContext) { /* ... */ }
fun init(otw: OTW, ctx: &mut TxContext) { /* ... */ }
```

```move
fun init(ctx: &TxContext) { /* ... */ }
fun init(otw: OTW, ctx: &TxContext) { /* ... */ }
```

--------------------------------

### Demonstrating Phantom Type Parameters

Source: https://move-book.com/move-basics/generics

Illustrates the use of phantom type parameters by creating `Coin` instances with different types (`USD`, `EUR`). It shows that unpacking is identical as the phantom type is not used in fields.

```move
public struct USD {}
public struct EUR {}

#[test] 
fun test_phantom_type() {
    let coin1: Coin<USD> = Coin { value: 10 };
    let coin2: Coin<EUR> = Coin { value: 20 };

    // Unpacking is identical because the phantom type parameter is not used.
    let Coin { value: _ } = coin1;
    let Coin { value: _ } = coin2;
}
```

--------------------------------

### Valid Recursive Generic Function Calls

Source: https://move-book.com/reference/generics

These examples show valid recursive calls within generic functions. The key is that the recursion must result in a finite number of types. The first example shows direct recursion, and the second shows recursion with a specific type argument.

```move
module a::m;

public struct A<T> {}

// Finitely many types -- allowed.
// foo<T> -> foo<T> -> foo<T> -> ... is valid
fun foo<T>() {
    foo<T>();
}

// Finitely many types -- allowed.
// foo<T> -> foo<A<u64>> -> foo<A<u64>> -> ... is valid
fun foo<T>() {
    foo<A<u64>>();
}
```

--------------------------------

### Create and Initialize Artist Struct

Source: https://move-book.com/move-basics/struct

Initializes an instance of the 'Artist' struct with a given name. This demonstrates the basic syntax for struct instantiation.

```move
let mut artist = Artist {
    name: b"The Beatles".to_string()
};
```

--------------------------------

### Initialize Admin Capability on Package Publish

Source: https://move-book.com/programmability/capability

Defines the `AdminCap` struct and an `init` function that creates and transfers the `AdminCap` to the package owner upon publish.

```move
module book::admin_cap;

/// The capability granting the admin privileges in the system.
/// Created only once in the `init` function.
public struct AdminCap has key { id: UID }

/// Create the AdminCap object on package publish and transfer it to the
/// package owner.
fun init(ctx: &mut TxContext) {
    transfer::transfer(
        AdminCap { id: object::new(ctx) },
        ctx.sender()
    )
}

```

--------------------------------

### Infinite Loop

Source: https://move-book.com/reference/control-flow/loops

An example of an infinite 'loop' that continues forever because there is no 'break' condition.

```move
fun foo() {
    let mut i = 0;
    loop { i = i + 1 }
}
```

--------------------------------

### Move At-Pattern Example

Source: https://move-book.com/reference/control-flow/pattern-matching

Binds the entire matched value to a variable using the '@' symbol.

```move
x @ MyEnum::Variant(..)
```

--------------------------------

### Unused Local Variable Warning

Source: https://move-book.com/reference/variables

This example shows a compiler warning for an unused local variable `y`.

```move
let (x1, y, z1) = three(); // WARNING!
//       ^ unused local 'y'
```

--------------------------------

### Test with Clock System Object

Source: https://move-book.com/testing/test-scenario

Demonstrates how to create system objects like Clock and access them within a test scenario. The Clock's initial timestamp is verified.

```move
use sui::clock::Clock;

#[test] 
fun test_with_clock() {
    use std::unit_test::assert_eq;
    use sui::test_scenario;

    let alice = @0xA;
    let mut scenario = test_scenario::begin(alice);

    // Create system objects (Clock, Random, DenyList)
    scenario.create_system_objects();

    scenario.next_tx(alice);
    {
        // Now Clock is available as a shared object
        let clock = scenario.take_shared<Clock>();
        assert_eq!(clock.timestamp_ms(), 0);
        test_scenario::return_shared(clock);
    };

    scenario.end();
}
```

--------------------------------

### Move Wildcard Pattern Example

Source: https://move-book.com/reference/control-flow/pattern-matching

Demonstrates the use of the wildcard pattern '_' to ignore a matched value.

```move

```

--------------------------------

### Basic `use fun` Alias Syntax

Source: https://move-book.com/reference/method-syntax

Illustrates the fundamental syntax for creating a `use fun` alias, associating a function with a type and an alias name.

```move
use fun <function> as <type>.<method alias>;
```

--------------------------------

### Build for Publication

Source: https://move-book.com/move-advanced/modes

This command shows how to perform a clean build for publishing, ensuring no special modes or test-only code are included.

```bash
sui move build   # no --mode, no --test
```

--------------------------------

### Valid enum and variant naming

Source: https://move-book.com/reference/enums

Provides examples of valid enum and variant names adhering to the naming conventions.

```move
public enum Foo {
    Variant
}
public enum BAR {
    Variant
}
public enum B_a_z_4_2 {
    V_a_riant_0
}
```

--------------------------------

### Type Compatibility in if Branches

Source: https://move-book.com/reference/control-flow/conditionals

Ensures that both branches of an `if` expression have compatible types. The commented-out examples show type errors.

```move
// x and y must be u64 integers
let maximum: u64 = if (x > y) x else y;

// highlight-error-start
// ERROR! branches different types
let z = if (maximum < 10) 10u8 else 100u64;

// ERROR! branches different types, as default false-branch is () not u64
let y = if (maximum >= 10) maximum;
// highlight-error-end
```

--------------------------------

### Immutable Index Syntax Method

Source: https://move-book.com/reference/index-syntax

Example of an immutable index syntax method definition. This serves as the reference for compatibility checks.

```move
#[syntax(index)]
public fun borrow<T>(s: &Matrix<T>, i: u64, j: u64): &T {
    vector::borrow(vector::borrow(&s.v, i), j)
}
```

--------------------------------

### Index Syntax Translation Examples

Source: https://move-book.com/reference/index-syntax

The compiler translates index syntax into appropriate function calls based on mutability and usage.

```move
let mat = matrix::make_matrix(...);
let m_0_0 = mat[0, 0];
```

```move
let mut mat = matrix::make_matrix(...);

let m_0_0 = mat[0, 0];
// translates to `copy matrix::borrow(&mat, 0, 0)`
```

```move
let m_0_0 = &mat[0, 0];
// translates to `matrix::borrow(&mat, 0, 0)`
```

```move
let m_0_0 = &mut mat[0, 0];
// translates to `matrix::borrow_mut(&mut mat, 0, 0)`
```

--------------------------------

### Valid Constant Naming Examples

Source: https://move-book.com/reference/constants

Illustrates valid naming conventions for constants, including boolean, error codes, and addresses.

```move
const FLAG: bool = false;
const EMyErrorCode: u64 = 0;
const ADDRESS_42: address = @0x42;
```

--------------------------------

### User Creation with Address Check

Source: https://move-book.com/programmability/capability

This function demonstrates creating a new user by checking if the sender's address matches a predefined admin address. It requires the `TxContext` object.

```move
/// Error code for unauthorized access.
const ENotAuthorized: u64 = 0;

/// The application admin address.
const APPLICATION_ADMIN: address = @0xa11ce;

/// Creates a new user in the system. Requires the sender to be the application
/// admin.
public fun new(ctx: &mut TxContext): User {
    assert!(ctx.sender() == APPLICATION_ADMIN, ENotAuthorized);
    User { id: object::new(ctx) }
}
```

--------------------------------

### Native Function Declaration

Source: https://move-book.com/move-basics/visibility

Example of a native function declaration, which is provided by the Move VM and has no Move source code body.

```move
module std::type_name;

public native fun get<T>(): TypeName;
```

--------------------------------

### Create and Test Clock Object

Source: https://move-book.com/testing/using-system-objects

Demonstrates creating a Clock object for testing, asserting its initial state, and manipulating its time using test-only functions. Includes cleanup.

```move
use std::unit_test::assert_eq;
use sui::clock;

#[test]
fun test_clock() {
    let ctx = &mut tx_context::dummy();
    let mut clock = clock::create_for_testing(ctx);

    // Starts at 0
    assert_eq!(clock.timestamp_ms(), 0);

    // Add time (in milliseconds)
    clock.increment_for_testing(1000);
    assert_eq!(clock.timestamp_ms(), 1000);

    // Set absolute time (must be >= current)
    clock.set_for_testing(5000);
    assert_eq!(clock.timestamp_ms(), 5000);

    // Clean up - Clock doesn't have `drop`
    clock.destroy_for_testing();
}
```

--------------------------------

### Get Current Epoch

Source: https://move-book.com/programmability/epoch-and-time

Retrieves the current epoch number from the transaction context. Used in system operations and staking mechanisms.

```move
public fun current_epoch(ctx: &TxContext) {
    let epoch = ctx.epoch();
    // ...
}
```

--------------------------------

### ValidatorBuilder in Sui System

Source: https://move-book.com/testing/builder-pattern

Shows an example of using `ValidatorBuilder` from the `sui-system` package to create a complex validator object with pre-filled defaults.

```move
use sui_system::validator_builder;

#[test]
fun test_validator_operations() {
    let validator = validator_builder::preset()
        .name("My Validator")
        .gas_price(1000)
        .commission_rate(500) // 5%
        .initial_stake(100_000_000)
        .build(ctx);

    // test validator operations...
}
```

--------------------------------

### Using `use fun` Aliases for Method Syntax

Source: https://move-book.com/reference/method-syntax

Demonstrates how to use `use fun` to create aliases for functions from another module, enabling them to be called using method syntax on the `Cup` type.

```move
module b::example;

use fun a::cup::cup_borrow as Cup.borrow;
use fun a::cup::cup_value as Cup.value;
use fun a::cup::cup_swap as Cup.set;

fun example(c: &mut Cup<u64>) {
    let _ = c.borrow(); // resolves to a::cup::cup_borrow
    let v = c.value(); // resolves to a::cup::cup_value
    c.set(v * 2); // resolves to a::cup::cup_swap
}
```

--------------------------------

### Using Bag as a Struct Field

Source: https://move-book.com/programmability/dynamic-collections

An example of how to embed a `Bag` as a field within another struct, demonstrating its usage in a `Carrier` struct.

```move
/// Imported from the `sui::bag` module.
use sui::bag::{Self, Bag};

/// An example of a `Bag` as a struct field.
public struct Carrier has key {
    id: UID,
    bag: Bag
}
```

--------------------------------

### Share Clock for Testing

Source: https://move-book.com/testing/using-system-objects

Shows how to create a Clock object and then share it for use within a test scenario.

```move
#[test]
fun test_shared_clock() {
    let ctx = &mut tx_context::dummy();
    let clock = clock::create_for_testing(ctx);
    clock.share_for_testing();
}
```

--------------------------------

### Module Name Conventions

Source: https://move-book.com/reference/modules

Shows valid naming conventions for Move modules, including allowed characters and typical starting letters.

```move
module a::my_module {}
```

```move
module a::foo_bar_42 {}
```

--------------------------------

### Calling Aliased Utility Functions

Source: https://move-book.com/reference/method-syntax

Demonstrates calling a `use fun` aliased utility function multiple times, showing how the alias resolves to the correct function defined in another module.

```move
fun double_double(c: Cup<u64>): (Cup<u64>, Cup<u64>) {
    use fun b::example::double as Cup.dub;
    (c.dub(), c.dub()) // resolves to b::example::double in both calls
}
```

--------------------------------

### Call Move Function

Source: https://move-book.com/your-first-move/hello-sui

Invokes a specific Move function within a published package. This example calls the 'new' function in the 'todo_list' module.

```bash
--move-call $PACKAGE_ID::todo_list::new
```

--------------------------------

### Tuple Declaration Arity Mismatch Errors

Source: https://move-book.com/reference/variables

These examples show errors that occur when the number of declared locals does not match the tuple's arity.

```move
let (x, y) = (0, 1, 2); // ERROR!
let (x, y, z, q) = (0, 1, 2); // ERROR!
```

--------------------------------

### Calling Functions with Arguments

Source: https://move-book.com/reference/functions?highlight=native

Demonstrates calling functions that require arguments for each of their parameters.

```move
module a::example {
    public fun takes_none(): u64 { 0 }
    public fun takes_one(x: u64): u64 { x }
    public fun takes_two(x: u64, y: u64): u64 { x + y }
    public fun takes_three(x: u64, y: u64, z: u64): u64 { x + y + z }
}

module b::other {
    fun call_all() {
        a::example::takes_none();
        a::example::takes_one(0);
        a::example::takes_two(0, 1);
        a::example::takes_three(0, 1, 2);
    }
}
```

--------------------------------

### Display Help for Sui Move Test

Source: https://move-book.com/reference/unit-testing

View all available options and their descriptions for the `sui move test` command.

```bash
$ sui move test --help
```

--------------------------------

### Multiline Style Dependencies in Move.toml

Source: https://move-book.com/concepts/manifest

Illustrates the multiline TOML style for defining dependencies, which can improve readability for complex configurations.

```toml
# Multiline style
[dependencies.example]
override = true
git = "https://github.com/example/example.git"
subdir = "crates/sui-framework/packages/sui-framework"
rev = "framework/testnet"

[dependencies.my_package]
local = "../my-package"
```

--------------------------------

### Method Aliases with `use` Aliases

Source: https://move-book.com/reference/method-syntax

Demonstrates how method aliases respect normal `use` aliases. A `use` alias can implicitly create a `use fun` alias if it's a valid renaming for a function.

```move
module a::cup {
    public struct Cup<T>(T) has copy, drop, store;

    public fun cup_borrow<T>(c: &Cup<T>): &T {
        &c.0
    }
}

module b::other {
    use a::cup::{Cup, cup_borrow as borrow};

    fun example(c: &Cup<u64>) {
        c.borrow(); // resolves to a::cup::cup_borrow
    }
}
```

--------------------------------

### Immutable Vector Iteration Examples

Source: https://move-book.com/reference/functions/macros

Demonstrates usage of the `for_imm` macro for printing elements, calculating sum, and finding the maximum element in a vector.

```move
fun imm_examples(v: &vector<u64>) {
    // print all elements
    for_imm!(v, |x| std::debug::print(x));

    // sum all elements
    let mut sum = 0;
    for_imm!(v, |x| sum = sum + x);

    // find the max element
    let mut max = 0;
    for_imm!(v, |x| if (x > max) max = x);
}
```

--------------------------------

### Import Modules from Other Packages in Move

Source: https://move-book.com/move-basics/importing-modules

Demonstrates how to import modules from other packages using the 'use' keyword. Aliases like 'std' and 'sui' can be used for common libraries.

```move
module book::imports;

use std::string; // std = 0x1, string is a module in the standard library
use sui::coin;   // sui = 0x2, coin is a module in the Sui Framework
```
Tokens:
Raw