The implementation `From<&'a [T; N]>` for `Cow<'a, [T]>` seems missing

[oisyn]

This fails to compile

use std::borrow::Cow;

fn foo<'a>(v: impl Into<Cow<'a, [i32]>>) { }

fn main() {
    foo(&[1, 2, 3]);
}

Rust playground link

With the following diagnostics:

   Compiling playground v0.0.1 (/playground)
error[E0277]: the trait bound `Cow<'_, [i32]>: From<&[{integer}; 3]>` is not satisfied
 --> src/main.rs:8:9
  |
8 |     foo(&[1, 2, 3]);
  |     --- ^^^^^^^^^^ the trait `From<&[{integer}; 3]>` is not implemented for `Cow<'_, [i32]>`
  |     |
  |     required by a bound introduced by this call
  |
  = help: the following other types implement trait `From<T>`:
            <Cow<'a, OsStr> as From<OsString>>
            <Cow<'a, OsStr> as From<&'a OsStr>>
            <Cow<'a, OsStr> as From<&'a OsString>>
            <Cow<'a, CStr> as From<CString>>
            <Cow<'a, CStr> as From<&'a CStr>>
            <Cow<'a, CStr> as From<&'a CString>>
            <Cow<'a, Path> as From<&'a Path>>
            <Cow<'a, Path> as From<PathBuf>>
          and 7 others
  = note: required for `&[{integer}; 3]` to implement `Into<Cow<'_, [i32]>>`
note: required by a bound in `foo`
 --> src/main.rs:5:20
  |
5 | fn foo<'a>(v: impl Into<Cow<'a, [i32]>>) { }
  |                    ^^^^^^^^^^^^^^^^^^^^ required by this bound in `foo`

For more information about this error, try `rustc --explain E0277`.

It seems that From<&'a [T; N]> is not implemented for Cow<'a [T]>, while From<&'a [T]> is. Has this been an oversight, or is there a rationale behind this?

Providing my own implementation does seem to work

impl<'a, T: Clone, const N: usize> From<&'a [T; N]> for Cow<'a, [T]> {
    fn from(s: &'a [T; N]) -> Cow<'a, [T]> {
        Cow::Borrowed(s)
    }
}

[demosdemon]

The two are not compatible as &[T; N] is not the same as &[T]. The former is a reference to an array which has a fixed size and thus the size and alignment of the reference is for a single usize (the pointer). The latter is reference to a slice which is an unsized type meaning the size and alignment of the reference is for 2 usizes; one for the pointer and one for the count of elements within the slice.

Converting &[T; N] to Cow<'_, [T]> is an unsizing type conversion. Your implementation for From first implicitly converts the &[T; N] into a &[T] which creates a new reference and then wraps that with the Cow enum.

The difference is important when it comes to ToOwned. The impl for ToOwned is different for &[T; N] and &[T]. The former is delegated to Clone which will create a [T; N] and the latter will create a new Vec<T> with all of the differences of an array versus a vector.

[zachs18]

An impl<'a, T: Clone, const N: usize> From<&'a [T; N]> for Cow<'a, [T]> could be added, but has not been proposed (yet) as far as I know (see linked PR).

There also does not currently exist an impl<'a, T: Clone> From<&'a T> for Cow<'a, T>, which is good because that means that Cow::from(array_ref) would unambiguously resolve to Cow::<[T]>::from(array_ref), and not resolve to Cow::<[T; N]>::from(array_ref) or cause an inference error.

---

As a workaround for the code snippet in the OP, you can use [..] after the array to slice it (and then the & on the front borrows that), e.g. (playground link)

use std::borrow::Cow;

fn foo<'a>(v: impl Into<Cow<'a, [i32]>>) { }

fn main() {
    foo(&[1, 2, 3][..]);
}

[minghuaw]

Should this issue be closed given that #113489 is already merged?

[oisyn]

Yes, thank you.