ffe8873ae7
The concrete Iterator type for all implementations of
IntoEnumIterator is guaranteed to implement these traits, because
the only implementor is the `#[derive(EnumIter)]` macro, which
emits an impl for each for the generated {EnumType}Iter struct.
However, when using IntoEnumIterator as a generic constraint, the
concrete type is not known, so the impl of these traits cannot be
inferred by the type checker with out additional help.
Here are some examples, using Itertools::cartesian_product() as
the motivator, because it requires `Iterator + Clone`:
// We know this function will work, but it fails to type check
// without these additional trait bounds on IntoEnumIterator.
pub fn example_broken<T: Clone + IntoEnumIterator, U: Clone + IntoEnumIterator>(
) -> impl Iterator<Item = (T, U)> + Clone {
T::iter().cartesian_product(U::iter())
}
// It's possible to add where constraints at the use point to
// workaround the issue, without this change.
// This version will typecheck.
pub fn example_workaround<T: Clone + IntoEnumIterator, U: Clone + IntoEnumIterator>(
) -> impl Iterator<Item = (T, U)>
where
<T as IntoEnumIterator>::Iterator: Clone,
<U as IntoEnumIterator>::Iterator: Clone,
{
T::iter().cartesian_product(U::iter())
}
|
||
|---|---|---|
| .devcontainer | ||
| strum | ||
| strum_macros | ||
| strum_nostd_tests | ||
| strum_tests | ||
| .clippy.toml | ||
| .gitignore | ||
| .travis.yml | ||
| appveyor.yml | ||
| Cargo.toml | ||
| CHANGELOG.md | ||
| LICENSE | ||
| README.md | ||
| travis.sh | ||
Strum
Strum is a set of macros and traits for working with enums and strings easier in Rust.
Compatibility
Strum is currently compatible with versions of rustc >= 1.56.1. Pull Requests that improve compatibility with older versions are welcome. The project goal is to support a rust version for at least 2 years after release and even longer is preferred since this project changes slowly.
Including Strum in Your Project
Import strum and strum_macros into your project by adding the following lines to your Cargo.toml. Strum_macros contains the macros needed to derive all the traits in Strum.
[dependencies]
strum = "0.25"
strum_macros = "0.25"
# You can also use the "derive" feature, and import the macros directly from "strum"
# strum = { version = "0.25", features = ["derive"] }
Strum Macros
Strum has implemented the following macros:
| Macro | Description |
|---|---|
| EnumString | Converts strings to enum variants based on their name. |
| Display | Converts enum variants to strings |
| FromRepr | Convert from an integer to an enum. |
| AsRefStr | Implement AsRef<str> for MyEnum |
| IntoStaticStr | Implements From<MyEnum> for &'static str on an enum |
| EnumVariantNames | Adds an associated VARIANTS constant which is an array of discriminant names |
| EnumIter | Creates a new type that iterates of the variants of an enum. |
| EnumProperty | Add custom properties to enum variants. |
| EnumMessage | Add a verbose message to an enum variant. |
| EnumDiscriminants | Generate a new type with only the discriminant names. |
| EnumCount | Add a constant usize equal to the number of variants. |
Contributing
Thanks for your interest in contributing. The project is divided into 3 parts, the traits are in the
/strum folder. The procedural macros are in the /strum_macros folder, and the integration tests are
in /strum_tests. If you are adding additional features to strum or strum_macros, you should make sure
to run the tests and add new integration tests to make sure the features work as expected.
Debugging
To see the generated code, set the STRUM_DEBUG environment variable before compiling your code.
STRUM_DEBUG=1 will dump all of the generated code for every type. STRUM_DEBUG=YourType will
only dump the code generated on a type named YourType.
Name
Strum is short for STRing enUM because it's a library for augmenting enums with additional information through strings.
Strumming is also a very whimsical motion, much like writing Rust code.