How to split an implementation of a trait into multiple files?

Question

I started working with ws, and I would like to split the Handler trait implementation into multiple files.

So I wrote this in one file, on_open.rs:

impl Handler for Client {
    fn on_open(&mut self, _: Handshake) -> Result<()> {
        println!("Socket opened");
        Ok(())
    }
}

And this in another file, on_message.rs:

impl Handler for Client {
    fn on_message(&mut self, msg: Message) -> Result<()> {
        println!("Server got message '{}'. ", msg);
        Ok(())
    }
}

While compiling it I got the following error:

error[E0119]: conflicting implementations of trait `ws::handler::Handler` for type `models::client::Client`:
 --> src\sockets\on_message.rs:9:1
  |
9 | impl Handler for Client {
  | ^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `models::client::Client`
  |
 ::: src\sockets\on_open.rs:8:1
  |
8 | impl Handler for Client {
  | ----------------------- first implementation here

I'd like to have the files to be separated so that each developer can work on a separate one. Is there a way to achieve this or am I forced to have the full trait implementation in a single file?

Answer 1

Thanks for @Peter's answer, I re-wrote my code as below, and it is working fine: socket.rs

use ws::Handler;
use crate::models::client::Client;
use ws::{Message, Request, Response, Result, CloseCode, Handshake};

impl Handler for Client {
    fn on_open(&mut self, hs: Handshake) -> Result<()> {
        self.handle_on_open(hs)
    }

    fn on_message(&mut self, msg: Message) -> Result<()> {
        self.handle_on_message(msg)
    }

    fn on_close(&mut self, code: CloseCode, reason: &str) {
        self.handle_on_close(code, reason)
    }

    fn on_request(&mut self, req: &Request) -> Result<(Response)> {
        self.handle_on_request(req)
    }
}

sockets/on_open.rs

use crate::models::client::Client;

use crate::CLIENTS;
use crate::models::{truck::Truck};
use ws::{Result, Handshake};

impl Client {
    pub fn handle_on_open(&mut self, _: Handshake) -> Result<()> {
        println!("socket is opened");
        Ok(())
    }
}

Answer 2

Although you can have multiple impl blocks for the same object, you can't have two which are exactly the same, hence the error of conflicting implementations indicated by E0119:

Since a trait cannot be implemented multiple times, this is an error.

(If the trait could be specialised because it takes any number of generic type arguments the situation would be very much different because every specialisation would be a different impl block. However even then you wouldn't be able to have the same specialisation implemented more than once.)

If you would like to split the functionality into separate files, you could do that, but in a slightly different way than you originally thought. You could split the Client's impl block instead of the Handler implementation as the following minimal and compilable example demonstrates. (Try it in the playground!)

As you can see, the Handler trait is implemented for Client in one place, but all the implementations of Client are split into multiple files/modules and the Handler implementation is just referencing those:

mod handler
{
    pub type Result<T> = ::std::result::Result<T, HandlerError>;

    pub struct HandlerError;

    pub trait Handler
    {
        fn on_open(&mut self, h: usize) -> Result<()>;
        fn on_message(&mut self, m: bool) -> Result<()>;
    }
}

mod client
{
    use super::handler::{ self, Handler };

    struct Client
    {
        h: usize,
        m: bool,
    }

    impl Handler for Client
    {
        fn on_open(&mut self, h: usize) -> handler::Result<()>
        {
            self.handle_on_open(h)
        }

        fn on_message(&mut self, m: bool) -> handler::Result<()>
        {
            self.handle_on_message(m)
        }
    }

    mod open
    {
        use super::super::handler;
        use super::Client;

        impl Client
        {
            pub fn handle_on_open(&mut self, h: usize) -> handler::Result<()>
            {
                self.h = h;
                Ok(())
            }
        }
    }

    mod message
    {
        use super::super::handler;
        use super::Client;

        impl Client
        {
            pub fn handle_on_message(&mut self, m: bool) -> handler::Result<()>
            {
                self.m = m;
                Ok(())
            }
        }
    }
}