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).

Hoja de referencia

El trait From proporciona una forma estandarizada de convertir entre tipos. Cuando implementas From, obtienes automáticamente el trait Into de forma gratuita.

Para implementar From, define 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)
    }
}

Puedes realizar la conversión utilizando 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 (requiere anotación de tipo)
let distance = Kilometers(3.0);
let m2: Meters = distance.into();

El método into() requiere una anotación de tipo para que Rust sepa a qué tipo estás realizando la conversión.

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
}