Olivier Lasne's questions

Gostaria de converter um i128 para um f64 .

Eu sei que posso lançar silenciosamente com as.

let nb: i128 = 1337;
let converted = nb as f64;

Mas isso não me dá a oportunidade de lidar com nenhum erro.

Existe uma maneira de fazer algo semelhante a

let nb: i128 = 1337;
let converted: f64 = nb.try_into()?;

Onde posso lidar com o erro, se o valor convertido não couber em um f64?

Tenho uma variável na qual faço muitas operações aritméticas.

Meu código era mais ou menos assim:

let a: u32 = 3;
let res = (a*2) - 42

Tive um estouro quando aestava muito baixo, então tive que usar saturating_sub()para resolver o problema:

let a: u32 = 3;
let res = (a * 2).saturating_sub(42);

Isso funciona muito bem, mas saturating_subé um pouco menos legível que -.

Como tenho muitas dessas operações, e em todos os casos, quero asaturar. Eu estava pensando se é possível definir que asempre deve saturar . E não substituir every -por saturate_sub.

Se eu tentar construir o seguinte código:

fn main () {
    let my_val: u32 = 42;
    
    match my_val % 2 {
        0 => println!("We're even now"),
        1 => println!("Well, that's odd"),
    }
}

Terei a seguinte mensagem de erro:

error[E0004]: non-exhaustive patterns: `2_u32..=u32::MAX` not covered
 --> src/main.rs:4:11
  |
4 |     match my_val % 2 {
  |           ^^^^^^^^^^ pattern `2_u32..=u32::MAX` not covered
  |
  = note: the matched value is of type `u32`
help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
  |
6 ~         1 => println!("Well, that's odd"),
7 ~         2_u32..=u32::MAX => todo!(),
  |

Eu realmente não entendi. Qual é o caso representado por 2_u32..=u32::MAX?

Gostaria de escrever uma addfunção que possa receber como entrada um i64ou f64dois parâmetros.

Consegui chegar ao seguinte:

use std::ops::Add;

fn add<T: Add<Output = T>>(a: T, b: T) -> T{
    a + b
}

fn main() {
    let a: i64 = 10;
    let b: i64 = 20;
    let c: f64 = 10.5;
    let d: f64 = 20.5;

    println!("{:?}", add(a, b)); // Outputs: 30
    println!("{:?}", add(c, d)); // Outputs: 31.0
}

É possível modificar esta função para que seja possível ter:

• um parâmetro sendo umi64
• o outro parâmetro é umf64

Se qualquer um dos parâmetros for um, f64fazemos uma conversão e retornamos um f64.

A função principal teria a seguinte saída:

fn main() {
    let a: i64 = 10;
    let b: i64 = 20;
    let c: f64 = 10.5;
    let d: f64 = 20.5;

    println!("{:?}", add(a, b)); // Outputs: 30    | i64 + i64 -> i64
    println!("{:?}", add(a, c)); // Outputs: 20.5  | i64 + f64 -> f64
    println!("{:?}", add(c, a)); // Outputs: 20.5  | f64 + i64 -> f64
    println!("{:?}", add(c, d)); // Outputs: 30.0  | f64 + f64 -> f64
}

No código a seguir, não entendo por que o Span require alife . Como todos os argumentos implementam copy trait , meu entendimento é que o Span possui todas as variáveis ​​necessárias.

use ratatui::{
    style::{Color, Style},
    text::Span,
};

/// Take a u8, and render a colorized ascii, or placeholdler
fn render_ascii_char(val: u8) -> Span {
    match val {

        val if val > 0x20 && val < 0x7f => {
            Span::styled(
                val.to_string(),
                Style::default().fg(Color::LightCyan)
            )
        },

        _ => {
            Span::styled(
                "•",
                Style::default().fg(Color::Yellow)
            )
        }
    }
}

fn test_function() -> Span {
    let val = 0x42;

    render_ascii_char(val)
}

fn main() {
    let _my_span = test_function();
}

Este código usa ratatui. Abaixo o Cargo.toml:

[package]
name = "span_lifetime"
version = "0.1.0"
edition = "2024"

[dependencies]
crossterm = "0.27.0"
ratatui = "0.26.2"

Tenho a seguinte mensagem de erro ao compilar com cargo build:

$ cargo build
   Compiling span_lifetime v0.1.0 (/tmp/playground/span_lifetime)
error[E0106]: missing lifetime specifier
 --> src/main.rs:7:34
  |
7 | fn render_ascii_char(val: u8) -> Span {
  |                                  ^^^^ expected named lifetime parameter
  |
  = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
help: consider using the `'static` lifetime, but this is uncommon unless you're returning a borrowed value from a `const` or a `static`, or if you will only have owned values
  |
7 | fn render_ascii_char(val: u8) -> Span<'static> {
  |                                      +++++++++

error[E0106]: missing lifetime specifier
  --> src/main.rs:26:23
   |
26 | fn test_function() -> Span {
   |                       ^^^^ expected named lifetime parameter
   |
   = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
help: consider using the `'static` lifetime, but this is uncommon unless you're returning a borrowed value from a `const` or a `static`, or if you will only have owned values
   |
26 | fn test_function() -> Span<'static> {
   |                           +++++++++

For more information about this error, try `rustc --explain E0106`.
error: could not compile `span_lifetime` (bin "span_lifetime") due to 2 previous errors

Usar uma <'static>vida inteira não parece uma boa ideia, já que não uso essa função apenas com constantes.

Usar uma referência val: &u8como argumento, em vez de val: u8funcionar. Mas cria problemas quando o valor passado sai do escopo.

Minha solução até agora é especificar uma vida inteira:

fn render_ascii_char<'a>(val: u8) -> Span<'a> {
    match val {
[...]

Mas eu realmente não entendo por que isso é necessário, nem as implicações desta vida.