Conditionally Use ProxyConnector or HTTPConnector

I want to make an HTTP request using the hyper crate. If the user has provided the proxy settings, the request must go through the proxy, otherwise the request will be sent without the proxy.

Here is my approach: -


use hyper::Client;
use hyper::client::HttpConnector;
use hyper_proxy::Intercept;
use hyper_proxy::Proxy;
use hyper_proxy::ProxyConnector;

fn main(){
    let proxy_url_opt:Option<String> = Some(String::from("http://ip-address:port"))

    let client = match proxy_url_opt { // Line 68
        Some(proxy_url)=>{
            let uri_str = &proxy_url;
            let proxy_uri = uri_str.parse().unwrap();
            let mut proxy = Proxy::new(Intercept::All, proxy_uri);

            let connector = HttpConnector::new();
            let proxy_connector = ProxyConnector::from_proxy(connector, proxy).unwrap();

            let client = Client::builder().build(proxy_connector);

            client // Line 80
        }
        None=>{
            Client::new() // Line 83
        }
    };   

    // while condition {

      let response = client.request(request).await?; 

    // }
}

But this code giving me and error.

match arms have incompatible types

expected struct `hyper_proxy::ProxyConnector`, found struct `hyper::client::connect::http::HttpConnector`

note: expected type `hyper::client::Client<hyper_proxy::ProxyConnector<hyper::client::connect::http::HttpConnector>, _>`
       found struct `hyper::client::Client<hyper::client::connect::http::HttpConnector, hyper::body::body::Body>`rustc(E0308)
main.rs(68, 18): `match` arms have incompatible types
main.rs(80, 13): this is found to be of type `hyper::client::Client<hyper_proxy::ProxyConnector<hyper::client::connect::http::HttpConnector>, _>`
main.rs(83, 13): expected struct `hyper_proxy::ProxyConnector`, found struct `hyper::client::connect::http::HttpConnector`

What is the rust way to solve this?

Solution

With the support of yorodm I have solved it using an enum. This is how I solved it:-

enum Client {
    Proxy(HyperClient<ProxyConnector<HttpConnector>>),
    Http(HyperClient<HttpConnector>)
}

impl Client {
    pub fn request(&self, mut req: Request<Body>) -> ResponseFuture{
        match self {
            Client::Proxy(client)=>{
                client.request(req)
            }
            Client::Http(client)=>{
                client.request(req)
            }
        }
    }
}