在rust中将同步闭包移植到异步闭包时的生存期问题

4urapxun  于 2021-06-10  发布在  Redis
关注(0)|答案(0)|浏览(283)

我目前正在尝试将一些使用redis板条箱和redis事务的生 rust 代码从同步代码移植到异步代码，并遇到一些问题（目前与生存期相关，但根本原因可能在端口的其他地方）。
这两种情况下的代码在中都使用以下依赖项 Cargo.toml :

  1. [dependencies]
  2. redis = "0.16"
  3. tokio = { version = "0.2", features = ["full"] }

工作同步代码的最小示例如下所示：

  1. use redis::{pipe, cmd, Pipeline, ToRedisArgs, RedisResult};
  3. fn main() -> RedisResult<()> {
  4.     let client = redis::Client::open("redis://127.0.0.1/").unwrap();
  5.     let mut sync_conn = client.get_connection()?;
  7.     let key = "foo";
  9.     let (val,): (u32,) = transaction(&mut sync_conn, &[key], |conn, pipe| {
  10.         pipe.set(key, 1)
  11.             .ignore()
  12.             .get(key)
  13.             .query(conn)
  14.     })?;
  15.     println!("val: {}", val);
  17.     Ok(())
  18. }
  20. fn transaction<
  21.     C: redis::ConnectionLike,
  22.     K: ToRedisArgs,
  23.     T,
  24.     F: FnMut(&mut C, &mut Pipeline) -> RedisResult<Option<T>>,
  25. >(
  26.     con: &mut C,
  27.     keys: &[K],
  28.     func: F,
  29. ) -> RedisResult<T> {
  30.     let mut func = func;
  31.     loop {
  32.         cmd("WATCH").arg(keys).query(con)?;
  33.         if let Some(response) = func(con, pipe().atomic())? {
  34.             cmd("UNWATCH").query(con)?;
  35.             return Ok(response);
  36.         }
  37.     }
  38. }

我尝试将此代码转换为异步代码，如下所示：

  1. use redis::{AsyncCommands, pipe, cmd, Pipeline, ToRedisArgs, RedisResult, aio::ConnectionLike};
  2. use std::future::Future;
  4. # [tokio::main]
  6. async fn main() -> RedisResult<()> {
  7.     let client = redis::Client::open("redis://127.0.0.1/").unwrap();
  8.     let mut async_conn = client.get_async_connection().await?;
  10.     let key = "foo";
  12.     let (val,): (u32,) = async_transaction(&mut async_conn, &[key], |conn, pipe| async {
  13.         pipe.set(key, 1)
  14.             .ignore()
  15.             .get(key)
  16.             .query_async(conn).await
  17.     }).await?;
  18.     println!("val: {}", val);
  20.     Ok(())
  21. }
  23. pub async fn async_transaction<
  24.     C: ConnectionLike + Send,
  25.     K: ToRedisArgs,
  26.     T,
  27.     F: FnMut(&mut C, &mut Pipeline) -> Fut,
  28.     Fut: Future<Output = RedisResult<Option<T>>>,
  29. >(
  30.     con: & mut C,
  31.     keys: &[K],
  32.     func: F,
  33. ) -> RedisResult<T> {
  34.     let mut func = func;
  35.     loop {
  36.         cmd("WATCH").arg(keys).query_async(con).await?;
  37.         if let Some(response) = func(con, pipe().atomic()).await? {
  38.             cmd("UNWATCH").query_async(con).await?;
  39.             return Ok(response);
  40.         }
  41.     }
  42. }

