What is the difference between From::from and as in Rust?

Question

I can cast between types by using either from or as:

i64::from(42i32);
42i32 as i64;

What is the difference betwe

Answer 1

as can only be used in a small, fixed set of transformations. The reference documents as:

as can be used to explicitly perform coercions, as well as the following additional casts. Here *T means either *const T or *mut T.

| Type of `e`           | `U`                     | Cast performed by `e as U`       |
|-----------------------+-------------------------+----------------------------------|
| Integer or Float type | Integer or Float type   | Numeric cast                     |
| C-like enum           | Integer type            | Enum cast                        |
| `bool` or `char`      | Integer type            | Primitive to integer cast        |
| `u8`                  | `char`                  | `u8` to `char` cast              |
| `*T`                  | `*V` where `V: Sized` * | Pointer to pointer cast          |
| `*T` where `T: Sized` | Numeric type            | Pointer to address cast          |
| Integer type          | `*V` where `V: Sized`   | Address to pointer cast          |
| `&[T; n]`             | `*const T`              | Array to pointer cast            |
| Function pointer      | `*V` where `V: Sized`   | Function pointer to pointer cast |
| Function pointer      | Integer                 | Function pointer to address cast |
| Closure **            | Function pointer        | Closure to function pointer cast |

* or `T` and `V` are compatible unsized types, e.g., both slices, both the
same trait object.

** only for closures that do not capture (close over) any local variables

Because as is known to the compiler and only valid for certain transformations, it can do certain types of more complicated transformations.

From is a trait, which means that any programmer can implement it for their own types and it is thus able to be applied in more situations. It pairs with Into. TryFrom and TryInto have been stable since Rust 1.34.

Because it's a trait, it can be used in a generic context (fn foo(name: impl Into<String>) { /* ... */ }). This is not possible with as.

When converting between numeric types, one thing to note is that From is only implemented for lossless conversions (e.g. you can convert from i32 to i64 with From, but not the other way around), whereas as works for both lossless and lossy conversions (if the conversion is lossy, it truncates). Thus, if you want to ensure that you don't accidentally perform a lossy conversion, you may prefer using From::from rather than as.

See also:

• When should I implement std::convert::From vs std::convert::Into?