Compiling libdictenstein v0.1.0 (/home/dylon/Workspace/f1r3fly.io/libdictenstein) warning: unused import: `rayon::prelude` --> src/persistent_artrie_char/parallel_merge.rs:18:5 | 18 | use rayon::prelude::*; | ^^^^^^^^^^^^^^ | = note: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default warning: unused import: `rayon::prelude` --> src/persistent_artrie/dict_impl.rs:51:5 | 51 | use rayon::prelude::*; | ^^^^^^^^^^^^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/dict_impl.rs:634:56 | 634 | let dict: PersistentARTrie = PersistentARTrie::new(); | ^^^ | = note: `#[warn(deprecated)]` on by default warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/dict_impl.rs:641:56 | 641 | let dict: PersistentARTrie = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/dict_impl.rs:658:56 | 658 | let dict: PersistentARTrie = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/dict_impl.rs:668:56 | 668 | let dict: PersistentARTrie = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/dict_impl.rs:682:56 | 682 | let dict: PersistentARTrie = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/dict_impl.rs:692:56 | 692 | let dict: PersistentARTrie = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/dict_impl.rs:704:56 | 704 | let dict: PersistentARTrie = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/dict_impl.rs:717:56 | 717 | let dict: PersistentARTrie = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/dict_impl.rs:728:56 | 728 | let dict: PersistentARTrie = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/dict_impl.rs:745:56 | 745 | let dict: PersistentARTrie = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/dict_impl.rs:751:56 | 751 | let dict: PersistentARTrie = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/dict_impl.rs:758:56 | 758 | let dict: PersistentARTrie = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/dict_impl.rs:768:56 | 768 | let dict: PersistentARTrie = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/dict_impl.rs:784:56 | 784 | let dict: PersistentARTrie = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/dict_impl.rs:796:56 | 796 | let dict: PersistentARTrie = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/dict_impl.rs:812:56 | 812 | let dict: PersistentARTrie = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/dict_impl.rs:1586:67 | 1586 | let source: PersistentARTrie<u32> = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/dict_impl.rs:1594:71 | 1594 | let mut target: PersistentARTrie<u32> = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/dict_impl.rs:1616:67 | 1616 | let source: PersistentARTrie<u32> = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/dict_impl.rs:1623:71 | 1623 | let mut target: PersistentARTrie<u32> = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/dict_impl.rs:1644:65 | 1644 | let trie: PersistentARTrie<u32> = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/dict_impl.rs:1671:65 | 1671 | let trie: PersistentARTrie<u32> = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/dict_impl.rs:1693:65 | 1693 | let trie: PersistentARTrie<u32> = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/dict_impl.rs:1703:68 | 1703 | let trie: PersistentARTrie<String> = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/dict_impl.rs:1764:65 | 1764 | let dict: PersistentARTrie<i32> = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/dict_impl.rs:1812:65 | 1812 | let dict: PersistentARTrie<i32> = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/dict_impl.rs:1918:56 | 1918 | let dict: PersistentARTrie = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/dict_impl.rs:1941:56 | 1941 | let dict: PersistentARTrie = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/dict_impl.rs:1956:56 | 1956 | let dict: PersistentARTrie = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/dict_impl.rs:1972:56 | 1972 | let dict: PersistentARTrie = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/dict_impl.rs:2001:56 | 2001 | let dict: PersistentARTrie = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/dict_impl.rs:2033:56 | 2033 | let dict: PersistentARTrie = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/dict_impl.rs:2069:56 | 2069 | let dict: PersistentARTrie = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/dict_impl.rs:2087:56 | 2087 | let dict: PersistentARTrie = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/zipper.rs:480:60 | 480 | let dict: PersistentARTrie<()> = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/zipper.rs:489:60 | 489 | let dict: PersistentARTrie<()> = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/zipper.rs:503:60 | 503 | let dict: PersistentARTrie<()> = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/zipper.rs:513:60 | 513 | let dict: PersistentARTrie<()> = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/zipper.rs:528:60 | 528 | let dict: PersistentARTrie<()> = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/zipper.rs:543:60 | 543 | let dict: PersistentARTrie<()> = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/zipper.rs:553:60 | 553 | let dict: PersistentARTrie<()> = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/zipper.rs:567:60 | 567 | let dict: PersistentARTrie<()> = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/zipper.rs:587:60 | 587 | let dict: PersistentARTrie<()> = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/zipper.rs:606:60 | 606 | let dict: PersistentARTrie<()> = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/zipper.rs:620:60 | 620 | let dict: PersistentARTrie<()> = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/zipper.rs:641:60 | 641 | let dict: PersistentARTrie<()> = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `persistent_artrie::mmap_ctor::<impl persistent_artrie::dict_impl::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> src/persistent_artrie/zipper.rs:664:60 | 664 | let dict: PersistentARTrie<()> = PersistentARTrie::new(); | ^^^ warning: method `serialize_node_to_disk` is never used --> src/persistent_artrie/serialize_impl.rs:57:19 | 36 | impl<V: DictionaryValue, S: BlockStorage> PersistentARTrie<V, S> { | ---------------------------------------------------------------- method in this implementation ... 57 | pub(super) fn serialize_node_to_disk(&self, node: &Node) -> Result<SwizzledPtr> { | ^^^^^^^^^^^^^^^^^^^^^^ | = note: `#[warn(dead_code)]` (part of `#[warn(unused)]`) on by default warning: variant `Empty` is never constructed --> src/persistent_artrie/node_impl.rs:93:5 | 58 | enum NodeInner<V: DictionaryValue> { | --------- variant in this enum ... 93 | Empty, | ^^^^^ warning: associated function `empty` is never used --> src/persistent_artrie/node_impl.rs:260:8 | 143 | impl<V: DictionaryValue> PersistentARTrieNode<V> { | ------------------------------------------------ associated function in this implementation ... 260 | fn empty() -> Self { | ^^^^^ warning: field `commit_seq_by_data_lsn` is never read --> src/persistent_artrie_char/mod.rs:595:16 | 413 | pub struct PersistentARTrieChar<V: DictionaryValue = (), S: crate::persistent_artrie::block_storage::BlockStorage = crate::persiste... | -------------------- field in this struct ... 595 | pub(crate) commit_seq_by_data_lsn: std::sync::Mutex<std::collections::BTreeMap<u64, u64>>, | ^^^^^^^^^^^^^^^^^^^^^^ warning: method `pending_len` is never used --> src/persistent_artrie_char/reclaim.rs:59:19 | 44 | impl<V: DictionaryValue> CharRetireList<V> { | ------------------------------------------ method in this implementation ... 59 | pub(crate) fn pending_len(&self) -> usize { | ^^^^^^^^^^^ warning: method `checkpoint_path` is never used --> src/persistent_artrie_core/epoch.rs:776:8 | 447 | impl CheckpointManager { | ---------------------- method in this implementation ... 776 | fn checkpoint_path(&self, epoch: EpochId) -> PathBuf { | ^^^^^^^^^^^^^^^ warning: struct `PendingTransaction` is never constructed --> src/persistent_artrie_core/recovery.rs:439:8 | 439 | struct PendingTransaction { | ^^^^^^^^^^^^^^^^^^ warning: associated function `new` is never used --> src/persistent_artrie_core/shared_access.rs:126:19 | 122 | impl<'a, T: ?Sized> TrieAccessGuard<'a, T> { | ------------------------------------------ associated function in this implementation ... 126 | pub(crate) fn new(inner: &'a T) -> Self { | ^^^ warning: field `archive_config` is never read --> src/persistent_artrie_core/wal/async_writer.rs:383:5 | 371 | pub struct AsyncWalWriter { | -------------- field in this struct ... 383 | archive_config: WalConfig, | ^^^^^^^^^^^^^^ warning: associated function `placeholder` is never used --> src/persistent_vocab_artrie/mod.rs:267:8 | 256 | impl VocabTrieNodeRef { | --------------------- associated function in this implementation ... 267 | fn placeholder() -> Self { | ^^^^^^^^^^^ warning: constant `DEFAULT_VOCAB_BUFFER_POOL_SIZE` is never used --> src/persistent_vocab_artrie/dict_impl.rs:73:7 | 73 | const DEFAULT_VOCAB_BUFFER_POOL_SIZE: usize = 64; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ warning: field `shutdown` is never read --> src/persistent_vocab_artrie/concurrent.rs:132:5 | 100 | pub struct ConcurrentVocabARTrie { | --------------------- field in this struct ... 132 | shutdown: AtomicBool, | ^^^^^^^^ warning: type alias `ScdawgNode` is never used --> src/scdawg.rs:74:6 | 74 | type ScdawgNode<V = ()> = crate::scdawg_core::ScdawgNode<u8, V>; | ^^^^^^^^^^ warning: type alias `ScdawgCharNode` is never used --> src/scdawg_char.rs:66:6 | 66 | type ScdawgCharNode<V = ()> = crate::scdawg_core::ScdawgNode<char, V>; | ^^^^^^^^^^^^^^ warning: type alias `SuffixNode` is never used --> src/suffix_automaton.rs:150:17 | 150 | pub(crate) type SuffixNode<V = ()> = crate::suffix_automaton_core::SuffixNode<u8, V>; | ^^^^^^^^^^ warning: type alias `SuffixNodeChar` is never used --> src/suffix_automaton_char.rs:149:17 | 149 | pub(crate) type SuffixNodeChar<V = ()> = crate::suffix_automaton_core::SuffixNode<char, V>; | ^^^^^^^^^^^^^^ warning: unused `std::result::Result` that must be used --> src/persistent_artrie_char/mod.rs:813:13 | 813 | trie.insert(&term); | ^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled = note: `#[warn(unused_must_use)]` (part of `#[warn(unused)]`) on by default help: use `let _ = ...` to ignore the resulting value | 813 | let _ = trie.insert(&term); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_artrie_char/mod.rs:824:13 | 824 | trie.insert(term); | ^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 824 | let _ = trie.insert(term); | +++++++ warning: unused import: `rayon::prelude` --> src/persistent_artrie/dict_impl.rs:51:5 | 51 | use rayon::prelude::*; | ^^^^^^^^^^^^^^ | = note: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default warning: unused import: `MappedDictionary` --> src/persistent_artrie_char/persist.rs:1933:29 | 1933 | use crate::{Dictionary, MappedDictionary}; | ^^^^^^^^^^^^^^^^ warning: unused import: `MappedDictionary` --> src/persistent_artrie_char/persist.rs:1619:29 | 1619 | use crate::{Dictionary, MappedDictionary}; | ^^^^^^^^^^^^^^^^ warning: unused import: `MappedDictionary` --> src/persistent_artrie_char/persist.rs:2073:29 | 2073 | use crate::{Dictionary, MappedDictionary}; | ^^^^^^^^^^^^^^^^ warning: unused import: `crate::ARTrie` --> src/persistent_artrie_char/dict_impl_char.rs:208:9 | 208 | use crate::ARTrie; | ^^^^^^^^^^^^^ warning: unused import: `Dictionary` --> src/persistent_artrie_char/overlay_dictionary_node_faulting_tests.rs:27:13 | 27 | use crate::{Dictionary, DictionaryNode}; | ^^^^^^^^^^ warning: unused import: `Dictionary` --> src/persistent_artrie/lockfree_cas.rs:2214:17 | 2214 | use crate::{Dictionary, MappedDictionary}; | ^^^^^^^^^^ warning: unused import: `crate::persistent_artrie_core::overlay::flip::LockFreeOverlay` --> src/persistent_artrie/lockfree_cas.rs:2625:13 | 2625 | use crate::persistent_artrie_core::overlay::flip::LockFreeOverlay; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ warning: unused import: `crate::persistent_artrie_core::overlay::flip::LockFreeOverlay` --> src/persistent_artrie/lockfree_cas.rs:2716:13 | 2716 | use crate::persistent_artrie_core::overlay::flip::LockFreeOverlay; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ warning: unused import: `crate::persistent_artrie_core::overlay::flip::LockFreeOverlay` --> src/persistent_artrie/lockfree_cas.rs:2738:13 | 2738 | use crate::persistent_artrie_core::overlay::flip::LockFreeOverlay; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ warning: unused import: `MappedDictionary` --> src/persistent_artrie_char/lockfree_cas.rs:2371:29 | 2371 | use crate::{Dictionary, MappedDictionary}; | ^^^^^^^^^^^^^^^^ warning: unused import: `rayon::prelude` --> src/persistent_artrie_char/parallel_merge.rs:18:5 | 18 | use rayon::prelude::*; | ^^^^^^^^^^^^^^ warning: `libdictenstein` (lib) generated 20 warnings warning: unused import: `libdictenstein::MutableMappedDictionary` --> examples/batched_merge_comparison.rs:4:5 | 4 | use libdictenstein::MutableMappedDictionary; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default warning: unused imports: `WalConfig` and `WalWriter` --> examples/wal_size_test.rs:1:59 | 1 | use libdictenstein::persistent_artrie::{PersistentARTrie, WalConfig, WalWriter}; | ^^^^^^^^^ ^^^^^^^^^ | = note: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default warning: variable does not need to be mutable --> examples/batched_merge_comparison.rs:17:9 | 17 | let mut source: PersistentARTrie<i64> = | ----^^^^^^ | | | help: remove this `mut` | = note: `#[warn(unused_mut)]` (part of `#[warn(unused)]`) on by default warning: unused import: `MutableMappedDictionary` --> examples/streaming_merge_test.rs:2:52 | 2 | use libdictenstein::{Dictionary, MappedDictionary, MutableMappedDictionary}; | ^^^^^^^^^^^^^^^^^^^^^^^ | = note: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default warning: variable does not need to be mutable --> examples/test_checkpoint_debug.rs:33:13 | 33 | let mut dict = PersistentARTrie::<()>::create(&path).expect("create dict"); | ----^^^^ | | | help: remove this `mut` | = note: `#[warn(unused_mut)]` (part of `#[warn(unused)]`) on by default warning: variable does not need to be mutable --> examples/streaming_merge_test.rs:11:9 | 11 | let mut source: PersistentARTrie<i64> = | ----^^^^^^ | | | help: remove this `mut` | = note: `#[warn(unused_mut)]` (part of `#[warn(unused)]`) on by default warning: variable does not need to be mutable --> examples/streaming_merge_test.rs:24:9 | 24 | let mut target: PersistentARTrie<i64> = | ----^^^^^^ | | | help: remove this `mut` warning: variable does not need to be mutable --> examples/wal_size_test.rs:15:13 | 15 | let mut trie: PersistentARTrie<()> = PersistentARTrie::create(&path1).expect("create trie"); | ----^^^^ | | | help: remove this `mut` | = note: `#[warn(unused_mut)]` (part of `#[warn(unused)]`) on by default warning: variable does not need to be mutable --> examples/wal_size_test.rs:28:13 | 28 | let mut trie: PersistentARTrie<()> = PersistentARTrie::create(&path2).expect("create trie"); | ----^^^^ | | | help: remove this `mut` warning: unused import: `MappedDictionary` --> tests/persistent_artrie_char_integration.rs:21:38 | 21 | use libdictenstein::{DictionaryNode, MappedDictionary}; | ^^^^^^^^^^^^^^^^ | = note: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default warning: variable does not need to be mutable --> examples/test_bench.rs:14:13 | 14 | let mut trie = | ----^^^^ | | | help: remove this `mut` | = note: `#[warn(unused_mut)]` (part of `#[warn(unused)]`) on by default warning: unused import: `libdictenstein::Dictionary` --> tests/proptest_bijective.rs:11:5 | 11 | use libdictenstein::Dictionary; | ^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default warning: variable does not need to be mutable --> examples/test_bench_large.rs:15:13 | 15 | let mut trie = | ----^^^^ | | | help: remove this `mut` | = note: `#[warn(unused_mut)]` (part of `#[warn(unused)]`) on by default warning: function `unicode_term` is never used --> tests/common/strategies.rs:28:8 | 28 | pub fn unicode_term(min_len: usize, max_len: usize) -> impl Strategy<Value = String> { | ^^^^^^^^^^^^ | = note: `#[warn(dead_code)]` (part of `#[warn(unused)]`) on by default warning: function `alphanumeric_term` is never used --> tests/common/strategies.rs:38:8 | 38 | pub fn alphanumeric_term(min_len: usize, max_len: usize) -> impl Strategy<Value = String> { | ^^^^^^^^^^^^^^^^^ warning: function `suffix_clustered_terms` is never used --> tests/common/strategies.rs:78:8 | 78 | pub fn suffix_clustered_terms(count: usize) -> impl Strategy<Value = Vec<String>> { | ^^^^^^^^^^^^^^^^^^^^^^ warning: function `first_byte_clustered_terms` is never used --> tests/common/strategies.rs:100:8 | 100 | pub fn first_byte_clustered_terms(count: usize) -> impl Strategy<Value = Vec<String>> { | ^^^^^^^^^^^^^^^^^^^^^^^^^^ warning: function `edge_case_terms` is never used --> tests/common/strategies.rs:131:8 | 131 | pub fn edge_case_terms() -> impl Strategy<Value = Vec<String>> { | ^^^^^^^^^^^^^^^ warning: function `byte_sequence` is never used --> tests/common/strategies.rs:161:8 | 161 | pub fn byte_sequence(min_len: usize, max_len: usize) -> impl Strategy<Value = Vec<u8>> { | ^^^^^^^^^^^^^ warning: enum `DictOp` is never used --> tests/common/strategies.rs:172:10 | 172 | pub enum DictOp<V: Clone + std::fmt::Debug> { | ^^^^^^ warning: function `dict_ops_strategy` is never used --> tests/common/strategies.rs:186:8 | 186 | pub fn dict_ops_strategy<V>( | ^^^^^^^^^^^^^^^^^ warning: function `insert_remove_ops` is never used --> tests/common/strategies.rs:209:8 | 209 | pub fn insert_remove_ops(count: usize) -> impl Strategy<Value = Vec<DictOp<()>>> { | ^^^^^^^^^^^^^^^^^ warning: function `u32_value` is never used --> tests/common/strategies.rs:218:8 | 218 | pub fn u32_value() -> impl Strategy<Value = u32> { | ^^^^^^^^^ warning: function `i64_value` is never used --> tests/common/strategies.rs:223:8 | 223 | pub fn i64_value() -> impl Strategy<Value = i64> { | ^^^^^^^^^ warning: function `string_value` is never used --> tests/common/strategies.rs:228:8 | 228 | pub fn string_value() -> impl Strategy<Value = String> { | ^^^^^^^^^^^^ warning: function `overlapping_term_sets` is never used --> tests/common/strategies.rs:241:8 | 241 | pub fn overlapping_term_sets( | ^^^^^^^^^^^^^^^^^^^^^ warning: function `three_term_sets` is never used --> tests/common/strategies.rs:272:8 | 272 | pub fn three_term_sets( | ^^^^^^^^^^^^^^^ warning: function `dedupe_terms` is never used --> tests/common/strategies.rs:294:8 | 294 | pub fn dedupe_terms(terms: Vec<String>) -> Vec<String> { | ^^^^^^^^^^^^ warning: function `sets_equal` is never used --> tests/common/strategies.rs:303:8 | 303 | pub fn sets_equal<T: Eq + std::hash::Hash>(a: &[T], b: &[T]) -> bool { | ^^^^^^^^^^ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:32:5 | 32 | trie.insert("café"); | ^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled = note: `#[warn(unused_must_use)]` (part of `#[warn(unused)]`) on by default help: use `let _ = ...` to ignore the resulting value | 32 | let _ = trie.insert("café"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:33:5 | 33 | trie.insert("naïve"); | ^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 33 | let _ = trie.insert("naïve"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:34:5 | 34 | trie.insert("résumé"); | ^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 34 | let _ = trie.insert("résumé"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:48:5 | 48 | trie.insert("中文"); | ^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 48 | let _ = trie.insert("中文"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:49:5 | 49 | trie.insert("你好"); | ^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 49 | let _ = trie.insert("你好"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:50:5 | 50 | trie.insert("世界"); | ^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 50 | let _ = trie.insert("世界"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:53:5 | 53 | trie.insert("日本語"); | ^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 53 | let _ = trie.insert("日本語"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:54:5 | 54 | trie.insert("こんにちは"); | ^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 54 | let _ = trie.insert("こんにちは"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:55:5 | 55 | trie.insert("ありがとう"); | ^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 55 | let _ = trie.insert("ありがとう"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:58:5 | 58 | trie.insert("한국어"); | ^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 58 | let _ = trie.insert("한국어"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:59:5 | 59 | trie.insert("안녕하세요"); | ^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 59 | let _ = trie.insert("안녕하세요"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:73:5 | 73 | trie.insert("🎉"); | ^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 73 | let _ = trie.insert("🎉"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:74:5 | 74 | trie.insert("🌍"); | ^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 74 | let _ = trie.insert("🌍"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:75:5 | 75 | trie.insert("❤️"); | ^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 75 | let _ = trie.insert("❤️"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:78:5 | 78 | trie.insert("👨👩👧"); // Family emoji (ZWJ sequence) | ^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 78 | let _ = trie.insert("👨👩👧"); // Family emoji (ZWJ sequence) | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:79:5 | 79 | trie.insert("🏳️🌈"); // Rainbow flag | ^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 79 | let _ = trie.insert("🏳️🌈"); // Rainbow flag | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:82:5 | 82 | trie.insert("Hello 🌍!"); | ^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 82 | let _ = trie.insert("Hello 🌍!"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:83:5 | 83 | trie.insert("I ❤️ Rust"); | ^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 83 | let _ = trie.insert("I ❤️ Rust"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:104:5 | 104 | trie.insert(precomposed); | ^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 104 | let _ = trie.insert(precomposed); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:105:5 | 105 | trie.insert(decomposed); | ^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 105 | let _ = trie.insert(decomposed); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:120:5 | 120 | trie.insert("مرحبا"); | ^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 120 | let _ = trie.insert("مرحبا"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:121:5 | 121 | trie.insert("العالم"); | ^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 121 | let _ = trie.insert("العالم"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:124:5 | 124 | trie.insert("שלום"); | ^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 124 | let _ = trie.insert("שלום"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:125:5 | 125 | trie.insert("עולם"); | ^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 125 | let _ = trie.insert("עולם"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:137:5 | 137 | trie.insert("Café 中文"); | ^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 137 | let _ = trie.insert("Café 中文"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:138:5 | 138 | trie.insert("Tōkyō 東京"); | ^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 138 | let _ = trie.insert("Tōkyō 東京"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:139:5 | 139 | trie.insert("München München"); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 139 | let _ = trie.insert("München München"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:140:5 | 140 | trie.insert("São Paulo"); | ^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 140 | let _ = trie.insert("São Paulo"); | +++++++ warning: function `alphanumeric_term` is never used --> tests/common/strategies.rs:38:8 | 38 | pub fn alphanumeric_term(min_len: usize, max_len: usize) -> impl Strategy<Value = String> { | ^^^^^^^^^^^^^^^^^ | = note: `#[warn(dead_code)]` (part of `#[warn(unused)]`) on by default warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:152:5 | 152 | trie.insert("∑∏∫∂"); | ^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 152 | let _ = trie.insert("∑∏∫∂"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:153:5 | 153 | trie.insert("∀x∃y"); | ^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 153 | let _ = trie.insert("∀x∃y"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:156:5 | 156 | trie.insert("$€£¥₿"); | ^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 156 | let _ = trie.insert("$€£¥₿"); | +++++++ warning: function `prefix_clustered_terms` is never used --> tests/common/strategies.rs:53:8 | 53 | pub fn prefix_clustered_terms(count: usize) -> impl Strategy<Value = Vec<String>> { | ^^^^^^^^^^^^^^^^^^^^^^ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:159:5 | 159 | trie.insert("♩♪♫♬"); | ^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 159 | let _ = trie.insert("♩♪♫♬"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:162:5 | 162 | trie.insert("⚡⚙️🔧"); | ^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 162 | let _ = trie.insert("⚡⚙️🔧"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:177:5 | 177 | trie.insert_with_value("café", 1); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 177 | let _ = trie.insert_with_value("café", 1); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:178:5 | 178 | trie.insert_with_value("中文", 2); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 178 | let _ = trie.insert_with_value("中文", 2); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:179:5 | 179 | trie.insert_with_value("🎉", 3); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 179 | let _ = trie.insert_with_value("🎉", 3); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:191:5 | 191 | trie.insert_with_value("hello", "greeting".to_string()); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 191 | let _ = trie.insert_with_value("hello", "greeting".to_string()); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:192:5 | 192 | trie.insert_with_value("世界", "world".to_string()); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 192 | let _ = trie.insert_with_value("世界", "world".to_string()); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:193:5 | 193 | trie.insert_with_value("café", "coffee place".to_string()); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 193 | let _ = trie.insert_with_value("café", "coffee place".to_string()); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:208:5 | 208 | trie.insert("café"); | ^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 208 | let _ = trie.insert("café"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:209:5 | 209 | trie.insert("cat"); | ^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 209 | let _ = trie.insert("cat"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:233:5 | 233 | trie.insert("中文"); | ^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 233 | let _ = trie.insert("中文"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:251:5 | 251 | trie.insert("ab"); | ^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 251 | let _ = trie.insert("ab"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:252:5 | 252 | trie.insert("aé"); | ^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 252 | let _ = trie.insert("aé"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:253:5 | 253 | trie.insert("a中"); | ^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 253 | let _ = trie.insert("a中"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:254:5 | 254 | trie.insert("a🎉"); | ^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 254 | let _ = trie.insert("a🎉"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:277:5 | 277 | trie.insert("hello"); | ^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 277 | let _ = trie.insert("hello"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:278:5 | 278 | trie.insert("世界"); | ^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 278 | let _ = trie.insert("世界"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:279:5 | 279 | trie.insert("café"); | ^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 279 | let _ = trie.insert("café"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:295:5 | 295 | trie.insert("abc"); | ^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 295 | let _ = trie.insert("abc"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:296:5 | 296 | trie.insert("aéc"); | ^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 296 | let _ = trie.insert("aéc"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:349:5 | 349 | trie.insert("aaa"); | ^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 349 | let _ = trie.insert("aaa"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:350:5 | 350 | trie.insert("café"); | ^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 350 | let _ = trie.insert("café"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:351:5 | 351 | trie.insert("中文"); | ^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 351 | let _ = trie.insert("中文"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:371:5 | 371 | trie.insert("中文"); | ^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 371 | let _ = trie.insert("中文"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:372:5 | 372 | trie.insert("中国"); | ^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 372 | let _ = trie.insert("中国"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:373:5 | 373 | trie.insert("中心"); | ^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 373 | let _ = trie.insert("中心"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:386:5 | 386 | trie.insert("🎉🎊"); | ^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 386 | let _ = trie.insert("🎉🎊"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:387:5 | 387 | trie.insert("🎉🎁"); | ^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 387 | let _ = trie.insert("🎉🎁"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:388:5 | 388 | trie.insert("🎉🎈"); | ^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 388 | let _ = trie.insert("🎉🎈"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:409:5 | 409 | trie.insert(""); | ^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 409 | let _ = trie.insert(""); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:420:5 | 420 | trie.insert("a"); | ^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 420 | let _ = trie.insert("a"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:421:5 | 421 | trie.insert("é"); | ^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 421 | let _ = trie.insert("é"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:422:5 | 422 | trie.insert("中"); | ^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 422 | let _ = trie.insert("中"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:423:5 | 423 | trie.insert("🎉"); | ^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 423 | let _ = trie.insert("🎉"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:438:5 | 438 | trie.insert(long_unicode); | ^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 438 | let _ = trie.insert(long_unicode); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:467:9 | 467 | trie.insert(term); | ^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 467 | let _ = trie.insert(term); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:509:5 | 509 | trie.insert_with_value("one", 1); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 509 | let _ = trie.insert_with_value("one", 1); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:510:5 | 510 | trie.insert_with_value("一", 1); // Chinese for "one" | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 510 | let _ = trie.insert_with_value("一", 1); // Chinese for "one" | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:511:5 | 511 | trie.insert_with_value("하나", 1); // Korean for "one" | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 511 | let _ = trie.insert_with_value("하나", 1); // Korean for "one" | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:531:5 | 531 | trie.insert("𝄞"); // G clef | ^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 531 | let _ = trie.insert("𝄞"); // G clef | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:534:5 | 534 | trie.insert("𝐀𝐁𝐂"); // Bold letters | ^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 534 | let _ = trie.insert("𝐀𝐁𝐂"); // Bold letters | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:537:5 | 537 | trie.insert("𐀀"); // Linear B syllable | ^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 537 | let _ = trie.insert("𐀀"); // Linear B syllable | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:540:5 | 540 | trie.insert("👋🏽"); // Waving hand with medium skin tone | ^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 540 | let _ = trie.insert("👋🏽"); // Waving hand with medium skin tone | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:561:5 | 561 | trie.insert(with_zwj); | ^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 561 | let _ = trie.insert(with_zwj); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:562:5 | 562 | trie.insert(without_zwj); | ^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 562 | let _ = trie.insert(without_zwj); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:582:5 | 582 | trie.insert("hello world"); // Regular space | ^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 582 | let _ = trie.insert("hello world"); // Regular space | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:583:5 | 583 | trie.insert("hello\u{00A0}world"); // Non-breaking space | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 583 | let _ = trie.insert("hello\u{00A0}world"); // Non-breaking space | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:584:5 | 584 | trie.insert("hello\u{2003}world"); // Em space | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 584 | let _ = trie.insert("hello\u{2003}world"); // Em space | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_char_integration.rs:585:5 | 585 | trie.insert("hello\u{3000}world"); // Ideographic space | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 585 | let _ = trie.insert("hello\u{3000}world"); // Ideographic space | +++++++ warning: variable does not need to be mutable --> examples/exp_checkpoint_throughput.rs:65:21 | 65 | let mut g = trie.write(); | ----^ | | | help: remove this `mut` | = note: `#[warn(unused_mut)]` (part of `#[warn(unused)]`) on by default warning: method `label` is never used --> examples/exp_checkpoint_throughput.rs:53:8 | 52 | impl Arm { | -------- method in this implementation 53 | fn label(self) -> &'static str { | ^^^^^ | = note: `#[warn(dead_code)]` (part of `#[warn(unused)]`) on by default warning: use of deprecated type alias `libdictenstein::persistent_artrie_char::SharedCharTrie`: Use SharedCharARTrie instead --> tests/persistent_artrie_recovery_tests.rs:2171:49 | 2171 | use libdictenstein::persistent_artrie_char::SharedCharTrie; | ^^^^^^^^^^^^^^ | = note: `#[warn(deprecated)]` on by default warning: use of deprecated type alias `libdictenstein::persistent_artrie_char::SharedCharTrie`: Use SharedCharARTrie instead --> tests/persistent_artrie_recovery_tests.rs:2515:41 | 2515 | let trie: SharedCharTrie<i64> = SharedCharTrie::create(&path).expect("create shared trie"); | ^^^^^^^^^^^^^^ warning: use of deprecated type alias `libdictenstein::persistent_artrie_char::SharedCharTrie`: Use SharedCharARTrie instead --> tests/persistent_artrie_recovery_tests.rs:2515:19 | 2515 | let trie: SharedCharTrie<i64> = SharedCharTrie::create(&path).expect("create shared trie"); | ^^^^^^^^^^^^^^ warning: use of deprecated type alias `libdictenstein::persistent_artrie_char::SharedCharTrie`: Use SharedCharARTrie instead --> tests/persistent_artrie_recovery_tests.rs:2581:41 | 2581 | let trie: SharedCharTrie<i64> = SharedCharTrie::create(&path).expect("create shared trie"); | ^^^^^^^^^^^^^^ warning: use of deprecated type alias `libdictenstein::persistent_artrie_char::SharedCharTrie`: Use SharedCharARTrie instead --> tests/persistent_artrie_recovery_tests.rs:2581:19 | 2581 | let trie: SharedCharTrie<i64> = SharedCharTrie::create(&path).expect("create shared trie"); | ^^^^^^^^^^^^^^ warning: unused `Result` that must be used --> tests/vocab_trait_honesty.rs:112:9 | 112 | g.insert("foo"); | ^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled = note: `#[warn(unused_must_use)]` (part of `#[warn(unused)]`) on by default help: use `let _ = ...` to ignore the resulting value | 112 | let _ = g.insert("foo"); | +++++++ warning: unused `Result` that must be used --> tests/vocab_trait_honesty.rs:113:9 | 113 | g.insert("bar"); | ^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 113 | let _ = g.insert("bar"); | +++++++ warning: unused `Result` that must be used --> tests/vocab_trait_honesty.rs:165:9 | 165 | g.insert("apple"); | ^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 165 | let _ = g.insert("apple"); | +++++++ warning: unused `Result` that must be used --> tests/vocab_trait_honesty.rs:184:9 | 184 | g.insert("apple"); | ^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 184 | let _ = g.insert("apple"); | +++++++ warning: unused `Result` that must be used --> tests/vocab_trait_honesty.rs:185:9 | 185 | g.insert("application"); | ^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 185 | let _ = g.insert("application"); | +++++++ warning: unused `Result` that must be used --> tests/vocab_trait_honesty.rs:207:9 | 207 | g.insert("counter"); | ^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 207 | let _ = g.insert("counter"); | +++++++ warning: use of deprecated associated function `libdictenstein::persistent_artrie::mmap_ctor::<impl libdictenstein::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> tests/persistent_artrie_recovery_tests.rs:1364:60 | 1364 | let trie: PersistentARTrie<()> = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `libdictenstein::persistent_artrie::mmap_ctor::<impl libdictenstein::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> tests/persistent_artrie_recovery_tests.rs:1387:60 | 1387 | let trie: PersistentARTrie<()> = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `libdictenstein::persistent_artrie::mmap_ctor::<impl libdictenstein::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> tests/persistent_artrie_recovery_tests.rs:1400:60 | 1400 | let trie: PersistentARTrie<()> = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `libdictenstein::persistent_artrie::mmap_ctor::<impl libdictenstein::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> tests/persistent_artrie_recovery_tests.rs:1412:60 | 1412 | let trie: PersistentARTrie<()> = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `libdictenstein::persistent_artrie::mmap_ctor::<impl libdictenstein::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> tests/persistent_artrie_recovery_tests.rs:1427:61 | 1427 | let trie: PersistentARTrie<i32> = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `libdictenstein::persistent_artrie::mmap_ctor::<impl libdictenstein::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> tests/persistent_artrie_recovery_tests.rs:1446:60 | 1446 | let trie: PersistentARTrie<()> = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `libdictenstein::persistent_artrie::mmap_ctor::<impl libdictenstein::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> tests/persistent_artrie_recovery_tests.rs:1469:60 | 1469 | let trie: PersistentARTrie<()> = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `libdictenstein::persistent_artrie::mmap_ctor::<impl libdictenstein::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> tests/persistent_artrie_recovery_tests.rs:1484:60 | 1484 | let trie: PersistentARTrie<()> = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `libdictenstein::persistent_artrie::mmap_ctor::<impl libdictenstein::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> tests/persistent_artrie_recovery_tests.rs:1503:60 | 1503 | let trie: PersistentARTrie<()> = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `libdictenstein::persistent_artrie::mmap_ctor::<impl libdictenstein::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> tests/persistent_artrie_recovery_tests.rs:1582:60 | 1582 | let trie: PersistentARTrie<()> = PersistentARTrie::new(); | ^^^ warning: use of deprecated associated function `libdictenstein::persistent_artrie::mmap_ctor::<impl libdictenstein::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> tests/persistent_artrie_recovery_tests.rs:1605:60 | 1605 | let trie: PersistentARTrie<()> = PersistentARTrie::new(); | ^^^ warning: unused import: `libdictenstein::ARTrie` --> tests/persistent_artrie_recovery_tests.rs:2172:9 | 2172 | use libdictenstein::ARTrie; | ^^^^^^^^^^^^^^^^^^^^^^ | = note: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default warning: unused import: `libdictenstein::ARTrie` --> tests/persistent_artrie_recovery_tests.rs:2543:13 | 2543 | use libdictenstein::ARTrie; | ^^^^^^^^^^^^^^^^^^^^^^ warning: unused import: `Dictionary` --> tests/persistent_artrie_recovery_tests.rs:2776:26 | 2776 | use libdictenstein::{Dictionary, MappedDictionary}; | ^^^^^^^^^^ warning: unused import: `libdictenstein::MutableMappedDictionary` --> tests/persistent_artrie_recovery_tests.rs:2858:13 | 2858 | use libdictenstein::MutableMappedDictionary; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ warning: unused import: `libdictenstein::MutableMappedDictionary` --> tests/persistent_artrie_recovery_tests.rs:2903:13 | 2903 | use libdictenstein::MutableMappedDictionary; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ warning: unused import: `libdictenstein::MutableMappedDictionary` --> tests/persistent_artrie_recovery_tests.rs:2939:13 | 2939 | use libdictenstein::MutableMappedDictionary; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ warning: comparison is useless due to type limits --> tests/persistent_artrie_recovery_tests.rs:1441:17 | 1441 | assert!(matches.len() >= 0, "Should return iterator"); | ^^^^^^^^^^^^^^^^^^ | = note: `#[warn(unused_comparisons)]` on by default warning: unused `Result` that must be used --> tests/persistent_artrie_recovery_tests.rs:1634:9 | 1634 | trie.insert("apple"); | ^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled = note: `#[warn(unused_must_use)]` (part of `#[warn(unused)]`) on by default help: use `let _ = ...` to ignore the resulting value | 1634 | let _ = trie.insert("apple"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_recovery_tests.rs:1635:9 | 1635 | trie.insert("application"); | ^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1635 | let _ = trie.insert("application"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_recovery_tests.rs:1636:9 | 1636 | trie.insert("apply"); | ^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1636 | let _ = trie.insert("apply"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_recovery_tests.rs:1637:9 | 1637 | trie.insert("banana"); | ^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1637 | let _ = trie.insert("banana"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_recovery_tests.rs:1638:9 | 1638 | trie.insert("band"); | ^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1638 | let _ = trie.insert("band"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_recovery_tests.rs:1655:9 | 1655 | trie.insert("apple"); | ^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1655 | let _ = trie.insert("apple"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_recovery_tests.rs:1656:9 | 1656 | trie.insert("banana"); | ^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1656 | let _ = trie.insert("banana"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_recovery_tests.rs:1668:9 | 1668 | trie.insert("日本語"); | ^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1668 | let _ = trie.insert("日本語"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_recovery_tests.rs:1669:9 | 1669 | trie.insert("日本人"); | ^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1669 | let _ = trie.insert("日本人"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_recovery_tests.rs:1670:9 | 1670 | trie.insert("日曜日"); | ^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1670 | let _ = trie.insert("日曜日"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_recovery_tests.rs:1671:9 | 1671 | trie.insert("月曜日"); | ^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1671 | let _ = trie.insert("月曜日"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_recovery_tests.rs:1687:9 | 1687 | trie.insert_with_value("apple", 1); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1687 | let _ = trie.insert_with_value("apple", 1); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_recovery_tests.rs:1688:9 | 1688 | trie.insert_with_value("application", 2); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1688 | let _ = trie.insert_with_value("application", 2); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_recovery_tests.rs:1689:9 | 1689 | trie.insert_with_value("apply", 3); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1689 | let _ = trie.insert_with_value("apply", 3); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_recovery_tests.rs:1690:9 | 1690 | trie.insert_with_value("banana", 4); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1690 | let _ = trie.insert_with_value("banana", 4); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_recovery_tests.rs:1709:9 | 1709 | trie.insert("apple"); | ^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1709 | let _ = trie.insert("apple"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_recovery_tests.rs:1710:9 | 1710 | trie.insert("application"); | ^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1710 | let _ = trie.insert("application"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_recovery_tests.rs:1711:9 | 1711 | trie.insert("apply"); | ^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1711 | let _ = trie.insert("apply"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_recovery_tests.rs:1712:9 | 1712 | trie.insert("banana"); | ^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1712 | let _ = trie.insert("banana"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_recovery_tests.rs:1713:9 | 1713 | trie.insert("band"); | ^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1713 | let _ = trie.insert("band"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_recovery_tests.rs:1732:9 | 1732 | trie.insert("日本語"); | ^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1732 | let _ = trie.insert("日本語"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_recovery_tests.rs:1733:9 | 1733 | trie.insert("日本人"); | ^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1733 | let _ = trie.insert("日本人"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_recovery_tests.rs:1734:9 | 1734 | trie.insert("日曜日"); | ^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1734 | let _ = trie.insert("日曜日"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_recovery_tests.rs:1735:9 | 1735 | trie.insert("月曜日"); | ^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1735 | let _ = trie.insert("月曜日"); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_recovery_tests.rs:1753:13 | 1753 | trie.insert(&format!("prefix_{:03}", i)); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1753 | let _ = trie.insert(&format!("prefix_{:03}", i)); | +++++++ warning: unused `Result` that must be used --> tests/persistent_artrie_recovery_tests.rs:1755:9 | 1755 | trie.insert("other_term"); | ^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1755 | let _ = trie.insert("other_term"); | +++++++ warning: variable does not need to be mutable --> examples/wal_debug.rs:18:13 | 18 | let mut trie: PersistentARTrie<()> = PersistentARTrie::create(&path).expect("create trie"); | ----^^^^ | | | help: remove this `mut` | = note: `#[warn(unused_mut)]` (part of `#[warn(unused)]`) on by default warning: variable `failures` is assigned to, but never used --> src/persistent_artrie_core/concurrency.rs:1444:13 | 1444 | let mut failures = 0; | ^^^^^^^^^^^^ | = note: consider using `_failures` instead = note: `#[warn(unused_variables)]` (part of `#[warn(unused)]`) on by default warning: value assigned to `failures` is never read --> src/persistent_artrie_core/concurrency.rs:1447:17 | 1447 | failures += 1; | ^^^^^^^^^^^^^ | = help: maybe it is overwritten before being read? = note: `#[warn(unused_assignments)]` (part of `#[warn(unused)]`) on by default warning: `libdictenstein` (test "vocab_trait_honesty") generated 6 warnings warning: unused import: `libdictenstein::MappedDictionary` --> tests/common/macros.rs:263:29 | 263 | use libdictenstein::MappedDictionary; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ::: tests/proptest_trait_macros.rs:35:1 | 35 | / test_mapped_dictionary!( 36 | | dawg_mapped => DynamicDawg::<u32>::new(), 37 | | dawg_char_mapped => DynamicDawgChar::<u32>::new(), 38 | | ); | |_- in this macro invocation | = note: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default = note: this warning originates in the macro `test_mapped_dictionary` (in Nightly builds, run with -Z macro-backtrace for more info) warning: unused import: `libdictenstein::MappedDictionary` --> tests/common/macros.rs:236:29 | 236 | use libdictenstein::MappedDictionary; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ::: tests/proptest_trait_macros.rs:35:1 | 35 | / test_mapped_dictionary!( 36 | | dawg_mapped => DynamicDawg::<u32>::new(), 37 | | dawg_char_mapped => DynamicDawgChar::<u32>::new(), 38 | | ); | |_- in this macro invocation | = note: this warning originates in the macro `test_mapped_dictionary` (in Nightly builds, run with -Z macro-backtrace for more info) warning: unused import: `libdictenstein::MappedDictionary` --> tests/proptest_trait_macros.rs:14:5 | 14 | use libdictenstein::MappedDictionary; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ warning: unused import: `libdictenstein::MappedDictionary` --> tests/common/macros.rs:263:29 | 263 | use libdictenstein::MappedDictionary; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ::: tests/proptest_trait_macros.rs:35:1 | 35 | / test_mapped_dictionary!( 36 | | dawg_mapped => DynamicDawg::<u32>::new(), 37 | | dawg_char_mapped => DynamicDawgChar::<u32>::new(), 38 | | ); | |_- in this macro invocation | = note: this warning originates in the macro `test_mapped_dictionary` (in Nightly builds, run with -Z macro-backtrace for more info) warning: `libdictenstein` (example "wal_size_test") generated 3 warnings (run `cargo fix --example "wal_size_test" -p libdictenstein` to apply 3 suggestions) warning: unused import: `CompactableDictionary` --> tests/proptest_core_dictionaries.rs:17:22 | 17 | use libdictenstein::{CompactableDictionary, Dictionary}; | ^^^^^^^^^^^^^^^^^^^^^ | = note: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default warning: `libdictenstein` (example "streaming_merge_test") generated 3 warnings (run `cargo fix --example "streaming_merge_test" -p libdictenstein` to apply 2 suggestions) warning: `libdictenstein` (example "wal_debug") generated 1 warning (run `cargo fix --example "wal_debug" -p libdictenstein` to apply 1 suggestion) warning: `libdictenstein` (example "batched_merge_comparison") generated 2 warnings (run `cargo fix --example "batched_merge_comparison" -p libdictenstein` to apply 1 suggestion) warning: `libdictenstein` (example "exp_checkpoint_throughput") generated 2 warnings (run `cargo fix --example "exp_checkpoint_throughput" -p libdictenstein` to apply 1 suggestion) warning: `libdictenstein` (example "test_bench") generated 1 warning (run `cargo fix --example "test_bench" -p libdictenstein` to apply 1 suggestion) warning: function `create_test_trie` is never used --> tests/persistent_artrie_acid_tests.rs:20:4 | 20 | fn create_test_trie(name: &str) -> (PersistentARTrie<u64>, PathBuf) { | ^^^^^^^^^^^^^^^^ | = note: `#[warn(dead_code)]` (part of `#[warn(unused)]`) on by default warning: function `cleanup_test_files` is never used --> tests/persistent_artrie_acid_tests.rs:31:4 | 31 | fn cleanup_test_files(path: &PathBuf) { | ^^^^^^^^^^^^^^^^^^ warning: `libdictenstein` (example "test_bench_large") generated 1 warning (run `cargo fix --example "test_bench_large" -p libdictenstein` to apply 1 suggestion) warning: `libdictenstein` (test "proptest_serialization") generated 16 warnings warning: `libdictenstein` (test "proptest_bijective") generated 16 warnings (13 duplicates) warning: `libdictenstein` (example "test_checkpoint_debug") generated 1 warning (run `cargo fix --example "test_checkpoint_debug" -p libdictenstein` to apply 1 suggestion) warning: unused `std::result::Result` that must be used --> src/double_array_trie_char.rs:1124:9 | 1124 | pat.insert_with_value("apple", 1); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled = note: `#[warn(unused_must_use)]` (part of `#[warn(unused)]`) on by default help: use `let _ = ...` to ignore the resulting value | 1124 | let _ = pat.insert_with_value("apple", 1); | +++++++ warning: unused `std::result::Result` that must be used --> src/double_array_trie_char.rs:1125:9 | 1125 | pat.insert_with_value("banana", 2); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1125 | let _ = pat.insert_with_value("banana", 2); | +++++++ warning: unused `std::result::Result` that must be used --> src/double_array_trie_char.rs:1126:9 | 1126 | pat.insert_with_value("cherry", 3); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1126 | let _ = pat.insert_with_value("cherry", 3); | +++++++ warning: unused `std::result::Result` that must be used --> src/double_array_trie_char.rs:1140:9 | 1140 | pat.insert_with_value("café", 10); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1140 | let _ = pat.insert_with_value("café", 10); | +++++++ warning: unused `std::result::Result` that must be used --> src/double_array_trie_char.rs:1141:9 | 1141 | pat.insert_with_value("日本語", 20); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1141 | let _ = pat.insert_with_value("日本語", 20); | +++++++ warning: unused `std::result::Result` that must be used --> src/double_array_trie_char.rs:1142:9 | 1142 | pat.insert_with_value("🎉", 30); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1142 | let _ = pat.insert_with_value("🎉", 30); | +++++++ warning: unused `std::result::Result` that must be used --> src/double_array_trie_char.rs:1155:9 | 1155 | pat.insert_with_value("test", 42); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1155 | let _ = pat.insert_with_value("test", 42); | +++++++ warning: unused `std::result::Result` that must be used --> src/double_array_trie_char.rs:1176:13 | 1176 | pat.insert_with_value(term, value.to_string()); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1176 | let _ = pat.insert_with_value(term, value.to_string()); | +++++++ warning: unused `std::result::Result` that must be used --> src/double_array_trie_char.rs:1191:9 | 1191 | pat.insert_with_value("cat", 1); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1191 | let _ = pat.insert_with_value("cat", 1); | +++++++ warning: unused `std::result::Result` that must be used --> src/double_array_trie_char.rs:1192:9 | 1192 | pat.insert_with_value("car", 2); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1192 | let _ = pat.insert_with_value("car", 2); | +++++++ warning: unused `std::result::Result` that must be used --> src/double_array_trie_char.rs:1193:9 | 1193 | pat.insert_with_value("cart", 3); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1193 | let _ = pat.insert_with_value("cart", 3); | +++++++ warning: unused `std::result::Result` that must be used --> src/double_array_trie_char.rs:1194:9 | 1194 | pat.insert_with_value("card", 4); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1194 | let _ = pat.insert_with_value("card", 4); | +++++++ warning: comparison is useless due to type limits --> src/persistent_artrie/arena_manager.rs:1905:17 | 1905 | assert!(stats.dirty_arenas >= 0); | ^^^^^^^^^^^^^^^^^^^^^^^ | = note: `#[warn(unused_comparisons)]` on by default warning: unused `std::result::Result` that must be used --> src/persistent_artrie_char/mod.rs:813:13 | 813 | trie.insert(&term); | ^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 813 | let _ = trie.insert(&term); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_artrie_char/dict_impl_char.rs:2951:9 | 2951 | trie.write().insert("hello"); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 2951 | let _ = trie.write().insert("hello"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_artrie_char/dict_impl_char.rs:2965:9 | 2965 | trie.write().insert("hello"); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 2965 | let _ = trie.write().insert("hello"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_artrie_char/dict_impl_char.rs:3070:9 | 3070 | trie.write().insert("persistent"); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 3070 | let _ = trie.write().insert("persistent"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_artrie_char/mmap_ctor.rs:1544:17 | 1544 | trie.insert_with_value(k, v.clone()); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1544 | let _ = trie.insert_with_value(k, v.clone()); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_artrie_char/persist.rs:1732:17 | 1732 | owned.insert_with_value(t, *v); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1732 | let _ = owned.insert_with_value(t, *v); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_artrie_char/persist.rs:2013:17 | 2013 | owned.insert_with_value(t, *v); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 2013 | let _ = owned.insert_with_value(t, *v); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_artrie_char/persist.rs:2202:17 | 2202 | owned.insert_with_value(t, *v); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 2202 | let _ = owned.insert_with_value(t, *v); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_artrie_char/persist.rs:2276:17 | 2276 | owned.insert_with_value(t, *v); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 2276 | let _ = owned.insert_with_value(t, *v); | +++++++ warning: comparison is useless due to type limits --> src/persistent_artrie_core/prefetch.rs:532:17 | 532 | assert!(stats.requests >= 0); | ^^^^^^^^^^^^^^^^^^^ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:318:9 | 318 | vocab.insert("apple"); | ^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 318 | let _ = vocab.insert("apple"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:319:9 | 319 | vocab.insert("banana"); | ^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 319 | let _ = vocab.insert("banana"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:320:9 | 320 | vocab.insert("cherry"); | ^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 320 | let _ = vocab.insert("cherry"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:334:9 | 334 | vocab.insert("apple"); | ^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 334 | let _ = vocab.insert("apple"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:335:9 | 335 | vocab.insert("banana"); | ^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 335 | let _ = vocab.insert("banana"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:336:9 | 336 | vocab.insert("cherry"); | ^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 336 | let _ = vocab.insert("cherry"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:387:13 | 387 | vocab.insert("hello"); | ^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 387 | let _ = vocab.insert("hello"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:388:13 | 388 | vocab.insert("world"); | ^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 388 | let _ = vocab.insert("world"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:389:13 | 389 | vocab.insert("test"); | ^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 389 | let _ = vocab.insert("test"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:414:13 | 414 | vocab.insert("apple"); | ^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 414 | let _ = vocab.insert("apple"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:415:13 | 415 | vocab.insert("banana"); | ^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 415 | let _ = vocab.insert("banana"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:423:13 | 423 | vocab.insert("cherry"); | ^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 423 | let _ = vocab.insert("cherry"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:424:13 | 424 | vocab.insert("durian"); | ^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 424 | let _ = vocab.insert("durian"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:445:9 | 445 | vocab.insert("present"); | ^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 445 | let _ = vocab.insert("present"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:467:9 | 467 | vocab.insert("test"); | ^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 467 | let _ = vocab.insert("test"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:498:13 | 498 | vocab.insert("term1"); | ^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 498 | let _ = vocab.insert("term1"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:499:13 | 499 | vocab.insert("term2"); | ^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 499 | let _ = vocab.insert("term2"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:500:13 | 500 | vocab.insert("term3"); | ^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 500 | let _ = vocab.insert("term3"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:524:13 | 524 | vocab.insert("apple"); | ^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 524 | let _ = vocab.insert("apple"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:525:13 | 525 | vocab.insert("banana"); | ^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 525 | let _ = vocab.insert("banana"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:532:13 | 532 | vocab.insert("cherry"); | ^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 532 | let _ = vocab.insert("cherry"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:533:13 | 533 | vocab.insert("durian"); | ^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 533 | let _ = vocab.insert("durian"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:743:13 | 743 | vocab.insert("with_value_1"); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 743 | let _ = vocab.insert("with_value_1"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:744:13 | 744 | vocab.insert("with_value_2"); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 744 | let _ = vocab.insert("with_value_2"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:745:13 | 745 | vocab.insert("with_value_3"); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 745 | let _ = vocab.insert("with_value_3"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:797:9 | 797 | vocab.write().insert("hello"); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 797 | let _ = vocab.write().insert("hello"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:809:9 | 809 | vocab.write().insert("world"); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 809 | let _ = vocab.write().insert("world"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:825:9 | 825 | vocab.insert("hello"); | ^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 825 | let _ = vocab.insert("hello"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:833:9 | 833 | vocab.insert("world"); | ^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 833 | let _ = vocab.insert("world"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:857:17 | 857 | vocab.insert(&format!("word{}", i)); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 857 | let _ = vocab.insert(&format!("word{}", i)); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:886:9 | 886 | vocab.insert("hello"); | ^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 886 | let _ = vocab.insert("hello"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:889:9 | 889 | vocab.insert("world"); | ^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 889 | let _ = vocab.insert("world"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:921:13 | 921 | vocab.insert("hello"); | ^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 921 | let _ = vocab.insert("hello"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:922:13 | 922 | vocab.insert("world"); | ^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 922 | let _ = vocab.insert("world"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:958:13 | 958 | vocab.write().insert(&format!("initial_{}", i)); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 958 | let _ = vocab.write().insert(&format!("initial_{}", i)); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:979:17 | 979 | vocab_clone2.write().insert(&format!("concurrent_{}", i)); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 979 | let _ = vocab_clone2.write().insert(&format!("concurrent_{}", i)); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:1012:9 | 1012 | vocab.insert("test"); | ^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1012 | let _ = vocab.insert("test"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:1160:13 | 1160 | vocab.insert("simple"); | ^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1160 | let _ = vocab.insert("simple"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:1161:13 | 1161 | vocab.insert("日本語"); | ^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1161 | let _ = vocab.insert("日本語"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:1162:13 | 1162 | vocab.insert(""); | ^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1162 | let _ = vocab.insert(""); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:1163:13 | 1163 | vocab.insert("with spaces and punctuation!"); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1163 | let _ = vocab.insert("with spaces and punctuation!"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:1164:13 | 1164 | vocab.insert(&"x".repeat(100)); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1164 | let _ = vocab.insert(&"x".repeat(100)); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:1202:17 | 1202 | vocab.insert(&format!("term_{:05}", i)); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1202 | let _ = vocab.insert(&format!("term_{:05}", i)); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:1231:9 | 1231 | vocab.insert("test"); | ^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1231 | let _ = vocab.insert("test"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:1244:9 | 1244 | vocab.insert("test"); | ^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1244 | let _ = vocab.insert("test"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:1262:9 | 1262 | vocab.insert("test"); | ^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1262 | let _ = vocab.insert("test"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:1283:9 | 1283 | vocab.insert("first"); | ^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1283 | let _ = vocab.insert("first"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:1286:9 | 1286 | vocab.insert("second"); | ^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1286 | let _ = vocab.insert("second"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:1290:9 | 1290 | vocab.insert("first"); | ^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1290 | let _ = vocab.insert("first"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:1302:13 | 1302 | vocab.insert("test"); | ^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1302 | let _ = vocab.insert("test"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:1354:9 | 1354 | vocab.insert("apple"); | ^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1354 | let _ = vocab.insert("apple"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:1355:9 | 1355 | vocab.insert("banana"); | ^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1355 | let _ = vocab.insert("banana"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:1426:9 | 1426 | vocab.insert("hello"); | ^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1426 | let _ = vocab.insert("hello"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:1427:9 | 1427 | vocab.insert("world"); | ^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1427 | let _ = vocab.insert("world"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:1448:13 | 1448 | vocab.insert("apple"); | ^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1448 | let _ = vocab.insert("apple"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:1449:13 | 1449 | vocab.insert("banana"); | ^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1449 | let _ = vocab.insert("banana"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:1474:9 | 1474 | vocab.insert_batch(&["apple", "banana"]); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1474 | let _ = vocab.insert_batch(&["apple", "banana"]); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:1477:9 | 1477 | vocab.insert_batch(&["cherry", "date"]); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1477 | let _ = vocab.insert_batch(&["cherry", "date"]); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/dict_impl.rs:1480:9 | 1480 | vocab.insert_batch(&["elderberry"]); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1480 | let _ = vocab.insert_batch(&["elderberry"]); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/mod.rs:1162:9 | 1162 | vocab.insert("日本語"); | ^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1162 | let _ = vocab.insert("日本語"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/mod.rs:1163:9 | 1163 | vocab.insert("中文"); | ^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1163 | let _ = vocab.insert("中文"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/mod.rs:1164:9 | 1164 | vocab.insert("한글"); | ^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1164 | let _ = vocab.insert("한글"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/mod.rs:1165:9 | 1165 | vocab.insert("العربية"); | ^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1165 | let _ = vocab.insert("العربية"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/mod.rs:1166:9 | 1166 | vocab.insert("emoji😀"); | ^^^^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1166 | let _ = vocab.insert("emoji😀"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/mod.rs:1222:9 | 1222 | vocab.insert("test"); | ^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1222 | let _ = vocab.insert("test"); | +++++++ warning: unused `std::result::Result` that must be used --> src/persistent_vocab_artrie/mod.rs:1264:9 | 1264 | vocab.insert("test"); | ^^^^^^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 1264 | let _ = vocab.insert("test"); | +++++++ warning: unused `Result` that must be used --> tests/bijective_trait_invariant.rs:60:13 | 60 | vocab.insert(t); | ^^^^^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled = note: `#[warn(unused_must_use)]` (part of `#[warn(unused)]`) on by default help: use `let _ = ...` to ignore the resulting value | 60 | let _ = vocab.insert(t); | +++++++ warning: unused `Result` that must be used --> tests/bijective_trait_invariant.rs:107:17 | 107 | g.insert(t); | ^^^^^^^^^^^ | = note: this `Result` may be an `Err` variant, which should be handled help: use `let _ = ...` to ignore the resulting value | 107 | let _ = g.insert(t); | +++++++ warning: `libdictenstein` (test "persistent_artrie_char_integration") generated 81 warnings warning: variable does not need to be mutable --> examples/insert_trace.rs:9:9 | 9 | let mut trie: PersistentARTrie<()> = PersistentARTrie::create(&path).expect("create trie"); | ----^^^^ | | | help: remove this `mut` | = note: `#[warn(unused_mut)]` (part of `#[warn(unused)]`) on by default warning: `libdictenstein` (test "proptest_zipper_operations") generated 15 warnings (15 duplicates) warning: `libdictenstein` (test "proptest_trait_macros") generated 21 warnings (17 duplicates) warning: `libdictenstein` (test "persistent_artrie_acid_tests") generated 2 warnings warning: unused import: `libdictenstein::MappedDictionary` --> tests/serialization_value_roundtrip.rs:34:5 | 34 | use libdictenstein::MappedDictionary; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default warning: use of deprecated associated function `libdictenstein::persistent_artrie::mmap_ctor::<impl libdictenstein::PersistentARTrie<V>>::new`: Use `create()` or `open()` for disk persistence. For in-memory tries, use DoubleArrayTrie or DynamicDawg instead. --> examples/bench_disk_io.rs:59:68 | 59 | let mut trie: PersistentARTrie<()> = PersistentARTrie::new(); | ^^^ | = note: `#[warn(deprecated)]` on by default warning: variable does not need to be mutable --> examples/bench_disk_io.rs:59:17 | 59 | let mut trie: PersistentARTrie<()> = PersistentARTrie::new(); | ----^^^^ | | | help: remove this `mut` | = note: `#[warn(unused_mut)]` (part of `#[warn(unused)]`) on by default warning: unused variable: `path` --> examples/bench_disk_io.rs:55:13 | 55 | let path = dir.path().join("bench.dat"); | ^^^^ help: if this is intentional, prefix it with an underscore: `_path` | = note: `#[warn(unused_variables)]` (part of `#[warn(unused)]`) on by default warning: `libdictenstein` (test "bijective_trait_invariant") generated 2 warnings warning: use of deprecated type alias `libdictenstein::persistent_artrie_char::SharedCharTrie`: Use SharedCharARTrie instead --> tests/persistent_arbitrary_v_overlay.rs:25:68 | 25 | use libdictenstein::persistent_artrie_char::{PersistentARTrieChar, SharedCharTrie}; | ^^^^^^^^^^^^^^ | = note: `#[warn(deprecated)]` on by default warning: use of deprecated type alias `libdictenstein::persistent_artrie_char::SharedCharTrie`: Use SharedCharARTrie instead --> tests/persistent_arbitrary_v_overlay.rs:267:9 | 267 | SharedCharTrie::create(&dir.path().join("a.artc")).expect("create a"); | ^^^^^^^^^^^^^^ warning: use of deprecated type alias `libdictenstein::persistent_artrie_char::SharedCharTrie`: Use SharedCharARTrie instead --> tests/persistent_arbitrary_v_overlay.rs:266:12 | 266 | let a: SharedCharTrie<u64> = | ^^^^^^^^^^^^^^ warning: use of deprecated type alias `libdictenstein::persistent_artrie_char::SharedCharTrie`: Use SharedCharARTrie instead --> tests/persistent_arbitrary_v_overlay.rs:269:9 | 269 | SharedCharTrie::create(&dir.path().join("b.artc")).expect("create b"); | ^^^^^^^^^^^^^^ warning: use of deprecated type alias `libdictenstein::persistent_artrie_char::SharedCharTrie`: Use SharedCharARTrie instead --> tests/persistent_arbitrary_v_overlay.rs:268:12 | 268 | let b: SharedCharTrie<u64> = | ^^^^^^^^^^^^^^ warning: `libdictenstein` (example "insert_trace") generated 1 warning (run `cargo fix --example "insert_trace" -p libdictenstein` to apply 1 suggestion) warning: `libdictenstein` (test "double_array_trie_correspondence") generated 17 warnings (17 duplicates) warning: `libdictenstein` (test "proptest_core_dictionaries") generated 14 warnings (13 duplicates) warning: `libdictenstein` (test "dynamic_dawg_mutation_correspondence") generated 16 warnings (16 duplicates) warning: `libdictenstein` (test "dictionary_law_correspondence") generated 13 warnings (13 duplicates) warning: variable does not need to be mutable --> examples/prefix_diversity_test.rs:11:13 | 11 | let mut trie: PersistentARTrie<()> = PersistentARTrie::create(&path).expect("create"); | ----^^^^ | | | help: remove this `mut` | = note: `#[warn(unused_mut)]` (part of `#[warn(unused)]`) on by default warning: variable does not need to be mutable --> examples/prefix_diversity_test.rs:28:13 | 28 | let mut trie: PersistentARTrie<()> = PersistentARTrie::create(&path).expect("create"); | ----^^^^ | | | help: remove this `mut` warning: variable does not need to be mutable --> examples/prefix_diversity_test.rs:48:13 | 48 | let mut trie: PersistentARTrie<()> = PersistentARTrie::create(&path).expect("create"); | ----^^^^ | | | help: remove this `mut` warning: variable does not need to be mutable --> examples/wal_flush_debug.rs:16:13 | 16 | let mut trie: PersistentARTrie<()> = PersistentARTrie::create(&path).expect("create trie"); | ----^^^^ | | | help: remove this `mut` | = note: `#[warn(unused_mut)]` (part of `#[warn(unused)]`) on by default warning: `libdictenstein` (example "bench_disk_io") generated 3 warnings (run `cargo fix --example "bench_disk_io" -p libdictenstein` to apply 2 suggestions) warning: unused import: `libdictenstein::SubstringDictionary` --> tests/scdawg_core_parity.rs:14:5 | 14 | use libdictenstein::SubstringDictionary; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default warning: function `generate_highly_diverse_terms` is never used --> tests/persistent_artrie_stress.rs:33:4 | 33 | fn generate_highly_diverse_terms(count: usize) -> Vec<String> { | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: `#[warn(dead_code)]` (part of `#[warn(unused)]`) on by default warning: variable does not need to be mutable --> examples/wal_compare.rs:18:17 | 18 | let mut trie: PersistentARTrie<()> = | ----^^^^ | | | help: remove this `mut` | = note: `#[warn(unused_mut)]` (part of `#[warn(unused)]`) on by default warning: variable does not need to be mutable --> examples/wal_compare.rs:36:17 | 36 | let mut trie: PersistentARTrie<()> = | ----^^^^ | | | help: remove this `mut` warning: `libdictenstein` (example "wal_flush_debug") generated 1 warning (run `cargo fix --example "wal_flush_debug" -p libdictenstein` to apply 1 suggestion) warning: `libdictenstein` (test "scdawg_core_parity") generated 1 warning warning: `libdictenstein` (example "prefix_diversity_test") generated 3 warnings (run `cargo fix --example "prefix_diversity_test" -p libdictenstein` to apply 3 suggestions) warning: `libdictenstein` (test "serialization_value_roundtrip") generated 1 warning warning: `libdictenstein` (test "valued_set_combinator_correspondence") generated 17 warnings (17 duplicates) warning: `libdictenstein` (example "wal_compare") generated 2 warnings (run `cargo fix --example "wal_compare" -p libdictenstein` to apply 2 suggestions) warning: `libdictenstein` (test "persistent_artrie_recovery_tests") generated 49 warnings warning: `libdictenstein` (test "serialization_correspondence") generated 16 warnings (16 duplicates) warning: `libdictenstein` (test "dynamic_dawg_u64_correspondence") generated 17 warnings (17 duplicates) warning: `libdictenstein` (test "persistent_artrie_stress") generated 1 warning warning: `libdictenstein` (test "persistent_arbitrary_v_overlay") generated 5 warnings warning: `libdictenstein` (test "zipper_language_correspondence") generated 15 warnings (15 duplicates) warning: `libdictenstein` (lib test) generated 165 warnings (15 duplicates) Finished `test` profile [unoptimized + debuginfo] target(s) in 18.21s ──────────── Nextest run ID a2da94b4-0aad-4c27-855b-e140ead7fcbb with nextest profile: default Starting 3 tests across 1 binary (88 binaries skipped) PASS [ 0.006s] (1/3) libdictenstein::persistent_lockfree_f4_lock_hierarchy_loom disable_releases_ec_before_join PASS [ 3.751s] (2/3) libdictenstein::persistent_lockfree_f4_lock_hierarchy_loom checkpoint_evict_disable_writer_is_deadlock_free SLOW [> 30.000s] (───) libdictenstein::persistent_lockfree_f4_lock_hierarchy_loom full_hierarchy_no_cycle PASS [ 57.039s] (3/3) libdictenstein::persistent_lockfree_f4_lock_hierarchy_loom full_hierarchy_no_cycle ──────────── Summary [ 57.039s] 3 tests run: 3 passed (1 slow), 0 skipped