Struggling with Rust to figure out the right types for a function signature
Share on Mastodon
I am loving writing code in Rust. So many things about the language and its ecosystem feel so right*.
* For example: ownership of objects, expressive type system, compile to native, offline API docs, immutability, high quality libraries.
One of the things I like about it is that I don’t feel like I need to use an IDE, so I can happily code in Vim with no clever plugins.
One thing an IDE might give me would be an “extract function” refactoring. In most languages I am happy to do that manually, because I can let the compile errors guide me on what my function should look like.
However, in Rust I sometimes find it’s hard to find the right signature for a function I want to extract, and I am struggling to persuade the compiler to help me.
Here is an example from my new listsync project, in listsync-client-rust.rs:
use actix_web::{middleware, App, HttpServer};
use listsync_client_rust;
// ...
#[actix_rt::main]
async fn main() -> std::io::Result<()> {
//...
HttpServer::new(|| {
App::new()
.wrap(listsync_client_rust::cookie_session::new_session())
.wrap(middleware::Logger::default())
.configure(listsync_client_rust::config)
})
//...
I would like to extract the code highlighted above, the creation of an App, into a separate function, like this:
fn new_app() -> ??? { App::new() .wrap(listsync_client_rust::cookie_session::new_session()) .wrap(middleware::Logger::default()) .configure(listsync_client_rust::config) } //... HttpServer::new(|| { new_app() })
Simple, right? To find out what the return type of the function should be, I can just make a bad guess, and get the compiler to tell me what I did wrong. In this case, I will guess by changing the question marks above into i32, and run cargo test. I get quite a few errors, one of which is:
error[E0277]: the trait bound `i32: actix_service::IntoServiceFactory<_>` is not satisfied
--> src/bin/listsync-client-rust.rs:27:5
|
27 | / HttpServer::new(|| {
28 | | new_app()
29 | | })
| |______^ the trait `actix_service::IntoServiceFactory<_>` is not implemented for `i32`
|
= note: required by `actix_web::server::HttpServer`
So the first problem I see is that the error message I am seeing is about the later code, and there are no errors about my new function.
I obviously went a little too fast. Let’s change the HttpServer::new code back to how it was before, and only make a new function new_app. Now I get an error that should help me:
error[E0308]: mismatched types --> src/bin/listsync-client-rust.rs:12:5 | 11 | fn new_app() -> i32 { | --- expected `i32` because of return type 12 | / App::new() 13 | | .wrap(listsync_client_rust::cookie_session::new_session()) 14 | | .wrap(middleware::Logger::default()) 15 | | .configure(listsync_client_rust::config) | |________________________________________________^ expected i32, found struct `actix_web::app::App` | = note: expected type `i32` found type `actix_web::app::App<impl actix_service::ServiceFactory, actix_web::middleware::logger::StreamLog<actix_http::body::Body>>`
So the compiler has told us what type we are returning! Let’s copy that into the type signature of the function:
use actix_service::ServiceFactory;
use actix_http::body::Body;
// ...
fn new_app() -> App<impl ServiceFactory, middleware::logger::StreamLog<Body>> {
// ...
The first error I get from the compiler is a distraction:
error[E0432]: unresolved import `actix_service`
--> src/bin/listsync-client-rust.rs:1:5
|
1 | use actix_service::ServiceFactory;
| ^^^^^^^^^^^^^ use of undeclared type or module `actix_service`
I can fix it by adding actix-service = "1.0.5" to Cargo.toml. (I found the version by looking in Cargo.lock, since this dependency was already implicitly used – I just need to make it explicit if I am going to use it directly.)
Once I do that I get the next error:
error[E0603]: module `logger` is private
--> src/bin/listsync-client-rust.rs:13:54
|
13 | fn new_app() -> App<impl ServiceFactory, middleware::logger::StreamLog<Body>> {
| ^^^^^^
This leaves me a bit stuck: I can’t use StreamLog because it’s in a private module.
More importantly, it makes the point that I don’t actually want to be as specific as I am being: I don’t care what the exact type parameters for App are – I just want to return an App of some kind and have the compiler fill in the blanks. Ideally, if I change the body of new_app later, for example to add another wrap call that changes the type of App we are returning, I’d like to leave the return type the same and have it just work.
With that in mind, I took a look at the type that HttpServer::new takes in. Here is impl HttpServer:
impl<F, I, S, B> HttpServer<F, I, S, B> where
F: Fn() -> I + Send + Clone + 'static,
I: IntoServiceFactory<S>,
S: ServiceFactory<Config = AppConfig, Request = Request>,
S::Error: Into<Error> + 'static,
S::InitError: Debug,
S::Response: Into<Response<B>> + 'static,
<S::Service as Service>::Future: 'static,
B: MessageBody + 'static,
and HttpServer::new looks like:
pub fn new(factory: F) -> Self
So it takes in a function which actually makes the App, and the type of that function is F, which is a Fn which returns a I + Send + Clone + 'static. From the declaration of impl HttpServer we can see that the type of I depends on S and B, which have quite complex types. Let’s paste the whole thing in:
use actix_http::{Error, Request, Response};
use actix_service::IntoServiceFactory;
use actix_web::body::MessageBody;
use actix_web::dev::{AppConfig, Service};
use core::fmt::Debug;
// ...
fn new_app<I, S, B>() -> I
where
I: IntoServiceFactory<S> + Send + Clone + 'static,
S: ServiceFactory<Config = AppConfig, Request = Request>,
S::Error: Into<Error> + 'static,
S::InitError: Debug,
S::Response: Into<Response<B>> + 'static,
<S::Service as Service>::Future: 'static,
B: MessageBody + 'static,
{
App::new()
.wrap(listsync_client_rust::cookie_session::new_session())
.wrap(middleware::Logger::default())
.configure(listsync_client_rust::config)
}
Note that I had to modify I to include the extra requirements on the return type of F from the definition of HttpServer. (I think I did the right thing, but I’m not sure. If I just remove the + Send + Clone + 'static it seems to behave similarly.)
Now I get this error from the compiler:
error[E0308]: mismatched types
--> src/bin/listsync-client-rust.rs:27:5
|
17 | fn new_app<I, S, B>() -> I
| - expected `I` because of return type
...
27 | / App::new()
28 | | .wrap(listsync_client_rust::cookie_session::new_session())
29 | | .wrap(middleware::Logger::default())
30 | | .configure(listsync_client_rust::config)
| |________________________________________________^ expected type parameter, found struct `actix_web::app::App`
|
= note: expected type `I`
found type `actix_web::app::App<impl actix_service::ServiceFactory, actix_web::middleware::logger::StreamLog<actix_http::body::Body>>`
= help: type parameters must be constrained to match other types
= note: for more information, visit https://doc.rust-lang.org/book/ch10-02-traits.html#traits-as-parameters
The compiler really tries to help here, suggesting I read a chapter of the Rust Book, but even after reading it I could not figure out how to do what I am trying to do.
Can anyone help me?
Wouldn’t it be amazing if there were some way the compiler could give me easier-to-understand help to figure this out?
With thanks to https://manowar.social/@zatnosk , this GitHub issue might help people fighting this specific situation in actix: https://github.com/actix/actix-web/issues/853 , but doesn’t address my general question about extracting functions.
Hey Andy,
Ever found a good solution to this problem?
I was facing the same issue today (using actix-web, too) and I tried figuring out the correct types by looking at the compiler errors like you did here, but ultimately I gave up as well.
Instead I simply wrote a macro which instantiates the test app/service and that worked without having to figure out the exact type.
Maybe not the perfect solution, but good enough for now.
Kind regards,
Daniel
Hi Daniel, no – as you can see here https://gitlab.com/listsync/listsync-client-rust/-/blob/master/src/bin/listsync-client-rust.rs I just create the App inline.
Next time I’ll consider a macro though – thanks for the tip – although I agree it’s not very satisfactory.
Maybe this helps:
https://github.com/meilisearch/MeiliSearch/blob/main/meilisearch-http/src/lib.rs
+
https://github.com/meilisearch/MeiliSearch/blob/main/meilisearch-http/src/main.rs
There is a macro “create_app” in combination with anyhow.
I’m a total noob in rust. But to me it looked very similar to what you describe in your post.