小编kmd*_*eko的帖子

我为 MySQL 数据库创建了一个池，如下所示：

let database_url = env::var("DATABASE_URL").expect("set DATABASE_URL");

let manager = ConnectionManager::<MysqlConnection>::new(database_url);
let pool = r2d2::Pool::builder()
    .build(manager)
    .expect("Failed to create pool.");

像这样包含在 actix 中：

HttpServer::new(move || App::new()
    .data(pool.clone()) // <-- HERE
    .service(
        web::resource("/infos")
          .route(web::post().to(get_infos))
    ))

    .bind("127.0.0.1:8080")?
    .start();

println!("Starting http server: 127.0.0.1:8080");

问题来了，如何在这个 info 函数中使用它：

pub fn get_infos(conn: &MysqlConnection) -> Vec<Book> {
    all_books
        .order(books::id.desc())
        .load::<Book>(conn)
        .expect("error loading the books")
}

直接将 MySQL 连接的一个实例传递给 get_infos 运行良好，但使用池我不知道如何处理它？！有什么帮助吗？

为了获得更多说明，我的目标是使用 POOLING 而不是仅使用一个实例，就像此代码中的情况一样：

let database_url = env::var("DATABASE_URL").expect("set DATABASE_URL");
let conn = MysqlConnection::establish(&database_url).unwrap();
// And then passing …

考虑以下 Rust 程序：

fn f<'a>(x: &'a i32) {
    unimplemented!();
}

fn main() {
    f::<'static>;
}

编译时，输出如下编译错误：

fn f<'a>(x: &'a i32) {
    unimplemented!();
}

fn main() {
    f::<'static>;
}

让我们像这样修改程序：

