Mediciones mágicas

let small_number: u8 = 42;
let big_number: u32 = small_number.into();

let value: u16 = 100;
let converted: u32 = value.into();

let large_value: u32 = 70000;
let small_value: Option<u16> = large_value.try_into();

match small_value {
    Option::Some(v) => println!("Converted: {}", v),
    Option::None => println!("Conversion failed"),
}

#[derive(Drop)]
struct Celsius {
    value: i32,
}

#[derive(Drop)]
struct Fahrenheit {
    value: i32,
}

impl CelsiusIntoFahrenheit of Into<Celsius, Fahrenheit> {
    fn into(self: Celsius) -> Fahrenheit {
        Fahrenheit { value: (self.value * 9) / 5 + 32 }
    }
}

Instrucciones

Astrid, una alquimista aventurera, está intentando estandarizar las unidades mágicas de medida que recoge de distintos reinos. Algunos reinos usan medidas con signo (que pueden ser negativas), mientras que otros usan medidas sin signo (que siempre son positivas). Además, Astrid tiene dos tipos personalizados para ciertos ingredientes poco comunes, y necesita una forma de convertir fácilmente entre estos tipos.

Tu misión es ayudar a Astrid a convertir entre enteros con signo y sin signo, y crear conversiones de tipos personalizadas para sus tipos de ingredientes especiales usando los traits Into y TryInto de Cairo.

1. Convertir unidades mágicas entre enteros con signo y sin signo

Astrid tiene medidas que a veces vienen en valores positivos o negativos (enteros con signo), pero para ciertas tareas necesita asegurarse de que los valores sean siempre positivos (enteros sin signo).

Ayuda a Astrid escribiendo una función que convierta:

1. Un entero con signo (i32) a un entero sin signo (u16).
2. Un entero sin signo (u16) a un entero con signo (i32).

let signed_value: i32 = -42;
match convert_signed_to_unsigned(signed_value) {
    Option::Some(v) => println!("Converted to unsigned: {}", v),
    Option::None => println!("Failed to convert: {}", signed_value),
} // prints "Failed to convert: -42"

let unsigned_value: u16 = 42;
let signed_value: i32 = convert_unsigned_to_signed(unsigned_value);
println!("Converted to signed: {}", signed_value); // prints "Converted to signed: 42"

2. Conversión de tipos de ingredientes personalizados

Astrid trabaja con dos ingredientes poco comunes, Essence y Elixir, que están representados por tipos personalizados. Quiere poder convertir Essence en Elixir, pero no al contrario.

Ayuda a Astrid creando dos tipos personalizados, Essence y Elixir, e implementando el trait Into para convertir de Essence a Elixir.

Escribe una función que acepte un Essence y lo convierta en un Elixir usando .into().

#[derive(Drop)]
struct Essence {
    potency: u16,
}

#[derive(Drop)]
struct Elixir {
    strength: u16,
}

fn convert_essence_to_elixir(essence: Essence) -> Elixir {
    // Convert the Essence to Elixir using the Into trait.
    essence.into()
}

fn main() {
    let essence = Essence { potency: 100 };
    let elixir: Elixir = convert_essence_to_elixir(essence);
    println!("Elixir strength: {}", elixir.strength); // Elixir strength: 100
}