Crate virtue

Virtue, a sinless derive macro helper

Goals

• Zero dependencies, so fast compile times
• No other dependencies needed
• Declarative code generation
• As much typesystem checking as possible
• Build for modern rust: 1.57 and up
• Build with popular crates in mind:
  • bincode
• Will always respect semver. Minor releases will never have:
  • Breaking API changes
  • MSRV changes

Example

First, add this to your Cargo.toml:

[lib]
proc-macro = true

Then instantiate your project with:

use virtue::prelude::*;

#[proc_macro_derive(RetHi)] // change this to change your #[derive(...)] name
pub fn derive_ret_hi(input: TokenStream) -> TokenStream {
    derive_ret_hi_inner(input).unwrap_or_else(|error| error.into_token_stream())
}

fn derive_ret_hi_inner(input: TokenStream) -> Result<TokenStream> {
    let parse = Parse::new(input)?;
    let (mut generator, _attributes, _body) = parse.into_generator();
    generator
        .generate_impl()
        .generate_fn("hi")
        .with_self_arg(FnSelfArg::RefSelf)
        .with_return_type("&'static str")
        .body(|body| {
            body.lit_str("hi");
            Ok(())
        })?;
    generator.finish()
}

You can invoke this with

#[derive(RetHi)]
struct Foo;

fn main() {
    println!("{}", Foo.hi());
}

The generated code is:

impl Foo {
    fn hi(&self) -> &'static str {
        "hi"
    }
}

Modules

generate

Code to help generate functions.

parse

Module for parsing code. The main enum is Parse.

prelude

Useful includes

utils

Utility functions

Enums

Error

Errors that can occur while parsing or generator your derive macro.

Type Aliases

Result

Result alias for virtue’s errors