Pass slices to functions in exercise 9.6.1 (#2848)

[iurii-kyrylenko]

Fixes issue #2848:
Use the references to a Dynamically Sized Slice instead of references to a Fixed-Size Array in function parameters.

[google-cla]

Thanks for your pull request! It looks like this may be your first contribution to a Google open source project. Before we can look at your pull request, you'll need to sign a Contributor License Agreement (CLA).

View this failed invocation of the CLA check for more information.

For the most up to date status, view the checks section at the bottom of the pull request.

[djmitche]

Thank you!

[mgeisler]

Have people learned about slices at this point?

[mgeisler]

Have people learned about slices at this point?

Ah, yes, I see they have 😄 Slices are introduced in 9.3 Slices.

However, the exercise text says:

utility functions for 3-dimensional geometry, representing a point as [f64; 3].

So that is the reason why the functions use the [f64; 3] type — it's a simple concrete type which people should have an easy time understanding.

When I've been teaching the class (both inside and outside of Google), I'm sometimes met with questions about the math-related exercises. That is, while magnitude works for higher dimensions, the math is not the point of this exercise. The use of shared and unique references is the point.

I would suggest keeping the solution as-is, but add a speaker note showing that one could use slices instead. The speaker note should then discuss the tradeoffs: with slices, you have a runtime length check, but with borrowed arrays, you have compile-time knowledge of the length (and the compiler can unroll the loops accordingly).

Basically, I don't think it's 100% clear that always using slices is the right call. A vector-library would want to use const generics instead, I believe.

[djmitche]

That's a good point, @mgeisler -- thank you! I had missed that the instructions specifically mention arrays.

This solution already has a speaker note, so adding another regarding slices seems like a good idea (and this is the segment to do it in, since we have discussed both references and slices).

(agreeing with @mgeisler)

[iurii-kyrylenko]

I would suggest keeping the solution as-is, but add a speaker note showing that one could use slices instead. The speaker note should then discuss the tradeoffs.

@djmitche, Can we ask @mgeisler to add a speaker note?

We could mention that declaring slice &[T] as function params has a flexibility, based on deref coercions:

• if we have a slice &[T], we can pass that directly;
• if we have an array [T; N], we can pass a slice &[T] or a reference to the array &[T;N].

The same holds for string slices as parameters.

[djmitche]

Fair point - I made #2851 for that purpose.

The Deref trait is covered (indirectly) later in the course, so I think it's best to omit deref coercion here.

[iurii-kyrylenko]

Thank you, @djmitche !

[mgeisler]

@djmitche, Can we ask @mgeisler to add a speaker note?

Yes, certainly! I've been meaning to get back into the habit of contributing PRs! 🙂

Thanks for the PR, both of you!