actix / actix-derive Goto Github PK

View Code? Open in Web Editor NEW

39.0 6.0 38.0 49 KB

[ARCHIVED] development moved into main actix repo

Home Page: https://github.com/actix/actix

License: Apache License 2.0

Rust 100.00%

actix rust rust-library

actix-derive's Introduction

actix-derive

Actix is a rust actor framework.

Features

actix-derive adds support for Rust Custom Derive / Macros 1.1 to actix

Usage

use actix_derive::{Message, MessageResponse};

#[derive(MessageResponse)]
struct Added(usize);

#[derive(Message)]
#[rtype(result = "Added")]
struct Sum(usize, usize);

fn main() {}

This code expands into following code:

use actix::{Actor, Context, Handler, System};
use actix_derive::{Message, MessageResponse};

#[derive(MessageResponse)]
struct Added(usize);

#[derive(Message)]
#[rtype(result = "Added")]
struct Sum(usize, usize);

#[derive(Default)]
struct Adder;

impl Actor for Adder {
    type Context = Context<Self>;
}

impl Handler<Sum> for Adder {
    type Result = <Sum as actix::Message>::Result;
    fn handle(&mut self, msg: Sum, _: &mut Self::Context) -> Added {
        Added(msg.0 + msg.1)
    }
}

fn main() {}

License

This project is licensed under either of

Apache License, Version 2.0, (LICENSE-APACHE or https://www.apache.org/licenses/LICENSE-2.0)
MIT license (LICENSE-MIT or https://opensource.org/licenses/MIT)

at your option.

actix-derive's People

Contributors

Stargazers

Watchers

actix-derive's Issues

naming

i don't like Message for response, let's rename it to response.
also, i dont think we need MessageResult or MessageError

#[derive(Actor)]

Should we add a custom derive for the Actor trait?

#[derive(Actor)]
struct SumActor;

Which expands to:

impl Actor for SumActor {
    type Context = Context<Self>;
}

Depends on old actix for testing

@JohnTitor would be nice if you could upgrade dev-deps to current actix :)

I think it would make sense to add a MessageResponse custom derive, along the lines of the SIMPLE_RESULT macro. I know there's the MessageResult helper, but I prefer not having to wrap my result types.

I've read through the issues #1 and #2, and understand the reluctance to add new macros if they only save a small amount of code, but in this case (as shown by the existence of SIMPLE_RESULT ;-)), I think the boilerplate saved is enough to justify a custom derive.

Using `()` as the default Message result type

What about using () as the default result type? Currently I need to use a lot of boilerplate code with the rtype attribute, like this:

#[derive(Message, Debug)]
#[rtype(result = "()")]
pub struct SomeMessage {
    pub name: String,
}

More advanced macros

I implemented a #[handler] macro to allow you to tag functions as a handler for a type, and generate the necessary code implementing the Handler trait for the type.
Is this useful?

It'd require Nightly because it depends on feature(proc_macro), but that can be feature-gated, so the custom derives would still work on Stable.

#[handler]
impl SumActor {
    #[handle(Sum)]
    fn sum(&mut self, message: Sum, _: &mut Context<Self>) -> Response<Self, Sum> {
        println!("{}", message.0 + message.1);
        Self::reply(message.0 + message.1)
    }
}

Which would expand to:

impl SumActor {
    fn sum(&mut self, message: Sum, _: &mut Context<Self>) -> Response<Self, Sum> {
        println!("{}", message.0 + message.1);
        Self::reply(message.0 + message.1)
    }
}

impl Handler<Sum> for SumActor {
    fn handle(&mut self, message: Sum, context: &mut Context<Self>) -> Response<Self, Sum> {
        self.sum(message, context)
    }
}

Give publish permission to ActixDeriveAdmins

@callym i need you to give publish permission ActixDeriveAdmins for actix_derive crate and add me to owners. my email is [email protected]

Way of specifying none in derive message

Hi,

Is there a way of using this lib to derive a message which has an empty Item as well as an empty Error?

The way I'm currently doing it is

type none = ();

#[derive(Message)]
#[Message(none, none)]
struct Wake;

Thanks in advance