类型擦除

tower = { version = "=0.5.3", features = ["limit", "timeout", "util"] }
tokio = { version = "=1.54.1", features = ["macros", "rt-multi-thread"] }

use std::time::Duration;
use tower::{service_fn, BoxError, Service, ServiceBuilder, ServiceExt};

async fn handle(req: String) -> Result<String, BoxError> {
  Ok(req.to_uppercase())
}

fn build(strict: bool) -> impl Service<String, Response = String, Error = BoxError> {
  if strict {
    ServiceBuilder::new()
      .timeout(Duration::from_secs(1))
      .concurrency_limit(10)
      .service_fn(handle)
  } else {
    service_fn(handle)
  }
}

error[E0308]: `if` and `else` have incompatible types
  --> examples/branch.rs:15:5
   |
 9 | /    if strict {
10 | |/     ServiceBuilder::new()
11 | ||       .timeout(Duration::from_secs(1))
12 | ||       .concurrency_limit(10)
13 | ||       .service_fn(handle)
   | ||_________________________- expected because of this
14 | |    } else {
15 | |      service_fn(handle)
   | |      ^^^^^^^^^^^^^^^^^^ expected `Timeout<ConcurrencyLimit<ServiceFn<_>>>`, found `ServiceFn<fn(String) -> _ {handle}>`
16 | |    }
   | |____- `if` and `else` have incompatible types
   |
   = note: expected struct `tower:...le}>>>`
              found struct `ServiceFn<fn(String) -> impl std::future::Future<Output = Result<String, Box<(dyn std::error::Error + Send + Sync + 'static)>>> {handle}>`
