From e Into

Parte de la sección Object Oriented Programming del Journey de Rust de Coddy — lección 57 de 61.

Convertir entre tipos es una tarea común en Rust. El trait From proporciona una forma estandarizada de definir cómo se puede crear un tipo a partir de otro. Cuando implementas From, obtienes el trait Into automáticamente de forma gratuita.

Para implementar From, defines cómo construir tu tipo a partir de otro tipo:

struct Meters(f64);
struct Kilometers(f64);

impl From<Kilometers> for Meters {
    fn from(km: Kilometers) -> Self {
        Meters(km.0 * 1000.0)
    }
}

Ahora puedes realizar la conversión utilizando ya sea la función from o el método into:

let distance = Kilometers(5.0);

// Usando From explícitamente
let m1 = Meters::from(distance);

// Usando Into (funciona porque From está implementado)
let distance = Kilometers(3.0);
let m2: Meters = distance.into();

El método into() requiere una anotación de tipo ya que Rust necesita saber a qué tipo estás convirtiendo. Este patrón es especialmente útil cuando tienes estructuras auxiliares que necesitan ser convertidas a tus tipos principales—como convertir datos de configuración en un objeto inicializado, o transformar una entrada bruta en una estructura validada.

Desafío

Fácil

¡Vamos a construir un sistema de conversión de temperatura utilizando el trait From! Crearás dos tipos de temperatura—Celsius y Fahrenheit—e implementarás conversiones entre ellos utilizando los traits de conversión estándar de Rust.

Organizarás tu código en dos archivos:

temperature.rs: Define dos structs newtype públicos—Celsius y Fahrenheit—ambos envolviendo un f64. Implementa el trait From para convertir Celsius en Fahrenheit usando la fórmula: fahrenheit = celsius × 1.8 + 32.0. También añade un método value a cada struct que devuelva el f64 interno.
main.rs: Incorpora tu módulo de temperatura y demuestra ambos enfoques de conversión. Crea un valor Celsius a partir de la entrada proporcionada, luego conviértelo a Fahrenheit usando Fahrenheit::from(). Crea otro valor Celsius y conviértelo usando el método .into(). Imprime ambos resultados.

La fórmula de conversión de Celsius a Fahrenheit es: multiplicar por 1.8 y sumar 32. ¡Recuerda que implementar From<Celsius> for Fahrenheit te otorga automáticamente el trait Into<Fahrenheit> en Celsius de forma gratuita!

Tu salida debe mostrar ambas conversiones en este formato:

From: {celsius1}C = {fahrenheit1}F
Into: {celsius2}C = {fahrenheit2}F

Por ejemplo, con las entradas 0 y 100:

From: 0C = 32F
Into: 100C = 212F

Y con las entradas 25 y -40:

From: 25C = 77F
Into: -40C = -40F

Recibirás dos entradas: el primer valor Celsius (analizado como f64) y el segundo valor Celsius (analizado como f64).

Pruébalo tú mismo

mod temperature;

use temperature::{Celsius, Fahrenheit};

fn main() {
    // Leer la entrada
    let mut input1 = String::new();
    std::io::stdin().read_line(&mut input1).expect("Failed to read line");
    let celsius1: f64 = input1.trim().parse().expect("Invalid number");
    
    let mut input2 = String::new();
    std::io::stdin().read_line(&mut input2).expect("Failed to read line");
    let celsius2: f64 = input2.trim().parse().expect("Invalid number");
    
    // TODO: Crear un valor Celsius a partir de celsius1
    // TODO: Convertirlo a Fahrenheit usando Fahrenheit::from()
    
    // TODO: Crear otro valor Celsius a partir de celsius2
    // TODO: Convertirlo a Fahrenheit usando .into()
    
    // TODO: Imprimir los resultados en el formato:
    // From: {celsius1}C = {fahrenheit1}F
    // Into: {celsius2}C = {fahrenheit2}F
}