主要的变化是使用异步连接、使用async/await和 query_async 而不是 query . 另一个主要的变化是传递给 async_transaction 返回 Future 而不是直接的结果。
但是，试图编译此文件会导致19个错误（它们大多是基于生命周期的）：

  1. error[E0486]: type of expression contains references that are not valid during the expression: `for<'_, '_> fn(&mut redis::aio::Connection, &[&str], [closure@src/main.rs:11:69: 16:6 key:&&str]) -> impl std::future::Future {async_transaction::<redis::aio::Connection, &str, (u32,), [closure@src/main.rs:11:69: 16:6 key:&&str], impl std::future::Future>}`
  2.   --> src/main.rs:11:26
  3.    |
  4. 11 |     let (val,): (u32,) = async_transaction(&mut async_conn, &[key], |conn, pipe| async {
  5.    |                          ^^^^^^^^^^^^^^^^^
  6.    |
  7. note: type is only valid for the anonymous lifetime #2 defined on the body at 11:69
  8.   --> src/main.rs:11:69
  9.    |
  10. 11 |       let (val,): (u32,) = async_transaction(&mut async_conn, &[key], |conn, pipe| async {
  11.    |  _____________________________________________________________________^
  12. 12 | |         pipe.set(key, 1)
  13. 13 | |             .ignore()
  14. 14 | |             .get(key)
  15. 15 | |             .query_async(conn).await
  16. 16 | |     }).await?;
  17.    | |_____^
  19. error[E0486]: type of expression contains references that are not valid during the expression: `for<'_, '_> fn(&mut redis::aio::Connection, &[&str], [closure@src/main.rs:11:69: 16:6 key:&&str]) -> impl std::future::Future {async_transaction::<redis::aio::Connection, &str, (u32,), [closure@src/main.rs:11:69: 16:6 key:&&str], impl std::future::Future>}`
  20.   --> src/main.rs:11:26
  21.    |
  22. 11 |     let (val,): (u32,) = async_transaction(&mut async_conn, &[key], |conn, pipe| async {
  23.    |                          ^^^^^^^^^^^^^^^^^
  24.    |
  25. note: type is only valid for the anonymous lifetime #3 defined on the body at 11:69
  26.   --> src/main.rs:11:69
  27.    |
  28. 11 |       let (val,): (u32,) = async_transaction(&mut async_conn, &[key], |conn, pipe| async {
  29.    |  _____________________________________________________________________^
  30. 12 | |         pipe.set(key, 1)
  31. 13 | |             .ignore()
  32. 14 | |             .get(key)
  33. 15 | |             .query_async(conn).await
  34. 16 | |     }).await?;
  35.    | |_____^
  37. error[E0486]: type of expression contains references that are not valid during the expression: `impl std::future::Future`
  38.   --> src/main.rs:11:26
  39.    |
  40. 11 |       let (val,): (u32,) = async_transaction(&mut async_conn, &[key], |conn, pipe| async {
  41.    |  __________________________^
  42. 12 | |         pipe.set(key, 1)
  43. 13 | |             .ignore()
  44. 14 | |             .get(key)
  45. 15 | |             .query_async(conn).await
  46. 16 | |     }).await?;
  47.    | |______^
  48.    |
  49. note: type is only valid for the anonymous lifetime #2 defined on the body at 11:69
  50.   --> src/main.rs:11:69
  51.    |
  52. 11 |       let (val,): (u32,) = async_transaction(&mut async_conn, &[key], |conn, pipe| async {
  53.    |  _____________________________________________________________________^
  54. 12 | |         pipe.set(key, 1)
  55. 13 | |             .ignore()
  56. 14 | |             .get(key)
  57. 15 | |             .query_async(conn).await
  58. 16 | |     }).await?;
  59.    | |_____^
  61. error[E0486]: type of expression contains references that are not valid during the expression: `impl std::future::Future`
  62.   --> src/main.rs:11:26
  63.    |
  64. 11 |       let (val,): (u32,) = async_transaction(&mut async_conn, &[key], |conn, pipe| async {
  65.    |  __________________________^
  66. 12 | |         pipe.set(key, 1)
  67. 13 | |             .ignore()
  68. 14 | |             .get(key)
  69. 15 | |             .query_async(conn).await
  70. 16 | |     }).await?;
  71.    | |______^
  72.    |
  73. note: type is only valid for the anonymous lifetime #3 defined on the body at 11:69
  74.   --> src/main.rs:11:69
  75.    |
  76. 11 |       let (val,): (u32,) = async_transaction(&mut async_conn, &[key], |conn, pipe| async {
  77.    |  _____________________________________________________________________^
  78. 12 | |         pipe.set(key, 1)
  79. 13 | |             .ignore()
  80. 14 | |             .get(key)
  81. 15 | |             .query_async(conn).await
  82. 16 | |     }).await?;
  83.    | |_____^
  85. error[E0486]: type of expression contains references that are not valid during the expression: `impl std::future::Future`
  86.   --> src/main.rs:11:26
  87.    |
  88. 11 |       let (val,): (u32,) = async_transaction(&mut async_conn, &[key], |conn, pipe| async {
  89.    |  __________________________^
  90. 12 | |         pipe.set(key, 1)
  91. 13 | |             .ignore()
  92. 14 | |             .get(key)
  93. 15 | |             .query_async(conn).await
  94. 16 | |     }).await?;
  95.    | |____________^
  96.    |
  97. note: type is only valid for the anonymous lifetime #2 defined on the body at 11:69
  98.   --> src/main.rs:11:69
  99.    |
  100. 11 |       let (val,): (u32,) = async_transaction(&mut async_conn, &[key], |conn, pipe| async {
  101.    |  _____________________________________________________________________^
  102. 12 | |         pipe.set(key, 1)
  103. 13 | |             .ignore()
  104. 14 | |             .get(key)
  105. 15 | |             .query_async(conn).await
  106. 16 | |     }).await?;
  107.    | |_____^
  109. error[E0486]: type of expression contains references that are not valid during the expression: `impl std::future::Future`
  110.   --> src/main.rs:11:26
  111.    |
  112. 11 |       let (val,): (u32,) = async_transaction(&mut async_conn, &[key], |conn, pipe| async {
  113.    |  __________________________^
  114. 12 | |         pipe.set(key, 1)
  115. 13 | |             .ignore()
  116. 14 | |             .get(key)
  117. 15 | |             .query_async(conn).await
  118. 16 | |     }).await?;
  119.    | |____________^
  120.    |
  121. note: type is only valid for the anonymous lifetime #3 defined on the body at 11:69
  122.   --> src/main.rs:11:69
  123.    |
  124. 11 |       let (val,): (u32,) = async_transaction(&mut async_conn, &[key], |conn, pipe| async {
  125.    |  _____________________________________________________________________^
  126. 12 | |         pipe.set(key, 1)
  127. 13 | |             .ignore()
  128. 14 | |             .get(key)
  129. 15 | |             .query_async(conn).await
  130. 16 | |     }).await?;
  131.    | |_____^
  133. error[E0486]: type of expression contains references that are not valid during the expression: `&mut impl std::future::Future`
  134.   --> src/main.rs:11:26
  135.    |
  136. 11 |       let (val,): (u32,) = async_transaction(&mut async_conn, &[key], |conn, pipe| async {
  137.    |  __________________________^
  138. 12 | |         pipe.set(key, 1)
  139. 13 | |             .ignore()
  140. 14 | |             .get(key)
  141. 15 | |             .query_async(conn).await
  142. 16 | |     }).await?;
  143.    | |____________^
  144.    |
  145. note: type is only valid for the anonymous lifetime #2 defined on the body at 11:69
  146.   --> src/main.rs:11:69
  147.    |
  148. 11 |       let (val,): (u32,) = async_transaction(&mut async_conn, &[key], |conn, pipe| async {
  149.    |  _____________________________________________________________________^
  150. 12 | |         pipe.set(key, 1)
  151. 13 | |             .ignore()
  152. 14 | |             .get(key)
  153. 15 | |             .query_async(conn).await
  154. 16 | |     }).await?;
  155.    | |_____^
  157. error[E0486]: type of expression contains references that are not valid during the expression: `&mut impl std::future::Future`
  158.   --> src/main.rs:11:26
  159.    |
  160. 11 |       let (val,): (u32,) = async_transaction(&mut async_conn, &[key], |conn, pipe| async {
  161.    |  __________________________^
  162. 12 | |         pipe.set(key, 1)
  163. 13 | |             .ignore()
  164. 14 | |             .get(key)
  165. 15 | |             .query_async(conn).await
  166. 16 | |     }).await?;
  167.    | |____________^
  168.    |
  169. note: type is only valid for the anonymous lifetime #3 defined on the body at 11:69
  170.   --> src/main.rs:11:69
  171.    |
  172. 11 |       let (val,): (u32,) = async_transaction(&mut async_conn, &[key], |conn, pipe| async {
  173.    |  _____________________________________________________________________^
  174. 12 | |         pipe.set(key, 1)
  175. 13 | |             .ignore()
  176. 14 | |             .get(key)
  177. 15 | |             .query_async(conn).await
  178. 16 | |     }).await?;
  179.    | |_____^
  181. error[E0486]: type of expression contains references that are not valid during the expression: `unsafe fn(&mut impl std::future::Future) -> std::pin::Pin<&mut impl std::future::Future> {std::pin::Pin::<&mut impl std::future::Future>::new_unchecked}`
  182.   --> src/main.rs:11:26
  183.    |
  184. 11 |       let (val,): (u32,) = async_transaction(&mut async_conn, &[key], |conn, pipe| async {
  185.    |  __________________________^
  186. 12 | |         pipe.set(key, 1)
  187. 13 | |             .ignore()
  188. 14 | |             .get(key)
  189. 15 | |             .query_async(conn).await
  190. 16 | |     }).await?;
  191.    | |____________^
  192.    |
  193. note: type is only valid for the anonymous lifetime #2 defined on the body at 11:69
  194.   --> src/main.rs:11:69
  195.    |
  196. 11 |       let (val,): (u32,) = async_transaction(&mut async_conn, &[key], |conn, pipe| async {
  197.    |  _____________________________________________________________________^
  198. 12 | |         pipe.set(key, 1)
  199. 13 | |             .ignore()
  200. 14 | |             .get(key)
  201. 15 | |             .query_async(conn).await
  202. 16 | |     }).await?;
  203.    | |_____^
  205. error[E0486]: type of expression contains references that are not valid during the expression: `unsafe fn(&mut impl std::future::Future) -> std::pin::Pin<&mut impl std::future::Future> {std::pin::Pin::<&mut impl std::future::Future>::new_unchecked}`
  206.   --> src/main.rs:11:26
  207.    |
  208. 11 |       let (val,): (u32,) = async_transaction(&mut async_conn, &[key], |conn, pipe| async {
  209.    |  __________________________^
  210. 12 | |         pipe.set(key, 1)
  211. 13 | |             .ignore()
  212. 14 | |             .get(key)
  213. 15 | |             .query_async(conn).await
  214. 16 | |     }).await?;
  215.    | |____________^
  216.    |
  217. note: type is only valid for the anonymous lifetime #3 defined on the body at 11:69
  218.   --> src/main.rs:11:69
  219.    |
  220. 11 |       let (val,): (u32,) = async_transaction(&mut async_conn, &[key], |conn, pipe| async {
  221.    |  _____________________________________________________________________^
  222. 12 | |         pipe.set(key, 1)
  223. 13 | |             .ignore()
  224. 14 | |             .get(key)
  225. 15 | |             .query_async(conn).await
  226. 16 | |     }).await?;
  227.    | |_____^
  229. error[E0486]: type of expression contains references that are not valid during the expression: `std::pin::Pin<&mut impl std::future::Future>`
  230.   --> src/main.rs:11:26
  231.    |
  232. 11 |       let (val,): (u32,) = async_transaction(&mut async_conn, &[key], |conn, pipe| async {
  233.    |  __________________________^
  234. 12 | |         pipe.set(key, 1)
  235. 13 | |             .ignore()
  236. 14 | |             .get(key)
  237. 15 | |             .query_async(conn).await
  238. 16 | |     }).await?;
  239.    | |____________^
  240.    |
  241. note: type is only valid for the anonymous lifetime #2 defined on the body at 11:69
  242.   --> src/main.rs:11:69
  243.    |
  244. 11 |       let (val,): (u32,) = async_transaction(&mut async_conn, &[key], |conn, pipe| async {
  245.    |  _____________________________________________________________________^
  246. 12 | |         pipe.set(key, 1)
  247. 13 | |             .ignore()
  248. 14 | |             .get(key)
  249. 15 | |             .query_async(conn).await
  250. 16 | |     }).await?;
  251.    | |_____^
  253. error[E0486]: type of expression contains references that are not valid during the expression: `std::pin::Pin<&mut impl std::future::Future>`
  254.   --> src/main.rs:11:26
  255.    |
  256. 11 |       let (val,): (u32,) = async_transaction(&mut async_conn, &[key], |conn, pipe| async {
  257.    |  __________________________^
  258. 12 | |         pipe.set(key, 1)
  259. 13 | |             .ignore()
  260. 14 | |             .get(key)
  261. 15 | |             .query_async(conn).await
  262. 16 | |     }).await?;
  263.    | |____________^
  264.    |
  265. note: type is only valid for the anonymous lifetime #3 defined on the body at 11:69
  266.   --> src/main.rs:11:69
  267.    |
  268. 11 |       let (val,): (u32,) = async_transaction(&mut async_conn, &[key], |conn, pipe| async {
  269.    |  _____________________________________________________________________^
  270. 12 | |         pipe.set(key, 1)
  271. 13 | |             .ignore()
  272. 14 | |             .get(key)
  273. 15 | |             .query_async(conn).await
  274. 16 | |     }).await?;
  275.    | |_____^
  277. error[E0486]: type of expression contains references that are not valid during the expression: `for<'r, 's, 't0> fn(std::pin::Pin<&'r mut impl std::future::Future>, &'s mut std::task::Context<'t0>) -> std::task::Poll<<impl std::future::Future as std::future::Future>::Output> {<impl std::future::Future as std::future::Future>::poll}`
  278.   --> src/main.rs:11:26
  279.    |
  280. 11 |       let (val,): (u32,) = async_transaction(&mut async_conn, &[key], |conn, pipe| async {
  281.    |  __________________________^
  282. 12 | |         pipe.set(key, 1)
  283. 13 | |             .ignore()
  284. 14 | |             .get(key)
  285. 15 | |             .query_async(conn).await
  286. 16 | |     }).await?;
  287.    | |____________^
  288.    |
  289. note: type is only valid for the anonymous lifetime #2 defined on the body at 11:69
  290.   --> src/main.rs:11:69
  291.    |
  292. 11 |       let (val,): (u32,) = async_transaction(&mut async_conn, &[key], |conn, pipe| async {
  293.    |  _____________________________________________________________________^
  294. 12 | |         pipe.set(key, 1)
  295. 13 | |             .ignore()
  296. 14 | |             .get(key)
  297. 15 | |             .query_async(conn).await
  298. 16 | |     }).await?;
  299.    | |_____^
  301. error[E0486]: type of expression contains references that are not valid during the expression: `for<'r, 's, 't0> fn(std::pin::Pin<&'r mut impl std::future::Future>, &'s mut std::task::Context<'t0>) -> std::task::Poll<<impl std::future::Future as std::future::Future>::Output> {<impl std::future::Future as std::future::Future>::poll}`
  302.   --> src/main.rs:11:26
  303.    |
  304. 11 |       let (val,): (u32,) = async_transaction(&mut async_conn, &[key], |conn, pipe| async {
  305.    |  __________________________^
  306. 12 | |         pipe.set(key, 1)
  307. 13 | |             .ignore()
  308. 14 | |             .get(key)
  309. 15 | |             .query_async(conn).await
  310. 16 | |     }).await?;
  311.    | |____________^
  312.    |
  313. note: type is only valid for the anonymous lifetime #3 defined on the body at 11:69
  314.   --> src/main.rs:11:69
  315.    |
  316. 11 |       let (val,): (u32,) = async_transaction(&mut async_conn, &[key], |conn, pipe| async {
  317.    |  _____________________________________________________________________^
  318. 12 | |         pipe.set(key, 1)
  319. 13 | |             .ignore()
  320. 14 | |             .get(key)
  321. 15 | |             .query_async(conn).await
  322. 16 | |     }).await?;
  323.    | |_____^
  325. error[E0481]: lifetime of function argument does not outlive the function call
  326.   --> src/main.rs:11:26
  327.    |
  328. 11 |       let (val,): (u32,) = async_transaction(&mut async_conn, &[key], |conn, pipe| async {
  329.    |  __________________________^
  330. 12 | |         pipe.set(key, 1)
  331. 13 | |             .ignore()
  332. 14 | |             .get(key)
  333. 15 | |             .query_async(conn).await
  334. 16 | |     }).await?;
  335.    | |____________^
  336.    |
  337. note: the function argument is only valid for the anonymous lifetime #2 defined on the body at 11:69
  338.   --> src/main.rs:11:69
  339.    |
  340. 11 |       let (val,): (u32,) = async_transaction(&mut async_conn, &[key], |conn, pipe| async {
  341.    |  _____________________________________________________________________^
  342. 12 | |         pipe.set(key, 1)
  343. 13 | |             .ignore()
  344. 14 | |             .get(key)
  345. 15 | |             .query_async(conn).await
  346. 16 | |     }).await?;
  347.    | |_____^
  349. error[E0481]: lifetime of function argument does not outlive the function call
  350.   --> src/main.rs:11:26
  351.    |
  352. 11 |       let (val,): (u32,) = async_transaction(&mut async_conn, &[key], |conn, pipe| async {
  353.    |  __________________________^
  354. 12 | |         pipe.set(key, 1)
  355. 13 | |             .ignore()
  356. 14 | |             .get(key)
  357. 15 | |             .query_async(conn).await
  358. 16 | |     }).await?;
  359.    | |____________^
  360.    |
  361. note: the function argument is only valid for the anonymous lifetime #3 defined on the body at 11:69
  362.   --> src/main.rs:11:69
  363.    |
  364. 11 |       let (val,): (u32,) = async_transaction(&mut async_conn, &[key], |conn, pipe| async {
  365.    |  _____________________________________________________________________^
  366. 12 | |         pipe.set(key, 1)
  367. 13 | |             .ignore()
  368. 14 | |             .get(key)
  369. 15 | |             .query_async(conn).await
  370. 16 | |     }).await?;
  371.    | |_____^
  373. error[E0488]: lifetime of variable does not enclose its declaration
  374.   --> src/main.rs:11:26
  375.    |
  376. 11 |       let (val,): (u32,) = async_transaction(&mut async_conn, &[key], |conn, pipe| async {
  377.    |  __________________________^
  378. 12 | |         pipe.set(key, 1)
  379. 13 | |             .ignore()
  380. 14 | |             .get(key)
  381. 15 | |             .query_async(conn).await
  382. 16 | |     }).await?;
  383.    | |____________^
  384.    |
  385. note: the variable is only valid for the anonymous lifetime #2 defined on the body at 11:69
  386.   --> src/main.rs:11:69
  387.    |
  388. 11 |       let (val,): (u32,) = async_transaction(&mut async_conn, &[key], |conn, pipe| async {
  389.    |  _____________________________________________________________________^
  390. 12 | |         pipe.set(key, 1)
  391. 13 | |             .ignore()
  392. 14 | |             .get(key)
  393. 15 | |             .query_async(conn).await
  394. 16 | |     }).await?;
  395.    | |_____^
  397. error[E0488]: lifetime of variable does not enclose its declaration
  398.   --> src/main.rs:11:26
  399.    |
  400. 11 |       let (val,): (u32,) = async_transaction(&mut async_conn, &[key], |conn, pipe| async {
  401.    |  __________________________^
  402. 12 | |         pipe.set(key, 1)
  403. 13 | |             .ignore()
  404. 14 | |             .get(key)
  405. 15 | |             .query_async(conn).await
  406. 16 | |     }).await?;
  407.    | |____________^
  408.    |
  409. note: the variable is only valid for the anonymous lifetime #3 defined on the body at 11:69
  410.   --> src/main.rs:11:69
  411.    |
  412. 11 |       let (val,): (u32,) = async_transaction(&mut async_conn, &[key], |conn, pipe| async {
  413.    |  _____________________________________________________________________^
  414. 12 | |         pipe.set(key, 1)
  415. 13 | |             .ignore()
  416. 14 | |             .get(key)
  417. 15 | |             .query_async(conn).await
  418. 16 | |     }).await?;
  419.    | |_____^
  421. error[E0495]: cannot infer an appropriate lifetime due to conflicting requirements
  422.   --> src/main.rs:11:26
  423.    |
  424. 11 |       let (val,): (u32,) = async_transaction(&mut async_conn, &[key], |conn, pipe| async {
  425.    |  __________________________^
  426. 12 | |         pipe.set(key, 1)
  427. 13 | |             .ignore()
  428. 14 | |             .get(key)
  429. 15 | |             .query_async(conn).await
  430. 16 | |     }).await?;
  431.    | |____________^
  432.    |
  433. note: first, the lifetime cannot outlive the anonymous lifetime #3 defined on the body at 11:69...
  434.   --> src/main.rs:11:69
  435.    |
  436. 11 |       let (val,): (u32,) = async_transaction(&mut async_conn, &[key], |conn, pipe| async {
  437.    |  _____________________________________________________________________^
  438. 12 | |         pipe.set(key, 1)
  439. 13 | |             .ignore()
  440. 14 | |             .get(key)
  441. 15 | |             .query_async(conn).await
  442. 16 | |     }).await?;
  443.    | |_____^
  444. note: ...so that the type `impl std::future::Future` is not borrowed for too long
  445.   --> src/main.rs:11:26
  446.    |
  447. 11 |       let (val,): (u32,) = async_transaction(&mut async_conn, &[key], |conn, pipe| async {
  448.    |  __________________________^
  449. 12 | |         pipe.set(key, 1)
  450. 13 | |             .ignore()
  451. 14 | |             .get(key)
  452. 15 | |             .query_async(conn).await
  453. 16 | |     }).await?;
  454.    | |____________^
  455. note: but, the lifetime must be valid for the call at 11:26...
  456.   --> src/main.rs:11:26
  457.    |
  458. 11 |       let (val,): (u32,) = async_transaction(&mut async_conn, &[key], |conn, pipe| async {
  459.    |  __________________________^
  460. 12 | |         pipe.set(key, 1)
  461. 13 | |             .ignore()
  462. 14 | |             .get(key)
  463. 15 | |             .query_async(conn).await
  464. 16 | |     }).await?;
  465.    | |____________^
  466. note: ...so that argument is valid for the call
  467.   --> src/main.rs:11:26
  468.    |
  469. 11 |       let (val,): (u32,) = async_transaction(&mut async_conn, &[key], |conn, pipe| async {
  470.    |  __________________________^
  471. 12 | |         pipe.set(key, 1)
  472. 13 | |             .ignore()
  473. 14 | |             .get(key)
  474. 15 | |             .query_async(conn).await
  475. 16 | |     }).await?;
  476.    | |____________^
  478. error: aborting due to 19 previous errors
  480. For more information about this error, try `rustc --explain E0495`.
  481. error: could not compile `redistest`.
  483. To learn more, run the command again with --verbose.

我是否可以应用一些生命周期注解来解决这个问题，或者在这种情况下，我应该做些其他的事情来从同步代码转移到异步代码？

redisasync-awaitrustrust-tokio

暂无答案！

目前还没有任何答案，快来回答吧！

我来回答

相关问题

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新问答

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com