give up docmatic

Author: sekineh

CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+
+* Quickstart section in the doc

Cargo.toml

@@ -15,7 +15,6 @@ serde = { version = "1.0", optional = true, features = ["derive"] }
 
 [dev-dependencies]
 serde_json = "1.0.39"
-docmatic = "0.1"
 
 [badges]
 travis-ci = { repository = "sekineh/binary-heap-plus-rs" }

README.md

@@ -13,51 +13,6 @@ It supports the following features and still maintains backward compatibility.
 
 This crate requires Rust 1.26 or later.
 
-# Quick start
-
-## Max/Min Heap
-For max/min heap, `BiaryHeap::from_vec()` is the most versatile way to create a heap.
-
-```rust
-    extern crate binary_heap_plus;
-    use binary_heap_plus::*;
-
-    // max heap
-    let mut h: BinaryHeap<i32> = BinaryHeap::from_vec(vec![]);
-    // max heap with initial capacity
-    let mut h: BinaryHeap<i32> = BinaryHeap::from_vec(Vec::with_capacity(16));
-    // max heap from iterator
-    let mut h: BinaryHeap<i32> = BinaryHeap::from_vec((0..42).collect());
-    assert_eq!(h.pop(), Some(41));
-```
-Min heap requires type annotation.
-```rust
-    extern crate binary_heap_plus;
-    use binary_heap_plus::*;
-
-    // min heap
-    let mut h: BinaryHeap<i32, MinComparator> = BinaryHeap::from_vec(vec![]);
-    // min heap with initial capacity
-    let mut h: BinaryHeap<i32, MinComparator> = BinaryHeap::from_vec(Vec::with_capacity(16));
-    // min heap from iterator
-    let mut h: BinaryHeap<i32, MinComparator> = BinaryHeap::from_vec((0..42).collect());
-    assert_eq!(h.pop(), Some(0));
-```
-
-## Custom Heap
-For custom heap, `BinaryHeap::from_vec_cmp()` works in a similar way to max/min heap. The only difference is that you add the comparator closure with apropriate signature.
-```rust
-    extern crate binary_heap_plus;
-    use binary_heap_plus::*;
-
-    // custom heap: ordered by second value (_.1) of the tuples; min first
-    let mut h = BinaryHeap::from_vec_cmp(
-        vec![(1, 5), (3, 2), (2, 3)],
-        |a: &(i32, i32), b: &(i32, i32)| b.1.cmp(&a.1), // comparator closure here
-    );
-    assert_eq!(h.pop(), Some((3, 2)));
-```
-
 ## Note on `BinaryHeap::from_vec()`
 
 Currently, the `From<Vec<T>>` trait is implemented for max heap only.

src/lib.rs

@@ -4,6 +4,56 @@
 //! * Heaps other than max heap.
 //! * Optional `serde` feature.
 //!
+//! # Quick start
+//!
+//! ## Max/Min Heap
+//! 
+//! For max heap, `BiaryHeap::from_vec()` is the most versatile way to create a heap.
+//!
+//! ```rust
+//!     // extern crate binary_heap_plus;
+//!     use binary_heap_plus::*;
+//!
+//!     // max heap
+//!     let mut h: BinaryHeap<i32> = BinaryHeap::from_vec(vec![]);
+//!     // max heap with initial capacity
+//!     let mut h: BinaryHeap<i32> = BinaryHeap::from_vec(Vec::with_capacity(16));
+//!     // max heap from iterator
+//!     let mut h: BinaryHeap<i32> = BinaryHeap::from_vec((0..42).collect());
+//!     assert_eq!(h.pop(), Some(41));
+//! ```
+//! 
+//! Min heap is similar, but requires type annotation.
+//! 
+//! ```rust
+//!     // extern crate binary_heap_plus;
+//!     use binary_heap_plus::*;
+//!
+//!     // min heap
+//!     let mut h: BinaryHeap<i32, MinComparator> = BinaryHeap::from_vec(vec![]);
+//!     // min heap with initial capacity
+//!     let mut h: BinaryHeap<i32, MinComparator> = BinaryHeap::from_vec(Vec::with_capacity(16));
+//!     // min heap from iterator
+//!     let mut h: BinaryHeap<i32, MinComparator> = BinaryHeap::from_vec((0..42).collect());
+//!     assert_eq!(h.pop(), Some(0));
+//! ```
+//!
+//! ## Custom Heap
+//! 
+//! For custom heap, `BinaryHeap::from_vec_cmp()` works in a similar way to max/min heap. The only difference is that you add the comparator closure with apropriate signature.
+//! 
+//! ```rust
+//!     // extern crate binary_heap_plus;
+//!     use binary_heap_plus::*;
+//!
+//!     // custom heap: ordered by second value (_.1) of the tuples; min first
+//!     let mut h = BinaryHeap::from_vec_cmp(
+//!         vec![(1, 5), (3, 2), (2, 3)],
+//!         |a: &(i32, i32), b: &(i32, i32)| b.1.cmp(&a.1), // comparator closure here
+//!     );
+//!     assert_eq!(h.pop(), Some((3, 2)));
+//! ```
+//!
 //! # Constructers
 //!
 //! ## Generic methods to create different kind of heaps from initial `vec` data.
@@ -23,7 +73,7 @@
 //! assert_eq!(heap.pop(), Some(1));
 //!
 //! // custom-sort heap
-//! let mut heap = BinaryHeap::from_vec_cmp(vec![1,5,3], FnComparator(|a: &i32, b: &i32| b.cmp(a)));
+//! let mut heap = BinaryHeap::from_vec_cmp(vec![1,5,3], |a: &i32, b: &i32| b.cmp(a));
 //! assert_eq!(heap.pop(), Some(1));
 //!
 //! // custom-key heap