count_is_even() is true.
// You also don't need to call closures here.
"even" <=> countiseven
] />
}
```
Options
Each option must be followed by a ;.
Raw
To generate a non-reactive String, add the raw option to the beginning.
rs
class_list![
raw;
"default-class-names",
]
Clone
Rarely, you may need to clone something before passing it in.
The macro makes this easy with the clone option which clones the variable before it gets moved into the closure.
If possible try to avoid needing this option in the first place.
rs
class_list![
clone[count_class];
"default-class-names",
]
Crate
This should never be needed because it's automatically supplied by a wrapper macro_rules!.
In a case where the trait imports cannot be resolved--such as when used inside of another library--, the path can be redefined.
The path should lead to the root of this library.
rs
__class_list![
crate = ::your_lib::class_list;
"default-class-names",
]
Implementing Traits
If you'd like to simply pass a type to the macro instead of converting it every time, you can implement the ClassList and ClassToggle types.
Check out traits.rs to see the default implementations which are good examples of implementing them.
```rs // If you're using a type you don't own, // you must wrap it in a new struct. struct Bool(bool);
impl ClassList for Bool {
fn toclasslist(&self, normalize: bool) -> String {
// If the string could contain multiple class names
// you should use normalize to determine whether
// or not to call .to_class_list() on it before
// returning.
// If you're lazy you could always normalize, but
// then the string will be normalized multiple
// times for every update in the macro.
if self.0 {
"true".into()
} else {
"false".into()
}
}
}
impl ClassToggle for Bool {
fn toclasstoggle(&self) -> bool {
self.0
}
}
// Option, Result, and Fn are implemented in a way which
// allows any new type you implement to be automatically
// passed through.
asserteq!(
classlist,
"false true class list".to_string()
);
```