fn f<'a, 'b>(x: &'a i32) -> &'b i32 {
    unimplemented!();
}

fn main() {
    f::<'static>;
}

由于某些奇怪的原因，现在编译时没有任何编译错误。为什么是这样？如果第一个程序中的生命周期参数 'a 是后期绑定的，为什么它不应该在第二个程序中也后期绑定？请注意，我在第一个和第二个程序之间所做的唯一更改是添加另一个生命周期参数和一个依赖于这个新生命周期参数的返回类型。

我在项目中使用跟踪库，但有一件事我无法弄清楚：如何访问我的 中的值（我在创建它时在跨度中设置的值）Layer？

我的图层看起来像这样：

impl<S> Layer<S> for CustomLayer where S: Subscriber {
    fn register_callsite(&self, metadata: &'static Metadata<'static>) -> Interest {
        Interest::sometimes() //hardcoding so enabled() will be called everytime a span is created
    }

    fn enabled(&self, metadata: &Metadata<'_>, ctx: Context<'_, S>) -> bool {
        if metadata.is_span() {
            // How do I access value of key here?
            if value == X {
                true
            } else if value == Y {
                false
            }
        }
        true // default
    }
}

我在 Rust 中有这个函数：

fn printboard(board: Vec<u32>) {
    println!("|  |{:>2$} {:>2$} {:>2$} {:>2$} {:>2$} {:>2$}|  |", 
        board[1], board[2], board[3], board[4], board[5], board[6]);
}

由于某种原因，代码在 处抛出错误board[3]，显示“预期的 usize，发现了 u32”。对于任何其他board[x]表达式都不会发生这种情况。知道为什么会发生这种情况吗？

这是完整的错误：

fn printboard(board: Vec<u32>) {
    println!("|  |{:>2$} {:>2$} {:>2$} {:>2$} {:>2$} {:>2$}|  |", 
        board[1], board[2], board[3], board[4], board[5], board[6]);
}

如果使用set_hook，我们可以获得大量信息，尤其是堆栈跟踪 - 这非常有帮助。然而，对于catch_unwind，我只得到 a Result，其中几乎不包含任何有用的信息。因此，我想知道如何使用 Rust 获取恐慌信息（尤其是堆栈跟踪）catch_unwind？

我处于多线程环境中，其中有许多线程同时运行，任何线程都可能出现恐慌。我想我应该set_hook与 一起使用catch_unwind，并且还使用一些线程局部变量，但我不确定它是否可行以及细节。

我有一个程序属性宏，给定一个函数对每个二进制表达式进行操作，例如let a = b + c;并根据它返回另一个表达式。根据类型进行操作，需要知道、、+的类型。abc

有没有办法在编译时获取变量的推断类型？

（就像 rust-analysisr 可能会显示推断的类型一样，我可以在宏中获取这些类型吗？）

简单示例 -游乐场

为了在 Rust 游乐场中更简洁地说明我的方法，我们可以使用声明性宏来调用给定变量上的函数，该函数的细节基于给定变量的类型。

我在 Rust 游乐场中最接近我想要的功能：

macro_rules! SomeMacro {
    ($x:expr) => {{
        $x.some_function(3.)
    }};
}
trait SomeTrait {
    fn some_function(&self,x:f32) -> f32;
}
impl SomeTrait for u32 {
    fn some_function(&self,x:f32) -> f32 {
        x * 3.
    }
}

fn main() {
    let a = 3u32;
    let b = SomeMacro!(a);
    assert_eq!(b,9.);
}

我怎样才能让事情像这样工作：

fn some_function<u32>(x:f32) -> f32 {
    3. * x …

我有以下代码，适用于我的 rust 应用程序，将日志写入 stdout 和滚动 json 文件。

    let appender = tracing_appender::rolling::hourly(app_log_path.clone(), "application.log");
    let (non_blocking, _guard) = tracing_appender::non_blocking(appender);

    let subscriber = tracing_subscriber::registry()
        .with(fmt::Layer::new().with_writer(std::io::stdout).pretty())
        .with(fmt::Layer::new().with_writer(non_blocking).json());

    tracing::subscriber::set_global_default(subscriber).expect("Unable to set a global collector");

这有效，但会记录所有日志记录级别，包括详细跟踪日志记录。我想将日志限制为仅信息级别，但不知道如何做到这一点。

从跟踪文档来看，它说要做：

fmt()
    .with_max_level(Level::DEBUG)
    .init();

但是，我在上面的代码中找不到任何可以添加.with_max_level()函数调用的地方。我尝试放置的每个地方都给出了不同的特征违规。例如

 the following trait bounds were not satisfied:
           `tracing_subscriber::fmt::Layer<_, Pretty, Format<Pretty>, fn() -> std::io::Stdout {std::io::stdout}>: MakeWriter<'_>`
           which is required by `tracing_subscriber::fmt::Layer<_, Pretty, Format<Pretty>, fn() -> std::io::Stdout {std::io::stdout}>: MakeWriterExt`
           `&tracing_subscriber::fmt::Layer<_, Pretty, Format<Pretty>, fn() -> std::io::Stdout {std::io::stdout}>: MakeWriter<'_>`
           which is required by `&tracing_subscriber::fmt::Layer<_, Pretty, Format<Pretty>, fn() …

我刚刚完成了关于 C 和 Rust元音计数的 CodeWars kata。示例代码简单明了。数组可以用作快速映射。在这里，我将字符映射到逻辑值（0 或 1）。

C实现：

#include <stddef.h>
#include <stdint.h>

// :) This const array design looks smart & IMO-readable. Use of C99 feature.
const uint8_t areVowels[256]= {['a']=1, ['e']=1, ['i']=1, ['o']=1,  ['u']=1};

size_t get_count(const unsigned char *s)
{
  auto size_t count= 0;
  for (;*s!='\0';s++){
    count+= areVowels[*s];
  }
  return count;
}

Rust 实现：

// :( Here is me pain. Unreadable, python3-generated array content.
const ARE_VOWELS:[u8;256]= [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];

fn get_count(s: &str) -> usize {
  let mut vowels_count: usize …

假设我有这段代码：

pub trait A {}
pub trait B {}

pub trait SomeBehavior {
  fn func() -> bool;
}

我想提供这样的总体A实现B：

impl <T> SomeBehavior for T where T: A {
  fn func() -> bool { true }
}

impl <T> SomeBehavior for T where T: B {
  fn func() -> bool { false }
}

但这会产生以下错误：

pub trait A {}
pub trait B {}

pub trait SomeBehavior {
  fn func() -> bool;
}

为什么编译器将不同特征的两种不同实现视为相同实现？

在 Rust 中，您可以使用某种通过关键字访问的编译器魔法从 转换Arc/Box/Rc<T>为。有没有办法为用户定义的类型选择这种魔法，或者是特殊情况？Arc/Box/Rc<dyn Trait>asArcBox

天真的尝试会导致错误：

use std::sync::Arc;

struct X<T: ?Sized> {
    t: Box<T>,
}

impl <T> X<T> {
    pub fn new(t: T) -> Self {
        Self { t: Box::new(t) }
    }
}

pub fn main() {
    let x = Arc::new("123".to_owned()) as Arc<dyn AsRef<str>>;
    let x = Box::new("123".to_owned()) as Box<dyn AsRef<str>>;
    let x = X::new("123".to_owned()) as X<dyn AsRef<str>>;
}

error[E0605]: non-primitive cast: `X<String>` as `X<dyn AsRef<str>>`
  --> src/main.rs:16:13
   |
16 |     let x = …