[−][src]Crate impls
Determine if a type implements a logical trait expression?.
This library defines impls!
, a macro? that
returns a bool
indicating whether a type implements a boolean-like
expression over a set of traits?.
assert!(impls!(String: Clone & !Copy & Send & Sync));
See examples for detailed use cases.
Index
Usage
This crate is available on crates.io and can be used by adding the
following to your project's Cargo.toml
:
[dependencies]
impls = "1"
and this to your crate root (main.rs
or lib.rs
):
#[macro_use] extern crate impls;
When using Rust 2018 edition, the following import can help if
having #[macro_use]
is undesirable.
use impls::impls;
Vocabulary
This documentation uses jargon that may be new to inexperienced Rust users. This section exists to make these terms easier to understand. Feel free to skip this section if these are already familiar to you.
Macro
In Rust, macros are functions over the abstract syntax tree (AST). They map input tokens to output tokens by performing some operation over them through a set of rules. Because of this, only their outputs are ever type-checked.
If you wish to learn about implementing macros, I recommend:
- The Little Book of Rust Macros
- "Macros" - The Rust Programming Language
- "Macros" - The Rust Reference
- "Macros By Example" - The Rust Reference
To use this crate, you do not need to know how macros are defined.
Trait
In Rust, traits are a way of defining a generalized property. They should be
thought of expressing what a type is capable of doing. For example: if a
type implements Into
for some type T
, then we know it can be converted
into T
by just calling the .into()
method on it.
If you wish to learn about traits in detail, I recommend:
Logical Trait Expression
In this crate, traits should be thought of as bool
s where the condition
is whether the given type implements the trait or not.
An expression can be formed from these trait operations:
-
And (
&
): also known as logical disjunction, this returnstrue
if both operands aretrue
. This is usually defined in Rust via theBitAnd
trait. -
Or (
|
): also known as logical conjunction, this returnstrue
if either of two operands istrue
. This is usually defined in Rust via theBitOr
trait. -
Exclusive-or (
^
): also known as exclusive disjunction, this returnstrue
if only one of two operands istrue
. This is usually defined in Rust via theBitXor
trait. -
Not (
!
): a negation that returnsfalse
if the operand istrue
, ortrue
if the operand isfalse
. This is usually defined in Rust via theNot
trait.
See "Precedence and Nesting" for information about the order in which these operations are performed.
Examples
This macro works in every type context. See below for use cases.
Constant Evaluation
Because types are compile-time constructs, the result of this macro can be
used as a const
value:
const IMPLS: bool = impls!(u8: From<u32>);
Using static_assertions
, we can fail to compile if the trait expression
evaluates to false
:
const_assert!(impls!(*const u8: Send | Sync));
Precedence and Nesting
Trait operations abide by Rust's expression precedence. To define a custom order of operations (e.g. left-to-right), simply nest the expressions with parentheses.
let pre = impls!(u64: From<u8> | From<u16> ^ From<u32> & From<u64>); let ltr = impls!(u64: ((From<u8> | From<u16>) ^ From<u32>) & From<u64>); assert_eq!(pre, true | true ^ true & true); assert_ne!(pre, ltr);
Mutual Exclusion
Because exclusive-or (^
) is a trait operation, we can check that a type
implements one of two traits, but not both:
struct T; trait Foo {} trait Bar {} impl Foo for T {} assert!(impls!(T: Foo ^ Bar));
Reference Types
Something that's surprising to many Rust users is that &mut T
does not
implement Copy
nor Clone
:
assert!(impls!(&mut u32: !Copy & !Clone));
Surely you're thinking now that this macro must be broken, because you've
been able to reuse &mut T
throughout your lifetime with Rust. This works
because, in certain contexts, the compiler silently adds "re-borrows"
(&mut *ref
) with a shorter lifetime and shadows the original. In reality,
&mut T
is a move-only type.
Unsized Types
There's a variety of types in Rust that don't implement Sized
:
// Slices store their size with their pointer. assert!(impls!(str: !Sized)); assert!(impls!([u8]: !Sized)); // Trait objects store their size in a vtable. trait Foo {} assert!(impls!(dyn Foo: !Sized)); // Wrappers around unsized types are also unsized themselves. struct Bar([u8]); assert!(impls!(Bar: !Sized));
Generic Types
When called from a generic function, the returned value is based on the constraints of the generic type:
use std::cell::Cell; struct Value<T> { // ... } impl<T: Send> Value<T> { fn do_stuff() { assert!(impls!(Cell<T>: Send)); // ... } }
Keep in mind that this can result in false negatives:
const fn is_copy<T>() -> bool { impls!(T: Copy) } assert_ne!(is_copy::<u32>(), impls!(u32: Copy));
Lifetimes
Traits with lifetimes are also supported:
trait Ref<'a> {} impl<'a, T: ?Sized> Ref<'a> for &'a T {} impl<'a, T: ?Sized> Ref<'a> for &'a mut T {} assert!(impls!(&'static str: Ref<'static>)); assert!(impls!(&'static mut [u8]: Ref<'static>)); assert!(impls!(String: !Ref<'static>));
Authors
-
Nikolai Vazquez (GitHub: @nvzqz, Twitter: @NikolaiVazquez)
Implemented the
impls!
macro with support for all logical operators and without the limitations of the initialdoes_impl!
macro by Nadrieril. -
Nadrieril Feneanar (GitHub: @Nadrieril)
Implemented the initial
does_impl!
macro in nvzqz/static-assertions-rs#28 upon which this crate was originally based.
License
This project is released under either:
at your choosing.
Macros
impls | Returns |