Fill an array "let x = [1..11], iterate over it multiple times in different functions?

Question

I'm searching an easy, not bloated solution for an easy problem.

Code (playpen):

use std::ops::Range;

// Sum of square numbers from 1 to 10 # 1^2 + 2^2 + 3^2 ...
fn sum_square(v: &[i64; 10]) -> i64 {
    let mut sum: i64 = 0;
    for x in v {
        sum += x * x;
    }
    return sum;
}


// Square sum of the added numbers from 1 to 10 # (1+2+3+...)^2
fn square_sum(v: &[i64; 10]) -> i64{
    let mut sum: i64 = 0;
    for x in v {
        sum += x;
    }
    return sum*sum;
}

fn main() {
    let v: [i64; 10] = [1,2,3,4,5,6,7,8,9,10];
    let diff = sum_square(&v) - square_sum(&v);
    println!("{}", diff);
}

I have an array in the main function, filled with numbers from 1-10 (yes I know [1..11] doesn't work, but what's the best solution? Using "range" is out of question, I want an array without having to type each number). Now I need to iterate over this array multiple times (here 2x) in different functions.

I don't want to use .copy() (because I don't want to move), I want to borrow the array to the functions like explained here: https://i.stack.imgur.com/VlZ8N.jpg

fn main() {
    let v: [i64; 10] = [1..11];
    let diff = sum_square(&v) - square_sum(&v);
    println!("{}", diff);
}

Two functions, each iterating over this array. So I just use a

fn sum_square(v: &[i64; 10]) -> i64 {
    let mut sum: i64 = 0;
    for x in v {
        sum += x * x;
    }
    return sum;
}

Seems to work. If I use the second function

// Square sum of the added numbers from 1 to 10 # (1+2+3+...)^2
fn square_sum(v: &[i64; 10]) -> i64{
    let mut sum: i64 = 0;
    for x in v {
    sum += x;
    }
    return sum*sum;
}

I get an error: type mismatch resolving <core::slice::Iter<'_, i64> as core::iter::Iterator>::Item == i64:

Answer 1

Pothead Grandma has a reasonable explanation, but I wanted to also include some other details.

fn square_sum(v: &[i64]) -> i64 { // 1
    let mut sum = 0;
    for &x in v { // 2
        sum += x;
    }
    sum * sum // 3
}

fn main() {
    let v: Vec<_> = (1..11).collect(); // 4
    let diff = sum_square(&v) - square_sum(&v); //5
    println!("{}", diff);
}

1. We accept a slice of numbers, instead of a reference to an array. A slice is just a chunk of values and how many values there are.
2. We bind to a reference variable, so x will be implicitly dereferenced. This means that instead of having to always say *x to get to the value of the variable, we can use x to get to the value.
3. No need for an explicit return statement. Explicit returns are useful when you return early from a method, but if a function returns a value, then the last statement of the function is the return value.
4. Use a range and collect it into a Vec. collect takes an iterator and makes a collection (in this case a Vec).
5. We take a reference to the Vec. Rust has auto-dereferencing rules, and &Vec<T> will dereference to &[T].

In the spirit of showing a more Rust-like way of solving this problem, I'll also show fold and map:

fn sum_square(v: &[i64]) -> i64 {
    v.iter().map(|i| i * i).fold(0, |accumulator, i| accumulator + i)
}

fn square_sum(v: &[i64]) -> i64 {
    let sum = v.iter().fold(0, |accumulator, &i| accumulator + i);
    sum * sum
}

Or using AdditiveIterator:

use std::iter::AdditiveIterator;

fn sum_square(v: &[i64]) -> i64 {
    v.iter().map(|i| i * i).sum()
}

fn square_sum(v: &[i64]) -> i64 {
    let sum: i64 = v.iter().cloned().sum();
    sum * sum
}

Answer 2

I'm new to Rust myself so my explanation might be incorrect or outdated, but it looks like that the issue is caused by a type mismatch.

fn sum_square(v: &[i64; 10]) -> i64 {
    let mut sum: i64 = 0;
    for x in v {
        sum += x * x;
    }
    return sum;
}

Here x has type &i64. It is a reference to the value inside the array. Multiplying or applying any other operator on x causes it to dereference - i.e. x*x now has type i64.

fn square_sum(v: &[i64; 10]) -> i64{
    let mut sum: i64 = 0;
    for x in v {
        sum += x;
    }
    return sum*sum;
}

Here x also has type &i64, but this time it won't get dereferenced. A correct solution would look like this:

fn square_sum(v: &[i64; 10]) -> i64{
    let mut sum: i64 = 0;
    for x in v {
        // alternatively sum = x + sum works, but sum = sum + x doesn't.
        sum += *x;
    }
    return sum*sum;
}