Medições 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 }
    }
}

Instruções

A Astrid, uma alquimista aventureira, está a tentar normalizar as unidades de medida mágicas que recolhe de diferentes reinos. Alguns reinos usam medições com sinal (que podem ser negativas), enquanto outros usam medições sem sinal (que são sempre positivas). Além disso, a Astrid tem dois tipos personalizados para certos ingredientes raros e precisa de uma forma de converter facilmente entre esses tipos.

A tua missão é ajudar a Astrid a converter entre inteiros com e sem sinal, e criar conversões de tipos personalizados para os seus tipos de ingredientes especiais, usando os traits Into e TryInto do Cairo.

1. Converter unidades mágicas entre com e sem sinal

A Astrid tem medições que às vezes aparecem com valores positivos ou negativos (inteiros com sinal), mas, para certas tarefas, precisa de garantir que os valores são sempre positivos (inteiros sem sinal).

Ajuda a Astrid escrevendo uma função que converte:

1. Um inteiro com sinal (i32) num inteiro sem sinal (u16).
2. Um inteiro sem sinal (u16) num inteiro com sinal (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. Conversão de tipos de ingredientes personalizados

A Astrid trabalha com dois ingredientes raros, Essence e Elixir, que são representados por tipos personalizados. Quer conseguir converter Essence em Elixir, mas não o contrário.

Ajuda a Astrid a criar dois tipos personalizados, Essence e Elixir, e a implementar o trait Into para converter Essence em Elixir.

Escreve uma função que recebe uma Essence e a converte num 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
}