---
name: aptos-move-language
description: Expert on Move programming language fundamentals including abilities (copy/drop/store/key), generics, phantom types, references, global storage operations (move_to/move_from/borrow_global), signer pattern, visibility modifiers, and advanced type system features.
allowed-tools: Read, Write, Edit, Grep, Glob, Bash
model: sonnet
license: MIT
metadata:
author: raintree
version: "1.0"
---
# Move Language Expert
Deep expertise on the Move programming language for Aptos blockchain.
## Triggers
- move language, abilities, generics
- phantom type, borrow_global
- signer, friend, inline
- copy, drop, store, key
- move_to, move_from, acquires
## Abilities
The four abilities control what can be done with types:
| Ability | Meaning | Use Case |
|---------|---------|----------|
| `copy` | Can be copied | Primitives, configs |
| `drop` | Can be discarded | Temporary data |
| `store` | Can be stored in structs | Most data types |
| `key` | Can be top-level resource | Account resources |
```move
struct Resource has key, store { value: u64 }
struct Point has copy, drop, store { x: u64, y: u64 }
struct Capability {} // No abilities - hot potato
```
### Critical Rules
1. Fields must have compatible abilities
2. Structs without `drop` must be explicitly handled
3. `copy` requires all fields to have `copy`
## Generics
```move
struct Box<T: store> has store {
value: T
}
public fun create<T: store>(value: T): Box<T> {
Box { value }
}
```
### Phantom Types (Zero-Cost Type Safety)
```move
struct Coin<phantom CoinType> has store {
value: u64 // CoinType doesn't appear here
}
struct BTC {}
struct ETH {}
// Coin<BTC> != Coin<ETH> at compile time
```
## References
```move
// Immutable reference
fun read(x: &u64): u64 { *x }
// Mutable reference
fun increment(x: &mut u64) { *x = *x + 1; }
```
### Reference Rules
- Can't have mutable + immutable refs simultaneously
- Only one mutable reference at a time
- References can't outlive values
## Global Storage
```move
// Store resource
move_to(account, MyResource { value: 0 });
// Remove resource
let resource = move_from<MyResource>(addr);
// Immutable borrow
let r = borrow_global<MyResource>(addr);
// Mutable borrow
let r = borrow_global_mut<MyResource>(addr);
// Check existence
exists<MyResource>(addr);
```
### The `acquires` Annotation
```move
public fun get_value(addr: address): u64 acquires MyResource {
borrow_global<MyResource>(addr).value
}
```
## Signer
`signer` is Move's authentication primitive:
```move
public entry fun initialize(account: &signer) {
move_to(account, Resource { value: 0 });
}
let addr = signer::address_of(account);
```
## Visibility
```move
fun private_fn() { } // Module only
public fun public_fn() { } // Anywhere
public(friend) fun friend_fn() { } // Friends only
public entry fun entry_fn(s: &signer) { } // Transaction entry
entry fun local_entry(s: &signer) { } // Local entry
```
### Friend Declarations
```move
module admin {
friend user_module;
public(friend) fun admin_function() { }
}
```
## Inline Functions
```move
inline fun min(a: u64, b: u64): u64 {
if (a < b) a else b
}
```
## Common Patterns
### Capability Pattern
```move
struct AdminCap has key, store {}
public fun admin_only(admin: &signer) acquires AdminCap {
assert!(exists<AdminCap>(signer::address_of(admin)), ERROR);
}
```
### Witness Pattern
```move
struct MyModule has drop {}
public fun initialize<T: drop>(account: &signer, _witness: T) {
move_to(account, Config<T> { });
}
```
### Hot Potato Pattern
```move
struct Receipt { amount: u64 } // No abilities!
public fun buy(): Receipt { Receipt { amount: 100 } }
public fun redeem(r: Receipt) { let Receipt { amount } = r; }
// Must call both - can't drop Receipt
```
## Best Practices
- Use abilities explicitly
- Leverage phantom types for type safety
- Constrain generics only as needed
- Use references to avoid copies
- Check exists before borrow_global
- Always annotate acquires