Split state off from Request

Author: yoshuawuyts

README.md

@@ -80,7 +80,7 @@ async fn main() -> tide::Result<()> {
     Ok(())
 }
 
-async fn order_shoes(mut req: Request<()>) -> tide::Result {
+async fn order_shoes(mut req: Request, _state: ()) -> tide::Result {
     let Animal { name, legs } = req.body_json().await?;
     Ok(format!("Hello, {}! I've put in an order for {} shoes", name, legs).into())
 }

examples/catflap.rs

@@ -4,7 +4,7 @@ async fn main() -> Result<(), std::io::Error> {
     use std::{env, net::TcpListener, os::unix::io::FromRawFd};
     tide::log::start();
     let mut app = tide::new();
-    app.at("/").get(|_| async { Ok(CHANGE_THIS_TEXT) });
+    app.at("/").get(|_, _| async { Ok(CHANGE_THIS_TEXT) });
 
     const CHANGE_THIS_TEXT: &str = "hello world!";
 

examples/chunked.rs

@@ -4,7 +4,7 @@ use tide::Body;
 async fn main() -> Result<(), std::io::Error> {
     tide::log::start();
     let mut app = tide::new();
-    app.at("/").get(|_| async {
+    app.at("/").get(|_, _| async {
         // File sends are chunked by default.
         Ok(Body::from_file(file!()).await?)
     });

examples/concurrent_listeners.rs

@@ -5,10 +5,10 @@ async fn main() -> Result<(), std::io::Error> {
     tide::log::start();
     let mut app = tide::new();
 
-    app.at("/").get(|request: Request<_>| async move {
+    app.at("/").get(|req: Request, _| async move {
         Ok(format!(
             "Hi! You reached this app through: {}",
-            request.local_addr().unwrap_or("an unknown port")
+            req.local_addr().unwrap_or("an unknown port")
         ))
     });
 

examples/cookies.rs

@@ -3,17 +3,17 @@ use tide::{Request, Response, StatusCode};
 
 /// Tide will use the the `Cookies`'s `Extract` implementation to build this parameter.
 ///
-async fn retrieve_cookie(req: Request<()>) -> tide::Result<String> {
+async fn retrieve_cookie(req: Request, _state: ()) -> tide::Result<String> {
     Ok(format!("hello cookies: {:?}", req.cookie("hello").unwrap()))
 }
 
-async fn insert_cookie(_req: Request<()>) -> tide::Result {
+async fn insert_cookie(_req: Request, _state: ()) -> tide::Result {
     let mut res = Response::new(StatusCode::Ok);
     res.insert_cookie(Cookie::new("hello", "world"));
     Ok(res)
 }
 
-async fn remove_cookie(_req: Request<()>) -> tide::Result {
+async fn remove_cookie(_req: Request, _state: ()) -> tide::Result {
     let mut res = Response::new(StatusCode::Ok);
     res.remove_cookie(Cookie::named("hello"));
     Ok(res)

examples/error_handling.rs

@@ -1,7 +1,7 @@
 use std::io::ErrorKind;
 
 use tide::utils::After;
-use tide::{Body, Request, Response, Result, StatusCode};
+use tide::{Body, Response, Result, StatusCode};
 
 #[async_std::main]
 async fn main() -> Result<()> {
@@ -22,7 +22,7 @@ async fn main() -> Result<()> {
     }));
 
     app.at("/")
-        .get(|_req: Request<_>| async { Ok(Body::from_file("./does-not-exist").await?) });
+        .get(|_, _| async { Ok(Body::from_file("./does-not-exist").await?) });
 
     app.listen("127.0.0.1:8080").await?;
 

examples/fib.rs

@@ -8,7 +8,7 @@ fn fib(n: usize) -> usize {
     }
 }
 
-async fn fibsum(req: Request<()>) -> tide::Result<String> {
+async fn fibsum(req: Request, _state: ()) -> tide::Result<String> {
     use std::time::Instant;
     let n: usize = req.param("n")?.parse().unwrap_or(0);
     // Start a stopwatch

examples/graphql.rs

@@ -74,9 +74,9 @@ lazy_static! {
     static ref SCHEMA: Schema = Schema::new(QueryRoot {}, MutationRoot {});
 }
 
-async fn handle_graphql(mut request: Request<State>) -> tide::Result {
+async fn handle_graphql(mut request: Request, state: State) -> tide::Result {
     let query: GraphQLRequest = request.body_json().await?;
-    let response = query.execute(&SCHEMA, request.state());
+    let response = query.execute(&SCHEMA, &state);
     let status = if response.is_ok() {
         StatusCode::Ok
     } else {
@@ -88,7 +88,7 @@ async fn handle_graphql(mut request: Request<State>) -> tide::Result {
         .build())
 }
 
-async fn handle_graphiql(_: Request<State>) -> tide::Result<impl Into<Response>> {
+async fn handle_graphiql(_: Request, _state: State) -> tide::Result<impl Into<Response>> {
     Ok(Response::builder(200)
         .body(graphiql::graphiql_source("/graphql"))
         .content_type(mime::HTML))

examples/hello.rs

@@ -2,7 +2,7 @@
 async fn main() -> Result<(), std::io::Error> {
     tide::log::start();
     let mut app = tide::new();
-    app.at("/").get(|_| async { Ok("Hello, world!") });
+    app.at("/").get(|_, _| async { Ok("Hello, world!") });
     app.listen("127.0.0.1:8080").await?;
     Ok(())
 }

examples/json.rs

@@ -12,7 +12,7 @@ async fn main() -> tide::Result<()> {
     tide::log::start();
     let mut app = tide::new();
 
-    app.at("/submit").post(|mut req: Request<()>| async move {
+    app.at("/submit").post(|mut req: Request, _| async move {
         let cat: Cat = req.body_json().await?;
         println!("cat name: {}", cat.name);
 
@@ -23,7 +23,7 @@ async fn main() -> tide::Result<()> {
         Ok(Body::from_json(&cat)?)
     });
 
-    app.at("/animals").get(|_| async {
+    app.at("/animals").get(|_, _| async {
         Ok(json!({
             "meta": { "count": 2 },
             "animals": [