No pacote Rust fastnum de ponto flutuante decimal de alta precisão, dividir por zero causa pânico por padrão. Justo.
Mas o fastnum lista especificamente entre seus recursos o suporte para semântica completa de ponto flutuante, incluindo +/- Inf: https://www.reddit.com/r/rust/comments/1hk61om/announcing_a_new_fast_exact_precision_decimal/
Como você faz a divisão render Inf em vez de pânico? A documentação não diz.
Estou lendo "o livro" e queria testar minha compreensão das regras de empréstimo no fatiamento de capítulos .
Fiquei impressionado com (minha suposição de) como o verificador de empréstimos associava o que eu passava, com o que a função retornava. Então, tentei alguns exemplos para testar meu entendimento, e estou com dificuldades para descobrir as regras do verificador de empréstimos.
test1falha ao compilar, onde test5funciona?Este código é sempre o mesmo:
fn tmp() {
let mut s = String::from("hello world");
let thing = testX(&s);
s.clear(); // error!
let tmp = thing.len();
println!("the first word is: {tmp}");
}
Teste 1:
fn test1(s: &String) -> &str {
"Slice"
}
Aqui estou passando uma referência imutável de uma string mutável, mas não a uso na função. Eu retorno uma fatia diferente (na minha mente, uma string imutável diferente). Acredito que uma vez test1retornado ele não mantém mais seu empréstimo em &s. Eu esperava que esse código compilasse, mas não compila, eu ainda mantenho de alguma forma um empréstimo imutável em s.
Então eu me perguntei se o verificador de empréstimo correlaciona o tipo retornado com o tipo que foi passado.
Teste 2:
fn test2(s: &String) -> Vec<&str> {
let mut vec = Vec::new();
vec.push(s.as_str());
vec
}
Tentei ser criativo com mais indireção. Não tenho ideia do que as_str()acontece em termos de propriedade, mas estou interessado em aprender. Aqui estou passando de volta uma parte do que foi passado, então não estou surpreso que não compile, mas já suspeito que meu entendimento das regras esteja errado.
Teste 3
fn test3(s: &String) -> Vec<&str> {
let mut vec = Vec::new();
vec.push("Slice");
vec
}
Eu sigo um raciocínio similar ao test1, também não compila. Isso me diz que não se trata de retornar um tipo de referência do tipo que foi passado, a menos que esteja estendendo o raciocínio para o tipo do vetor proprietário..?
Teste 4
fn test4(s: &String) -> Vec<&usize> {
let mut vec = Vec::new();
vec.push(&1);
vec
}
Agora estou ficando furtivo, estou criando um código que acho que é comparável a test3, mas retorna um tipo não relacionado. Ainda assim, o compilador não permite. Então parece que por algum motivo a função está segurando o empréstimo de &Stringdepois que ele retorna?!
Teste 5
fn test5(s: &String) -> Vec<String> {
let mut vec = Vec::new();
vec.push(String::from("something new"));
vec
}
Eu tentei isso, esperando que também não compilasse, mas funcionou!
Eu vejo isso como logicamente o mesmo que test1em relação ao empréstimo de s. Em ambos os casos, não estou fazendo nada com s, mas ainda assim test1mantenho o empréstimo, enquanto test5não.
Ajuda!
Este é um problema de comportamento potencialmente indefinido de memória não inicializada em Rust inseguro.
Vec<Vec<usize>>, ou deve ser vetor de algo no heap em vez da pilha ; em outras palavras, Vec<usize>o tipo não entrará em pânico aqui);MaybeUninit); então ocorre uma liberação dupla.O código ( playground ) listado da seguinte forma:
#[deny(clippy::uninit_vec)]
unsafe fn uninitialized_vec<T>(size: usize) -> Vec<T> {
let mut v: Vec<T> = Vec::with_capacity(size);
unsafe { v.set_len(size) };
v
}
fn case_1() {
println!("=== Case 1 ===");
let vec_a: Vec<Vec<usize>> = vec![vec![0]; 4];
let _ = vec_a.clone();
let _: Vec<Vec<usize>> = unsafe { uninitialized_vec(4) };
}
fn case_2() {
println!("=== Case 2 ===");
let vec_a: Vec<Vec<usize>> = vec![vec![0]; 4];
{
let _ = vec_a.clone();
}
let _: Vec<Vec<usize>> = unsafe { uninitialized_vec(4) };
}
fn main() {
case_1();
case_2();
}
case_2ficará preso aqui;case_1ficará preso aqui.Pelo meu senso comum, o código em si não pretende liberar nenhuma variável duas vezes. Nós apenas declaramos uma variável não inicializada, mas não usamos essa variável. Se isso não for um bug, a otimização do compilador é provavelmente a única razão que pode explicar esse problema.
O que me deixa curioso é que: se esse código realmente aciona comportamento indefinido em rust inseguro, essa otimização do compilador pode causar problemas de double free ou outros. E
Além disso, sabe-se que o uso MaybeUninitcorreto pode evitar erros de tempo de execução double-free como este:
use std::mem::MaybeUninit;
unsafe fn uninitialized_vec<T>(size: usize) -> Vec<MaybeUninit<T>> {
let mut v: Vec<MaybeUninit<T>> = Vec::with_capacity(size);
unsafe { v.set_len(size) };
v
}
fn main() {
println!("=== This will not cause error ===");
let vec_a: Vec<Vec<usize>> = vec![vec![0]; 12];
{
let _ = vec_a.clone();
}
let _: Vec<MaybeUninit<Vec<usize>>> = unsafe { uninitialized_vec(12) };
}
Ainda assim, MaybeUninitpode ser inconveniente em muitas circunstâncias. Subjetivamente, prefiro usar Vec<T>em vez de Vec<MaybeUninit<T>>, especialmente quando posso ter certeza de que os valores desse vetor não inicializado serão preenchidos corretamente mais tarde.
Ambiente : rustc 1.82.0 (f6e511eec 2024-10-15)
Pergunta: Desreferenciamento vs. Empréstimo Direto em Rust
Estou confuso sobre a diferença entre *&Te Tem empréstimo. O código a seguir compila com let b = &mut *a, mas falha com let b = &mut x. Por que *ase comporta diferentemente de xneste contexto?
Além disso, descomentar a última linha ( *b = ...) causa o erro:
não pode atribuir
*aporque é emprestado
fn annoying_borrow() {
let mut x = Box::new(1);
let a = &mut x;
let b = &mut *a;
// let b = &mut x; // error: cannot borrow `x` as mutable more than once at a time
*a = Box::new(2);
// *b = Box::new(3); // error: `*a` is assigned to here but it was already borrowed
}
Usar the *aem vez de the xhere implica ainda mais na sutil diferença entre eles? Emmm, o que eu realmente quero explorar não é a diferença entre *aand x, mas as regras de empréstimo no sistema de tipos Rust (compilador).
Fundo:
Consultei Programming Rust, 2ª edição (Capítulo 5), mas não consigo compreender totalmente esse conhecimento:
O acesso compartilhado é somente leitura.
Valores emprestados por referências compartilhadas são somente leitura. Ao longo da vida útil de uma referência compartilhada, nem seu referente, nem nada alcançável daquele referente, pode ser alterado por nada. Não existem referências mutáveis vivas para nada naquela estrutura, seu proprietário é mantido somente leitura, e assim por diante. Está realmente congelado.
Acesso mutável é acesso exclusivo.
Um valor emprestado por uma referência mutável é alcançável exclusivamente por meio dessa referência. Ao longo do tempo de vida de uma referência mutável, não há outro caminho utilizável para seu referente ou para qualquer valor alcançável a partir daí. As únicas referências cujos tempos de vida podem se sobrepor a uma referência mutável são aquelas que você pega emprestado da própria referência mutável.
Gostaria de saber se há alguma explicação unificada e detalhada sobre empréstimos em Rust. Talvez houvesse um conjunto claro de regras sobre empréstimos em Rust, mas com o compilador relaxando continuamente as restrições de sintaxe (para facilitar a codificação em certos cenários?), as regras atuais são mais caóticas?
Estou escrevendo um Rust crate onde tenho uma struct cujo campo implementa uma característica, e gostaria de fornecer um recurso onde:
#[cfg(not(feature = "dyn"))]: o campo struct é Tdespachado estaticamente (mais eficiente, mas menos flexível em tempo de execução)#[cfg(feature = "dyn")]: struct field é Box<dyn MyTrait>um objeto de característica despachado dinamicamente (flexibilidade de tempo de execução com pequeno custo de desempenho)trait MyTrait {}
#[cfg(not(feature = "dyn"))]
struct MyStruct<T: MyTrait> {
my_field: T
}
#[cfg(feature = "dyn")]
struct MyStruct {
my_field: Box<dyn MyTrait>
}
Meu problema é que cada implbloco precisa ser duplicado por completo, quando as alterações deveriam afetar apenas algumas linhas.
#[cfg(not(feature = "dyn"))]
impl<T: MyTrait> MyStruct<T> {
fn new(field: T) -> Self {
Self { field }
}
}
#[cfg(feature = "dyn")]
impl MyStruct {
fn new(field: impl MyTrait + 'static) -> Self {
Self { field: Box::new(field) }
}
}
Existe uma maneira mais elegante de fazer isso? Macro black magic? Isso é apenas uma má ideia e não vale a pena fazer?
Por resposta de @cdhowie
Isso quase chega à compilação bem-sucedida! No entanto, MyTraitna verdade tem um método (que eu retirei para obter um exemplo mínimo):
trait MyTrait: Sized {
fn calculate(&self, struct: &MyStruct<Self>);
}
a referência &MyStruct<Self>é necessária porque esse método precisa acessar dados para cálculos.
Tentar implementar como sugerido não funciona... algo sobre isso quebra a compatibilidade dinâmica
impl MyTrait for Box<dyn MyTrait> {
// ^^^^^^^^^^^^^^^^
// ERROR
// the trait `MyTrait` cannot be made into an object
Se eu tentar implementar a característica para Box (não tenho certeza se isso resolveria meu problema), esse é o problema:
impl<T: MyTrait> MyTrait for Box<T> {
fn calculate(
&self,
struct: &MyStruct<Self>,
) {
(**self).calculate(struct)
// ^^^^^^
// ERROR: mismatched types
// expected reference &MyStruct<T>
// found reference &MyStruct<Box<T>>
}
}
Estou escrevendo uma aplicação visando o alvo Wasm (plataforma Yew), e tenho getrandomdependência. No entanto, recentemente o suporte mudou, e de acordo com a documentação , agora preciso:
wasm_jsrecurso--cfg getrandom_backend="linux_getrandom"Eu fiz isso, definindo a variável de ambiente RUSTFLAGS para cobrir o segundo caso, mas agora isso causa problemas ao executar cargo testou cargo clippyquando eles são compilados para um destino diferente, para o qual eu não deveria usar o recurso nem definir os sinalizadores.
Estou tentando usar Cargo.tomlisso e configurei isso:
[target.'cfg(target_arch = "wasm32")'.dependencies]
getrandom = { version = "0.3", features = ["wasm_js"] }
[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
getrandom = "0.3"
[target.wasm32-unknown-unknown]
rustflags = ["--cfg", "getrandom_backend='wasm_js'"]
A parte de dependências parece funcionar bem, no sentido de que posso executar cargo clippy, cargo teste trunk serve. No entanto, a parte para definir os sinalizadores não funciona. Tenho este aviso:
aviso: chave de manifesto não utilizada: target.wasm32-unknown-unknown.rustflags
E trunk serveainda preciso definir sinalizadores de ferrugem manualmente para que funcione:
RUSTFLAGS="--cfg getrandom_backend=\"wasm_js\"" trunk serve
Embora isso seja o que eu entendi do documento Cargo . Eu também tentei isso sem mais sucesso:
[target.'cfg(target_arch = "wasm32")']
rustflags = ["--cfg", "getrandom_backend=\"wasm_js\""]
Alguma ideia do que estou perdendo?
Não entendi bem a ideia de mutabilidade em Rust na seguinte situação:
Até onde eu entendi, se ambos são imutáveis (4), então é apenas um vetor somente leitura. Mas, desde que eu torne o vetor mutável, não importa se os elementos são mutáveis ou não...
Com vetor mutável eu sempre posso mutar elementos mesmo que eu não os tenha tornado mutáveis...
let mut st1 = String::from("Some");
let mut st2 = String::from("Value");
let vec: Vec<&mut str> = vec![&mut st1, &mut st2];
Alguém pode explicar em quais situações as combinações acima devem ser usadas e se há certos limites para cada uma delas?
Muito obrigado!
É possível canonizar uma string de caminho de arquivo contendo o diretório atual ( .) com um diretório fornecido. Por exemplo, caminho de arquivo => ./abcd.txt, diretório fornecido => /a/b/c. O resultado esperado do caminho de arquivo resultante é /a/b/c/abcd.txt.
fn main() {
let file_path = "./abcd.txt";
let cur_dir = "/a/b/c";
let path = std::fs::canonicalize(file_path).unwrap();
println!("{:#?}", path);
}
Saída
thread 'main' panicked at src/main.rs:5:49:
called `Result::unwrap()` on an `Err` value: Os { code: 2, kind: NotFound, message: "No such file or directory" }
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
Estou tentando passar o pool de banco de dados que está em State(app_state): State<AppState>fn authorizedentro do meu auth.rsfrom, api.rsonde estou usando esse middleware como JWT para proteger minhas URLs assim.
api.rs
pub fn api_routes() -> Router<AppState> {
let route = Router::new()
.route("/api", get(main_page_get).post(main_page_post))
.route("/api/{query}", get(id_page_get))
.route("/demo.json", get(get_demo_json).put(put_demo_json)
.layer(middleware::from_fn(auth::authorize))
);
return route;
}
autor.rs
pub async fn authorize(
mut req: Request<Body>,
State(app_state): State<AppState>,
next: Next
) -> Result<Response<Body>, AuthError> {
Estou recebendo um erro nesta linha middleware::from_fn(auth::authorize)dizendo:
the trait bound `axum::middleware::FromFn<fn(http::Request<Body>, axum::extract::State<AppState>, Next) -> impl Future<Output = Result<Response<Body>, AuthError>> {authorize}, (), Route, _>: tower_service::Service<http::Request<Body>>` is not satisfied
the trait `tower_service::Service<http::Request<Body>>` is not implemented for `FromFn<fn(Request<Body>, ..., ...) -> ... {authorize}, ..., ..., ...>`
the following other types implement trait `tower_service::Service<Request>`:
axum::middleware::FromFn<F, S, I, (T1, T2)>
axum::middleware::FromFn<F, S, I, (T1, T2, T3)>
axum::middleware::FromFn<F, S, I, (T1, T2, T3, T4)>
axum::middleware::FromFn<F, S, I, (T1, T2, T3, T4, T5)>
axum::middleware::FromFn<F, S, I, (T1, T2, T3, T4, T5, T6)>
axum::middleware::FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7)>
axum::middleware::FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8)>
axum::middleware::FromFn<F, S, I, (T1, T2, T3, T4, T5, T6, T7, T8, T9)>
and 8 othersrustcClick for full compiler diagnostic
api.rs(17, 10): required by a bound introduced by this call
method_routing.rs(967, 21): required by a bound in `MethodRouter::<S, E>::layer`
E não sei por quê, porque a authorizeassinatura parece boa.
EDIT: Meu estado compartilhado é implementado assim
use std::sync::Arc;
use sqlx::postgres::PgPool;
#[derive(Clone)]
pub struct AppState {
pub html_path: Arc<String>,
pub db_pool: Arc<PgPool>,
}
impl AppState {
pub fn new(html_path: String, db_pool: PgPool) -> Self {
AppState {
html_path: Arc::new(html_path),
db_pool: Arc::new(db_pool),
}
}
}
Aqui está o código:
fn main() {
let foo: Foo<i32> = Foo(42);
let bar: Foo<i64> = foo.map_ref(|x| *x as i64); // OK
let baz: Foo<&i32> = foo.map_ref(|x| x); // Error
}
struct Foo<T>(T);
impl<T> Foo<T> {
fn map_ref<U, F>(&self, f: F) -> Foo<U>
where
F: Fn(&T) -> U,
{
Foo(f(&self.0))
}
}
Falha ao compilar quando Ué referência:
error: lifetime may not live long enough
--> src\main.rs:4:48
|
4 | let baz: Foo<&i32> = foo.map_ref(|x: &i32| x); // Error
| - - ^ returning this value requires that `'1` must outlive `'2`
| | |
| | return type of closure is &'2 i32
| let's call the lifetime of this reference `'1`
|
help: dereference the return value
|
4 | let baz: Foo<&i32> = foo.map_ref(|x: &i32| *x); // Error
| +
Tentei introduzir um tempo de vida genérico 'ae Foo::map_refnão tenho ideia do que fazer a seguir.