Using generics inputs

[rrtoledo]

Content

So far, we could only use Element as input type. This was fixed to a byte array of a specific size for the whole repository.

This PR aims at supporting mroe input types, and allowing the use of different input types across examples and tests.

To do so, I have created a ToBytes trait and updating the relevant struct and functions to use a generic type implementing it. The hash functions then only have to call to_be_bytes() that is the one function defined in the trait.

I have also written some macros to implement ToBytes, and so support, some standard types.

Pre-submit checklist

• Branch
  • Tests are provided (if possible)
  • Commit sequence broadly makes sense
  • Key commits have useful messages
• PR
  • No clippy warnings in the CI
  • Self-reviewed the diff
  • Useful pull request description
  • Reviewer requested
• Documentation
  • Update README file (if relevant)
  • Update documentation website (if relevant)

Comments

We should be able to support both BLS and KES (with current Cardano params) signatures.

Issue(s)

Relates to #30

[tolikzinovyev]

I think it's customary to not impose restrictions on generic types where unnecessary. For example, HashMap doesn't require the key type to implement Eq and Hash traits in the struct definition or other functions that don't require them. https://doc.rust-lang.org/src/std/collections/hash/map.rs.html#211-213

The convention is to require as few trait bounds as possible.

https://stackoverflow.com/questions/49229332/should-trait-bounds-be-duplicated-in-struct-and-impl/66369912#66369912

[rrtoledo]

All these traits are needed (Except for ord if we compare on the bytes as you mentionned in the other comment).

[rrtoledo]

I could remove Sized when using AsRef :)

[tolikzinovyev]

We should probably check that the byte representations are distinct since that is what the proving algorithms really require.

Suggested change

	pub(crate) fn check_distinct<E: ToBytes + Clone + Sized + Ord>(elements: &[E]) -> bool {
	let mut elements = elements.to_vec();
	elements.sort_unstable();
	elements.is_sorted_by(|a, b| a < b)
	pub(crate) fn check_distinct<E: ToBytes + Clone>(elements: &[E]) -> bool {
	let mut elements = elements.to_vec();
	elements.sort_unstable_by(|a, b| a.to_be_bytes().as_ref().cmp(b.to_be_bytes().as_ref()));
	elements.is_sorted_by(|a, b| a.to_be_bytes().as_ref() < b.to_be_bytes().as_ref())

[rrtoledo]

I was not sure if comparing on bytes is the best approach as the conversion to byte might become expensive (say we have a big structure and not simply a signature). What do you reckon?

Perhaps we should, when truncating the dataset or filling the bins, convert everything to byte there and use references to retrieve the elements at the end?

[curiecrypt]

LGTM