rustmax 0.0.10

A collection of useful crates.
Documentation 
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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

Fast byte search primitives with SIMD acceleration.

- Crate [`::memchr`].
- [docs.rs](https://docs.rs/memchr)
- [crates.io](https://crates.io/crates/memchr)
- [GitHub](https://github.com/BurntSushi/memchr)

---

`memchr` provides optimized routines for searching bytes in slices,
using SIMD acceleration on supported architectures.
It is significantly faster than naive byte-by-byte searching,
often by an order of magnitude for larger inputs.

The primary functions are [`memchr`] for finding a single byte,
[`memchr2`] and [`memchr3`] for finding one of 2-3 bytes,
and the [`memmem`] module for substring search.

This crate is a foundational building block used by
higher-level crates like [`regex`].

## Examples

Finding a single byte:

```rust
use memchr::memchr;

let haystack = b"hello world";
let needle = b'o';

assert_eq!(memchr(needle, haystack), Some(4));
```

Finding any of multiple bytes:

```rust
use memchr::memchr2;

let haystack = b"hello world";
// Find the first 'l' or 'w'
assert_eq!(memchr2(b'l', b'w', haystack), Some(2));
```

Substring search with the memmem module:

```rust
use memchr::memmem;

let haystack = b"the quick brown fox";
let needle = b"quick";

let finder = memmem::Finder::new(needle);
assert_eq!(finder.find(haystack), Some(4));
```

Finding all occurrences:

```rust
use memchr::memchr_iter;

let haystack = b"hello";
let positions: Vec<_> = memchr_iter(b'l', haystack).collect();
assert_eq!(positions, vec![2, 3]);
```

[`memchr`]: crate::memchr::memchr
[`memchr2`]: crate::memchr::memchr2
[`memchr3`]: crate::memchr::memchr3
[`memmem`]: crate::memchr::memmem
[`regex`]: crate::regex