spaghetto 0.0.1

A library for making double-ended data structures, like an always-contigouous double-ended queue (deque) and double-ended string.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

# Spaghetto


Spaghetto is a library for creating double-ended data structures that can be rolled out or eaten on from either side.
This includes the base structure `DeVec`, a double-ended `Vec` (heap-allocated dynamically sized array-like collection) that can be used as a deque, and `DeString`, a double-ended alternative to `String`.
<br>
## Examples

### DeVec

A `DeVec` (Double-Ended Vec) can be used as a double-ended queue, but with the added benefit of being able to get a single contiguous slice of the entire structure.
```rust
use spaghetto::DeVec;
let mut devec = DeVec::with_capacity(5);
devec.push_back(1);
devec.push_front(2);
devec.push_back(3);
assert_eq!(devec.pop_front(), Some(2));
devec.pop_front();
// Now let's overload one side.
// This forces a DeVec to reallocate in order to keep the elements contiguous.
// With a VecDeque this would no longer be a contiguous allocation
// because we moved the front of the queue into the middle of the buffer
// and pushed it out past the end of the buffer.
// It would need to wrap around.
for i in 0..3 {
   devec.push_back(i);
}

// we can get a single contiguous slice of the entire DeVec without having to shift elements.
let no_mutation = &devec;
let slice = no_mutation.as_slice();
```

### DeString

A `DeString` can be used as a double-ended string, and because of this, we can efficiently remove extra whitespace from either side, mutating in place and maintining a single contiguous string slice without the cost of shifting like with a String.
```rust
use spaghetto::DeString;
let mut destring = DeString::from("  hello world  ");
destring.mut_trim_front();
// It is contiguous and also mutated its starting position!
assert_eq!(destring.as_str(), "hello world  ");
```