fst-no-std 0.4.7

Use finite state transducers to compactly represents sets or maps of many strings (> 1 billion is possible).
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
72
73

fst no-std mode
===

This is a fork of [fst](https://github.com/BurntSushi/fst) adding support for `no_std` targets (see [`no_std` usage](#no_std-usage) for details).

If you're unsure whether to use this fork or the original one: Just use the original, chances are that's more up-to-date.

### Documentation

https://docs.rs/fst-no-std

### Installation

Simply add a corresponding entry to your `Cargo.toml` dependency list:

```toml,ignore
[dependencies]
fst-no-std = "0.4"
```

### Example

This example demonstrates building a set in memory and executing a fuzzy query
against it. You'll need `fst_no_std = "0.4"` with the `levenshtein` feature enabled in
your `Cargo.toml`.

```rust
use fst_no_std::{IntoStreamer, Set};
use fst_no_std::automaton::Levenshtein;

fn main() -> Result<(), Box<dyn std::error::Error>> {
  // A convenient way to create sets in memory.
  let keys = vec!["fa", "fo", "fob", "focus", "foo", "food", "foul"];
  let set = Set::from_iter(keys)?;

  // Build our fuzzy query.
  let lev = Levenshtein::new("foo", 1)?;

  // Apply our fuzzy query to the set we built.
  let stream = set.search(lev).into_stream();

  let keys = stream.into_strs()?;
  assert_eq!(keys, vec!["fo", "fob", "foo", "food"]);
  Ok(())
}
```

Check out the documentation for a lot more examples!

### Cargo features

* `std` - **Enabled** by default. Adds features that depend on the standard library.
* `alloc` - **Enabled** by default. Adds features that depend on `alloc`.
* `levenshtein` - **Disabled** by default. This adds the `Levenshtein`
  automaton to the `automaton` sub-module. This includes an additional
  dependency on `utf8-ranges` and `std`.

### `no_std` Usage

You can use this crate in `no_std` environments by disabling default features, like so:

```toml,ignore
[dependencies]
fst-no-std = { version = "0.4", default-features = false }
```

This way `fst-no-std` will not depend on the standard library and not even allocate (!) at the cost of being rather kneecaped: You can not construct FSTs and the evailable querying features are limited to simple lookups. You can optionally enable the `alloc` feature which adds a dependency on the `alloc` crate (i.e. you will need a global allocator) but it enables all querying features.

#### License

<sup>
Licensed under the <a href="LICENSE-MIT">MIT license</a>.
</sup>