As of Rust 1.24.1, the array length basically needs to either be a numeric literal or a “regular” constant that is a usize. There’s a small amount of constant evaluation that exists today, but it’s more-or-less limited to basic math. a perfectly valid expression in other contexts, just not as a length parameter to an … Read more
Crates uploaded to crates.io (and thus to docs.rs) will show what feature flags exist. crates.io issue #465 suggests placing the feature list on the crate’s page as well. Beyond that, the only guaranteed way to see what features are available is to look at the Cargo.toml for the crate. This generally means that you need … Read more
Since I was essentially trying to emulate C macros, I tried to solve the problem with Rust macros and succeeded: macro_rules! description { () => ( “my program” ) } macro_rules! version { () => ( env!(“CARGO_PKG_VERSION”) ) } macro_rules! version_string { () => ( concat!(description!(), ” v”, version!()) ) } It feels a bit … Read more
For references into an array usually you’d just use a usize rather than different integer types. However, to do what you are after you can create a new trait, implement that trait for u16, u32 and u64 and then restrict T to your new trait. pub trait MyNewTrait {} impl MyNewTrait for u16 {} impl … Read more
You should implement std::str::FromStr trait. use std::str::FromStr; #[derive(Debug, PartialEq)] enum Foo { Bar, Baz, Bat, Quux, } impl FromStr for Foo { type Err = (); fn from_str(input: &str) -> Result<Foo, Self::Err> { match input { “Bar” => Ok(Foo::Bar), “Baz” => Ok(Foo::Baz), “Bat” => Ok(Foo::Bat), “Quux” => Ok(Foo::Quux), _ => Err(()), } } } fn … Read more
Is there syntax for moving fields between similar structs? No. There is no such syntax. The current implementation of “struct update” (previously called “functional record update”) syntax only allows the exact same type. Is there better syntax for this somewhere, or a better way to implement these map-like methods for non-trivial structs? No. The only … Read more
You want to implement the Debug trait on your struct. Using #[derive(Debug)] is the easiest solution. Then you can print it with {:?}: #[derive(Debug)] struct MyStruct{ a: i32, b: i32 } fn main() { let x = MyStruct{ a: 10, b: 20 }; println!(“{:?}”, x); }
The great thing about Rust is that it’s open source. This means you can see how the authors of the language have solved a problem. The closest analogue is primitive integer types: macro_rules! add_impl { ($($t:ty)*) => ($( #[stable(feature = “rust1”, since = “1.0.0”)] impl Add for $t { type Output = $t; #[inline] fn … Read more
The null pointer optimization basically means that if you have an enum with two variants, where one variant has no associated data, and the other variant has associated data where the bit pattern of all zeros isn’t a valid value, then the enum itself will take exactly the same amount of space as that associated … Read more
Arrays must be completely initialized, so you quickly run into concerns about what to do when you convert a vector with too many or too few elements into an array. These examples simply panic. As of Rust 1.51 you can parameterize over an array’s length. use std::convert::TryInto; fn demo<T, const N: usize>(v: Vec<T>) -> [T; … Read more