Type Conversion in Rust

Type conversion is the process of converting a value from one type to another. Rust provides several ways to perform type conversions, ranging from simple casting with the as keyword to safe, trait-based conversions. In this lesson, you'll learn when and how to use each method.

The as Keyword

The as keyword is used for primitive type conversions. It's simple but can be unsafe:

Click Run to execute your code

Common Uses of as

From and Into Traits

The From and Into traits provide safe, explicit type conversions:

The From Trait

From defines how to create a type from another type:

// Converting &str to String
let my_str = "Hello";
let my_string = String::from(my_str);

// Converting i32 to i64
let small: i32 = 42;
let large: i64 = i64::from(small);

The Into Trait

Into is the reciprocal of From. If a type implements From, it automatically gets Into:

let num: i32 = 42;
let num_i64: i64 = num.into(); // Calls i64::from(num)

let text: String = "Hello".into(); // Calls String::from("Hello")

Click Run to execute your code

Parsing Strings to Numbers

The parse method converts strings to numbers. It returns a Result because parsing can fail:

// Using parse with type annotation
let number_str = "42";
let number: i32 = number_str.parse().expect("Not a number!");

// Using turbofish syntax
let float_num = "3.14".parse::().expect("Not a float!");

// Handling errors with match
let input = "not a number";
match input.parse::() {
    Ok(n) => println!("Parsed: {}", n),
    Err(e) => println!("Parse error: {}", e),
}

TryFrom and TryInto Traits

For conversions that can fail, use TryFrom and TryInto. They return a Result:

use std::convert::TryFrom;
use std::convert::TryInto;

// TryFrom - safe conversion that can fail
let big_num: i64 = 1000;
let small_num: Result = i8::try_from(big_num);

match small_num {
    Ok(n) => println!("Converted: {}", n),
    Err(e) => println!("Conversion failed: {}", e),
}

// TryInto - the reverse
let value: i32 = 100;
let result: Result = value.try_into();
match result {
    Ok(n) => println!("Success: {}", n),
    Err(e) => println!("Failed: {}", e),
}

Common Type Conversions

String Conversions

// &str to String
let s1 = String::from("Hello");
let s2 = "World".to_string();

// String to &str
let owned = String::from("Hello");
let borrowed: &str = &owned;

// Number to String
let num = 42;
let num_str = num.to_string();
let formatted = format!("{}", num);

Number Conversions

// Safe widening (smaller to larger)
let small: i32 = 42;
let large: i64 = small.into();

// Unsafe narrowing (use TryFrom)
let big: i64 = 1000;
let small: i8 = i8::try_from(big).unwrap_or(-1);

// Float to int (truncates)
let pi: f64 = 3.14;
let pi_int: i32 = pi as i32; // 3

Common Mistakes

let big: u32 = 1000;
let small: u8 = big as u8; // Silently becomes 232 (1000 % 256)

let big: u32 = 1000;
let small: u8 = u8::try_from(big).unwrap_or(255); // Handle overflow

let num: i32 = "not a number".parse().unwrap(); // Panics!

let num: i32 = "not a number".parse().unwrap_or(0); // Default value
// Or use match to handle error properly

let s: String = "Hello".from(); // Error: from is not a method!

let s = String::from("Hello"); // From is a trait method
let s: String = "Hello".into(); // Into is a method (needs type annotation)

Exercise: Type Conversion Practice

Click Run to execute your code

use std::convert::TryInto;

fn main() {
    // Parse string to integer
    let age_str = "25";
    let age: i32 = age_str.parse().expect("Failed to parse age");
    println!("Age: {}", age);
    
    // Convert float to integer
    let price: f64 = 19.99;
    let price_int = price as i32;
    println!("Price (integer): {}", price_int);
    
    // Safe conversion with error handling
    let big_number: i64 = 1000;
    let small_number: Result = big_number.try_into();
    match small_number {
        Ok(n) => println!("Converted: {}", n),
        Err(_) => println!("Number too large for i8"),
    }
    
    // Parse with error handling
    let input = "not a number";
    match input.parse::() {
        Ok(n) => println!("Parsed: {}", n),
        Err(e) => println!("Parse error: {}", e),
    }
    
    // Char to Unicode
    let letter = 'Z';
    let unicode_value = letter as u32;
    println!("Unicode value of '{}': {}", letter, unicode_value);
    
    // &str to String
    let str_slice = "Hello, Rust!";
    let owned_string = String::from(str_slice);
    println!("String: {}", owned_string);
    
    // Boolean to integer
    let is_active = true;
    let status_code = is_active as i32;
    println!("Status code: {}", status_code);
}

Summary

What's Next?

Now that you understand type conversion, you're ready to learn about functions. In the next lesson, you'll learn how to define functions, pass parameters, return values, and understand the crucial difference between statements and expressions in Rust.