ghost-lite

Crates.ioghost-lite
lib.rsghost-lite
version0.1.2
sourcesrc
created_at2023-01-13 07:48:17.621743
updated_at2023-01-13 09:37:04.361003
descriptioncustom PhantomData types
homepagehttps://github.com/frender-rs/ghost-lite
repositoryhttps://github.com/frender-rs/ghost-lite
max_upload_size
id757752
size23,780
(EqualMa)

documentation

https://docs.rs/ghost-lite

README

::ghost_lite

A lightweight implementation of ::ghost with macro_rules.

Usage

use ghost_lite::ghost;

ghost! {
    /// `ghost` macro defines a custom `PhantomData`,
    /// which can be used as both a type and a value.
    pub struct MyPhantomData<T>
}

fn main() {
    let _: MyPhantomData<i32> = MyPhantomData;
    let _ = MyPhantomData::<&str>;
}

Caveats

  1. derive should be in inner attributes (#![derive(...)]). Only the following traits are supported.

    ghost_lite::ghost! {
        #![derive(Clone, Copy, Default, Hash, PartialOrd, Ord, PartialEq, Eq, Debug)]
        pub struct MyPhantom<T>
    }
    
    /// `String` is not copy, but `MyPhantom` is always Copy, like `PhantomData`
    fn test() -> impl Copy {
        MyPhantom::<String>
    }
    # fn main() {}
    

    derive in outer attributes will be directly prepended to the generated enum, which works like normal derive macros.

    ghost_lite::ghost! {
        /// MyPhantom is `Clone` and `Copy` only if T is `Clone` and `Copy`
        #[derive(Clone, Copy)]
        pub struct MyPhantom<T>
    }
    
    /// `String` is not copy, so `MyPhantom` is not Copy
    fn test() -> impl Copy {
        MyPhantom::<String>
    }
    # fn main() {}
    
  2. The implementation relies on a mod name. To define multiple custom PhantomData types in the same module, you must provide custom mod name with #![mod_value_namespace = my_phantom_data].

    ghost_lite::ghost! {
        struct MyPhantomData1<T>
    }
    
    ghost_lite::ghost! {
        struct MyPhantomData2<T>
    }
    # fn main() {}
    
    ghost_lite::ghost! {
        struct MyPhantomData1<T>
    }
    
    ghost_lite::ghost! {
        #![mod_value_namespace = my_phantom_data_2]
        struct MyPhantomData2<T>
    }
    # fn main() {}
    
  3. Move type generic bounds to where clause if ghost! reports error.

    Parsing tokens is limited with macro_rules, so complex type bounds are not supported.

    For example:

    ghost_lite::ghost! {
        struct MyPhantomData<T: Clone + PartialEq>
    }
    # fn main() {}
    
    ghost_lite::ghost! {
        struct MyPhantomData<T> where T: Clone + PartialEq
    }
    # fn main() {}
    
  4. Please don't add a trailing semicolon ;.

    ghost_lite::ghost! {
        struct MyPhantomData<T>;
    }
    # fn main() {}
    
    ghost_lite::ghost! {
        struct MyPhantomData<T>
    }
    # fn main() {}
    
Commit count: 9

cargo fmt