diff --git a/.github/workflows/clippy.yml b/.github/workflows/clippy.yml
new file mode 100644
index 00000000..91433ef7
--- /dev/null
+++ b/.github/workflows/clippy.yml
@@ -0,0 +1,35 @@
+name: Clippy
+
+on:
+  push:
+    branches: ["master"]
+  pull_request:
+    branches: ["master"]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  clippy:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Install Clippy
+        run:
+          rustup toolchain install nightly --component clippy
+      - name: Set up Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: nightly
+          override: true
+      - name: Run clippy
+        run: cargo clippy --all-features
+      - name: Run clippy without rayon
+        run: cargo clippy --no-default-features --features="serde"
+      - name: Run tests
+        run: cargo test --all-features
+      - name: Run tests without rayon
+        run: cargo test --no-default-features --features="serde"
+      - name: Run tests release
+        run: cargo test --release --all-features
\ No newline at end of file
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 64afdc10..dafb94d7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,17 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ## [Unreleased]
 
+## [v0.3.1]
+- Added derives across all data structures, including:
+  - `Clone`
+  - `Debug`
+  - serde's `Serialize` & `Deserialize`, available under the feature `serde`.
+  - [mem-dbg](https://github.com/zommiommy/mem_dbg-rs)'s `MemDbg` & `MemSize`, available under the feature `mem-dbg`.
+- Moved rayon, which is optionally used in dependency crates, under the feature `rayon`.
+- Switched from Travis-CI to GitHub Actions.
+- Fixed several code smells as reported by clippy.
+- Extended documentation & doctests.
+
 ## [v0.3.0]
 - Use iterators for search results.
 
diff --git a/Cargo.toml b/Cargo.toml
index 3d0ba1dd..d5e2c9d1 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "trie-rs"
-version = "0.3.0"
+version = "0.3.1"
 authors = ["Sho Nakatani <lay.sakura@gmail.com>", "Shane Celis <shane.celis@gmail.com>"]
 description = "Memory efficient trie (prefix tree) and map library based on LOUDS"
 readme = "README.md"
@@ -9,10 +9,12 @@ repository = "https://github.com/laysakura/trie-rs"
 homepage = "https://github.com/laysakura/trie-rs"
 keywords = ["trie", "louds", "succinct"] # up to 5 keywords, each keyword should have <= 20 chars
 categories = ["compression", "data-structures"]
-edition = "2018"
+edition = "2021"
 
 [dependencies]
 louds-rs = "0.6"
+mem_dbg = { version = "0.1.4", optional = true }
+serde = { version = "1.0", features = ["derive"], optional = true }
 
 [dev-dependencies]
 criterion = "0.2"
@@ -23,3 +25,8 @@ version-sync = "0.9"
 [[bench]]
 name = "bench"
 harness = false
+
+[features]
+serde = ["louds-rs/serde", "dep:serde"]
+mem_dbg = ["louds-rs/mem_dbg", "dep:mem_dbg"]
+rayon = ["louds-rs/rayon"]
\ No newline at end of file
diff --git a/README.md b/README.md
index 8bfb6efe..1393b1fa 100644
--- a/README.md
+++ b/README.md
@@ -10,7 +10,8 @@ Memory efficient trie (prefix tree) and map library based on LOUDS.
 |
 [Changelog](https://github.com/laysakura/trie-rs/blob/master/CHANGELOG.md)
 
-[![Build Status](https://travis-ci.com/laysakura/trie-rs.svg?branch=master)](https://travis-ci.com/laysakura/trie-rs)
+[![GitHub Actions Status](https://github.com/laysakura/trie-rs/actions/workflows/clippy.yml/badge.svg)](https://github.com/laysakura/trie-rs/actions)
+[![Travis Status](https://travis-ci.com/laysakura/trie-rs.svg?branch=master)](https://travis-ci.com/laysakura/trie-rs)
 [![Crates.io Version](https://img.shields.io/crates/v/trie-rs.svg)](https://crates.io/crates/trie-rs)
 [![Crates.io Downloads](https://img.shields.io/crates/d/trie-rs.svg)](https://crates.io/crates/trie-rs)
 [![Minimum rustc version](https://img.shields.io/badge/rustc-1.33+-lightgray.svg)](https://github.com/laysakura/trie-rs#rust-version-supports)
@@ -78,7 +79,7 @@ assert_eq!(
 ### Using with Various Data Types
 `TrieBuilder` is implemented using generic type like following:
 
-```rust
+```ignore
 impl<Label: Ord> TrieBuilder<Label> {
     ...
     pub fn push<Arr: AsRef<[Label]>>(&mut self, word: Arr) where Label: Clone { ... }
diff --git a/benches/bench.rs b/benches/bench.rs
index d23b8c64..edda7372 100644
--- a/benches/bench.rs
+++ b/benches/bench.rs
@@ -248,9 +248,14 @@ mod trie {
                     |trie| {
                         // iter_batched() does not properly time `routine` time when `setup` time is far longer than `routine` time.
                         // Tested function takes too short compared to build(). So loop many times.
-                        let result = trie.common_prefix_search::<Vec<u8>, _>("すしをにぎる").next().is_some();
+                        let result = trie
+                            .common_prefix_search::<Vec<u8>, _>("すしをにぎる")
+                            .next()
+                            .is_some();
                         for _ in 0..(times - 1) {
-                            trie.common_prefix_search::<Vec<u8>, _>("すしをにぎる").next().is_some();
+                            trie.common_prefix_search::<Vec<u8>, _>("すしをにぎる")
+                                .next()
+                                .is_some();
                         }
 
                         assert_eq!(result, true);
diff --git a/src/inc_search.rs b/src/inc_search.rs
index a7fcba1f..797ba102 100644
--- a/src/inc_search.rs
+++ b/src/inc_search.rs
@@ -9,12 +9,16 @@
 //! the number of entries in the trie. Consider this loop where we simulate
 //! accumulating a query.
 //!
-//! ```ignore
+//! ```rust
+//! use trie_rs::Trie;
+//! 
 //! let q = "appli"; // query string
 //! let mut is_match: bool;
-//! for i = 0..q.len() {
-//!     is_match = trie.exact_match(q[0..i]);
+//! let trie = Trie::from_iter(vec!["appli", "application"]);
+//! for i in 0..q.len() - 1 {
+//!     assert!(!trie.exact_match(&q[0..i]));
 //! }
+//! assert!(trie.exact_match(q));
 //! ```
 //!
 //! Building the query one "character" at a time and `exact_match()`ing each
@@ -37,6 +41,7 @@
 use crate::map::Trie;
 use louds_rs::LoudsNodeNum;
 
+#[derive(Debug, Clone)]
 /// An incremental search of the trie.
 pub struct IncSearch<'a, Label, Value> {
     trie: &'a Trie<Label, Value>,
diff --git a/src/internal_data_structure/naive_trie.rs b/src/internal_data_structure/naive_trie.rs
index a76c19b7..c5e2ca21 100644
--- a/src/internal_data_structure/naive_trie.rs
+++ b/src/internal_data_structure/naive_trie.rs
@@ -1,6 +1,12 @@
-pub mod naive_trie;
 pub mod naive_trie_b_f_iter;
+pub mod naive_trie_impl;
 
+#[cfg(feature = "mem_dbg")]
+use mem_dbg::MemDbg;
+
+#[derive(Debug, Clone)]
+#[cfg_attr(feature = "mem_dbg", derive(mem_dbg::MemDbg, mem_dbg::MemSize))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 /// Naive trie with ordered Label sequence in edges.
 ///
 /// The following naive trie contains these words.
@@ -72,11 +78,17 @@ pub enum NaiveTrie<Label, Value> {
     PhantomSibling,
 }
 
+#[derive(Debug, Clone)]
+#[cfg_attr(feature = "mem_dbg", derive(mem_dbg::MemDbg, mem_dbg::MemSize))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct NaiveTrieRoot<Label, Value> {
     /// Sorted by Label's order.
     children: Vec<NaiveTrie<Label, Value>>,
 }
 
+#[derive(Debug, Clone)]
+#[cfg_attr(feature = "mem_dbg", derive(mem_dbg::MemDbg, mem_dbg::MemSize))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct NaiveTrieIntermOrLeaf<Label, Value> {
     /// Sorted by Label's order.
     children: Vec<NaiveTrie<Label, Value>>,
diff --git a/src/internal_data_structure/naive_trie/naive_trie_b_f_iter.rs b/src/internal_data_structure/naive_trie/naive_trie_b_f_iter.rs
index cd79c538..3f95d4d1 100644
--- a/src/internal_data_structure/naive_trie/naive_trie_b_f_iter.rs
+++ b/src/internal_data_structure/naive_trie/naive_trie_b_f_iter.rs
@@ -1,6 +1,12 @@
 use super::NaiveTrie;
 use std::collections::VecDeque;
 
+#[cfg(feature = "mem_dbg")]
+use mem_dbg::MemDbg;
+
+#[derive(Debug, Clone)]
+#[cfg_attr(feature = "mem_dbg", derive(mem_dbg::MemDbg, mem_dbg::MemSize))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 /// Iterates over NaiveTrie in Breadth-First manner.
 pub struct NaiveTrieBFIter<Label, Value> {
     unvisited: VecDeque<NaiveTrie<Label, Value>>,
diff --git a/src/internal_data_structure/naive_trie/naive_trie.rs b/src/internal_data_structure/naive_trie/naive_trie_impl.rs
similarity index 100%
rename from src/internal_data_structure/naive_trie/naive_trie.rs
rename to src/internal_data_structure/naive_trie/naive_trie_impl.rs
diff --git a/src/iter/keys.rs b/src/iter/keys.rs
index 70cb1f4e..61caca48 100644
--- a/src/iter/keys.rs
+++ b/src/iter/keys.rs
@@ -1,8 +1,9 @@
+#[derive(Debug, Clone)]
 /// Strips off `Value`s from [crate::map::Trie].
 pub struct Keys<I>(I);
 
 impl<I> Keys<I> {
-    ///
+    ///Creates a new `Keys` iterator.
     pub fn new(iter: I) -> Self {
         Self(iter)
     }
diff --git a/src/iter/postfix_iter.rs b/src/iter/postfix_iter.rs
index 123d76b0..c1f0a3f4 100644
--- a/src/iter/postfix_iter.rs
+++ b/src/iter/postfix_iter.rs
@@ -3,6 +3,7 @@ use crate::try_collect::{TryCollect, TryFromIterator};
 use louds_rs::LoudsNodeNum;
 use std::marker::PhantomData;
 
+#[derive(Debug, Clone)]
 /// Iterates through all the postfixes of a matching query.
 pub struct PostfixIter<'a, Label, Value, C, M> {
     trie: &'a Trie<Label, Value>,
diff --git a/src/iter/prefix_iter.rs b/src/iter/prefix_iter.rs
index 3ab5374a..1a0c8972 100644
--- a/src/iter/prefix_iter.rs
+++ b/src/iter/prefix_iter.rs
@@ -3,6 +3,7 @@ use crate::try_collect::{TryCollect, TryFromIterator};
 use louds_rs::LoudsNodeNum;
 use std::marker::PhantomData;
 
+#[derive(Debug, Clone)]
 /// Iterates through all the common prefixes of a given query.
 pub struct PrefixIter<'a, Label, Value, C, M> {
     trie: &'a Trie<Label, Value>,
diff --git a/src/iter/search_iter.rs b/src/iter/search_iter.rs
index d9d14a9b..fbc7df47 100644
--- a/src/iter/search_iter.rs
+++ b/src/iter/search_iter.rs
@@ -4,6 +4,7 @@ use crate::try_collect::{Collect, TryCollect, TryFromIterator};
 use louds_rs::LoudsNodeNum;
 use std::marker::PhantomData;
 
+#[derive(Debug, Clone)]
 /// Iterates through all the matches of a query.
 pub struct SearchIter<'a, Label, Value, C, M> {
     prefix: Vec<Label>,
diff --git a/src/lib.rs b/src/lib.rs
index c90664bd..05def48a 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,262 +1,5 @@
-#![doc(html_root_url = "https://docs.rs/trie-rs/0.3.0")]
 #![forbid(missing_docs)]
-//! Memory efficient trie (prefix tree) and map library based on LOUDS.
-//!
-//! [Master API Docs](https://laysakura.github.io/trie-rs/trie_rs/)
-//! |
-//! [Released API Docs](https://docs.rs/crate/trie-rs)
-//! |
-//! [Benchmark Results](https://laysakura.github.io/trie-rs/criterion/report/)
-//! |
-//! [Changelog](https://github.com/laysakura/trie-rs/blob/master/CHANGELOG.md)
-//!
-//! [![Build Status](https://travis-ci.com/laysakura/trie-rs.svg?branch=master)](https://travis-ci.com/laysakura/trie-rs)
-//! [![Crates.io Version](https://img.shields.io/crates/v/trie-rs.svg)](https://crates.io/crates/trie-rs)
-//! [![Crates.io Downloads](https://img.shields.io/crates/d/trie-rs.svg)](https://crates.io/crates/trie-rs)
-//! [![Minimum rustc version](https://img.shields.io/badge/rustc-1.33+-lightgray.svg)](https://github.com/laysakura/trie-rs#rust-version-supports)
-//! [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/laysakura/trie-rs/blob/master/LICENSE-MIT)
-//! [![License: Apache 2.0](https://img.shields.io/badge/license-Apache_2.0-blue.svg)](https://github.com/laysakura/trie-rs/blob/master/LICENSE-APACHE)
-//!
-//! # Quickstart
-//!
-//! To use trie-rs, add the following to your `Cargo.toml` file:
-//!
-//! ```toml
-//! [dependencies]
-//! trie-rs = "0.3"
-//! ```
-//!
-//! ## Usage Overview
-//! ```rust
-//! use std::str;
-//! use trie_rs::TrieBuilder;
-//!
-//! let mut builder = TrieBuilder::new();  // Inferred `TrieBuilder<u8>` automatically
-//! builder.push("すし");
-//! builder.push("すしや");
-//! builder.push("すしだね");
-//! builder.push("すしづめ");
-//! builder.push("すしめし");
-//! builder.push("すしをにぎる");
-//! builder.push("すし");  // Word `push`ed twice is just ignored.
-//! builder.push("🍣");
-//!
-//! let trie = builder.build();
-//!
-//! // exact_match(): Find a word exactly match to query.
-//! assert_eq!(trie.exact_match("すし"), true);
-//! assert_eq!(trie.exact_match("🍣"), true);
-//! assert_eq!(trie.exact_match("🍜"), false);
-//!
-//! // predictive_search(): Find words which include `query` as their prefix.
-//! let results_in_u8s: Vec<Vec<u8>> = trie.predictive_search("すし").collect();
-//! let results_in_str: Vec<String> = trie.predictive_search("すし").collect();
-//! assert_eq!(
-//!     results_in_str,
-//!     vec![
-//!         "すし",
-//!         "すしだね",
-//!         "すしづめ",
-//!         "すしめし",
-//!         "すしや",
-//!         "すしをにぎる"
-//!     ]  // Sorted by `Vec<u8>`'s order
-//! );
-//!
-//! // common_prefix_search(): Find words which is included in `query`'s prefix.
-//! let results_in_u8s: Vec<Vec<u8>> = trie.common_prefix_search("すしや").collect();
-//! let results_in_str: Vec<String> = trie.common_prefix_search("すしや").collect();
-//! assert_eq!(
-//!     results_in_str,
-//!     vec![
-//!         "すし",
-//!         "すしや",
-//!     ]  // Sorted by `Vec<u8>`'s order
-//! );
-//! ```
-//!
-//! ## Using with Various Data Types
-//! `TrieBuilder` is implemented using generic type like following:
-//!
-//! ```ignore
-//! impl<Label: Ord> TrieBuilder<Label> {
-//!     ...
-//!     pub fn push<Arr: AsRef<[Label]>>(&mut self, word: Arr) where Label: Clone { ... }
-//!     ...
-//! }
-//! ```
-//!
-//! In the above `Usage Overview` example, we used `Label=u8, Arr=&str`. If
-//! `Label` does not implement `Clone`, use
-//! [`insert()`][crate::trie::TrieBuilder::insert].
-//!
-//! Here shows other `Label` and `Arr` type examples.
-//!
-//! ### `Label=&str, Arr=Vec<&str>`
-//! Say `Label` is English words and `Arr` is English phrases.
-//!
-//! ```rust
-//! use trie_rs::TrieBuilder;
-//!
-//! let mut builder = TrieBuilder::new();
-//! builder.push(vec!["a", "woman"]);
-//! builder.push(vec!["a", "woman", "on", "the", "beach"]);
-//! builder.push(vec!["a", "woman", "on", "the", "run"]);
-//!
-//! let trie = builder.build();
-//!
-//! assert_eq!(
-//!     trie.exact_match(vec!["a", "woman", "on", "the", "beach"]),
-//!     true
-//! );
-//! let r: Vec<Vec<&str>> = trie.predictive_search(vec!["a", "woman", "on"]).collect();
-//! assert_eq!(
-//!     r,
-//!     vec![
-//!         ["a", "woman", "on", "the", "beach"],
-//!         ["a", "woman", "on", "the", "run"],
-//!     ],
-//! );
-//! let s: Vec<Vec<&str>> = trie.common_prefix_search(vec!["a", "woman", "on", "the", "beach"]).collect();
-//! assert_eq!(
-//!     s,
-//!     vec![vec!["a", "woman"], vec!["a", "woman", "on", "the", "beach"]],
-//! );
-//! ```
-//!
-//! ### `Label=u8, Arr=[u8; n]`
-//! Say `Label` is a digit in Pi (= 3.14...) and Arr is a window to separate pi's digit by 10.
-//!
-//! ```rust
-//! use trie_rs::TrieBuilder;
-//!
-//! let mut builder = TrieBuilder::<u8>::new(); // Pi = 3.14...
-//!
-//! builder.push([1, 4, 1, 5, 9, 2, 6, 5, 3, 5]);
-//! builder.push([8, 9, 7, 9, 3, 2, 3, 8, 4, 6]);
-//! builder.push([2, 6, 4, 3, 3, 8, 3, 2, 7, 9]);
-//! builder.push([6, 9, 3, 9, 9, 3, 7, 5, 1, 0]);
-//! builder.push([5, 8, 2, 0, 9, 7, 4, 9, 4, 4]);
-//! builder.push([5, 9, 2, 3, 0, 7, 8, 1, 6, 4]);
-//! builder.push([0, 6, 2, 8, 6, 2, 0, 8, 9, 9]);
-//! builder.push([8, 6, 2, 8, 0, 3, 4, 8, 2, 5]);
-//! builder.push([3, 4, 2, 1, 1, 7, 0, 6, 7, 9]);
-//! builder.push([8, 2, 1, 4, 8, 0, 8, 6, 5, 1]);
-//! builder.push([3, 2, 8, 2, 3, 0, 6, 6, 4, 7]);
-//! builder.push([0, 9, 3, 8, 4, 4, 6, 0, 9, 5]);
-//! builder.push([5, 0, 5, 8, 2, 2, 3, 1, 7, 2]);
-//! builder.push([5, 3, 5, 9, 4, 0, 8, 1, 2, 8]);
-//!
-//! let trie = builder.build();
-//!
-//! assert_eq!(trie.exact_match([5, 3, 5, 9, 4, 0, 8, 1, 2, 8]), true);
-//!
-//! let t: Vec<Vec<u8>> = trie.predictive_search([3]).collect();
-//! assert_eq!(
-//!     t,
-//!     vec![
-//!         [3, 2, 8, 2, 3, 0, 6, 6, 4, 7],
-//!         [3, 4, 2, 1, 1, 7, 0, 6, 7, 9],
-//!     ],
-//! );
-//! let u: Vec<Vec<u8>> = trie.common_prefix_search([1, 4, 1, 5, 9, 2, 6, 5, 3, 5]).collect();
-//! assert_eq!(
-//!     u,
-//!     vec![[1, 4, 1, 5, 9, 2, 6, 5, 3, 5]],
-//! );
-//! ```
-//!
-//! ## Trie Map Usage
-//!
-//! To store a value with each word, use `trie_rs::map::{Trie, TrieBuilder}`.
-//!
-//! ```rust
-//! use std::str;
-//! use trie_rs::map::TrieBuilder;
-//!
-//! let mut builder = TrieBuilder::new();  // Inferred `TrieBuilder<u8, u8>` automatically
-//! builder.push("すし", 0);
-//! builder.push("すしや", 1);
-//! builder.push("すしだね", 2);
-//! builder.push("すしづめ", 3);
-//! builder.push("すしめし", 4);
-//! builder.push("すしをにぎる", 5);
-//! builder.push("すし", 6);  // Word `push`ed twice is just ignored.
-//! builder.push("🍣", 7);
-//!
-//! let mut trie = builder.build();
-//!
-//! // exact_match(): Find a word exactly match to query.
-//! assert_eq!(trie.exact_match("すし"), Some(&0));
-//! assert_eq!(trie.exact_match("🍣"), Some(&7));
-//! assert_eq!(trie.exact_match("🍜"), None);
-//!
-//! // Values can be modified.
-//! let v = trie.exact_match_mut("🍣").unwrap();
-//! *v = 8;
-//! assert_eq!(trie.exact_match("🍣"), Some(&8));
-//! ```
-//!
-//! ## Incremental Search
-//!
-//! For interactive applications, one can use an incremental search to get the
-//! best performance. See [IncSearch][crate::inc_search::IncSearch].
-//!
-//! ```rust
-//! use std::str;
-//! use trie_rs::{TrieBuilder, inc_search::Answer};
-//!
-//! let mut builder = TrieBuilder::new();  // Inferred `TrieBuilder<u8, u8>` automatically
-//! builder.push("ab");
-//! builder.push("すし");
-//! builder.push("すしや");
-//! builder.push("すしだね");
-//! builder.push("すしづめ");
-//! builder.push("すしめし");
-//! builder.push("すしをにぎる");
-//! let trie = builder.build();
-//! let mut search = trie.inc_search();
-//!
-//! // Query by the byte.
-//! assert_eq!(search.query(&b'a'), Some(Answer::Prefix));
-//! assert_eq!(search.query(&b'c'), None);
-//! assert_eq!(search.query(&b'b'), Some(Answer::Match));
-//!
-//! // Reset the query to go again.
-//! search.reset();
-//!
-//! // For unicode its easier to use .query_until().
-//! assert_eq!(search.query_until("す"), Ok(Answer::Prefix));
-//! assert_eq!(search.query_until("し"), Ok(Answer::PrefixAndMatch));
-//! assert_eq!(search.query_until("や"), Ok(Answer::Match));
-//! assert_eq!(search.query(&b'a'), None);
-//! assert_eq!(search.query_until("a"), Err(0));
-//!
-//! search.reset();
-//! assert_eq!(search.query_until("ab-NO-MATCH-"), Err(2)); // No match on byte at index 2.
-//! ```
-//!
-//! # Features
-//! - **Generic type support**: As the above examples show, trie-rs can be used for searching not only UTF-8 string but also other data types.
-//! - **Based on [louds-rs](https://crates.io/crates/louds-rs)**, which is fast, parallelized, and memory efficient.
-//! - **Latest benchmark results are always accessible**: trie-rs is continuously benchmarked in Travis CI using [Criterion.rs](https://crates.io/crates/criterion). Graphical benchmark results are published [here](https://laysakura.github.io/trie-rs/criterion/report/).
-//! - `map::Trie` associates a `Value` with each entry.
-//! - `Value` does not require any traits.
-//! - `Label: Clone` not required to create `Trie<Label>` but useful for many reifying search operations like `predictive_search()`.
-//! - Many search operations are implemented via iterators which are lazy, require less memory, and can be short circuited.
-//! - Incremental search available for "online" applications, i.e., searching one `Label` at a time.
-//!
-//! # Acknowledgments
-//! [`edict.furigana`](https://github.com/laysakura/trie-rs/blob/master/benches/edict.furigana) is used for benchmark.
-//! This file is constructed in the following step:
-//!
-//! 1. Download `edict.gz` from [EDICT](http://www.edrdg.org/jmdict/edict.html).
-//! 2. Convert it from original EUC into UTF-8.
-//! 3. Translate it into CSV file with [edict-to-csv](https://pypi.org/project/edict-to-csv/).
-//! 4. Extract field $1 for Hiragana/Katakana words, and field $3 for other (like Kanji) words.
-//! 5. Translate Katakana into Hiragana with [kana2hira](https://github.com/ShellShoccar-jpn/misc-tools/blob/master/kata2hira).
-//!
-//! Many thanks for these dictionaries and tools.
+#![doc = include_str!("../README.md")]
 
 pub mod inc_search;
 mod internal_data_structure;
diff --git a/src/map.rs b/src/map.rs
index ac4a3807..11b56894 100644
--- a/src/map.rs
+++ b/src/map.rs
@@ -5,6 +5,12 @@ use louds_rs::Louds;
 mod trie;
 mod trie_builder;
 
+#[cfg(feature = "mem_dbg")]
+use mem_dbg::MemDbg;
+
+#[derive(Debug, Clone)]
+#[cfg_attr(feature = "mem_dbg", derive(mem_dbg::MemDbg, mem_dbg::MemSize))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 /// A trie for sequences of the type `Label`; each sequence has an associated `Value`.
 pub struct Trie<Label, Value> {
     louds: Louds,
@@ -13,38 +19,18 @@ pub struct Trie<Label, Value> {
     trie_labels: Vec<TrieLabel<Label, Value>>,
 }
 
+#[derive(Debug, Clone)]
+#[cfg_attr(feature = "mem_dbg", derive(mem_dbg::MemDbg, mem_dbg::MemSize))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 /// A trie builder for [Trie].
 pub struct TrieBuilder<Label, Value> {
     naive_trie: NaiveTrie<Label, Value>,
 }
 
+#[derive(Debug, Clone)]
+#[cfg_attr(feature = "mem_dbg", derive(mem_dbg::MemDbg, mem_dbg::MemSize))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 struct TrieLabel<Label, Value> {
     label: Label,
     value: Option<Value>,
 }
-
-impl<Label, Value> Clone for TrieLabel<Label, Value>
-where
-    Label: Clone,
-    Value: Clone,
-{
-    fn clone(&self) -> Self {
-        Self {
-            label: self.label.clone(),
-            value: self.value.clone(),
-        }
-    }
-}
-
-impl<Label, Value> Clone for Trie<Label, Value>
-where
-    Label: Clone,
-    Value: Clone,
-{
-    fn clone(&self) -> Self {
-        Self {
-            louds: self.louds.clone(),
-            trie_labels: self.trie_labels.clone(),
-        }
-    }
-}
diff --git a/src/trie/mod.rs b/src/trie/mod.rs
index 3e07102f..696dd038 100644
--- a/src/trie/mod.rs
+++ b/src/trie/mod.rs
@@ -1,5 +1,5 @@
-mod trie;
 mod trie_builder;
+mod trie_impl;
 
-pub use trie::Trie;
 pub use trie_builder::TrieBuilder;
+pub use trie_impl::Trie;
diff --git a/src/trie/trie_builder.rs b/src/trie/trie_builder.rs
index 4c223918..b92c3f4e 100644
--- a/src/trie/trie_builder.rs
+++ b/src/trie/trie_builder.rs
@@ -1,6 +1,12 @@
 use super::Trie;
 use crate::map;
 
+#[cfg(feature = "mem_dbg")]
+use mem_dbg::MemDbg;
+
+#[derive(Debug, Clone)]
+#[cfg_attr(feature = "mem_dbg", derive(mem_dbg::MemDbg, mem_dbg::MemSize))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 /// A trie builder for [Trie].
 pub struct TrieBuilder<Label>(map::TrieBuilder<Label, ()>);
 
diff --git a/src/trie/trie.rs b/src/trie/trie_impl.rs
similarity index 72%
rename from src/trie/trie.rs
rename to src/trie/trie_impl.rs
index 9d27576e..238c7373 100644
--- a/src/trie/trie.rs
+++ b/src/trie/trie_impl.rs
@@ -4,16 +4,56 @@ use crate::map;
 use crate::try_collect::TryFromIterator;
 use std::iter::FromIterator;
 
+#[cfg(feature = "mem_dbg")]
+use mem_dbg::MemDbg;
+
+#[derive(Debug, Clone)]
+#[cfg_attr(feature = "mem_dbg", derive(mem_dbg::MemDbg, mem_dbg::MemSize))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 /// A trie for sequences of the type `Label`.
 pub struct Trie<Label>(pub map::Trie<Label, ()>);
 
 impl<Label: Ord> Trie<Label> {
     /// Return true if `query` is an exact match.
+    ///
+    /// # Arguments
+    /// * `query` - The query to search for.
+    ///
+    /// # Examples
+    /// In the following example we illustrate how to query an exact match.
+    ///
+    /// ```rust
+    /// use trie_rs::Trie;
+    ///
+    /// let trie = Trie::from_iter(["a", "app", "apple", "better", "application"]);
+    ///
+    /// assert!(trie.exact_match("application"));
+    /// assert!(trie.exact_match("app"));
+    /// assert!(!trie.exact_match("appla"));
+    ///
+    /// ```
     pub fn exact_match(&self, query: impl AsRef<[Label]>) -> bool {
         self.0.exact_match(query).is_some()
     }
 
     /// Return the common prefixes of `query`.
+    ///
+    /// # Arguments
+    /// * `query` - The query to search for.
+    ///
+    /// # Examples
+    /// In the following example we illustrate how to query the common prefixes of a query string.
+    ///
+    /// ```rust
+    /// use trie_rs::Trie;
+    ///
+    /// let trie = Trie::from_iter(["a", "app", "apple", "better", "application"]);
+    ///
+    /// let results: Vec<String> = trie.common_prefix_search("application").collect();
+    ///
+    /// assert_eq!(results, vec!["a", "app", "application"]);
+    ///
+    /// ```
     pub fn common_prefix_search<C, M>(
         &self,
         query: impl AsRef<[Label]>,
@@ -37,7 +77,29 @@ impl<Label: Ord> Trie<Label> {
     {
         self.0.predictive_search(query).keys()
     }
+
     /// Return the postfixes of all entries that match `query`.
+    ///
+    /// # Arguments
+    /// * `query` - The query to search for.
+    ///
+    /// # Examples
+    /// In the following example we illustrate how to query the postfixes of a query string.
+    ///
+    /// ```rust
+    /// use trie_rs::Trie;
+    ///
+    /// let trie = Trie::from_iter(["a", "app", "apple", "better", "application"]);
+    ///
+    /// let results: Vec<String> = trie.postfix_search("application").collect();
+    ///
+    /// assert!(results.is_empty());
+    ///
+    /// let results: Vec<String> = trie.postfix_search("app").collect();
+    ///
+    /// assert_eq!(results, vec!["le", "lication"]);
+    ///
+    /// ```
     pub fn postfix_search<C, M>(
         &self,
         query: impl AsRef<[Label]>,
@@ -49,6 +111,31 @@ impl<Label: Ord> Trie<Label> {
         self.0.postfix_search(query).keys()
     }
 
+    /// Returns an iterator across all keys in the trie.
+    ///
+    /// # Examples
+    /// In the following example we illustrate how to iterate over all keys in the trie.
+    /// Note that the order of the keys is not guaranteed, as they will be returned in
+    /// lexicographical order.
+    ///
+    /// ```rust
+    /// use trie_rs::Trie;
+    ///
+    /// let trie = Trie::from_iter(["a", "app", "apple", "better", "application"]);
+    ///
+    /// let results: Vec<String> = trie.iter().collect();
+    ///
+    /// assert_eq!(results, vec!["a", "app", "apple", "application", "better"]);
+    ///
+    /// ```
+    pub fn iter<C, M>(&self) -> Keys<PostfixIter<'_, Label, (), C, M>>
+    where
+        C: TryFromIterator<Label, M>,
+        Label: Clone,
+    {
+        self.postfix_search([])
+    }
+
     /// Create an incremental search. Useful for interactive applications. See
     /// [crate::inc_search] for details.
     pub fn inc_search(&self) -> IncSearch<'_, Label, ()> {
@@ -91,12 +178,6 @@ where
     }
 }
 
-impl<Label: Clone> Clone for Trie<Label> {
-    fn clone(&self) -> Self {
-        Trie(self.0.clone())
-    }
-}
-
 #[cfg(test)]
 mod search_tests {
     use crate::{Trie, TrieBuilder};
@@ -121,8 +202,8 @@ mod search_tests {
 
     #[test]
     fn collect_a_trie() {
-        let trie: Trie<u8> = IntoIterator::into_iter(["a", "app", "apple", "better", "application"])
-            .collect();
+        let trie: Trie<u8> =
+            IntoIterator::into_iter(["a", "app", "apple", "better", "application"]).collect();
         assert!(trie.exact_match("application"));
     }
 
diff --git a/src/try_collect.rs b/src/try_collect.rs
index 67d5d051..dc84cec5 100644
--- a/src/try_collect.rs
+++ b/src/try_collect.rs
@@ -64,6 +64,10 @@ pub trait TryFromIterator<A, Marker> {
         Self: Sized,
         T: IntoIterator<Item = A>;
 }
+
+#[derive(Debug, Clone)]
+#[cfg_attr(feature = "mem_dbg", derive(mem_dbg::MemDbg, mem_dbg::MemSize))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 /// Marker type for blanket [TryFromIterator] implementation.
 #[doc(hidden)]
 pub struct Collect;
@@ -82,6 +86,7 @@ where
     }
 }
 
+#[derive(Debug, Clone)]
 /// Marker type for String [TryFromIterator] implementation.
 #[doc(hidden)]
 pub struct StringCollect;
diff --git a/tests/test.rs b/tests/test.rs
deleted file mode 100644
index 8b137891..00000000
--- a/tests/test.rs
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/tests/version-numbers.rs b/tests/test_versions.rs
similarity index 98%
rename from tests/version-numbers.rs
rename to tests/test_versions.rs
index 288592d0..f6bfb672 100644
--- a/tests/version-numbers.rs
+++ b/tests/test_versions.rs
@@ -6,4 +6,4 @@ fn test_readme_deps() {
 #[test]
 fn test_html_root_url() {
     version_sync::assert_html_root_url_updated!("src/lib.rs");
-}
+}
\ No newline at end of file