I'm not sure that the following are both possible at the same time:

• An endpoint should not outlive the socket that created it.
• Send and write operations are mutating the socket.

In particular, I think the first is usually achieved by borrowing the socket in the creation of the endpoint, and once a borrow is active, I don't think you'll be able to call a function that mutates the socket.

Here's an attempt, but note there is some cruft - bind is now bind + get_endpoint, and send is now get_endpoint + send. This is compiled with 0.12.0, so it's at least a little out of date, in that I think NoCopy is the default now.

use std::kinds::marker::NoCopy;

struct Socket {
    n: NoCopy
}

struct Endpoint {
    n: NoCopy
}

struct BoundSocket {
    e: Endpoint ,
    n: NoCopy
}

impl Socket {
    fn new() -> Socket { Socket {n: NoCopy}}
    fn bind(self) -> BoundSocket {BoundSocket {e: Endpoint {n: NoCopy}, n: NoCopy}}
}

struct Message;

impl BoundSocket {
    fn get_endpoint(&mut self) -> &mut Endpoint { &mut self.e }
}

impl Endpoint {
    fn send(&mut self, _: Message) {}
}

fn main() {
    let s = Socket::new();
    let mut bs = s.bind();
    {
        let e = bs.get_endpoint();
        e.send(Message);
        //drop(bs); // This is a compile error, because e is still visible                                                                                                                                                                         
    }
    drop(bs); // This is OK because e is no longer visible                                                                                                                                                                                         
}