How do I convert a usize to a u32 using TryFrom?

by

Since this answer was created, it was decided to have the implementation of TryFrom<usize> always allow for the possibility of failure, regardless of the current platform. The original code now compiles successfully in Rust 1.34.

Original answer

having TryFrom<usize> for u32 is dependent on having From<usize> for u32, which seems somewhat strange to me

This is because there’s a blanket implementation of TryFrom for anything that implements From:

impl<T, U> TryFrom<U> for T
where
    T: From<U>,
{
    type Error = !;
}

As you mentioned, since Rust supports platforms where the native integer length is 16, 32, or 64 bits, having such an implementation of From / Into would not be lossless on some of these platforms.

This error occurs because there’s no direct implementation of TryFrom / TryInto for these types. This is because users of these traits prefer that the implementations be infallible when platform-appropriate (The type Error = !).

There is a separate tracking issue 49415 specifically for deciding this issue.

I think that I can write my own function that does the conversion

Yes, that is what you should do. Something like this untested piece of code:

use std::u32;

struct SomeError;

// usize is a u16 or u32, which always fits in a u32
#[cfg(any(target_pointer_width = "16", target_pointer_width = "32"))]
fn my_thing(a: usize) -> Result<u32, SomeError> {
    Ok(a as u32)
}

// usize is a u64, which might be too big
#[cfg(target_pointer_width = "64")]
fn my_thing(a: usize) -> Result<u32, SomeError> {
    if a > u32::MAX as usize {
        Err(SomeError)
    } else {
        Ok(a as u32)
    }
}

I would be surprised if Rust doesn’t have some idiomatic way to do this conversion. usize and u32 are two basic types, after all.

The problem is that usize isn’t really a “basic” type because it changes size depending on the target platform. Getting this correct, performant and ergonomic is not easy.

More Related Contents:

  1. Cannot obtain a mutable reference when iterating a recursive structure: cannot borrow as mutable more than once at a time
  2. How can you make a safe static singleton in Rust?
  3. Why can impl trait not be used to return multiple / conditional types?
  4. Lifetime error when creating a function that returns a value implementing serde::Deserialize
  5. Rust proper error handling (auto convert from one error type to another with question mark)
  6. Why is a borrow still held in the else block of an if let?
  7. How to create a static string at compile time
  8. How to call a method when a trait and struct use the same method name?
  9. What does “cannot move out of index of” mean?
  10. What is the syntax: `instance.method::()`?
  11. Why does passing a closure to function which accepts a function pointer not work?
  12. “expected type parameter, found struct”
  13. Adding an append method to a singly linked list
  14. How do you set, clear and toggle a single bit in Rust?
  15. Is it possible to declare the type of the variable in Rust for loops?
  16. Cannot create a generic function that uses a literal zero
  17. Is there a way to combine multiple traits in order to define a new trait? [duplicate]
  18. How can I store a pattern in a variable in Rust?
  19. Why does a mutable borrow of a closure through DerefMut not work?
  20. How to switch between Rust toolchains?
  21. Why should I prefer `Option::ok_or_else` instead of `Option::ok_or`?
  22. How to get an Option’s value or set it if it’s empty?
  23. How to set a field in a struct with an empty value?
  24. Rust equivalent to Swift’s extension methods to a protocol?
  25. How can I solve “use of moved value” and “which does not implement the `Copy` trait”?
  26. Why does using Option::map to Box::new a trait object not work?
  27. Is the resource of a shadowed variable binding freed immediately?
  28. How can I download Rust API docs?
  29. How can I convert a hex string to a u8 slice?
  30. How do I pin indirect dependencies of a crate?

Leave a Comment