Why We Chose Rust (And You Should Too)

use solana_sdk::{
    pubkey::Pubkey,
    transaction::Transaction,
    signature::Signature,
};
 
// This is THE Pubkey type, not a wrapper
fn process_payment(merchant: Pubkey, amount: u64) -> Transaction {
    // Direct access to Solana primitives
}

// Fingers crossed, hope this 64-bit integer fits in a Number!
const amount = BigInt(response.amount);  // ...and now I need to convert everywhere

let amount: u64 = response.amount;  // Yup, that's ready to go!

// This allocation pattern is deterministic
fn process_request(input: &[u8]) -> Result<Response> {
    let parsed = parse_request(input)?;  // Stack or heap, we control it
    let result = compute(parsed)?;
    Ok(result)  // Memory freed deterministically
}

use tokio::sync::RwLock;
use std::sync::Arc;
 
struct PaymentProcessor {
    pending: Arc<RwLock<HashMap<String, PendingPayment>>>,
    rpc_pool: Arc<RpcPool>,
}
 
impl PaymentProcessor {
    async fn process(&self, payment: Payment) -> Result<Receipt> {
        // Concurrent access is safe - compiler verifies
        let pending = self.pending.read().await;
        if pending.contains_key(&payment.id) {
            return Err(anyhow!("Duplicate payment"));
        }
        drop(pending);  // Release read lock
 
        // Parallel RPC calls
        let (balance, recent_blockhash) = tokio::try_join!(
            self.rpc_pool.get_balance(&payment.from),
            self.rpc_pool.get_recent_blockhash(),
        )?;
 
        // No data races possible - compiler enforces it
    }
}

// This won't compile, can't have multiple mutable references
async fn bad_code() {
    let mut data = vec![1, 2, 3];
    let ref1 = &mut data;
    let ref2 = &mut data;  // ERROR: cannot borrow `data` as mutable more than once
 
    tokio::join!(
        modify(ref1),
        modify(ref2),
    );
}

// Distinct types for different units
#[derive(Debug, Clone, Copy)]
struct Lamports(u64);
 
#[derive(Debug, Clone, Copy)]
struct UsdCents(u64);
 
#[derive(Debug, Clone, Copy)]
struct TokenAmount(u64, u8);  // amount, decimals
 
fn create_payment(amount: UsdCents) -> Transaction {
    // Can't accidentally pass lamports here
}
 
// This won't compile:
let lamports = Lamports(1_000_000);
create_payment(lamports);  // ERROR: expected UsdCents, found Lamports

enum PaymentState {
    Pending { expires_at: DateTime<Utc> },
    Submitted { signature: Signature, submitted_at: DateTime<Utc> },
    Confirmed { signature: Signature, slot: u64 },
    Failed { reason: String },
    Refunded { refund_signature: Signature },
}
 
impl PaymentState {
    fn can_refund(&self) -> bool {
        matches!(self, PaymentState::Confirmed { .. })
    }
 
    fn signature(&self) -> Option<&Signature> {
        match self {
            PaymentState::Submitted { signature, .. } => Some(signature),
            PaymentState::Confirmed { signature, .. } => Some(signature),
            _ => None,
        }
    }
}

// Result forces you to handle errors
fn get_payment(id: &str) -> Result<Payment, PaymentError> {
    let record = db.query(id)?;  // ? propagates errors
    parse_payment(record)
}
 
// You can't ignore the Result
let payment = get_payment("pay_123");  // WARNING: unused Result
let payment = get_payment("pay_123")?;  // ✓ Properly handled

// This high-level, readable code...
let valid_payments: Vec<_> = payments
    .iter()
    .filter(|p| p.amount > 0)
    .filter(|p| p.expires_at > Utc::now())
    .map(|p| ValidPayment::from(p))
    .collect();
 
// ...compiles to the same assembly as hand-written loops

cargo build          # Compile
cargo test           # Run tests
cargo run            # Run the app
cargo fmt            # Format code
cargo clippy         # Lint
cargo doc            # Generate docs
cargo bench          # Benchmarks

# Cargo.toml
[dependencies]
tokio = { version = "1.0", features = ["full"] }
axum = "0.7"
sqlx = { version = "0.7", features = ["postgres", "runtime-tokio"] }

error[E0382]: borrow of moved value: `payment`
  --> src/main.rs:10:15
   |
7  |     let payment = Payment::new();
   |         ------- move occurs because `payment` has type `Payment`, which does not implement the `Copy` trait
8  |     process(payment);
   |             ------- value moved here
9  |     
10 |     log(payment);
   |         ^^^^^^^ value borrowed here after move
   |
help: consider cloning the value if the performance cost is acceptable
   |
8  |     process(payment.clone());
   |                    ++++++++

// This is real production code
#[tokio::main]
async fn main() -> Result<()> {
    // Tracing subscriber for structured logging
    tracing_subscriber::init();
 
    // Database with compile-time checked queries
    let db = PgPoolOptions::new()
        .max_connections(50)
        .connect(&env::var("DATABASE_URL")?)
        .await?;
 
    // Verify schema at startup
    sqlx::migrate!().run(&db).await?;
 
    // Build the app
    let app = Router::new()
        .route("/v1/payments", post(create_payment))
        .route("/v1/payments/:id", get(get_payment))
        .layer(TraceLayer::new_for_http())
        .with_state(AppState::new(db));
 
    // Run it
    axum::serve(listener, app).await?;
 
    Ok(())
}

# Python: 3 lines
data = requests.get(url).json()
result = [x['name'] for x in data if x['active']]
print(result)

// Rust: More lines
let data: Vec<Item> = reqwest::get(url).await?.json().await?;
let result: Vec<&str> = data.iter()
    .filter(|x| x.active)
    .map(|x| x.name.as_str())
    .collect();
println!("{:?}", result);