let my_arr = [1, 2, 3, 4, 5];

    let new_arr = std::array::from_fn(|i| my_arr[i] + 1);
    
    assert_eq!([2, 3, 4, 5, 6], new_arr);

https://doc.rust-lang.org/std/array/fn.from_fn.html

https://doc.rust-lang.org/nightly/std/primitive.array.html#m...

I suppose it gives you a way to specify the length in the examples (below), but it seems more ergonomic to take it from the original array.

    let bool_arr = core::array::from_fn::<_, 5, _>(|i| i % 2 == 0);

Note that this inference is static, and the compiler would tell you if it didn't have something concrete to infer the type from. The type inference is also limited to the function body, so removing the assertion could only ever cause an effect in that single function.

    let bool_arr: [bool; 5] = ...

Wow! I hate that with an amount of emotion that surprised me!

Does Rust do this kind of look-ahead inference a lot (specifically for deciding what the result shape/type is for a statement)?

Yes, but it's important to note that type inference in Rust is function-local. Furthermore, crucially, Rust requires types to be explicitly specified at function boundaries. Altogether this means that you (and the compiler) don't need to look farther than the function signature to figure out a given type.

This means that you can do stuff like this:

    let mut foo = HashMap::new();
    foo.insert("bar", true);

Is it theoretically possible to split the resolution into two lines? Then, as a reader, it might not always be obvious at what point the type is fully resolved.

E.g (pseudocode, and also it makes no practical sense since you would have populated it before interrogating it).

    let mut foo = HashMap::new();
    print(foo.containsKey("bar")); // here we've resolved the key type
    print(foo.containsValue(true)); // here we've resolved the value type

This is rarely a problem, because Rust is strict enough that it will tell you if your types aren't lining up like you think they are. And if you're using an editor with LSP support, then you can have inlay hints that reveal the types of all variables if you like.

Oh, that would go a long way to making me feel less nervous reading code like this.

        let my_arr = [1, 2, 3, 4, 5];
        my_arr.iter().map(|x| x + 1).for_each(
            |item| println!("The Value of this item is {item}")
        );