From e Into

Fa parte della sezione Programmazione orientata agli oggetti del percorso Rust di Coddy. Lezione 57 di 61.

La conversione tra tipi è un'operazione comune in Rust. Il trait From fornisce un modo standardizzato per definire come un tipo può essere creato da un altro. Quando implementi From, ottieni automaticamente e gratuitamente il trait Into.

Per implementare From, definisci come costruire il tuo tipo a partire da un altro tipo:

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

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

Ora puoi convertire usando la funzione from oppure il metodo into:

let distance = Kilometers(5.0);

// Usando From esplicitamente
let m1 = Meters::from(distance);

// Usando Into (funziona perché From è implementato)
let distance = Kilometers(3.0);
let m2: Meters = distance.into();

Il metodo into() richiede un’annotazione di tipo, poiché Rust deve sapere in quale tipo stai convertendo. Questo schema è particolarmente utile quando hai strutture helper da convertire nei tuoi tipi principali, ad esempio per convertire i dati di configurazione in un oggetto inizializzato o trasformare input grezzi in una struttura convalidata.

Sfida

Facile

Costruiamo un sistema di conversione della temperatura usando il trait From! Creerai due tipi di temperatura, Celsius e Fahrenheit, e implementerai le conversioni tra loro usando i trait di conversione standard di Rust.

Organizzerai il codice in due file:

temperature.rs: Definisci due struct newtype pubbliche, Celsius e Fahrenheit, che contengono entrambe un f64. Implementa il trait From per convertire Celsius in Fahrenheit usando la formula: fahrenheit = celsius × 1.8 + 32.0. Aggiungi anche un metodo value a ciascuna struct, che restituisca il valore interno di tipo f64.
main.rs: Includi il modulo delle temperature e mostra entrambi i metodi di conversione. Crea un valore Celsius a partire dall'input fornito, poi convertilo in Fahrenheit usando Fahrenheit::from(). Crea un altro valore Celsius e convertilo usando il metodo .into(). Stampa entrambi i risultati.

La formula di conversione da Celsius a Fahrenheit è: moltiplica per 1.8 e aggiungi 32. Ricorda che implementare From<Celsius> for Fahrenheit ti fornisce automaticamente e gratuitamente il trait Into<Fahrenheit> per Celsius!

Entrambe le temperature vengono stampate come numeri interi: esegui il cast di ciascun f64 con as i64, che tronca i decimali verso zero. Quindi, un input di 36.6 viene stampato come 36C, e i 97.88 gradi Fahrenheit in cui viene convertito vengono stampati come 97F. Non si arrotonda mai per eccesso.

L'output dovrebbe mostrare entrambe le conversioni in questo formato:

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

Per esempio, con gli input 0 e 100:

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

E con gli input 25 e -40:

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

Riceverai due input: il primo valore in Celsius (da analizzare come f64) e il secondo valore in Celsius (da analizzare come f64).

Provalo tu

mod temperature;

use temperature::{Celsius, Fahrenheit};

fn main() {
    // Leggi l'input
    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: Crea un valore Celsius da celsius1
    // TODO: Convertilo in Fahrenheit usando Fahrenheit::from()
    
    // TODO: Crea un altro valore Celsius da celsius2
    // TODO: Convertilo in Fahrenheit usando .into()
    
    // TODO: Stampa i risultati nel formato:
    // From: {celsius1}C = {fahrenheit1}F
    // Into: {celsius2}C = {fahrenheit2}F
}