Syncwrap

根据是否启用 "sync" 功能来包装异步函数以使其同步执行。这在编写 HTTP 客户端时很有用，因为您可以编写异步方法并将它们自动包装以在同步代码库中使用。

用法

[dependencies]
syncwrap = "0.4.0"

然后在您希望为您创建同步函数的包中创建一个 sync 功能。当此功能启用时，syncwrap 将在您已包装的内容上创建同步函数。

您可以选择

• 用同步函数替换您的异步函数
• 用同步函数克隆您的异步函数，以阻塞结束
• 克隆 impl 中的所有方法为同步方法

替换异步函数

您可以通过以下方式将异步函数替换为同步函数

#[syncwrap::wrap]
async fn foo(input: &str) -> String {
  format!("I am {} now", input)
}

fn main() {
  let out = foo("sync");
  assert_eq!(out, "I am sync now".to_owned())
}

克隆异步函数

您可以通过以下方式用同步函数克隆异步函数，以阻塞结束

#[syncwrap::clone]
async fn foo(input: &str) -> String {
 format!("I am {} now", input)
}

let out = foo_blocking("sync");
assert_eq!(out, "I am sync now".to_owned())

克隆 impl 中的异步方法

您可以通过使用 syncwrap::clone_impl 来克隆 impl 中的所有方法为同步方法。这适用于您希望在结构体实现中同时支持异步和同步函数的情况。

// The original struct
#[derive(Default)]
pub struct Example {
  pub fooers: Fooers,
}

// You also need to create the struct to place the cloned impls in
// This is done so you can choose what structs/impls to clone/wrap
// The cloned structs/impls should end in Blocking
#[derive(Default)]
pub struct ExampleBlocking {
  pub fooers: FooersBlocking,
}

// The original struct with async functions
#[derive(Default)]
pub struct Fooers;

// The blocking struct that we are cloning impls into
// You have to create this so you can add custom derives
#[derive(Default)]
pub struct FooersBlocking;

// The async impls that you want to wrap
// All methods within this impl must be async
#[syncwrap::clone_impl]
impl Fooers {
  pub async fn foo(&self, input: &str) -> String {
    format!("I am {} now", input)
  }

  pub async fn bar(&self, input: &str) -> String {
    format!("I am also {} now", input)
  }
}
let example = ExampleBlocking::default();
let out = example.fooers.foo("sync");
assert_eq!(out, "I am sync now".to_owned());
let out = example.fooers.bar("sync");
assert_eq!(out, "I am also sync now".to_owned())

目前包装非常简单，只是将函数包装在 tokio::main 中。这可能比实际需要的要昂贵，我希望以后使其更高效。