Pretty much this entire PR is just a bunch of cosmetic changes bringing kodama up to latest edition of Rust, along with updating idioms and applying rustfmt.

In a recent commit, we fixed the linkage routines to handle the case of an empty matrix gracefully. Unfortunately, this seems to have uncovered another bug. When asking for the steps from an empty dendrogram, the Rust FFI code does something like this:

creating an empty dendrogram:

  let steps = vec![];
  for i in 0..num_steps { // num_steps == 0 here
    steps.push(build_step(...));
  }
  dendrogram{steps: steps}

asking for the steps:

  dendrogram.steps.as_ptr()

It turns out that when Rust creates a Vec that has zero capacity, it specifically does not allocate. (This is a very desirable quality, since it makes creating empty Vecs very very cheap.) However, since the Vec doesn't allocate but still provides routines for accessing its inner raw pointer (e.g., as_ptr() above), it must still be able to provide a non-null pointer. The Vec implementation achieves this by using a pointer value that is known to never point to valid memory.

Go does not like this, which makes sense in a way, because it has a garbage collector and garbage collectors like to do funny things with pointers. The end result here is that attempting to cast the pointer returned by Rust to an array on which we can index causes the compiler to generate code that attempts to dereference the pointer (that we know is invalid). This in turn causes a nil-dereference panic.

A simple way to fix this is to replace this

let steps = vec![];

with this

let steps = Vec::with_capacity(1);

This crates a Vec with zero elements but a capacity of 1, which forces an allocation, and therefore in turn results in producing a pointer to valid memory. This makes Go happy.

Alternatively, we can detect this case from the Go code (the dendrogram is empty) and just return a slice. We choose to do that in this commit, but for no particularly strong reason other than the fact that it seems weird to create a non-empty allocation on the Rust side.

The commit messages should explain things.

This PR also bumps kodama to 0.2 to reflect a corresponding bump to num-traits (which is a public dependency).