The GSL is over kill for this crate. We can switch to the lighter rand family of crates.

Several DRY problems here!

Several places where we drain a slice should instead be calls to truncate, as we don't need the drained items.

Need a bitflags type to affect the behavior of the table sorting function. Right now, we need a "skip edge table" flag.

This should be a cargo option. Given how tskit metadata works, the implementation should be either a set of functions or a class that consumes a table collection.

Provenance, too, should be an option.

This may be what pushes a redesign of the code layout into a cargo workspace.

Let's get rid of booleans in favor of flags.

All of the current data access functions are range checked, yet we generate the final return value with [], which is also range checked. The second accesses should use get_unchecked.

Some things still refer to tskit_rust instead of tskit or just plain don't link to a function.

We may want info beyond just "is a sample or not", so let's move the sample's vector into a struct.

After #80, we can do this.

Define the spec, including diffs from how tskit rolls.

The typography is inconsistent. This should be NullId.

1. Array of mutation keys that simplify out.
2. Array of site positions that simplify out.

Eventually, we want to return more than just the idmap, so we need a structure for that.

Gotta make cargo publish --dry-run happy.

it seems that we should be able to keep the info about the roots in the simplification state, then re-use them the next time we simplify, etc..

There's safe stuff in there. Move it out!

This should make modules more readable and give better coverage estimates.

It would be preferable to have a means of iterating a list via Iterator rather than the current callback method (which we should deprecate).

Currently, examples/forward_simluation.rs serves as both. That should change, and just be an example of the most efficient means of tree seq recording.

The "integration" test stuff should be move internally to test-only modules.

The down side is some code duplication, but we can make the internal simulator much simpler.

This will also mean moving the wright-fisher module out and into the examples. This move is a good thing, and keeps this crate leaner.

We want a bitflag type to say, "yes, validate the tables". Perhaps also we want flags to include/exclude various tables?

For cases where tables are worked on via dumped vectors, several currently private functions become useful.

Thus, the mod should be pub, and we only import a few key types into the module root/prelude.

Should add this to the docs. Sadly, rustdoc doesn't allow standalone markdown (yet) in stable, so let's do it in the EdgeBuffer type.

But, do it after #53, as we'll move one of the bits of data there.

We'd like to support 32 and 64 tables "out of the box". A big first step is to get the API written down as a trait. Here's a mock-up for future me.

// Table row
pub struct E<T> {
    left: i64,
    right: i64,
    parent: T,
    child: T,
}

// table collection
pub struct TC<T> {
    pub edges: Vec<E<T>>,
}

impl<T> TC<T> {
    pub fn new() -> Self {
        TC::<T> { edges: vec![] }
    }
}

// Interface
trait TCT<T> {
    fn add_edge(&mut self, left: i64, right: i64, parent: T, child: T) -> T;
}

// macros for the details
macro_rules! add_edge {
    ($itype: ty) => {
        fn add_edge(&mut self, left: i64, right: i64, parent: $itype, child: $itype) -> $itype {
            self.edges.push(E::<$itype> {
                left,
                right,
                parent,
                child,
            });
            self.edges.len() as $itype
        }
    };
}

// Concrete definitions
impl TCT<i32> for TC<i32> {
    add_edge!(i32);
}

impl TCT<i64> for TC<i64> {
    add_edge!(i64);
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn it_works() {
        let mut t = TC::<i32>::new();
        let x = t.add_edge(0, 1, 2, 3);
        assert_eq!(x, 1);
        assert_eq!(t.edges[0].left, 0);
        assert_eq!(t.edges[0].right, 1);
        assert_eq!(t.edges[0].parent, 2);
        assert_eq!(t.edges[0].child, 3);
    }
}

Need mutation/site table validation, too.

The extend function can currently panic, but this should be returned to calling environment as an error.

Should typedef the i32 as the "index type" so that its easier to switch to 64 bit later, etc..

For cases where the borrow checker is being "impossible", one may need to separate the tables from the parent objects and then reset them later.

The forward simulation example has the following incorrect behavior:

Simulating with a buffer and not simplifying returns an empty edge table.

This should do it:

const VERSION: &'static str = env!("CARGO_PKG_VERSION");```

It is too annoying!

Once that is released, we can update, which will let us clean up loads of tests with safe code.

We should generate a fixture of many forward simulations. For each, simplify with respect to many subsets of nodes. Compare to tskit. This looks like a job for Once.

The latest release was changes to the MIT license, which we did because we removed using the GSL for random numbers. However, a GPL license is more in the spirit of what we intend here. This is academic research software, and requiring modifications to be open is more in line with my views on open access.

Should allow for sites not attached to mutations to be retained. The current behavior rebuilds the table.

These setter functions need to set is_indexed to false

The current scheme uses default pinning, but we should use "=x.y.x" while that dependency is unstable.

The current .edge(...), etc., panic! if indexes are out of range. We need to add analogs to Vec's get and get_unchecked functions. The latter will be unsafe.