main.rs

extern crate languageserver_types as ls_types;

pub trait Request {
    type Param;
    type Result;
    // Has to be a method as associated constants are unstable
    fn method(&self) -> &'static str;
    fn id(&self) -> &ls_types::NumberOrString;
    fn params(&self) -> &Self::Param;
}

struct RequestStruct<Params> {
    id: ls_types::NumberOrString,
    params: Params
}

type ShowMessageRequest = RequestStruct<ls_types::ShowMessageRequestParams>;

impl Request for ShowMessageRequest {
    type Param = ls_types::ShowMessageRequestParams;
    type Result = ls_types::MessageActionItem;
    fn method(&self) -> &'static str { ls_types::REQUEST__ShowMessageRequest }
    fn id(&self) -> &ls_types::NumberOrString { &self.id }
    fn params(&self) -> &Self::Param { &self.params }
}

// Example separated request handling logic
trait RequestHandler<R: Request> {
    fn handle(&self, request: R) -> R::Result;
}

struct MyHandler;

impl RequestHandler<ShowMessageRequest> for MyHandler {
    fn handle(&self, request: ShowMessageRequest) -> ls_types::MessageActionItem {
        eprintln!("Handling ShowMessageRequest");
        ls_types::MessageActionItem { title: String::from("dummy") }
    }
}


fn main() {
    let handler = MyHandler;
    let request = ShowMessageRequest {
        id: ls_types::NumberOrString::Number(1),
        params: ls_types::ShowMessageRequestParams {
            typ: ls_types::MessageType::Info,
            message: String::from("Hello!"),
            actions: None
        }
    };

    handler.handle(request);

    type MyRequest = RequestStruct<String>;
    let request = MyRequest {
        id: ls_types::NumberOrString::Number(1),
        params: String::from("dummy")
    };
    // handler.handle(request); //ERROR: trait bound is not satisfied
}