How to initialize a const generic array?

Question

I am trying to learn more about const generics and how they can apply to some grid algorithms in any dimensions. Below is a snippet - how can I create an array of the size of a const generic parameter?

type Point<const N: usize> = [i32; N];

fn new_point<const N: usize>(x: i32, y: i32) -> Point<N> {
    [x, y]
}

fn main() {
    let point: Point<2> = new_point(1, 2);
    println!("Point: {:?}", point)
}

The above results in a compiler error:

error[E0308]: mismatched types
 --> src/main.rs:4:5
  |
3 | fn new_point<const N: usize>(x: i32, y: i32) -> Point<N> {
  |                                                 -------- expected `[i32; N]` because of return type
4 |     [x, y]
  |     ^^^^^^ expected `N`, found `2_usize`
  |
  = note: expected array `[i32; N]`
             found array `[i32; 2]`

Note that I am not looking for a solution using Vec<N>. How can I initialize this generic array with some values?

https://play.integer32.com/?version=stable&mode=debug&edition=2021&gist=fc1ed4a5f7d96f145188ba211d3b1839 ? — Stargateur, Jan 24 '22 at 17:32
Well, your function is not generic over `N`. You always return `Point<2>` no matter the value of `N`. Why try to make it generic in the first place? — mcarton, Jan 24 '22 at 17:42

Kevin Reid · Answer 1 · 2022-09-25T19:29:30.333

Here are some ways to construct an array of arbitrary length.

You can use std::array::from_fn which will allow constructing an array of any size from a function computing its elements:

/// Constructs an array with the first two elements being x and y.
fn new_point<const N: usize>(x: i32, y: i32) -> Point<N> {
    std::array::from_fn(|i| {
        match i {
            0 => x,
            1 => y,
            _ => 0,
        }
    })
}

You can construct an array with copies of a single value:
```
[0; N]

// or
[foo(); N]
```

You can construct an array and then mutate it:

fn new_point<const N: usize>(x: i32, y: i32) -> Point<N> {
    let mut array = [0; N];
    if N > 0 {
        array[0] = x;
    }
    if N > 1 {
        array[1] = y;
    }
    array
}

You can construct an array by mapping from another array (this used to be done as a workaround for lack of from_fn()):
```
let mut i = 0;
[(); N].map(|()| {
    i += 1;
    i
}]
```
You can construct an array by using .try_into() to convert a slice or vector; the conversion will fail if the slice or vector is not the correct length. See the list of implementors of TryFrom, and look for the ones that say ... for [T; N].

looks like `from_fn` is stable now? – Artemis Sep 25 '22 at 15:28 — Artemis, Sep 25 '22 at 15:28

How to initialize a const generic array?

1 Answers1