the method oneshot exists for struct Filter<ServiceFn<{closure@...}>, _>, but its trait bounds were not satisfied

tower = { version = "=0.5.3", features = ["filter", "util"] }
tokio = { version = "=1.54.1", features = ["full"] }

use tower::filter::AsyncFilter;
use tower::{service_fn, BoxError, ServiceBuilder, ServiceExt};

async fn check(user: String) -> Result<String, BoxError> {
  if user == "mallory" { Err("banned".into()) } else { Ok(user) }
}

#[tokio::main(flavor = "current_thread")]
async fn main() {
  let echo = service_fn(|s: String| async move { Ok::<_, BoxError>(s) });
  let svc = ServiceBuilder::new()
    .layer(AsyncFilter::layer(check))
    .service(echo);
  println!("{:?}", svc.oneshot("alice".to_string()).await);
}

error[E0599]: the method `oneshot` exists for struct `Filter<ServiceFn<{closure@...}>, _>`, but its trait bounds were not satisfied
  --> examples/afl_infer.rs:14:24
   |
14 |   println!("{:?}", svc.oneshot("alice".to_string()).await);
   |                        ^^^^^^^ method cannot be called on `Filter<ServiceFn<{closure@...}>, _>` due to unsatisfied trait bounds
   |
   = note: the following trait bounds were not satisfied:
           `tower::filter::Filter<ServiceFn<{closure@examples/afl_infer.rs:10:25: 10:36}>, fn(String) -> impl std::future::Future<Output = Result<String, Box<(dyn std::error::Error + Send + Sync + 'static)>>> {check}>: Service<_>`
           which is required by `tower::filter::Filter<ServiceFn<{closure@examples/afl_infer.rs:10:25: 10:36}>, fn(String) -> impl std::future::Future<Output = Result<String, Box<(dyn std::error::Error + Send + Sync + 'static)>>> {check}>: ServiceExt<_>`

error[E0282]: type annotations needed
 --> examples/afl_only.rs:9:16
  |
9 |   let _layer = AsyncFilter::layer(check);
  |                ^^^^^^^^^^^^^^^^^^ cannot infer type of the type parameter `T` declared on the struct `AsyncFilter`
  |
help: consider specifying the generic arguments
  |
9 |   let _layer = AsyncFilter::<T, _>::layer(check);
  |                           ++++++++

    pub fn layer(predicate: U) -> FilterLayer<U> {
        FilterLayer::new(predicate)
    }

use tower::filter::AsyncFilterLayer;
use tower::{service_fn, BoxError, ServiceBuilder, ServiceExt};

async fn check(user: String) -> Result<String, BoxError> {
  if user == "mallory" { Err("banned".into()) } else { Ok(user) }
}

#[tokio::main(flavor = "current_thread")]
async fn main() {
  let echo = service_fn(|s: String| async move { Ok::<_, BoxError>(s) });

  let a = ServiceBuilder::new().layer(AsyncFilterLayer::new(check)).service(echo);
  let b = ServiceBuilder::new().filter_async(check).service(echo);
  for (name, svc) in [("AsyncFilterLayer::new", a), ("filter_async", b)] {
    for user in ["alice", "mallory"] {
      let r = svc.clone().oneshot(user.to_string()).await;
      println!("{name}({user:?}) = {:?}", r.map_err(|e| e.to_string()));
    }
  }
}

AsyncFilterLayer::new("alice") = Ok("alice")
AsyncFilterLayer::new("mallory") = Err("banned")
filter_async("alice") = Ok("alice")
filter_async("mallory") = Err("banned")

tower::filter::Filter
Ok("bob")