Medidas 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

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

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

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

Astrid tem medidas que às vezes vêm com valores positivos ou negativos (inteiros com sinal), mas para certas tarefas ela precisa garantir que os valores sejam sempre positivos (inteiros sem sinal).

Ajude Astrid escrevendo uma função que converte:

1. Um inteiro com sinal (i32) em um inteiro sem sinal (u16).
2. Um inteiro sem sinal (u16) em um 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

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

Ajude Astrid criando dois tipos personalizados, Essence e Elixir, e implementando o trait Into para converter de Essence para Elixir.

Escreva uma função que aceita uma Essence e a converte em um 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
}