What trait bounds are appropriate for stubs?

[petertseng]

As we add stubs, we should ask what trait bounds are appropriate.

Decision made in #497 (simple-linked-list c5f7a43): Not to add Debug.

Should Debug remain in custom-set? #605 (comment)

Not to put Debug in circular-buffer: #608 (comment)

Discussion in sublist: Be minimally restrictive: #610 (comment)

Summary: I think we are indeed trying to be consistent about being minimally restrictive. Please chime in if you think we should do differently, or for any further input on the topic.

Current trait bounds (the grep pattern may not be the best, feel free to suggest a better)

$ git grep '<[^>]:.*>' exercises/*/src/lib.rs 
exercises/custom-set/src/lib.rs:impl<T: Debug> CustomSet<T> {
exercises/react/src/lib.rs:impl<T: Copy + PartialEq> Reactor<T> {
exercises/react/src/lib.rs:    pub fn create_compute<F: Fn(&[T]) -> T>(
exercises/react/src/lib.rs:    pub fn add_callback<F: FnMut(T) -> ()>(
exercises/simple-linked-list/src/lib.rs:impl<T: Clone> SimpleLinkedList<T> {
exercises/simple-linked-list/src/lib.rs:impl<'a, T: Clone> From<&'a [T]> for SimpleLinkedList<T> {

If there is no further input, I think the way to close this issue is to remove Debug from custom-set. You will then need to remove references to variables in unimplemented! messages, so will have to replace them with underscored names.

[petertseng]

todo: Note discussion supporting PartialEq in #610 (comment) .

[coriolinus]

Related: should minimal bounds be enforced? Consider the sublist exercise: the simplest implementation is for the student to tighten the required bounds to Hash+Eq or Ord and then collect the lists into one of the std::collections::*Set objects, from where they can use the is_subset and is_superset methods.

It would be possible to defend against this by creating a newtype which only implements PartialEq, and then testing that the student's implementation succeed on that newtype. I am not certain whether or not that behavior is desired, though.

Point in favor of allowing the student to tighten the trait bounds for their implementation: allows them to demonstrate knowledge of the standard library and the trait system, and would probably be the best way to proceed in production code.

Point in favor of preventing the student from tightening the trait bounds for their implementation: student must implement fundamental algorithms, can't take shortcuts.