I found a keyset which cases the builder to panic.
Is it a bug or did I just miss something?

Code to reproduce

use yada::builder::DoubleArrayBuilder;

fn main() {
    let keyset = [
        ("goo", 1),
        ("mag", 2),
        ("gon", 3),
    ];
    let da_bytes: Option<Vec<u8>> = DoubleArrayBuilder::build(&keyset);
    println!("{:?}", da_bytes);
}

Resulting panic

thread 'main' panicked at 'assertion failed: `(left == right)`
  left: `103`,
 right: `0`', /home/<USER>/.cargo/registry/src/github.com-1ecc6299db9ec823/yada-0.5.0/src/builder.rs:201:13
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Now, the builder expects that keys have a terminal character.
But, it is easy to use user only provides key and value.

What do you think?

Hi,

We are using yada in Lindera.
I got an error from yada for building ipadic neologd dictionary with lindera-ipadic-neologd-builder.
See the detail of error in this PR

Lindera needs DoubleArray is Clone-able for some reason.
Can make DoubleArray struct Clone-able?

DoubleArray::get_unit() calls slice::get_unchecked() internally, but this slice is not checked in DoubleArray::new().
So, it is possible to cause a segmentation fault even though the caller does not use unsafe blocks.

use yada::DoubleArray;

fn main() {
    let da = DoubleArray::new(vec![]);
    if let Some(index) = da.exact_match_search("example input") {
        dbg!(index);
    }
}

$ cargo run --release
...
[1]    81236 segmentation fault  cargo run --release

Solution 1: Change DoubleArray::new() to an unsafe function

This solution does not pay the additional runtime cost, but requires callers to be responsible for using the correct slice.

let da = unsafe { DoubleArray::new(trusted_bytes) };

Solution 2: Change slice::get_unchecked() to a checked function

The opposite of Solution 1.

let b = &self.0[index * UNIT_SIZE..(index + 1) * UNIT_SIZE];

or

let b = self.0.get(index * UNIT_SIZE..(index + 1) * UNIT_SIZE)
          .ok_or_else(|| ...)?;

Solution 3: Check the argument of DoubleArray::new()

This is too much work, but it does not require any responsibility on callers and does not pay any additional costs during the search.