Mesures magiques

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 }
    }
}

Instructions

Astrid, une alchimiste aventurière, cherche à uniformiser les unités de mesure magiques qu'elle collecte dans différents royaumes. Certains royaumes utilisent des mesures signées (qui peuvent être négatives), tandis que d'autres utilisent des mesures non signées (toujours positives). En plus de cela, Astrid dispose de deux types personnalisés pour certains ingrédients rares, et elle a besoin d'un moyen simple de convertir ces types entre eux.

Ta mission est d'aider Astrid à convertir entre entiers signés et non signés, et de créer des conversions de types personnalisés pour ses types d'ingrédients spéciaux, en utilisant les traits Into et TryInto de Cairo.

1. Convertir les unités magiques entre valeurs signées et non signées

Astrid a des mesures qui prennent parfois des valeurs positives ou négatives (entiers signés), mais pour certaines tâches, elle doit s'assurer que les valeurs sont toujours positives (entiers non signés).

Aide Astrid en écrivant une fonction qui convertit :

1. Un entier signé (i32) en un entier non signé (u16).
2. Un entier non signé (u16) en un entier signé (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. Conversion des types d'ingrédients personnalisés

Astrid travaille avec deux ingrédients rares, Essence et Elixir, qui sont représentés par des types personnalisés. Elle veut pouvoir convertir Essence en Elixir, mais pas dans l'autre sens.

Aide Astrid en créant deux types personnalisés, Essence et Elixir, et en implémentant le trait Into pour convertir Essence en Elixir.

Écris une fonction qui prend une Essence et la convertit en un Elixir avec .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
}