pub fn get_gt<K>(
        &self,
        key: K,
    ) -> io::Result<Option<(InlineArray, InlineArray)>>
    where
        K: AsRef<[u8]>,
    {
        self.range((ops::Bound::Excluded(key), ops::Bound::Unbounded))
            .next()
            .transpose()
    }
Retrieve the next key and value from the `Tree` after the
provided key.

# Note
The order follows the Ord implementation for `Vec<u8>`:

`[] < [0] < [255] < [255, 0] < [255, 255] ...`

To retain the ordering of numerical types use big endian reprensentation

# Examples

```
# fn main() -> Result<(), Box<dyn std::error::Error>> {
use sled::InlineArray;
# let config = sled::Config::tmp().unwrap();
# let db: sled::Db<1024> = config.open()?;
for i in 0..10 {
db.insert(&[i], vec![i])?;
}

assert_eq!(
db.get_gt(&[]).unwrap(),
Some((InlineArray::from(&[0]), InlineArray::from(&[0])))
);
assert_eq!(
db.get_gt(&[0]).unwrap(),
Some((InlineArray::from(&[1]), InlineArray::from(&[1])))
);
assert_eq!(
db.get_gt(&[1]).unwrap(),
Some((InlineArray::from(&[2]), InlineArray::from(&[2])))
);
assert_eq!(
db.get_gt(&[8]).unwrap(),
Some((InlineArray::from(&[9]), InlineArray::from(&[9])))
);
assert!(db.get_gt(&[9]).unwrap().is_none());

db.insert(500u16.to_be_bytes(), vec![10]);
assert_eq!(
db.get_gt(&499u16.to_be_bytes()).unwrap(),
Some((InlineArray::from(&500u16.to_be_bytes()), InlineArray::from(&[10])))
);
# Ok(()) }
```
src/tree.rs