Cow from array

[bend-n]

enables

Cow::<[u8]>::from(&[])

as well as

Cow::<[i32]>::from(&[1, 1, 2, 3, 5, 8])

References #116890

[rustbot]

Thanks for the pull request, and welcome! The Rust team is excited to review your changes, and you should hear from @Mark-Simulacrum (or someone else) soon.

Please see the contribution instructions for more information. Namely, in order to ensure the minimum review times lag, PR authors and assigned reviewers should ensure that the review label (S-waiting-on-review and S-waiting-on-author) stays updated, invoking these commands when appropriate:

• @rustbot author: the review is finished, PR author should check the comments and take action accordingly
• @rustbot review: the author is ready for a review, this PR will be queued again in the reviewer's queue

[workingjubilee]

r? libs-api

[dtolnay]

Thanks for the PR!

Before I put this to FCP, would you be able to share some example code in which doing this conversion generically using From is useful? Usually I'd expect what you showed to be written as:

Cow::Borrowed::<[i32]>(&[1, 1, 2, 3, 5, 8])

or:

Cow::Borrowed(&[1, 1, 2, 3, 5, 8] as &[i32])

[bend-n]

Its supposed to fix Cow::from(&[1, 1, 2, 3, 5, 8][..]). I didnt think of simply using Cow::Borrowed.

I think its still useful though, if only because it saves you a rewrite when you do it (dont have to change it to Cow::Borrowed), as its very annoying when your doctest fails because of this.

Is Cow::Borrowed / Cow::Owned generally preferred to Cow::from anyway?

[dtolnay]

I would say, yes, Cow::Borrowed is preferred. There is no advantage to going through a generic From impl in the case you describe; it's only more roundabout.

The impls exists in support of generic code like this:

rust/compiler/rustc_errors/src/diagnostic.rs

Lines 974 to 981 in 1dfb6b1

	pub fn set_arg(
	&mut self,
	name: impl Into<Cow<'static, str>>,
	arg: impl IntoDiagnosticArg,
	) -> &mut Self {
	self.args.insert(name.into(), arg.into_diagnostic_arg());
	self
	}

where they enable different callers to efficiently pass a variety of different types for the name arg.

[bend-n]

Wont this help, there, then?

[oisyn]

@dtolnay That generic code is the exact reason I opened an issue about this about a month ago: #116890. If a function accepts a impl Cow<'a, [T]>, you can't give it a &[T; N], currently.

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

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

[zachs18]

CC #113489

[dtolnay]

Thanks zachs18! Closing in favor of #113489, as that one was opened earlier and demonstrated the use case.