Add BoundedBTreeSet

[coriolinus]

Part of #8719

[bkchr]

IMHO we have now reached the point where this should be abstracted. IMHO I don't see any point in copying this for every type in the std library (I know that we don't need every type). However this is mainly code copying. Which should be doable with some generic container or a macro that generates the stuff.

[coriolinus]

I'm not sure how well it can be automated. The desired abstraction involves

• Deref / AsRef impls for appropriate types
• passthrough methods for &mut self methods which cannot increase the size
• try_X methods for &mut self methods which can increase the size

Knowing which types are appropriate, and which methods can increase the size, seems to require human intervention.

That said, once this is in, we'll have bounded variants for lists, sets, and maps. Those should suffice for all reasonable storage cases. I'm not anticipating adding more PRs like this soon.

[kianenigma]

TIL 👍

[kianenigma]

I think we might miss this in BoundedVec and BoundedBTreeMap, good one!

[kianenigma]

IMHO we have now reached the point where this should be abstracted. IMHO I don't see any point in copying this for every type in the std library (I know that we don't need every type). However this is mainly code copying. Which should be doable with some generic container or a macro that generates the stuff.

I don't have as strong opinion about BtreeMap and Set. On one hand they are types that we support in storage and we are a library, on the other hand we don't really use them (for good reasons) and we shouldn't overkill it. Either way I am happy with this PR.

About your comment on abstraction: I think what we do need is a SortedVec next to our BoundedVec, because we have quite a few storage items that have the assumption that they must always be sorted. And implementation-wise I was thinking of something like this:

struct AttributeVec<T, Attr: Attribute>(Vec<T>);

/// An attribute to a container like a Vec
trait Attribute {
  fn pre_insert();
  fn post_insert();
  fn pre_delete(); 
  fn post_delete(); 
  // and some other hooks/utilities that allow an attribute to control how a container mutates.
}

/// An attribute that ensures a container's length never goes beyond a limit.
struct Bounded;
impl Attribute for Bounded {
  fn pre_insert() { /* ensure bound */}
}

/// An attribute that ensures a container is always sorted. 
struct Sorted;
impl Attribute for Sorted {
  fn post_insert() { /* do sort! */}
  fn post_delete() { /* do sort! */}
}

// and we can have other attributes, and attributes can be combined by aggregating them into a tuple. 
#[impl_trait_for_tuples(18)]
if Attribute for Tuple { /* ... */ }

/// 
type BoundedVec<T> = AttributeVec<T, Bounded>;
type SortedVec<T> = AttributeVec<T, Sorted>;
type BoundedSortedVec<T> = AttributeVec<T, (Bounded, Sorted)>;

But to be honest there are a lot of empty pieces in my brain dump above, and I am worried that this would add so much complexity that we would regret it and just go back to the simpler way of copy-pasta.

[cla-bot-2021]

@kianenigma No commands could be detected from your comment.

[joao-paulo-parity]

Hello?

[kianenigma]

do you love me cla bot?

[coriolinus]

bot merge

[ghost]

Trying merge.