Tracking Issue for `array_map`

[JulianKnodt]

The feature gate for the issue is #![feature(array_map)].

Public API

impl<T, const N: usize> [T; N] {
    pub fn map<F, U>(self, f: F) -> [U; N] where F: FnMut(T) -> U;
}

Steps / History

• Implement it: Add array lang item and [T; N]::map(f: FnMut(T) -> S) #75212
• Add in place optimization for same size & alignment (?)
• FCP
• Stabilization PR Stabilize [T; N]::map() #87174

Unresolved Questions

How should order be documented/allowed for map? See #75212 (comment) for discussion.

[the8472]

A possible followup optimization: Perform this in place when size_of::<T>() == size_of::<U>() && align_of::<T>() == align_of<U>(), which can be checked at compile time. Together with RVO that might save a lot of extra stack space on large arrays.

[vadixidav]

This feature is currently breaking arraymap::ArrayMap without enabling the feature:

error[E0658]: use of unstable library feature 'array_map'
  --> lambda-twist/tests/consensus.rs:25:6
   |
25 |     .map(|&p| Point3::from(p));
   |      ^^^
   |
   = note: see issue #75243 <https://github.com/rust-lang/rust/issues/75243> for more information
   = help: add `#![feature(array_map)]` to the crate attributes to enable

This code started breaking on more recent Rust versions as it seems that it thinks I am attempting to use the map method on array created by this feature, but actually I am using arraymap::ArrayMap::map.

Since I am depending on nightly anyways, I will simply use this feature instead to get around this issue.

[JulianKnodt]

Ah I didn't know this crate existed, thanks for the heads up. I'm not quite sure how to resolve this, but will investigate.

[sugar700]

That seems like a compiler bug. I think a warning should show, but due to map accepting &self rather than self, it's not being seen. The problem can be seen with the following program:

trait ArrayExt {
    fn map<F: FnMut(i32) -> i32>(&self, f: F);
}

impl ArrayExt for [i32; 1] {
    fn map<F: FnMut(i32) -> i32>(&self, f: F) {}
}

fn main() {
    [4].map(|x| x);
}

In my opinion, this should print the following:

warning: a method with this name may be added to the standard library in the future
  --> src/main.rs:10:15
   |
10 |     [4].map(|x| x);
   |         ^^^
   |
   = note: `#[warn(unstable_name_collisions)]` on by default
   = warning: once this method is added to the standard library, the ambiguity may cause an error or change in behavior!
   = note: for more information, see issue #48919 <https://github.com/rust-lang/rust/issues/48919>
   = help: call with fully qualified syntax `ArrayExt::map(...)` to keep using the current method
   = help: add `#![feature(array_map)]` to the crate attributes to enable `array::<impl [T; N]>::map`

That being said, I'm kinda wondering whether [T; N]::map should use self or &self? Maybe we should have two methods, because they both have their use-cases. &mut self is also possible, albeit that one is kinda niche.