help: you could change the return type to be a boxed trait object
   |
 8 - fn build(strict: bool) -> impl Service<String, Response = String, Error = BoxError> {
 8 + fn build(strict: bool) -> Box<dyn Service<String, Response = String, Error = BoxError>> {
   |

error[E0191]: the value of the associated type `Future` in `Service<String>` must be specified
 --> examples/branch_dyn.rs:8:35
  |
8 | fn build(strict: bool) -> Box<dyn Service<String, Response = String, Error = BoxError>> {
  |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  |
help: specify the associated type
  |
8 | fn build(strict: bool) -> Box<dyn Service<String, Response = String, Error = BoxError, Future = /* Type */>> {
  |                                                                                      +++++++++++++++++++++

use tower::util::BoxService;

fn build(strict: bool) -> BoxService<String, String, BoxError> {
  if strict {
    ServiceBuilder::new()
      .timeout(Duration::from_secs(1))
      .concurrency_limit(10)
      .service_fn(handle)
      .boxed()
  } else {
    service_fn(handle).boxed()
  }
}

#[tokio::main]
async fn main() {
  for strict in [true, false] {
    let r = build(strict).oneshot("hi".to_string()).await.unwrap();
    println!("strict={strict}: {r}");
  }
}

strict=true: HI
strict=false: HI

pub struct BoxService<T, U, E> {
    inner:
        SyncWrapper<Box<dyn Service<T, Response = U, Error = E, Future = BoxFuture<U, E>> + Send>>,
}

type BoxFuture<T, E> = Pin<Box<dyn Future<Output = Result<T, E>> + Send>>;

impl<T, U, E> BoxService<T, U, E> {
    pub fn new<S>(inner: S) -> Self
    where
        S: Service<T, Response = U, Error = E> + Send + 'static,
        S::Future: Send + 'static,
    {
        // rust can't infer the type
        let inner: Box<dyn Service<T, Response = U, Error = E, Future = BoxFuture<U, E>> + Send> =
            Box::new(inner.map_future(|f: S::Future| Box::pin(f) as _));
        let inner = SyncWrapper::new(inner);
        BoxService { inner }
    }
    // ...
}

impl<T, U, E> Service<T> for BoxService<T, U, E> {
    type Response = U;
    type Error = E;
    type Future = BoxFuture<U, E>;

    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), E>> {
        self.inner.get_mut().poll_ready(cx)
    }

    fn call(&mut self, request: T) -> BoxFuture<U, E> {
        self.inner.get_mut().call(request)
    }
}

unsafe impl<T> Sync for SyncWrapper<T> {}

tower = { version = "=0.5.3", features = ["util"] }

use std::cell::Cell;
use std::convert::Infallible;
use std::future::{ready, Ready};
use std::task::{Context, Poll};
use tower::util::{BoxCloneService, BoxCloneSyncService, BoxService};
use tower::Service;

// Send + Clone, but not Sync: Cell
#[derive(Clone)]
struct Counter {
  n: Cell<u32>,
}

impl Service<()> for Counter {
  type Response = u32;
  type Error = Infallible;
  type Future = Ready<Result<u32, Infallible>>;
  fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Infallible>> {
    Poll::Ready(Ok(()))
  }
  fn call(&mut self, _: ()) -> Self::Future {
    self.n.set(self.n.get() + 1);
    ready(Ok(self.n.get()))
  }
}

fn assert_sync<T: Sync>(_: &T) {}

fn main() {
  let c = Counter { n: Cell::new(0) };
  assert_sync(&BoxService::new(c.clone()));
  assert_sync(&BoxCloneService::new(c.clone()));
  let _ = BoxCloneSyncService::new(c);
}

error[E0277]: `dyn CloneService<(), Error = _, Future = _, Response = u32> + Send` cannot be shared between threads safely
   --> examples/sync.rs:32:15
    |
 32 |   assert_sync(&BoxCloneService::new(c.clone()));
    |   ----------- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `dyn CloneService<(), Error = _, Future = _, Response = u32> + Send` cannot be shared between threads safely
    |   |
    |   required by a bound introduced by this call
    |
    = help: the trait `Sync` is not implemented for `dyn CloneService<(), Error = _, Future = _, Response = u32> + Send`
    = note: required for `Unique<_>` to implement `Sync`
note: required because it appears within the type `Box<_>`
   --> .../library/alloc/src/boxed.rs:236:12
    |
236 | pub struct Box<
    |            ^^^
note: required because it appears within the type `BoxCloneService<(), u32, Infallible>`
   --> .../tower-0.5.3/src/util/boxed_clone.rs:58:12
    |
 58 | pub struct BoxCloneService<T, U, E>(
    |            ^^^^^^^^^^^^^^^
note: required by a bound in `assert_sync`
   --> examples/sync.rs:27:19
    |
 27 | fn assert_sync<T: Sync>(_: &T) {}
    |                   ^^^^ required by this bound in `assert_sync`

error[E0277]: `Cell<u32>` cannot be shared between threads safely
  --> examples/sync.rs:33:36
   |
33 |   let _ = BoxCloneSyncService::new(c);
   |           ------------------------ ^ `Cell<u32>` cannot be shared between threads safely
   |           |
   |           required by a bound introduced by this call
   |
   = help: within `Counter`, the trait `Sync` is not implemented for `Cell<u32>`
   = note: if you want to do aliasing and mutation between multiple threads, use `std::sync::RwLock` or `std::sync::atomic::AtomicU32` instead
note: required because it appears within the type `Counter`
  --> examples/sync.rs:10:8
   |
10 | struct Counter {
   |        ^^^^^^^
note: required by a bound in `BoxCloneSyncService::<T, U, E>::new`
  --> .../tower-0.5.3/src/util/boxed_clone_sync.rs:29:65
   |
27 |     pub fn new<S>(inner: S) -> Self
   |            --- required by a bound in this associated function
28 |     where
29 |         S: Service<T, Response = U, Error = E> + Clone + Send + Sync + 'static,
   |                                                                 ^^^^ required by this bound in `BoxCloneSyncService::<T, U, E>::new`

pub struct BoxLayer<In, T, U, E> {
    boxed: Arc<dyn Layer<In, Service = BoxService<T, U, E>> + Send + Sync + 'static>,
}

impl<In, T, U, E> BoxLayer<In, T, U, E> {
    pub fn new<L>(inner_layer: L) -> Self
    where
        L: Layer<In> + Send + Sync + 'static,
        L::Service: Service<T, Response = U, Error = E> + Send + 'static,
        <L::Service as Service<T>>::Future: Send + 'static,
    {
        let layer = layer_fn(move |inner: In| {
            let out = inner_layer.layer(inner);
            BoxService::new(out)
        });

        Self {
            boxed: Arc::new(layer),
        }
    }
}

stack                        0 allocations / 1000 calls
stack.boxed()                1000 allocations / 1000 calls
stack.boxed_clone()          1000 allocations / 1000 calls