Add wrap_fn, closes #16

examples/wrapping.rs

@@ -0,0 +1,31 @@
+#![deny(warnings)]
+use warp::Filter;
+
+fn hello_wrapper<F, T>(
+    filter: F,
+) -> impl Filter<Extract = (&'static str,)> + Clone + Send + Sync + 'static
+where
+    F: Filter<Extract = (T,), Error = std::convert::Infallible> + Clone + Send + Sync + 'static,
+    F::Extract: warp::Reply,
+{
+    warp::any()
+        .map(|| {
+            println!("before filter");
+        })
+        .untuple_one()
+        .and(filter)
+        .map(|_arg| "wrapped hello world")
+}
+
+#[tokio::main]
+async fn main() {
+    // Match any request and return hello world!
+    let routes = warp::any()
+        .map(|| "hello world")
+        .boxed()
+        .recover(|_err| async { Ok("recovered") })
+        // wrap the filter with hello_wrapper
+        .with(warp::wrap_fn(hello_wrapper));
+
+    warp::serve(routes).run(([127, 0, 0, 1], 3030)).await;
+}

src/filter/mod.rs

@@ -30,6 +30,7 @@ use self::or_else::OrElse;
 use self::recover::Recover;
 use self::unify::Unify;
 use self::untuple_one::UntupleOne;
+pub use self::wrap::wrap_fn;
 pub(crate) use self::wrap::{Wrap, WrapSealed};
 
 // A crate-private base trait, allowing the actual `filter` method to change

src/filter/wrap.rs

@@ -25,3 +25,31 @@ where
     F: Filter,
 {
 }
+
+/// Function that receives a filter to be combined with pre and after filters
+pub fn wrap_fn<F, T, U>(func: F) -> WrapFn<F>
+where
+    F: Fn(T) -> U,
+    T: Filter,
+    U: Filter,
+{
+    WrapFn { func }
+}
+
+#[derive(Debug)]
+pub struct WrapFn<F> {
+    func: F,
+}
+
+impl<F, T, U> WrapSealed<T> for WrapFn<F>
+where
+    F: Fn(T) -> U,
+    T: Filter,
+    U: Filter,
+{
+    type Wrapped = U;
+
+    fn wrap(&self, filter: T) -> Self::Wrapped {
+        (self.func)(filter)
+    }
+}

src/lib.rs

@@ -149,6 +149,7 @@ pub use self::filters::{
     trace::trace,
 };
 // ws() function
+pub use self::filter::wrap_fn;
 #[cfg(feature = "websocket")]
 #[doc(hidden)]
 pub use self::filters::ws::ws;