How to enforce that a type implements a trait at compile time?

by

First, solve the problem without macros. One solution is to create undocumented private functions that will fail compilation if your conditions aren’t met:

struct MyType {
    age: i32,
    name: String,
}

const _: () = {
    fn assert_send<T: Send>() {}
    fn assert_sync<T: Sync>() {}

    // RFC 2056
    fn assert_all() {
        assert_send::<MyType>();
        assert_sync::<MyType>();
    }
};

Then, modify the simple solution to use macros:

macro_rules! example {
    ($name:ident, $field:ty) => {
        struct $name {
            x: $field,
        }

        const _: () = {
            fn assert_add<T: std::ops::Add<$field, Output = $field>>() {}
            fn assert_mul<T: std::ops::Mul<$field, Output = $field>>() {}

            // RFC 2056
            fn assert_all() {
                assert_add::<$field>();
                assert_mul::<$field>();
            }
        };
    };
}

example!(Moo, u8);
example!(Woof, bool);

In both cases, we create a dummy const value to scope the functions and their calls, avoiding name clashes.

I would then trust in the optimizer to remove the code at compile time, so I wouldn’t expect any additional bloat.

Major thanks to Chris Morgan for providing a better version of this that supports non-object-safe traits.

It’s worth highlighting RFC 2056 which will allow for “trivial” constraints in where clauses. Once implemented, clauses like this would be accepted:

impl Foo for Bar
where 
    i32: Iterator,
{}

This exact behavior has changed multiple times during Rust’s history and RFC 2056 pins it down. To keep the behavior we want in this case, we need to call the assertion functions from another function which has no constraints (and thus must always be true).

More Related Contents:

  1. Is it possible to declare variables procedurally using Rust macros?
  2. Can a Rust macro create new identifiers?
  3. Generating documentation in macros
  4. How to prefix/suffix identifiers within a macro? [duplicate]
  5. How do I match the type of an expression in a Rust macro?
  6. Is there a way to count with macros?
  7. Can macros match against constant arguments instead of literals?
  8. How to allow optional trailing commas in macros?
  9. How to embed a Rust macro variable into documentation?
  10. What makes Lisp macros so special?
  11. Macros in Swift?
  12. How can I generate unique values in the C preprocessor?
  13. Variadic recursive preprocessor macros – is it possible?
  14. How do I show the value of a #define at compile-time?
  15. How to write macro for Notepad++?
  16. How to auto execute a macro when opening a Powerpoint presentation?
  17. Mathematica: Unevaluated vs Defer vs Hold vs HoldForm vs HoldAllComplete vs etc etc
  18. Can I convert a string to enum without macros in Rust?
  19. Is there a way to get the field names of a struct in a macro?
  20. Why does my string not match when reading user input from stdin?
  21. Can I do type introspection with trait objects and then downcast it?
  22. How can I perform parallel asynchronous HTTP GET requests with reqwest?
  23. How can I have a collection of objects that differ by their associated type?
  24. Why doesn’t println! work in Rust unit tests?
  25. What’s the easiest way to use reify (get an AST of) an expression in Scala?
  26. Why do I get “type annotations needed” when using Iterator::collect?
  27. How to idiomatically convert between u32 and usize?
  28. Performance comparison of a Vec and a boxed slice
  29. How can I iterate on an Option?
  30. Comparing every element in a vector with the next one

Leave a Comment