From 3719c04f8c18398e90b1a7e2ffd304495b7c493f Mon Sep 17 00:00:00 2001 From: Joel Parker Henderson Date: Wed, 2 Oct 2024 14:27:48 +0200 Subject: [PATCH] Rerun rustdoc --- README.md | 73 +-- doc/lib/assert_err/assert_err/index.html | 14 + .../assert_err/assert_err/sidebar-items.js | 1 + doc/lib/assert_err/assert_err_eq/index.html | 15 + .../assert_err/assert_err_eq/sidebar-items.js | 1 + .../assert_err/assert_err_eq_expr/index.html | 15 + .../assert_err_eq_expr/sidebar-items.js | 1 + doc/lib/assert_err/assert_err_ne/index.html | 15 + .../assert_err/assert_err_ne/sidebar-items.js | 1 + .../assert_err/assert_err_ne_expr/index.html | 15 + .../assert_err_ne_expr/sidebar-items.js | 1 + doc/lib/assert_err/index.html | 40 +- doc/lib/assert_err/sidebar-items.js | 2 +- doc/lib/assert_none/assert_none/index.html | 14 + .../assert_none/assert_none/sidebar-items.js | 1 + doc/lib/assert_none/index.html | 18 +- doc/lib/assert_none/sidebar-items.js | 2 +- doc/lib/assert_ok/assert_ok/index.html | 14 + doc/lib/assert_ok/assert_ok/sidebar-items.js | 1 + doc/lib/assert_ok/assert_ok_eq/index.html | 15 + .../assert_ok/assert_ok_eq/sidebar-items.js | 1 + .../assert_ok/assert_ok_eq_expr/index.html | 15 + .../assert_ok_eq_expr/sidebar-items.js | 1 + doc/lib/assert_ok/assert_ok_ne/index.html | 15 + .../assert_ok/assert_ok_ne/sidebar-items.js | 1 + .../assert_ok/assert_ok_ne_expr/index.html | 15 + .../assert_ok_ne_expr/sidebar-items.js | 1 + doc/lib/assert_ok/index.html | 40 +- doc/lib/assert_ok/sidebar-items.js | 2 +- .../assert_pending/assert_pending/index.html | 17 + .../assert_pending/sidebar-items.js | 1 + doc/lib/assert_pending/index.html | 21 +- doc/lib/assert_pending/sidebar-items.js | 2 +- doc/lib/assert_ready/assert_ready/index.html | 17 + .../assert_ready/sidebar-items.js | 1 + .../assert_ready/assert_ready_eq/index.html | 17 + .../assert_ready_eq/sidebar-items.js | 1 + .../assert_ready_eq_expr/index.html | 17 + .../assert_ready_eq_expr/sidebar-items.js | 1 + .../assert_ready/assert_ready_ne/index.html | 17 + .../assert_ready_ne/sidebar-items.js | 1 + .../assert_ready_ne_expr/index.html | 17 + .../assert_ready_ne_expr/sidebar-items.js | 1 + doc/lib/assert_ready/index.html | 43 +- doc/lib/assert_ready/sidebar-items.js | 2 +- doc/lib/assert_some/assert_some/index.html | 14 + .../assert_some/assert_some/sidebar-items.js | 1 + doc/lib/assert_some/assert_some_eq/index.html | 15 + .../assert_some_eq/sidebar-items.js | 1 + .../assert_some_eq_expr/index.html | 15 + .../assert_some_eq_expr/sidebar-items.js | 1 + doc/lib/assert_some/assert_some_ne/index.html | 15 + .../assert_some_ne/sidebar-items.js | 1 + .../assert_some_ne_expr/index.html | 15 + .../assert_some_ne_expr/sidebar-items.js | 1 + doc/lib/assert_some/index.html | 40 +- doc/lib/assert_some/sidebar-items.js | 2 +- doc/lib/index.html | 66 +-- doc/lib/macro.assert_err.html | 2 +- doc/lib/macro.assert_err_as_result.html | 2 +- doc/lib/macro.assert_err_eq.html | 2 +- doc/lib/macro.assert_err_eq_as_result.html | 2 +- doc/lib/macro.assert_err_eq_expr.html | 2 +- .../macro.assert_err_eq_expr_as_result.html | 2 +- doc/lib/macro.assert_err_ne.html | 2 +- doc/lib/macro.assert_err_ne_as_result.html | 2 +- doc/lib/macro.assert_err_ne_expr.html | 2 +- .../macro.assert_err_ne_expr_as_result.html | 2 +- doc/lib/macro.assert_none.html | 2 +- doc/lib/macro.assert_none_as_result.html | 2 +- doc/lib/macro.assert_ok.html | 2 +- doc/lib/macro.assert_ok_as_result.html | 2 +- doc/lib/macro.assert_ok_eq.html | 2 +- doc/lib/macro.assert_ok_eq_as_result.html | 2 +- doc/lib/macro.assert_ok_eq_expr.html | 2 +- .../macro.assert_ok_eq_expr_as_result.html | 2 +- doc/lib/macro.assert_ok_ne.html | 2 +- doc/lib/macro.assert_ok_ne_as_result.html | 2 +- doc/lib/macro.assert_ok_ne_expr.html | 2 +- .../macro.assert_ok_ne_expr_as_result.html | 2 +- doc/lib/macro.assert_pending.html | 2 +- doc/lib/macro.assert_pending_as_result.html | 2 +- doc/lib/macro.assert_ready.html | 2 +- doc/lib/macro.assert_ready_as_result.html | 2 +- doc/lib/macro.assert_ready_eq.html | 2 +- doc/lib/macro.assert_ready_eq_as_result.html | 2 +- doc/lib/macro.assert_ready_eq_expr.html | 2 +- .../macro.assert_ready_eq_expr_as_result.html | 2 +- doc/lib/macro.assert_ready_ne.html | 2 +- doc/lib/macro.assert_ready_ne_as_result.html | 2 +- doc/lib/macro.assert_ready_ne_expr.html | 2 +- .../macro.assert_ready_ne_expr_as_result.html | 2 +- doc/lib/macro.assert_some.html | 2 +- doc/lib/macro.assert_some_as_result.html | 2 +- doc/lib/macro.assert_some_eq.html | 2 +- doc/lib/macro.assert_some_eq_as_result.html | 2 +- doc/lib/macro.assert_some_eq_expr.html | 2 +- .../macro.assert_some_eq_expr_as_result.html | 2 +- doc/lib/macro.assert_some_ne.html | 2 +- doc/lib/macro.assert_some_ne_as_result.html | 2 +- doc/lib/macro.assert_some_ne_expr.html | 2 +- .../macro.assert_some_ne_expr_as_result.html | 2 +- doc/lib/macro.debug_assert_err.html | 2 +- doc/lib/macro.debug_assert_err_eq.html | 2 +- doc/lib/macro.debug_assert_err_eq_expr.html | 2 +- doc/lib/macro.debug_assert_err_ne.html | 2 +- doc/lib/macro.debug_assert_err_ne_expr.html | 2 +- doc/lib/macro.debug_assert_none.html | 2 +- doc/lib/macro.debug_assert_ok.html | 2 +- doc/lib/macro.debug_assert_ok_eq.html | 2 +- doc/lib/macro.debug_assert_ok_eq_expr.html | 2 +- doc/lib/macro.debug_assert_ok_ne.html | 2 +- doc/lib/macro.debug_assert_ok_ne_expr.html | 2 +- doc/lib/macro.debug_assert_pending.html | 2 +- doc/lib/macro.debug_assert_ready.html | 2 +- doc/lib/macro.debug_assert_ready_eq.html | 2 +- doc/lib/macro.debug_assert_ready_eq_expr.html | 2 +- doc/lib/macro.debug_assert_ready_ne.html | 2 +- doc/lib/macro.debug_assert_ready_ne_expr.html | 2 +- doc/lib/macro.debug_assert_some.html | 2 +- doc/lib/macro.debug_assert_some_eq.html | 2 +- doc/lib/macro.debug_assert_some_eq_expr.html | 2 +- doc/lib/macro.debug_assert_some_ne.html | 2 +- doc/lib/macro.debug_assert_some_ne_expr.html | 2 +- doc/lib/sidebar-items.js | 2 +- doc/search-index.js | 2 +- doc/search.desc/lib/lib-desc-0-.js | 2 +- doc/src-files.js | 2 +- doc/src/lib/assert_err/assert_err.rs.html | 391 +++++++++++++ doc/src/lib/assert_err/assert_err_eq.rs.html | 515 +++++++++++++++++ .../lib/assert_err/assert_err_eq_expr.rs.html | 505 +++++++++++++++++ doc/src/lib/assert_err/assert_err_ne.rs.html | 509 +++++++++++++++++ .../lib/assert_err/assert_err_ne_expr.rs.html | 505 +++++++++++++++++ doc/src/lib/assert_err/mod.rs.html | 71 +++ doc/src/lib/assert_none/assert_none.rs.html | 391 +++++++++++++ doc/src/lib/assert_none/mod.rs.html | 21 + doc/src/lib/assert_ok/assert_ok.rs.html | 391 +++++++++++++ doc/src/lib/assert_ok/assert_ok_eq.rs.html | 515 +++++++++++++++++ .../lib/assert_ok/assert_ok_eq_expr.rs.html | 505 +++++++++++++++++ doc/src/lib/assert_ok/assert_ok_ne.rs.html | 509 +++++++++++++++++ .../lib/assert_ok/assert_ok_ne_expr.rs.html | 505 +++++++++++++++++ doc/src/lib/assert_ok/mod.rs.html | 71 +++ .../lib/assert_pending/assert_pending.rs.html | 405 ++++++++++++++ doc/src/lib/assert_pending/mod.rs.html | 21 + doc/src/lib/assert_ready/assert_ready.rs.html | 405 ++++++++++++++ .../lib/assert_ready/assert_ready_eq.rs.html | 527 ++++++++++++++++++ .../assert_ready/assert_ready_eq_expr.rs.html | 517 +++++++++++++++++ .../lib/assert_ready/assert_ready_ne.rs.html | 527 ++++++++++++++++++ .../assert_ready/assert_ready_ne_expr.rs.html | 517 +++++++++++++++++ doc/src/lib/assert_ready/mod.rs.html | 71 +++ doc/src/lib/assert_some/assert_some.rs.html | 391 +++++++++++++ .../lib/assert_some/assert_some_eq.rs.html | 515 +++++++++++++++++ .../assert_some/assert_some_eq_expr.rs.html | 505 +++++++++++++++++ .../lib/assert_some/assert_some_ne.rs.html | 515 +++++++++++++++++ .../assert_some/assert_some_ne_expr.rs.html | 505 +++++++++++++++++ doc/src/lib/assert_some/mod.rs.html | 71 +++ doc/src/lib/lib.rs.html | 154 +---- src/assert_err/mod.rs | 14 +- src/assert_none/mod.rs | 9 + src/assert_ok/mod.rs | 13 +- src/assert_some/mod.rs | 13 +- src/lib.rs | 94 +--- 162 files changed, 11554 insertions(+), 492 deletions(-) create mode 100644 doc/lib/assert_err/assert_err/index.html create mode 100644 doc/lib/assert_err/assert_err/sidebar-items.js create mode 100644 doc/lib/assert_err/assert_err_eq/index.html create mode 100644 doc/lib/assert_err/assert_err_eq/sidebar-items.js create mode 100644 doc/lib/assert_err/assert_err_eq_expr/index.html create mode 100644 doc/lib/assert_err/assert_err_eq_expr/sidebar-items.js create mode 100644 doc/lib/assert_err/assert_err_ne/index.html create mode 100644 doc/lib/assert_err/assert_err_ne/sidebar-items.js create mode 100644 doc/lib/assert_err/assert_err_ne_expr/index.html create mode 100644 doc/lib/assert_err/assert_err_ne_expr/sidebar-items.js create mode 100644 doc/lib/assert_none/assert_none/index.html create mode 100644 doc/lib/assert_none/assert_none/sidebar-items.js create mode 100644 doc/lib/assert_ok/assert_ok/index.html create mode 100644 doc/lib/assert_ok/assert_ok/sidebar-items.js create mode 100644 doc/lib/assert_ok/assert_ok_eq/index.html create mode 100644 doc/lib/assert_ok/assert_ok_eq/sidebar-items.js create mode 100644 doc/lib/assert_ok/assert_ok_eq_expr/index.html create mode 100644 doc/lib/assert_ok/assert_ok_eq_expr/sidebar-items.js create mode 100644 doc/lib/assert_ok/assert_ok_ne/index.html create mode 100644 doc/lib/assert_ok/assert_ok_ne/sidebar-items.js create mode 100644 doc/lib/assert_ok/assert_ok_ne_expr/index.html create mode 100644 doc/lib/assert_ok/assert_ok_ne_expr/sidebar-items.js create mode 100644 doc/lib/assert_pending/assert_pending/index.html create mode 100644 doc/lib/assert_pending/assert_pending/sidebar-items.js create mode 100644 doc/lib/assert_ready/assert_ready/index.html create mode 100644 doc/lib/assert_ready/assert_ready/sidebar-items.js create mode 100644 doc/lib/assert_ready/assert_ready_eq/index.html create mode 100644 doc/lib/assert_ready/assert_ready_eq/sidebar-items.js create mode 100644 doc/lib/assert_ready/assert_ready_eq_expr/index.html create mode 100644 doc/lib/assert_ready/assert_ready_eq_expr/sidebar-items.js create mode 100644 doc/lib/assert_ready/assert_ready_ne/index.html create mode 100644 doc/lib/assert_ready/assert_ready_ne/sidebar-items.js create mode 100644 doc/lib/assert_ready/assert_ready_ne_expr/index.html create mode 100644 doc/lib/assert_ready/assert_ready_ne_expr/sidebar-items.js create mode 100644 doc/lib/assert_some/assert_some/index.html create mode 100644 doc/lib/assert_some/assert_some/sidebar-items.js create mode 100644 doc/lib/assert_some/assert_some_eq/index.html create mode 100644 doc/lib/assert_some/assert_some_eq/sidebar-items.js create mode 100644 doc/lib/assert_some/assert_some_eq_expr/index.html create mode 100644 doc/lib/assert_some/assert_some_eq_expr/sidebar-items.js create mode 100644 doc/lib/assert_some/assert_some_ne/index.html create mode 100644 doc/lib/assert_some/assert_some_ne/sidebar-items.js create mode 100644 doc/lib/assert_some/assert_some_ne_expr/index.html create mode 100644 doc/lib/assert_some/assert_some_ne_expr/sidebar-items.js create mode 100644 doc/src/lib/assert_err/assert_err.rs.html create mode 100644 doc/src/lib/assert_err/assert_err_eq.rs.html create mode 100644 doc/src/lib/assert_err/assert_err_eq_expr.rs.html create mode 100644 doc/src/lib/assert_err/assert_err_ne.rs.html create mode 100644 doc/src/lib/assert_err/assert_err_ne_expr.rs.html create mode 100644 doc/src/lib/assert_err/mod.rs.html create mode 100644 doc/src/lib/assert_none/assert_none.rs.html create mode 100644 doc/src/lib/assert_none/mod.rs.html create mode 100644 doc/src/lib/assert_ok/assert_ok.rs.html create mode 100644 doc/src/lib/assert_ok/assert_ok_eq.rs.html create mode 100644 doc/src/lib/assert_ok/assert_ok_eq_expr.rs.html create mode 100644 doc/src/lib/assert_ok/assert_ok_ne.rs.html create mode 100644 doc/src/lib/assert_ok/assert_ok_ne_expr.rs.html create mode 100644 doc/src/lib/assert_ok/mod.rs.html create mode 100644 doc/src/lib/assert_pending/assert_pending.rs.html create mode 100644 doc/src/lib/assert_pending/mod.rs.html create mode 100644 doc/src/lib/assert_ready/assert_ready.rs.html create mode 100644 doc/src/lib/assert_ready/assert_ready_eq.rs.html create mode 100644 doc/src/lib/assert_ready/assert_ready_eq_expr.rs.html create mode 100644 doc/src/lib/assert_ready/assert_ready_ne.rs.html create mode 100644 doc/src/lib/assert_ready/assert_ready_ne_expr.rs.html create mode 100644 doc/src/lib/assert_ready/mod.rs.html create mode 100644 doc/src/lib/assert_some/assert_some.rs.html create mode 100644 doc/src/lib/assert_some/assert_some_eq.rs.html create mode 100644 doc/src/lib/assert_some/assert_some_eq_expr.rs.html create mode 100644 doc/src/lib/assert_some/assert_some_ne.rs.html create mode 100644 doc/src/lib/assert_some/assert_some_ne_expr.rs.html create mode 100644 doc/src/lib/assert_some/mod.rs.html diff --git a/README.md b/README.md index 63d386f11..f25211d1b 100644 --- a/README.md +++ b/README.md @@ -71,8 +71,8 @@ For matching: For infix operators: -* [`assert_infix!(a == b)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_infix.html) -* [`assert_infix!(a && b)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_infix.html) +* [`assert_infix!(a == b)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_infix.html) ([more](https://docs.rs/assertables/8.11.0/assertables/assert_infix)) +* [`assert_infix!(a && b)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_infix.html) ([more](https://docs.rs/assertables/8.11.0/assertables/assert_infix)) For nearness: @@ -81,35 +81,23 @@ For nearness: For Result Ok/Err: -* [`assert_ok!(a)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_ok.html) -* [`assert_ok_eq!(a, b)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_ok_eq.html) -* [`assert_ok_eq_expr!(a, expr)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_ok_eq_expr.html) -* [`assert_ok_ne!(a, b)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_ok_ne.html) -* [`assert_ok_ne_expr!(a, expr)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_ok_ne_expr.html) -* [`assert_err!(a)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_err.html) +* [`assert_ok!(a)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_ok.html) ([eq, ne, etc.](https://docs.rs/assertables/8.11.0/assertables/assert_ok)) +* [`assert_err!(a)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_err.html ([eq, ne, etc.](https://docs.rs/assertables/8.11.0/assertables/assert_err)) For Option Some/None: -* [`assert_some!(a)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_some.html) -* [`assert_some_eq!(a, b)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_some_eq.html) -* [`assert_some_eq_expr!(a, expr)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_some_eq_expr.html) -* [`assert_some_ne!(a, b)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_some_ne.html) -* [`assert_some_ne_expr!(a, expr)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_some_ne_expr.html) +* [`assert_some!(a)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_some.html) ([eq, ne, etc.](https://docs.rs/assertables/8.11.0/assertables/assert_some)) * [`assert_none!(a)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_none.html) For Poll Ready/Pending: -* [`assert_ready!(a)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_ready.html) -* [`assert_ready_eq!(a, b)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_ready_eq.html) -* [`assert_ready_eq_expr!(a, expr)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_ready_eq_expr.html) -* [`assert_ready_ne!(a, b)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_ready_ne.html) -* [`assert_ready_ne_expr!(a, expr)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_ready_ne_expr.html) +* [`assert_ready!(a)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_ready.html) ([eq, ne, etc.](https://docs.rs/assertables/8.11.0/assertables/assert_ready)) * [`assert_pending!(a)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_pending.html) For collections such as arrays, vectors, maps, sets: -* [`assert_set_subset!(collection1, collection2)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_set_subset.html) -* [`assert_set_disjoint!(collection1, collection2)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_set_disjoint.html) +* [`assert_bag_eq!(collection1, collection2)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_bag_eq.html) ([more](https://docs.rs/assertables/8.11.0/assertables/assert_bag)). +* [`assert_set_eq!(collection1, collection2)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_set_eq.html) [more](https://docs.rs/assertables/8.11.0/assertables/assert_set). For file system paths and input/output readers: @@ -147,46 +135,21 @@ Modules for external calls: ## Forms +All assertables macros have forms for different outcomes: -### Forms for panic versus error +* [`assert_gt!(a, b)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_gt.html) // panic during typical test +* [`assert_gt_as_result!(a, b)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_gt_as_result.html) // return Ok or Err +* [`debug_assert_gt!(a, b)`](https://docs.rs/assertables/8.11.0/assertables/macro.debug_assert_gt.html) // panic when in debug mode -All the assert macros have 3 forms for different purposes: +All assertables macros have forms for an optional message: -* Panic form for typical tests. -* Debug form for debugging runtimes. -* Result form for runtime checks, verifications, validations, etc. +* [`assert_gt!(a, b)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_gt.html) // automatic error message +* [`assert_gt!(a, b, "your text")`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_gt.html) // custom error message -Examples: - -* [`assert_starts_with!(a, b)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_starts_with.html) // panic! -* [`debug_assert_starts_with!(a, b)`](https://docs.rs/assertables/8.11.0/assertables/macro.debug_assert_starts_with.html) // panic! in debug mode -* [`assert_starts_with_as_result!(a, b)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_starts_with_as_result.html) // return Ok or Err - - -### Forms for messages - -All the assert macros have 2 forms for messages. +Many assertables macros have forms for comparing left hand side (LHS) and right hand side (RHS) as the same type or as an expression: -* Default message form. -* Custom message form. - -Examples: - -* [`assert_starts_with!(a, b)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_starts_with.html) -* [`assert_starts_with!(a, b, "Your custom message here")`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_starts_with.html) - - -### Forms for other versus expression - -Many of the assert macros have 2 forms for comparing left hand side and right hand side. - -* Comparing a LHS item to a RHS other of the same type. -* Comparing a LHS item to a RHS expression. - -Examples: - -* [`assert_io_read_to_string_eq!(reader1, reader2)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_io_read_to_string_eq.html) -* [`assert_io_read_to_string_eq_expr!(reader, expr)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_io_read_to_string_eq_expr.html) +* [`assert_ok_eq!(a, b)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_ok_eq.html) // Ok(…) = Ok(…) +* [`assert_ok_eq_expr!(a, b)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_ok_eq_expr.html) // Ok(…) = expression ## Tracking diff --git a/doc/lib/assert_err/assert_err/index.html b/doc/lib/assert_err/assert_err/index.html new file mode 100644 index 000000000..2d4ad955e --- /dev/null +++ b/doc/lib/assert_err/assert_err/index.html @@ -0,0 +1,14 @@ +lib::assert_err::assert_err - Rust

Module lib::assert_err::assert_err

source ·
Expand description

Assert expression is Err(_).

+

Pseudocode:
+a is Err(_)

+

§Example

+
use assertables::*;
+let a: Result<(), i8> = Err(1);
+assert_err!(a);
+

§Module macros

+ +
\ No newline at end of file diff --git a/doc/lib/assert_err/assert_err/sidebar-items.js b/doc/lib/assert_err/assert_err/sidebar-items.js new file mode 100644 index 000000000..5244ce01c --- /dev/null +++ b/doc/lib/assert_err/assert_err/sidebar-items.js @@ -0,0 +1 @@ +window.SIDEBAR_ITEMS = {}; \ No newline at end of file diff --git a/doc/lib/assert_err/assert_err_eq/index.html b/doc/lib/assert_err/assert_err_eq/index.html new file mode 100644 index 000000000..e619fe017 --- /dev/null +++ b/doc/lib/assert_err/assert_err_eq/index.html @@ -0,0 +1,15 @@ +lib::assert_err::assert_err_eq - Rust

Module lib::assert_err::assert_err_eq

source ·
Expand description

Assert two expressions are Err(_) and their values are equal.

+

Pseudocode:
+(a ⇒ Err(a̅) ⇒ a̅) = (b ⇒ Err(b̅) ⇒ b̅)

+

§Example

+
use assertables::*;
+let a: Result<i8, i8> = Err(1);
+let b: Result<i8, i8> = Err(1);
+assert_err_eq!(a, b);
+

§Module macros

+ +
\ No newline at end of file diff --git a/doc/lib/assert_err/assert_err_eq/sidebar-items.js b/doc/lib/assert_err/assert_err_eq/sidebar-items.js new file mode 100644 index 000000000..5244ce01c --- /dev/null +++ b/doc/lib/assert_err/assert_err_eq/sidebar-items.js @@ -0,0 +1 @@ +window.SIDEBAR_ITEMS = {}; \ No newline at end of file diff --git a/doc/lib/assert_err/assert_err_eq_expr/index.html b/doc/lib/assert_err/assert_err_eq_expr/index.html new file mode 100644 index 000000000..2a4fae674 --- /dev/null +++ b/doc/lib/assert_err/assert_err_eq_expr/index.html @@ -0,0 +1,15 @@ +lib::assert_err::assert_err_eq_expr - Rust

Module lib::assert_err::assert_err_eq_expr

source ·
Expand description

Assert an expression is Err(_) and its value is equal to an expression.

+

Pseudocode:
+(a ⇒ Err(a̅) ⇒ a̅) = b

+

§Example

+
use assertables::*;
+let a: Result<i8, i8> = Err(1);
+let b: i8 = 1;
+assert_err_eq_expr!(a, b);
+

§Module macros

+ +
\ No newline at end of file diff --git a/doc/lib/assert_err/assert_err_eq_expr/sidebar-items.js b/doc/lib/assert_err/assert_err_eq_expr/sidebar-items.js new file mode 100644 index 000000000..5244ce01c --- /dev/null +++ b/doc/lib/assert_err/assert_err_eq_expr/sidebar-items.js @@ -0,0 +1 @@ +window.SIDEBAR_ITEMS = {}; \ No newline at end of file diff --git a/doc/lib/assert_err/assert_err_ne/index.html b/doc/lib/assert_err/assert_err_ne/index.html new file mode 100644 index 000000000..56ac769b8 --- /dev/null +++ b/doc/lib/assert_err/assert_err_ne/index.html @@ -0,0 +1,15 @@ +lib::assert_err::assert_err_ne - Rust

Module lib::assert_err::assert_err_ne

source ·
Expand description

Assert two expressions are Err(_) and their values are not equal.

+

Pseudocode:
+(a ⇒ Err(a̅) ⇒ a̅) ≠ (b ⇒ Err(b̅) ⇒ b̅)

+

§Example

+
use assertables::*;
+let a: Result<i8, i8> = Err(1);
+let b: Result<i8, i8> = Err(2);
+assert_err_ne!(a, b);
+

§Module macros

+ +
\ No newline at end of file diff --git a/doc/lib/assert_err/assert_err_ne/sidebar-items.js b/doc/lib/assert_err/assert_err_ne/sidebar-items.js new file mode 100644 index 000000000..5244ce01c --- /dev/null +++ b/doc/lib/assert_err/assert_err_ne/sidebar-items.js @@ -0,0 +1 @@ +window.SIDEBAR_ITEMS = {}; \ No newline at end of file diff --git a/doc/lib/assert_err/assert_err_ne_expr/index.html b/doc/lib/assert_err/assert_err_ne_expr/index.html new file mode 100644 index 000000000..acb231f53 --- /dev/null +++ b/doc/lib/assert_err/assert_err_ne_expr/index.html @@ -0,0 +1,15 @@ +lib::assert_err::assert_err_ne_expr - Rust

Module lib::assert_err::assert_err_ne_expr

source ·
Expand description

Assert an expression is Err(_) and its value is not equal to an expression.

+

Pseudocode:
+(a ⇒ Err(a̅) ⇒ a̅) ≠ b

+

§Example

+
use assertables::*;
+let a: Result<i8, i8> = Err(1);
+let b: i8 = 2;
+assert_err_ne_expr!(a, b);
+

§Module macros

+ +
\ No newline at end of file diff --git a/doc/lib/assert_err/assert_err_ne_expr/sidebar-items.js b/doc/lib/assert_err/assert_err_ne_expr/sidebar-items.js new file mode 100644 index 000000000..5244ce01c --- /dev/null +++ b/doc/lib/assert_err/assert_err_ne_expr/sidebar-items.js @@ -0,0 +1 @@ +window.SIDEBAR_ITEMS = {}; \ No newline at end of file diff --git a/doc/lib/assert_err/index.html b/doc/lib/assert_err/index.html index c17f3aff0..6efb989e9 100644 --- a/doc/lib/assert_err/index.html +++ b/doc/lib/assert_err/index.html @@ -1,14 +1,30 @@ -lib::assert_err - Rust

Module lib::assert_err

source ·
Expand description

Assert expression is Err(_).

-

Pseudocode:
-a is Err(_)

-

§Example

-
use assertables::*;
-let a: Result<(), i8> = Err(1);
-assert_err!(a);
-

§Module macros

+lib::assert_err - Rust

Module lib::assert_err

source ·
Expand description

Assert macros for Err(_) items.

+

These macros help compare Err(…) items, such as std::Result::Err or similar.

+

Assert expression is Err(_):

-
\ No newline at end of file +

Compare Err(…) to another Err(…):

+ +

Compare Err(…) to an expression:

+ +

Modules§

  • assert_err
    Assert expression is Err(_).
  • assert_err_eq
    Assert two expressions are Err(_) and their values are equal.
  • assert_err_eq_expr
    Assert an expression is Err(_) and its value is equal to an expression.
  • assert_err_ne
    Assert two expressions are Err(_) and their values are not equal.
  • assert_err_ne_expr
    Assert an expression is Err(_) and its value is not equal to an expression.
\ No newline at end of file diff --git a/doc/lib/assert_err/sidebar-items.js b/doc/lib/assert_err/sidebar-items.js index 5244ce01c..2dda017e8 100644 --- a/doc/lib/assert_err/sidebar-items.js +++ b/doc/lib/assert_err/sidebar-items.js @@ -1 +1 @@ -window.SIDEBAR_ITEMS = {}; \ No newline at end of file +window.SIDEBAR_ITEMS = {"mod":["assert_err","assert_err_eq","assert_err_eq_expr","assert_err_ne","assert_err_ne_expr"]}; \ No newline at end of file diff --git a/doc/lib/assert_none/assert_none/index.html b/doc/lib/assert_none/assert_none/index.html new file mode 100644 index 000000000..636fda939 --- /dev/null +++ b/doc/lib/assert_none/assert_none/index.html @@ -0,0 +1,14 @@ +lib::assert_none::assert_none - Rust

Module lib::assert_none::assert_none

source ·
Expand description

Assert expression is None.

+

Pseudocode:
+a is None

+

§Example

+
use assertables::*;
+let a: Option<i8> = Option::None;
+assert_none!(a);
+

§Module macros

+ +
\ No newline at end of file diff --git a/doc/lib/assert_none/assert_none/sidebar-items.js b/doc/lib/assert_none/assert_none/sidebar-items.js new file mode 100644 index 000000000..5244ce01c --- /dev/null +++ b/doc/lib/assert_none/assert_none/sidebar-items.js @@ -0,0 +1 @@ +window.SIDEBAR_ITEMS = {}; \ No newline at end of file diff --git a/doc/lib/assert_none/index.html b/doc/lib/assert_none/index.html index 39dab20d4..8174c41ef 100644 --- a/doc/lib/assert_none/index.html +++ b/doc/lib/assert_none/index.html @@ -1,14 +1,8 @@ -lib::assert_none - Rust

Module lib::assert_none

source ·
Expand description

Assert expression is None.

-

Pseudocode:
-a is None

-

§Example

-
use assertables::*;
-let a: Option<i8> = Option::None;
-assert_none!(a);
-

§Module macros

+lib::assert_none - Rust

Module lib::assert_none

source ·
Expand description

Assert macro for None items.

+

These macros help compare None items, such as std::Option::None or similar.

+

Assert expression is None:

-
\ No newline at end of file +

Modules§

\ No newline at end of file diff --git a/doc/lib/assert_none/sidebar-items.js b/doc/lib/assert_none/sidebar-items.js index 5244ce01c..a295b8797 100644 --- a/doc/lib/assert_none/sidebar-items.js +++ b/doc/lib/assert_none/sidebar-items.js @@ -1 +1 @@ -window.SIDEBAR_ITEMS = {}; \ No newline at end of file +window.SIDEBAR_ITEMS = {"mod":["assert_none"]}; \ No newline at end of file diff --git a/doc/lib/assert_ok/assert_ok/index.html b/doc/lib/assert_ok/assert_ok/index.html new file mode 100644 index 000000000..b2fa173c6 --- /dev/null +++ b/doc/lib/assert_ok/assert_ok/index.html @@ -0,0 +1,14 @@ +lib::assert_ok::assert_ok - Rust

Module lib::assert_ok::assert_ok

source ·
Expand description

Assert expression is Ok(_).

+

Pseudocode:
+a is Ok(_)

+

§Example

+
use assertables::*;
+let a: Result<(), i8> = Ok(());
+assert_ok!(a);
+

§Module macros

+ +
\ No newline at end of file diff --git a/doc/lib/assert_ok/assert_ok/sidebar-items.js b/doc/lib/assert_ok/assert_ok/sidebar-items.js new file mode 100644 index 000000000..5244ce01c --- /dev/null +++ b/doc/lib/assert_ok/assert_ok/sidebar-items.js @@ -0,0 +1 @@ +window.SIDEBAR_ITEMS = {}; \ No newline at end of file diff --git a/doc/lib/assert_ok/assert_ok_eq/index.html b/doc/lib/assert_ok/assert_ok_eq/index.html new file mode 100644 index 000000000..9d46ba214 --- /dev/null +++ b/doc/lib/assert_ok/assert_ok_eq/index.html @@ -0,0 +1,15 @@ +lib::assert_ok::assert_ok_eq - Rust

Module lib::assert_ok::assert_ok_eq

source ·
Expand description

Assert two expressions are Ok(_) and their values are equal.

+

Pseudocode:
+(a ⇒ Ok(a̅) ⇒ a̅) = (b ⇒ Ok(b̅) ⇒ b̅)

+

§Example

+
use assertables::*;
+let a: Result<i8, i8> = Ok(1);
+let b: Result<i8, i8> = Ok(1);
+assert_ok_eq!(a, b);
+

§Module macros

+ +
\ No newline at end of file diff --git a/doc/lib/assert_ok/assert_ok_eq/sidebar-items.js b/doc/lib/assert_ok/assert_ok_eq/sidebar-items.js new file mode 100644 index 000000000..5244ce01c --- /dev/null +++ b/doc/lib/assert_ok/assert_ok_eq/sidebar-items.js @@ -0,0 +1 @@ +window.SIDEBAR_ITEMS = {}; \ No newline at end of file diff --git a/doc/lib/assert_ok/assert_ok_eq_expr/index.html b/doc/lib/assert_ok/assert_ok_eq_expr/index.html new file mode 100644 index 000000000..520d575d3 --- /dev/null +++ b/doc/lib/assert_ok/assert_ok_eq_expr/index.html @@ -0,0 +1,15 @@ +lib::assert_ok::assert_ok_eq_expr - Rust

Module lib::assert_ok::assert_ok_eq_expr

source ·
Expand description

Assert an expression is Ok(_) and its value is equal to an expression.

+

Pseudocode:
+(a ⇒ Ok(a̅) ⇒ a̅) = b

+

§Example

+
use assertables::*;
+let a: Result<i8, i8> = Ok(1);
+let b: i8 = 1;
+assert_ok_eq_expr!(a, b);
+

§Module macros

+ +
\ No newline at end of file diff --git a/doc/lib/assert_ok/assert_ok_eq_expr/sidebar-items.js b/doc/lib/assert_ok/assert_ok_eq_expr/sidebar-items.js new file mode 100644 index 000000000..5244ce01c --- /dev/null +++ b/doc/lib/assert_ok/assert_ok_eq_expr/sidebar-items.js @@ -0,0 +1 @@ +window.SIDEBAR_ITEMS = {}; \ No newline at end of file diff --git a/doc/lib/assert_ok/assert_ok_ne/index.html b/doc/lib/assert_ok/assert_ok_ne/index.html new file mode 100644 index 000000000..2b6d3e268 --- /dev/null +++ b/doc/lib/assert_ok/assert_ok_ne/index.html @@ -0,0 +1,15 @@ +lib::assert_ok::assert_ok_ne - Rust

Module lib::assert_ok::assert_ok_ne

source ·
Expand description

Assert two expressions are Ok(_) and their values are not equal.

+

Pseudocode:
+(a ⇒ Ok(a̅) ⇒ a̅) ≠ (b ⇒ Ok(b̅) ⇒ b̅)

+

§Example

+
use assertables::*;
+let a: Result<i8, i8> = Ok(1);
+let b: Result<i8, i8> = Ok(2);
+assert_ok_ne!(a, b);
+

§Module macros

+ +
\ No newline at end of file diff --git a/doc/lib/assert_ok/assert_ok_ne/sidebar-items.js b/doc/lib/assert_ok/assert_ok_ne/sidebar-items.js new file mode 100644 index 000000000..5244ce01c --- /dev/null +++ b/doc/lib/assert_ok/assert_ok_ne/sidebar-items.js @@ -0,0 +1 @@ +window.SIDEBAR_ITEMS = {}; \ No newline at end of file diff --git a/doc/lib/assert_ok/assert_ok_ne_expr/index.html b/doc/lib/assert_ok/assert_ok_ne_expr/index.html new file mode 100644 index 000000000..bb9e666a8 --- /dev/null +++ b/doc/lib/assert_ok/assert_ok_ne_expr/index.html @@ -0,0 +1,15 @@ +lib::assert_ok::assert_ok_ne_expr - Rust

Module lib::assert_ok::assert_ok_ne_expr

source ·
Expand description

Assert an expression is Ok(_) and its value is not equal to an expression.

+

Pseudocode:
+(a ⇒ Ok(a̅) ⇒ a̅) ≠ b

+

§Example

+
use assertables::*;
+let a: Result<i8, i8> = Ok(1);
+let b: i8 = 2;
+assert_ok_ne_expr!(a, b);
+

§Module macros

+ +
\ No newline at end of file diff --git a/doc/lib/assert_ok/assert_ok_ne_expr/sidebar-items.js b/doc/lib/assert_ok/assert_ok_ne_expr/sidebar-items.js new file mode 100644 index 000000000..5244ce01c --- /dev/null +++ b/doc/lib/assert_ok/assert_ok_ne_expr/sidebar-items.js @@ -0,0 +1 @@ +window.SIDEBAR_ITEMS = {}; \ No newline at end of file diff --git a/doc/lib/assert_ok/index.html b/doc/lib/assert_ok/index.html index bc22ab68a..e4fabfbf2 100644 --- a/doc/lib/assert_ok/index.html +++ b/doc/lib/assert_ok/index.html @@ -1,14 +1,30 @@ -lib::assert_ok - Rust

Module lib::assert_ok

source ·
Expand description

Assert expression is Ok(_).

-

Pseudocode:
-a is Ok(_)

-

§Example

-
use assertables::*;
-let a: Result<(), i8> = Ok(());
-assert_ok!(a);
-

§Module macros

+lib::assert_ok - Rust

Module lib::assert_ok

source ·
Expand description

Assert macros for Ok(_) items.

+

These macros help compare Ok(…) items, such as std::Result::Ok or similar.

+

Assert expression is Ok(_):

-
\ No newline at end of file +

Compare Ok(…) to another Ok(…):

+ +

Compare Ok(…) to an expression:

+ +

Modules§

  • assert_ok
    Assert expression is Ok(_).
  • assert_ok_eq
    Assert two expressions are Ok(_) and their values are equal.
  • assert_ok_eq_expr
    Assert an expression is Ok(_) and its value is equal to an expression.
  • assert_ok_ne
    Assert two expressions are Ok(_) and their values are not equal.
  • assert_ok_ne_expr
    Assert an expression is Ok(_) and its value is not equal to an expression.
\ No newline at end of file diff --git a/doc/lib/assert_ok/sidebar-items.js b/doc/lib/assert_ok/sidebar-items.js index 5244ce01c..edb9dd9cc 100644 --- a/doc/lib/assert_ok/sidebar-items.js +++ b/doc/lib/assert_ok/sidebar-items.js @@ -1 +1 @@ -window.SIDEBAR_ITEMS = {}; \ No newline at end of file +window.SIDEBAR_ITEMS = {"mod":["assert_ok","assert_ok_eq","assert_ok_eq_expr","assert_ok_ne","assert_ok_ne_expr"]}; \ No newline at end of file diff --git a/doc/lib/assert_pending/assert_pending/index.html b/doc/lib/assert_pending/assert_pending/index.html new file mode 100644 index 000000000..cdc271a7e --- /dev/null +++ b/doc/lib/assert_pending/assert_pending/index.html @@ -0,0 +1,17 @@ +lib::assert_pending::assert_pending - Rust

Module lib::assert_pending::assert_pending

source ·
Expand description

Assert an expression is Pending.

+

Pseudocode:
+a is Pending

+

§Example

+
use assertables::*;
+use std::task::Poll;
+use std::task::Poll::*;
+
+let a: Poll<i8> = Pending;
+assert_pending!(a);
+

§Module macros

+ +
\ No newline at end of file diff --git a/doc/lib/assert_pending/assert_pending/sidebar-items.js b/doc/lib/assert_pending/assert_pending/sidebar-items.js new file mode 100644 index 000000000..5244ce01c --- /dev/null +++ b/doc/lib/assert_pending/assert_pending/sidebar-items.js @@ -0,0 +1 @@ +window.SIDEBAR_ITEMS = {}; \ No newline at end of file diff --git a/doc/lib/assert_pending/index.html b/doc/lib/assert_pending/index.html index 8940ada3f..1c2a99697 100644 --- a/doc/lib/assert_pending/index.html +++ b/doc/lib/assert_pending/index.html @@ -1,17 +1,8 @@ -lib::assert_pending - Rust

Module lib::assert_pending

source ·
Expand description

Assert an expression is Pending.

-

Pseudocode:
-a is Pending

-

§Example

-
use assertables::*;
-use std::task::Poll;
-use std::task::Poll::*;
-
-let a: Poll<i8> = Pending;
-assert_pending!(a);
-

§Module macros

+lib::assert_pending - Rust

Module lib::assert_pending

source ·
Expand description

Assert macro for Pending items.

+

These macros help compare Pending items, such as std::Poll::Pending or similar.

+

Assert expression is Pending:

-
\ No newline at end of file +

Modules§

\ No newline at end of file diff --git a/doc/lib/assert_pending/sidebar-items.js b/doc/lib/assert_pending/sidebar-items.js index 5244ce01c..728aeeb65 100644 --- a/doc/lib/assert_pending/sidebar-items.js +++ b/doc/lib/assert_pending/sidebar-items.js @@ -1 +1 @@ -window.SIDEBAR_ITEMS = {}; \ No newline at end of file +window.SIDEBAR_ITEMS = {"mod":["assert_pending"]}; \ No newline at end of file diff --git a/doc/lib/assert_ready/assert_ready/index.html b/doc/lib/assert_ready/assert_ready/index.html new file mode 100644 index 000000000..fe072eb47 --- /dev/null +++ b/doc/lib/assert_ready/assert_ready/index.html @@ -0,0 +1,17 @@ +lib::assert_ready::assert_ready - Rust

Module lib::assert_ready::assert_ready

source ·
Expand description

Assert an expression is Ready(_).

+

Pseudocode:
+a is Ready(_)

+

§Example

+
use assertables::*;
+use std::task::Poll;
+use std::task::Poll::*;
+
+let a: Poll<i8> = Ready(1);
+assert_ready!(a);
+

§Module macros

+ +
\ No newline at end of file diff --git a/doc/lib/assert_ready/assert_ready/sidebar-items.js b/doc/lib/assert_ready/assert_ready/sidebar-items.js new file mode 100644 index 000000000..5244ce01c --- /dev/null +++ b/doc/lib/assert_ready/assert_ready/sidebar-items.js @@ -0,0 +1 @@ +window.SIDEBAR_ITEMS = {}; \ No newline at end of file diff --git a/doc/lib/assert_ready/assert_ready_eq/index.html b/doc/lib/assert_ready/assert_ready_eq/index.html new file mode 100644 index 000000000..a9f988c6f --- /dev/null +++ b/doc/lib/assert_ready/assert_ready_eq/index.html @@ -0,0 +1,17 @@ +lib::assert_ready::assert_ready_eq - Rust

Module lib::assert_ready::assert_ready_eq

source ·
Expand description

Assert two expressions are Ready(_) and their values are equal.

+

Pseudocode:
+(a ⇒ Ready(a̅) ⇒ a̅) = (b ⇒ Ready(b̅) ⇒ b̅)

+

§Example

+
use assertables::*;
+use std::task::Poll;
+use std::task::Poll::*;
+let a: Poll<i8> = Ready(1);
+let b: Poll<i8> = Ready(1);
+assert_ready_eq!(a, b);
+

§Module macros

+ +
\ No newline at end of file diff --git a/doc/lib/assert_ready/assert_ready_eq/sidebar-items.js b/doc/lib/assert_ready/assert_ready_eq/sidebar-items.js new file mode 100644 index 000000000..5244ce01c --- /dev/null +++ b/doc/lib/assert_ready/assert_ready_eq/sidebar-items.js @@ -0,0 +1 @@ +window.SIDEBAR_ITEMS = {}; \ No newline at end of file diff --git a/doc/lib/assert_ready/assert_ready_eq_expr/index.html b/doc/lib/assert_ready/assert_ready_eq_expr/index.html new file mode 100644 index 000000000..94c016215 --- /dev/null +++ b/doc/lib/assert_ready/assert_ready_eq_expr/index.html @@ -0,0 +1,17 @@ +lib::assert_ready::assert_ready_eq_expr - Rust

Module lib::assert_ready::assert_ready_eq_expr

source ·
Expand description

Assert an expression is Ready(_) and its value is equal to an expression.

+

Pseudocode:
+(a ⇒ Ready(a̅) ⇒ a̅) = b

+

§Example

+
use assertables::*;
+use std::task::Poll;
+use std::task::Poll::*;
+let a: Poll<i8> = Ready(1);
+let b: i8 = 1;
+assert_ready_eq_expr!(a, b);
+

§Module macros

+ +
\ No newline at end of file diff --git a/doc/lib/assert_ready/assert_ready_eq_expr/sidebar-items.js b/doc/lib/assert_ready/assert_ready_eq_expr/sidebar-items.js new file mode 100644 index 000000000..5244ce01c --- /dev/null +++ b/doc/lib/assert_ready/assert_ready_eq_expr/sidebar-items.js @@ -0,0 +1 @@ +window.SIDEBAR_ITEMS = {}; \ No newline at end of file diff --git a/doc/lib/assert_ready/assert_ready_ne/index.html b/doc/lib/assert_ready/assert_ready_ne/index.html new file mode 100644 index 000000000..05e615d08 --- /dev/null +++ b/doc/lib/assert_ready/assert_ready_ne/index.html @@ -0,0 +1,17 @@ +lib::assert_ready::assert_ready_ne - Rust

Module lib::assert_ready::assert_ready_ne

source ·
Expand description

Assert two expressions are Ready(_) and their values are not equal.

+

Pseudocode:
+(a ⇒ Ready(a̅) ⇒ a̅) ≠ (b ⇒ Ready(b̅) ⇒ b̅)

+

§Example

+
use assertables::*;
+use std::task::Poll;
+use std::task::Poll::*;
+let a: Poll<i8> = Ready(1);
+let b: Poll<i8> = Ready(2);
+assert_ready_ne!(a, b);
+

§Module macros

+ +
\ No newline at end of file diff --git a/doc/lib/assert_ready/assert_ready_ne/sidebar-items.js b/doc/lib/assert_ready/assert_ready_ne/sidebar-items.js new file mode 100644 index 000000000..5244ce01c --- /dev/null +++ b/doc/lib/assert_ready/assert_ready_ne/sidebar-items.js @@ -0,0 +1 @@ +window.SIDEBAR_ITEMS = {}; \ No newline at end of file diff --git a/doc/lib/assert_ready/assert_ready_ne_expr/index.html b/doc/lib/assert_ready/assert_ready_ne_expr/index.html new file mode 100644 index 000000000..8da50076c --- /dev/null +++ b/doc/lib/assert_ready/assert_ready_ne_expr/index.html @@ -0,0 +1,17 @@ +lib::assert_ready::assert_ready_ne_expr - Rust

Module lib::assert_ready::assert_ready_ne_expr

source ·
Expand description

Assert an expression is Ready(_) and its value is not equal to an expression.

+

Pseudocode:
+(a ⇒ Ready(a̅) ⇒ a̅) ≠ b

+

§Example

+
use assertables::*;
+use std::task::Poll;
+use std::task::Poll::*;
+let a: Poll<i8> = Ready(1);
+let b: i8 = 2;
+assert_ready_ne_expr!(a, b);
+

§Module macros

+ +
\ No newline at end of file diff --git a/doc/lib/assert_ready/assert_ready_ne_expr/sidebar-items.js b/doc/lib/assert_ready/assert_ready_ne_expr/sidebar-items.js new file mode 100644 index 000000000..5244ce01c --- /dev/null +++ b/doc/lib/assert_ready/assert_ready_ne_expr/sidebar-items.js @@ -0,0 +1 @@ +window.SIDEBAR_ITEMS = {}; \ No newline at end of file diff --git a/doc/lib/assert_ready/index.html b/doc/lib/assert_ready/index.html index adee5e128..25220edda 100644 --- a/doc/lib/assert_ready/index.html +++ b/doc/lib/assert_ready/index.html @@ -1,17 +1,30 @@ -lib::assert_ready - Rust

Module lib::assert_ready

source ·
Expand description

Assert an expression is Ready(_).

-

Pseudocode:
-a is Ready(_)

-

§Example

-
use assertables::*;
-use std::task::Poll;
-use std::task::Poll::*;
-
-let a: Poll<i8> = Ready(1);
-assert_ready!(a);
-

§Module macros

+lib::assert_ready - Rust

Module lib::assert_ready

source ·
Expand description

Assert macros for Ready(_) items.

+

These macros help compare Ready(…) items, such as std::Ready::Ready or similar.

+

Assert expression is Ready(_):

-
\ No newline at end of file +

Compare Ready(…) to another Ready(…):

+ +

Compare Ready(…) to an expression:

+ +

Modules§

\ No newline at end of file diff --git a/doc/lib/assert_ready/sidebar-items.js b/doc/lib/assert_ready/sidebar-items.js index 5244ce01c..1ec6199be 100644 --- a/doc/lib/assert_ready/sidebar-items.js +++ b/doc/lib/assert_ready/sidebar-items.js @@ -1 +1 @@ -window.SIDEBAR_ITEMS = {}; \ No newline at end of file +window.SIDEBAR_ITEMS = {"mod":["assert_ready","assert_ready_eq","assert_ready_eq_expr","assert_ready_ne","assert_ready_ne_expr"]}; \ No newline at end of file diff --git a/doc/lib/assert_some/assert_some/index.html b/doc/lib/assert_some/assert_some/index.html new file mode 100644 index 000000000..1dac8a7b5 --- /dev/null +++ b/doc/lib/assert_some/assert_some/index.html @@ -0,0 +1,14 @@ +lib::assert_some::assert_some - Rust

Module lib::assert_some::assert_some

source ·
Expand description

Assert expression is Some(_).

+

Pseudocode:
+a is Some(_)

+

§Example

+
use assertables::*;
+let a: Option<i8> = Option::Some(1);
+assert_some!(a);
+

§Module macros

+ +
\ No newline at end of file diff --git a/doc/lib/assert_some/assert_some/sidebar-items.js b/doc/lib/assert_some/assert_some/sidebar-items.js new file mode 100644 index 000000000..5244ce01c --- /dev/null +++ b/doc/lib/assert_some/assert_some/sidebar-items.js @@ -0,0 +1 @@ +window.SIDEBAR_ITEMS = {}; \ No newline at end of file diff --git a/doc/lib/assert_some/assert_some_eq/index.html b/doc/lib/assert_some/assert_some_eq/index.html new file mode 100644 index 000000000..acfac7bc2 --- /dev/null +++ b/doc/lib/assert_some/assert_some_eq/index.html @@ -0,0 +1,15 @@ +lib::assert_some::assert_some_eq - Rust

Module lib::assert_some::assert_some_eq

source ·
Expand description

Assert two expressions are Some(_) and their values are equal.

+

Pseudocode:
+(a ⇒ Some(a̅) ⇒ a̅) = (b ⇒ Some(b̅) ⇒ b̅)

+

§Example

+
use assertables::*;
+let a: Option<i8> = Option::Some(1);
+let b: Option<i8> = Option::Some(1);
+assert_some_eq!(a, b);
+

§Module macros

+ +
\ No newline at end of file diff --git a/doc/lib/assert_some/assert_some_eq/sidebar-items.js b/doc/lib/assert_some/assert_some_eq/sidebar-items.js new file mode 100644 index 000000000..5244ce01c --- /dev/null +++ b/doc/lib/assert_some/assert_some_eq/sidebar-items.js @@ -0,0 +1 @@ +window.SIDEBAR_ITEMS = {}; \ No newline at end of file diff --git a/doc/lib/assert_some/assert_some_eq_expr/index.html b/doc/lib/assert_some/assert_some_eq_expr/index.html new file mode 100644 index 000000000..922814644 --- /dev/null +++ b/doc/lib/assert_some/assert_some_eq_expr/index.html @@ -0,0 +1,15 @@ +lib::assert_some::assert_some_eq_expr - Rust

Module lib::assert_some::assert_some_eq_expr

source ·
Expand description

Assert an expression is Some(_) and its value is equal to an expression.

+

Pseudocode:
+(a ⇒ Some(a̅) ⇒ a̅) = b

+

§Example

+
use assertables::*;
+let a: Option<i8> = Option::Some(1);
+let b: i8 = 1;
+assert_some_eq_expr!(a, b);
+

§Module macros

+ +
\ No newline at end of file diff --git a/doc/lib/assert_some/assert_some_eq_expr/sidebar-items.js b/doc/lib/assert_some/assert_some_eq_expr/sidebar-items.js new file mode 100644 index 000000000..5244ce01c --- /dev/null +++ b/doc/lib/assert_some/assert_some_eq_expr/sidebar-items.js @@ -0,0 +1 @@ +window.SIDEBAR_ITEMS = {}; \ No newline at end of file diff --git a/doc/lib/assert_some/assert_some_ne/index.html b/doc/lib/assert_some/assert_some_ne/index.html new file mode 100644 index 000000000..81256a7b3 --- /dev/null +++ b/doc/lib/assert_some/assert_some_ne/index.html @@ -0,0 +1,15 @@ +lib::assert_some::assert_some_ne - Rust

Module lib::assert_some::assert_some_ne

source ·
Expand description

Assert two expressions are Some(_) and their values are not equal.

+

Pseudocode:
+(a ⇒ Some(a̅) ⇒ a̅) ≠ (b ⇒ Some(b̅) ⇒ b̅)

+

§Example

+
use assertables::*;
+let a: Option<i8> = Option::Some(1);
+let b: Option<i8> = Option::Some(2);
+assert_some_ne!(a, b);
+

§Module macros

+ +
\ No newline at end of file diff --git a/doc/lib/assert_some/assert_some_ne/sidebar-items.js b/doc/lib/assert_some/assert_some_ne/sidebar-items.js new file mode 100644 index 000000000..5244ce01c --- /dev/null +++ b/doc/lib/assert_some/assert_some_ne/sidebar-items.js @@ -0,0 +1 @@ +window.SIDEBAR_ITEMS = {}; \ No newline at end of file diff --git a/doc/lib/assert_some/assert_some_ne_expr/index.html b/doc/lib/assert_some/assert_some_ne_expr/index.html new file mode 100644 index 000000000..99899686b --- /dev/null +++ b/doc/lib/assert_some/assert_some_ne_expr/index.html @@ -0,0 +1,15 @@ +lib::assert_some::assert_some_ne_expr - Rust

Module lib::assert_some::assert_some_ne_expr

source ·
Expand description

Assert an expression is Some(_) and its value is not equal to an expression.

+

Pseudocode:
+(a ⇒ Some(a̅) ⇒ a̅) ≠ b

+

§Example

+
use assertables::*;
+let a: Option<i8> = Option::Some(1);
+let b: i8 = 2;
+assert_some_ne_expr!(a, b);
+

§Module macros

+ +
\ No newline at end of file diff --git a/doc/lib/assert_some/assert_some_ne_expr/sidebar-items.js b/doc/lib/assert_some/assert_some_ne_expr/sidebar-items.js new file mode 100644 index 000000000..5244ce01c --- /dev/null +++ b/doc/lib/assert_some/assert_some_ne_expr/sidebar-items.js @@ -0,0 +1 @@ +window.SIDEBAR_ITEMS = {}; \ No newline at end of file diff --git a/doc/lib/assert_some/index.html b/doc/lib/assert_some/index.html index c6acc4108..aec97c7c9 100644 --- a/doc/lib/assert_some/index.html +++ b/doc/lib/assert_some/index.html @@ -1,14 +1,30 @@ -lib::assert_some - Rust

Module lib::assert_some

source ·
Expand description

Assert expression is Some(_).

-

Pseudocode:
-a is Some(_)

-

§Example

-
use assertables::*;
-let a: Option<i8> = Option::Some(1);
-assert_some!(a);
-

§Module macros

+lib::assert_some - Rust

Module lib::assert_some

source ·
Expand description

Assert macros for Some(_) items.

+

These macros help compare Some(…) items, such as std::Option::Some or similar.

+

Assert expression is Some(_):

-
\ No newline at end of file +

Compare Some(…) to another Some(…):

+ +

Compare Some(…) to an expression:

+ +

Modules§

\ No newline at end of file diff --git a/doc/lib/assert_some/sidebar-items.js b/doc/lib/assert_some/sidebar-items.js index 5244ce01c..58196719f 100644 --- a/doc/lib/assert_some/sidebar-items.js +++ b/doc/lib/assert_some/sidebar-items.js @@ -1 +1 @@ -window.SIDEBAR_ITEMS = {}; \ No newline at end of file +window.SIDEBAR_ITEMS = {"mod":["assert_some","assert_some_eq","assert_some_eq_expr","assert_some_ne","assert_some_ne_expr"]}; \ No newline at end of file diff --git a/doc/lib/index.html b/doc/lib/index.html index 90791b7a2..3554e861f 100644 --- a/doc/lib/index.html +++ b/doc/lib/index.html @@ -1,4 +1,4 @@ -lib - Rust

Crate lib

source ·
Expand description

§Assertables: Rust crate of assert macros for testing

+lib - Rust

Crate lib

source ·
Expand description

§Assertables: Rust crate of assert macros for testing

The assertables Rust crate provides many assert macros to improve your compile-time tests and run-time reliability.

    @@ -73,27 +73,17 @@

    §Introduct

For Result Ok/Err:

For Option Some/None:

For Poll Ready/Pending:

For collections such as arrays, vectors, maps, sets:

@@ -114,8 +104,8 @@

§Introduct

There are many more macros that are grouped into modules.

Modules for collections, such as arrays, vectors, lists, maps:

Modules for functions:

-

§Forms

§Forms for panic versus error

-

All the assert macros have 3 forms for different purposes:

+

§Forms

+

All assertables macros have forms for different outcomes:

-

Examples:

- -

§Forms for messages

-

All the assert macros have 2 forms for messages.

+

All assertables macros have forms for an optional message:

-

Examples:

- -

§Forms for other versus expression

-

Many of the assert macros have 2 forms for comparing left hand side and right hand side.

-
    -
  • Comparing a LHS item to a RHS other of the same type.
    • -
  • Comparing a LHS item to a RHS expression.
    • -
-

Examples:

+

Many assertables macros have forms for comparing left hand side (LHS) and right hand side (RHS) as the same type or as an expression:

§Tracking

    @@ -177,4 +149,4 @@

    §Tracking

  • License: MIT or Apache-2.0 or GPL-2.0 or GPL-3.0 or contact us for more
  • Contact: Joel Parker Henderson (joel@sixarm.com)
-

Modules§

Macros§

\ No newline at end of file +

Modules§

Macros§

\ No newline at end of file diff --git a/doc/lib/macro.assert_err.html b/doc/lib/macro.assert_err.html index c482d024c..04e91321a 100644 --- a/doc/lib/macro.assert_err.html +++ b/doc/lib/macro.assert_err.html @@ -1,4 +1,4 @@ -assert_err in lib - Rust

Macro lib::assert_err

source · 
macro_rules! assert_err {
+assert_err in lib - Rust
Macro lib::assert_err
source · 
macro_rules! assert_err {
     ($a:expr $(,)?) => { ... };
     ($a:expr, $($message:tt)+) => { ... };
 }
Expand description
Assert expression is Err(_).

diff --git a/doc/lib/macro.assert_err_as_result.html b/doc/lib/macro.assert_err_as_result.html
index 37a613db0..ea3686c30 100644
--- a/doc/lib/macro.assert_err_as_result.html
+++ b/doc/lib/macro.assert_err_as_result.html
@@ -1,4 +1,4 @@
-assert_err_as_result in lib - Rust
Macro lib::assert_err_as_result
source · 
macro_rules! assert_err_as_result {
+assert_err_as_result in lib - Rust
Macro lib::assert_err_as_result
source · 
macro_rules! assert_err_as_result {
     ($a:expr $(,)?) => { ... };
 }
Expand description
Assert expression is Err(_).

 
Pseudocode:

diff --git a/doc/lib/macro.assert_err_eq.html b/doc/lib/macro.assert_err_eq.html
index c23a8b5b8..aa2ee8321 100644
--- a/doc/lib/macro.assert_err_eq.html
+++ b/doc/lib/macro.assert_err_eq.html
@@ -1,4 +1,4 @@
-assert_err_eq in lib - Rust
Macro lib::assert_err_eq
source · 
macro_rules! assert_err_eq {
+assert_err_eq in lib - Rust
Macro lib::assert_err_eq
source · 
macro_rules! assert_err_eq {
     ($a:expr, $b:expr $(,)?) => { ... };
     ($a:expr, $b:expr, $($message:tt)+) => { ... };
 }
Expand description
Assert two expressions are Err(_) and their values are equal.

diff --git a/doc/lib/macro.assert_err_eq_as_result.html b/doc/lib/macro.assert_err_eq_as_result.html
index da926f2a3..ef089461d 100644
--- a/doc/lib/macro.assert_err_eq_as_result.html
+++ b/doc/lib/macro.assert_err_eq_as_result.html
@@ -1,4 +1,4 @@
-assert_err_eq_as_result in lib - Rust
Macro lib::assert_err_eq_as_result
source · 
macro_rules! assert_err_eq_as_result {
+assert_err_eq_as_result in lib - Rust
Macro lib::assert_err_eq_as_result
source · 
macro_rules! assert_err_eq_as_result {
     ($a:expr, $b:expr $(,)?) => { ... };
 }
Expand description
Assert two expressions are Err(_) and their values are equal.

 
Pseudocode:

diff --git a/doc/lib/macro.assert_err_eq_expr.html b/doc/lib/macro.assert_err_eq_expr.html
index 878060cca..d48b0cd21 100644
--- a/doc/lib/macro.assert_err_eq_expr.html
+++ b/doc/lib/macro.assert_err_eq_expr.html
@@ -1,4 +1,4 @@
-assert_err_eq_expr in lib - Rust
Macro lib::assert_err_eq_expr
source · 
macro_rules! assert_err_eq_expr {
+assert_err_eq_expr in lib - Rust
Macro lib::assert_err_eq_expr
source · 
macro_rules! assert_err_eq_expr {
     ($a:expr, $b:expr $(,)?) => { ... };
     ($a:expr, $b:expr, $($message:tt)+) => { ... };
 }
Expand description
Assert an expression is Err(_) and its value is equal to an expression.

diff --git a/doc/lib/macro.assert_err_eq_expr_as_result.html b/doc/lib/macro.assert_err_eq_expr_as_result.html
index 9c88120af..5e7b0185b 100644
--- a/doc/lib/macro.assert_err_eq_expr_as_result.html
+++ b/doc/lib/macro.assert_err_eq_expr_as_result.html
@@ -1,4 +1,4 @@
-assert_err_eq_expr_as_result in lib - Rust
Macro lib::assert_err_eq_expr_as_result
source · 
macro_rules! assert_err_eq_expr_as_result {
+assert_err_eq_expr_as_result in lib - Rust
Macro lib::assert_err_eq_expr_as_result
source · 
macro_rules! assert_err_eq_expr_as_result {
     ($a:expr, $b:expr $(,)?) => { ... };
 }
Expand description
Assert an expression is Err(_) and its value is equal to an expression.

 
Pseudocode:

diff --git a/doc/lib/macro.assert_err_ne.html b/doc/lib/macro.assert_err_ne.html
index 73b02109d..ad8edd1f9 100644
--- a/doc/lib/macro.assert_err_ne.html
+++ b/doc/lib/macro.assert_err_ne.html
@@ -1,4 +1,4 @@
-assert_err_ne in lib - Rust
Macro lib::assert_err_ne
source · 
macro_rules! assert_err_ne {
+assert_err_ne in lib - Rust
Macro lib::assert_err_ne
source · 
macro_rules! assert_err_ne {
     ($a:expr, $b:expr $(,)?) => { ... };
     ($a:expr, $b:expr, $($message:tt)+) => { ... };
 }
Expand description
Assert two expressions are Err(_) and their values are not equal.

diff --git a/doc/lib/macro.assert_err_ne_as_result.html b/doc/lib/macro.assert_err_ne_as_result.html
index 96e4d1853..efe6b4cd2 100644
--- a/doc/lib/macro.assert_err_ne_as_result.html
+++ b/doc/lib/macro.assert_err_ne_as_result.html
@@ -1,4 +1,4 @@
-assert_err_ne_as_result in lib - Rust
Macro lib::assert_err_ne_as_result
source · 
macro_rules! assert_err_ne_as_result {
+assert_err_ne_as_result in lib - Rust
Macro lib::assert_err_ne_as_result
source · 
macro_rules! assert_err_ne_as_result {
     ($a:expr, $b:expr $(,)?) => { ... };
 }
Expand description
Assert two expressions are Err(_) and their values are not equal.

 
Pseudocode:

diff --git a/doc/lib/macro.assert_err_ne_expr.html b/doc/lib/macro.assert_err_ne_expr.html
index f1c791d30..ff5dfd36e 100644
--- a/doc/lib/macro.assert_err_ne_expr.html
+++ b/doc/lib/macro.assert_err_ne_expr.html
@@ -1,4 +1,4 @@
-assert_err_ne_expr in lib - Rust
Macro lib::assert_err_ne_expr
source · 
macro_rules! assert_err_ne_expr {
+assert_err_ne_expr in lib - Rust
Macro lib::assert_err_ne_expr
source · 
macro_rules! assert_err_ne_expr {
     ($a:expr, $b:expr $(,)?) => { ... };
     ($a:expr, $b:expr, $($message:tt)+) => { ... };
 }
Expand description
Assert an expression is Err(_) and its value is equal to an expression.

diff --git a/doc/lib/macro.assert_err_ne_expr_as_result.html b/doc/lib/macro.assert_err_ne_expr_as_result.html
index 621c54888..b27e62fec 100644
--- a/doc/lib/macro.assert_err_ne_expr_as_result.html
+++ b/doc/lib/macro.assert_err_ne_expr_as_result.html
@@ -1,4 +1,4 @@
-assert_err_ne_expr_as_result in lib - Rust
Macro lib::assert_err_ne_expr_as_result
source · 
macro_rules! assert_err_ne_expr_as_result {
+assert_err_ne_expr_as_result in lib - Rust
Macro lib::assert_err_ne_expr_as_result
source · 
macro_rules! assert_err_ne_expr_as_result {
     ($a:expr, $b:expr $(,)?) => { ... };
 }
Expand description
Assert an expression is Err(_) and its value is equal to an expression.

 
Pseudocode:

diff --git a/doc/lib/macro.assert_none.html b/doc/lib/macro.assert_none.html
index 07e71408d..c2ad89d42 100644
--- a/doc/lib/macro.assert_none.html
+++ b/doc/lib/macro.assert_none.html
@@ -1,4 +1,4 @@
-assert_none in lib - Rust
Macro lib::assert_none
source · 
macro_rules! assert_none {
+assert_none in lib - Rust
Macro lib::assert_none
source · 
macro_rules! assert_none {
     ($a:expr $(,)?) => { ... };
     ($a:expr, $($message:tt)+) => { ... };
 }
Expand description
Assert expression is None.

diff --git a/doc/lib/macro.assert_none_as_result.html b/doc/lib/macro.assert_none_as_result.html
index 20a02942e..0a4be022f 100644
--- a/doc/lib/macro.assert_none_as_result.html
+++ b/doc/lib/macro.assert_none_as_result.html
@@ -1,4 +1,4 @@
-assert_none_as_result in lib - Rust
Macro lib::assert_none_as_result
source · 
macro_rules! assert_none_as_result {
+assert_none_as_result in lib - Rust
Macro lib::assert_none_as_result
source · 
macro_rules! assert_none_as_result {
     ($a:expr $(,)?) => { ... };
 }
Expand description
Assert an expression.is_none() is true.

 
Pseudocode:

diff --git a/doc/lib/macro.assert_ok.html b/doc/lib/macro.assert_ok.html
index 00a10cba9..56bf583de 100644
--- a/doc/lib/macro.assert_ok.html
+++ b/doc/lib/macro.assert_ok.html
@@ -1,4 +1,4 @@
-assert_ok in lib - Rust
Macro lib::assert_ok
source · 
macro_rules! assert_ok {
+assert_ok in lib - Rust
Macro lib::assert_ok
source · 
macro_rules! assert_ok {
     ($a:expr $(,)?) => { ... };
     ($a:expr, $($message:tt)+) => { ... };
 }
Expand description
Assert expression is Ok(_).

diff --git a/doc/lib/macro.assert_ok_as_result.html b/doc/lib/macro.assert_ok_as_result.html
index 574995b4d..881584ea0 100644
--- a/doc/lib/macro.assert_ok_as_result.html
+++ b/doc/lib/macro.assert_ok_as_result.html
@@ -1,4 +1,4 @@
-assert_ok_as_result in lib - Rust
Macro lib::assert_ok_as_result
source · 
macro_rules! assert_ok_as_result {
+assert_ok_as_result in lib - Rust
Macro lib::assert_ok_as_result
source · 
macro_rules! assert_ok_as_result {
     ($a:expr $(,)?) => { ... };
 }
Expand description
Assert expression is Ok(_).

 
Pseudocode:

diff --git a/doc/lib/macro.assert_ok_eq.html b/doc/lib/macro.assert_ok_eq.html
index e8deb0766..82de41a94 100644
--- a/doc/lib/macro.assert_ok_eq.html
+++ b/doc/lib/macro.assert_ok_eq.html
@@ -1,4 +1,4 @@
-assert_ok_eq in lib - Rust
Macro lib::assert_ok_eq
source · 
macro_rules! assert_ok_eq {
+assert_ok_eq in lib - Rust
Macro lib::assert_ok_eq
source · 
macro_rules! assert_ok_eq {
     ($a:expr, $b:expr $(,)?) => { ... };
     ($a:expr, $b:expr, $($message:tt)+) => { ... };
 }
Expand description
Assert two expressions are Ok(_) and their values are equal.

diff --git a/doc/lib/macro.assert_ok_eq_as_result.html b/doc/lib/macro.assert_ok_eq_as_result.html
index 36d9cd1df..750de176f 100644
--- a/doc/lib/macro.assert_ok_eq_as_result.html
+++ b/doc/lib/macro.assert_ok_eq_as_result.html
@@ -1,4 +1,4 @@
-assert_ok_eq_as_result in lib - Rust
Macro lib::assert_ok_eq_as_result
source · 
macro_rules! assert_ok_eq_as_result {
+assert_ok_eq_as_result in lib - Rust
Macro lib::assert_ok_eq_as_result
source · 
macro_rules! assert_ok_eq_as_result {
     ($a:expr, $b:expr $(,)?) => { ... };
 }
Expand description
Assert two expressions are Ok(_) and their values are equal.

 
Pseudocode:

diff --git a/doc/lib/macro.assert_ok_eq_expr.html b/doc/lib/macro.assert_ok_eq_expr.html
index 9f64cbb62..a26de2107 100644
--- a/doc/lib/macro.assert_ok_eq_expr.html
+++ b/doc/lib/macro.assert_ok_eq_expr.html
@@ -1,4 +1,4 @@
-assert_ok_eq_expr in lib - Rust
Macro lib::assert_ok_eq_expr
source · 
macro_rules! assert_ok_eq_expr {
+assert_ok_eq_expr in lib - Rust
Macro lib::assert_ok_eq_expr
source · 
macro_rules! assert_ok_eq_expr {
     ($a:expr, $b:expr $(,)?) => { ... };
     ($a:expr, $b:expr, $($message:tt)+) => { ... };
 }
Expand description
Assert an expression is Ok(_) and its value is equal to an expression.

diff --git a/doc/lib/macro.assert_ok_eq_expr_as_result.html b/doc/lib/macro.assert_ok_eq_expr_as_result.html
index 962021160..76e58e4c6 100644
--- a/doc/lib/macro.assert_ok_eq_expr_as_result.html
+++ b/doc/lib/macro.assert_ok_eq_expr_as_result.html
@@ -1,4 +1,4 @@
-assert_ok_eq_expr_as_result in lib - Rust
Macro lib::assert_ok_eq_expr_as_result
source · 
macro_rules! assert_ok_eq_expr_as_result {
+assert_ok_eq_expr_as_result in lib - Rust
Macro lib::assert_ok_eq_expr_as_result
source · 
macro_rules! assert_ok_eq_expr_as_result {
     ($a:expr, $b:expr $(,)?) => { ... };
 }
Expand description
Assert an expression is Ok(_) and its value is equal to an expression.

 
Pseudocode:

diff --git a/doc/lib/macro.assert_ok_ne.html b/doc/lib/macro.assert_ok_ne.html
index bf992fc5c..a581f51f3 100644
--- a/doc/lib/macro.assert_ok_ne.html
+++ b/doc/lib/macro.assert_ok_ne.html
@@ -1,4 +1,4 @@
-assert_ok_ne in lib - Rust
Macro lib::assert_ok_ne
source · 
macro_rules! assert_ok_ne {
+assert_ok_ne in lib - Rust
Macro lib::assert_ok_ne
source · 
macro_rules! assert_ok_ne {
     ($a:expr, $b:expr $(,)?) => { ... };
     ($a:expr, $b:expr, $($message:tt)+) => { ... };
 }
Expand description
Assert two expressions are Ok(_) and their values are not equal.

diff --git a/doc/lib/macro.assert_ok_ne_as_result.html b/doc/lib/macro.assert_ok_ne_as_result.html
index be2584727..7701e8944 100644
--- a/doc/lib/macro.assert_ok_ne_as_result.html
+++ b/doc/lib/macro.assert_ok_ne_as_result.html
@@ -1,4 +1,4 @@
-assert_ok_ne_as_result in lib - Rust
Macro lib::assert_ok_ne_as_result
source · 
macro_rules! assert_ok_ne_as_result {
+assert_ok_ne_as_result in lib - Rust
Macro lib::assert_ok_ne_as_result
source · 
macro_rules! assert_ok_ne_as_result {
     ($a:expr, $b:expr $(,)?) => { ... };
 }
Expand description
Assert two expressions are Ok(_) and their values are not equal.

 
Pseudocode:

diff --git a/doc/lib/macro.assert_ok_ne_expr.html b/doc/lib/macro.assert_ok_ne_expr.html
index 71f01ca12..763edaca4 100644
--- a/doc/lib/macro.assert_ok_ne_expr.html
+++ b/doc/lib/macro.assert_ok_ne_expr.html
@@ -1,4 +1,4 @@
-assert_ok_ne_expr in lib - Rust
Macro lib::assert_ok_ne_expr
source · 
macro_rules! assert_ok_ne_expr {
+assert_ok_ne_expr in lib - Rust
Macro lib::assert_ok_ne_expr
source · 
macro_rules! assert_ok_ne_expr {
     ($a:expr, $b:expr $(,)?) => { ... };
     ($a:expr, $b:expr, $($message:tt)+) => { ... };
 }
Expand description
Assert an expression is Ok(_) and its value is equal to an expression.

diff --git a/doc/lib/macro.assert_ok_ne_expr_as_result.html b/doc/lib/macro.assert_ok_ne_expr_as_result.html
index b9f436568..b861cb9a8 100644
--- a/doc/lib/macro.assert_ok_ne_expr_as_result.html
+++ b/doc/lib/macro.assert_ok_ne_expr_as_result.html
@@ -1,4 +1,4 @@
-assert_ok_ne_expr_as_result in lib - Rust
Macro lib::assert_ok_ne_expr_as_result
source · 
macro_rules! assert_ok_ne_expr_as_result {
+assert_ok_ne_expr_as_result in lib - Rust
Macro lib::assert_ok_ne_expr_as_result
source · 
macro_rules! assert_ok_ne_expr_as_result {
     ($a:expr, $b:expr $(,)?) => { ... };
 }
Expand description
Assert an expression is Ok(_) and its value is equal to an expression.

 
Pseudocode:

diff --git a/doc/lib/macro.assert_pending.html b/doc/lib/macro.assert_pending.html
index 7ec8c1776..122c0b15f 100644
--- a/doc/lib/macro.assert_pending.html
+++ b/doc/lib/macro.assert_pending.html
@@ -1,4 +1,4 @@
-assert_pending in lib - Rust
Macro lib::assert_pending
source · 
macro_rules! assert_pending {
+assert_pending in lib - Rust
Macro lib::assert_pending
source · 
macro_rules! assert_pending {
     ($a:expr $(,)?) => { ... };
     ($a:expr, $($message:tt)+) => { ... };
 }
Expand description
Assert an expression is Pending.

diff --git a/doc/lib/macro.assert_pending_as_result.html b/doc/lib/macro.assert_pending_as_result.html
index 4bc81cb4c..35956c263 100644
--- a/doc/lib/macro.assert_pending_as_result.html
+++ b/doc/lib/macro.assert_pending_as_result.html
@@ -1,4 +1,4 @@
-assert_pending_as_result in lib - Rust
Macro lib::assert_pending_as_result
source · 
macro_rules! assert_pending_as_result {
+assert_pending_as_result in lib - Rust
Macro lib::assert_pending_as_result
source · 
macro_rules! assert_pending_as_result {
     ($a:expr $(,)?) => { ... };
 }
Expand description
Assert an expression.is_pending() is true.

 
Pseudocode:

diff --git a/doc/lib/macro.assert_ready.html b/doc/lib/macro.assert_ready.html
index 2e9821e5c..b5663b78d 100644
--- a/doc/lib/macro.assert_ready.html
+++ b/doc/lib/macro.assert_ready.html
@@ -1,4 +1,4 @@
-assert_ready in lib - Rust
Macro lib::assert_ready
source · 
macro_rules! assert_ready {
+assert_ready in lib - Rust
Macro lib::assert_ready
source · 
macro_rules! assert_ready {
     ($a:expr $(,)?) => { ... };
     ($a:expr, $($message:tt)+) => { ... };
 }
Expand description
Assert an expression is Ready(_).

diff --git a/doc/lib/macro.assert_ready_as_result.html b/doc/lib/macro.assert_ready_as_result.html
index 746d89530..6fd680eb5 100644
--- a/doc/lib/macro.assert_ready_as_result.html
+++ b/doc/lib/macro.assert_ready_as_result.html
@@ -1,4 +1,4 @@
-assert_ready_as_result in lib - Rust
Macro lib::assert_ready_as_result
source · 
macro_rules! assert_ready_as_result {
+assert_ready_as_result in lib - Rust
Macro lib::assert_ready_as_result
source · 
macro_rules! assert_ready_as_result {
     ($a:expr $(,)?) => { ... };
 }
Expand description
Assert an expression is Ready(_).

 
Pseudocode:

diff --git a/doc/lib/macro.assert_ready_eq.html b/doc/lib/macro.assert_ready_eq.html
index 543ddc32e..1c77c189a 100644
--- a/doc/lib/macro.assert_ready_eq.html
+++ b/doc/lib/macro.assert_ready_eq.html
@@ -1,4 +1,4 @@
-assert_ready_eq in lib - Rust
Macro lib::assert_ready_eq
source · 
macro_rules! assert_ready_eq {
+assert_ready_eq in lib - Rust
Macro lib::assert_ready_eq
source · 
macro_rules! assert_ready_eq {
     ($a:expr, $b:expr $(,)?) => { ... };
     ($a:expr, $b:expr, $($message:tt)+) => { ... };
 }
Expand description
Assert two expressions are Ready(_) and their values are equal.

diff --git a/doc/lib/macro.assert_ready_eq_as_result.html b/doc/lib/macro.assert_ready_eq_as_result.html
index b45fa7210..ecce9a759 100644
--- a/doc/lib/macro.assert_ready_eq_as_result.html
+++ b/doc/lib/macro.assert_ready_eq_as_result.html
@@ -1,4 +1,4 @@
-assert_ready_eq_as_result in lib - Rust
Macro lib::assert_ready_eq_as_result
source · 
macro_rules! assert_ready_eq_as_result {
+assert_ready_eq_as_result in lib - Rust
Macro lib::assert_ready_eq_as_result
source · 
macro_rules! assert_ready_eq_as_result {
     ($a:expr, $b:expr $(,)?) => { ... };
 }
Expand description
Assert two expressions are Ready(_) and their values are equal.

 
Pseudocode:

diff --git a/doc/lib/macro.assert_ready_eq_expr.html b/doc/lib/macro.assert_ready_eq_expr.html
index 59c8fd765..affde06fb 100644
--- a/doc/lib/macro.assert_ready_eq_expr.html
+++ b/doc/lib/macro.assert_ready_eq_expr.html
@@ -1,4 +1,4 @@
-assert_ready_eq_expr in lib - Rust
Macro lib::assert_ready_eq_expr
source · 
macro_rules! assert_ready_eq_expr {
+assert_ready_eq_expr in lib - Rust
Macro lib::assert_ready_eq_expr
source · 
macro_rules! assert_ready_eq_expr {
     ($a:expr, $b:expr $(,)?) => { ... };
     ($a:expr, $b:expr, $($message:tt)+) => { ... };
 }
Expand description
Assert an expression is Ready(_) and its value is equal to an expression.

diff --git a/doc/lib/macro.assert_ready_eq_expr_as_result.html b/doc/lib/macro.assert_ready_eq_expr_as_result.html
index 5484ea6b2..c6c5ea474 100644
--- a/doc/lib/macro.assert_ready_eq_expr_as_result.html
+++ b/doc/lib/macro.assert_ready_eq_expr_as_result.html
@@ -1,4 +1,4 @@
-assert_ready_eq_expr_as_result in lib - Rust
Macro lib::assert_ready_eq_expr_as_result
source · 
macro_rules! assert_ready_eq_expr_as_result {
+assert_ready_eq_expr_as_result in lib - Rust
Macro lib::assert_ready_eq_expr_as_result
source · 
macro_rules! assert_ready_eq_expr_as_result {
     ($a:expr, $b:expr $(,)?) => { ... };
 }
Expand description
Assert an expression is Ready(_) and its value is equal to an expression.

 
Pseudocode:

diff --git a/doc/lib/macro.assert_ready_ne.html b/doc/lib/macro.assert_ready_ne.html
index 9016948d3..ba55423bc 100644
--- a/doc/lib/macro.assert_ready_ne.html
+++ b/doc/lib/macro.assert_ready_ne.html
@@ -1,4 +1,4 @@
-assert_ready_ne in lib - Rust
Macro lib::assert_ready_ne
source · 
macro_rules! assert_ready_ne {
+assert_ready_ne in lib - Rust
Macro lib::assert_ready_ne
source · 
macro_rules! assert_ready_ne {
     ($a:expr, $b:expr $(,)?) => { ... };
     ($a:expr, $b:expr, $($message:tt)+) => { ... };
 }
Expand description
Assert two expressions are Ready(_) and their values are not equal.

diff --git a/doc/lib/macro.assert_ready_ne_as_result.html b/doc/lib/macro.assert_ready_ne_as_result.html
index 9383d2d50..c965ae1a1 100644
--- a/doc/lib/macro.assert_ready_ne_as_result.html
+++ b/doc/lib/macro.assert_ready_ne_as_result.html
@@ -1,4 +1,4 @@
-assert_ready_ne_as_result in lib - Rust
Macro lib::assert_ready_ne_as_result
source · 
macro_rules! assert_ready_ne_as_result {
+assert_ready_ne_as_result in lib - Rust
Macro lib::assert_ready_ne_as_result
source · 
macro_rules! assert_ready_ne_as_result {
     ($a:expr, $b:expr $(,)?) => { ... };
 }
Expand description
Assert two expressions are Ready(_) and their values are not equal.

 
Pseudocode:

diff --git a/doc/lib/macro.assert_ready_ne_expr.html b/doc/lib/macro.assert_ready_ne_expr.html
index f87034ec5..13fec321a 100644
--- a/doc/lib/macro.assert_ready_ne_expr.html
+++ b/doc/lib/macro.assert_ready_ne_expr.html
@@ -1,4 +1,4 @@
-assert_ready_ne_expr in lib - Rust
Macro lib::assert_ready_ne_expr
source · 
macro_rules! assert_ready_ne_expr {
+assert_ready_ne_expr in lib - Rust
Macro lib::assert_ready_ne_expr
source · 
macro_rules! assert_ready_ne_expr {
     ($a:expr, $b:expr $(,)?) => { ... };
     ($a:expr, $b:expr, $($message:tt)+) => { ... };
 }
Expand description
Assert an expression is Ready(_) and its value is not equal to an expression.

diff --git a/doc/lib/macro.assert_ready_ne_expr_as_result.html b/doc/lib/macro.assert_ready_ne_expr_as_result.html
index 04d8cbfae..540879fa4 100644
--- a/doc/lib/macro.assert_ready_ne_expr_as_result.html
+++ b/doc/lib/macro.assert_ready_ne_expr_as_result.html
@@ -1,4 +1,4 @@
-assert_ready_ne_expr_as_result in lib - Rust
Macro lib::assert_ready_ne_expr_as_result
source · 
macro_rules! assert_ready_ne_expr_as_result {
+assert_ready_ne_expr_as_result in lib - Rust
Macro lib::assert_ready_ne_expr_as_result
source · 
macro_rules! assert_ready_ne_expr_as_result {
     ($a:expr, $b:expr $(,)?) => { ... };
 }
Expand description
Assert an expression is Ready(_) and its value is not equal to an expression.

 
Pseudocode:

diff --git a/doc/lib/macro.assert_some.html b/doc/lib/macro.assert_some.html
index 61f716fc2..54ae6e079 100644
--- a/doc/lib/macro.assert_some.html
+++ b/doc/lib/macro.assert_some.html
@@ -1,4 +1,4 @@
-assert_some in lib - Rust
Macro lib::assert_some
source · 
macro_rules! assert_some {
+assert_some in lib - Rust
Macro lib::assert_some
source · 
macro_rules! assert_some {
     ($a:expr $(,)?) => { ... };
     ($a:expr, $($message:tt)+) => { ... };
 }
Expand description
Assert expression is Some(_).

diff --git a/doc/lib/macro.assert_some_as_result.html b/doc/lib/macro.assert_some_as_result.html
index 5a541d50c..0d9a3991d 100644
--- a/doc/lib/macro.assert_some_as_result.html
+++ b/doc/lib/macro.assert_some_as_result.html
@@ -1,4 +1,4 @@
-assert_some_as_result in lib - Rust
Macro lib::assert_some_as_result
source · 
macro_rules! assert_some_as_result {
+assert_some_as_result in lib - Rust
Macro lib::assert_some_as_result
source · 
macro_rules! assert_some_as_result {
     ($a:expr $(,)?) => { ... };
 }
Expand description
Assert an expression.is_some() is true.

 
Pseudocode:

diff --git a/doc/lib/macro.assert_some_eq.html b/doc/lib/macro.assert_some_eq.html
index a3781de80..b11961974 100644
--- a/doc/lib/macro.assert_some_eq.html
+++ b/doc/lib/macro.assert_some_eq.html
@@ -1,4 +1,4 @@
-assert_some_eq in lib - Rust
Macro lib::assert_some_eq
source · 
macro_rules! assert_some_eq {
+assert_some_eq in lib - Rust
Macro lib::assert_some_eq
source · 
macro_rules! assert_some_eq {
     ($a:expr, $b:expr $(,)?) => { ... };
     ($a:expr, $b:expr, $($message:tt)+) => { ... };
 }
Expand description
Assert two expressions are Some(_) and their values are equal.

diff --git a/doc/lib/macro.assert_some_eq_as_result.html b/doc/lib/macro.assert_some_eq_as_result.html
index ea7760930..702096797 100644
--- a/doc/lib/macro.assert_some_eq_as_result.html
+++ b/doc/lib/macro.assert_some_eq_as_result.html
@@ -1,4 +1,4 @@
-assert_some_eq_as_result in lib - Rust
Macro lib::assert_some_eq_as_result
source · 
macro_rules! assert_some_eq_as_result {
+assert_some_eq_as_result in lib - Rust
Macro lib::assert_some_eq_as_result
source · 
macro_rules! assert_some_eq_as_result {
     ($a:expr, $b:expr $(,)?) => { ... };
 }
Expand description
Assert a.is_some() and a.unwrap() are equal to another.

 
Pseudocode:

diff --git a/doc/lib/macro.assert_some_eq_expr.html b/doc/lib/macro.assert_some_eq_expr.html
index 8320dbd2c..23faac119 100644
--- a/doc/lib/macro.assert_some_eq_expr.html
+++ b/doc/lib/macro.assert_some_eq_expr.html
@@ -1,4 +1,4 @@
-assert_some_eq_expr in lib - Rust
Macro lib::assert_some_eq_expr
source · 
macro_rules! assert_some_eq_expr {
+assert_some_eq_expr in lib - Rust
Macro lib::assert_some_eq_expr
source · 
macro_rules! assert_some_eq_expr {
     ($a:expr, $b:expr $(,)?) => { ... };
     ($a:expr, $b:expr, $($message:tt)+) => { ... };
 }
Expand description
Assert an expression is Some(_) and its value is equal to an expression.

diff --git a/doc/lib/macro.assert_some_eq_expr_as_result.html b/doc/lib/macro.assert_some_eq_expr_as_result.html
index b4ebfc7b5..badb7a1a5 100644
--- a/doc/lib/macro.assert_some_eq_expr_as_result.html
+++ b/doc/lib/macro.assert_some_eq_expr_as_result.html
@@ -1,4 +1,4 @@
-assert_some_eq_expr_as_result in lib - Rust
Macro lib::assert_some_eq_expr_as_result
source · 
macro_rules! assert_some_eq_expr_as_result {
+assert_some_eq_expr_as_result in lib - Rust
Macro lib::assert_some_eq_expr_as_result
source · 
macro_rules! assert_some_eq_expr_as_result {
     ($a:expr, $b:expr $(,)?) => { ... };
 }
Expand description
Assert a.is_some() and a.unwrap() are equal to another.

 
Pseudocode:

diff --git a/doc/lib/macro.assert_some_ne.html b/doc/lib/macro.assert_some_ne.html
index 4e199d481..38c04b5ba 100644
--- a/doc/lib/macro.assert_some_ne.html
+++ b/doc/lib/macro.assert_some_ne.html
@@ -1,4 +1,4 @@
-assert_some_ne in lib - Rust
Macro lib::assert_some_ne
source · 
macro_rules! assert_some_ne {
+assert_some_ne in lib - Rust
Macro lib::assert_some_ne
source · 
macro_rules! assert_some_ne {
     ($a:expr, $b:expr $(,)?) => { ... };
     ($a:expr, $b:expr, $($message:tt)+) => { ... };
 }
Expand description
Assert two expressions are Some(_) and their values are not equal.

diff --git a/doc/lib/macro.assert_some_ne_as_result.html b/doc/lib/macro.assert_some_ne_as_result.html
index 2a02b7778..0ec56b4ea 100644
--- a/doc/lib/macro.assert_some_ne_as_result.html
+++ b/doc/lib/macro.assert_some_ne_as_result.html
@@ -1,4 +1,4 @@
-assert_some_ne_as_result in lib - Rust
Macro lib::assert_some_ne_as_result
source · 
macro_rules! assert_some_ne_as_result {
+assert_some_ne_as_result in lib - Rust
Macro lib::assert_some_ne_as_result
source · 
macro_rules! assert_some_ne_as_result {
     ($a:expr, $b:expr $(,)?) => { ... };
 }
Expand description
Assert two expressions are Some(_) and their values are not equal.

 
Pseudocode:

diff --git a/doc/lib/macro.assert_some_ne_expr.html b/doc/lib/macro.assert_some_ne_expr.html
index 0a22705a5..2aa3acf67 100644
--- a/doc/lib/macro.assert_some_ne_expr.html
+++ b/doc/lib/macro.assert_some_ne_expr.html
@@ -1,4 +1,4 @@
-assert_some_ne_expr in lib - Rust
Macro lib::assert_some_ne_expr
source · 
macro_rules! assert_some_ne_expr {
+assert_some_ne_expr in lib - Rust
Macro lib::assert_some_ne_expr
source · 
macro_rules! assert_some_ne_expr {
     ($a:expr, $b:expr $(,)?) => { ... };
     ($a:expr, $b:expr, $($message:tt)+) => { ... };
 }
Expand description
Assert an expression is Some(_) and its value is not equal to an expression.

diff --git a/doc/lib/macro.assert_some_ne_expr_as_result.html b/doc/lib/macro.assert_some_ne_expr_as_result.html
index 5b8889448..b9efc3d2b 100644
--- a/doc/lib/macro.assert_some_ne_expr_as_result.html
+++ b/doc/lib/macro.assert_some_ne_expr_as_result.html
@@ -1,4 +1,4 @@
-assert_some_ne_expr_as_result in lib - Rust
Macro lib::assert_some_ne_expr_as_result
source · 
macro_rules! assert_some_ne_expr_as_result {
+assert_some_ne_expr_as_result in lib - Rust
Macro lib::assert_some_ne_expr_as_result
source · 
macro_rules! assert_some_ne_expr_as_result {
     ($a:expr, $b:expr $(,)?) => { ... };
 }
Expand description
Assert a.is_some() and a.unwrap() are equal to another.

 
Pseudocode:

diff --git a/doc/lib/macro.debug_assert_err.html b/doc/lib/macro.debug_assert_err.html
index b30323b4b..bc4dfd880 100644
--- a/doc/lib/macro.debug_assert_err.html
+++ b/doc/lib/macro.debug_assert_err.html
@@ -1,4 +1,4 @@
-debug_assert_err in lib - Rust
Macro lib::debug_assert_err
source · 
macro_rules! debug_assert_err {
+debug_assert_err in lib - Rust
Macro lib::debug_assert_err
source · 
macro_rules! debug_assert_err {
     ($($arg:tt)*) => { ... };
 }
Expand description
Assert expression is Err(_).

 
Pseudocode:

diff --git a/doc/lib/macro.debug_assert_err_eq.html b/doc/lib/macro.debug_assert_err_eq.html
index 07d5bd637..7574d027a 100644
--- a/doc/lib/macro.debug_assert_err_eq.html
+++ b/doc/lib/macro.debug_assert_err_eq.html
@@ -1,4 +1,4 @@
-debug_assert_err_eq in lib - Rust
Macro lib::debug_assert_err_eq
source · 
macro_rules! debug_assert_err_eq {
+debug_assert_err_eq in lib - Rust
Macro lib::debug_assert_err_eq
source · 
macro_rules! debug_assert_err_eq {
     ($($arg:tt)*) => { ... };
 }
Expand description
Assert two expressions are Err(_) and their values are equal.

 
Pseudocode:

diff --git a/doc/lib/macro.debug_assert_err_eq_expr.html b/doc/lib/macro.debug_assert_err_eq_expr.html
index 542e88102..9711a945e 100644
--- a/doc/lib/macro.debug_assert_err_eq_expr.html
+++ b/doc/lib/macro.debug_assert_err_eq_expr.html
@@ -1,4 +1,4 @@
-debug_assert_err_eq_expr in lib - Rust
Macro lib::debug_assert_err_eq_expr
source · 
macro_rules! debug_assert_err_eq_expr {
+debug_assert_err_eq_expr in lib - Rust
Macro lib::debug_assert_err_eq_expr
source · 
macro_rules! debug_assert_err_eq_expr {
     ($($arg:tt)*) => { ... };
 }
Expand description
Assert an expression is Err(_) and its value is equal to an expression.

 
Pseudocode:

diff --git a/doc/lib/macro.debug_assert_err_ne.html b/doc/lib/macro.debug_assert_err_ne.html
index 1dccbec66..be2237465 100644
--- a/doc/lib/macro.debug_assert_err_ne.html
+++ b/doc/lib/macro.debug_assert_err_ne.html
@@ -1,4 +1,4 @@
-debug_assert_err_ne in lib - Rust
Macro lib::debug_assert_err_ne
source · 
macro_rules! debug_assert_err_ne {
+debug_assert_err_ne in lib - Rust
Macro lib::debug_assert_err_ne
source · 
macro_rules! debug_assert_err_ne {
     ($($arg:tt)*) => { ... };
 }
Expand description
Assert two expressions are Err(_) and their values are not equal.

 
This macro provides the same statements as assert_err_ne,
diff --git a/doc/lib/macro.debug_assert_err_ne_expr.html b/doc/lib/macro.debug_assert_err_ne_expr.html
index aa7eb8fee..b68ba92b9 100644
--- a/doc/lib/macro.debug_assert_err_ne_expr.html
+++ b/doc/lib/macro.debug_assert_err_ne_expr.html
@@ -1,4 +1,4 @@
-debug_assert_err_ne_expr in lib - Rust
Macro lib::debug_assert_err_ne_expr
source · 
macro_rules! debug_assert_err_ne_expr {
+debug_assert_err_ne_expr in lib - Rust
Macro lib::debug_assert_err_ne_expr
source · 
macro_rules! debug_assert_err_ne_expr {
     ($($arg:tt)*) => { ... };
 }
Expand description
Assert an expression is Err(_) and its value is equal to an expression.

 
Pseudocode:

diff --git a/doc/lib/macro.debug_assert_none.html b/doc/lib/macro.debug_assert_none.html
index 73b74d307..7c0a39161 100644
--- a/doc/lib/macro.debug_assert_none.html
+++ b/doc/lib/macro.debug_assert_none.html
@@ -1,4 +1,4 @@
-debug_assert_none in lib - Rust
Macro lib::debug_assert_none
source · 
macro_rules! debug_assert_none {
+debug_assert_none in lib - Rust
Macro lib::debug_assert_none
source · 
macro_rules! debug_assert_none {
     ($($arg:tt)*) => { ... };
 }
Expand description
Assert expression is None.

 
Pseudocode:

diff --git a/doc/lib/macro.debug_assert_ok.html b/doc/lib/macro.debug_assert_ok.html
index 40a64c63c..47b2059f9 100644
--- a/doc/lib/macro.debug_assert_ok.html
+++ b/doc/lib/macro.debug_assert_ok.html
@@ -1,4 +1,4 @@
-debug_assert_ok in lib - Rust
Macro lib::debug_assert_ok
source · 
macro_rules! debug_assert_ok {
+debug_assert_ok in lib - Rust
Macro lib::debug_assert_ok
source · 
macro_rules! debug_assert_ok {
     ($($arg:tt)*) => { ... };
 }
Expand description
Assert expression is Ok(_).

 
Pseudocode:

diff --git a/doc/lib/macro.debug_assert_ok_eq.html b/doc/lib/macro.debug_assert_ok_eq.html
index 7a6057387..71a96b6bf 100644
--- a/doc/lib/macro.debug_assert_ok_eq.html
+++ b/doc/lib/macro.debug_assert_ok_eq.html
@@ -1,4 +1,4 @@
-debug_assert_ok_eq in lib - Rust
Macro lib::debug_assert_ok_eq
source · 
macro_rules! debug_assert_ok_eq {
+debug_assert_ok_eq in lib - Rust
Macro lib::debug_assert_ok_eq
source · 
macro_rules! debug_assert_ok_eq {
     ($($arg:tt)*) => { ... };
 }
Expand description
Assert two expressions are Ok(_) and their values are equal.

 
Pseudocode:

diff --git a/doc/lib/macro.debug_assert_ok_eq_expr.html b/doc/lib/macro.debug_assert_ok_eq_expr.html
index cc694c1b3..79d0c626c 100644
--- a/doc/lib/macro.debug_assert_ok_eq_expr.html
+++ b/doc/lib/macro.debug_assert_ok_eq_expr.html
@@ -1,4 +1,4 @@
-debug_assert_ok_eq_expr in lib - Rust
Macro lib::debug_assert_ok_eq_expr
source · 
macro_rules! debug_assert_ok_eq_expr {
+debug_assert_ok_eq_expr in lib - Rust
Macro lib::debug_assert_ok_eq_expr
source · 
macro_rules! debug_assert_ok_eq_expr {
     ($($arg:tt)*) => { ... };
 }
Expand description
Assert an expression is Ok(_) and its value is equal to an expression.

 
Pseudocode:

diff --git a/doc/lib/macro.debug_assert_ok_ne.html b/doc/lib/macro.debug_assert_ok_ne.html
index 9eb082438..5024302b2 100644
--- a/doc/lib/macro.debug_assert_ok_ne.html
+++ b/doc/lib/macro.debug_assert_ok_ne.html
@@ -1,4 +1,4 @@
-debug_assert_ok_ne in lib - Rust
Macro lib::debug_assert_ok_ne
source · 
macro_rules! debug_assert_ok_ne {
+debug_assert_ok_ne in lib - Rust
Macro lib::debug_assert_ok_ne
source · 
macro_rules! debug_assert_ok_ne {
     ($($arg:tt)*) => { ... };
 }
Expand description
Assert two expressions are Ok(_) and their values are not equal.

 
This macro provides the same statements as assert_ok_ne,
diff --git a/doc/lib/macro.debug_assert_ok_ne_expr.html b/doc/lib/macro.debug_assert_ok_ne_expr.html
index 2cd202731..b229e5ed4 100644
--- a/doc/lib/macro.debug_assert_ok_ne_expr.html
+++ b/doc/lib/macro.debug_assert_ok_ne_expr.html
@@ -1,4 +1,4 @@
-debug_assert_ok_ne_expr in lib - Rust
Macro lib::debug_assert_ok_ne_expr
source · 
macro_rules! debug_assert_ok_ne_expr {
+debug_assert_ok_ne_expr in lib - Rust
Macro lib::debug_assert_ok_ne_expr
source · 
macro_rules! debug_assert_ok_ne_expr {
     ($($arg:tt)*) => { ... };
 }
Expand description
Assert an expression is Ok(_) and its value is equal to an expression.

 
Pseudocode:

diff --git a/doc/lib/macro.debug_assert_pending.html b/doc/lib/macro.debug_assert_pending.html
index ae577a2c5..27ba07009 100644
--- a/doc/lib/macro.debug_assert_pending.html
+++ b/doc/lib/macro.debug_assert_pending.html
@@ -1,4 +1,4 @@
-debug_assert_pending in lib - Rust
Macro lib::debug_assert_pending
source · 
macro_rules! debug_assert_pending {
+debug_assert_pending in lib - Rust
Macro lib::debug_assert_pending
source · 
macro_rules! debug_assert_pending {
     ($($arg:tt)*) => { ... };
 }
Expand description
Assert an expression is Pending.

 
Pseudocode:

diff --git a/doc/lib/macro.debug_assert_ready.html b/doc/lib/macro.debug_assert_ready.html
index f9e2516eb..b7f839754 100644
--- a/doc/lib/macro.debug_assert_ready.html
+++ b/doc/lib/macro.debug_assert_ready.html
@@ -1,4 +1,4 @@
-debug_assert_ready in lib - Rust
Macro lib::debug_assert_ready
source · 
macro_rules! debug_assert_ready {
+debug_assert_ready in lib - Rust
Macro lib::debug_assert_ready
source · 
macro_rules! debug_assert_ready {
     ($($arg:tt)*) => { ... };
 }
Expand description
Assert poll.is_ready() is true.

 
Pseudocode:

diff --git a/doc/lib/macro.debug_assert_ready_eq.html b/doc/lib/macro.debug_assert_ready_eq.html
index 1692e0da7..88d8f48ef 100644
--- a/doc/lib/macro.debug_assert_ready_eq.html
+++ b/doc/lib/macro.debug_assert_ready_eq.html
@@ -1,4 +1,4 @@
-debug_assert_ready_eq in lib - Rust
Macro lib::debug_assert_ready_eq
source · 
macro_rules! debug_assert_ready_eq {
+debug_assert_ready_eq in lib - Rust
Macro lib::debug_assert_ready_eq
source · 
macro_rules! debug_assert_ready_eq {
     ($($arg:tt)*) => { ... };
 }
Expand description
Assert two expressions are Ready(_) and their values are equal.

 
Pseudocode:

diff --git a/doc/lib/macro.debug_assert_ready_eq_expr.html b/doc/lib/macro.debug_assert_ready_eq_expr.html
index d7cb0e31c..9dc22df0d 100644
--- a/doc/lib/macro.debug_assert_ready_eq_expr.html
+++ b/doc/lib/macro.debug_assert_ready_eq_expr.html
@@ -1,4 +1,4 @@
-debug_assert_ready_eq_expr in lib - Rust
Macro lib::debug_assert_ready_eq_expr
source · 
macro_rules! debug_assert_ready_eq_expr {
+debug_assert_ready_eq_expr in lib - Rust
Macro lib::debug_assert_ready_eq_expr
source · 
macro_rules! debug_assert_ready_eq_expr {
     ($($arg:tt)*) => { ... };
 }
Expand description
Assert an expression is Ready(_) and its value is equal to an expression.

 
Pseudocode:

diff --git a/doc/lib/macro.debug_assert_ready_ne.html b/doc/lib/macro.debug_assert_ready_ne.html
index 7b80bc4e5..fd6caf0e4 100644
--- a/doc/lib/macro.debug_assert_ready_ne.html
+++ b/doc/lib/macro.debug_assert_ready_ne.html
@@ -1,4 +1,4 @@
-debug_assert_ready_ne in lib - Rust
Macro lib::debug_assert_ready_ne
source · 
macro_rules! debug_assert_ready_ne {
+debug_assert_ready_ne in lib - Rust
Macro lib::debug_assert_ready_ne
source · 
macro_rules! debug_assert_ready_ne {
     ($($arg:tt)*) => { ... };
 }
Expand description
Assert two expressions are Ready(_) and their values are not equal.

 
Pseudocode:

diff --git a/doc/lib/macro.debug_assert_ready_ne_expr.html b/doc/lib/macro.debug_assert_ready_ne_expr.html
index 86798cf8c..d601dac47 100644
--- a/doc/lib/macro.debug_assert_ready_ne_expr.html
+++ b/doc/lib/macro.debug_assert_ready_ne_expr.html
@@ -1,4 +1,4 @@
-debug_assert_ready_ne_expr in lib - Rust
Macro lib::debug_assert_ready_ne_expr
source · 
macro_rules! debug_assert_ready_ne_expr {
+debug_assert_ready_ne_expr in lib - Rust
Macro lib::debug_assert_ready_ne_expr
source · 
macro_rules! debug_assert_ready_ne_expr {
     ($($arg:tt)*) => { ... };
 }
Expand description
Assert an expression is Ready(_) and its value is not equal to an expression.

 
Pseudocode:

diff --git a/doc/lib/macro.debug_assert_some.html b/doc/lib/macro.debug_assert_some.html
index 0c7a8998d..46876b1e1 100644
--- a/doc/lib/macro.debug_assert_some.html
+++ b/doc/lib/macro.debug_assert_some.html
@@ -1,4 +1,4 @@
-debug_assert_some in lib - Rust
Macro lib::debug_assert_some
source · 
macro_rules! debug_assert_some {
+debug_assert_some in lib - Rust
Macro lib::debug_assert_some
source · 
macro_rules! debug_assert_some {
     ($($arg:tt)*) => { ... };
 }
Expand description
Assert expression is Some(_).

 
Pseudocode:

diff --git a/doc/lib/macro.debug_assert_some_eq.html b/doc/lib/macro.debug_assert_some_eq.html
index 04ce2c701..f41800c36 100644
--- a/doc/lib/macro.debug_assert_some_eq.html
+++ b/doc/lib/macro.debug_assert_some_eq.html
@@ -1,4 +1,4 @@
-debug_assert_some_eq in lib - Rust
Macro lib::debug_assert_some_eq
source · 
macro_rules! debug_assert_some_eq {
+debug_assert_some_eq in lib - Rust
Macro lib::debug_assert_some_eq
source · 
macro_rules! debug_assert_some_eq {
     ($($arg:tt)*) => { ... };
 }
Expand description
Assert two expressions are Some(_) and their values are equal.

 
Pseudocode:

diff --git a/doc/lib/macro.debug_assert_some_eq_expr.html b/doc/lib/macro.debug_assert_some_eq_expr.html
index 159599e3d..85e537177 100644
--- a/doc/lib/macro.debug_assert_some_eq_expr.html
+++ b/doc/lib/macro.debug_assert_some_eq_expr.html
@@ -1,4 +1,4 @@
-debug_assert_some_eq_expr in lib - Rust
Macro lib::debug_assert_some_eq_expr
source · 
macro_rules! debug_assert_some_eq_expr {
+debug_assert_some_eq_expr in lib - Rust
Macro lib::debug_assert_some_eq_expr
source · 
macro_rules! debug_assert_some_eq_expr {
     ($($arg:tt)*) => { ... };
 }
Expand description
Assert an expression is Some(_) and its value is equal to an expression.

 
Pseudocode:

diff --git a/doc/lib/macro.debug_assert_some_ne.html b/doc/lib/macro.debug_assert_some_ne.html
index 94fb035a8..87ae31d0b 100644
--- a/doc/lib/macro.debug_assert_some_ne.html
+++ b/doc/lib/macro.debug_assert_some_ne.html
@@ -1,4 +1,4 @@
-debug_assert_some_ne in lib - Rust
Macro lib::debug_assert_some_ne
source · 
macro_rules! debug_assert_some_ne {
+debug_assert_some_ne in lib - Rust
Macro lib::debug_assert_some_ne
source · 
macro_rules! debug_assert_some_ne {
     ($($arg:tt)*) => { ... };
 }
Expand description
Assert two expressions are Some(_) and their values are not equal.

 
Pseudocode:

diff --git a/doc/lib/macro.debug_assert_some_ne_expr.html b/doc/lib/macro.debug_assert_some_ne_expr.html
index 58209de0e..c5812e52a 100644
--- a/doc/lib/macro.debug_assert_some_ne_expr.html
+++ b/doc/lib/macro.debug_assert_some_ne_expr.html
@@ -1,4 +1,4 @@
-debug_assert_some_ne_expr in lib - Rust
Macro lib::debug_assert_some_ne_expr
source · 
macro_rules! debug_assert_some_ne_expr {
+debug_assert_some_ne_expr in lib - Rust
Macro lib::debug_assert_some_ne_expr
source · 
macro_rules! debug_assert_some_ne_expr {
     ($($arg:tt)*) => { ... };
 }
Expand description
Assert an expression is Some(_) and its value is not equal to an expression.

 
Pseudocode:

diff --git a/doc/lib/sidebar-items.js b/doc/lib/sidebar-items.js
index a638fc042..12f59a2e3 100644
--- a/doc/lib/sidebar-items.js
+++ b/doc/lib/sidebar-items.js
@@ -1 +1 @@
-window.SIDEBAR_ITEMS = {"macro":["assert_approx_eq","assert_approx_eq_as_result","assert_approx_ne","assert_approx_ne_as_result","assert_as_result","assert_bag_eq","assert_bag_eq_as_result","assert_bag_impl_prep","assert_bag_ne","assert_bag_ne_as_result","assert_bag_subbag","assert_bag_subbag_as_result","assert_bag_superbag","assert_bag_superbag_as_result","assert_command_stderr_contains","assert_command_stderr_contains_as_result","assert_command_stderr_eq","assert_command_stderr_eq_as_result","assert_command_stderr_eq_expr","assert_command_stderr_eq_expr_as_result","assert_command_stderr_is_match","assert_command_stderr_is_match_as_result","assert_command_stdout_contains","assert_command_stdout_contains_as_result","assert_command_stdout_eq","assert_command_stdout_eq_as_result","assert_command_stdout_eq_expr","assert_command_stdout_eq_expr_as_result","assert_command_stdout_is_match","assert_command_stdout_is_match_as_result","assert_contains","assert_contains_as_result","assert_ends_with","assert_ends_with_as_result","assert_eq_as_result","assert_err","assert_err_as_result","assert_err_eq","assert_err_eq_as_result","assert_err_eq_expr","assert_err_eq_expr_as_result","assert_err_ne","assert_err_ne_as_result","assert_err_ne_expr","assert_err_ne_expr_as_result","assert_fn_eq","assert_fn_eq_as_result","assert_fn_eq_expr","assert_fn_eq_expr_as_result","assert_fn_err_eq","assert_fn_err_eq_as_result","assert_fn_err_eq_expr","assert_fn_err_eq_expr_as_result","assert_fn_err_ge","assert_fn_err_ge_as_result","assert_fn_err_ge_expr","assert_fn_err_ge_expr_as_result","assert_fn_err_gt","assert_fn_err_gt_as_result","assert_fn_err_gt_expr","assert_fn_err_gt_expr_as_result","assert_fn_err_le","assert_fn_err_le_as_result","assert_fn_err_le_expr","assert_fn_err_le_expr_as_result","assert_fn_err_lt","assert_fn_err_lt_as_result","assert_fn_err_lt_expr","assert_fn_err_lt_expr_as_result","assert_fn_err_ne","assert_fn_err_ne_as_result","assert_fn_err_ne_expr","assert_fn_err_ne_expr_as_result","assert_fn_ge","assert_fn_ge_as_result","assert_fn_ge_expr","assert_fn_ge_expr_as_result","assert_fn_gt","assert_fn_gt_as_result","assert_fn_gt_expr","assert_fn_gt_expr_as_result","assert_fn_le","assert_fn_le_as_result","assert_fn_le_expr","assert_fn_le_expr_as_result","assert_fn_lt","assert_fn_lt_as_result","assert_fn_lt_expr","assert_fn_lt_expr_as_result","assert_fn_ne","assert_fn_ne_as_result","assert_fn_ne_expr","assert_fn_ne_expr_as_result","assert_fn_ok_eq","assert_fn_ok_eq_as_result","assert_fn_ok_eq_expr","assert_fn_ok_eq_expr_as_result","assert_fn_ok_ge","assert_fn_ok_ge_as_result","assert_fn_ok_ge_expr","assert_fn_ok_ge_expr_as_result","assert_fn_ok_gt","assert_fn_ok_gt_as_result","assert_fn_ok_gt_expr","assert_fn_ok_gt_expr_as_result","assert_fn_ok_le","assert_fn_ok_le_as_result","assert_fn_ok_le_expr","assert_fn_ok_le_expr_as_result","assert_fn_ok_lt","assert_fn_ok_lt_as_result","assert_fn_ok_lt_expr","assert_fn_ok_lt_expr_as_result","assert_fn_ok_ne","assert_fn_ok_ne_as_result","assert_fn_ok_ne_expr","assert_fn_ok_ne_expr_as_result","assert_fs_read_to_string_contains","assert_fs_read_to_string_contains_as_result","assert_fs_read_to_string_eq","assert_fs_read_to_string_eq_as_result","assert_fs_read_to_string_eq_expr","assert_fs_read_to_string_eq_expr_as_result","assert_fs_read_to_string_ge","assert_fs_read_to_string_ge_as_result","assert_fs_read_to_string_ge_expr","assert_fs_read_to_string_ge_expr_as_result","assert_fs_read_to_string_gt","assert_fs_read_to_string_gt_as_result","assert_fs_read_to_string_gt_expr","assert_fs_read_to_string_gt_expr_as_result","assert_fs_read_to_string_le","assert_fs_read_to_string_le_as_result","assert_fs_read_to_string_le_expr","assert_fs_read_to_string_le_expr_as_result","assert_fs_read_to_string_lt","assert_fs_read_to_string_lt_as_result","assert_fs_read_to_string_lt_expr","assert_fs_read_to_string_lt_expr_as_result","assert_fs_read_to_string_matches","assert_fs_read_to_string_matches_as_result","assert_fs_read_to_string_ne","assert_fs_read_to_string_ne_as_result","assert_fs_read_to_string_ne_expr","assert_fs_read_to_string_ne_expr_as_result","assert_ge","assert_ge_as_result","assert_gt","assert_gt_as_result","assert_in_delta","assert_in_delta_as_result","assert_in_epsilon","assert_in_epsilon_as_result","assert_infix","assert_infix_as_result","assert_io_read_to_string_contains","assert_io_read_to_string_contains_as_result","assert_io_read_to_string_eq","assert_io_read_to_string_eq_as_result","assert_io_read_to_string_eq_expr","assert_io_read_to_string_eq_expr_as_result","assert_io_read_to_string_ge","assert_io_read_to_string_ge_as_result","assert_io_read_to_string_ge_expr","assert_io_read_to_string_ge_expr_as_result","assert_io_read_to_string_gt","assert_io_read_to_string_gt_as_result","assert_io_read_to_string_gt_expr","assert_io_read_to_string_gt_expr_as_result","assert_io_read_to_string_le","assert_io_read_to_string_le_as_result","assert_io_read_to_string_le_expr","assert_io_read_to_string_le_expr_as_result","assert_io_read_to_string_lt","assert_io_read_to_string_lt_as_result","assert_io_read_to_string_lt_expr","assert_io_read_to_string_lt_expr_as_result","assert_io_read_to_string_matches","assert_io_read_to_string_matches_as_result","assert_io_read_to_string_ne","assert_io_read_to_string_ne_as_result","assert_io_read_to_string_ne_expr","assert_io_read_to_string_ne_expr_as_result","assert_is_match","assert_is_match_as_result","assert_le","assert_le_as_result","assert_lt","assert_lt_as_result","assert_ne_as_result","assert_none","assert_none_as_result","assert_not_contains","assert_not_contains_as_result","assert_not_ends_with","assert_not_ends_with_as_result","assert_not_match","assert_not_match_as_result","assert_not_starts_with","assert_not_starts_with_as_result","assert_ok","assert_ok_as_result","assert_ok_eq","assert_ok_eq_as_result","assert_ok_eq_expr","assert_ok_eq_expr_as_result","assert_ok_ne","assert_ok_ne_as_result","assert_ok_ne_expr","assert_ok_ne_expr_as_result","assert_option_none","assert_option_none_as_result","assert_option_some","assert_option_some_as_result","assert_option_some_eq","assert_option_some_eq_as_result","assert_option_some_ne","assert_option_some_ne_as_result","assert_pending","assert_pending_as_result","assert_poll_pending","assert_poll_pending_as_result","assert_poll_ready","assert_poll_ready_as_result","assert_poll_ready_eq","assert_poll_ready_eq_as_result","assert_poll_ready_ne","assert_poll_ready_ne_as_result","assert_program_args_impl_prep","assert_program_args_stderr_contains","assert_program_args_stderr_contains_as_result","assert_program_args_stderr_eq","assert_program_args_stderr_eq_as_result","assert_program_args_stderr_eq_expr","assert_program_args_stderr_eq_expr_as_result","assert_program_args_stderr_ge","assert_program_args_stderr_ge_as_result","assert_program_args_stderr_ge_expr","assert_program_args_stderr_ge_expr_as_result","assert_program_args_stderr_gt","assert_program_args_stderr_gt_as_result","assert_program_args_stderr_gt_expr","assert_program_args_stderr_gt_expr_as_result","assert_program_args_stderr_is_match","assert_program_args_stderr_is_match_as_result","assert_program_args_stderr_le","assert_program_args_stderr_le_as_result","assert_program_args_stderr_le_expr","assert_program_args_stderr_le_expr_as_result","assert_program_args_stderr_lt","assert_program_args_stderr_lt_as_result","assert_program_args_stderr_lt_expr","assert_program_args_stderr_lt_expr_as_result","assert_program_args_stderr_ne","assert_program_args_stderr_ne_as_result","assert_program_args_stderr_ne_expr","assert_program_args_stderr_ne_expr_as_result","assert_program_args_stdout_contains","assert_program_args_stdout_contains_as_result","assert_program_args_stdout_eq","assert_program_args_stdout_eq_as_result","assert_program_args_stdout_eq_expr","assert_program_args_stdout_eq_expr_as_result","assert_program_args_stdout_ge","assert_program_args_stdout_ge_as_result","assert_program_args_stdout_ge_expr","assert_program_args_stdout_ge_expr_as_result","assert_program_args_stdout_gt","assert_program_args_stdout_gt_as_result","assert_program_args_stdout_gt_expr","assert_program_args_stdout_gt_expr_as_result","assert_program_args_stdout_is_match","assert_program_args_stdout_is_match_as_result","assert_program_args_stdout_le","assert_program_args_stdout_le_as_result","assert_program_args_stdout_le_expr","assert_program_args_stdout_le_expr_as_result","assert_program_args_stdout_lt","assert_program_args_stdout_lt_as_result","assert_program_args_stdout_lt_expr","assert_program_args_stdout_lt_expr_as_result","assert_program_args_stdout_ne","assert_program_args_stdout_ne_as_result","assert_program_args_stdout_ne_expr","assert_program_args_stdout_ne_expr_as_result","assert_ready","assert_ready_as_result","assert_ready_eq","assert_ready_eq_as_result","assert_ready_eq_expr","assert_ready_eq_expr_as_result","assert_ready_ne","assert_ready_ne_as_result","assert_ready_ne_expr","assert_ready_ne_expr_as_result","assert_result_err","assert_result_err_as_result","assert_result_ok","assert_result_ok_as_result","assert_result_ok_eq","assert_result_ok_eq_as_result","assert_result_ok_ne","assert_result_ok_ne_as_result","assert_set_disjoint","assert_set_disjoint_as_result","assert_set_eq","assert_set_eq_as_result","assert_set_impl_prep","assert_set_joint","assert_set_joint_as_result","assert_set_ne","assert_set_ne_as_result","assert_set_subset","assert_set_subset_as_result","assert_set_superset","assert_set_superset_as_result","assert_some","assert_some_as_result","assert_some_eq","assert_some_eq_as_result","assert_some_eq_expr","assert_some_eq_expr_as_result","assert_some_ne","assert_some_ne_as_result","assert_some_ne_expr","assert_some_ne_expr_as_result","assert_starts_with","assert_starts_with_as_result","debug_assert_approx_eq","debug_assert_approx_ne","debug_assert_bag_eq","debug_assert_bag_ne","debug_assert_bag_subbag","debug_assert_bag_superbag","debug_assert_command_stderr_contains","debug_assert_command_stderr_eq","debug_assert_command_stderr_eq_expr","debug_assert_command_stderr_is_match","debug_assert_command_stdout_contains","debug_assert_command_stdout_eq","debug_assert_command_stdout_eq_expr","debug_assert_command_stdout_is_match","debug_assert_contains","debug_assert_ends_with","debug_assert_err","debug_assert_err_eq","debug_assert_err_eq_expr","debug_assert_err_ne","debug_assert_err_ne_expr","debug_assert_fn_eq","debug_assert_fn_eq_expr","debug_assert_fn_err_eq","debug_assert_fn_err_eq_expr","debug_assert_fn_err_ge","debug_assert_fn_err_ge_expr","debug_assert_fn_err_gt","debug_assert_fn_err_gt_expr","debug_assert_fn_err_le","debug_assert_fn_err_le_expr","debug_assert_fn_err_lt","debug_assert_fn_err_lt_expr","debug_assert_fn_err_ne","debug_assert_fn_err_ne_expr","debug_assert_fn_ge","debug_assert_fn_ge_expr","debug_assert_fn_gt","debug_assert_fn_gt_expr","debug_assert_fn_le","debug_assert_fn_le_expr","debug_assert_fn_lt","debug_assert_fn_lt_expr","debug_assert_fn_ne","debug_assert_fn_ne_expr","debug_assert_fn_ok_eq","debug_assert_fn_ok_eq_expr","debug_assert_fn_ok_ge","debug_assert_fn_ok_ge_expr","debug_assert_fn_ok_gt","debug_assert_fn_ok_gt_expr","debug_assert_fn_ok_le","debug_assert_fn_ok_le_expr","debug_assert_fn_ok_lt","debug_assert_fn_ok_lt_expr","debug_assert_fn_ok_ne","debug_assert_fn_ok_ne_expr","debug_assert_fs_read_to_string_contains","debug_assert_fs_read_to_string_eq","debug_assert_fs_read_to_string_eq_expr","debug_assert_fs_read_to_string_ge","debug_assert_fs_read_to_string_ge_expr","debug_assert_fs_read_to_string_gt","debug_assert_fs_read_to_string_gt_expr","debug_assert_fs_read_to_string_le","debug_assert_fs_read_to_string_le_expr","debug_assert_fs_read_to_string_lt","debug_assert_fs_read_to_string_lt_expr","debug_assert_fs_read_to_string_matches","debug_assert_fs_read_to_string_ne","debug_assert_fs_read_to_string_ne_expr","debug_assert_ge","debug_assert_gt","debug_assert_in_delta","debug_assert_in_epsilon","debug_assert_infix","debug_assert_io_read_to_string_contains","debug_assert_io_read_to_string_eq","debug_assert_io_read_to_string_eq_expr","debug_assert_io_read_to_string_ge","debug_assert_io_read_to_string_ge_expr","debug_assert_io_read_to_string_gt","debug_assert_io_read_to_string_gt_expr","debug_assert_io_read_to_string_le","debug_assert_io_read_to_string_le_expr","debug_assert_io_read_to_string_lt","debug_assert_io_read_to_string_lt_expr","debug_assert_io_read_to_string_matches","debug_assert_io_read_to_string_ne","debug_assert_io_read_to_string_ne_expr","debug_assert_is_match","debug_assert_le","debug_assert_lt","debug_assert_none","debug_assert_not_contains","debug_assert_not_ends_with","debug_assert_not_match","debug_assert_not_starts_with","debug_assert_ok","debug_assert_ok_eq","debug_assert_ok_eq_expr","debug_assert_ok_ne","debug_assert_ok_ne_expr","debug_assert_option_none","debug_assert_option_some","debug_assert_option_some_eq","debug_assert_option_some_ne","debug_assert_pending","debug_assert_poll_pending","debug_assert_poll_ready","debug_assert_poll_ready_eq","debug_assert_poll_ready_ne","debug_assert_program_args_stderr_contains","debug_assert_program_args_stderr_eq","debug_assert_program_args_stderr_eq_expr","debug_assert_program_args_stderr_ge","debug_assert_program_args_stderr_ge_expr","debug_assert_program_args_stderr_gt","debug_assert_program_args_stderr_gt_expr","debug_assert_program_args_stderr_is_match","debug_assert_program_args_stderr_le","debug_assert_program_args_stderr_le_expr","debug_assert_program_args_stderr_lt","debug_assert_program_args_stderr_lt_expr","debug_assert_program_args_stderr_ne","debug_assert_program_args_stderr_ne_expr","debug_assert_program_args_stdout_contains","debug_assert_program_args_stdout_eq","debug_assert_program_args_stdout_eq_expr","debug_assert_program_args_stdout_ge","debug_assert_program_args_stdout_ge_expr","debug_assert_program_args_stdout_gt","debug_assert_program_args_stdout_gt_expr","debug_assert_program_args_stdout_is_match","debug_assert_program_args_stdout_le","debug_assert_program_args_stdout_le_expr","debug_assert_program_args_stdout_lt","debug_assert_program_args_stdout_lt_expr","debug_assert_program_args_stdout_ne","debug_assert_program_args_stdout_ne_expr","debug_assert_ready","debug_assert_ready_eq","debug_assert_ready_eq_expr","debug_assert_ready_ne","debug_assert_ready_ne_expr","debug_assert_result_err","debug_assert_result_ok","debug_assert_result_ok_eq","debug_assert_result_ok_ne","debug_assert_set_disjoint","debug_assert_set_eq","debug_assert_set_joint","debug_assert_set_ne","debug_assert_set_subset","debug_assert_set_superset","debug_assert_some","debug_assert_some_eq","debug_assert_some_eq_expr","debug_assert_some_ne","debug_assert_some_ne_expr","debug_assert_starts_with"],"mod":["assert","assert_approx_eq","assert_approx_ne","assert_bag","assert_command","assert_contains","assert_ends_with","assert_eq","assert_err","assert_err_eq","assert_err_eq_expr","assert_err_ne","assert_err_ne_expr","assert_fn","assert_fn_err","assert_fn_ok","assert_fs_read_to_string","assert_ge","assert_gt","assert_in_delta","assert_in_epsilon","assert_infix","assert_io_read_to_string","assert_is_match","assert_le","assert_lt","assert_ne","assert_none","assert_not_contains","assert_not_ends_with","assert_not_match","assert_not_starts_with","assert_ok","assert_ok_eq","assert_ok_eq_expr","assert_ok_ne","assert_ok_ne_expr","assert_option","assert_pending","assert_poll","assert_program_args","assert_ready","assert_ready_eq","assert_ready_eq_expr","assert_ready_ne","assert_ready_ne_expr","assert_result","assert_set","assert_some","assert_some_eq","assert_some_eq_expr","assert_some_ne","assert_some_ne_expr","assert_starts_with"]};
\ No newline at end of file
+window.SIDEBAR_ITEMS = {"macro":["assert_approx_eq","assert_approx_eq_as_result","assert_approx_ne","assert_approx_ne_as_result","assert_as_result","assert_bag_eq","assert_bag_eq_as_result","assert_bag_impl_prep","assert_bag_ne","assert_bag_ne_as_result","assert_bag_subbag","assert_bag_subbag_as_result","assert_bag_superbag","assert_bag_superbag_as_result","assert_command_stderr_contains","assert_command_stderr_contains_as_result","assert_command_stderr_eq","assert_command_stderr_eq_as_result","assert_command_stderr_eq_expr","assert_command_stderr_eq_expr_as_result","assert_command_stderr_is_match","assert_command_stderr_is_match_as_result","assert_command_stdout_contains","assert_command_stdout_contains_as_result","assert_command_stdout_eq","assert_command_stdout_eq_as_result","assert_command_stdout_eq_expr","assert_command_stdout_eq_expr_as_result","assert_command_stdout_is_match","assert_command_stdout_is_match_as_result","assert_contains","assert_contains_as_result","assert_ends_with","assert_ends_with_as_result","assert_eq_as_result","assert_err","assert_err_as_result","assert_err_eq","assert_err_eq_as_result","assert_err_eq_expr","assert_err_eq_expr_as_result","assert_err_ne","assert_err_ne_as_result","assert_err_ne_expr","assert_err_ne_expr_as_result","assert_fn_eq","assert_fn_eq_as_result","assert_fn_eq_expr","assert_fn_eq_expr_as_result","assert_fn_err_eq","assert_fn_err_eq_as_result","assert_fn_err_eq_expr","assert_fn_err_eq_expr_as_result","assert_fn_err_ge","assert_fn_err_ge_as_result","assert_fn_err_ge_expr","assert_fn_err_ge_expr_as_result","assert_fn_err_gt","assert_fn_err_gt_as_result","assert_fn_err_gt_expr","assert_fn_err_gt_expr_as_result","assert_fn_err_le","assert_fn_err_le_as_result","assert_fn_err_le_expr","assert_fn_err_le_expr_as_result","assert_fn_err_lt","assert_fn_err_lt_as_result","assert_fn_err_lt_expr","assert_fn_err_lt_expr_as_result","assert_fn_err_ne","assert_fn_err_ne_as_result","assert_fn_err_ne_expr","assert_fn_err_ne_expr_as_result","assert_fn_ge","assert_fn_ge_as_result","assert_fn_ge_expr","assert_fn_ge_expr_as_result","assert_fn_gt","assert_fn_gt_as_result","assert_fn_gt_expr","assert_fn_gt_expr_as_result","assert_fn_le","assert_fn_le_as_result","assert_fn_le_expr","assert_fn_le_expr_as_result","assert_fn_lt","assert_fn_lt_as_result","assert_fn_lt_expr","assert_fn_lt_expr_as_result","assert_fn_ne","assert_fn_ne_as_result","assert_fn_ne_expr","assert_fn_ne_expr_as_result","assert_fn_ok_eq","assert_fn_ok_eq_as_result","assert_fn_ok_eq_expr","assert_fn_ok_eq_expr_as_result","assert_fn_ok_ge","assert_fn_ok_ge_as_result","assert_fn_ok_ge_expr","assert_fn_ok_ge_expr_as_result","assert_fn_ok_gt","assert_fn_ok_gt_as_result","assert_fn_ok_gt_expr","assert_fn_ok_gt_expr_as_result","assert_fn_ok_le","assert_fn_ok_le_as_result","assert_fn_ok_le_expr","assert_fn_ok_le_expr_as_result","assert_fn_ok_lt","assert_fn_ok_lt_as_result","assert_fn_ok_lt_expr","assert_fn_ok_lt_expr_as_result","assert_fn_ok_ne","assert_fn_ok_ne_as_result","assert_fn_ok_ne_expr","assert_fn_ok_ne_expr_as_result","assert_fs_read_to_string_contains","assert_fs_read_to_string_contains_as_result","assert_fs_read_to_string_eq","assert_fs_read_to_string_eq_as_result","assert_fs_read_to_string_eq_expr","assert_fs_read_to_string_eq_expr_as_result","assert_fs_read_to_string_ge","assert_fs_read_to_string_ge_as_result","assert_fs_read_to_string_ge_expr","assert_fs_read_to_string_ge_expr_as_result","assert_fs_read_to_string_gt","assert_fs_read_to_string_gt_as_result","assert_fs_read_to_string_gt_expr","assert_fs_read_to_string_gt_expr_as_result","assert_fs_read_to_string_le","assert_fs_read_to_string_le_as_result","assert_fs_read_to_string_le_expr","assert_fs_read_to_string_le_expr_as_result","assert_fs_read_to_string_lt","assert_fs_read_to_string_lt_as_result","assert_fs_read_to_string_lt_expr","assert_fs_read_to_string_lt_expr_as_result","assert_fs_read_to_string_matches","assert_fs_read_to_string_matches_as_result","assert_fs_read_to_string_ne","assert_fs_read_to_string_ne_as_result","assert_fs_read_to_string_ne_expr","assert_fs_read_to_string_ne_expr_as_result","assert_ge","assert_ge_as_result","assert_gt","assert_gt_as_result","assert_in_delta","assert_in_delta_as_result","assert_in_epsilon","assert_in_epsilon_as_result","assert_infix","assert_infix_as_result","assert_io_read_to_string_contains","assert_io_read_to_string_contains_as_result","assert_io_read_to_string_eq","assert_io_read_to_string_eq_as_result","assert_io_read_to_string_eq_expr","assert_io_read_to_string_eq_expr_as_result","assert_io_read_to_string_ge","assert_io_read_to_string_ge_as_result","assert_io_read_to_string_ge_expr","assert_io_read_to_string_ge_expr_as_result","assert_io_read_to_string_gt","assert_io_read_to_string_gt_as_result","assert_io_read_to_string_gt_expr","assert_io_read_to_string_gt_expr_as_result","assert_io_read_to_string_le","assert_io_read_to_string_le_as_result","assert_io_read_to_string_le_expr","assert_io_read_to_string_le_expr_as_result","assert_io_read_to_string_lt","assert_io_read_to_string_lt_as_result","assert_io_read_to_string_lt_expr","assert_io_read_to_string_lt_expr_as_result","assert_io_read_to_string_matches","assert_io_read_to_string_matches_as_result","assert_io_read_to_string_ne","assert_io_read_to_string_ne_as_result","assert_io_read_to_string_ne_expr","assert_io_read_to_string_ne_expr_as_result","assert_is_match","assert_is_match_as_result","assert_le","assert_le_as_result","assert_lt","assert_lt_as_result","assert_ne_as_result","assert_none","assert_none_as_result","assert_not_contains","assert_not_contains_as_result","assert_not_ends_with","assert_not_ends_with_as_result","assert_not_match","assert_not_match_as_result","assert_not_starts_with","assert_not_starts_with_as_result","assert_ok","assert_ok_as_result","assert_ok_eq","assert_ok_eq_as_result","assert_ok_eq_expr","assert_ok_eq_expr_as_result","assert_ok_ne","assert_ok_ne_as_result","assert_ok_ne_expr","assert_ok_ne_expr_as_result","assert_option_none","assert_option_none_as_result","assert_option_some","assert_option_some_as_result","assert_option_some_eq","assert_option_some_eq_as_result","assert_option_some_ne","assert_option_some_ne_as_result","assert_pending","assert_pending_as_result","assert_poll_pending","assert_poll_pending_as_result","assert_poll_ready","assert_poll_ready_as_result","assert_poll_ready_eq","assert_poll_ready_eq_as_result","assert_poll_ready_ne","assert_poll_ready_ne_as_result","assert_program_args_impl_prep","assert_program_args_stderr_contains","assert_program_args_stderr_contains_as_result","assert_program_args_stderr_eq","assert_program_args_stderr_eq_as_result","assert_program_args_stderr_eq_expr","assert_program_args_stderr_eq_expr_as_result","assert_program_args_stderr_ge","assert_program_args_stderr_ge_as_result","assert_program_args_stderr_ge_expr","assert_program_args_stderr_ge_expr_as_result","assert_program_args_stderr_gt","assert_program_args_stderr_gt_as_result","assert_program_args_stderr_gt_expr","assert_program_args_stderr_gt_expr_as_result","assert_program_args_stderr_is_match","assert_program_args_stderr_is_match_as_result","assert_program_args_stderr_le","assert_program_args_stderr_le_as_result","assert_program_args_stderr_le_expr","assert_program_args_stderr_le_expr_as_result","assert_program_args_stderr_lt","assert_program_args_stderr_lt_as_result","assert_program_args_stderr_lt_expr","assert_program_args_stderr_lt_expr_as_result","assert_program_args_stderr_ne","assert_program_args_stderr_ne_as_result","assert_program_args_stderr_ne_expr","assert_program_args_stderr_ne_expr_as_result","assert_program_args_stdout_contains","assert_program_args_stdout_contains_as_result","assert_program_args_stdout_eq","assert_program_args_stdout_eq_as_result","assert_program_args_stdout_eq_expr","assert_program_args_stdout_eq_expr_as_result","assert_program_args_stdout_ge","assert_program_args_stdout_ge_as_result","assert_program_args_stdout_ge_expr","assert_program_args_stdout_ge_expr_as_result","assert_program_args_stdout_gt","assert_program_args_stdout_gt_as_result","assert_program_args_stdout_gt_expr","assert_program_args_stdout_gt_expr_as_result","assert_program_args_stdout_is_match","assert_program_args_stdout_is_match_as_result","assert_program_args_stdout_le","assert_program_args_stdout_le_as_result","assert_program_args_stdout_le_expr","assert_program_args_stdout_le_expr_as_result","assert_program_args_stdout_lt","assert_program_args_stdout_lt_as_result","assert_program_args_stdout_lt_expr","assert_program_args_stdout_lt_expr_as_result","assert_program_args_stdout_ne","assert_program_args_stdout_ne_as_result","assert_program_args_stdout_ne_expr","assert_program_args_stdout_ne_expr_as_result","assert_ready","assert_ready_as_result","assert_ready_eq","assert_ready_eq_as_result","assert_ready_eq_expr","assert_ready_eq_expr_as_result","assert_ready_ne","assert_ready_ne_as_result","assert_ready_ne_expr","assert_ready_ne_expr_as_result","assert_result_err","assert_result_err_as_result","assert_result_ok","assert_result_ok_as_result","assert_result_ok_eq","assert_result_ok_eq_as_result","assert_result_ok_ne","assert_result_ok_ne_as_result","assert_set_disjoint","assert_set_disjoint_as_result","assert_set_eq","assert_set_eq_as_result","assert_set_impl_prep","assert_set_joint","assert_set_joint_as_result","assert_set_ne","assert_set_ne_as_result","assert_set_subset","assert_set_subset_as_result","assert_set_superset","assert_set_superset_as_result","assert_some","assert_some_as_result","assert_some_eq","assert_some_eq_as_result","assert_some_eq_expr","assert_some_eq_expr_as_result","assert_some_ne","assert_some_ne_as_result","assert_some_ne_expr","assert_some_ne_expr_as_result","assert_starts_with","assert_starts_with_as_result","debug_assert_approx_eq","debug_assert_approx_ne","debug_assert_bag_eq","debug_assert_bag_ne","debug_assert_bag_subbag","debug_assert_bag_superbag","debug_assert_command_stderr_contains","debug_assert_command_stderr_eq","debug_assert_command_stderr_eq_expr","debug_assert_command_stderr_is_match","debug_assert_command_stdout_contains","debug_assert_command_stdout_eq","debug_assert_command_stdout_eq_expr","debug_assert_command_stdout_is_match","debug_assert_contains","debug_assert_ends_with","debug_assert_err","debug_assert_err_eq","debug_assert_err_eq_expr","debug_assert_err_ne","debug_assert_err_ne_expr","debug_assert_fn_eq","debug_assert_fn_eq_expr","debug_assert_fn_err_eq","debug_assert_fn_err_eq_expr","debug_assert_fn_err_ge","debug_assert_fn_err_ge_expr","debug_assert_fn_err_gt","debug_assert_fn_err_gt_expr","debug_assert_fn_err_le","debug_assert_fn_err_le_expr","debug_assert_fn_err_lt","debug_assert_fn_err_lt_expr","debug_assert_fn_err_ne","debug_assert_fn_err_ne_expr","debug_assert_fn_ge","debug_assert_fn_ge_expr","debug_assert_fn_gt","debug_assert_fn_gt_expr","debug_assert_fn_le","debug_assert_fn_le_expr","debug_assert_fn_lt","debug_assert_fn_lt_expr","debug_assert_fn_ne","debug_assert_fn_ne_expr","debug_assert_fn_ok_eq","debug_assert_fn_ok_eq_expr","debug_assert_fn_ok_ge","debug_assert_fn_ok_ge_expr","debug_assert_fn_ok_gt","debug_assert_fn_ok_gt_expr","debug_assert_fn_ok_le","debug_assert_fn_ok_le_expr","debug_assert_fn_ok_lt","debug_assert_fn_ok_lt_expr","debug_assert_fn_ok_ne","debug_assert_fn_ok_ne_expr","debug_assert_fs_read_to_string_contains","debug_assert_fs_read_to_string_eq","debug_assert_fs_read_to_string_eq_expr","debug_assert_fs_read_to_string_ge","debug_assert_fs_read_to_string_ge_expr","debug_assert_fs_read_to_string_gt","debug_assert_fs_read_to_string_gt_expr","debug_assert_fs_read_to_string_le","debug_assert_fs_read_to_string_le_expr","debug_assert_fs_read_to_string_lt","debug_assert_fs_read_to_string_lt_expr","debug_assert_fs_read_to_string_matches","debug_assert_fs_read_to_string_ne","debug_assert_fs_read_to_string_ne_expr","debug_assert_ge","debug_assert_gt","debug_assert_in_delta","debug_assert_in_epsilon","debug_assert_infix","debug_assert_io_read_to_string_contains","debug_assert_io_read_to_string_eq","debug_assert_io_read_to_string_eq_expr","debug_assert_io_read_to_string_ge","debug_assert_io_read_to_string_ge_expr","debug_assert_io_read_to_string_gt","debug_assert_io_read_to_string_gt_expr","debug_assert_io_read_to_string_le","debug_assert_io_read_to_string_le_expr","debug_assert_io_read_to_string_lt","debug_assert_io_read_to_string_lt_expr","debug_assert_io_read_to_string_matches","debug_assert_io_read_to_string_ne","debug_assert_io_read_to_string_ne_expr","debug_assert_is_match","debug_assert_le","debug_assert_lt","debug_assert_none","debug_assert_not_contains","debug_assert_not_ends_with","debug_assert_not_match","debug_assert_not_starts_with","debug_assert_ok","debug_assert_ok_eq","debug_assert_ok_eq_expr","debug_assert_ok_ne","debug_assert_ok_ne_expr","debug_assert_option_none","debug_assert_option_some","debug_assert_option_some_eq","debug_assert_option_some_ne","debug_assert_pending","debug_assert_poll_pending","debug_assert_poll_ready","debug_assert_poll_ready_eq","debug_assert_poll_ready_ne","debug_assert_program_args_stderr_contains","debug_assert_program_args_stderr_eq","debug_assert_program_args_stderr_eq_expr","debug_assert_program_args_stderr_ge","debug_assert_program_args_stderr_ge_expr","debug_assert_program_args_stderr_gt","debug_assert_program_args_stderr_gt_expr","debug_assert_program_args_stderr_is_match","debug_assert_program_args_stderr_le","debug_assert_program_args_stderr_le_expr","debug_assert_program_args_stderr_lt","debug_assert_program_args_stderr_lt_expr","debug_assert_program_args_stderr_ne","debug_assert_program_args_stderr_ne_expr","debug_assert_program_args_stdout_contains","debug_assert_program_args_stdout_eq","debug_assert_program_args_stdout_eq_expr","debug_assert_program_args_stdout_ge","debug_assert_program_args_stdout_ge_expr","debug_assert_program_args_stdout_gt","debug_assert_program_args_stdout_gt_expr","debug_assert_program_args_stdout_is_match","debug_assert_program_args_stdout_le","debug_assert_program_args_stdout_le_expr","debug_assert_program_args_stdout_lt","debug_assert_program_args_stdout_lt_expr","debug_assert_program_args_stdout_ne","debug_assert_program_args_stdout_ne_expr","debug_assert_ready","debug_assert_ready_eq","debug_assert_ready_eq_expr","debug_assert_ready_ne","debug_assert_ready_ne_expr","debug_assert_result_err","debug_assert_result_ok","debug_assert_result_ok_eq","debug_assert_result_ok_ne","debug_assert_set_disjoint","debug_assert_set_eq","debug_assert_set_joint","debug_assert_set_ne","debug_assert_set_subset","debug_assert_set_superset","debug_assert_some","debug_assert_some_eq","debug_assert_some_eq_expr","debug_assert_some_ne","debug_assert_some_ne_expr","debug_assert_starts_with"],"mod":["assert","assert_approx_eq","assert_approx_ne","assert_bag","assert_command","assert_contains","assert_ends_with","assert_eq","assert_err","assert_fn","assert_fn_err","assert_fn_ok","assert_fs_read_to_string","assert_ge","assert_gt","assert_in_delta","assert_in_epsilon","assert_infix","assert_io_read_to_string","assert_is_match","assert_le","assert_lt","assert_ne","assert_none","assert_not_contains","assert_not_ends_with","assert_not_match","assert_not_starts_with","assert_ok","assert_option","assert_pending","assert_poll","assert_program_args","assert_ready","assert_result","assert_set","assert_some","assert_starts_with"]};
\ No newline at end of file
diff --git a/doc/search-index.js b/doc/search-index.js
index 7ff579929..c4650fd14 100644
--- a/doc/search-index.js
+++ b/doc/search-index.js
@@ -1,5 +1,5 @@
 var searchIndex = new Map(JSON.parse('[\
-["lib",{"t":"CCQQCQQQCQQQQQQQQQCQQQQQQQQQQQQQQQQCQQCQQCQCQQCQQCQQCQQCQQCQQQQCQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQCQQQQQQQQQQQQQQQQQQQQQQQQCQQQQQQQQQQQQQQQQQQQQQQQQQQQQCQQCQQCQQCQQCQQCQQQQQQQQQQQQQQQQQQQQQQQQQQQQCQQCQQCQQCQCQQCQQCQQCQQCQQCQQCQQCQQCQQCQQCQQQQQQQQCQQCQQQQQQQQCQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQCQQCQQCQQCQQCQQCQQQQQQQQCQQQQQQQQQQQQQCQQCQQCQQCQQCQQCQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC","n":["assert","assert_approx_eq","assert_approx_eq","assert_approx_eq_as_result","assert_approx_ne","assert_approx_ne","assert_approx_ne_as_result","assert_as_result","assert_bag","assert_bag_eq","assert_bag_eq_as_result","assert_bag_impl_prep","assert_bag_ne","assert_bag_ne_as_result","assert_bag_subbag","assert_bag_subbag_as_result","assert_bag_superbag","assert_bag_superbag_as_result","assert_command","assert_command_stderr_contains","assert_command_stderr_contains_as_result","assert_command_stderr_eq","assert_command_stderr_eq_as_result","assert_command_stderr_eq_expr","assert_command_stderr_eq_expr_as_result","assert_command_stderr_is_match","assert_command_stderr_is_match_as_result","assert_command_stdout_contains","assert_command_stdout_contains_as_result","assert_command_stdout_eq","assert_command_stdout_eq_as_result","assert_command_stdout_eq_expr","assert_command_stdout_eq_expr_as_result","assert_command_stdout_is_match","assert_command_stdout_is_match_as_result","assert_contains","assert_contains","assert_contains_as_result","assert_ends_with","assert_ends_with","assert_ends_with_as_result","assert_eq","assert_eq_as_result","assert_err","assert_err","assert_err_as_result","assert_err_eq","assert_err_eq","assert_err_eq_as_result","assert_err_eq_expr","assert_err_eq_expr","assert_err_eq_expr_as_result","assert_err_ne","assert_err_ne","assert_err_ne_as_result","assert_err_ne_expr","assert_err_ne_expr","assert_err_ne_expr_as_result","assert_fn","assert_fn_eq","assert_fn_eq_as_result","assert_fn_eq_expr","assert_fn_eq_expr_as_result","assert_fn_err","assert_fn_err_eq","assert_fn_err_eq_as_result","assert_fn_err_eq_expr","assert_fn_err_eq_expr_as_result","assert_fn_err_ge","assert_fn_err_ge_as_result","assert_fn_err_ge_expr","assert_fn_err_ge_expr_as_result","assert_fn_err_gt","assert_fn_err_gt_as_result","assert_fn_err_gt_expr","assert_fn_err_gt_expr_as_result","assert_fn_err_le","assert_fn_err_le_as_result","assert_fn_err_le_expr","assert_fn_err_le_expr_as_result","assert_fn_err_lt","assert_fn_err_lt_as_result","assert_fn_err_lt_expr","assert_fn_err_lt_expr_as_result","assert_fn_err_ne","assert_fn_err_ne_as_result","assert_fn_err_ne_expr","assert_fn_err_ne_expr_as_result","assert_fn_ge","assert_fn_ge_as_result","assert_fn_ge_expr","assert_fn_ge_expr_as_result","assert_fn_gt","assert_fn_gt_as_result","assert_fn_gt_expr","assert_fn_gt_expr_as_result","assert_fn_le","assert_fn_le_as_result","assert_fn_le_expr","assert_fn_le_expr_as_result","assert_fn_lt","assert_fn_lt_as_result","assert_fn_lt_expr","assert_fn_lt_expr_as_result","assert_fn_ne","assert_fn_ne_as_result","assert_fn_ne_expr","assert_fn_ne_expr_as_result","assert_fn_ok","assert_fn_ok_eq","assert_fn_ok_eq_as_result","assert_fn_ok_eq_expr","assert_fn_ok_eq_expr_as_result","assert_fn_ok_ge","assert_fn_ok_ge_as_result","assert_fn_ok_ge_expr","assert_fn_ok_ge_expr_as_result","assert_fn_ok_gt","assert_fn_ok_gt_as_result","assert_fn_ok_gt_expr","assert_fn_ok_gt_expr_as_result","assert_fn_ok_le","assert_fn_ok_le_as_result","assert_fn_ok_le_expr","assert_fn_ok_le_expr_as_result","assert_fn_ok_lt","assert_fn_ok_lt_as_result","assert_fn_ok_lt_expr","assert_fn_ok_lt_expr_as_result","assert_fn_ok_ne","assert_fn_ok_ne_as_result","assert_fn_ok_ne_expr","assert_fn_ok_ne_expr_as_result","assert_fs_read_to_string","assert_fs_read_to_string_contains","assert_fs_read_to_string_contains_as_result","assert_fs_read_to_string_eq","assert_fs_read_to_string_eq_as_result","assert_fs_read_to_string_eq_expr","assert_fs_read_to_string_eq_expr_as_result","assert_fs_read_to_string_ge","assert_fs_read_to_string_ge_as_result","assert_fs_read_to_string_ge_expr","assert_fs_read_to_string_ge_expr_as_result","assert_fs_read_to_string_gt","assert_fs_read_to_string_gt_as_result","assert_fs_read_to_string_gt_expr","assert_fs_read_to_string_gt_expr_as_result","assert_fs_read_to_string_le","assert_fs_read_to_string_le_as_result","assert_fs_read_to_string_le_expr","assert_fs_read_to_string_le_expr_as_result","assert_fs_read_to_string_lt","assert_fs_read_to_string_lt_as_result","assert_fs_read_to_string_lt_expr","assert_fs_read_to_string_lt_expr_as_result","assert_fs_read_to_string_matches","assert_fs_read_to_string_matches_as_result","assert_fs_read_to_string_ne","assert_fs_read_to_string_ne_as_result","assert_fs_read_to_string_ne_expr","assert_fs_read_to_string_ne_expr_as_result","assert_ge","assert_ge","assert_ge_as_result","assert_gt","assert_gt","assert_gt_as_result","assert_in_delta","assert_in_delta","assert_in_delta_as_result","assert_in_epsilon","assert_in_epsilon","assert_in_epsilon_as_result","assert_infix","assert_infix","assert_infix_as_result","assert_io_read_to_string","assert_io_read_to_string_contains","assert_io_read_to_string_contains_as_result","assert_io_read_to_string_eq","assert_io_read_to_string_eq_as_result","assert_io_read_to_string_eq_expr","assert_io_read_to_string_eq_expr_as_result","assert_io_read_to_string_ge","assert_io_read_to_string_ge_as_result","assert_io_read_to_string_ge_expr","assert_io_read_to_string_ge_expr_as_result","assert_io_read_to_string_gt","assert_io_read_to_string_gt_as_result","assert_io_read_to_string_gt_expr","assert_io_read_to_string_gt_expr_as_result","assert_io_read_to_string_le","assert_io_read_to_string_le_as_result","assert_io_read_to_string_le_expr","assert_io_read_to_string_le_expr_as_result","assert_io_read_to_string_lt","assert_io_read_to_string_lt_as_result","assert_io_read_to_string_lt_expr","assert_io_read_to_string_lt_expr_as_result","assert_io_read_to_string_matches","assert_io_read_to_string_matches_as_result","assert_io_read_to_string_ne","assert_io_read_to_string_ne_as_result","assert_io_read_to_string_ne_expr","assert_io_read_to_string_ne_expr_as_result","assert_is_match","assert_is_match","assert_is_match_as_result","assert_le","assert_le","assert_le_as_result","assert_lt","assert_lt","assert_lt_as_result","assert_ne","assert_ne_as_result","assert_none","assert_none","assert_none_as_result","assert_not_contains","assert_not_contains","assert_not_contains_as_result","assert_not_ends_with","assert_not_ends_with","assert_not_ends_with_as_result","assert_not_match","assert_not_match","assert_not_match_as_result","assert_not_starts_with","assert_not_starts_with","assert_not_starts_with_as_result","assert_ok","assert_ok","assert_ok_as_result","assert_ok_eq","assert_ok_eq","assert_ok_eq_as_result","assert_ok_eq_expr","assert_ok_eq_expr","assert_ok_eq_expr_as_result","assert_ok_ne","assert_ok_ne","assert_ok_ne_as_result","assert_ok_ne_expr","assert_ok_ne_expr","assert_ok_ne_expr_as_result","assert_option","assert_option_none","assert_option_none_as_result","assert_option_some","assert_option_some_as_result","assert_option_some_eq","assert_option_some_eq_as_result","assert_option_some_ne","assert_option_some_ne_as_result","assert_pending","assert_pending","assert_pending_as_result","assert_poll","assert_poll_pending","assert_poll_pending_as_result","assert_poll_ready","assert_poll_ready_as_result","assert_poll_ready_eq","assert_poll_ready_eq_as_result","assert_poll_ready_ne","assert_poll_ready_ne_as_result","assert_program_args","assert_program_args_impl_prep","assert_program_args_stderr_contains","assert_program_args_stderr_contains_as_result","assert_program_args_stderr_eq","assert_program_args_stderr_eq_as_result","assert_program_args_stderr_eq_expr","assert_program_args_stderr_eq_expr_as_result","assert_program_args_stderr_ge","assert_program_args_stderr_ge_as_result","assert_program_args_stderr_ge_expr","assert_program_args_stderr_ge_expr_as_result","assert_program_args_stderr_gt","assert_program_args_stderr_gt_as_result","assert_program_args_stderr_gt_expr","assert_program_args_stderr_gt_expr_as_result","assert_program_args_stderr_is_match","assert_program_args_stderr_is_match_as_result","assert_program_args_stderr_le","assert_program_args_stderr_le_as_result","assert_program_args_stderr_le_expr","assert_program_args_stderr_le_expr_as_result","assert_program_args_stderr_lt","assert_program_args_stderr_lt_as_result","assert_program_args_stderr_lt_expr","assert_program_args_stderr_lt_expr_as_result","assert_program_args_stderr_ne","assert_program_args_stderr_ne_as_result","assert_program_args_stderr_ne_expr","assert_program_args_stderr_ne_expr_as_result","assert_program_args_stdout_contains","assert_program_args_stdout_contains_as_result","assert_program_args_stdout_eq","assert_program_args_stdout_eq_as_result","assert_program_args_stdout_eq_expr","assert_program_args_stdout_eq_expr_as_result","assert_program_args_stdout_ge","assert_program_args_stdout_ge_as_result","assert_program_args_stdout_ge_expr","assert_program_args_stdout_ge_expr_as_result","assert_program_args_stdout_gt","assert_program_args_stdout_gt_as_result","assert_program_args_stdout_gt_expr","assert_program_args_stdout_gt_expr_as_result","assert_program_args_stdout_is_match","assert_program_args_stdout_is_match_as_result","assert_program_args_stdout_le","assert_program_args_stdout_le_as_result","assert_program_args_stdout_le_expr","assert_program_args_stdout_le_expr_as_result","assert_program_args_stdout_lt","assert_program_args_stdout_lt_as_result","assert_program_args_stdout_lt_expr","assert_program_args_stdout_lt_expr_as_result","assert_program_args_stdout_ne","assert_program_args_stdout_ne_as_result","assert_program_args_stdout_ne_expr","assert_program_args_stdout_ne_expr_as_result","assert_ready","assert_ready","assert_ready_as_result","assert_ready_eq","assert_ready_eq","assert_ready_eq_as_result","assert_ready_eq_expr","assert_ready_eq_expr","assert_ready_eq_expr_as_result","assert_ready_ne","assert_ready_ne","assert_ready_ne_as_result","assert_ready_ne_expr","assert_ready_ne_expr","assert_ready_ne_expr_as_result","assert_result","assert_result_err","assert_result_err_as_result","assert_result_ok","assert_result_ok_as_result","assert_result_ok_eq","assert_result_ok_eq_as_result","assert_result_ok_ne","assert_result_ok_ne_as_result","assert_set","assert_set_disjoint","assert_set_disjoint_as_result","assert_set_eq","assert_set_eq_as_result","assert_set_impl_prep","assert_set_joint","assert_set_joint_as_result","assert_set_ne","assert_set_ne_as_result","assert_set_subset","assert_set_subset_as_result","assert_set_superset","assert_set_superset_as_result","assert_some","assert_some","assert_some_as_result","assert_some_eq","assert_some_eq","assert_some_eq_as_result","assert_some_eq_expr","assert_some_eq_expr","assert_some_eq_expr_as_result","assert_some_ne","assert_some_ne","assert_some_ne_as_result","assert_some_ne_expr","assert_some_ne_expr","assert_some_ne_expr_as_result","assert_starts_with","assert_starts_with","assert_starts_with_as_result","debug_assert_approx_eq","debug_assert_approx_ne","debug_assert_bag_eq","debug_assert_bag_ne","debug_assert_bag_subbag","debug_assert_bag_superbag","debug_assert_command_stderr_contains","debug_assert_command_stderr_eq","debug_assert_command_stderr_eq_expr","debug_assert_command_stderr_is_match","debug_assert_command_stdout_contains","debug_assert_command_stdout_eq","debug_assert_command_stdout_eq_expr","debug_assert_command_stdout_is_match","debug_assert_contains","debug_assert_ends_with","debug_assert_err","debug_assert_err_eq","debug_assert_err_eq_expr","debug_assert_err_ne","debug_assert_err_ne_expr","debug_assert_fn_eq","debug_assert_fn_eq_expr","debug_assert_fn_err_eq","debug_assert_fn_err_eq_expr","debug_assert_fn_err_ge","debug_assert_fn_err_ge_expr","debug_assert_fn_err_gt","debug_assert_fn_err_gt_expr","debug_assert_fn_err_le","debug_assert_fn_err_le_expr","debug_assert_fn_err_lt","debug_assert_fn_err_lt_expr","debug_assert_fn_err_ne","debug_assert_fn_err_ne_expr","debug_assert_fn_ge","debug_assert_fn_ge_expr","debug_assert_fn_gt","debug_assert_fn_gt_expr","debug_assert_fn_le","debug_assert_fn_le_expr","debug_assert_fn_lt","debug_assert_fn_lt_expr","debug_assert_fn_ne","debug_assert_fn_ne_expr","debug_assert_fn_ok_eq","debug_assert_fn_ok_eq_expr","debug_assert_fn_ok_ge","debug_assert_fn_ok_ge_expr","debug_assert_fn_ok_gt","debug_assert_fn_ok_gt_expr","debug_assert_fn_ok_le","debug_assert_fn_ok_le_expr","debug_assert_fn_ok_lt","debug_assert_fn_ok_lt_expr","debug_assert_fn_ok_ne","debug_assert_fn_ok_ne_expr","debug_assert_fs_read_to_string_contains","debug_assert_fs_read_to_string_eq","debug_assert_fs_read_to_string_eq_expr","debug_assert_fs_read_to_string_ge","debug_assert_fs_read_to_string_ge_expr","debug_assert_fs_read_to_string_gt","debug_assert_fs_read_to_string_gt_expr","debug_assert_fs_read_to_string_le","debug_assert_fs_read_to_string_le_expr","debug_assert_fs_read_to_string_lt","debug_assert_fs_read_to_string_lt_expr","debug_assert_fs_read_to_string_matches","debug_assert_fs_read_to_string_ne","debug_assert_fs_read_to_string_ne_expr","debug_assert_ge","debug_assert_gt","debug_assert_in_delta","debug_assert_in_epsilon","debug_assert_infix","debug_assert_io_read_to_string_contains","debug_assert_io_read_to_string_eq","debug_assert_io_read_to_string_eq_expr","debug_assert_io_read_to_string_ge","debug_assert_io_read_to_string_ge_expr","debug_assert_io_read_to_string_gt","debug_assert_io_read_to_string_gt_expr","debug_assert_io_read_to_string_le","debug_assert_io_read_to_string_le_expr","debug_assert_io_read_to_string_lt","debug_assert_io_read_to_string_lt_expr","debug_assert_io_read_to_string_matches","debug_assert_io_read_to_string_ne","debug_assert_io_read_to_string_ne_expr","debug_assert_is_match","debug_assert_le","debug_assert_lt","debug_assert_none","debug_assert_not_contains","debug_assert_not_ends_with","debug_assert_not_match","debug_assert_not_starts_with","debug_assert_ok","debug_assert_ok_eq","debug_assert_ok_eq_expr","debug_assert_ok_ne","debug_assert_ok_ne_expr","debug_assert_option_none","debug_assert_option_some","debug_assert_option_some_eq","debug_assert_option_some_ne","debug_assert_pending","debug_assert_poll_pending","debug_assert_poll_ready","debug_assert_poll_ready_eq","debug_assert_poll_ready_ne","debug_assert_program_args_stderr_contains","debug_assert_program_args_stderr_eq","debug_assert_program_args_stderr_eq_expr","debug_assert_program_args_stderr_ge","debug_assert_program_args_stderr_ge_expr","debug_assert_program_args_stderr_gt","debug_assert_program_args_stderr_gt_expr","debug_assert_program_args_stderr_is_match","debug_assert_program_args_stderr_le","debug_assert_program_args_stderr_le_expr","debug_assert_program_args_stderr_lt","debug_assert_program_args_stderr_lt_expr","debug_assert_program_args_stderr_ne","debug_assert_program_args_stderr_ne_expr","debug_assert_program_args_stdout_contains","debug_assert_program_args_stdout_eq","debug_assert_program_args_stdout_eq_expr","debug_assert_program_args_stdout_ge","debug_assert_program_args_stdout_ge_expr","debug_assert_program_args_stdout_gt","debug_assert_program_args_stdout_gt_expr","debug_assert_program_args_stdout_is_match","debug_assert_program_args_stdout_le","debug_assert_program_args_stdout_le_expr","debug_assert_program_args_stdout_lt","debug_assert_program_args_stdout_lt_expr","debug_assert_program_args_stdout_ne","debug_assert_program_args_stdout_ne_expr","debug_assert_ready","debug_assert_ready_eq","debug_assert_ready_eq_expr","debug_assert_ready_ne","debug_assert_ready_ne_expr","debug_assert_result_err","debug_assert_result_ok","debug_assert_result_ok_eq","debug_assert_result_ok_ne","debug_assert_set_disjoint","debug_assert_set_eq","debug_assert_set_joint","debug_assert_set_ne","debug_assert_set_subset","debug_assert_set_superset","debug_assert_some","debug_assert_some_eq","debug_assert_some_eq_expr","debug_assert_some_ne","debug_assert_some_ne_expr","debug_assert_starts_with","assert_bag_eq","assert_bag_ne","assert_bag_subbag","assert_bag_superbag","assert_command_stderr_contains","assert_command_stderr_eq","assert_command_stderr_eq_expr","assert_command_stderr_is_match","assert_command_stdout_contains","assert_command_stdout_eq","assert_command_stdout_eq_expr","assert_command_stdout_is_match","assert_fn_eq","assert_fn_eq_expr","assert_fn_ge","assert_fn_ge_expr","assert_fn_gt","assert_fn_gt_expr","assert_fn_le","assert_fn_le_expr","assert_fn_lt","assert_fn_lt_expr","assert_fn_ne","assert_fn_ne_expr","assert_fn_err_eq","assert_fn_err_eq_expr","assert_fn_err_ge","assert_fn_err_ge_expr","assert_fn_err_gt","assert_fn_err_gt_expr","assert_fn_err_le","assert_fn_err_le_expr","assert_fn_err_lt","assert_fn_err_lt_expr","assert_fn_err_ne","assert_fn_err_ne_expr","assert_fn_ok_eq","assert_fn_ok_eq_expr","assert_fn_ok_ge","assert_fn_ok_ge_expr","assert_fn_ok_gt","assert_fn_ok_gt_expr","assert_fn_ok_le","assert_fn_ok_le_expr","assert_fn_ok_lt","assert_fn_ok_lt_expr","assert_fn_ok_ne","assert_fn_ok_ne_expr","assert_fs_read_to_string_contains","assert_fs_read_to_string_eq","assert_fs_read_to_string_eq_expr","assert_fs_read_to_string_ge","assert_fs_read_to_string_ge_expr","assert_fs_read_to_string_gt","assert_fs_read_to_string_gt_expr","assert_fs_read_to_string_le","assert_fs_read_to_string_le_expr","assert_fs_read_to_string_lt","assert_fs_read_to_string_lt_expr","assert_fs_read_to_string_matches","assert_fs_read_to_string_ne","assert_fs_read_to_string_ne_expr","assert_io_read_to_string_contains","assert_io_read_to_string_eq","assert_io_read_to_string_eq_expr","assert_io_read_to_string_ge","assert_io_read_to_string_ge_expr","assert_io_read_to_string_gt","assert_io_read_to_string_gt_expr","assert_io_read_to_string_le","assert_io_read_to_string_le_expr","assert_io_read_to_string_lt","assert_io_read_to_string_lt_expr","assert_io_read_to_string_matches","assert_io_read_to_string_ne","assert_io_read_to_string_ne_expr","assert_option_none","assert_option_some","assert_option_some_eq","assert_option_some_ne","assert_poll_pending","assert_poll_ready","assert_poll_ready_eq","assert_poll_ready_ne","assert_program_args_stderr_contains","assert_program_args_stderr_eq","assert_program_args_stderr_eq_expr","assert_program_args_stderr_ge","assert_program_args_stderr_ge_expr","assert_program_args_stderr_gt","assert_program_args_stderr_gt_expr","assert_program_args_stderr_is_match","assert_program_args_stderr_le","assert_program_args_stderr_le_expr","assert_program_args_stderr_lt","assert_program_args_stderr_lt_expr","assert_program_args_stderr_ne","assert_program_args_stderr_ne_expr","assert_program_args_stdout_contains","assert_program_args_stdout_eq","assert_program_args_stdout_eq_expr","assert_program_args_stdout_ge","assert_program_args_stdout_ge_expr","assert_program_args_stdout_gt","assert_program_args_stdout_gt_expr","assert_program_args_stdout_is_match","assert_program_args_stdout_le","assert_program_args_stdout_le_expr","assert_program_args_stdout_lt","assert_program_args_stdout_lt_expr","assert_program_args_stdout_ne","assert_program_args_stdout_ne_expr","assert_result_err","assert_result_ok","assert_result_ok_eq","assert_result_ok_ne","assert_set_disjoint","assert_set_eq","assert_set_joint","assert_set_ne","assert_set_subset","assert_set_superset"],"q":[[0,"lib"],[543,"lib::assert_bag"],[547,"lib::assert_command"],[555,"lib::assert_fn"],[567,"lib::assert_fn_err"],[579,"lib::assert_fn_ok"],[591,"lib::assert_fs_read_to_string"],[605,"lib::assert_io_read_to_string"],[619,"lib::assert_option"],[623,"lib::assert_poll"],[627,"lib::assert_program_args"],[655,"lib::assert_result"],[659,"lib::assert_set"]],"i":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"f":"`````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````","D":"EBn","p":[],"r":[],"b":[],"c":"OzAAAAEAACIABgD5AAcABQEHAFcBBwDmAQMA6wECABACAwA=","e":"OjAAAAEAAAAAAAIAEAAAAAwADgFkAQ=="}]\
+["lib",{"t":"CCQQCQQQCQQQQQQQQQCQQQQQQQQQQQQQQQQCQQCQQCQCQQQQQQQQQQCQQQQCQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQCQQQQQQQQQQQQQQQQQQQQQQQQCQQQQQQQQQQQQQQQQQQQQQQQQQQQQCQQCQQCQQCQQCQQCQQQQQQQQQQQQQQQQQQQQQQQQQQQQCQQCQQCQQCQCQQCQQCQQCQQCQQCQQQQQQQQQQCQQQQQQQQCQQCQQQQQQQQCQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQCQQQQQQQQQQCQQQQQQQQCQQQQQQQQQQQQQCQQQQQQQQQQCQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC","n":["assert","assert_approx_eq","assert_approx_eq","assert_approx_eq_as_result","assert_approx_ne","assert_approx_ne","assert_approx_ne_as_result","assert_as_result","assert_bag","assert_bag_eq","assert_bag_eq_as_result","assert_bag_impl_prep","assert_bag_ne","assert_bag_ne_as_result","assert_bag_subbag","assert_bag_subbag_as_result","assert_bag_superbag","assert_bag_superbag_as_result","assert_command","assert_command_stderr_contains","assert_command_stderr_contains_as_result","assert_command_stderr_eq","assert_command_stderr_eq_as_result","assert_command_stderr_eq_expr","assert_command_stderr_eq_expr_as_result","assert_command_stderr_is_match","assert_command_stderr_is_match_as_result","assert_command_stdout_contains","assert_command_stdout_contains_as_result","assert_command_stdout_eq","assert_command_stdout_eq_as_result","assert_command_stdout_eq_expr","assert_command_stdout_eq_expr_as_result","assert_command_stdout_is_match","assert_command_stdout_is_match_as_result","assert_contains","assert_contains","assert_contains_as_result","assert_ends_with","assert_ends_with","assert_ends_with_as_result","assert_eq","assert_eq_as_result","assert_err","assert_err","assert_err_as_result","assert_err_eq","assert_err_eq_as_result","assert_err_eq_expr","assert_err_eq_expr_as_result","assert_err_ne","assert_err_ne_as_result","assert_err_ne_expr","assert_err_ne_expr_as_result","assert_fn","assert_fn_eq","assert_fn_eq_as_result","assert_fn_eq_expr","assert_fn_eq_expr_as_result","assert_fn_err","assert_fn_err_eq","assert_fn_err_eq_as_result","assert_fn_err_eq_expr","assert_fn_err_eq_expr_as_result","assert_fn_err_ge","assert_fn_err_ge_as_result","assert_fn_err_ge_expr","assert_fn_err_ge_expr_as_result","assert_fn_err_gt","assert_fn_err_gt_as_result","assert_fn_err_gt_expr","assert_fn_err_gt_expr_as_result","assert_fn_err_le","assert_fn_err_le_as_result","assert_fn_err_le_expr","assert_fn_err_le_expr_as_result","assert_fn_err_lt","assert_fn_err_lt_as_result","assert_fn_err_lt_expr","assert_fn_err_lt_expr_as_result","assert_fn_err_ne","assert_fn_err_ne_as_result","assert_fn_err_ne_expr","assert_fn_err_ne_expr_as_result","assert_fn_ge","assert_fn_ge_as_result","assert_fn_ge_expr","assert_fn_ge_expr_as_result","assert_fn_gt","assert_fn_gt_as_result","assert_fn_gt_expr","assert_fn_gt_expr_as_result","assert_fn_le","assert_fn_le_as_result","assert_fn_le_expr","assert_fn_le_expr_as_result","assert_fn_lt","assert_fn_lt_as_result","assert_fn_lt_expr","assert_fn_lt_expr_as_result","assert_fn_ne","assert_fn_ne_as_result","assert_fn_ne_expr","assert_fn_ne_expr_as_result","assert_fn_ok","assert_fn_ok_eq","assert_fn_ok_eq_as_result","assert_fn_ok_eq_expr","assert_fn_ok_eq_expr_as_result","assert_fn_ok_ge","assert_fn_ok_ge_as_result","assert_fn_ok_ge_expr","assert_fn_ok_ge_expr_as_result","assert_fn_ok_gt","assert_fn_ok_gt_as_result","assert_fn_ok_gt_expr","assert_fn_ok_gt_expr_as_result","assert_fn_ok_le","assert_fn_ok_le_as_result","assert_fn_ok_le_expr","assert_fn_ok_le_expr_as_result","assert_fn_ok_lt","assert_fn_ok_lt_as_result","assert_fn_ok_lt_expr","assert_fn_ok_lt_expr_as_result","assert_fn_ok_ne","assert_fn_ok_ne_as_result","assert_fn_ok_ne_expr","assert_fn_ok_ne_expr_as_result","assert_fs_read_to_string","assert_fs_read_to_string_contains","assert_fs_read_to_string_contains_as_result","assert_fs_read_to_string_eq","assert_fs_read_to_string_eq_as_result","assert_fs_read_to_string_eq_expr","assert_fs_read_to_string_eq_expr_as_result","assert_fs_read_to_string_ge","assert_fs_read_to_string_ge_as_result","assert_fs_read_to_string_ge_expr","assert_fs_read_to_string_ge_expr_as_result","assert_fs_read_to_string_gt","assert_fs_read_to_string_gt_as_result","assert_fs_read_to_string_gt_expr","assert_fs_read_to_string_gt_expr_as_result","assert_fs_read_to_string_le","assert_fs_read_to_string_le_as_result","assert_fs_read_to_string_le_expr","assert_fs_read_to_string_le_expr_as_result","assert_fs_read_to_string_lt","assert_fs_read_to_string_lt_as_result","assert_fs_read_to_string_lt_expr","assert_fs_read_to_string_lt_expr_as_result","assert_fs_read_to_string_matches","assert_fs_read_to_string_matches_as_result","assert_fs_read_to_string_ne","assert_fs_read_to_string_ne_as_result","assert_fs_read_to_string_ne_expr","assert_fs_read_to_string_ne_expr_as_result","assert_ge","assert_ge","assert_ge_as_result","assert_gt","assert_gt","assert_gt_as_result","assert_in_delta","assert_in_delta","assert_in_delta_as_result","assert_in_epsilon","assert_in_epsilon","assert_in_epsilon_as_result","assert_infix","assert_infix","assert_infix_as_result","assert_io_read_to_string","assert_io_read_to_string_contains","assert_io_read_to_string_contains_as_result","assert_io_read_to_string_eq","assert_io_read_to_string_eq_as_result","assert_io_read_to_string_eq_expr","assert_io_read_to_string_eq_expr_as_result","assert_io_read_to_string_ge","assert_io_read_to_string_ge_as_result","assert_io_read_to_string_ge_expr","assert_io_read_to_string_ge_expr_as_result","assert_io_read_to_string_gt","assert_io_read_to_string_gt_as_result","assert_io_read_to_string_gt_expr","assert_io_read_to_string_gt_expr_as_result","assert_io_read_to_string_le","assert_io_read_to_string_le_as_result","assert_io_read_to_string_le_expr","assert_io_read_to_string_le_expr_as_result","assert_io_read_to_string_lt","assert_io_read_to_string_lt_as_result","assert_io_read_to_string_lt_expr","assert_io_read_to_string_lt_expr_as_result","assert_io_read_to_string_matches","assert_io_read_to_string_matches_as_result","assert_io_read_to_string_ne","assert_io_read_to_string_ne_as_result","assert_io_read_to_string_ne_expr","assert_io_read_to_string_ne_expr_as_result","assert_is_match","assert_is_match","assert_is_match_as_result","assert_le","assert_le","assert_le_as_result","assert_lt","assert_lt","assert_lt_as_result","assert_ne","assert_ne_as_result","assert_none","assert_none","assert_none_as_result","assert_not_contains","assert_not_contains","assert_not_contains_as_result","assert_not_ends_with","assert_not_ends_with","assert_not_ends_with_as_result","assert_not_match","assert_not_match","assert_not_match_as_result","assert_not_starts_with","assert_not_starts_with","assert_not_starts_with_as_result","assert_ok","assert_ok","assert_ok_as_result","assert_ok_eq","assert_ok_eq_as_result","assert_ok_eq_expr","assert_ok_eq_expr_as_result","assert_ok_ne","assert_ok_ne_as_result","assert_ok_ne_expr","assert_ok_ne_expr_as_result","assert_option","assert_option_none","assert_option_none_as_result","assert_option_some","assert_option_some_as_result","assert_option_some_eq","assert_option_some_eq_as_result","assert_option_some_ne","assert_option_some_ne_as_result","assert_pending","assert_pending","assert_pending_as_result","assert_poll","assert_poll_pending","assert_poll_pending_as_result","assert_poll_ready","assert_poll_ready_as_result","assert_poll_ready_eq","assert_poll_ready_eq_as_result","assert_poll_ready_ne","assert_poll_ready_ne_as_result","assert_program_args","assert_program_args_impl_prep","assert_program_args_stderr_contains","assert_program_args_stderr_contains_as_result","assert_program_args_stderr_eq","assert_program_args_stderr_eq_as_result","assert_program_args_stderr_eq_expr","assert_program_args_stderr_eq_expr_as_result","assert_program_args_stderr_ge","assert_program_args_stderr_ge_as_result","assert_program_args_stderr_ge_expr","assert_program_args_stderr_ge_expr_as_result","assert_program_args_stderr_gt","assert_program_args_stderr_gt_as_result","assert_program_args_stderr_gt_expr","assert_program_args_stderr_gt_expr_as_result","assert_program_args_stderr_is_match","assert_program_args_stderr_is_match_as_result","assert_program_args_stderr_le","assert_program_args_stderr_le_as_result","assert_program_args_stderr_le_expr","assert_program_args_stderr_le_expr_as_result","assert_program_args_stderr_lt","assert_program_args_stderr_lt_as_result","assert_program_args_stderr_lt_expr","assert_program_args_stderr_lt_expr_as_result","assert_program_args_stderr_ne","assert_program_args_stderr_ne_as_result","assert_program_args_stderr_ne_expr","assert_program_args_stderr_ne_expr_as_result","assert_program_args_stdout_contains","assert_program_args_stdout_contains_as_result","assert_program_args_stdout_eq","assert_program_args_stdout_eq_as_result","assert_program_args_stdout_eq_expr","assert_program_args_stdout_eq_expr_as_result","assert_program_args_stdout_ge","assert_program_args_stdout_ge_as_result","assert_program_args_stdout_ge_expr","assert_program_args_stdout_ge_expr_as_result","assert_program_args_stdout_gt","assert_program_args_stdout_gt_as_result","assert_program_args_stdout_gt_expr","assert_program_args_stdout_gt_expr_as_result","assert_program_args_stdout_is_match","assert_program_args_stdout_is_match_as_result","assert_program_args_stdout_le","assert_program_args_stdout_le_as_result","assert_program_args_stdout_le_expr","assert_program_args_stdout_le_expr_as_result","assert_program_args_stdout_lt","assert_program_args_stdout_lt_as_result","assert_program_args_stdout_lt_expr","assert_program_args_stdout_lt_expr_as_result","assert_program_args_stdout_ne","assert_program_args_stdout_ne_as_result","assert_program_args_stdout_ne_expr","assert_program_args_stdout_ne_expr_as_result","assert_ready","assert_ready","assert_ready_as_result","assert_ready_eq","assert_ready_eq_as_result","assert_ready_eq_expr","assert_ready_eq_expr_as_result","assert_ready_ne","assert_ready_ne_as_result","assert_ready_ne_expr","assert_ready_ne_expr_as_result","assert_result","assert_result_err","assert_result_err_as_result","assert_result_ok","assert_result_ok_as_result","assert_result_ok_eq","assert_result_ok_eq_as_result","assert_result_ok_ne","assert_result_ok_ne_as_result","assert_set","assert_set_disjoint","assert_set_disjoint_as_result","assert_set_eq","assert_set_eq_as_result","assert_set_impl_prep","assert_set_joint","assert_set_joint_as_result","assert_set_ne","assert_set_ne_as_result","assert_set_subset","assert_set_subset_as_result","assert_set_superset","assert_set_superset_as_result","assert_some","assert_some","assert_some_as_result","assert_some_eq","assert_some_eq_as_result","assert_some_eq_expr","assert_some_eq_expr_as_result","assert_some_ne","assert_some_ne_as_result","assert_some_ne_expr","assert_some_ne_expr_as_result","assert_starts_with","assert_starts_with","assert_starts_with_as_result","debug_assert_approx_eq","debug_assert_approx_ne","debug_assert_bag_eq","debug_assert_bag_ne","debug_assert_bag_subbag","debug_assert_bag_superbag","debug_assert_command_stderr_contains","debug_assert_command_stderr_eq","debug_assert_command_stderr_eq_expr","debug_assert_command_stderr_is_match","debug_assert_command_stdout_contains","debug_assert_command_stdout_eq","debug_assert_command_stdout_eq_expr","debug_assert_command_stdout_is_match","debug_assert_contains","debug_assert_ends_with","debug_assert_err","debug_assert_err_eq","debug_assert_err_eq_expr","debug_assert_err_ne","debug_assert_err_ne_expr","debug_assert_fn_eq","debug_assert_fn_eq_expr","debug_assert_fn_err_eq","debug_assert_fn_err_eq_expr","debug_assert_fn_err_ge","debug_assert_fn_err_ge_expr","debug_assert_fn_err_gt","debug_assert_fn_err_gt_expr","debug_assert_fn_err_le","debug_assert_fn_err_le_expr","debug_assert_fn_err_lt","debug_assert_fn_err_lt_expr","debug_assert_fn_err_ne","debug_assert_fn_err_ne_expr","debug_assert_fn_ge","debug_assert_fn_ge_expr","debug_assert_fn_gt","debug_assert_fn_gt_expr","debug_assert_fn_le","debug_assert_fn_le_expr","debug_assert_fn_lt","debug_assert_fn_lt_expr","debug_assert_fn_ne","debug_assert_fn_ne_expr","debug_assert_fn_ok_eq","debug_assert_fn_ok_eq_expr","debug_assert_fn_ok_ge","debug_assert_fn_ok_ge_expr","debug_assert_fn_ok_gt","debug_assert_fn_ok_gt_expr","debug_assert_fn_ok_le","debug_assert_fn_ok_le_expr","debug_assert_fn_ok_lt","debug_assert_fn_ok_lt_expr","debug_assert_fn_ok_ne","debug_assert_fn_ok_ne_expr","debug_assert_fs_read_to_string_contains","debug_assert_fs_read_to_string_eq","debug_assert_fs_read_to_string_eq_expr","debug_assert_fs_read_to_string_ge","debug_assert_fs_read_to_string_ge_expr","debug_assert_fs_read_to_string_gt","debug_assert_fs_read_to_string_gt_expr","debug_assert_fs_read_to_string_le","debug_assert_fs_read_to_string_le_expr","debug_assert_fs_read_to_string_lt","debug_assert_fs_read_to_string_lt_expr","debug_assert_fs_read_to_string_matches","debug_assert_fs_read_to_string_ne","debug_assert_fs_read_to_string_ne_expr","debug_assert_ge","debug_assert_gt","debug_assert_in_delta","debug_assert_in_epsilon","debug_assert_infix","debug_assert_io_read_to_string_contains","debug_assert_io_read_to_string_eq","debug_assert_io_read_to_string_eq_expr","debug_assert_io_read_to_string_ge","debug_assert_io_read_to_string_ge_expr","debug_assert_io_read_to_string_gt","debug_assert_io_read_to_string_gt_expr","debug_assert_io_read_to_string_le","debug_assert_io_read_to_string_le_expr","debug_assert_io_read_to_string_lt","debug_assert_io_read_to_string_lt_expr","debug_assert_io_read_to_string_matches","debug_assert_io_read_to_string_ne","debug_assert_io_read_to_string_ne_expr","debug_assert_is_match","debug_assert_le","debug_assert_lt","debug_assert_none","debug_assert_not_contains","debug_assert_not_ends_with","debug_assert_not_match","debug_assert_not_starts_with","debug_assert_ok","debug_assert_ok_eq","debug_assert_ok_eq_expr","debug_assert_ok_ne","debug_assert_ok_ne_expr","debug_assert_option_none","debug_assert_option_some","debug_assert_option_some_eq","debug_assert_option_some_ne","debug_assert_pending","debug_assert_poll_pending","debug_assert_poll_ready","debug_assert_poll_ready_eq","debug_assert_poll_ready_ne","debug_assert_program_args_stderr_contains","debug_assert_program_args_stderr_eq","debug_assert_program_args_stderr_eq_expr","debug_assert_program_args_stderr_ge","debug_assert_program_args_stderr_ge_expr","debug_assert_program_args_stderr_gt","debug_assert_program_args_stderr_gt_expr","debug_assert_program_args_stderr_is_match","debug_assert_program_args_stderr_le","debug_assert_program_args_stderr_le_expr","debug_assert_program_args_stderr_lt","debug_assert_program_args_stderr_lt_expr","debug_assert_program_args_stderr_ne","debug_assert_program_args_stderr_ne_expr","debug_assert_program_args_stdout_contains","debug_assert_program_args_stdout_eq","debug_assert_program_args_stdout_eq_expr","debug_assert_program_args_stdout_ge","debug_assert_program_args_stdout_ge_expr","debug_assert_program_args_stdout_gt","debug_assert_program_args_stdout_gt_expr","debug_assert_program_args_stdout_is_match","debug_assert_program_args_stdout_le","debug_assert_program_args_stdout_le_expr","debug_assert_program_args_stdout_lt","debug_assert_program_args_stdout_lt_expr","debug_assert_program_args_stdout_ne","debug_assert_program_args_stdout_ne_expr","debug_assert_ready","debug_assert_ready_eq","debug_assert_ready_eq_expr","debug_assert_ready_ne","debug_assert_ready_ne_expr","debug_assert_result_err","debug_assert_result_ok","debug_assert_result_ok_eq","debug_assert_result_ok_ne","debug_assert_set_disjoint","debug_assert_set_eq","debug_assert_set_joint","debug_assert_set_ne","debug_assert_set_subset","debug_assert_set_superset","debug_assert_some","debug_assert_some_eq","debug_assert_some_eq_expr","debug_assert_some_ne","debug_assert_some_ne_expr","debug_assert_starts_with","assert_bag_eq","assert_bag_ne","assert_bag_subbag","assert_bag_superbag","assert_command_stderr_contains","assert_command_stderr_eq","assert_command_stderr_eq_expr","assert_command_stderr_is_match","assert_command_stdout_contains","assert_command_stdout_eq","assert_command_stdout_eq_expr","assert_command_stdout_is_match","assert_err","assert_err_eq","assert_err_eq_expr","assert_err_ne","assert_err_ne_expr","assert_fn_eq","assert_fn_eq_expr","assert_fn_ge","assert_fn_ge_expr","assert_fn_gt","assert_fn_gt_expr","assert_fn_le","assert_fn_le_expr","assert_fn_lt","assert_fn_lt_expr","assert_fn_ne","assert_fn_ne_expr","assert_fn_err_eq","assert_fn_err_eq_expr","assert_fn_err_ge","assert_fn_err_ge_expr","assert_fn_err_gt","assert_fn_err_gt_expr","assert_fn_err_le","assert_fn_err_le_expr","assert_fn_err_lt","assert_fn_err_lt_expr","assert_fn_err_ne","assert_fn_err_ne_expr","assert_fn_ok_eq","assert_fn_ok_eq_expr","assert_fn_ok_ge","assert_fn_ok_ge_expr","assert_fn_ok_gt","assert_fn_ok_gt_expr","assert_fn_ok_le","assert_fn_ok_le_expr","assert_fn_ok_lt","assert_fn_ok_lt_expr","assert_fn_ok_ne","assert_fn_ok_ne_expr","assert_fs_read_to_string_contains","assert_fs_read_to_string_eq","assert_fs_read_to_string_eq_expr","assert_fs_read_to_string_ge","assert_fs_read_to_string_ge_expr","assert_fs_read_to_string_gt","assert_fs_read_to_string_gt_expr","assert_fs_read_to_string_le","assert_fs_read_to_string_le_expr","assert_fs_read_to_string_lt","assert_fs_read_to_string_lt_expr","assert_fs_read_to_string_matches","assert_fs_read_to_string_ne","assert_fs_read_to_string_ne_expr","assert_io_read_to_string_contains","assert_io_read_to_string_eq","assert_io_read_to_string_eq_expr","assert_io_read_to_string_ge","assert_io_read_to_string_ge_expr","assert_io_read_to_string_gt","assert_io_read_to_string_gt_expr","assert_io_read_to_string_le","assert_io_read_to_string_le_expr","assert_io_read_to_string_lt","assert_io_read_to_string_lt_expr","assert_io_read_to_string_matches","assert_io_read_to_string_ne","assert_io_read_to_string_ne_expr","assert_none","assert_ok","assert_ok_eq","assert_ok_eq_expr","assert_ok_ne","assert_ok_ne_expr","assert_option_none","assert_option_some","assert_option_some_eq","assert_option_some_ne","assert_pending","assert_poll_pending","assert_poll_ready","assert_poll_ready_eq","assert_poll_ready_ne","assert_program_args_stderr_contains","assert_program_args_stderr_eq","assert_program_args_stderr_eq_expr","assert_program_args_stderr_ge","assert_program_args_stderr_ge_expr","assert_program_args_stderr_gt","assert_program_args_stderr_gt_expr","assert_program_args_stderr_is_match","assert_program_args_stderr_le","assert_program_args_stderr_le_expr","assert_program_args_stderr_lt","assert_program_args_stderr_lt_expr","assert_program_args_stderr_ne","assert_program_args_stderr_ne_expr","assert_program_args_stdout_contains","assert_program_args_stdout_eq","assert_program_args_stdout_eq_expr","assert_program_args_stdout_ge","assert_program_args_stdout_ge_expr","assert_program_args_stdout_gt","assert_program_args_stdout_gt_expr","assert_program_args_stdout_is_match","assert_program_args_stdout_le","assert_program_args_stdout_le_expr","assert_program_args_stdout_lt","assert_program_args_stdout_lt_expr","assert_program_args_stdout_ne","assert_program_args_stdout_ne_expr","assert_ready","assert_ready_eq","assert_ready_eq_expr","assert_ready_ne","assert_ready_ne_expr","assert_result_err","assert_result_ok","assert_result_ok_eq","assert_result_ok_ne","assert_set_disjoint","assert_set_eq","assert_set_joint","assert_set_ne","assert_set_subset","assert_set_superset","assert_some","assert_some_eq","assert_some_eq_expr","assert_some_ne","assert_some_ne_expr"],"q":[[0,"lib"],[527,"lib::assert_bag"],[531,"lib::assert_command"],[539,"lib::assert_err"],[544,"lib::assert_fn"],[556,"lib::assert_fn_err"],[568,"lib::assert_fn_ok"],[580,"lib::assert_fs_read_to_string"],[594,"lib::assert_io_read_to_string"],[608,"lib::assert_none"],[609,"lib::assert_ok"],[614,"lib::assert_option"],[618,"lib::assert_pending"],[619,"lib::assert_poll"],[623,"lib::assert_program_args"],[651,"lib::assert_ready"],[656,"lib::assert_result"],[660,"lib::assert_set"],[666,"lib::assert_some"]],"i":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"f":"```````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````","D":"ECj","p":[],"r":[],"b":[],"c":"OzAAAAEAACIABgDxAAcA/QAHAEsBBwDWAQMA2wECAAACAwA=","e":"OjAAAAEAAAAAAAIAEAAAAAwABgFYAQ=="}]\
 ]'));
 if (typeof exports !== 'undefined') exports.searchIndex = searchIndex;
 else if (window.initSearch) window.initSearch(searchIndex);
diff --git a/doc/search.desc/lib/lib-desc-0-.js b/doc/search.desc/lib/lib-desc-0-.js
index 6532dfb8f..5b254cce1 100644
--- a/doc/search.desc/lib/lib-desc-0-.js
+++ b/doc/search.desc/lib/lib-desc-0-.js
@@ -1 +1 @@
-searchState.loadedDescShard("lib", 0, "Assertables: Rust crate of assert macros for testing\nAssert a condition is true.\nAssert a number is approximately equal to another number.\nAssert a number is approximately equal to another number.\nAssert a number is approximately equal to another number.\nAssert a number is approximately not equal to another …\nAssert a number is approximately not equal to another …\nAssert a number is approximately not equal to another …\nAssert a condition is true.\nAssert macros for comparing bag collections.\nAssert a bag is equal to another.\nAssert a bag is equal to another.\nAssert a bag is not equal to another.\nAssert a bag is not equal to another.\nAssert a bag is a subbag of another.\nAssert a bag is a subbag of another.\nAssert a bag is a superbag of another.\nAssert a bag is a superbag of another.\nAssert macros for comparing commands and their stdout & …\nAssert a command stderr string contains a given containee.\nAssert a command stderr string contains a given containee.\nAssert a command stderr string is equal to another.\nAssert a command stderr string is equal to another.\nAssert a command stderr string is equal to an expression.\nAssert a command stderr string is equal to an expression.\nAssert a command stderr string is a match to a regex.\nAssert a command stderr string is a match to a regex.\nAssert a command stdout string contains a given containee.\nAssert a command stdout string contains a given containee.\nAssert a command stdout string is equal to another.\nAssert a command stdout string is equal to another.\nAssert a command stdout string is equal to an expression.\nAssert a command stdout string is equal to an expression.\nAssert command stdout string is a match to a regex.\nAssert command stdout string is a match to a regex.\nAssert a container is a match for an expression.\nAssert a container is a match for an expression.\nAssert an expression (such as a string) contains an …\nAssert an expression (such as a string) ends with an …\nAssert an expression (such as a string) ends with an …\nAssert an expression (such as a string) ends with an …\nAssert an expression is equal to another.\nAssert an expression is equal to another.\nAssert expression is Err(_).\nAssert expression is Err(_).\nAssert expression is Err(_).\nAssert two expressions are Err(_) and their values are …\nAssert two expressions are Err(_) and their values are …\nAssert two expressions are Err(_) and their values are …\nAssert an expression is Err(_) and its value is equal to …\nAssert an expression is Err(_) and its value is equal to …\nAssert an expression is Err(_) and its value is equal to …\nAssert two expressions are Err(_) and their values are not …\nAssert two expressions are Err(_) and their values are not …\nAssert two expressions are Err(_) and their values are not …\nAssert an expression is Err(_) and its value is not equal …\nAssert an expression is Err(_) and its value is equal to …\nAssert an expression is Err(_) and its value is equal to …\nAssert macros for comparing functions.\nAssert a function output is equal to another function …\nAssert a function output is equal to another function …\nAssert a function output is equal to an expression.\nAssert a function output is equal to an expression.\nAssert macros for comparing functions that return errors.\nAssert a function error is equal to another.\nAssert a function error is equal to another.\nAssert a function error is equal to an expression.\nAssert a function error is equal to an expression.\nAssert a function error is greater than or equal to …\nAssert a function error is greater than or equal to …\nAssert a function error is greater than or equal to an …\nAssert a function error is greater than or equal to an …\nAssert a function error is greater than another.\nAssert a function error is greater than another.\nAssert a function error is greater than an expression.\nAssert a function error is greater than an expression.\nAssert a function error is less than or equal to another.\nAssert a function error is less than or equal to another.\nAssert a function error is less than or equal to an …\nAssert a function error is less than or equal to an …\nAssert a function error is less than another.\nAssert a function error is less than another.\nAssert a function error is less than an expression.\nAssert a function error is less than an expression.\nAssert a function error is not equal to another.\nAssert a function error is not equal to another.\nAssert a function error is not equal to an expression.\nAssert a function error is not equal to an expression.\nAssert a function output is greater than or equal to …\nAssert a function output is greater than or equal to …\nAssert a function output is greater than or equal to an …\nAssert a function output is greater than or equal to an …\nAssert a function output is greater than another.\nAssert a function output is greater than another.\nAssert a function output is greater than an expression.\nAssert a function output is greater than an expression.\nAssert a function output is less than or equal to another.\nAssert a function output is less than or equal to another.\nAssert a function output is less than or equal to an …\nAssert a function output is less than or equal to an …\nAssert a function output is less than another.\nAssert a function output is less than another.\nAssert a function output is less than an expression.\nAssert a function output is less than an expression.\nAssert a function output is not equal to another.\nAssert a function output is not equal to another.\nAssert a function output is not equal to an expression.\nAssert a function output is not equal to an expression.\nAssert macros for comparing functions that return …\nAssert a function Ok(…) is equal to another.\nAssert a function Ok(…) is equal to another.\nAssert a function Ok(…) is equal to an expression.\nAssert a function Ok(…) is equal to an expression.\nAssert a function Ok(…) is greater than or equal to …\nAssert a function Ok(…) is greater than or equal to …\nAssert a function Ok(…) is greater than or equal to an …\nAssert a function Ok(…) is greater than or equal to an …\nAssert a function Ok(…) is greater than another.\nAssert a function Ok(…) is greater than another.\nAssert a function Ok(…) is greater than an expression.\nAssert a function Ok(…) is greater than an expression.\nAssert a function Ok(…) is less than or equal to another.\nAssert a function Ok(…) is less than or equal to another.\nAssert a function Ok(…) is less than or equal to an …\nAssert a function Ok(…) is less than or equal to an …\nAssert a function Ok(…) is less than another.\nAssert a function Ok(…) is less than another.\nAssert a function Ok(…) is less than an expression.\nAssert a function Ok(…) is less than an expression.\nAssert a function Ok(…) is not equal to another.\nAssert a function Ok(…) is not equal to another.\nAssert a function Ok(…) is not equal to an expression.\nAssert a function Ok(…) is not equal to an expression.\nAssert macros for comparing file system path contents.\nAssert a std::fs::read_to_string(path) contains a pattern.\nAssert a std::fs::read_to_string(path) contains a pattern.\nAssert a std::fs::read_to_string(path) value is equal to …\nAssert a std::fs::read_to_string(path) is equal to another.\nAssert a std::fs::read_to_string(path) value is equal to …\nAssert a std::fs::read_to_string(path) value is equal to …\nAssert a std::fs::read_to_string(path) value is greater …\nAssert a std::fs::read_to_string(path) value is greater …\nAssert a std::fs::read_to_string(path) value is greater …\nAssert a std::fs::read_to_string(path) value is greater …\nAssert a std::fs::read_to_string(path) value is greater …\nAssert a std::fs::read_to_string(path) value is greater …\nAssert a std::fs::read_to_string(path) value is greater …\nAssert a std::fs::read_to_string(path) value is greater …\nAssert a std::fs::read_to_string(path) value is less than …\nAssert a std::fs::read_to_string(path) value is less than …\nAssert a std::fs::read_to_string(path) value is less than …\nAssert a std::fs::read_to_string(path) value is less than …\nAssert a std::fs::read_to_string(path) value is less than …\nAssert a std::fs::read_to_string(path) value is less than …\nAssert a std::fs::read_to_string(path) value is less than …\nAssert a std::fs::read_to_string(path) value is less than …\nAssert a std::fs::read_to_string(path) is a match to a …\nAssert a std::fs::read_to_string(path) is a match to a …\nAssert a std::fs::read_to_string(path) is not equal to …\nAssert a std::fs::read_to_string(path) is not equal to …\nAssert a std::fs::read_to_string(path) is not equal to an …\nAssert a std::fs::read_to_string(path) is not equal to an …\nAssert a value is greater than or equal to an expression.\nAssert a value is greater than or equal to an expression.\nAssert a value is greater than or equal to an expression.\nAssert a value is greater than an expression.\nAssert a value is greater than an expression.\nAssert a value is greater than an expression.\nAssert a number is within delta of another number.\nAssert a number is within delta of another number.\nAssert a number is within delta of another number.\nAssert a number is within epsilon of another number.\nAssert a number is within epsilon of another number.\nAssert a number is within epsilon of another number.\nAssert a infix operator, such as assert_infix!(a == b).\nAssert a infix operator, such as assert_infix!(a == b).\nAssert a infix operator, such as assert_infix!(a == b).\nAssert macros for comparing input/output reader streams.\nAssert a std::io::Read read_to_string() contains a pattern.\nAssert a std::io::Read read_to_string() contains a pattern.\nAssert a std::io::Read read_to_string() value is equal to …\nAssert a std::io::Read read_to_string() is equal to …\nAssert a std::io::Read read_to_string() value is equal to …\nAssert a std::io::Read read_to_string() value is equal to …\nAssert a std::io::Read read_to_string() value is greater …\nAssert a std::io::Read read_to_string() value is greater …\nAssert a std::io::Read read_to_string() value is greater …\nAssert a std::io::Read read_to_string() value is greater …\nAssert a std::io::Read read_to_string() value is greater …\nAssert a std::io::Read read_to_string() value is greater …\nAssert a std::io::Read read_to_string() value is greater …\nAssert a std::io::Read read_to_string() value is greater …\nAssert a std::io::Read read_to_string() value is less than …\nAssert a std::io::Read read_to_string() value is less than …\nAssert a std::io::Read read_to_string() value is less than …\nAssert a std::io::Read read_to_string() value is less than …\nAssert a std::io::Read read_to_string() value is less than …\nAssert a std::io::Read read_to_string() value is less than …\nAssert a std::io::Read read_to_string() value is less than …\nAssert a std::io::Read read_to_string() value is less than …\nAssert a std::io::Read read_to_string() is a match to a …\nAssert a std::io::Read read_to_string() is a match to a …\nAssert a std::io::Read read_to_string() is not equal to …\nAssert a std::io::Read read_to_string() is not equal to …\nAssert a std::io::Read read_to_string() is not equal to an …\nAssert a std::io::Read read_to_string() is not equal to an …\nAssert a matcher is a match for an expression.\nAssert a matcher is a match for an expression.\nAssert an expression (such as a regex) is a match for an …\nAssert a value is less than or equal to an expression.\nAssert a value is less than or equal to an expression.\nAssert a value is less than or equal to an expression.\nAssert a value is less than an expression.\nAssert a value is less than an expression.\nAssert a value is less than an expression.\nAssert an expression is not equal to an expression.\nAssert an expression is not equal to an expression.\nAssert expression is None.\nAssert expression is None.\nAssert an expression.is_none() is true.\nAssert an expression (such as a string) does not contain …\nAssert an expression (such as a string) does not contain …\nAssert an expression (such as a string) does not contain …\nAssert an expression (such as a string) does not end with …\nAssert an expression (such as a string) does not end with …\nAssert an expression (such as a string) does not end with …\nAssert an expression (such as a regex) is not a match for …\nAssert an expression (such as a regex) is not a match for …\nAssert an expression (such as a regex) is not a match for …\nAssert an expression (such as a string) does not start …\nAssert an expression (such as a string) does not start …\nAssert an expression (such as a string) does not start …\nAssert expression is Ok(_).\nAssert expression is Ok(_).\nAssert expression is Ok(_).\nAssert two expressions are Ok(_) and their values are …\nAssert two expressions are Ok(_) and their values are …\nAssert two expressions are Ok(_) and their values are …\nAssert an expression is Ok(_) and its value is equal to an …\nAssert an expression is Ok(_) and its value is equal to an …\nAssert an expression is Ok(_) and its value is equal to an …\nAssert two expressions are Ok(_) and their values are not …\nAssert two expressions are Ok(_) and their values are not …\nAssert two expressions are Ok(_) and their values are not …\nAssert an expression is Ok(_) and its value is not equal …\nAssert an expression is Ok(_) and its value is equal to an …\nAssert an expression is Ok(_) and its value is equal to an …\nAssert macros for Option {Some, None}\nAssert expression is None.\nAssert an expression.is_none() is true.\nAssert expression is Some(_).\nAssert an expression.is_some() is true.\nAssert two expressions are Some(_) and their values are …\nAssert a.is_some() and a.unwrap() are equal to another.\nAssert two expressions are Some(_) and their values are …\nAssert two expressions are Some(_) and their values are …\nAssert an expression is Pending.\nAssert an expression is Pending.\nAssert an expression.is_pending() is true.\nAssert macros for Poll {Ready, Pending}\nAssert an expression is Pending.\nAssert an expression.is_pending() is true.\nAssert an expression is Ready(_).\nAssert an expression is Ready(_).\nAssert two expressions are Ready(_) and their values are …\nAssert two expressions are Ready(_) and their values are …\nAssert two expressions are Ready(_) and their values are …\nAssert two expressions are Ready(_) and their values are …\nAssert macros for comparing programs with arguments.\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert an expression is Ready(_).\nAssert an expression is Ready(_).\nAssert an expression is Ready(_).\nAssert two expressions are Ready(_) and their values are …\nAssert two expressions are Ready(_) and their values are …\nAssert two expressions are Ready(_) and their values are …\nAssert an expression is Ready(_) and its value is equal to …\nAssert an expression is Ready(_) and its value is equal to …\nAssert an expression is Ready(_) and its value is equal to …\nAssert two expressions are Ready(_) and their values are …\nAssert two expressions are Ready(_) and their values are …\nAssert two expressions are Ready(_) and their values are …\nAssert an expression is Ready(_) and its value is not …\nAssert an expression is Ready(_) and its value is not …\nAssert an expression is Ready(_) and its value is not …\nAssert macros for Result {Ok, Err}\nAssert expression is Err(_).\nAssert expression is Err(_).\nAssert expression is Ok(_).\nAssert expression is Ok(_).\nAssert two expressions are Ok(_) and their values are …\nAssert two expressions are Ok(_) and their values are …\nAssert two expressions are Ok(_) and their values are not …\nAssert two expressions are Ok(_) and their values are not …\nAssert macros for comparing set collections.\nAssert a set is disjoint with another.\nAssert a set is disjoint with another.\nAssert a set is equal to another.\nAssert a set is equal to another.\nAssert a set is joint with another.\nAssert a set is joint with another.\nAssert a set is not equal to another.\nAssert a set is not equal to another.\nAssert a set is a subset of another.\nAssert a set is a subset of another.\nAssert a set is a superset of another.\nAssert a set is a superset of another.\nAssert expression is Some(_).\nAssert expression is Some(_).\nAssert an expression.is_some() is true.\nAssert two expressions are Some(_) and their values are …\nAssert two expressions are Some(_) and their values are …\nAssert a.is_some() and a.unwrap() are equal to another.\nAssert an expression is Some(_) and its value is equal to …\nAssert an expression is Some(_) and its value is equal to …\nAssert a.is_some() and a.unwrap() are equal to another.\nAssert two expressions are Some(_) and their values are …\nAssert two expressions are Some(_) and their values are …\nAssert two expressions are Some(_) and their values are …\nAssert an expression is Some(_) and its value is not equal …\nAssert an expression is Some(_) and its value is not equal …\nAssert a.is_some() and a.unwrap() are equal to another.\nAssert an expression (such as a string) starts with an …\nAssert an expression (such as a string) starts with an …\nAssert an expression (such as a string) starts with an …\nAssert a number is approximately equal to another number.\nAssert a number is approximately not equal to another …\nAssert a bag is equal to another.\nAssert a bag is not equal to another.\nAssert a bag is a subbag of another.\nAssert a bag is a superbag of another.\nAssert a command stderr string contains a given containee.\nAssert a command stderr string is equal to another.\nAssert a command stderr string is equal to an expression.\nAssert a command stderr string is a match to a regex.\nAssert a command stdout string contains a given containee.\nAssert a command stdout string is equal to another.\nAssert a command stdout string is equal to an expression.\nAssert command stdout string is a match to a regex.\nAssert a container is a match for an expression.\nAssert an expression (such as a string) ends with an …\nAssert expression is Err(_).\nAssert two expressions are Err(_) and their values are …\nAssert an expression is Err(_) and its value is equal to …\nAssert two expressions are Err(_) and their values are not …\nAssert an expression is Err(_) and its value is equal to …\nAssert a function output is equal to another function …\nAssert a function output is equal to an expression.\nAssert a function error is equal to another.\nAssert a function error is equal to an expression.\nAssert a function error is greater than or equal to …\nAssert a function error is greater than or equal to an …\nAssert a function error is greater than another.\nAssert a function error is greater than an expression.\nAssert a function error is less than or equal to another.\nAssert a function error is less than or equal to an …\nAssert a function error is less than another.\nAssert a function error is less than an expression.\nAssert a function error is not equal to another.\nAssert a function error is not equal to an expression.\nAssert a function output is greater than or equal to …\nAssert a function output is greater than or equal to an …\nAssert a function output is greater than another.\nAssert a function output is greater than an expression.\nAssert a function output is less than or equal to another.\nAssert a function output is less than or equal to an …\nAssert a function output is less than another.\nAssert a function output is less than an expression.\nAssert a function output is not equal to another.\nAssert a function output is not equal to an expression.\nAssert a function Ok(…) is equal to another.\nAssert a function Ok(…) is equal to an expression.\nAssert a function Ok(…) is greater than or equal to …\nAssert a function Ok(…) is greater than or equal to an …\nAssert a function Ok(…) is greater than another.\nAssert a function Ok(…) is greater than an expression.\nAssert a function Ok(…) is less than or equal to another.\nAssert a function Ok(…) is less than or equal to an …\nAssert a function Ok(…) is less than another.\nAssert a function Ok(…) is less than an expression.\nAssert a function Ok(…) is not equal to another.\nAssert a function Ok(…) is not equal to an expression.\nAssert a std::fs::read_to_string(path) contains a pattern.\nAssert a std::fs::read_to_string(path) value is equal to …\nAssert a std::fs::read_to_string(path) value is equal to …\nAssert a std::fs::read_to_string(path) value is greater …\nAssert zzz.\nAssert a std::fs::read_to_string(path) value is greater …\nAssert a std::fs::read_to_string(path) value is greater …\nAssert a std::fs::read_to_string(path) value is less than …\nAssert a std::fs::read_to_string(path) value is less than …\nAssert a std::fs::read_to_string(path) value is less than …\nAssert a std::fs::read_to_string(path) value is less than …\nAssert a std::fs::read_to_string(path) is a match to a …\nAssert a std::fs::read_to_string(path) is not equal to …\nAssert a std::fs::read_to_string(path) is not equal to an …\nAssert a value is greater than or equal to an expression.\nAssert a value is greater than an expression.\nAssert a number is within delta of another number.\nAssert a number is within epsilon of another number.\nAssert a infix operator, such as assert_infix!(a == b).\nAssert a std::io::Read read_to_string() contains a pattern.\nAssert a std::io::Read read_to_string() value is equal to …\nAssert a std::io::Read read_to_string() value is equal to …\nAssert a std::io::Read read_to_string() value is greater …\nAssert zzz.\nAssert a std::io::Read read_to_string() value is greater …\nAssert a std::io::Read read_to_string() value is greater …\nAssert a std::io::Read read_to_string() value is less than …\nAssert a std::io::Read read_to_string() value is less than …\nAssert a std::io::Read read_to_string() value is less than …\nAssert a std::io::Read read_to_string() value is less than …\nAssert a std::io::Read read_to_string() is a match to a …\nAssert a std::io::Read read_to_string() is not equal to …\nAssert a std::io::Read read_to_string() is not equal to an …\nAssert a matcher is a match for an expression.\nAssert a value is less than or equal to an expression.\nAssert a value is less than an expression.\nAssert expression is None.\nAssert an expression (such as a string) does not contain …\nAssert an expression (such as a string) does not end with …\nAssert an expression (such as a regex) is not a match for …\nAssert an expression (such as a string) does not start …\nAssert expression is Ok(_).\nAssert two expressions are Ok(_) and their values are …\nAssert an expression is Ok(_) and its value is equal to an …\nAssert two expressions are Ok(_) and their values are not …\nAssert an expression is Ok(_) and its value is equal to an …\nAssert expression is None.\nAssert expression is Some(_).\nAssert two expressions are Some(_) and their values are …\nAssert two expressions are Some(_) and their values are …\nAssert an expression is Pending.\nAssert an expression is Pending.\nAssert poll.is_ready() is true.\nAssert two expressions are Ready(_) and their values are …\nAssert two expressions are Ready(_) and their values are …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert poll.is_ready() is true.\nAssert two expressions are Ready(_) and their values are …\nAssert an expression is Ready(_) and its value is equal to …\nAssert two expressions are Ready(_) and their values are …\nAssert an expression is Ready(_) and its value is not …\nAssert expression is Err(_).\nAssert expression is Ok(_).\nAssert two expressions are Ok(_) and their values are …\nAssert two expressions are Ok(_) and their values are not …\nAssert a set is disjoint with another.\nAssert a set is equal to another.\nAssert a set is joint with another.\nAssert a set is not equal to another.\nAssert a set is a subset of another.\nAssert a set is a superset of another.\nAssert expression is Some(_).\nAssert two expressions are Some(_) and their values are …\nAssert an expression is Some(_) and its value is equal to …\nAssert two expressions are Some(_) and their values are …\nAssert an expression is Some(_) and its value is not equal …\nAssert an expression (such as a string) starts with an …\nAssert a bag is equal to another.\nAssert a bag is not equal to another.\nAssert a bag is a subbag of another.\nAssert a bag is a superbag of another.\nAssert a command stderr string contains a given containee.\nAssert a command stderr string is equal to another.\nAssert a command stderr string is equal to an expression.\nAssert a command stderr string is a match to a regex.\nAssert a command stdout string contains a given containee.\nAssert a command stdout string is equal to another.\nAssert a command stdout string is equal to an expression.\nAssert command stdout string is a match to a regex.\nAssert a function output is equal to another function …\nAssert a function output is equal to an expression.\nAssert a function output is greater than or equal to …\nAssert a function output is greater than or equal to an …\nAssert a function output is greater than another.\nAssert a function output is greater than an expression.\nAssert a function output is less than or equal to another.\nAssert a function output is less than or equal to an …\nAssert a function output is less than another.\nAssert a function output is less than an expression.\nAssert a function output is not equal to another.\nAssert a function output is not equal to an expression.\nAssert a function Err(…) is equal to another.\nAssert a function Err(…) is equal to an expression.\nAssert a function Err(…) is greater than or equal to …\nAssert a function Err(…) is greater than or equal to an …\nAssert a function Err(…) is greater than another.\nAssert a function Err(…) is greater than an expression.\nAssert a function Err(…) is less than or equal to …\nAssert a function Err(…) is less than or equal to an …\nAssert a function Err(…) is less than another.\nAssert a function Err(…) is less than an expression.\nAssert a function Err(…) is not equal to another.\nAssert a function Err(…) is not equal to an expression.\nAssert a function Ok(…) is equal to another.\nAssert a function Ok(…) is equal to an expression.\nAssert a function Ok(…) is greater than or equal to …\nAssert a function Ok(…) is greater than or equal to an …\nAssert a function Ok(…) is greater than another.\nAssert a function Ok(…) is greater than an expression.\nAssert a function Ok(…) is less than or equal to another.\nAssert a function Ok(…) is less than or equal to an …\nAssert a function Ok(…) is less than another.\nAssert a function Ok(…) is less than an expression.\nAssert a function Ok(…) is not equal to another.\nAssert a function Ok(…) is not equal to an expression.\nAssert a std::fs::read_to_string(path) contains a pattern.\nAssert a std::fs::read_to_string(path) value is equal to …\nAssert a std::fs::read_to_string(path) value is equal to …\nAssert a std::fs::read_to_string(path) value is greater …\nAssert a std::fs::read_to_string(path) value is greater …\nAssert a std::fs::read_to_string(path) value is greater …\nAssert a std::fs::read_to_string(path) value is greater …\nAssert a std::fs::read_to_string(path) value is less than …\nAssert a std::fs::read_to_string(path) value is less than …\nAssert a std::fs::read_to_string(path) value is less than …\nAssert a std::fs::read_to_string(path) value is less than …\nAssert a std::fs::read_to_string(path) is a match to a …\nAssert a std::fs::read_to_string(path) is not equal to …\nAssert a std::fs::read_to_string(path) is not equal to an …\nAssert a std::io::Read read_to_string() contains a pattern.\nAssert a std::io::Read read_to_string() value is equal to …\nAssert a std::io::Read read_to_string() value is equal to …\nAssert a std::io::Read read_to_string() value is greater …\nAssert a std::io::Read read_to_string() value is greater …\nAssert a std::io::Read read_to_string() value is greater …\nAssert a std::io::Read read_to_string() value is greater …\nAssert a std::io::Read read_to_string() value is less than …\nAssert a std::io::Read read_to_string() value is less than …\nAssert a std::io::Read read_to_string() value is less than …\nAssert a std::io::Read read_to_string() value is less than …\nAssert a std::io::Read read_to_string() is a match to a …\nAssert a std::io::Read read_to_string() is not equal to …\nAssert a std::io::Read read_to_string() is not equal to an …\nAssert expression is None.\nAssert expression is Some(_).\nAssert two expressions are Some(_) and their values are …\nAssert two expressions are Some(_) and their values are …\nAssert an expression is Pending.\nAssert an expression is Ready(_).\nAssert two expressions are Ready(_) and their values are …\nAssert two expressions are Ready(_) and their values are …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert expression is Err(_).\nAssert expression is Ok(_).\nAssert two expressions are Ok(_) and their values are …\nAssert two expressions are Ok(_) and their values are not …\nAssert a set is disjoint with another.\nAssert a set is equal to another.\nAssert a set is joint with another.\nAssert a set is not equal to another.\nAssert a set is a subset of another.\nAssert a set is a superset of another.")
\ No newline at end of file
+searchState.loadedDescShard("lib", 0, "Assertables: Rust crate of assert macros for testing\nAssert a condition is true.\nAssert a number is approximately equal to another number.\nAssert a number is approximately equal to another number.\nAssert a number is approximately equal to another number.\nAssert a number is approximately not equal to another …\nAssert a number is approximately not equal to another …\nAssert a number is approximately not equal to another …\nAssert a condition is true.\nAssert macros for comparing bag collections.\nAssert a bag is equal to another.\nAssert a bag is equal to another.\nAssert a bag is not equal to another.\nAssert a bag is not equal to another.\nAssert a bag is a subbag of another.\nAssert a bag is a subbag of another.\nAssert a bag is a superbag of another.\nAssert a bag is a superbag of another.\nAssert macros for comparing commands and their stdout & …\nAssert a command stderr string contains a given containee.\nAssert a command stderr string contains a given containee.\nAssert a command stderr string is equal to another.\nAssert a command stderr string is equal to another.\nAssert a command stderr string is equal to an expression.\nAssert a command stderr string is equal to an expression.\nAssert a command stderr string is a match to a regex.\nAssert a command stderr string is a match to a regex.\nAssert a command stdout string contains a given containee.\nAssert a command stdout string contains a given containee.\nAssert a command stdout string is equal to another.\nAssert a command stdout string is equal to another.\nAssert a command stdout string is equal to an expression.\nAssert a command stdout string is equal to an expression.\nAssert command stdout string is a match to a regex.\nAssert command stdout string is a match to a regex.\nAssert a container is a match for an expression.\nAssert a container is a match for an expression.\nAssert an expression (such as a string) contains an …\nAssert an expression (such as a string) ends with an …\nAssert an expression (such as a string) ends with an …\nAssert an expression (such as a string) ends with an …\nAssert an expression is equal to another.\nAssert an expression is equal to another.\nAssert macros for Err(_) items.\nAssert expression is Err(_).\nAssert expression is Err(_).\nAssert two expressions are Err(_) and their values are …\nAssert two expressions are Err(_) and their values are …\nAssert an expression is Err(_) and its value is equal to …\nAssert an expression is Err(_) and its value is equal to …\nAssert two expressions are Err(_) and their values are not …\nAssert two expressions are Err(_) and their values are not …\nAssert an expression is Err(_) and its value is equal to …\nAssert an expression is Err(_) and its value is equal to …\nAssert macros for comparing functions.\nAssert a function output is equal to another function …\nAssert a function output is equal to another function …\nAssert a function output is equal to an expression.\nAssert a function output is equal to an expression.\nAssert macros for comparing functions that return errors.\nAssert a function error is equal to another.\nAssert a function error is equal to another.\nAssert a function error is equal to an expression.\nAssert a function error is equal to an expression.\nAssert a function error is greater than or equal to …\nAssert a function error is greater than or equal to …\nAssert a function error is greater than or equal to an …\nAssert a function error is greater than or equal to an …\nAssert a function error is greater than another.\nAssert a function error is greater than another.\nAssert a function error is greater than an expression.\nAssert a function error is greater than an expression.\nAssert a function error is less than or equal to another.\nAssert a function error is less than or equal to another.\nAssert a function error is less than or equal to an …\nAssert a function error is less than or equal to an …\nAssert a function error is less than another.\nAssert a function error is less than another.\nAssert a function error is less than an expression.\nAssert a function error is less than an expression.\nAssert a function error is not equal to another.\nAssert a function error is not equal to another.\nAssert a function error is not equal to an expression.\nAssert a function error is not equal to an expression.\nAssert a function output is greater than or equal to …\nAssert a function output is greater than or equal to …\nAssert a function output is greater than or equal to an …\nAssert a function output is greater than or equal to an …\nAssert a function output is greater than another.\nAssert a function output is greater than another.\nAssert a function output is greater than an expression.\nAssert a function output is greater than an expression.\nAssert a function output is less than or equal to another.\nAssert a function output is less than or equal to another.\nAssert a function output is less than or equal to an …\nAssert a function output is less than or equal to an …\nAssert a function output is less than another.\nAssert a function output is less than another.\nAssert a function output is less than an expression.\nAssert a function output is less than an expression.\nAssert a function output is not equal to another.\nAssert a function output is not equal to another.\nAssert a function output is not equal to an expression.\nAssert a function output is not equal to an expression.\nAssert macros for comparing functions that return …\nAssert a function Ok(…) is equal to another.\nAssert a function Ok(…) is equal to another.\nAssert a function Ok(…) is equal to an expression.\nAssert a function Ok(…) is equal to an expression.\nAssert a function Ok(…) is greater than or equal to …\nAssert a function Ok(…) is greater than or equal to …\nAssert a function Ok(…) is greater than or equal to an …\nAssert a function Ok(…) is greater than or equal to an …\nAssert a function Ok(…) is greater than another.\nAssert a function Ok(…) is greater than another.\nAssert a function Ok(…) is greater than an expression.\nAssert a function Ok(…) is greater than an expression.\nAssert a function Ok(…) is less than or equal to another.\nAssert a function Ok(…) is less than or equal to another.\nAssert a function Ok(…) is less than or equal to an …\nAssert a function Ok(…) is less than or equal to an …\nAssert a function Ok(…) is less than another.\nAssert a function Ok(…) is less than another.\nAssert a function Ok(…) is less than an expression.\nAssert a function Ok(…) is less than an expression.\nAssert a function Ok(…) is not equal to another.\nAssert a function Ok(…) is not equal to another.\nAssert a function Ok(…) is not equal to an expression.\nAssert a function Ok(…) is not equal to an expression.\nAssert macros for comparing file system path contents.\nAssert a std::fs::read_to_string(path) contains a pattern.\nAssert a std::fs::read_to_string(path) contains a pattern.\nAssert a std::fs::read_to_string(path) value is equal to …\nAssert a std::fs::read_to_string(path) is equal to another.\nAssert a std::fs::read_to_string(path) value is equal to …\nAssert a std::fs::read_to_string(path) value is equal to …\nAssert a std::fs::read_to_string(path) value is greater …\nAssert a std::fs::read_to_string(path) value is greater …\nAssert a std::fs::read_to_string(path) value is greater …\nAssert a std::fs::read_to_string(path) value is greater …\nAssert a std::fs::read_to_string(path) value is greater …\nAssert a std::fs::read_to_string(path) value is greater …\nAssert a std::fs::read_to_string(path) value is greater …\nAssert a std::fs::read_to_string(path) value is greater …\nAssert a std::fs::read_to_string(path) value is less than …\nAssert a std::fs::read_to_string(path) value is less than …\nAssert a std::fs::read_to_string(path) value is less than …\nAssert a std::fs::read_to_string(path) value is less than …\nAssert a std::fs::read_to_string(path) value is less than …\nAssert a std::fs::read_to_string(path) value is less than …\nAssert a std::fs::read_to_string(path) value is less than …\nAssert a std::fs::read_to_string(path) value is less than …\nAssert a std::fs::read_to_string(path) is a match to a …\nAssert a std::fs::read_to_string(path) is a match to a …\nAssert a std::fs::read_to_string(path) is not equal to …\nAssert a std::fs::read_to_string(path) is not equal to …\nAssert a std::fs::read_to_string(path) is not equal to an …\nAssert a std::fs::read_to_string(path) is not equal to an …\nAssert a value is greater than or equal to an expression.\nAssert a value is greater than or equal to an expression.\nAssert a value is greater than or equal to an expression.\nAssert a value is greater than an expression.\nAssert a value is greater than an expression.\nAssert a value is greater than an expression.\nAssert a number is within delta of another number.\nAssert a number is within delta of another number.\nAssert a number is within delta of another number.\nAssert a number is within epsilon of another number.\nAssert a number is within epsilon of another number.\nAssert a number is within epsilon of another number.\nAssert a infix operator, such as assert_infix!(a == b).\nAssert a infix operator, such as assert_infix!(a == b).\nAssert a infix operator, such as assert_infix!(a == b).\nAssert macros for comparing input/output reader streams.\nAssert a std::io::Read read_to_string() contains a pattern.\nAssert a std::io::Read read_to_string() contains a pattern.\nAssert a std::io::Read read_to_string() value is equal to …\nAssert a std::io::Read read_to_string() is equal to …\nAssert a std::io::Read read_to_string() value is equal to …\nAssert a std::io::Read read_to_string() value is equal to …\nAssert a std::io::Read read_to_string() value is greater …\nAssert a std::io::Read read_to_string() value is greater …\nAssert a std::io::Read read_to_string() value is greater …\nAssert a std::io::Read read_to_string() value is greater …\nAssert a std::io::Read read_to_string() value is greater …\nAssert a std::io::Read read_to_string() value is greater …\nAssert a std::io::Read read_to_string() value is greater …\nAssert a std::io::Read read_to_string() value is greater …\nAssert a std::io::Read read_to_string() value is less than …\nAssert a std::io::Read read_to_string() value is less than …\nAssert a std::io::Read read_to_string() value is less than …\nAssert a std::io::Read read_to_string() value is less than …\nAssert a std::io::Read read_to_string() value is less than …\nAssert a std::io::Read read_to_string() value is less than …\nAssert a std::io::Read read_to_string() value is less than …\nAssert a std::io::Read read_to_string() value is less than …\nAssert a std::io::Read read_to_string() is a match to a …\nAssert a std::io::Read read_to_string() is a match to a …\nAssert a std::io::Read read_to_string() is not equal to …\nAssert a std::io::Read read_to_string() is not equal to …\nAssert a std::io::Read read_to_string() is not equal to an …\nAssert a std::io::Read read_to_string() is not equal to an …\nAssert a matcher is a match for an expression.\nAssert a matcher is a match for an expression.\nAssert an expression (such as a regex) is a match for an …\nAssert a value is less than or equal to an expression.\nAssert a value is less than or equal to an expression.\nAssert a value is less than or equal to an expression.\nAssert a value is less than an expression.\nAssert a value is less than an expression.\nAssert a value is less than an expression.\nAssert an expression is not equal to an expression.\nAssert an expression is not equal to an expression.\nAssert macro for None items.\nAssert expression is None.\nAssert an expression.is_none() is true.\nAssert an expression (such as a string) does not contain …\nAssert an expression (such as a string) does not contain …\nAssert an expression (such as a string) does not contain …\nAssert an expression (such as a string) does not end with …\nAssert an expression (such as a string) does not end with …\nAssert an expression (such as a string) does not end with …\nAssert an expression (such as a regex) is not a match for …\nAssert an expression (such as a regex) is not a match for …\nAssert an expression (such as a regex) is not a match for …\nAssert an expression (such as a string) does not start …\nAssert an expression (such as a string) does not start …\nAssert an expression (such as a string) does not start …\nAssert macros for Ok(_) items.\nAssert expression is Ok(_).\nAssert expression is Ok(_).\nAssert two expressions are Ok(_) and their values are …\nAssert two expressions are Ok(_) and their values are …\nAssert an expression is Ok(_) and its value is equal to an …\nAssert an expression is Ok(_) and its value is equal to an …\nAssert two expressions are Ok(_) and their values are not …\nAssert two expressions are Ok(_) and their values are not …\nAssert an expression is Ok(_) and its value is equal to an …\nAssert an expression is Ok(_) and its value is equal to an …\nAssert macros for Option {Some, None}\nAssert expression is None.\nAssert an expression.is_none() is true.\nAssert expression is Some(_).\nAssert an expression.is_some() is true.\nAssert two expressions are Some(_) and their values are …\nAssert a.is_some() and a.unwrap() are equal to another.\nAssert two expressions are Some(_) and their values are …\nAssert two expressions are Some(_) and their values are …\nAssert macro for Pending items.\nAssert an expression is Pending.\nAssert an expression.is_pending() is true.\nAssert macros for Poll {Ready, Pending}\nAssert an expression is Pending.\nAssert an expression.is_pending() is true.\nAssert an expression is Ready(_).\nAssert an expression is Ready(_).\nAssert two expressions are Ready(_) and their values are …\nAssert two expressions are Ready(_) and their values are …\nAssert two expressions are Ready(_) and their values are …\nAssert two expressions are Ready(_) and their values are …\nAssert macros for comparing programs with arguments.\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert macros for Ready(_) items.\nAssert an expression is Ready(_).\nAssert an expression is Ready(_).\nAssert two expressions are Ready(_) and their values are …\nAssert two expressions are Ready(_) and their values are …\nAssert an expression is Ready(_) and its value is equal to …\nAssert an expression is Ready(_) and its value is equal to …\nAssert two expressions are Ready(_) and their values are …\nAssert two expressions are Ready(_) and their values are …\nAssert an expression is Ready(_) and its value is not …\nAssert an expression is Ready(_) and its value is not …\nAssert macros for Result {Ok, Err}\nAssert expression is Err(_).\nAssert expression is Err(_).\nAssert expression is Ok(_).\nAssert expression is Ok(_).\nAssert two expressions are Ok(_) and their values are …\nAssert two expressions are Ok(_) and their values are …\nAssert two expressions are Ok(_) and their values are not …\nAssert two expressions are Ok(_) and their values are not …\nAssert macros for comparing set collections.\nAssert a set is disjoint with another.\nAssert a set is disjoint with another.\nAssert a set is equal to another.\nAssert a set is equal to another.\nAssert a set is joint with another.\nAssert a set is joint with another.\nAssert a set is not equal to another.\nAssert a set is not equal to another.\nAssert a set is a subset of another.\nAssert a set is a subset of another.\nAssert a set is a superset of another.\nAssert a set is a superset of another.\nAssert macros for Some(_) items.\nAssert expression is Some(_).\nAssert an expression.is_some() is true.\nAssert two expressions are Some(_) and their values are …\nAssert a.is_some() and a.unwrap() are equal to another.\nAssert an expression is Some(_) and its value is equal to …\nAssert a.is_some() and a.unwrap() are equal to another.\nAssert two expressions are Some(_) and their values are …\nAssert two expressions are Some(_) and their values are …\nAssert an expression is Some(_) and its value is not equal …\nAssert a.is_some() and a.unwrap() are equal to another.\nAssert an expression (such as a string) starts with an …\nAssert an expression (such as a string) starts with an …\nAssert an expression (such as a string) starts with an …\nAssert a number is approximately equal to another number.\nAssert a number is approximately not equal to another …\nAssert a bag is equal to another.\nAssert a bag is not equal to another.\nAssert a bag is a subbag of another.\nAssert a bag is a superbag of another.\nAssert a command stderr string contains a given containee.\nAssert a command stderr string is equal to another.\nAssert a command stderr string is equal to an expression.\nAssert a command stderr string is a match to a regex.\nAssert a command stdout string contains a given containee.\nAssert a command stdout string is equal to another.\nAssert a command stdout string is equal to an expression.\nAssert command stdout string is a match to a regex.\nAssert a container is a match for an expression.\nAssert an expression (such as a string) ends with an …\nAssert expression is Err(_).\nAssert two expressions are Err(_) and their values are …\nAssert an expression is Err(_) and its value is equal to …\nAssert two expressions are Err(_) and their values are not …\nAssert an expression is Err(_) and its value is equal to …\nAssert a function output is equal to another function …\nAssert a function output is equal to an expression.\nAssert a function error is equal to another.\nAssert a function error is equal to an expression.\nAssert a function error is greater than or equal to …\nAssert a function error is greater than or equal to an …\nAssert a function error is greater than another.\nAssert a function error is greater than an expression.\nAssert a function error is less than or equal to another.\nAssert a function error is less than or equal to an …\nAssert a function error is less than another.\nAssert a function error is less than an expression.\nAssert a function error is not equal to another.\nAssert a function error is not equal to an expression.\nAssert a function output is greater than or equal to …\nAssert a function output is greater than or equal to an …\nAssert a function output is greater than another.\nAssert a function output is greater than an expression.\nAssert a function output is less than or equal to another.\nAssert a function output is less than or equal to an …\nAssert a function output is less than another.\nAssert a function output is less than an expression.\nAssert a function output is not equal to another.\nAssert a function output is not equal to an expression.\nAssert a function Ok(…) is equal to another.\nAssert a function Ok(…) is equal to an expression.\nAssert a function Ok(…) is greater than or equal to …\nAssert a function Ok(…) is greater than or equal to an …\nAssert a function Ok(…) is greater than another.\nAssert a function Ok(…) is greater than an expression.\nAssert a function Ok(…) is less than or equal to another.\nAssert a function Ok(…) is less than or equal to an …\nAssert a function Ok(…) is less than another.\nAssert a function Ok(…) is less than an expression.\nAssert a function Ok(…) is not equal to another.\nAssert a function Ok(…) is not equal to an expression.\nAssert a std::fs::read_to_string(path) contains a pattern.\nAssert a std::fs::read_to_string(path) value is equal to …\nAssert a std::fs::read_to_string(path) value is equal to …\nAssert a std::fs::read_to_string(path) value is greater …\nAssert zzz.\nAssert a std::fs::read_to_string(path) value is greater …\nAssert a std::fs::read_to_string(path) value is greater …\nAssert a std::fs::read_to_string(path) value is less than …\nAssert a std::fs::read_to_string(path) value is less than …\nAssert a std::fs::read_to_string(path) value is less than …\nAssert a std::fs::read_to_string(path) value is less than …\nAssert a std::fs::read_to_string(path) is a match to a …\nAssert a std::fs::read_to_string(path) is not equal to …\nAssert a std::fs::read_to_string(path) is not equal to an …\nAssert a value is greater than or equal to an expression.\nAssert a value is greater than an expression.\nAssert a number is within delta of another number.\nAssert a number is within epsilon of another number.\nAssert a infix operator, such as assert_infix!(a == b).\nAssert a std::io::Read read_to_string() contains a pattern.\nAssert a std::io::Read read_to_string() value is equal to …\nAssert a std::io::Read read_to_string() value is equal to …\nAssert a std::io::Read read_to_string() value is greater …\nAssert zzz.\nAssert a std::io::Read read_to_string() value is greater …\nAssert a std::io::Read read_to_string() value is greater …\nAssert a std::io::Read read_to_string() value is less than …\nAssert a std::io::Read read_to_string() value is less than …\nAssert a std::io::Read read_to_string() value is less than …\nAssert a std::io::Read read_to_string() value is less than …\nAssert a std::io::Read read_to_string() is a match to a …\nAssert a std::io::Read read_to_string() is not equal to …\nAssert a std::io::Read read_to_string() is not equal to an …\nAssert a matcher is a match for an expression.\nAssert a value is less than or equal to an expression.\nAssert a value is less than an expression.\nAssert expression is None.\nAssert an expression (such as a string) does not contain …\nAssert an expression (such as a string) does not end with …\nAssert an expression (such as a regex) is not a match for …\nAssert an expression (such as a string) does not start …\nAssert expression is Ok(_).\nAssert two expressions are Ok(_) and their values are …\nAssert an expression is Ok(_) and its value is equal to an …\nAssert two expressions are Ok(_) and their values are not …\nAssert an expression is Ok(_) and its value is equal to an …\nAssert expression is None.\nAssert expression is Some(_).\nAssert two expressions are Some(_) and their values are …\nAssert two expressions are Some(_) and their values are …\nAssert an expression is Pending.\nAssert an expression is Pending.\nAssert poll.is_ready() is true.\nAssert two expressions are Ready(_) and their values are …\nAssert two expressions are Ready(_) and their values are …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert poll.is_ready() is true.\nAssert two expressions are Ready(_) and their values are …\nAssert an expression is Ready(_) and its value is equal to …\nAssert two expressions are Ready(_) and their values are …\nAssert an expression is Ready(_) and its value is not …\nAssert expression is Err(_).\nAssert expression is Ok(_).\nAssert two expressions are Ok(_) and their values are …\nAssert two expressions are Ok(_) and their values are not …\nAssert a set is disjoint with another.\nAssert a set is equal to another.\nAssert a set is joint with another.\nAssert a set is not equal to another.\nAssert a set is a subset of another.\nAssert a set is a superset of another.\nAssert expression is Some(_).\nAssert two expressions are Some(_) and their values are …\nAssert an expression is Some(_) and its value is equal to …\nAssert two expressions are Some(_) and their values are …\nAssert an expression is Some(_) and its value is not equal …\nAssert an expression (such as a string) starts with an …\nAssert a bag is equal to another.\nAssert a bag is not equal to another.\nAssert a bag is a subbag of another.\nAssert a bag is a superbag of another.\nAssert a command stderr string contains a given containee.\nAssert a command stderr string is equal to another.\nAssert a command stderr string is equal to an expression.\nAssert a command stderr string is a match to a regex.\nAssert a command stdout string contains a given containee.\nAssert a command stdout string is equal to another.\nAssert a command stdout string is equal to an expression.\nAssert command stdout string is a match to a regex.\nAssert expression is Err(_).\nAssert two expressions are Err(_) and their values are …\nAssert an expression is Err(_) and its value is equal to …\nAssert two expressions are Err(_) and their values are not …\nAssert an expression is Err(_) and its value is not equal …\nAssert a function output is equal to another function …\nAssert a function output is equal to an expression.\nAssert a function output is greater than or equal to …\nAssert a function output is greater than or equal to an …\nAssert a function output is greater than another.\nAssert a function output is greater than an expression.\nAssert a function output is less than or equal to another.\nAssert a function output is less than or equal to an …\nAssert a function output is less than another.\nAssert a function output is less than an expression.\nAssert a function output is not equal to another.\nAssert a function output is not equal to an expression.\nAssert a function Err(…) is equal to another.\nAssert a function Err(…) is equal to an expression.\nAssert a function Err(…) is greater than or equal to …\nAssert a function Err(…) is greater than or equal to an …\nAssert a function Err(…) is greater than another.\nAssert a function Err(…) is greater than an expression.\nAssert a function Err(…) is less than or equal to …\nAssert a function Err(…) is less than or equal to an …\nAssert a function Err(…) is less than another.\nAssert a function Err(…) is less than an expression.\nAssert a function Err(…) is not equal to another.\nAssert a function Err(…) is not equal to an expression.\nAssert a function Ok(…) is equal to another.\nAssert a function Ok(…) is equal to an expression.\nAssert a function Ok(…) is greater than or equal to …\nAssert a function Ok(…) is greater than or equal to an …\nAssert a function Ok(…) is greater than another.\nAssert a function Ok(…) is greater than an expression.\nAssert a function Ok(…) is less than or equal to another.\nAssert a function Ok(…) is less than or equal to an …\nAssert a function Ok(…) is less than another.\nAssert a function Ok(…) is less than an expression.\nAssert a function Ok(…) is not equal to another.\nAssert a function Ok(…) is not equal to an expression.\nAssert a std::fs::read_to_string(path) contains a pattern.\nAssert a std::fs::read_to_string(path) value is equal to …\nAssert a std::fs::read_to_string(path) value is equal to …\nAssert a std::fs::read_to_string(path) value is greater …\nAssert a std::fs::read_to_string(path) value is greater …\nAssert a std::fs::read_to_string(path) value is greater …\nAssert a std::fs::read_to_string(path) value is greater …\nAssert a std::fs::read_to_string(path) value is less than …\nAssert a std::fs::read_to_string(path) value is less than …\nAssert a std::fs::read_to_string(path) value is less than …\nAssert a std::fs::read_to_string(path) value is less than …\nAssert a std::fs::read_to_string(path) is a match to a …\nAssert a std::fs::read_to_string(path) is not equal to …\nAssert a std::fs::read_to_string(path) is not equal to an …\nAssert a std::io::Read read_to_string() contains a pattern.\nAssert a std::io::Read read_to_string() value is equal to …\nAssert a std::io::Read read_to_string() value is equal to …\nAssert a std::io::Read read_to_string() value is greater …\nAssert a std::io::Read read_to_string() value is greater …\nAssert a std::io::Read read_to_string() value is greater …\nAssert a std::io::Read read_to_string() value is greater …\nAssert a std::io::Read read_to_string() value is less than …\nAssert a std::io::Read read_to_string() value is less than …\nAssert a std::io::Read read_to_string() value is less than …\nAssert a std::io::Read read_to_string() value is less than …\nAssert a std::io::Read read_to_string() is a match to a …\nAssert a std::io::Read read_to_string() is not equal to …\nAssert a std::io::Read read_to_string() is not equal to an …\nAssert expression is None.\nAssert expression is Ok(_).\nAssert two expressions are Ok(_) and their values are …\nAssert an expression is Ok(_) and its value is equal to an …\nAssert two expressions are Ok(_) and their values are not …\nAssert an expression is Ok(_) and its value is not equal …\nAssert expression is None.\nAssert expression is Some(_).\nAssert two expressions are Some(_) and their values are …\nAssert two expressions are Some(_) and their values are …\nAssert an expression is Pending.\nAssert an expression is Pending.\nAssert an expression is Ready(_).\nAssert two expressions are Ready(_) and their values are …\nAssert two expressions are Ready(_) and their values are …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stderr …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert a command (built with program and args) stdout …\nAssert an expression is Ready(_).\nAssert two expressions are Ready(_) and their values are …\nAssert an expression is Ready(_) and its value is equal to …\nAssert two expressions are Ready(_) and their values are …\nAssert an expression is Ready(_) and its value is not …\nAssert expression is Err(_).\nAssert expression is Ok(_).\nAssert two expressions are Ok(_) and their values are …\nAssert two expressions are Ok(_) and their values are not …\nAssert a set is disjoint with another.\nAssert a set is equal to another.\nAssert a set is joint with another.\nAssert a set is not equal to another.\nAssert a set is a subset of another.\nAssert a set is a superset of another.\nAssert expression is Some(_).\nAssert two expressions are Some(_) and their values are …\nAssert an expression is Some(_) and its value is equal to …\nAssert two expressions are Some(_) and their values are …\nAssert an expression is Some(_) and its value is not equal …")
\ No newline at end of file
diff --git a/doc/src-files.js b/doc/src-files.js
index aaed55fa5..70ba65021 100644
--- a/doc/src-files.js
+++ b/doc/src-files.js
@@ -1,4 +1,4 @@
 var srcIndex = new Map(JSON.parse('[\
-["lib",["",[["assert_bag",[],["assert_bag_eq.rs","assert_bag_ne.rs","assert_bag_subbag.rs","assert_bag_superbag.rs","mod.rs"]],["assert_command",[],["assert_command_stderr_contains.rs","assert_command_stderr_eq.rs","assert_command_stderr_eq_expr.rs","assert_command_stderr_is_match.rs","assert_command_stdout_contains.rs","assert_command_stdout_eq.rs","assert_command_stdout_eq_expr.rs","assert_command_stdout_is_match.rs","mod.rs"]],["assert_fn",[],["assert_fn_eq.rs","assert_fn_eq_expr.rs","assert_fn_ge.rs","assert_fn_ge_expr.rs","assert_fn_gt.rs","assert_fn_gt_expr.rs","assert_fn_le.rs","assert_fn_le_expr.rs","assert_fn_lt.rs","assert_fn_lt_expr.rs","assert_fn_ne.rs","assert_fn_ne_expr.rs","mod.rs"]],["assert_fn_err",[],["assert_fn_err_eq.rs","assert_fn_err_eq_expr.rs","assert_fn_err_ge.rs","assert_fn_err_ge_expr.rs","assert_fn_err_gt.rs","assert_fn_err_gt_expr.rs","assert_fn_err_le.rs","assert_fn_err_le_expr.rs","assert_fn_err_lt.rs","assert_fn_err_lt_expr.rs","assert_fn_err_ne.rs","assert_fn_err_ne_expr.rs","mod.rs"]],["assert_fn_ok",[],["assert_fn_ok_eq.rs","assert_fn_ok_eq_expr.rs","assert_fn_ok_ge.rs","assert_fn_ok_ge_expr.rs","assert_fn_ok_gt.rs","assert_fn_ok_gt_expr.rs","assert_fn_ok_le.rs","assert_fn_ok_le_expr.rs","assert_fn_ok_lt.rs","assert_fn_ok_lt_expr.rs","assert_fn_ok_ne.rs","assert_fn_ok_ne_expr.rs","mod.rs"]],["assert_fs_read_to_string",[],["assert_fs_read_to_string_contains.rs","assert_fs_read_to_string_eq.rs","assert_fs_read_to_string_eq_expr.rs","assert_fs_read_to_string_ge.rs","assert_fs_read_to_string_ge_expr.rs","assert_fs_read_to_string_gt.rs","assert_fs_read_to_string_gt_expr.rs","assert_fs_read_to_string_le.rs","assert_fs_read_to_string_le_expr.rs","assert_fs_read_to_string_lt.rs","assert_fs_read_to_string_lt_expr.rs","assert_fs_read_to_string_matches.rs","assert_fs_read_to_string_ne.rs","assert_fs_read_to_string_ne_expr.rs","mod.rs"]],["assert_io_read_to_string",[],["assert_io_read_to_string_contains.rs","assert_io_read_to_string_eq.rs","assert_io_read_to_string_eq_expr.rs","assert_io_read_to_string_ge.rs","assert_io_read_to_string_ge_expr.rs","assert_io_read_to_string_gt.rs","assert_io_read_to_string_gt_expr.rs","assert_io_read_to_string_le.rs","assert_io_read_to_string_le_expr.rs","assert_io_read_to_string_lt.rs","assert_io_read_to_string_lt_expr.rs","assert_io_read_to_string_matches.rs","assert_io_read_to_string_ne.rs","assert_io_read_to_string_ne_expr.rs","mod.rs"]],["assert_option",[],["assert_option_none.rs","assert_option_some.rs","assert_option_some_eq.rs","assert_option_some_ne.rs","mod.rs"]],["assert_poll",[],["assert_poll_pending.rs","assert_poll_ready.rs","assert_poll_ready_eq.rs","assert_poll_ready_ne.rs","mod.rs"]],["assert_program_args",[],["assert_program_args_stderr_contains.rs","assert_program_args_stderr_eq.rs","assert_program_args_stderr_eq_expr.rs","assert_program_args_stderr_ge.rs","assert_program_args_stderr_ge_expr.rs","assert_program_args_stderr_gt.rs","assert_program_args_stderr_gt_expr.rs","assert_program_args_stderr_is_match.rs","assert_program_args_stderr_le.rs","assert_program_args_stderr_le_expr.rs","assert_program_args_stderr_lt.rs","assert_program_args_stderr_lt_expr.rs","assert_program_args_stderr_ne.rs","assert_program_args_stderr_ne_expr.rs","assert_program_args_stdout_contains.rs","assert_program_args_stdout_eq.rs","assert_program_args_stdout_eq_expr.rs","assert_program_args_stdout_ge.rs","assert_program_args_stdout_ge_expr.rs","assert_program_args_stdout_gt.rs","assert_program_args_stdout_gt_expr.rs","assert_program_args_stdout_is_match.rs","assert_program_args_stdout_le.rs","assert_program_args_stdout_le_expr.rs","assert_program_args_stdout_lt.rs","assert_program_args_stdout_lt_expr.rs","assert_program_args_stdout_ne.rs","assert_program_args_stdout_ne_expr.rs","mod.rs"]],["assert_result",[],["assert_result_err.rs","assert_result_ok.rs","assert_result_ok_eq.rs","assert_result_ok_ne.rs","mod.rs"]],["assert_set",[],["assert_set_disjoint.rs","assert_set_eq.rs","assert_set_joint.rs","assert_set_ne.rs","assert_set_subset.rs","assert_set_superset.rs","mod.rs"]]],["assert.rs","assert_approx_eq.rs","assert_approx_ne.rs","assert_contains.rs","assert_ends_with.rs","assert_eq.rs","assert_err.rs","assert_err_eq.rs","assert_err_eq_expr.rs","assert_err_ne.rs","assert_err_ne_expr.rs","assert_ge.rs","assert_gt.rs","assert_in_delta.rs","assert_in_epsilon.rs","assert_infix.rs","assert_is_match.rs","assert_le.rs","assert_lt.rs","assert_ne.rs","assert_none.rs","assert_not_contains.rs","assert_not_ends_with.rs","assert_not_match.rs","assert_not_starts_with.rs","assert_ok.rs","assert_ok_eq.rs","assert_ok_eq_expr.rs","assert_ok_ne.rs","assert_ok_ne_expr.rs","assert_pending.rs","assert_ready.rs","assert_ready_eq.rs","assert_ready_eq_expr.rs","assert_ready_ne.rs","assert_ready_ne_expr.rs","assert_some.rs","assert_some_eq.rs","assert_some_eq_expr.rs","assert_some_ne.rs","assert_some_ne_expr.rs","assert_starts_with.rs","lib.rs"]]]\
+["lib",["",[["assert_bag",[],["assert_bag_eq.rs","assert_bag_ne.rs","assert_bag_subbag.rs","assert_bag_superbag.rs","mod.rs"]],["assert_command",[],["assert_command_stderr_contains.rs","assert_command_stderr_eq.rs","assert_command_stderr_eq_expr.rs","assert_command_stderr_is_match.rs","assert_command_stdout_contains.rs","assert_command_stdout_eq.rs","assert_command_stdout_eq_expr.rs","assert_command_stdout_is_match.rs","mod.rs"]],["assert_err",[],["assert_err.rs","assert_err_eq.rs","assert_err_eq_expr.rs","assert_err_ne.rs","assert_err_ne_expr.rs","mod.rs"]],["assert_fn",[],["assert_fn_eq.rs","assert_fn_eq_expr.rs","assert_fn_ge.rs","assert_fn_ge_expr.rs","assert_fn_gt.rs","assert_fn_gt_expr.rs","assert_fn_le.rs","assert_fn_le_expr.rs","assert_fn_lt.rs","assert_fn_lt_expr.rs","assert_fn_ne.rs","assert_fn_ne_expr.rs","mod.rs"]],["assert_fn_err",[],["assert_fn_err_eq.rs","assert_fn_err_eq_expr.rs","assert_fn_err_ge.rs","assert_fn_err_ge_expr.rs","assert_fn_err_gt.rs","assert_fn_err_gt_expr.rs","assert_fn_err_le.rs","assert_fn_err_le_expr.rs","assert_fn_err_lt.rs","assert_fn_err_lt_expr.rs","assert_fn_err_ne.rs","assert_fn_err_ne_expr.rs","mod.rs"]],["assert_fn_ok",[],["assert_fn_ok_eq.rs","assert_fn_ok_eq_expr.rs","assert_fn_ok_ge.rs","assert_fn_ok_ge_expr.rs","assert_fn_ok_gt.rs","assert_fn_ok_gt_expr.rs","assert_fn_ok_le.rs","assert_fn_ok_le_expr.rs","assert_fn_ok_lt.rs","assert_fn_ok_lt_expr.rs","assert_fn_ok_ne.rs","assert_fn_ok_ne_expr.rs","mod.rs"]],["assert_fs_read_to_string",[],["assert_fs_read_to_string_contains.rs","assert_fs_read_to_string_eq.rs","assert_fs_read_to_string_eq_expr.rs","assert_fs_read_to_string_ge.rs","assert_fs_read_to_string_ge_expr.rs","assert_fs_read_to_string_gt.rs","assert_fs_read_to_string_gt_expr.rs","assert_fs_read_to_string_le.rs","assert_fs_read_to_string_le_expr.rs","assert_fs_read_to_string_lt.rs","assert_fs_read_to_string_lt_expr.rs","assert_fs_read_to_string_matches.rs","assert_fs_read_to_string_ne.rs","assert_fs_read_to_string_ne_expr.rs","mod.rs"]],["assert_io_read_to_string",[],["assert_io_read_to_string_contains.rs","assert_io_read_to_string_eq.rs","assert_io_read_to_string_eq_expr.rs","assert_io_read_to_string_ge.rs","assert_io_read_to_string_ge_expr.rs","assert_io_read_to_string_gt.rs","assert_io_read_to_string_gt_expr.rs","assert_io_read_to_string_le.rs","assert_io_read_to_string_le_expr.rs","assert_io_read_to_string_lt.rs","assert_io_read_to_string_lt_expr.rs","assert_io_read_to_string_matches.rs","assert_io_read_to_string_ne.rs","assert_io_read_to_string_ne_expr.rs","mod.rs"]],["assert_none",[],["assert_none.rs","mod.rs"]],["assert_ok",[],["assert_ok.rs","assert_ok_eq.rs","assert_ok_eq_expr.rs","assert_ok_ne.rs","assert_ok_ne_expr.rs","mod.rs"]],["assert_option",[],["assert_option_none.rs","assert_option_some.rs","assert_option_some_eq.rs","assert_option_some_ne.rs","mod.rs"]],["assert_pending",[],["assert_pending.rs","mod.rs"]],["assert_poll",[],["assert_poll_pending.rs","assert_poll_ready.rs","assert_poll_ready_eq.rs","assert_poll_ready_ne.rs","mod.rs"]],["assert_program_args",[],["assert_program_args_stderr_contains.rs","assert_program_args_stderr_eq.rs","assert_program_args_stderr_eq_expr.rs","assert_program_args_stderr_ge.rs","assert_program_args_stderr_ge_expr.rs","assert_program_args_stderr_gt.rs","assert_program_args_stderr_gt_expr.rs","assert_program_args_stderr_is_match.rs","assert_program_args_stderr_le.rs","assert_program_args_stderr_le_expr.rs","assert_program_args_stderr_lt.rs","assert_program_args_stderr_lt_expr.rs","assert_program_args_stderr_ne.rs","assert_program_args_stderr_ne_expr.rs","assert_program_args_stdout_contains.rs","assert_program_args_stdout_eq.rs","assert_program_args_stdout_eq_expr.rs","assert_program_args_stdout_ge.rs","assert_program_args_stdout_ge_expr.rs","assert_program_args_stdout_gt.rs","assert_program_args_stdout_gt_expr.rs","assert_program_args_stdout_is_match.rs","assert_program_args_stdout_le.rs","assert_program_args_stdout_le_expr.rs","assert_program_args_stdout_lt.rs","assert_program_args_stdout_lt_expr.rs","assert_program_args_stdout_ne.rs","assert_program_args_stdout_ne_expr.rs","mod.rs"]],["assert_ready",[],["assert_ready.rs","assert_ready_eq.rs","assert_ready_eq_expr.rs","assert_ready_ne.rs","assert_ready_ne_expr.rs","mod.rs"]],["assert_result",[],["assert_result_err.rs","assert_result_ok.rs","assert_result_ok_eq.rs","assert_result_ok_ne.rs","mod.rs"]],["assert_set",[],["assert_set_disjoint.rs","assert_set_eq.rs","assert_set_joint.rs","assert_set_ne.rs","assert_set_subset.rs","assert_set_superset.rs","mod.rs"]],["assert_some",[],["assert_some.rs","assert_some_eq.rs","assert_some_eq_expr.rs","assert_some_ne.rs","assert_some_ne_expr.rs","mod.rs"]]],["assert.rs","assert_approx_eq.rs","assert_approx_ne.rs","assert_contains.rs","assert_ends_with.rs","assert_eq.rs","assert_ge.rs","assert_gt.rs","assert_in_delta.rs","assert_in_epsilon.rs","assert_infix.rs","assert_is_match.rs","assert_le.rs","assert_lt.rs","assert_ne.rs","assert_not_contains.rs","assert_not_ends_with.rs","assert_not_match.rs","assert_not_starts_with.rs","assert_starts_with.rs","lib.rs"]]]\
 ]'));
 createSrcSidebar();
diff --git a/doc/src/lib/assert_err/assert_err.rs.html b/doc/src/lib/assert_err/assert_err.rs.html
new file mode 100644
index 000000000..7b5164ec0
--- /dev/null
+++ b/doc/src/lib/assert_err/assert_err.rs.html
@@ -0,0 +1,391 @@
+assert_err.rs - source
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+144
+145
+146
+147
+148
+149
+150
+151
+152
+153
+154
+155
+156
+157
+158
+159
+160
+161
+162
+163
+164
+165
+166
+167
+168
+169
+170
+171
+172
+173
+174
+175
+176
+177
+178
+179
+180
+181
+182
+183
+184
+185
+186
+187
+188
+189
+190
+191
+192
+193
+194
+195
+
//! Assert expression is Err(_).
+//!
+//! Pseudocode:<br>
+//! a is Err(_)
+//!
+//! # Example
+//!
+//! ```rust
+//! use assertables::*;
+//! # fn main() {
+//! let a: Result<(), i8> = Err(1);
+//! assert_err!(a);
+//! # }
+//! ```
+//!
+//! # Module macros
+//!
+//! * [`assert_err`](macro@crate::assert_err)
+//! * [`assert_err_as_result`](macro@crate::assert_err_as_result)
+//! * [`debug_assert_err`](macro@crate::debug_assert_err)
+
+/// Assert expression is Err(_).
+///
+/// Pseudocode:<br>
+/// a is Err(_)
+///
+/// * If true, return Result `Ok(())`.
+///
+/// * Otherwise, return Result `Err` with a diagnostic message.
+///
+/// This macro provides the same statements as [`assert_err`](macro.assert_err.html),
+/// except this macro returns a Result, rather than doing a panic.
+///
+/// This macro is useful for runtime checks, such as checking parameters,
+/// or sanitizing inputs, or handling different results in different ways.
+///
+/// # Module macros
+///
+/// * [`assert_err`](macro@crate::assert_err)
+/// * [`assert_err_as_result`](macro@crate::assert_err_as_result)
+/// * [`debug_assert_err`](macro@crate::debug_assert_err)
+///
+#[macro_export]
+macro_rules! assert_err_as_result {
+    ($a:expr $(,)?) => {{
+        match (&$a) {
+            a => {
+                match (a) {
+                    Err(_) => {
+                        Ok(())
+                    },
+                    _ => {
+                        Err(format!(
+                            concat!(
+                                "assertion failed: `assert_err!(a)`\n",
+                                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_err.html\n",
+                                " a label: `{}`,\n",
+                                " a debug: `{:?}`",
+                            ),
+                            stringify!($a),
+                            a
+                        ))
+                    }
+                }
+            }
+        }
+    }};
+}
+
+#[cfg(test)]
+mod tests {
+
+    #[test]
+    fn test_assert_err_as_result_x_success() {
+        let a: Result<(), i8> = Err(1);
+        let result = assert_err_as_result!(a);
+        assert_eq!(result, Ok(()));
+    }
+
+    #[test]
+    fn test_assert_err_as_result_x_failure() {
+        let a: Result<(), i8>  = Ok(());
+        let result = assert_err_as_result!(a);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err(),
+            concat!(
+                "assertion failed: `assert_err!(a)`\n",
+                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_err.html\n",
+                " a label: `a`,\n",
+                " a debug: `Ok(())`",
+            )
+        );
+    }
+}
+
+/// Assert expression is Err(_).
+///
+/// Pseudocode:<br>
+/// a is Err(_)
+///
+/// * If true, return `()`.
+///
+/// * Otherwise, call [`panic!`] with a message and the values of the
+///   expressions with their debug representations.
+///
+/// # Examples
+///
+/// ```rust
+/// use assertables::*;
+/// # use std::panic;
+/// # fn main() {
+/// let a: Result<(), i8> = Err(1);
+/// assert_err!(a);
+///
+/// # let result = panic::catch_unwind(|| {
+/// let a: Result<(), i8> = Ok(());
+/// assert_err!(a);
+/// # });
+/// // assertion failed: `assert_err!(a)`
+/// // https://docs.rs/assertables/8.11.0/assertables/macro.assert_err.html
+/// //  a label: `a`,
+/// //  a debug: `Ok(())`
+/// # let actual = result.unwrap_err().downcast::<String>().unwrap().to_string();
+/// # let expect = concat!(
+/// #     "assertion failed: `assert_err!(a)`\n",
+/// #     "https://docs.rs/assertables/8.11.0/assertables/macro.assert_err.html\n",
+/// #     " a label: `a`,\n",
+/// #     " a debug: `Ok(())`",
+/// # );
+/// # assert_eq!(actual, expect);
+/// # }
+/// ```
+///
+/// # Module macros
+///
+/// * [`assert_err`](macro@crate::assert_err)
+/// * [`assert_err_as_result`](macro@crate::assert_err_as_result)
+/// * [`debug_assert_err`](macro@crate::debug_assert_err)
+///
+#[macro_export]
+macro_rules! assert_err {
+    ($a:expr $(,)?) => {{
+        match $crate::assert_err_as_result!($a) {
+            Ok(()) => (),
+            Err(err) => panic!("{}", err),
+        }
+    }};
+    ($a:expr, $($message:tt)+) => {{
+        match $crate::assert_err_as_result!($a) {
+            Ok(()) => (),
+            Err(_err) => panic!("{}", $($message)+),
+        }
+    }};
+}
+
+/// Assert expression is Err(_).
+///
+/// Pseudocode:<br>
+/// a is Err(_)
+///
+/// This macro provides the same statements as [`assert_err`](macro.assert_err.html),
+/// except this macro's statements are only enabled in non-optimized
+/// builds by default. An optimized build will not execute this macro's
+/// statements unless `-C debug-assertions` is passed to the compiler.
+///
+/// This macro is useful for checks that are too expensive to be present
+/// in a release build but may be helpful during development.
+///
+/// The result of expanding this macro is always type checked.
+///
+/// An unchecked assertion allows a program in an inconsistent state to
+/// keep running, which might have unexpected consequences but does not
+/// introduce unsafety as long as this only happens in safe code. The
+/// performance cost of assertions, however, is not measurable in general.
+/// Replacing `assert*!` with `debug_assert*!` is thus only encouraged
+/// after thorough profiling, and more importantly, only in safe code!
+///
+/// This macro is intended to work in a similar way to
+/// [`std::debug_assert`](https://doc.rust-lang.org/std/macro.debug_assert.html).
+///
+/// # Module macros
+///
+/// * [`assert_err`](macro@crate::assert_err)
+/// * [`assert_err`](macro@crate::assert_err)
+/// * [`debug_assert_err`](macro@crate::debug_assert_err)
+///
+#[macro_export]
+macro_rules! debug_assert_err {
+    ($($arg:tt)*) => {
+        if $crate::cfg!(debug_assertions) {
+            $crate::assert_err!($($arg)*);
+        }
+    };
+}
+

\ No newline at end of file
diff --git a/doc/src/lib/assert_err/assert_err_eq.rs.html b/doc/src/lib/assert_err/assert_err_eq.rs.html
new file mode 100644
index 000000000..936f2982c
--- /dev/null
+++ b/doc/src/lib/assert_err/assert_err_eq.rs.html
@@ -0,0 +1,515 @@
+assert_err_eq.rs - source
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+144
+145
+146
+147
+148
+149
+150
+151
+152
+153
+154
+155
+156
+157
+158
+159
+160
+161
+162
+163
+164
+165
+166
+167
+168
+169
+170
+171
+172
+173
+174
+175
+176
+177
+178
+179
+180
+181
+182
+183
+184
+185
+186
+187
+188
+189
+190
+191
+192
+193
+194
+195
+196
+197
+198
+199
+200
+201
+202
+203
+204
+205
+206
+207
+208
+209
+210
+211
+212
+213
+214
+215
+216
+217
+218
+219
+220
+221
+222
+223
+224
+225
+226
+227
+228
+229
+230
+231
+232
+233
+234
+235
+236
+237
+238
+239
+240
+241
+242
+243
+244
+245
+246
+247
+248
+249
+250
+251
+252
+253
+254
+255
+256
+257
+
//! Assert two expressions are Err(_) and their values are equal.
+//!
+//! Pseudocode:<br>
+//! (a ⇒ Err(a̅) ⇒ a̅) = (b ⇒ Err(b̅) ⇒ b̅)
+//!
+//! # Example
+//!
+//! ```rust
+//! use assertables::*;
+//! # fn main() {
+//! let a: Result<i8, i8> = Err(1);
+//! let b: Result<i8, i8> = Err(1);
+//! assert_err_eq!(a, b);
+//! # }
+//! ```
+//!
+//! # Module macros
+//!
+//! * [`assert_err_eq`](macro@crate::assert_err_eq)
+//! * [`assert_err_eq_as_result`](macro@crate::assert_err_eq_as_result)
+//! * [`debug_assert_err_eq`](macro@crate::debug_assert_err_eq)
+
+/// Assert two expressions are Err(_) and their values are equal.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Err(a̅) ⇒ a̅) = (b ⇒ Err(b̅) ⇒ b̅)
+///
+/// * If true, return Result `Ok(())`.
+///
+/// * Otherwise, return Result `Err` with a diagnostic message.
+///
+/// This macro provides the same statements as [`assert_err_eq`](macro.assert_err_eq.html),
+/// except this macro returns a Result, rather than doing a panic.
+///
+/// This macro is useful for runtime checks, such as checking parameters,
+/// or sanitizing inputs, or handling different results in different ways.
+///
+/// # Module macros
+///
+/// * [`assert_err_eq`](macro@crate::assert_err_eq)
+/// * [`assert_err_eq_as_result`](macro@crate::assert_err_eq_as_result)
+/// * [`debug_assert_err_eq`](macro@crate::debug_assert_err_eq)
+///
+#[macro_export]
+macro_rules! assert_err_eq_as_result {
+    ($a:expr, $b:expr $(,)?) => {{
+        match (&$a, &$b) {
+            (a, b) => {
+                match (a, b) {
+                    (Err(a_inner), Err(b_inner)) => {
+                        if a_inner == b_inner {
+                            Ok(())
+                        } else {
+                            Err(format!(
+                                concat!(
+                                    "assertion failed: `assert_err_eq!(a, b)`\n",
+                                    "https://docs.rs/assertables/8.11.0/assertables/macro.assert_err_eq.html\n",
+                                    " a label: `{}`,\n",
+                                    " a debug: `{:?}`,\n",
+                                    " a inner: `{:?}`,\n",
+                                    " b label: `{}`,\n",
+                                    " b debug: `{:?}`,\n",
+                                    " b inner: `{:?}`"
+                                ),
+                                stringify!($a),
+                                a,
+                                a_inner,
+                                stringify!($b),
+                                b,
+                                b_inner
+                            ))
+                        }
+                    },
+                    _ => {
+                        Err(format!(
+                            concat!(
+                                "assertion failed: `assert_err_eq!(a, b)`\n",
+                                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_err_eq.html\n",
+                                " a label: `{}`,\n",
+                                " a debug: `{:?}`,\n",
+                                " b label: `{}`,\n",
+                                " b debug: `{:?}`",
+                            ),
+                            stringify!($a),
+                            a,
+                            stringify!($b),
+                            b,
+                        ))
+                    }
+                }
+            }
+        }
+    }};
+}
+
+#[cfg(test)]
+mod tests {
+
+    #[test]
+    fn test_assert_err_eq_as_result_x_success() {
+        let a: Result<i8, i8> = Err(1);
+        let b: Result<i8, i8> = Err(1);
+        let result = assert_err_eq_as_result!(a, b);
+        assert_eq!(result, Ok(()));
+    }
+
+    #[test]
+    fn test_assert_err_eq_as_result_x_failure_because_ne() {
+        let a: Result<i8, i8> = Err(1);
+        let b: Result<i8, i8> = Err(2);
+        let result = assert_err_eq_as_result!(a, b);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err(),
+            concat!(
+                "assertion failed: `assert_err_eq!(a, b)`\n",
+                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_err_eq.html\n",
+                " a label: `a`,\n",
+                " a debug: `Err(1)`,\n",
+                " a inner: `1`,\n",
+                " b label: `b`,\n",
+                " b debug: `Err(2)`,\n",
+                " b inner: `2`",
+            )
+        );
+    }
+
+    #[test]
+    fn test_assert_err_eq_as_result_x_failure_because_not_err() {
+        let a: Result<i8, i8> = Ok(1);
+        let b: Result<i8, i8> = Err(1);
+        let result = assert_err_eq_as_result!(a, b);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err(),
+            concat!(
+                "assertion failed: `assert_err_eq!(a, b)`\n",
+                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_err_eq.html\n",
+                " a label: `a`,\n",
+                " a debug: `Ok(1)`,\n",
+                " b label: `b`,\n",
+                " b debug: `Err(1)`",
+            )
+        );
+    }
+
+}
+
+/// Assert two expressions are Err(_) and their values are equal.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Err(a̅) ⇒ a̅) = (b ⇒ Err(b̅) ⇒ b̅)
+///
+/// * If true, return `()`.
+///
+/// * Otherwise, call [`panic!`] with a message and the values of the
+///   expressions with their debug representations.
+///
+/// # Examples
+///
+/// ```rust
+/// use assertables::*;
+/// # use std::panic;
+/// # fn main() {
+/// let a: Result<i8, i8> = Err(1);
+/// let b: Result<i8, i8> = Err(1);
+/// assert_err_eq!(a, b);
+///
+/// # let result = panic::catch_unwind(|| {
+/// let a: Result<i8, i8> = Err(1);
+/// let b: Result<i8, i8> = Err(2);
+/// assert_err_eq!(a, b);
+/// # });
+/// // assertion failed: `assert_err_eq!(a, b)`
+/// // https://docs.rs/assertables/8.11.0/assertables/macro.assert_err_eq.html
+/// //  a label: `a`,
+/// //  a debug: `Err(1)`,
+/// //  a inner: `1`,
+/// //  b label: `b`,
+/// //  b debug: `Err(2)`,
+/// //  b inner: `2`
+/// # let actual = result.unwrap_err().downcast::<String>().unwrap().to_string();
+/// # let expect = concat!(
+/// #     "assertion failed: `assert_err_eq!(a, b)`\n",
+/// #     "https://docs.rs/assertables/8.11.0/assertables/macro.assert_err_eq.html\n",
+/// #     " a label: `a`,\n",
+/// #     " a debug: `Err(1)`,\n",
+/// #     " a inner: `1`,\n",
+/// #     " b label: `b`,\n",
+/// #     " b debug: `Err(2)`,\n",
+/// #     " b inner: `2`",
+/// # );
+/// # assert_eq!(actual, expect);
+/// # }
+/// ```
+///
+/// # Module macros
+///
+/// * [`assert_err_eq`](macro@crate::assert_err_eq)
+/// * [`assert_err_eq_as_result`](macro@crate::assert_err_eq_as_result)
+/// * [`debug_assert_err_eq`](macro@crate::debug_assert_err_eq)
+///
+#[macro_export]
+macro_rules! assert_err_eq {
+    ($a:expr, $b:expr $(,)?) => {{
+        match $crate::assert_err_eq_as_result!($a, $b) {
+            Ok(()) => (),
+            Err(err) => panic!("{}", err),
+        }
+    }};
+    ($a:expr, $b:expr, $($message:tt)+) => {{
+        match $crate::assert_err_eq_as_result!($a, $b) {
+            Ok(()) => (),
+            Err(_err) => panic!("{}", $($message)+),
+        }
+    }};
+}
+
+/// Assert two expressions are Err(_) and their values are equal.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Err(a̅) ⇒ a̅) = (b ⇒ Err(b̅) ⇒ b̅)
+///
+/// This macro provides the same statements as [`assert_err_eq`](macro.assert_err_eq.html),
+/// except this macro's statements are only enabled in non-optimized
+/// builds by default. An optimized build will not execute this macro's
+/// statements unless `-C debug-assertions` is passed to the compiler.
+///
+/// This macro is useful for checks that are too expensive to be present
+/// in a release build but may be helpful during development.
+///
+/// The result of expanding this macro is always type checked.
+///
+/// An unchecked assertion allows a program in an inconsistent state to
+/// keep running, which might have unexpected consequences but does not
+/// introduce unsafety as long as this only happens in safe code. The
+/// performance cost of assertions, however, is not measurable in general.
+/// Replacing `assert*!` with `debug_assert*!` is thus only encouraged
+/// after thorough profiling, and more importantly, only in safe code!
+///
+/// This macro is intended to work in a similar way to
+/// [`std::debug_assert`](https://doc.rust-lang.org/std/macro.debug_assert.html).
+///
+/// # Module macros
+///
+/// * [`assert_err_eq`](macro@crate::assert_err_eq)
+/// * [`assert_err_eq`](macro@crate::assert_err_eq)
+/// * [`debug_assert_err_eq`](macro@crate::debug_assert_err_eq)
+///
+#[macro_export]
+macro_rules! debug_assert_err_eq {
+    ($($arg:tt)*) => {
+        if $crate::cfg!(debug_assertions) {
+            $crate::assert_err_eq!($($arg)*);
+        }
+    };
+}
+

\ No newline at end of file
diff --git a/doc/src/lib/assert_err/assert_err_eq_expr.rs.html b/doc/src/lib/assert_err/assert_err_eq_expr.rs.html
new file mode 100644
index 000000000..1da91949d
--- /dev/null
+++ b/doc/src/lib/assert_err/assert_err_eq_expr.rs.html
@@ -0,0 +1,505 @@
+assert_err_eq_expr.rs - source
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+144
+145
+146
+147
+148
+149
+150
+151
+152
+153
+154
+155
+156
+157
+158
+159
+160
+161
+162
+163
+164
+165
+166
+167
+168
+169
+170
+171
+172
+173
+174
+175
+176
+177
+178
+179
+180
+181
+182
+183
+184
+185
+186
+187
+188
+189
+190
+191
+192
+193
+194
+195
+196
+197
+198
+199
+200
+201
+202
+203
+204
+205
+206
+207
+208
+209
+210
+211
+212
+213
+214
+215
+216
+217
+218
+219
+220
+221
+222
+223
+224
+225
+226
+227
+228
+229
+230
+231
+232
+233
+234
+235
+236
+237
+238
+239
+240
+241
+242
+243
+244
+245
+246
+247
+248
+249
+250
+251
+252
+
//! Assert an expression is Err(_) and its value is equal to an expression.
+//!
+//! Pseudocode:<br>
+//! (a ⇒ Err(a̅) ⇒ a̅) = b
+//!
+//! # Example
+//!
+//! ```rust
+//! use assertables::*;
+//! # fn main() {
+//! let a: Result<i8, i8> = Err(1);
+//! let b: i8 = 1;
+//! assert_err_eq_expr!(a, b);
+//! # }
+//! ```
+//!
+//! # Module macros
+//!
+//! * [`assert_err_eq_expr`](macro@crate::assert_err_eq_expr)
+//! * [`assert_err_eq_expr_as_result`](macro@crate::assert_err_eq_expr_as_result)
+//! * [`debug_assert_err_eq_expr`](macro@crate::debug_assert_err_eq_expr)
+
+/// Assert an expression is Err(_) and its value is equal to an expression.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Err(a̅) ⇒ a̅) = b
+///
+/// * If true, return Result `Ok(())`.
+///
+/// * Otherwise, return Result `Err` with a diagnostic message.
+///
+/// This macro provides the same statements as [`assert_err_eq_expr`](macro.assert_err_eq_expr.html),
+/// except this macro returns a Result, rather than doing a panic.
+///
+/// This macro is useful for runtime checks, such as checking parameters,
+/// or sanitizing inputs, or handling different results in different ways.
+///
+/// # Module macros
+///
+/// * [`assert_err_eq_expr`](macro@crate::assert_err_eq_expr)
+/// * [`assert_err_eq_expr_as_result`](macro@crate::assert_err_eq_expr_as_result)
+/// * [`debug_assert_err_eq_expr`](macro@crate::debug_assert_err_eq_expr)
+///
+#[macro_export]
+macro_rules! assert_err_eq_expr_as_result {
+    ($a:expr, $b:expr $(,)?) => {{
+        match (&$a, &$b) {
+            (a, b) => {
+                match a {
+                    Err(a_inner) => {
+                        if a_inner == b {
+                            Ok(())
+                        } else {
+                            Err(format!(
+                                concat!(
+                                    "assertion failed: `assert_err_eq_expr!(a, b)`\n",
+                                    "https://docs.rs/assertables/8.11.0/assertables/macro.assert_err_eq_expr.html\n",
+                                    " a label: `{}`,\n",
+                                    " a debug: `{:?}`,\n",
+                                    " a inner: `{:?}`,\n",
+                                    " b label: `{}`,\n",
+                                    " b debug: `{:?}`",
+                                ),
+                                stringify!($a),
+                                a,
+                                a_inner,
+                                stringify!($b),
+                                b
+                            ))
+                        }
+                    },
+                    _ => {
+                        Err(format!(
+                            concat!(
+                                "assertion failed: `assert_err_eq_expr!(a, b)`\n",
+                                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_err_eq_expr.html\n",
+                                " a label: `{}`,\n",
+                                " a debug: `{:?}`,\n",
+                                " b label: `{}`,\n",
+                                " b debug: `{:?}`",
+                            ),
+                            stringify!($a),
+                            a,
+                            stringify!($b),
+                            b,
+                        ))
+                    }
+                }
+            }
+        }
+    }};
+}
+
+#[cfg(test)]
+mod tests {
+
+    #[test]
+    fn test_assert_err_eq_expr_as_result_x_success() {
+        let a: Result<i8, i8> = Err(1);
+        let b: i8 = 1;
+        let result = assert_err_eq_expr_as_result!(a, b);
+        assert_eq!(result, Ok(()));
+    }
+
+    #[test]
+    fn test_assert_err_eq_expr_as_result_x_failure_because_ne() {
+        let a: Result<i8, i8> = Err(1);
+        let b: i8 = 2;
+        let result = assert_err_eq_expr_as_result!(a, b);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err(),
+            concat!(
+                "assertion failed: `assert_err_eq_expr!(a, b)`\n",
+                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_err_eq_expr.html\n",
+                " a label: `a`,\n",
+                " a debug: `Err(1)`,\n",
+                " a inner: `1`,\n",
+                " b label: `b`,\n",
+                " b debug: `2`"
+            )
+        );
+    }
+
+    #[test]
+    fn test_assert_err_eq_expr_as_result_x_failure_because_not_err() {
+        let a: Result<i8, i8> = Ok(1);
+        let b: i8 = 1;
+        let result = assert_err_eq_expr_as_result!(a, b);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err(),
+            concat!(
+                "assertion failed: `assert_err_eq_expr!(a, b)`\n",
+                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_err_eq_expr.html\n",
+                " a label: `a`,\n",
+                " a debug: `Ok(1)`,\n",
+                " b label: `b`,\n",
+                " b debug: `1`",
+            )
+        );
+    }
+
+}
+
+/// Assert an expression is Err(_) and its value is equal to an expression.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Err(a̅) ⇒ a̅) = b
+///
+/// * If true, return `()`.
+///
+/// * Otherwise, call [`panic!`] with a message and the values of the
+///   expressions with their debug representations.
+///
+/// # Examples
+///
+/// ```rust
+/// use assertables::*;
+/// # use std::panic;
+/// # fn main() {
+/// let a: Result<i8, i8> = Err(1);
+/// let b: i8 = 1;
+/// assert_err_eq_expr!(a, b);
+///
+/// # let result = panic::catch_unwind(|| {
+/// let a: Result<i8, i8> = Err(1);
+/// let b: i8 = 2;
+/// assert_err_eq_expr!(a, b);
+/// # });
+/// // assertion failed: `assert_err_eq_expr!(a, b)`
+/// // https://docs.rs/assertables/8.11.0/assertables/macro.assert_err_eq_expr.html
+/// //  a label: `a`,
+/// //  a debug: `Err(1)`,
+/// //  a inner: `1`,
+/// //  b label: `b`,
+/// //  b debug: `2`
+/// # let actual = result.unwrap_err().downcast::<String>().unwrap().to_string();
+/// # let expect = concat!(
+/// #     "assertion failed: `assert_err_eq_expr!(a, b)`\n",
+/// #     "https://docs.rs/assertables/8.11.0/assertables/macro.assert_err_eq_expr.html\n",
+/// #     " a label: `a`,\n",
+/// #     " a debug: `Err(1)`,\n",
+/// #     " a inner: `1`,\n",
+/// #     " b label: `b`,\n",
+/// #     " b debug: `2`",
+/// # );
+/// # assert_eq!(actual, expect);
+/// # }
+/// ```
+///
+/// # Module macros
+///
+/// * [`assert_err_eq_expr`](macro@crate::assert_err_eq_expr)
+/// * [`assert_err_eq_expr_as_result`](macro@crate::assert_err_eq_expr_as_result)
+/// * [`debug_assert_err_eq_expr`](macro@crate::debug_assert_err_eq_expr)
+///
+#[macro_export]
+macro_rules! assert_err_eq_expr {
+    ($a:expr, $b:expr $(,)?) => {{
+        match $crate::assert_err_eq_expr_as_result!($a, $b) {
+            Ok(()) => (),
+            Err(err) => panic!("{}", err),
+        }
+    }};
+    ($a:expr, $b:expr, $($message:tt)+) => {{
+        match $crate::assert_err_eq_expr_as_result!($a, $b) {
+            Ok(()) => (),
+            Err(_err) => panic!("{}", $($message)+),
+        }
+    }};
+}
+
+/// Assert an expression is Err(_) and its value is equal to an expression.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Err(a̅) ⇒ a̅) = b
+///
+/// This macro provides the same statements as [`assert_err_eq_expr`](macro.assert_err_eq_expr.html),
+/// except this macro's statements are only enabled in non-optimized
+/// builds by default. An optimized build will not execute this macro's
+/// statements unless `-C debug-assertions` is passed to the compiler.
+///
+/// This macro is useful for checks that are too expensive to be present
+/// in a release build but may be helpful during development.
+///
+/// The result of expanding this macro is always type checked.
+///
+/// An unchecked assertion allows a program in an inconsistent state to
+/// keep running, which might have unexpected consequences but does not
+/// introduce unsafety as long as this only happens in safe code. The
+/// performance cost of assertions, however, is not measurable in general.
+/// Replacing `assert*!` with `debug_assert*!` is thus only encouraged
+/// after thorough profiling, and more importantly, only in safe code!
+///
+/// This macro is intended to work in a similar way to
+/// [`std::debug_assert`](https://doc.rust-lang.org/std/macro.debug_assert.html).
+///
+/// # Module macros
+///
+/// * [`assert_err_eq_expr`](macro@crate::assert_err_eq_expr)
+/// * [`assert_err_eq_expr`](macro@crate::assert_err_eq_expr)
+/// * [`debug_assert_err_eq_expr`](macro@crate::debug_assert_err_eq_expr)
+///
+#[macro_export]
+macro_rules! debug_assert_err_eq_expr {
+    ($($arg:tt)*) => {
+        if $crate::cfg!(debug_assertions) {
+            $crate::assert_err_eq_expr!($($arg)*);
+        }
+    };
+}
+

\ No newline at end of file
diff --git a/doc/src/lib/assert_err/assert_err_ne.rs.html b/doc/src/lib/assert_err/assert_err_ne.rs.html
new file mode 100644
index 000000000..4107c38e5
--- /dev/null
+++ b/doc/src/lib/assert_err/assert_err_ne.rs.html
@@ -0,0 +1,509 @@
+assert_err_ne.rs - source
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+144
+145
+146
+147
+148
+149
+150
+151
+152
+153
+154
+155
+156
+157
+158
+159
+160
+161
+162
+163
+164
+165
+166
+167
+168
+169
+170
+171
+172
+173
+174
+175
+176
+177
+178
+179
+180
+181
+182
+183
+184
+185
+186
+187
+188
+189
+190
+191
+192
+193
+194
+195
+196
+197
+198
+199
+200
+201
+202
+203
+204
+205
+206
+207
+208
+209
+210
+211
+212
+213
+214
+215
+216
+217
+218
+219
+220
+221
+222
+223
+224
+225
+226
+227
+228
+229
+230
+231
+232
+233
+234
+235
+236
+237
+238
+239
+240
+241
+242
+243
+244
+245
+246
+247
+248
+249
+250
+251
+252
+253
+254
+
//! Assert two expressions are Err(_) and their values are not equal.
+//!
+//! Pseudocode:<br>
+//! (a ⇒ Err(a̅) ⇒ a̅) ≠ (b ⇒ Err(b̅) ⇒ b̅)
+//!
+//! # Example
+//!
+//! ```rust
+//! use assertables::*;
+//! # fn main() {
+//! let a: Result<i8, i8> = Err(1);
+//! let b: Result<i8, i8> = Err(2);
+//! assert_err_ne!(a, b);
+//! # }
+//! ```
+//!
+//! # Module macros
+//!
+//! * [`assert_err_ne`](macro@crate::assert_err_ne)
+//! * [`assert_err_ne_as_result`](macro@crate::assert_err_ne_as_result)
+//! * [`debug_assert_err_ne`](macro@crate::debug_assert_err_ne)
+
+/// Assert two expressions are Err(_) and their values are not equal.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Err(a̅) ⇒ a̅) ≠ (b ⇒ Err(b̅) ⇒ b̅)
+///
+/// * If true, return Result `Ok(())`.
+///
+/// * Otherwise, return Result `Err` with a diagnostic message.
+///
+/// This macro provides the same statements as [`assert_err_ne`](macro.assert_err_ne.html),
+/// except this macro returns a Result, rather than doing a panic.
+///
+/// This macro is useful for runtime checks, such as checking parameters,
+/// or sanitizing inputs, or handling different results in different ways.
+///
+/// # Module macros
+///
+/// * [`assert_err_ne`](macro@crate::assert_err_ne)
+/// * [`assert_err_ne_as_result`](macro@crate::assert_err_ne_as_result)
+/// * [`debug_assert_err_ne`](macro@crate::debug_assert_err_ne)
+///
+#[macro_export]
+macro_rules! assert_err_ne_as_result {
+    ($a:expr, $b:expr $(,)?) => {{
+        match (&$a, &$b) {
+            (a, b) => {
+                match (a, b) {
+                    (Err(a_inner), Err(b_inner)) => {
+                        if a_inner != b_inner {
+                            Ok(())
+                        } else {
+                            Err(format!(
+                                concat!(
+                                    "assertion failed: `assert_err_ne!(a, b)`\n",
+                                    "https://docs.rs/assertables/8.11.0/assertables/macro.assert_err_ne.html\n",
+                                    " a label: `{}`,\n",
+                                    " a debug: `{:?}`,\n",
+                                    " a inner: `{:?}`,\n",
+                                    " b label: `{}`,\n",
+                                    " b debug: `{:?}`,\n",
+                                    " b inner: `{:?}`"
+                                ),
+                                stringify!($a),
+                                a,
+                                a_inner,
+                                stringify!($b),
+                                b,
+                                b_inner
+                            ))
+                        }
+                    },
+                    _ => {
+                        Err(format!(
+                            concat!(
+                                "assertion failed: `assert_err_ne!(a, b)`\n",
+                                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_err_ne.html\n",
+                                " a label: `{}`,\n",
+                                " a debug: `{:?}`,\n",
+                                " b label: `{}`,\n",
+                                " b debug: `{:?}`",
+                            ),
+                            stringify!($a),
+                            a,
+                            stringify!($b),
+                            b,
+                        ))
+                    }
+                }
+            }
+        }
+    }};
+}
+
+#[cfg(test)]
+mod tests {
+
+    #[test]
+    fn test_assert_err_ne_as_result_x_success() {
+        let a: Result<i8, i8> = Err(1);
+        let b: Result<i8, i8> = Err(2);
+        let result = assert_err_ne_as_result!(a, b);
+        assert_eq!(result, Ok(()));
+    }
+
+    #[test]
+    fn test_assert_err_ne_as_result_x_failure_because_eq() {
+        let a: Result<i8, i8> = Err(1);
+        let b: Result<i8, i8> = Err(1);
+        let result = assert_err_ne_as_result!(a, b);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err(),
+            concat!(
+                "assertion failed: `assert_err_ne!(a, b)`\n",
+                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_err_ne.html\n",
+                " a label: `a`,\n",
+                " a debug: `Err(1)`,\n",
+                " a inner: `1`,\n",
+                " b label: `b`,\n",
+                " b debug: `Err(1)`,\n",
+                " b inner: `1`",
+            )
+        );
+    }
+
+    #[test]
+    fn test_assert_err_ne_as_result_x_failure_because_not_err() {
+        let a: Result<i8, i8> = Ok(1);
+        let b: Result<i8, i8> = Err(1);
+        let result = assert_err_ne_as_result!(a, b);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err(),
+            concat!(
+                "assertion failed: `assert_err_ne!(a, b)`\n",
+                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_err_ne.html\n",
+                " a label: `a`,\n",
+                " a debug: `Ok(1)`,\n",
+                " b label: `b`,\n",
+                " b debug: `Err(1)`",
+            )
+        );
+    }
+
+}
+
+/// Assert two expressions are Err(_) and their values are not equal.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Err(a̅) ⇒ a̅) ≠ (b ⇒ Err(b̅) ⇒ b̅)
+///
+/// * If true, return `()`.
+///
+/// * Otherwise, call [`panic!`] with a message and the values of the
+///   expressions with their debug representations.
+///
+/// # Examples
+///
+/// ```rust
+/// use assertables::*;
+/// # use std::panic;
+/// # fn main() {
+/// let a: Result<i8, i8> = Err(1);
+/// let b: Result<i8, i8> = Err(2);
+/// assert_err_ne!(a, b);
+///
+/// # let result = panic::catch_unwind(|| {
+/// let a: Result<i8, i8> = Err(1);
+/// let b: Result<i8, i8> = Err(1);
+/// assert_err_ne!(a, b);
+/// # });
+/// // assertion failed: `assert_err_ne!(a, b)`
+/// // https://docs.rs/assertables/8.11.0/assertables/macro.assert_err_ne.html
+/// //  a label: `a`,
+/// //  a debug: `Err(1)`,
+/// //  a inner: `1`,
+/// //  b label: `b`,
+/// //  b debug: `Err(1)`,
+/// //  b inner: `1`
+/// # let actual = result.unwrap_err().downcast::<String>().unwrap().to_string();
+/// # let expect = concat!(
+/// #     "assertion failed: `assert_err_ne!(a, b)`\n",
+/// #     "https://docs.rs/assertables/8.11.0/assertables/macro.assert_err_ne.html\n",
+/// #     " a label: `a`,\n",
+/// #     " a debug: `Err(1)`,\n",
+/// #     " a inner: `1`,\n",
+/// #     " b label: `b`,\n",
+/// #     " b debug: `Err(1)`,\n",
+/// #     " b inner: `1`",
+/// # );
+/// # assert_eq!(actual, expect);
+/// # }
+/// ```
+///
+/// # Module macros
+///
+/// * [`assert_err_ne`](macro@crate::assert_err_ne)
+/// * [`assert_err_ne_as_result`](macro@crate::assert_err_ne_as_result)
+/// * [`debug_assert_err_ne`](macro@crate::debug_assert_err_ne)
+///
+#[macro_export]
+macro_rules! assert_err_ne {
+    ($a:expr, $b:expr $(,)?) => {{
+        match $crate::assert_err_ne_as_result!($a, $b) {
+            Ok(()) => (),
+            Err(err) => panic!("{}", err),
+        }
+    }};
+    ($a:expr, $b:expr, $($message:tt)+) => {{
+        match $crate::assert_err_ne_as_result!($a, $b) {
+            Ok(()) => (),
+            Err(_err) => panic!("{}", $($message)+),
+        }
+    }};
+}
+
+/// Assert two expressions are Err(_) and their values are not equal.
+///
+/// This macro provides the same statements as [`assert_err_ne`](macro.assert_err_ne.html),
+/// except this macro's statements are only enabled in non-optimized
+/// builds by default. An optimized build will not execute this macro's
+/// statements unless `-C debug-assertions` is passed to the compiler.
+///
+/// This macro is useful for checks that are too expensive to be present
+/// in a release build but may be helpful during development.
+///
+/// The result of expanding this macro is always type checked.
+///
+/// An unchecked assertion allows a program in an inconsistent state to
+/// keep running, which might have unexpected consequences but does not
+/// introduce unsafety as long as this only happens in safe code. The
+/// performance cost of assertions, however, is not measurable in general.
+/// Replacing `assert*!` with `debug_assert*!` is thus only encouraged
+/// after thorough profiling, and more importantly, only in safe code!
+///
+/// This macro is intended to work in a similar way to
+/// [`std::debug_assert`](https://doc.rust-lang.org/std/macro.debug_assert.html).
+///
+/// # Module macros
+///
+/// * [`assert_err_ne`](macro@crate::assert_err_ne)
+/// * [`assert_err_ne`](macro@crate::assert_err_ne)
+/// * [`debug_assert_err_ne`](macro@crate::debug_assert_err_ne)
+///
+#[macro_export]
+macro_rules! debug_assert_err_ne {
+    ($($arg:tt)*) => {
+        if $crate::cfg!(debug_assertions) {
+            $crate::assert_err_ne!($($arg)*);
+        }
+    };
+}
+

\ No newline at end of file
diff --git a/doc/src/lib/assert_err/assert_err_ne_expr.rs.html b/doc/src/lib/assert_err/assert_err_ne_expr.rs.html
new file mode 100644
index 000000000..ec237b559
--- /dev/null
+++ b/doc/src/lib/assert_err/assert_err_ne_expr.rs.html
@@ -0,0 +1,505 @@
+assert_err_ne_expr.rs - source
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+144
+145
+146
+147
+148
+149
+150
+151
+152
+153
+154
+155
+156
+157
+158
+159
+160
+161
+162
+163
+164
+165
+166
+167
+168
+169
+170
+171
+172
+173
+174
+175
+176
+177
+178
+179
+180
+181
+182
+183
+184
+185
+186
+187
+188
+189
+190
+191
+192
+193
+194
+195
+196
+197
+198
+199
+200
+201
+202
+203
+204
+205
+206
+207
+208
+209
+210
+211
+212
+213
+214
+215
+216
+217
+218
+219
+220
+221
+222
+223
+224
+225
+226
+227
+228
+229
+230
+231
+232
+233
+234
+235
+236
+237
+238
+239
+240
+241
+242
+243
+244
+245
+246
+247
+248
+249
+250
+251
+252
+
//! Assert an expression is Err(_) and its value is not equal to an expression.
+//!
+//! Pseudocode:<br>
+//! (a ⇒ Err(a̅) ⇒ a̅) ≠ b
+//!
+//! # Example
+//!
+//! ```rust
+//! use assertables::*;
+//! # fn main() {
+//! let a: Result<i8, i8> = Err(1);
+//! let b: i8 = 2;
+//! assert_err_ne_expr!(a, b);
+//! # }
+//! ```
+//!
+//! # Module macros
+//!
+//! * [`assert_err_ne_expr`](macro@crate::assert_err_ne_expr)
+//! * [`assert_err_ne_expr_as_result`](macro@crate::assert_err_ne_expr_as_result)
+//! * [`debug_assert_err_ne_expr`](macro@crate::debug_assert_err_ne_expr)
+
+/// Assert an expression is Err(_) and its value is equal to an expression.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Err(a̅) ⇒ a̅) = b
+///
+/// * If true, return Result `Ok(())`.
+///
+/// * Otherwise, return Result `Err` with a diagnostic message.
+///
+/// This macro provides the same statements as [`assert_err_ne_expr`](macro.assert_err_ne_expr.html),
+/// except this macro returns a Result, rather than doing a panic.
+///
+/// This macro is useful for runtime checks, such as checking parameters,
+/// or sanitizing inputs, or handling different results in different ways.
+///
+/// # Module macros
+///
+/// * [`assert_err_ne_expr`](macro@crate::assert_err_ne_expr)
+/// * [`assert_err_ne_expr_as_result`](macro@crate::assert_err_ne_expr_as_result)
+/// * [`debug_assert_err_ne_expr`](macro@crate::debug_assert_err_ne_expr)
+///
+#[macro_export]
+macro_rules! assert_err_ne_expr_as_result {
+    ($a:expr, $b:expr $(,)?) => {{
+        match (&$a, &$b) {
+            (a, b) => {
+                match a {
+                    Err(a_inner) => {
+                        if a_inner != b {
+                            Ok(())
+                        } else {
+                            Err(format!(
+                                concat!(
+                                    "assertion failed: `assert_err_ne_expr!(a, b)`\n",
+                                    "https://docs.rs/assertables/8.11.0/assertables/macro.assert_err_ne_expr.html\n",
+                                    " a label: `{}`,\n",
+                                    " a debug: `{:?}`,\n",
+                                    " a inner: `{:?}`,\n",
+                                    " b label: `{}`,\n",
+                                    " b debug: `{:?}`",
+                                ),
+                                stringify!($a),
+                                a,
+                                a_inner,
+                                stringify!($b),
+                                b
+                            ))
+                        }
+                    },
+                    _ => {
+                        Err(format!(
+                            concat!(
+                                "assertion failed: `assert_err_ne_expr!(a, b)`\n",
+                                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_err_ne_expr.html\n",
+                                " a label: `{}`,\n",
+                                " a debug: `{:?}`,\n",
+                                " b label: `{}`,\n",
+                                " b debug: `{:?}`",
+                            ),
+                            stringify!($a),
+                            a,
+                            stringify!($b),
+                            b,
+                        ))
+                    }
+                }
+            }
+        }
+    }};
+}
+
+#[cfg(test)]
+mod tests {
+
+    #[test]
+    fn test_assert_err_ne_expr_as_result_x_success() {
+        let a: Result<i8, i8> = Err(1);
+        let b: i8 = 2;
+        let result = assert_err_ne_expr_as_result!(a, b);
+        assert_eq!(result, Ok(()));
+    }
+
+    #[test]
+    fn test_assert_err_ne_expr_as_result_x_failure_because_ne() {
+        let a: Result<i8, i8> = Err(1);
+        let b: i8 = 1;
+        let result = assert_err_ne_expr_as_result!(a, b);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err(),
+            concat!(
+                "assertion failed: `assert_err_ne_expr!(a, b)`\n",
+                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_err_ne_expr.html\n",
+                " a label: `a`,\n",
+                " a debug: `Err(1)`,\n",
+                " a inner: `1`,\n",
+                " b label: `b`,\n",
+                " b debug: `1`",
+            )
+        );
+    }
+
+    #[test]
+    fn test_assert_err_ne_expr_as_result_x_failure_because_not_err() {
+        let a: Result<i8, i8> = Ok(1);
+        let b: i8 = 2;
+        let result = assert_err_ne_expr_as_result!(a, b);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err(),
+            concat!(
+                "assertion failed: `assert_err_ne_expr!(a, b)`\n",
+                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_err_ne_expr.html\n",
+                " a label: `a`,\n",
+                " a debug: `Ok(1)`,\n",
+                " b label: `b`,\n",
+                " b debug: `2`",
+            )
+        );
+    }
+
+}
+
+/// Assert an expression is Err(_) and its value is equal to an expression.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Err(a̅) ⇒ a̅) ≠ b
+///
+/// * If true, return `()`.
+///
+/// * Otherwise, call [`panic!`] with a message and the values of the
+///   expressions with their debug representations.
+///
+/// # Examples
+///
+/// ```rust
+/// use assertables::*;
+/// # use std::panic;
+/// # fn main() {
+/// let a: Result<i8, i8> = Err(1);
+/// let b: i8 = 2;
+/// assert_err_ne_expr!(a, b);
+///
+/// # let result = panic::catch_unwind(|| {
+/// let a: Result<i8, i8> = Err(1);
+/// let b: i8 = 1;
+/// assert_err_ne_expr!(a, b);
+/// # });
+/// // assertion failed: `assert_err_ne_expr!(a, b)`
+/// // https://docs.rs/assertables/8.11.0/assertables/macro.assert_err_ne_expr.html
+/// //  a label: `a`,
+/// //  a debug: `Err(1)`,
+/// //  a inner: `1`,
+/// //  b label: `b`,
+/// //  b debug: `1`
+/// # let actual = result.unwrap_err().downcast::<String>().unwrap().to_string();
+/// # let expect = concat!(
+/// #     "assertion failed: `assert_err_ne_expr!(a, b)`\n",
+/// #     "https://docs.rs/assertables/8.11.0/assertables/macro.assert_err_ne_expr.html\n",
+/// #     " a label: `a`,\n",
+/// #     " a debug: `Err(1)`,\n",
+/// #     " a inner: `1`,\n",
+/// #     " b label: `b`,\n",
+/// #     " b debug: `1`",
+/// # );
+/// # assert_eq!(actual, expect);
+/// # }
+/// ```
+///
+/// # Module macros
+///
+/// * [`assert_err_ne_expr`](macro@crate::assert_err_ne_expr)
+/// * [`assert_err_ne_expr_as_result`](macro@crate::assert_err_ne_expr_as_result)
+/// * [`debug_assert_err_ne_expr`](macro@crate::debug_assert_err_ne_expr)
+///
+#[macro_export]
+macro_rules! assert_err_ne_expr {
+    ($a:expr, $b:expr $(,)?) => {{
+        match $crate::assert_err_ne_expr_as_result!($a, $b) {
+            Ok(()) => (),
+            Err(err) => panic!("{}", err),
+        }
+    }};
+    ($a:expr, $b:expr, $($message:tt)+) => {{
+        match $crate::assert_err_ne_expr_as_result!($a, $b) {
+            Ok(()) => (),
+            Err(_err) => panic!("{}", $($message)+),
+        }
+    }};
+}
+
+/// Assert an expression is Err(_) and its value is equal to an expression.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Err(a̅) ⇒ a̅) ≠ b
+///
+/// This macro provides the same statements as [`assert_err_ne_expr`](macro.assert_err_ne_expr.html),
+/// except this macro's statements are only enabled in non-optimized
+/// builds by default. An optimized build will not execute this macro's
+/// statements unless `-C debug-assertions` is passed to the compiler.
+///
+/// This macro is useful for checks that are too expensive to be present
+/// in a release build but may be helpful during development.
+///
+/// The result of expanding this macro is always type checked.
+///
+/// An unchecked assertion allows a program in an inconsistent state to
+/// keep running, which might have unexpected consequences but does not
+/// introduce unsafety as long as this only happens in safe code. The
+/// performance cost of assertions, however, is not measurable in general.
+/// Replacing `assert*!` with `debug_assert*!` is thus only encouraged
+/// after thorough profiling, and more importantly, only in safe code!
+///
+/// This macro is intended to work in a similar way to
+/// [`std::debug_assert`](https://doc.rust-lang.org/std/macro.debug_assert.html).
+///
+/// # Module macros
+///
+/// * [`assert_err_ne_expr`](macro@crate::assert_err_ne_expr)
+/// * [`assert_err_ne_expr`](macro@crate::assert_err_ne_expr)
+/// * [`debug_assert_err_ne_expr`](macro@crate::debug_assert_err_ne_expr)
+///
+#[macro_export]
+macro_rules! debug_assert_err_ne_expr {
+    ($($arg:tt)*) => {
+        if $crate::cfg!(debug_assertions) {
+            $crate::assert_err_ne_expr!($($arg)*);
+        }
+    };
+}
+

\ No newline at end of file
diff --git a/doc/src/lib/assert_err/mod.rs.html b/doc/src/lib/assert_err/mod.rs.html
new file mode 100644
index 000000000..fdc56e5bd
--- /dev/null
+++ b/doc/src/lib/assert_err/mod.rs.html
@@ -0,0 +1,71 @@
+mod.rs - source
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+
//! Assert macros for Err(_) items.
+//!
+//! These macros help compare Err(…) items, such as `std::Result::Err` or similar.
+//!
+//! Assert expression is Err(_):
+//! 
+//! * [`assert_err!(a)`](macro@crate::assert_err) 
+//!   ≈ a is Err(_)
+//! 
+//! Compare Err(…) to another Err(…):
+//! 
+//! * [`assert_err_eq!(a, b)`](macro@crate::assert_err_eq) 
+//!   ≈ (a ⇒ Err(a̅) ⇒ a̅) = (b ⇒ Err(b̅) ⇒ b̅)
+//!
+//! * [`assert_err_ne!(a, b)`](macro@crate::assert_err_ne) 
+//!   ≈ (a ⇒ Err(a̅) ⇒ a̅) ≠ (b ⇒ Err(b̅) ⇒ b̅)
+//!
+//! Compare Err(…) to an expression:
+//! 
+//! * [`assert_err_eq_expr!(a, expr)`](macro@crate::assert_err_eq_expr) 
+//!   ≈ (a ⇒ Err(a̅) ⇒ a̅) = b
+//!
+//! * [`assert_err_ne_expr!(a, b)`](macro@crate::assert_err_ne_expr) 
+//!   ≈ (a ⇒ Err(a̅) ⇒ a̅) ≠ b
+
+// Verify Err(_)
+pub mod assert_err;
+
+// Compare with another
+pub mod assert_err_eq;
+pub mod assert_err_ne;
+
+// Compare with expression
+pub mod assert_err_eq_expr;
+pub mod assert_err_ne_expr;
+

\ No newline at end of file
diff --git a/doc/src/lib/assert_none/assert_none.rs.html b/doc/src/lib/assert_none/assert_none.rs.html
new file mode 100644
index 000000000..849384846
--- /dev/null
+++ b/doc/src/lib/assert_none/assert_none.rs.html
@@ -0,0 +1,391 @@
+assert_none.rs - source
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+144
+145
+146
+147
+148
+149
+150
+151
+152
+153
+154
+155
+156
+157
+158
+159
+160
+161
+162
+163
+164
+165
+166
+167
+168
+169
+170
+171
+172
+173
+174
+175
+176
+177
+178
+179
+180
+181
+182
+183
+184
+185
+186
+187
+188
+189
+190
+191
+192
+193
+194
+195
+
//! Assert expression is None.
+//!
+//! Pseudocode:<br>
+//! a is None
+//!
+//! # Example
+//!
+//! ```rust
+//! use assertables::*;
+//! # fn main() {
+//! let a: Option<i8> = Option::None;
+//! assert_none!(a);
+//! # }
+//! ```
+//!
+//! # Module macros
+//!
+//! * [`assert_none`](macro@crate::assert_none)
+//! * [`assert_none_as_result`](macro@crate::assert_none_as_result)
+//! * [`debug_assert_none`](macro@crate::debug_assert_none)
+
+/// Assert an expression.is_none() is true.
+///
+/// Pseudocode:<br>
+/// a is None
+///
+/// * If true, return Result `Ok(())`.
+///
+/// * Otherwise, return Result `Err` with a diagnostic message.
+///
+/// This macro provides the same statements as [`assert_none`](macro.assert_none.html),
+/// except this macro returns a Result, rather than doing a panic.
+///
+/// This macro is useful for runtime checks, such as checking parameters,
+/// or sanitizing inputs, or handling different results in different ways.
+///
+/// # Module macros
+///
+/// * [`assert_none`](macro@crate::assert_none)
+/// * [`assert_none_as_result`](macro@crate::assert_none_as_result)
+/// * [`debug_assert_none`](macro@crate::debug_assert_none)
+///
+#[macro_export]
+macro_rules! assert_none_as_result {
+    ($a:expr $(,)?) => {{
+        match (&$a) {
+            a => {
+                match (a) {
+                    None => {
+                        Ok(())
+                    },
+                    _ => {
+                        Err(format!(
+                            concat!(
+                                "assertion failed: `assert_none!(a)`\n",
+                                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_none.html\n",
+                                " a label: `{}`,\n",
+                                " a debug: `{:?}`",
+                            ),
+                            stringify!($a),
+                            a
+                        ))
+                    }
+                }
+            }
+        }
+    }};
+}
+
+#[cfg(test)]
+mod tests {
+
+    #[test]
+    fn test_assert_none_as_result_x_success() {
+        let a: Option<i8> = Option::None;
+        let result = assert_none_as_result!(a);
+        assert_eq!(result, Ok(()));
+    }
+
+    #[test]
+    fn test_assert_none_as_result_x_failure() {
+        let a: Option<i8> = Option::Some(1);
+        let result = assert_none_as_result!(a);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err(),
+            concat!(
+                "assertion failed: `assert_none!(a)`\n",
+                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_none.html\n",
+                " a label: `a`,\n",
+                " a debug: `Some(1)`",
+            )
+        );
+    }
+}
+
+/// Assert expression is None.
+///
+/// Pseudocode:<br>
+/// a is None
+///
+/// * If true, return `()`.
+///
+/// * Otherwise, call [`panic!`] with a message and the values of the
+///   expressions with their debug representations.
+///
+/// # Examples
+///
+/// ```rust
+/// use assertables::*;
+/// # use std::panic;
+/// # fn main() {
+/// let a: Option<i8> = Option::None;
+/// assert_none!(a);
+///
+/// # let result = panic::catch_unwind(|| {
+/// let a: Option<i8> = Option::Some(1);
+/// assert_none!(a);
+/// # });
+/// // assertion failed: `assert_none!(a)`
+/// // https://docs.rs/assertables/8.11.0/assertables/macro.assert_none.html
+/// //  a label: `a`,
+/// //  a debug: `Some(1)`
+/// # let actual = result.unwrap_err().downcast::<String>().unwrap().to_string();
+/// # let expect = concat!(
+/// #     "assertion failed: `assert_none!(a)`\n",
+/// #     "https://docs.rs/assertables/8.11.0/assertables/macro.assert_none.html\n",
+/// #     " a label: `a`,\n",
+/// #     " a debug: `Some(1)`",
+/// # );
+/// # assert_eq!(actual, expect);
+/// # }
+/// ```
+///
+/// # Module macros
+///
+/// * [`assert_none`](macro@crate::assert_none)
+/// * [`assert_none_as_result`](macro@crate::assert_none_as_result)
+/// * [`debug_assert_none`](macro@crate::debug_assert_none)
+///
+#[macro_export]
+macro_rules! assert_none {
+    ($a:expr $(,)?) => {{
+        match $crate::assert_none_as_result!($a) {
+            Ok(()) => (),
+            Err(err) => panic!("{}", err),
+        }
+    }};
+    ($a:expr, $($message:tt)+) => {{
+        match $crate::assert_none_as_result!($a) {
+            Ok(()) => (),
+            Err(_err) => panic!("{}", $($message)+),
+        }
+    }};
+}
+
+/// Assert expression is None.
+///
+/// Pseudocode:<br>
+/// a is None
+///
+/// This macro provides the same statements as [`assert_none`](macro.assert_none.html),
+/// except this macro's statements are only enabled in non-optimized
+/// builds by default. An optimized build will not execute this macro's
+/// statements unless `-C debug-assertions` is passed to the compiler.
+///
+/// This macro is useful for checks that are too expensive to be present
+/// in a release build but may be helpful during development.
+///
+/// The result of expanding this macro is always type checked.
+///
+/// An unchecked assertion allows a program in an inconsistent state to
+/// keep running, which might have unexpected consequences but does not
+/// introduce unsafety as long as this only happens in safe code. The
+/// performance cost of assertions, however, is not measurable in general.
+/// Replacing `assert*!` with `debug_assert*!` is thus only encouraged
+/// after thorough profiling, and more importantly, only in safe code!
+///
+/// This macro is intended to work in a similar way to
+/// [`std::debug_assert`](https://doc.rust-lang.org/std/macro.debug_assert.html).
+///
+/// # Module macros
+///
+/// * [`assert_none`](macro@crate::assert_none)
+/// * [`assert_none`](macro@crate::assert_none)
+/// * [`debug_assert_none`](macro@crate::debug_assert_none)
+///
+#[macro_export]
+macro_rules! debug_assert_none {
+    ($($arg:tt)*) => {
+        if $crate::cfg!(debug_assertions) {
+            $crate::assert_none!($($arg)*);
+        }
+    };
+}
+

\ No newline at end of file
diff --git a/doc/src/lib/assert_none/mod.rs.html b/doc/src/lib/assert_none/mod.rs.html
new file mode 100644
index 000000000..5b1bd9b10
--- /dev/null
+++ b/doc/src/lib/assert_none/mod.rs.html
@@ -0,0 +1,21 @@
+mod.rs - source
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
//! Assert macro for None items.
+//!
+//! These macros help compare None items, such as `std::Option::None` or similar.
+//!
+//! Assert expression is None:
+//! 
+//! * [`assert_none!(a)`](macro@crate::assert_none) 
+//!   ≈ a is None
+
+pub mod assert_none;
+

\ No newline at end of file
diff --git a/doc/src/lib/assert_ok/assert_ok.rs.html b/doc/src/lib/assert_ok/assert_ok.rs.html
new file mode 100644
index 000000000..d262e2e84
--- /dev/null
+++ b/doc/src/lib/assert_ok/assert_ok.rs.html
@@ -0,0 +1,391 @@
+assert_ok.rs - source
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+144
+145
+146
+147
+148
+149
+150
+151
+152
+153
+154
+155
+156
+157
+158
+159
+160
+161
+162
+163
+164
+165
+166
+167
+168
+169
+170
+171
+172
+173
+174
+175
+176
+177
+178
+179
+180
+181
+182
+183
+184
+185
+186
+187
+188
+189
+190
+191
+192
+193
+194
+195
+
//! Assert expression is Ok(_).
+//!
+//! Pseudocode:<br>
+//! a is Ok(_)
+//!
+//! # Example
+//!
+//! ```rust
+//! use assertables::*;
+//! # fn main() {
+//! let a: Result<(), i8> = Ok(());
+//! assert_ok!(a);
+//! # }
+//! ```
+//!
+//! # Module macros
+//!
+//! * [`assert_ok`](macro@crate::assert_ok)
+//! * [`assert_ok_as_result`](macro@crate::assert_ok_as_result)
+//! * [`debug_assert_ok`](macro@crate::debug_assert_ok)
+
+/// Assert expression is Ok(_).
+///
+/// Pseudocode:<br>
+/// a is Ok(_)
+///
+/// * If true, return Result `Ok(())`.
+///
+/// * Otherwise, return Result `Err` with a diagnostic message.
+///
+/// This macro provides the same statements as [`assert_ok`](macro.assert_ok.html),
+/// except this macro returns a Result, rather than doing a panic.
+///
+/// This macro is useful for runtime checks, such as checking parameters,
+/// or sanitizing inputs, or handling different results in different ways.
+///
+/// # Module macros
+///
+/// * [`assert_ok`](macro@crate::assert_ok)
+/// * [`assert_ok_as_result`](macro@crate::assert_ok_as_result)
+/// * [`debug_assert_ok`](macro@crate::debug_assert_ok)
+///
+#[macro_export]
+macro_rules! assert_ok_as_result {
+    ($a:expr $(,)?) => {{
+        match (&$a) {
+            a => {
+                match (a) {
+                    Ok(_) => {
+                        Ok(())
+                    },
+                    _ => {
+                        Err(format!(
+                            concat!(
+                                "assertion failed: `assert_ok!(a)`\n",
+                                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ok.html\n",
+                                " a label: `{}`,\n",
+                                " a debug: `{:?}`",
+                            ),
+                            stringify!($a),
+                            a
+                        ))
+                    }
+                }
+            }
+        }
+    }};
+}
+
+#[cfg(test)]
+mod tests {
+
+    #[test]
+    fn test_assert_ok_as_result_x_success() {
+        let a: Result<(), i8> = Ok(());
+        let result = assert_ok_as_result!(a);
+        assert_eq!(result, Ok(()));
+    }
+
+    #[test]
+    fn test_assert_ok_as_result_x_failure() {
+        let a: Result<(), i8> = Err(1);
+        let result = assert_ok_as_result!(a);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err(),
+            concat!(
+                "assertion failed: `assert_ok!(a)`\n",
+                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ok.html\n",
+                " a label: `a`,\n",
+                " a debug: `Err(1)`",
+            )
+        );
+    }
+}
+
+/// Assert expression is Ok(_).
+///
+/// Pseudocode:<br>
+/// a is Ok(_)
+///
+/// * If true, return `()`.
+///
+/// * Otherwise, call [`panic!`] with a message and the values of the
+///   expressions with their debug representations.
+///
+/// # Examples
+///
+/// ```rust
+/// use assertables::*;
+/// # use std::panic;
+/// # fn main() {
+/// let a: Result<(), i8> = Ok(());
+/// assert_ok!(a);
+///
+/// # let result = panic::catch_unwind(|| {
+/// let a: Result<(), i8> = Err(1);
+/// assert_ok!(a);
+/// # });
+/// // assertion failed: `assert_ok!(a)`
+/// // https://docs.rs/assertables/8.11.0/assertables/macro.assert_ok.html
+/// //  a label: `a`,
+/// //  a debug: `Err(1)`
+/// # let actual = result.unwrap_err().downcast::<String>().unwrap().to_string();
+/// # let expect = concat!(
+/// #     "assertion failed: `assert_ok!(a)`\n",
+/// #     "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ok.html\n",
+/// #     " a label: `a`,\n",
+/// #     " a debug: `Err(1)`",
+/// # );
+/// # assert_eq!(actual, expect);
+/// # }
+/// ```
+///
+/// # Module macros
+///
+/// * [`assert_ok`](macro@crate::assert_ok)
+/// * [`assert_ok_as_result`](macro@crate::assert_ok_as_result)
+/// * [`debug_assert_ok`](macro@crate::debug_assert_ok)
+///
+#[macro_export]
+macro_rules! assert_ok {
+    ($a:expr $(,)?) => {{
+        match $crate::assert_ok_as_result!($a) {
+            Ok(()) => (),
+            Err(err) => panic!("{}", err),
+        }
+    }};
+    ($a:expr, $($message:tt)+) => {{
+        match $crate::assert_ok_as_result!($a) {
+            Ok(()) => (),
+            Err(_err) => panic!("{}", $($message)+),
+        }
+    }};
+}
+
+/// Assert expression is Ok(_).
+///
+/// Pseudocode:<br>
+/// a is Ok(_)
+///
+/// This macro provides the same statements as [`assert_ok`](macro.assert_ok.html),
+/// except this macro's statements are only enabled in non-optimized
+/// builds by default. An optimized build will not execute this macro's
+/// statements unless `-C debug-assertions` is passed to the compiler.
+///
+/// This macro is useful for checks that are too expensive to be present
+/// in a release build but may be helpful during development.
+///
+/// The result of expanding this macro is always type checked.
+///
+/// An unchecked assertion allows a program in an inconsistent state to
+/// keep running, which might have unexpected consequences but does not
+/// introduce unsafety as long as this only happens in safe code. The
+/// performance cost of assertions, however, is not measurable in general.
+/// Replacing `assert*!` with `debug_assert*!` is thus only encouraged
+/// after thorough profiling, and more importantly, only in safe code!
+///
+/// This macro is intended to work in a similar way to
+/// [`std::debug_assert`](https://doc.rust-lang.org/std/macro.debug_assert.html).
+///
+/// # Module macros
+///
+/// * [`assert_ok`](macro@crate::assert_ok)
+/// * [`assert_ok`](macro@crate::assert_ok)
+/// * [`debug_assert_ok`](macro@crate::debug_assert_ok)
+///
+#[macro_export]
+macro_rules! debug_assert_ok {
+    ($($arg:tt)*) => {
+        if $crate::cfg!(debug_assertions) {
+            $crate::assert_ok!($($arg)*);
+        }
+    };
+}
+

\ No newline at end of file
diff --git a/doc/src/lib/assert_ok/assert_ok_eq.rs.html b/doc/src/lib/assert_ok/assert_ok_eq.rs.html
new file mode 100644
index 000000000..0b046ba71
--- /dev/null
+++ b/doc/src/lib/assert_ok/assert_ok_eq.rs.html
@@ -0,0 +1,515 @@
+assert_ok_eq.rs - source
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+144
+145
+146
+147
+148
+149
+150
+151
+152
+153
+154
+155
+156
+157
+158
+159
+160
+161
+162
+163
+164
+165
+166
+167
+168
+169
+170
+171
+172
+173
+174
+175
+176
+177
+178
+179
+180
+181
+182
+183
+184
+185
+186
+187
+188
+189
+190
+191
+192
+193
+194
+195
+196
+197
+198
+199
+200
+201
+202
+203
+204
+205
+206
+207
+208
+209
+210
+211
+212
+213
+214
+215
+216
+217
+218
+219
+220
+221
+222
+223
+224
+225
+226
+227
+228
+229
+230
+231
+232
+233
+234
+235
+236
+237
+238
+239
+240
+241
+242
+243
+244
+245
+246
+247
+248
+249
+250
+251
+252
+253
+254
+255
+256
+257
+
//! Assert two expressions are Ok(_) and their values are equal.
+//!
+//! Pseudocode:<br>
+//! (a ⇒ Ok(a̅) ⇒ a̅) = (b ⇒ Ok(b̅) ⇒ b̅)
+//!
+//! # Example
+//!
+//! ```rust
+//! use assertables::*;
+//! # fn main() {
+//! let a: Result<i8, i8> = Ok(1);
+//! let b: Result<i8, i8> = Ok(1);
+//! assert_ok_eq!(a, b);
+//! # }
+//! ```
+//!
+//! # Module macros
+//!
+//! * [`assert_ok_eq`](macro@crate::assert_ok_eq)
+//! * [`assert_ok_eq_as_result`](macro@crate::assert_ok_eq_as_result)
+//! * [`debug_assert_ok_eq`](macro@crate::debug_assert_ok_eq)
+
+/// Assert two expressions are Ok(_) and their values are equal.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Ok(a̅) ⇒ a̅) = (b ⇒ Ok(b̅) ⇒ b̅)
+///
+/// * If true, return Result `Ok(())`.
+///
+/// * Otherwise, return Result `Err` with a diagnostic message.
+///
+/// This macro provides the same statements as [`assert_ok_eq`](macro.assert_ok_eq.html),
+/// except this macro returns a Result, rather than doing a panic.
+///
+/// This macro is useful for runtime checks, such as checking parameters,
+/// or sanitizing inputs, or handling different results in different ways.
+///
+/// # Module macros
+///
+/// * [`assert_ok_eq`](macro@crate::assert_ok_eq)
+/// * [`assert_ok_eq_as_result`](macro@crate::assert_ok_eq_as_result)
+/// * [`debug_assert_ok_eq`](macro@crate::debug_assert_ok_eq)
+///
+#[macro_export]
+macro_rules! assert_ok_eq_as_result {
+    ($a:expr, $b:expr $(,)?) => {{
+        match (&$a, &$b) {
+            (a, b) => {
+                match (a, b) {
+                    (Ok(a_inner), Ok(b_inner)) => {
+                        if a_inner == b_inner {
+                            Ok(())
+                        } else {
+                            Err(format!(
+                                concat!(
+                                    "assertion failed: `assert_ok_eq!(a, b)`\n",
+                                    "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ok_eq.html\n",
+                                    " a label: `{}`,\n",
+                                    " a debug: `{:?}`,\n",
+                                    " a inner: `{:?}`,\n",
+                                    " b label: `{}`,\n",
+                                    " b debug: `{:?}`,\n",
+                                    " b inner: `{:?}`"
+                                ),
+                                stringify!($a),
+                                a,
+                                a_inner,
+                                stringify!($b),
+                                b,
+                                b_inner
+                            ))
+                        }
+                    },
+                    _ => {
+                        Err(format!(
+                            concat!(
+                                "assertion failed: `assert_ok_eq!(a, b)`\n",
+                                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ok_eq.html\n",
+                                " a label: `{}`,\n",
+                                " a debug: `{:?}`,\n",
+                                " b label: `{}`,\n",
+                                " b debug: `{:?}`",
+                            ),
+                            stringify!($a),
+                            a,
+                            stringify!($b),
+                            b,
+                        ))
+                    }
+                }
+            }
+        }
+    }};
+}
+
+#[cfg(test)]
+mod tests {
+
+    #[test]
+    fn test_assert_ok_eq_as_result_x_success() {
+        let a: Result<i8, i8> = Ok(1);
+        let b: Result<i8, i8> = Ok(1);
+        let result = assert_ok_eq_as_result!(a, b);
+        assert_eq!(result, Ok(()));
+    }
+
+    #[test]
+    fn test_assert_ok_eq_as_result_x_failure_because_ne() {
+        let a: Result<i8, i8> = Ok(1);
+        let b: Result<i8, i8> = Ok(2);
+        let result = assert_ok_eq_as_result!(a, b);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err(),
+            concat!(
+                "assertion failed: `assert_ok_eq!(a, b)`\n",
+                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ok_eq.html\n",
+                " a label: `a`,\n",
+                " a debug: `Ok(1)`,\n",
+                " a inner: `1`,\n",
+                " b label: `b`,\n",
+                " b debug: `Ok(2)`,\n",
+                " b inner: `2`",
+            )
+        );
+    }
+
+    #[test]
+    fn test_assert_ok_eq_as_result_x_failure_because_not_ok() {
+        let a: Result<i8, i8> = Err(1);
+        let b: Result<i8, i8> = Ok(1);
+        let result = assert_ok_eq_as_result!(a, b);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err(),
+            concat!(
+                "assertion failed: `assert_ok_eq!(a, b)`\n",
+                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ok_eq.html\n",
+                " a label: `a`,\n",
+                " a debug: `Err(1)`,\n",
+                " b label: `b`,\n",
+                " b debug: `Ok(1)`",
+            )
+        );
+    }
+
+}
+
+/// Assert two expressions are Ok(_) and their values are equal.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Ok(a̅) ⇒ a̅) = (b ⇒ Ok(b̅) ⇒ b̅)
+///
+/// * If true, return `()`.
+///
+/// * Otherwise, call [`panic!`] with a message and the values of the
+///   expressions with their debug representations.
+///
+/// # Examples
+///
+/// ```rust
+/// use assertables::*;
+/// # use std::panic;
+/// # fn main() {
+/// let a: Result<i8, i8> = Ok(1);
+/// let b: Result<i8, i8> = Ok(1);
+/// assert_ok_eq!(a, b);
+///
+/// # let result = panic::catch_unwind(|| {
+/// let a: Result<i8, i8> = Ok(1);
+/// let b: Result<i8, i8> = Ok(2);
+/// assert_ok_eq!(a, b);
+/// # });
+/// // assertion failed: `assert_ok_eq!(a, b)`
+/// // https://docs.rs/assertables/8.11.0/assertables/macro.assert_ok_eq.html
+/// //  a label: `a`,
+/// //  a debug: `Ok(1)`,
+/// //  a inner: `1`,
+/// //  b label: `b`,
+/// //  b debug: `Ok(2)`,
+/// //  b inner: `2`
+/// # let actual = result.unwrap_err().downcast::<String>().unwrap().to_string();
+/// # let expect = concat!(
+/// #     "assertion failed: `assert_ok_eq!(a, b)`\n",
+/// #     "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ok_eq.html\n",
+/// #     " a label: `a`,\n",
+/// #     " a debug: `Ok(1)`,\n",
+/// #     " a inner: `1`,\n",
+/// #     " b label: `b`,\n",
+/// #     " b debug: `Ok(2)`,\n",
+/// #     " b inner: `2`",
+/// # );
+/// # assert_eq!(actual, expect);
+/// # }
+/// ```
+///
+/// # Module macros
+///
+/// * [`assert_ok_eq`](macro@crate::assert_ok_eq)
+/// * [`assert_ok_eq_as_result`](macro@crate::assert_ok_eq_as_result)
+/// * [`debug_assert_ok_eq`](macro@crate::debug_assert_ok_eq)
+///
+#[macro_export]
+macro_rules! assert_ok_eq {
+    ($a:expr, $b:expr $(,)?) => {{
+        match $crate::assert_ok_eq_as_result!($a, $b) {
+            Ok(()) => (),
+            Err(err) => panic!("{}", err),
+        }
+    }};
+    ($a:expr, $b:expr, $($message:tt)+) => {{
+        match $crate::assert_ok_eq_as_result!($a, $b) {
+            Ok(()) => (),
+            Err(_err) => panic!("{}", $($message)+),
+        }
+    }};
+}
+
+/// Assert two expressions are Ok(_) and their values are equal.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Ok(a̅) ⇒ a̅) = (b ⇒ Ok(b̅) ⇒ b̅)
+///
+/// This macro provides the same statements as [`assert_ok_eq`](macro.assert_ok_eq.html),
+/// except this macro's statements are only enabled in non-optimized
+/// builds by default. An optimized build will not execute this macro's
+/// statements unless `-C debug-assertions` is passed to the compiler.
+///
+/// This macro is useful for checks that are too expensive to be present
+/// in a release build but may be helpful during development.
+///
+/// The result of expanding this macro is always type checked.
+///
+/// An unchecked assertion allows a program in an inconsistent state to
+/// keep running, which might have unexpected consequences but does not
+/// introduce unsafety as long as this only happens in safe code. The
+/// performance cost of assertions, however, is not measurable in general.
+/// Replacing `assert*!` with `debug_assert*!` is thus only encouraged
+/// after thorough profiling, and more importantly, only in safe code!
+///
+/// This macro is intended to work in a similar way to
+/// [`std::debug_assert`](https://doc.rust-lang.org/std/macro.debug_assert.html).
+///
+/// # Module macros
+///
+/// * [`assert_ok_eq`](macro@crate::assert_ok_eq)
+/// * [`assert_ok_eq`](macro@crate::assert_ok_eq)
+/// * [`debug_assert_ok_eq`](macro@crate::debug_assert_ok_eq)
+///
+#[macro_export]
+macro_rules! debug_assert_ok_eq {
+    ($($arg:tt)*) => {
+        if $crate::cfg!(debug_assertions) {
+            $crate::assert_ok_eq!($($arg)*);
+        }
+    };
+}
+

\ No newline at end of file
diff --git a/doc/src/lib/assert_ok/assert_ok_eq_expr.rs.html b/doc/src/lib/assert_ok/assert_ok_eq_expr.rs.html
new file mode 100644
index 000000000..d1d5d4668
--- /dev/null
+++ b/doc/src/lib/assert_ok/assert_ok_eq_expr.rs.html
@@ -0,0 +1,505 @@
+assert_ok_eq_expr.rs - source
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+144
+145
+146
+147
+148
+149
+150
+151
+152
+153
+154
+155
+156
+157
+158
+159
+160
+161
+162
+163
+164
+165
+166
+167
+168
+169
+170
+171
+172
+173
+174
+175
+176
+177
+178
+179
+180
+181
+182
+183
+184
+185
+186
+187
+188
+189
+190
+191
+192
+193
+194
+195
+196
+197
+198
+199
+200
+201
+202
+203
+204
+205
+206
+207
+208
+209
+210
+211
+212
+213
+214
+215
+216
+217
+218
+219
+220
+221
+222
+223
+224
+225
+226
+227
+228
+229
+230
+231
+232
+233
+234
+235
+236
+237
+238
+239
+240
+241
+242
+243
+244
+245
+246
+247
+248
+249
+250
+251
+252
+
//! Assert an expression is Ok(_) and its value is equal to an expression.
+//!
+//! Pseudocode:<br>
+//! (a ⇒ Ok(a̅) ⇒ a̅) = b
+//!
+//! # Example
+//!
+//! ```rust
+//! use assertables::*;
+//! # fn main() {
+//! let a: Result<i8, i8> = Ok(1);
+//! let b: i8 = 1;
+//! assert_ok_eq_expr!(a, b);
+//! # }
+//! ```
+//!
+//! # Module macros
+//!
+//! * [`assert_ok_eq_expr`](macro@crate::assert_ok_eq_expr)
+//! * [`assert_ok_eq_expr_as_result`](macro@crate::assert_ok_eq_expr_as_result)
+//! * [`debug_assert_ok_eq_expr`](macro@crate::debug_assert_ok_eq_expr)
+
+/// Assert an expression is Ok(_) and its value is equal to an expression.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Ok(a̅) ⇒ a̅) = b
+///
+/// * If true, return Result `Ok(())`.
+///
+/// * Otherwise, return Result `Err` with a diagnostic message.
+///
+/// This macro provides the same statements as [`assert_ok_eq_expr`](macro.assert_ok_eq_expr.html),
+/// except this macro returns a Result, rather than doing a panic.
+///
+/// This macro is useful for runtime checks, such as checking parameters,
+/// or sanitizing inputs, or handling different results in different ways.
+///
+/// # Module macros
+///
+/// * [`assert_ok_eq_expr`](macro@crate::assert_ok_eq_expr)
+/// * [`assert_ok_eq_expr_as_result`](macro@crate::assert_ok_eq_expr_as_result)
+/// * [`debug_assert_ok_eq_expr`](macro@crate::debug_assert_ok_eq_expr)
+///
+#[macro_export]
+macro_rules! assert_ok_eq_expr_as_result {
+    ($a:expr, $b:expr $(,)?) => {{
+        match (&$a, &$b) {
+            (a, b) => {
+                match a {
+                    Ok(a_inner) => {
+                        if a_inner == b {
+                            Ok(())
+                        } else {
+                            Err(format!(
+                                concat!(
+                                    "assertion failed: `assert_ok_eq_expr!(a, b)`\n",
+                                    "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ok_eq_expr.html\n",
+                                    " a label: `{}`,\n",
+                                    " a debug: `{:?}`,\n",
+                                    " a inner: `{:?}`,\n",
+                                    " b label: `{}`,\n",
+                                    " b debug: `{:?}`",
+                                ),
+                                stringify!($a),
+                                a,
+                                a_inner,
+                                stringify!($b),
+                                b
+                            ))
+                        }
+                    },
+                    _ => {
+                        Err(format!(
+                            concat!(
+                                "assertion failed: `assert_ok_eq_expr!(a, b)`\n",
+                                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ok_eq_expr.html\n",
+                                " a label: `{}`,\n",
+                                " a debug: `{:?}`,\n",
+                                " b label: `{}`,\n",
+                                " b debug: `{:?}`",
+                            ),
+                            stringify!($a),
+                            a,
+                            stringify!($b),
+                            b,
+                        ))
+                    }
+                }
+            }
+        }
+    }};
+}
+
+#[cfg(test)]
+mod tests {
+
+    #[test]
+    fn test_assert_ok_eq_expr_as_result_x_success() {
+        let a: Result<i8, i8> = Ok(1);
+        let b: i8 = 1;
+        let result = assert_ok_eq_expr_as_result!(a, b);
+        assert_eq!(result, Ok(()));
+    }
+
+    #[test]
+    fn test_assert_ok_eq_expr_as_result_x_failure_because_ne() {
+        let a: Result<i8, i8> = Ok(1);
+        let b: i8 = 2;
+        let result = assert_ok_eq_expr_as_result!(a, b);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err(),
+            concat!(
+                "assertion failed: `assert_ok_eq_expr!(a, b)`\n",
+                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ok_eq_expr.html\n",
+                " a label: `a`,\n",
+                " a debug: `Ok(1)`,\n",
+                " a inner: `1`,\n",
+                " b label: `b`,\n",
+                " b debug: `2`"
+            )
+        );
+    }
+
+    #[test]
+    fn test_assert_ok_eq_expr_as_result_x_failure_because_not_ok() {
+        let a: Result<i8, i8> = Err(1);
+        let b: i8 = 1;
+        let result = assert_ok_eq_expr_as_result!(a, b);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err(),
+            concat!(
+                "assertion failed: `assert_ok_eq_expr!(a, b)`\n",
+                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ok_eq_expr.html\n",
+                " a label: `a`,\n",
+                " a debug: `Err(1)`,\n",
+                " b label: `b`,\n",
+                " b debug: `1`",
+            )
+        );
+    }
+
+}
+
+/// Assert an expression is Ok(_) and its value is equal to an expression.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Ok(a̅) ⇒ a̅) = b
+///
+/// * If true, return `()`.
+///
+/// * Otherwise, call [`panic!`] with a message and the values of the
+///   expressions with their debug representations.
+///
+/// # Examples
+///
+/// ```rust
+/// use assertables::*;
+/// # use std::panic;
+/// # fn main() {
+/// let a: Result<i8, i8> = Ok(1);
+/// let b: i8 = 1;
+/// assert_ok_eq_expr!(a, b);
+///
+/// # let result = panic::catch_unwind(|| {
+/// let a: Result<i8, i8> = Ok(1);
+/// let b: i8 = 2;
+/// assert_ok_eq_expr!(a, b);
+/// # });
+/// // assertion failed: `assert_ok_eq_expr!(a, b)`
+/// // https://docs.rs/assertables/8.11.0/assertables/macro.assert_ok_eq_expr.html
+/// //  a label: `a`,
+/// //  a debug: `Ok(1)`,
+/// //  a inner: `1`,
+/// //  b label: `b`,
+/// //  b debug: `2`
+/// # let actual = result.unwrap_err().downcast::<String>().unwrap().to_string();
+/// # let expect = concat!(
+/// #     "assertion failed: `assert_ok_eq_expr!(a, b)`\n",
+/// #     "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ok_eq_expr.html\n",
+/// #     " a label: `a`,\n",
+/// #     " a debug: `Ok(1)`,\n",
+/// #     " a inner: `1`,\n",
+/// #     " b label: `b`,\n",
+/// #     " b debug: `2`",
+/// # );
+/// # assert_eq!(actual, expect);
+/// # }
+/// ```
+///
+/// # Module macros
+///
+/// * [`assert_ok_eq_expr`](macro@crate::assert_ok_eq_expr)
+/// * [`assert_ok_eq_expr_as_result`](macro@crate::assert_ok_eq_expr_as_result)
+/// * [`debug_assert_ok_eq_expr`](macro@crate::debug_assert_ok_eq_expr)
+///
+#[macro_export]
+macro_rules! assert_ok_eq_expr {
+    ($a:expr, $b:expr $(,)?) => {{
+        match $crate::assert_ok_eq_expr_as_result!($a, $b) {
+            Ok(()) => (),
+            Err(err) => panic!("{}", err),
+        }
+    }};
+    ($a:expr, $b:expr, $($message:tt)+) => {{
+        match $crate::assert_ok_eq_expr_as_result!($a, $b) {
+            Ok(()) => (),
+            Err(_err) => panic!("{}", $($message)+),
+        }
+    }};
+}
+
+/// Assert an expression is Ok(_) and its value is equal to an expression.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Ok(a̅) ⇒ a̅) = b
+///
+/// This macro provides the same statements as [`assert_ok_eq_expr`](macro.assert_ok_eq_expr.html),
+/// except this macro's statements are only enabled in non-optimized
+/// builds by default. An optimized build will not execute this macro's
+/// statements unless `-C debug-assertions` is passed to the compiler.
+///
+/// This macro is useful for checks that are too expensive to be present
+/// in a release build but may be helpful during development.
+///
+/// The result of expanding this macro is always type checked.
+///
+/// An unchecked assertion allows a program in an inconsistent state to
+/// keep running, which might have unexpected consequences but does not
+/// introduce unsafety as long as this only happens in safe code. The
+/// performance cost of assertions, however, is not measurable in general.
+/// Replacing `assert*!` with `debug_assert*!` is thus only encouraged
+/// after thorough profiling, and more importantly, only in safe code!
+///
+/// This macro is intended to work in a similar way to
+/// [`std::debug_assert`](https://doc.rust-lang.org/std/macro.debug_assert.html).
+///
+/// # Module macros
+///
+/// * [`assert_ok_eq_expr`](macro@crate::assert_ok_eq_expr)
+/// * [`assert_ok_eq_expr`](macro@crate::assert_ok_eq_expr)
+/// * [`debug_assert_ok_eq_expr`](macro@crate::debug_assert_ok_eq_expr)
+///
+#[macro_export]
+macro_rules! debug_assert_ok_eq_expr {
+    ($($arg:tt)*) => {
+        if $crate::cfg!(debug_assertions) {
+            $crate::assert_ok_eq_expr!($($arg)*);
+        }
+    };
+}
+

\ No newline at end of file
diff --git a/doc/src/lib/assert_ok/assert_ok_ne.rs.html b/doc/src/lib/assert_ok/assert_ok_ne.rs.html
new file mode 100644
index 000000000..97055a4b5
--- /dev/null
+++ b/doc/src/lib/assert_ok/assert_ok_ne.rs.html
@@ -0,0 +1,509 @@
+assert_ok_ne.rs - source
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+144
+145
+146
+147
+148
+149
+150
+151
+152
+153
+154
+155
+156
+157
+158
+159
+160
+161
+162
+163
+164
+165
+166
+167
+168
+169
+170
+171
+172
+173
+174
+175
+176
+177
+178
+179
+180
+181
+182
+183
+184
+185
+186
+187
+188
+189
+190
+191
+192
+193
+194
+195
+196
+197
+198
+199
+200
+201
+202
+203
+204
+205
+206
+207
+208
+209
+210
+211
+212
+213
+214
+215
+216
+217
+218
+219
+220
+221
+222
+223
+224
+225
+226
+227
+228
+229
+230
+231
+232
+233
+234
+235
+236
+237
+238
+239
+240
+241
+242
+243
+244
+245
+246
+247
+248
+249
+250
+251
+252
+253
+254
+
//! Assert two expressions are Ok(_) and their values are not equal.
+//!
+//! Pseudocode:<br>
+//! (a ⇒ Ok(a̅) ⇒ a̅) ≠ (b ⇒ Ok(b̅) ⇒ b̅)
+//!
+//! # Example
+//!
+//! ```rust
+//! use assertables::*;
+//! # fn main() {
+//! let a: Result<i8, i8> = Ok(1);
+//! let b: Result<i8, i8> = Ok(2);
+//! assert_ok_ne!(a, b);
+//! # }
+//! ```
+//!
+//! # Module macros
+//!
+//! * [`assert_ok_ne`](macro@crate::assert_ok_ne)
+//! * [`assert_ok_ne_as_result`](macro@crate::assert_ok_ne_as_result)
+//! * [`debug_assert_ok_ne`](macro@crate::debug_assert_ok_ne)
+
+/// Assert two expressions are Ok(_) and their values are not equal.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Ok(a̅) ⇒ a̅) ≠ (b ⇒ Ok(b̅) ⇒ b̅)
+///
+/// * If true, return Result `Ok(())`.
+///
+/// * Otherwise, return Result `Err` with a diagnostic message.
+///
+/// This macro provides the same statements as [`assert_ok_ne`](macro.assert_ok_ne.html),
+/// except this macro returns a Result, rather than doing a panic.
+///
+/// This macro is useful for runtime checks, such as checking parameters,
+/// or sanitizing inputs, or handling different results in different ways.
+///
+/// # Module macros
+///
+/// * [`assert_ok_ne`](macro@crate::assert_ok_ne)
+/// * [`assert_ok_ne_as_result`](macro@crate::assert_ok_ne_as_result)
+/// * [`debug_assert_ok_ne`](macro@crate::debug_assert_ok_ne)
+///
+#[macro_export]
+macro_rules! assert_ok_ne_as_result {
+    ($a:expr, $b:expr $(,)?) => {{
+        match (&$a, &$b) {
+            (a, b) => {
+                match (a, b) {
+                    (Ok(a_inner), Ok(b_inner)) => {
+                        if a_inner != b_inner {
+                            Ok(())
+                        } else {
+                            Err(format!(
+                                concat!(
+                                    "assertion failed: `assert_ok_ne!(a, b)`\n",
+                                    "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ok_ne.html\n",
+                                    " a label: `{}`,\n",
+                                    " a debug: `{:?}`,\n",
+                                    " a inner: `{:?}`,\n",
+                                    " b label: `{}`,\n",
+                                    " b debug: `{:?}`,\n",
+                                    " b inner: `{:?}`"
+                                ),
+                                stringify!($a),
+                                a,
+                                a_inner,
+                                stringify!($b),
+                                b,
+                                b_inner
+                            ))
+                        }
+                    },
+                    _ => {
+                        Err(format!(
+                            concat!(
+                                "assertion failed: `assert_ok_ne!(a, b)`\n",
+                                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ok_ne.html\n",
+                                " a label: `{}`,\n",
+                                " a debug: `{:?}`,\n",
+                                " b label: `{}`,\n",
+                                " b debug: `{:?}`",
+                            ),
+                            stringify!($a),
+                            a,
+                            stringify!($b),
+                            b,
+                        ))
+                    }
+                }
+            }
+        }
+    }};
+}
+
+#[cfg(test)]
+mod tests {
+
+    #[test]
+    fn test_assert_ok_ne_as_result_x_success() {
+        let a: Result<i8, i8> = Ok(1);
+        let b: Result<i8, i8> = Ok(2);
+        let result = assert_ok_ne_as_result!(a, b);
+        assert_eq!(result, Ok(()));
+    }
+
+    #[test]
+    fn test_assert_ok_ne_as_result_x_failure_because_eq() {
+        let a: Result<i8, i8> = Ok(1);
+        let b: Result<i8, i8> = Ok(1);
+        let result = assert_ok_ne_as_result!(a, b);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err(),
+            concat!(
+                "assertion failed: `assert_ok_ne!(a, b)`\n",
+                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ok_ne.html\n",
+                " a label: `a`,\n",
+                " a debug: `Ok(1)`,\n",
+                " a inner: `1`,\n",
+                " b label: `b`,\n",
+                " b debug: `Ok(1)`,\n",
+                " b inner: `1`",
+            )
+        );
+    }
+
+    #[test]
+    fn test_assert_ok_ne_as_result_x_failure_because_not_ok() {
+        let a: Result<i8, i8> = Err(1);
+        let b: Result<i8, i8> = Ok(1);
+        let result = assert_ok_ne_as_result!(a, b);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err(),
+            concat!(
+                "assertion failed: `assert_ok_ne!(a, b)`\n",
+                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ok_ne.html\n",
+                " a label: `a`,\n",
+                " a debug: `Err(1)`,\n",
+                " b label: `b`,\n",
+                " b debug: `Ok(1)`",
+            )
+        );
+    }
+
+}
+
+/// Assert two expressions are Ok(_) and their values are not equal.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Ok(a̅) ⇒ a̅) ≠ (b ⇒ Ok(b̅) ⇒ b̅)
+///
+/// * If true, return `()`.
+///
+/// * Otherwise, call [`panic!`] with a message and the values of the
+///   expressions with their debug representations.
+///
+/// # Examples
+///
+/// ```rust
+/// use assertables::*;
+/// # use std::panic;
+/// # fn main() {
+/// let a: Result<i8, i8> = Ok(1);
+/// let b: Result<i8, i8> = Ok(2);
+/// assert_ok_ne!(a, b);
+///
+/// # let result = panic::catch_unwind(|| {
+/// let a: Result<i8, i8> = Ok(1);
+/// let b: Result<i8, i8> = Ok(1);
+/// assert_ok_ne!(a, b);
+/// # });
+/// // assertion failed: `assert_ok_ne!(a, b)`
+/// // https://docs.rs/assertables/8.11.0/assertables/macro.assert_ok_ne.html
+/// //  a label: `a`,
+/// //  a debug: `Ok(1)`,
+/// //  a inner: `1`,
+/// //  b label: `b`,
+/// //  b debug: `Ok(1)`,
+/// //  b inner: `1`
+/// # let actual = result.unwrap_err().downcast::<String>().unwrap().to_string();
+/// # let expect = concat!(
+/// #     "assertion failed: `assert_ok_ne!(a, b)`\n",
+/// #     "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ok_ne.html\n",
+/// #     " a label: `a`,\n",
+/// #     " a debug: `Ok(1)`,\n",
+/// #     " a inner: `1`,\n",
+/// #     " b label: `b`,\n",
+/// #     " b debug: `Ok(1)`,\n",
+/// #     " b inner: `1`",
+/// # );
+/// # assert_eq!(actual, expect);
+/// # }
+/// ```
+///
+/// # Module macros
+///
+/// * [`assert_ok_ne`](macro@crate::assert_ok_ne)
+/// * [`assert_ok_ne_as_result`](macro@crate::assert_ok_ne_as_result)
+/// * [`debug_assert_ok_ne`](macro@crate::debug_assert_ok_ne)
+///
+#[macro_export]
+macro_rules! assert_ok_ne {
+    ($a:expr, $b:expr $(,)?) => {{
+        match $crate::assert_ok_ne_as_result!($a, $b) {
+            Ok(()) => (),
+            Err(err) => panic!("{}", err),
+        }
+    }};
+    ($a:expr, $b:expr, $($message:tt)+) => {{
+        match $crate::assert_ok_ne_as_result!($a, $b) {
+            Ok(()) => (),
+            Err(_err) => panic!("{}", $($message)+),
+        }
+    }};
+}
+
+/// Assert two expressions are Ok(_) and their values are not equal.
+///
+/// This macro provides the same statements as [`assert_ok_ne`](macro.assert_ok_ne.html),
+/// except this macro's statements are only enabled in non-optimized
+/// builds by default. An optimized build will not execute this macro's
+/// statements unless `-C debug-assertions` is passed to the compiler.
+///
+/// This macro is useful for checks that are too expensive to be present
+/// in a release build but may be helpful during development.
+///
+/// The result of expanding this macro is always type checked.
+///
+/// An unchecked assertion allows a program in an inconsistent state to
+/// keep running, which might have unexpected consequences but does not
+/// introduce unsafety as long as this only happens in safe code. The
+/// performance cost of assertions, however, is not measurable in general.
+/// Replacing `assert*!` with `debug_assert*!` is thus only encouraged
+/// after thorough profiling, and more importantly, only in safe code!
+///
+/// This macro is intended to work in a similar way to
+/// [`std::debug_assert`](https://doc.rust-lang.org/std/macro.debug_assert.html).
+///
+/// # Module macros
+///
+/// * [`assert_ok_ne`](macro@crate::assert_ok_ne)
+/// * [`assert_ok_ne`](macro@crate::assert_ok_ne)
+/// * [`debug_assert_ok_ne`](macro@crate::debug_assert_ok_ne)
+///
+#[macro_export]
+macro_rules! debug_assert_ok_ne {
+    ($($arg:tt)*) => {
+        if $crate::cfg!(debug_assertions) {
+            $crate::assert_ok_ne!($($arg)*);
+        }
+    };
+}
+

\ No newline at end of file
diff --git a/doc/src/lib/assert_ok/assert_ok_ne_expr.rs.html b/doc/src/lib/assert_ok/assert_ok_ne_expr.rs.html
new file mode 100644
index 000000000..8c4b16f80
--- /dev/null
+++ b/doc/src/lib/assert_ok/assert_ok_ne_expr.rs.html
@@ -0,0 +1,505 @@
+assert_ok_ne_expr.rs - source
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+144
+145
+146
+147
+148
+149
+150
+151
+152
+153
+154
+155
+156
+157
+158
+159
+160
+161
+162
+163
+164
+165
+166
+167
+168
+169
+170
+171
+172
+173
+174
+175
+176
+177
+178
+179
+180
+181
+182
+183
+184
+185
+186
+187
+188
+189
+190
+191
+192
+193
+194
+195
+196
+197
+198
+199
+200
+201
+202
+203
+204
+205
+206
+207
+208
+209
+210
+211
+212
+213
+214
+215
+216
+217
+218
+219
+220
+221
+222
+223
+224
+225
+226
+227
+228
+229
+230
+231
+232
+233
+234
+235
+236
+237
+238
+239
+240
+241
+242
+243
+244
+245
+246
+247
+248
+249
+250
+251
+252
+
//! Assert an expression is Ok(_) and its value is not equal to an expression.
+//!
+//! Pseudocode:<br>
+//! (a ⇒ Ok(a̅) ⇒ a̅) ≠ b
+//!
+//! # Example
+//!
+//! ```rust
+//! use assertables::*;
+//! # fn main() {
+//! let a: Result<i8, i8> = Ok(1);
+//! let b: i8 = 2;
+//! assert_ok_ne_expr!(a, b);
+//! # }
+//! ```
+//!
+//! # Module macros
+//!
+//! * [`assert_ok_ne_expr`](macro@crate::assert_ok_ne_expr)
+//! * [`assert_ok_ne_expr_as_result`](macro@crate::assert_ok_ne_expr_as_result)
+//! * [`debug_assert_ok_ne_expr`](macro@crate::debug_assert_ok_ne_expr)
+
+/// Assert an expression is Ok(_) and its value is equal to an expression.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Ok(a̅) ⇒ a̅) = b
+///
+/// * If true, return Result `Ok(())`.
+///
+/// * Otherwise, return Result `Err` with a diagnostic message.
+///
+/// This macro provides the same statements as [`assert_ok_ne_expr`](macro.assert_ok_ne_expr.html),
+/// except this macro returns a Result, rather than doing a panic.
+///
+/// This macro is useful for runtime checks, such as checking parameters,
+/// or sanitizing inputs, or handling different results in different ways.
+///
+/// # Module macros
+///
+/// * [`assert_ok_ne_expr`](macro@crate::assert_ok_ne_expr)
+/// * [`assert_ok_ne_expr_as_result`](macro@crate::assert_ok_ne_expr_as_result)
+/// * [`debug_assert_ok_ne_expr`](macro@crate::debug_assert_ok_ne_expr)
+///
+#[macro_export]
+macro_rules! assert_ok_ne_expr_as_result {
+    ($a:expr, $b:expr $(,)?) => {{
+        match (&$a, &$b) {
+            (a, b) => {
+                match a {
+                    Ok(a_inner) => {
+                        if a_inner != b {
+                            Ok(())
+                        } else {
+                            Err(format!(
+                                concat!(
+                                    "assertion failed: `assert_ok_ne_expr!(a, b)`\n",
+                                    "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ok_ne_expr.html\n",
+                                    " a label: `{}`,\n",
+                                    " a debug: `{:?}`,\n",
+                                    " a inner: `{:?}`,\n",
+                                    " b label: `{}`,\n",
+                                    " b debug: `{:?}`",
+                                ),
+                                stringify!($a),
+                                a,
+                                a_inner,
+                                stringify!($b),
+                                b
+                            ))
+                        }
+                    },
+                    _ => {
+                        Err(format!(
+                            concat!(
+                                "assertion failed: `assert_ok_ne_expr!(a, b)`\n",
+                                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ok_ne_expr.html\n",
+                                " a label: `{}`,\n",
+                                " a debug: `{:?}`,\n",
+                                " b label: `{}`,\n",
+                                " b debug: `{:?}`",
+                            ),
+                            stringify!($a),
+                            a,
+                            stringify!($b),
+                            b,
+                        ))
+                    }
+                }
+            }
+        }
+    }};
+}
+
+#[cfg(test)]
+mod tests {
+
+    #[test]
+    fn test_assert_ok_ne_expr_as_result_x_success() {
+        let a: Result<i8, i8> = Ok(1);
+        let b: i8 = 2;
+        let result = assert_ok_ne_expr_as_result!(a, b);
+        assert_eq!(result, Ok(()));
+    }
+
+    #[test]
+    fn test_assert_ok_ne_expr_as_result_x_failure_because_ne() {
+        let a: Result<i8, i8> = Ok(1);
+        let b: i8 = 1;
+        let result = assert_ok_ne_expr_as_result!(a, b);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err(),
+            concat!(
+                "assertion failed: `assert_ok_ne_expr!(a, b)`\n",
+                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ok_ne_expr.html\n",
+                " a label: `a`,\n",
+                " a debug: `Ok(1)`,\n",
+                " a inner: `1`,\n",
+                " b label: `b`,\n",
+                " b debug: `1`",
+            )
+        );
+    }
+
+    #[test]
+    fn test_assert_ok_ne_expr_as_result_x_failure_because_not_ok() {
+        let a: Result<i8, i8> = Err(1);
+        let b: i8 = 2;
+        let result = assert_ok_ne_expr_as_result!(a, b);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err(),
+            concat!(
+                "assertion failed: `assert_ok_ne_expr!(a, b)`\n",
+                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ok_ne_expr.html\n",
+                " a label: `a`,\n",
+                " a debug: `Err(1)`,\n",
+                " b label: `b`,\n",
+                " b debug: `2`",
+            )
+        );
+    }
+
+}
+
+/// Assert an expression is Ok(_) and its value is equal to an expression.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Ok(a̅) ⇒ a̅) ≠ b
+///
+/// * If true, return `()`.
+///
+/// * Otherwise, call [`panic!`] with a message and the values of the
+///   expressions with their debug representations.
+///
+/// # Examples
+///
+/// ```rust
+/// use assertables::*;
+/// # use std::panic;
+/// # fn main() {
+/// let a: Result<i8, i8> = Ok(1);
+/// let b: i8 = 2;
+/// assert_ok_ne_expr!(a, b);
+///
+/// # let result = panic::catch_unwind(|| {
+/// let a: Result<i8, i8> = Ok(1);
+/// let b: i8 = 1;
+/// assert_ok_ne_expr!(a, b);
+/// # });
+/// // assertion failed: `assert_ok_ne_expr!(a, b)`
+/// // https://docs.rs/assertables/8.11.0/assertables/macro.assert_ok_ne_expr.html
+/// //  a label: `a`,
+/// //  a debug: `Ok(1)`,
+/// //  a inner: `1`,
+/// //  b label: `b`,
+/// //  b debug: `1`
+/// # let actual = result.unwrap_err().downcast::<String>().unwrap().to_string();
+/// # let expect = concat!(
+/// #     "assertion failed: `assert_ok_ne_expr!(a, b)`\n",
+/// #     "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ok_ne_expr.html\n",
+/// #     " a label: `a`,\n",
+/// #     " a debug: `Ok(1)`,\n",
+/// #     " a inner: `1`,\n",
+/// #     " b label: `b`,\n",
+/// #     " b debug: `1`",
+/// # );
+/// # assert_eq!(actual, expect);
+/// # }
+/// ```
+///
+/// # Module macros
+///
+/// * [`assert_ok_ne_expr`](macro@crate::assert_ok_ne_expr)
+/// * [`assert_ok_ne_expr_as_result`](macro@crate::assert_ok_ne_expr_as_result)
+/// * [`debug_assert_ok_ne_expr`](macro@crate::debug_assert_ok_ne_expr)
+///
+#[macro_export]
+macro_rules! assert_ok_ne_expr {
+    ($a:expr, $b:expr $(,)?) => {{
+        match $crate::assert_ok_ne_expr_as_result!($a, $b) {
+            Ok(()) => (),
+            Err(err) => panic!("{}", err),
+        }
+    }};
+    ($a:expr, $b:expr, $($message:tt)+) => {{
+        match $crate::assert_ok_ne_expr_as_result!($a, $b) {
+            Ok(()) => (),
+            Err(_err) => panic!("{}", $($message)+),
+        }
+    }};
+}
+
+/// Assert an expression is Ok(_) and its value is equal to an expression.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Ok(a̅) ⇒ a̅) ≠ b
+///
+/// This macro provides the same statements as [`assert_ok_ne_expr`](macro.assert_ok_ne_expr.html),
+/// except this macro's statements are only enabled in non-optimized
+/// builds by default. An optimized build will not execute this macro's
+/// statements unless `-C debug-assertions` is passed to the compiler.
+///
+/// This macro is useful for checks that are too expensive to be present
+/// in a release build but may be helpful during development.
+///
+/// The result of expanding this macro is always type checked.
+///
+/// An unchecked assertion allows a program in an inconsistent state to
+/// keep running, which might have unexpected consequences but does not
+/// introduce unsafety as long as this only happens in safe code. The
+/// performance cost of assertions, however, is not measurable in general.
+/// Replacing `assert*!` with `debug_assert*!` is thus only encouraged
+/// after thorough profiling, and more importantly, only in safe code!
+///
+/// This macro is intended to work in a similar way to
+/// [`std::debug_assert`](https://doc.rust-lang.org/std/macro.debug_assert.html).
+///
+/// # Module macros
+///
+/// * [`assert_ok_ne_expr`](macro@crate::assert_ok_ne_expr)
+/// * [`assert_ok_ne_expr`](macro@crate::assert_ok_ne_expr)
+/// * [`debug_assert_ok_ne_expr`](macro@crate::debug_assert_ok_ne_expr)
+///
+#[macro_export]
+macro_rules! debug_assert_ok_ne_expr {
+    ($($arg:tt)*) => {
+        if $crate::cfg!(debug_assertions) {
+            $crate::assert_ok_ne_expr!($($arg)*);
+        }
+    };
+}
+

\ No newline at end of file
diff --git a/doc/src/lib/assert_ok/mod.rs.html b/doc/src/lib/assert_ok/mod.rs.html
new file mode 100644
index 000000000..a5febdd0e
--- /dev/null
+++ b/doc/src/lib/assert_ok/mod.rs.html
@@ -0,0 +1,71 @@
+mod.rs - source
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+
//! Assert macros for Ok(_) items.
+//!
+//! These macros help compare Ok(…) items, such as `std::Result::Ok` or similar.
+//!
+//! Assert expression is Ok(_):
+//! 
+//! * [`assert_ok!(a)`](macro@crate::assert_ok) 
+//!   ≈ a is Ok(_)
+//! 
+//! Compare Ok(…) to another Ok(…):
+//! 
+//! * [`assert_ok_eq!(a, b)`](macro@crate::assert_ok_eq) 
+//!   ≈ (a ⇒ Ok(a̅) ⇒ a̅) = (b ⇒ Ok(b̅) ⇒ b̅)
+//!
+//! * [`assert_ok_ne!(a, b)`](macro@crate::assert_ok_ne) 
+//!   ≈ (a ⇒ Ok(a̅) ⇒ a̅) ≠ (b ⇒ Ok(b̅) ⇒ b̅)
+//!
+//! Compare Ok(…) to an expression:
+//! 
+//! * [`assert_ok_eq_expr!(a, expr)`](macro@crate::assert_ok_eq_expr) 
+//!   ≈ (a ⇒ Ok(a̅) ⇒ a̅) = b
+//!
+//! * [`assert_ok_ne_expr!(a, b)`](macro@crate::assert_ok_ne_expr) 
+//!   ≈ (a ⇒ Ok(a̅) ⇒ a̅) ≠ b
+
+// Verify Ok(_)
+pub mod assert_ok;
+
+// Compare with another
+pub mod assert_ok_eq;
+pub mod assert_ok_ne;
+
+// Compare with expression
+pub mod assert_ok_eq_expr;
+pub mod assert_ok_ne_expr;
+

\ No newline at end of file
diff --git a/doc/src/lib/assert_pending/assert_pending.rs.html b/doc/src/lib/assert_pending/assert_pending.rs.html
new file mode 100644
index 000000000..7281a3bf9
--- /dev/null
+++ b/doc/src/lib/assert_pending/assert_pending.rs.html
@@ -0,0 +1,405 @@
+assert_pending.rs - source
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+144
+145
+146
+147
+148
+149
+150
+151
+152
+153
+154
+155
+156
+157
+158
+159
+160
+161
+162
+163
+164
+165
+166
+167
+168
+169
+170
+171
+172
+173
+174
+175
+176
+177
+178
+179
+180
+181
+182
+183
+184
+185
+186
+187
+188
+189
+190
+191
+192
+193
+194
+195
+196
+197
+198
+199
+200
+201
+202
+
//! Assert an expression is Pending.
+//!
+//! Pseudocode:<br>
+//! a is Pending
+//!
+//! # Example
+//!
+//! ```rust
+//! use assertables::*;
+//! use std::task::Poll;
+//! use std::task::Poll::*;
+//!
+//! # fn main() {
+//! let a: Poll<i8> = Pending;
+//! assert_pending!(a);
+//! # }
+//! ```
+//!
+//! # Module macros
+//!
+//! * [`assert_pending`](macro@crate::assert_pending)
+//! * [`assert_pending_as_result`](macro@crate::assert_pending_as_result)
+//! * [`debug_assert_pending`](macro@crate::debug_assert_pending)
+
+/// Assert an expression.is_pending() is true.
+///
+/// Pseudocode:<br>
+/// a is Pending
+///
+/// * If true, return Result `Ok(())`.
+///
+/// * Otherwise, return Result `Err` with a diagnostic message.
+///
+/// This macro provides the same statements as [`assert_pending`](macro.assert_pending.html),
+/// except this macro returns a Result, rather than doing a panic.
+///
+/// This macro is useful for runtime checks, such as checking parameters,
+/// or sanitizing inputs, or handling different results in different ways.
+///
+/// # Module macros
+///
+/// * [`assert_pending`](macro@crate::assert_pending)
+/// * [`assert_pending_as_result`](macro@crate::assert_pending_as_result)
+/// * [`debug_assert_pending`](macro@crate::debug_assert_pending)
+///
+#[macro_export]
+macro_rules! assert_pending_as_result {
+    ($a:expr $(,)?) => {{
+        match (&$a) {
+            a => {
+                match (a) {
+                    Pending => {
+                        Ok(())
+                    },
+                    _ => {
+                        Err(format!(
+                            concat!(
+                                "assertion failed: `assert_pending!(a)`\n",
+                                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_pending.html\n",
+                                " a label: `{}`,\n",
+                                " a debug: `{:?}`",
+                            ),
+                            stringify!($a),
+                            a
+                        ))
+                    }
+                }
+            }
+        }
+    }};
+}
+
+#[cfg(test)]
+mod tests {
+    use std::task::Poll;
+    use std::task::Poll::*;
+
+    #[test]
+    fn test_assert_pending_as_result_x_success() {
+        let a: Poll<i8> = Pending;
+        let result = assert_pending_as_result!(a);
+        assert_eq!(result, Ok(()));
+    }
+
+    #[test]
+    fn test_assert_pending_as_result_x_failure() {
+        let a: Poll<i8> = Ready(1);
+        let result = assert_pending_as_result!(a);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err(),
+            concat!(
+                "assertion failed: `assert_pending!(a)`\n",
+                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_pending.html\n",
+                " a label: `a`,\n",
+                " a debug: `Ready(1)`"
+            )
+        );
+    }
+}
+
+/// Assert an expression is Pending.
+///
+/// Pseudocode:<br>
+/// a is Pending
+///
+/// * If true, return `()`.
+///
+/// * Otherwise, call [`panic!`] with a message and the values of the
+///   expressions with their debug representations.
+///
+/// # Examples
+///
+/// ```rust
+/// use assertables::*;
+/// # use std::panic;
+/// use std::task::Poll;
+/// use std::task::Poll::*;
+/// # fn main() {
+/// let a: Poll<i8> = Pending;
+/// assert_pending!(a);
+///
+/// # let result = panic::catch_unwind(|| {
+/// let a: Poll<i8> = Ready(1);
+/// assert_pending!(a);
+/// # });
+/// // assertion failed: `assert_pending!(a)`
+/// // https://docs.rs/assertables/8.11.0/assertables/macro.assert_pending.html
+/// //  a label: `a`,
+/// //  a debug: `Ready(1)`
+/// # let actual = result.unwrap_err().downcast::<String>().unwrap().to_string();
+/// # let expect = concat!(
+/// #     "assertion failed: `assert_pending!(a)`\n",
+/// #     "https://docs.rs/assertables/8.11.0/assertables/macro.assert_pending.html\n",
+/// #     " a label: `a`,\n",
+/// #     " a debug: `Ready(1)`",
+/// # );
+/// # assert_eq!(actual, expect);
+/// # }
+/// ```
+///
+/// # Module macros
+///
+/// * [`assert_pending`](macro@crate::assert_pending)
+/// * [`assert_pending_as_result`](macro@crate::assert_pending_as_result)
+/// * [`debug_assert_pending`](macro@crate::debug_assert_pending)
+///
+#[macro_export]
+macro_rules! assert_pending {
+    ($a:expr $(,)?) => {{
+        match $crate::assert_pending_as_result!($a) {
+            Ok(()) => (),
+            Err(err) => panic!("{}", err),
+        }
+    }};
+    ($a:expr, $($message:tt)+) => {{
+        match $crate::assert_pending_as_result!($a) {
+            Ok(()) => (),
+            Err(_err) => panic!("{}", $($message)+),
+        }
+    }};
+}
+
+/// Assert an expression is Pending.
+///
+/// Pseudocode:<br>
+/// a is Pending
+///
+/// This macro provides the same statements as [`assert_pending`](macro.assert_pending.html),
+/// except this macro's statements are only enabled in non-optimized
+/// builds by default. An optimized build will not execute this macro's
+/// statements unless `-C debug-assertions` is passed to the compiler.
+///
+/// This macro is useful for checks that are too expensive to be present
+/// in a release build but may be helpful during development.
+///
+/// The result of expanding this macro is always type checked.
+///
+/// An unchecked assertion allows a program in an inconsistent state to
+/// keep running, which might have unexpected consequences but does not
+/// introduce unsafety as long as this only happens in safe code. The
+/// performance cost of assertions, however, is not measurable in general.
+/// Replacing `assert*!` with `debug_assert*!` is thus only encouraged
+/// after thorough profiling, and more importantly, only in safe code!
+///
+/// This macro is intended to work in a similar way to
+/// [`std::debug_assert`](https://doc.rust-lang.org/std/macro.debug_assert.html).
+///
+/// # Module macros
+///
+/// * [`assert_pending`](macro@crate::assert_pending)
+/// * [`assert_pending`](macro@crate::assert_pending)
+/// * [`debug_assert_pending`](macro@crate::debug_assert_pending)
+///
+#[macro_export]
+macro_rules! debug_assert_pending {
+    ($($arg:tt)*) => {
+        if $crate::cfg!(debug_assertions) {
+            $crate::assert_pending!($($arg)*);
+        }
+    };
+}
+

\ No newline at end of file
diff --git a/doc/src/lib/assert_pending/mod.rs.html b/doc/src/lib/assert_pending/mod.rs.html
new file mode 100644
index 000000000..0e283c40b
--- /dev/null
+++ b/doc/src/lib/assert_pending/mod.rs.html
@@ -0,0 +1,21 @@
+mod.rs - source
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+
//! Assert macro for Pending items.
+//!
+//! These macros help compare Pending items, such as `std::Poll::Pending` or similar.
+//!
+//! Assert expression is Pending:
+//! 
+//! * [`assert_pending!(a)`](macro@crate::assert_pending)
+//!   ≈ a is Pending
+
+pub mod assert_pending;
+

\ No newline at end of file
diff --git a/doc/src/lib/assert_ready/assert_ready.rs.html b/doc/src/lib/assert_ready/assert_ready.rs.html
new file mode 100644
index 000000000..6e909450b
--- /dev/null
+++ b/doc/src/lib/assert_ready/assert_ready.rs.html
@@ -0,0 +1,405 @@
+assert_ready.rs - source
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+144
+145
+146
+147
+148
+149
+150
+151
+152
+153
+154
+155
+156
+157
+158
+159
+160
+161
+162
+163
+164
+165
+166
+167
+168
+169
+170
+171
+172
+173
+174
+175
+176
+177
+178
+179
+180
+181
+182
+183
+184
+185
+186
+187
+188
+189
+190
+191
+192
+193
+194
+195
+196
+197
+198
+199
+200
+201
+202
+
//! Assert an expression is Ready(_).
+//!
+//! Pseudocode:<br>
+//! a is Ready(_)
+//!
+//! # Example
+//!
+//! ```rust
+//! use assertables::*;
+//! use std::task::Poll;
+//! use std::task::Poll::*;
+//!
+//! # fn main() {
+//! let a: Poll<i8> = Ready(1);
+//! assert_ready!(a);
+//! # }
+//! ```
+//!
+//! # Module macros
+//!
+//! * [`assert_ready`](macro@crate::assert_ready)
+//! * [`assert_ready_as_result`](macro@crate::assert_ready_as_result)
+//! * [`debug_assert_ready`](macro@crate::debug_assert_ready)
+
+/// Assert an expression is Ready(_).
+///
+/// Pseudocode:<br>
+/// a is Ready(_)
+///
+/// * If true, return Result `Ok(())`.
+///
+/// * Otherwise, return Result `Err` with a diagnostic message.
+///
+/// This macro provides the same statements as [`assert_ready`](macro.assert_ready.html),
+/// except this macro returns a Result, rather than doing a panic.
+///
+/// This macro is useful for runtime checks, such as checking parameters,
+/// or sanitizing inputs, or handling different results in different ways.
+///
+/// # Module macros
+///
+/// * [`assert_ready`](macro@crate::assert_ready)
+/// * [`assert_ready_as_result`](macro@crate::assert_ready_as_result)
+/// * [`debug_assert_ready`](macro@crate::debug_assert_ready)
+///
+#[macro_export]
+macro_rules! assert_ready_as_result {
+    ($a:expr $(,)?) => {{
+        match (&$a) {
+            a => {
+                match (a) {
+                    Ready(_) => {
+                        Ok(())
+                    },
+                    _ => {
+                        Err(format!(
+                            concat!(
+                                "assertion failed: `assert_ready!(a)`\n",
+                                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ready.html\n",
+                                " a label: `{}`,\n",
+                                " a debug: `{:?}`",
+                            ),
+                            stringify!($a),
+                            a,
+                        ))
+                    }
+                }
+            }
+        }
+    }};
+}
+
+#[cfg(test)]
+mod tests {
+    use std::task::Poll;
+    use std::task::Poll::*;
+
+    #[test]
+    fn test_assert_ready_as_result_x_success() {
+        let a: Poll<i8> = Ready(1);
+        let result = assert_ready_as_result!(a);
+        assert_eq!(result, Ok(()));
+    }
+
+    #[test]
+    fn test_assert_ready_as_result_x_failure() {
+        let a: Poll<i8> = Pending;
+        let result = assert_ready_as_result!(a);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err(),
+            concat!(
+                "assertion failed: `assert_ready!(a)`\n",
+                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ready.html\n",
+                " a label: `a`,\n",
+                " a debug: `Pending`",
+            )
+        );
+    }
+}
+
+/// Assert an expression is Ready(_).
+///
+/// Pseudocode:<br>
+/// a is Ready(_)
+///
+/// * If true, return `()`.
+///
+/// * Otherwise, call [`panic!`] with a message and the values of the
+///   expressions with their debug representations.
+///
+/// # Examples
+///
+/// ```rust
+/// use assertables::*;
+/// # use std::panic;
+/// use std::task::Poll;
+/// use std::task::Poll::*;
+/// # fn main() {
+/// let a: Poll<i8> = Ready(1);
+/// assert_ready!(a);
+///
+/// # let result = panic::catch_unwind(|| {
+/// let a: Poll<i8> = Pending;
+/// assert_ready!(a);
+/// # });
+/// // assertion failed: `assert_ready!(a)`
+/// // https://docs.rs/assertables/8.11.0/assertables/macro.assert_ready.html
+/// //  a label: `a`,
+/// //  a debug: `Pending`
+/// # let actual = result.unwrap_err().downcast::<String>().unwrap().to_string();
+/// # let expect = concat!(
+/// #     "assertion failed: `assert_ready!(a)`\n",
+/// #     "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ready.html\n",
+/// #     " a label: `a`,\n",
+/// #     " a debug: `Pending`",
+/// # );
+/// # assert_eq!(actual, expect);
+/// # }
+/// ```
+///
+/// # Module macros
+///
+/// * [`assert_ready`](macro@crate::assert_ready)
+/// * [`assert_ready_as_result`](macro@crate::assert_ready_as_result)
+/// * [`debug_assert_ready`](macro@crate::debug_assert_ready)
+///
+#[macro_export]
+macro_rules! assert_ready {
+    ($a:expr $(,)?) => {{
+        match $crate::assert_ready_as_result!($a) {
+            Ok(()) => (),
+            Err(err) => panic!("{}", err),
+        }
+    }};
+    ($a:expr, $($message:tt)+) => {{
+        match $crate::assert_ready_as_result!($a) {
+            Ok(()) => (),
+            Err(_err) => panic!("{}", $($message)+),
+        }
+    }};
+}
+
+/// Assert poll.is_ready() is true.
+///
+/// Pseudocode:<br>
+/// a is Ready(_)
+///
+/// This macro provides the same statements as [`assert_ready`](macro.assert_ready.html),
+/// except this macro's statements are only enabled in non-optimized
+/// builds by default. An optimized build will not execute this macro's
+/// statements unless `-C debug-assertions` is passed to the compiler.
+///
+/// This macro is useful for checks that are too expensive to be present
+/// in a release build but may be helpful during development.
+///
+/// The result of expanding this macro is always type checked.
+///
+/// An unchecked assertion allows a program in an inconsistent state to
+/// keep running, which might have unexpected consequences but does not
+/// introduce unsafety as long as this only happens in safe code. The
+/// performance cost of assertions, however, is not measurable in general.
+/// Replacing `assert*!` with `debug_assert*!` is thus only encouraged
+/// after thorough profiling, and more importantly, only in safe code!
+///
+/// This macro is intended to work in a similar way to
+/// [`std::debug_assert`](https://doc.rust-lang.org/std/macro.debug_assert.html).
+///
+/// # Module macros
+///
+/// * [`assert_ready`](macro@crate::assert_ready)
+/// * [`assert_ready`](macro@crate::assert_ready)
+/// * [`debug_assert_ready`](macro@crate::debug_assert_ready)
+///
+#[macro_export]
+macro_rules! debug_assert_ready {
+    ($($arg:tt)*) => {
+        if $crate::cfg!(debug_assertions) {
+            $crate::assert_ready!($($arg)*);
+        }
+    };
+}
+

\ No newline at end of file
diff --git a/doc/src/lib/assert_ready/assert_ready_eq.rs.html b/doc/src/lib/assert_ready/assert_ready_eq.rs.html
new file mode 100644
index 000000000..8a7a4f406
--- /dev/null
+++ b/doc/src/lib/assert_ready/assert_ready_eq.rs.html
@@ -0,0 +1,527 @@
+assert_ready_eq.rs - source
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+144
+145
+146
+147
+148
+149
+150
+151
+152
+153
+154
+155
+156
+157
+158
+159
+160
+161
+162
+163
+164
+165
+166
+167
+168
+169
+170
+171
+172
+173
+174
+175
+176
+177
+178
+179
+180
+181
+182
+183
+184
+185
+186
+187
+188
+189
+190
+191
+192
+193
+194
+195
+196
+197
+198
+199
+200
+201
+202
+203
+204
+205
+206
+207
+208
+209
+210
+211
+212
+213
+214
+215
+216
+217
+218
+219
+220
+221
+222
+223
+224
+225
+226
+227
+228
+229
+230
+231
+232
+233
+234
+235
+236
+237
+238
+239
+240
+241
+242
+243
+244
+245
+246
+247
+248
+249
+250
+251
+252
+253
+254
+255
+256
+257
+258
+259
+260
+261
+262
+263
+
//! Assert two expressions are Ready(_) and their values are equal.
+//!
+//! Pseudocode:<br>
+//! (a ⇒ Ready(a̅) ⇒ a̅) = (b ⇒ Ready(b̅) ⇒ b̅)
+//!
+//! # Example
+//!
+//! ```rust
+//! use assertables::*;
+//! use std::task::Poll;
+//! use std::task::Poll::*;
+//! # fn main() {
+//! let a: Poll<i8> = Ready(1);
+//! let b: Poll<i8> = Ready(1);
+//! assert_ready_eq!(a, b);
+//! # }
+//! ```
+//!
+//! # Module macros
+//!
+//! * [`assert_ready_eq`](macro@crate::assert_ready_eq)
+//! * [`assert_ready_eq_as_result`](macro@crate::assert_ready_eq_as_result)
+//! * [`debug_assert_ready_eq`](macro@crate::debug_assert_ready_eq)
+
+/// Assert two expressions are Ready(_) and their values are equal.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Ready(a̅) ⇒ a̅) = (b ⇒ Ready(b̅) ⇒ b̅)
+///
+/// * If true, return Result `Some(())`.
+///
+/// * Otherwise, return Result `Err` with a diagnostic message.
+///
+/// This macro provides the same statements as [`assert_ready_eq`](macro.assert_ready_eq.html),
+/// except this macro returns a Option, rather than doing a panic.
+///
+/// This macro is useful for runtime checks, such as checking parameters,
+/// or sanitizing inputs, or handling different results in different ways.
+///
+/// # Module macros
+///
+/// * [`assert_ready_eq`](macro@crate::assert_ready_eq)
+/// * [`assert_ready_eq_as_result`](macro@crate::assert_ready_eq_as_result)
+/// * [`debug_assert_ready_eq`](macro@crate::debug_assert_ready_eq)
+///
+#[macro_export]
+macro_rules! assert_ready_eq_as_result {
+    ($a:expr, $b:expr $(,)?) => {{
+        match (&$a, &$b) {
+            (a, b) => {
+                match (a, b) {
+                    (Ready(a_inner), Ready(b_inner)) => {
+                        if a_inner == b_inner {
+                            Ok(())
+                        } else {
+                            Err(format!(
+                                concat!(
+                                    "assertion failed: `assert_ready_eq!(a, b)`\n",
+                                    "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ready_eq.html\n",
+                                    " a label: `{}`,\n",
+                                    " a debug: `{:?}`,\n",
+                                    " a inner: `{:?}`,\n",
+                                    " b label: `{}`,\n",
+                                    " b debug: `{:?}`,\n",
+                                    " b inner: `{:?}`"
+                                ),
+                                stringify!($a),
+                                a,
+                                a_inner,
+                                stringify!($b),
+                                b,
+                                b_inner
+                            ))
+                        }
+                    },
+                    _ => {
+                        Err(format!(
+                            concat!(
+                                "assertion failed: `assert_ready_eq!(a, b)`\n",
+                                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ready_eq.html\n",
+                                " a label: `{}`,\n",
+                                " a debug: `{:?}`,\n",
+                                " b label: `{}`,\n",
+                                " b debug: `{:?}`",
+                            ),
+                            stringify!($a),
+                            a,
+                            stringify!($b),
+                            $b
+                        ))
+                    }
+                }
+            }
+        }
+    }};
+}
+
+#[cfg(test)]
+mod tests {
+    use std::task::Poll;
+    use std::task::Poll::*;
+
+    #[test]
+    fn test_assert_ready_eq_as_result_x_success() {
+        let a: Poll<i8> = Ready(1);
+        let b: Poll<i8> = Ready(1);
+        let result = assert_ready_eq_as_result!(a, b);
+        assert_eq!(result, Ok(()));
+    }
+
+    #[test]
+    fn test_assert_ready_eq_as_result_x_failure_because_ne() {
+        let a: Poll<i8> = Ready(1);
+        let b: Poll<i8> = Ready(2);
+        let result = assert_ready_eq_as_result!(a, b);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err(),
+            concat!(
+                "assertion failed: `assert_ready_eq!(a, b)`\n",
+                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ready_eq.html\n",
+                " a label: `a`,\n",
+                " a debug: `Ready(1)`,\n",
+                " a inner: `1`,\n",
+                " b label: `b`,\n",
+                " b debug: `Ready(2)`,\n",
+                " b inner: `2`",
+            )
+        );
+    }
+
+    #[test]
+    fn test_assert_ready_eq_as_result_x_failure_because_not_ready() {
+        let a: Poll<i8> = Pending;
+        let b: Poll<i8> = Ready(1);
+        let result = assert_ready_eq_as_result!(a, b);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err(),
+            concat!(
+                "assertion failed: `assert_ready_eq!(a, b)`\n",
+                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ready_eq.html\n",
+                " a label: `a`,\n",
+                " a debug: `Pending`,\n",
+                " b label: `b`,\n",
+                " b debug: `Ready(1)`",
+            )
+        );
+    }
+
+}
+
+/// Assert two expressions are Ready(_) and their values are equal.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Ready(a̅) ⇒ a̅) = (b ⇒ Ready(b̅) ⇒ b̅)
+///
+/// * If true, return `()`.
+///
+/// * Otherwise, call [`panic!`] with a message and the values of the
+///   expressions with their debug representations.
+///
+/// # Examples
+///
+/// ```rust
+/// use assertables::*;
+/// # use std::panic;
+/// use std::task::Poll;
+/// use std::task::Poll::*;
+/// # fn main() {
+/// let a: Poll<i8> = Ready(1);
+/// let b: Poll<i8> = Ready(1);
+/// assert_ready_eq!(a, b);
+///
+/// # let result = panic::catch_unwind(|| {
+/// let a: Poll<i8> = Ready(1);
+/// let b: Poll<i8> = Ready(2);
+/// assert_ready_eq!(a, b);
+/// # });
+/// // assertion failed: `assert_ready_eq!(a, b)`
+/// // https://docs.rs/assertables/8.11.0/assertables/macro.assert_ready_eq.html
+/// //  a label: `a`,
+/// //  a debug: `Ready(1)`,
+/// //  a inner: `1`,
+/// //  b label: `b`,
+/// //  b debug: `Ready(2)`,
+/// //  b inner: `2`
+/// # let actual = result.unwrap_err().downcast::<String>().unwrap().to_string();
+/// # let expect = concat!(
+/// #     "assertion failed: `assert_ready_eq!(a, b)`\n",
+/// #     "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ready_eq.html\n",
+/// #     " a label: `a`,\n",
+/// #     " a debug: `Ready(1)`,\n",
+/// #     " a inner: `1`,\n",
+/// #     " b label: `b`,\n",
+/// #     " b debug: `Ready(2)`,\n",
+/// #     " b inner: `2`",
+/// # );
+/// # assert_eq!(actual, expect);
+/// # }
+/// ```
+///
+/// # Module macros
+///
+/// * [`assert_ready_eq`](macro@crate::assert_ready_eq)
+/// * [`assert_ready_eq_as_result`](macro@crate::assert_ready_eq_as_result)
+/// * [`debug_assert_ready_eq`](macro@crate::debug_assert_ready_eq)
+///
+#[macro_export]
+macro_rules! assert_ready_eq {
+    ($a:expr, $b:expr $(,)?) => {{
+        match $crate::assert_ready_eq_as_result!($a, $b) {
+            Ok(()) => (),
+            Err(err) => panic!("{}", err),
+        }
+    }};
+    ($a:expr, $b:expr, $($message:tt)+) => {{
+        match $crate::assert_ready_eq_as_result!($a, $b) {
+            Ok(()) => (),
+            Err(_err) => panic!("{}", $($message)+),
+        }
+    }};
+}
+
+/// Assert two expressions are Ready(_) and their values are equal.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Ready(a̅) ⇒ a̅) = (b ⇒ Ready(b̅) ⇒ b̅)
+///
+/// This macro provides the same statements as [`assert_ready_eq`](macro.assert_ready_eq.html),
+/// except this macro's statements are only enabled in non-optimized
+/// builds by default. An optimized build will not execute this macro's
+/// statements unless `-C debug-assertions` is passed to the compiler.
+///
+/// This macro is useful for checks that are too expensive to be present
+/// in a release build but may be helpful during development.
+///
+/// The result of expanding this macro is always type checked.
+///
+/// An unchecked assertion allows a program in an inconsistent state to
+/// keep running, which might have unexpected consequences but does not
+/// introduce unsafety as long as this only happens in safe code. The
+/// performance cost of assertions, however, is not measurable in general.
+/// Replacing `assert*!` with `debug_assert*!` is thus only encouraged
+/// after thorough profiling, and more importantly, only in safe code!
+///
+/// This macro is intended to work in a similar way to
+/// [`std::debug_assert`](https://doc.rust-lang.org/std/macro.debug_assert.html).
+///
+/// # Module macros
+///
+/// * [`assert_ready_eq`](macro@crate::assert_ready_eq)
+/// * [`assert_ready_eq`](macro@crate::assert_ready_eq)
+/// * [`debug_assert_ready_eq`](macro@crate::debug_assert_ready_eq)
+///
+#[macro_export]
+macro_rules! debug_assert_ready_eq {
+    ($($arg:tt)*) => {
+        if $crate::cfg!(debug_assertions) {
+            $crate::assert_ready_eq!($($arg)*);
+        }
+    };
+}
+

\ No newline at end of file
diff --git a/doc/src/lib/assert_ready/assert_ready_eq_expr.rs.html b/doc/src/lib/assert_ready/assert_ready_eq_expr.rs.html
new file mode 100644
index 000000000..75232c86f
--- /dev/null
+++ b/doc/src/lib/assert_ready/assert_ready_eq_expr.rs.html
@@ -0,0 +1,517 @@
+assert_ready_eq_expr.rs - source
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+144
+145
+146
+147
+148
+149
+150
+151
+152
+153
+154
+155
+156
+157
+158
+159
+160
+161
+162
+163
+164
+165
+166
+167
+168
+169
+170
+171
+172
+173
+174
+175
+176
+177
+178
+179
+180
+181
+182
+183
+184
+185
+186
+187
+188
+189
+190
+191
+192
+193
+194
+195
+196
+197
+198
+199
+200
+201
+202
+203
+204
+205
+206
+207
+208
+209
+210
+211
+212
+213
+214
+215
+216
+217
+218
+219
+220
+221
+222
+223
+224
+225
+226
+227
+228
+229
+230
+231
+232
+233
+234
+235
+236
+237
+238
+239
+240
+241
+242
+243
+244
+245
+246
+247
+248
+249
+250
+251
+252
+253
+254
+255
+256
+257
+258
+
//! Assert an expression is Ready(_) and its value is equal to an expression.
+//!
+//! Pseudocode:<br>
+//! (a ⇒ Ready(a̅) ⇒ a̅) = b
+//!
+//! # Example
+//!
+//! ```rust
+//! use assertables::*;
+//! use std::task::Poll;
+//! use std::task::Poll::*;
+//! # fn main() {
+//! let a: Poll<i8> = Ready(1);
+//! let b: i8 = 1;
+//! assert_ready_eq_expr!(a, b);
+//! # }
+//! ```
+//!
+//! # Module macros
+//!
+//! * [`assert_ready_eq_expr`](macro@crate::assert_ready_eq_expr)
+//! * [`assert_ready_eq_expr_as_result`](macro@crate::assert_ready_eq_expr_as_result)
+//! * [`debug_assert_ready_eq_expr`](macro@crate::debug_assert_ready_eq_expr)
+
+/// Assert an expression is Ready(_) and its value is equal to an expression.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Ready(a̅) ⇒ a̅) = b
+///
+/// * If true, return Result `Some(())`.
+///
+/// * Otherwise, return Result `Err` with a diagnostic message.
+///
+/// This macro provides the same statements as [`assert_ready_eq_expr`](macro.assert_ready_eq_expr.html),
+/// except this macro returns a Option, rather than doing a panic.
+///
+/// This macro is useful for runtime checks, such as checking parameters,
+/// or sanitizing inputs, or handling different results in different ways.
+///
+/// # Module macros
+///
+/// * [`assert_ready_eq_expr`](macro@crate::assert_ready_eq_expr)
+/// * [`assert_ready_eq_expr_as_result`](macro@crate::assert_ready_eq_expr_as_result)
+/// * [`debug_assert_ready_eq_expr`](macro@crate::debug_assert_ready_eq_expr)
+///
+#[macro_export]
+macro_rules! assert_ready_eq_expr_as_result {
+    ($a:expr, $b:expr $(,)?) => {{
+        match (&$a, &$b) {
+            (a, b) => {
+                match a {
+                    Ready(a_inner) => {
+                        if a_inner == b {
+                            Ok(())
+                        } else {
+                            Err(format!(
+                                concat!(
+                                    "assertion failed: `assert_ready_eq_expr!(a, b)`\n",
+                                    "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ready_eq_expr.html\n",
+                                    " a label: `{}`,\n",
+                                    " a debug: `{:?}`,\n",
+                                    " a inner: `{:?}`,\n",
+                                    " b label: `{}`,\n",
+                                    " b debug: `{:?}`"
+                                ),
+                                stringify!($a),
+                                a,
+                                a_inner,
+                                stringify!($b),
+                                b
+                            ))
+                        }
+                    },
+                    _ => {
+                        Err(format!(
+                            concat!(
+                                "assertion failed: `assert_ready_eq_expr!(a, b)`\n",
+                                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ready_eq_expr.html\n",
+                                " a label: `{}`,\n",
+                                " a debug: `{:?}`,\n",
+                                " b label: `{}`,\n",
+                                " b debug: `{:?}`",
+                            ),
+                            stringify!($a),
+                            a,
+                            stringify!($b),
+                            $b
+                        ))
+                    }
+                }
+            }
+        }
+    }};
+}
+
+#[cfg(test)]
+mod tests {
+    use std::task::Poll;
+    use std::task::Poll::*;
+
+    #[test]
+    fn test_assert_ready_eq_expr_as_result_x_success() {
+        let a: Poll<i8> = Ready(1);
+        let b: i8 = 1;
+        let result = assert_ready_eq_expr_as_result!(a, b);
+        assert_eq!(result, Ok(()));
+    }
+
+    #[test]
+    fn test_assert_ready_eq_expr_as_result_x_failure_because_ne() {
+        let a: Poll<i8> = Ready(1);
+        let b: i8 = 2;
+        let result = assert_ready_eq_expr_as_result!(a, b);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err(),
+            concat!(
+                "assertion failed: `assert_ready_eq_expr!(a, b)`\n",
+                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ready_eq_expr.html\n",
+                " a label: `a`,\n",
+                " a debug: `Ready(1)`,\n",
+                " a inner: `1`,\n",
+                " b label: `b`,\n",
+                " b debug: `2`"
+            )
+        );
+    }
+
+    #[test]
+    fn test_assert_ready_eq_expr_as_result_x_failure_because_not_ready() {
+        let a: Poll<i8> = Pending;
+        let b: i8 = 1;
+        let result = assert_ready_eq_expr_as_result!(a, b);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err(),
+            concat!(
+                "assertion failed: `assert_ready_eq_expr!(a, b)`\n",
+                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ready_eq_expr.html\n",
+                " a label: `a`,\n",
+                " a debug: `Pending`,\n",
+                " b label: `b`,\n",
+                " b debug: `1`"
+            )
+        );
+    }
+
+}
+
+/// Assert an expression is Ready(_) and its value is equal to an expression.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Ready(a̅) ⇒ a̅) = b
+///
+/// * If true, return `()`.
+///
+/// * Otherwise, call [`panic!`] with a message and the values of the
+///   expressions with their debug representations.
+///
+/// # Examples
+///
+/// ```rust
+/// use assertables::*;
+/// # use std::panic;
+/// use std::task::Poll;
+/// use std::task::Poll::*;
+/// # fn main() {
+/// let a: Poll<i8> = Ready(1);
+/// let b: i8 = 1;
+/// assert_ready_eq_expr!(a, b);
+///
+/// # let result = panic::catch_unwind(|| {
+/// let a: Poll<i8> = Ready(1);
+/// let b: i8 = 2;
+/// assert_ready_eq_expr!(a, b);
+/// # });
+/// // assertion failed: `assert_ready_eq_expr!(a, b)`
+/// // https://docs.rs/assertables/8.11.0/assertables/macro.assert_ready_eq_expr.html
+/// //  a label: `a`,
+/// //  a debug: `Ready(1)`,
+/// //  a inner: `1`,
+/// //  b label: `b`,
+/// //  b debug: `2`
+/// # let actual = result.unwrap_err().downcast::<String>().unwrap().to_string();
+/// # let expect = concat!(
+/// #     "assertion failed: `assert_ready_eq_expr!(a, b)`\n",
+/// #     "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ready_eq_expr.html\n",
+/// #     " a label: `a`,\n",
+/// #     " a debug: `Ready(1)`,\n",
+/// #     " a inner: `1`,\n",
+/// #     " b label: `b`,\n",
+/// #     " b debug: `2`"
+/// # );
+/// # assert_eq!(actual, expect);
+/// # }
+/// ```
+///
+/// # Module macros
+///
+/// * [`assert_ready_eq_expr`](macro@crate::assert_ready_eq_expr)
+/// * [`assert_ready_eq_expr_as_result`](macro@crate::assert_ready_eq_expr_as_result)
+/// * [`debug_assert_ready_eq_expr`](macro@crate::debug_assert_ready_eq_expr)
+///
+#[macro_export]
+macro_rules! assert_ready_eq_expr {
+    ($a:expr, $b:expr $(,)?) => {{
+        match $crate::assert_ready_eq_expr_as_result!($a, $b) {
+            Ok(()) => (),
+            Err(err) => panic!("{}", err),
+        }
+    }};
+    ($a:expr, $b:expr, $($message:tt)+) => {{
+        match $crate::assert_ready_eq_expr_as_result!($a, $b) {
+            Ok(()) => (),
+            Err(_err) => panic!("{}", $($message)+),
+        }
+    }};
+}
+
+/// Assert an expression is Ready(_) and its value is equal to an expression.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Ready(a̅) ⇒ a̅) = b
+///
+/// This macro provides the same statements as [`assert_ready_eq_expr`](macro.assert_ready_eq_expr.html),
+/// except this macro's statements are only enabled in non-optimized
+/// builds by default. An optimized build will not execute this macro's
+/// statements unless `-C debug-assertions` is passed to the compiler.
+///
+/// This macro is useful for checks that are too expensive to be present
+/// in a release build but may be helpful during development.
+///
+/// The result of expanding this macro is always type checked.
+///
+/// An unchecked assertion allows a program in an inconsistent state to
+/// keep running, which might have unexpected consequences but does not
+/// introduce unsafety as long as this only happens in safe code. The
+/// performance cost of assertions, however, is not measurable in general.
+/// Replacing `assert*!` with `debug_assert*!` is thus only encouraged
+/// after thorough profiling, and more importantly, only in safe code!
+///
+/// This macro is intended to work in a similar way to
+/// [`std::debug_assert`](https://doc.rust-lang.org/std/macro.debug_assert.html).
+///
+/// # Module macros
+///
+/// * [`assert_ready_eq_expr`](macro@crate::assert_ready_eq_expr)
+/// * [`assert_ready_eq_expr`](macro@crate::assert_ready_eq_expr)
+/// * [`debug_assert_ready_eq_expr`](macro@crate::debug_assert_ready_eq_expr)
+///
+#[macro_export]
+macro_rules! debug_assert_ready_eq_expr {
+    ($($arg:tt)*) => {
+        if $crate::cfg!(debug_assertions) {
+            $crate::assert_ready_eq_expr!($($arg)*);
+        }
+    };
+}
+

\ No newline at end of file
diff --git a/doc/src/lib/assert_ready/assert_ready_ne.rs.html b/doc/src/lib/assert_ready/assert_ready_ne.rs.html
new file mode 100644
index 000000000..287dc2fb1
--- /dev/null
+++ b/doc/src/lib/assert_ready/assert_ready_ne.rs.html
@@ -0,0 +1,527 @@
+assert_ready_ne.rs - source
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+144
+145
+146
+147
+148
+149
+150
+151
+152
+153
+154
+155
+156
+157
+158
+159
+160
+161
+162
+163
+164
+165
+166
+167
+168
+169
+170
+171
+172
+173
+174
+175
+176
+177
+178
+179
+180
+181
+182
+183
+184
+185
+186
+187
+188
+189
+190
+191
+192
+193
+194
+195
+196
+197
+198
+199
+200
+201
+202
+203
+204
+205
+206
+207
+208
+209
+210
+211
+212
+213
+214
+215
+216
+217
+218
+219
+220
+221
+222
+223
+224
+225
+226
+227
+228
+229
+230
+231
+232
+233
+234
+235
+236
+237
+238
+239
+240
+241
+242
+243
+244
+245
+246
+247
+248
+249
+250
+251
+252
+253
+254
+255
+256
+257
+258
+259
+260
+261
+262
+263
+
//! Assert two expressions are Ready(_) and their values are not equal.
+//!
+//! Pseudocode:<br>
+//! (a ⇒ Ready(a̅) ⇒ a̅) ≠ (b ⇒ Ready(b̅) ⇒ b̅)
+//!
+//! # Example
+//!
+//! ```rust
+//! use assertables::*;
+//! use std::task::Poll;
+//! use std::task::Poll::*;
+//! # fn main() {
+//! let a: Poll<i8> = Ready(1);
+//! let b: Poll<i8> = Ready(2);
+//! assert_ready_ne!(a, b);
+//! # }
+//! ```
+//!
+//! # Module macros
+//!
+//! * [`assert_ready_ne`](macro@crate::assert_ready_ne)
+//! * [`assert_ready_ne_as_result`](macro@crate::assert_ready_ne_as_result)
+//! * [`debug_assert_ready_ne`](macro@crate::debug_assert_ready_ne)
+
+/// Assert two expressions are Ready(_) and their values are not equal.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Ready(a̅) ⇒ a̅) ≠ (b ⇒ Ready(b̅) ⇒ b̅)
+///
+/// * If true, return Result `Some(())`.
+///
+/// * Otherwise, return Result `Err` with a diagnostic message.
+///
+/// This macro provides the same statements as [`assert_ready_ne`](macro.assert_ready_ne.html),
+/// except this macro returns a Option, rather than doing a panic.
+///
+/// This macro is useful for runtime checks, such as checking parameters,
+/// or sanitizing inputs, or handling different results in different ways.
+///
+/// # Module macros
+///
+/// * [`assert_ready_ne`](macro@crate::assert_ready_ne)
+/// * [`assert_ready_ne_as_result`](macro@crate::assert_ready_ne_as_result)
+/// * [`debug_assert_ready_ne`](macro@crate::debug_assert_ready_ne)
+///
+#[macro_export]
+macro_rules! assert_ready_ne_as_result {
+    ($a:expr, $b:expr $(,)?) => {{
+        match (&$a, &$b) {
+            (a, b) => {
+                match (a, b) {
+                    (Ready(a_inner), Ready(b_inner)) => {
+                        if a_inner != b_inner {
+                            Ok(())
+                        } else {
+                            Err(format!(
+                                concat!(
+                                    "assertion failed: `assert_ready_ne!(a, b)`\n",
+                                    "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ready_ne.html\n",
+                                    " a label: `{}`,\n",
+                                    " a debug: `{:?}`,\n",
+                                    " a inner: `{:?}`,\n",
+                                    " b label: `{}`,\n",
+                                    " b debug: `{:?}`,\n",
+                                    " b inner: `{:?}`"
+                                ),
+                                stringify!($a),
+                                a,
+                                a_inner,
+                                stringify!($b),
+                                b,
+                                b_inner
+                            ))
+                        }
+                    },
+                    _ => {
+                        Err(format!(
+                            concat!(
+                                "assertion failed: `assert_ready_ne!(a, b)`\n",
+                                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ready_ne.html\n",
+                                " a label: `{}`,\n",
+                                " a debug: `{:?}`,\n",
+                                " b label: `{}`,\n",
+                                " b debug: `{:?}`",
+                            ),
+                            stringify!($a),
+                            a,
+                            stringify!($b),
+                            $b
+                        ))
+                    }
+                }
+            }
+        }
+    }};
+}
+
+#[cfg(test)]
+mod tests {
+    use std::task::Poll;
+    use std::task::Poll::*;
+
+    #[test]
+    fn test_assert_ready_ne_as_result_x_success() {
+        let a: Poll<i8> = Ready(1);
+        let b: Poll<i8> = Ready(2);
+        let result = assert_ready_ne_as_result!(a, b);
+        assert_eq!(result, Ok(()));
+    }
+
+    #[test]
+    fn test_assert_ready_ne_as_result_x_failure_because_ne() {
+        let a: Poll<i8> = Ready(1);
+        let b: Poll<i8> = Ready(1);
+        let result = assert_ready_ne_as_result!(a, b);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err(),
+            concat!(
+                "assertion failed: `assert_ready_ne!(a, b)`\n",
+                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ready_ne.html\n",
+                " a label: `a`,\n",
+                " a debug: `Ready(1)`,\n",
+                " a inner: `1`,\n",
+                " b label: `b`,\n",
+                " b debug: `Ready(1)`,\n",
+                " b inner: `1`",
+            )
+        );
+    }
+
+    #[test]
+    fn test_assert_ready_ne_as_result_x_failure_because_not_ready() {
+        let a: Poll<i8> = Pending;
+        let b: Poll<i8> = Ready(1);
+        let result = assert_ready_ne_as_result!(a, b);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err(),
+            concat!(
+                "assertion failed: `assert_ready_ne!(a, b)`\n",
+                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ready_ne.html\n",
+                " a label: `a`,\n",
+                " a debug: `Pending`,\n",
+                " b label: `b`,\n",
+                " b debug: `Ready(1)`",
+            )
+        );
+    }
+
+}
+
+/// Assert two expressions are Ready(_) and their values are not equal.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Ready(a̅) ⇒ a̅) ≠ (b ⇒ Ready(b̅) ⇒ b̅)
+///
+/// * If true, return `()`.
+///
+/// * Otherwise, call [`panic!`] with a message and the values of the
+///   expressions with their debug representations.
+///
+/// # Examples
+///
+/// ```rust
+/// use assertables::*;
+/// # use std::panic;
+/// use std::task::Poll;
+/// use std::task::Poll::*;
+/// # fn main() {
+/// let a: Poll<i8> = Ready(1);
+/// let b: Poll<i8> = Ready(2);
+/// assert_ready_ne!(a, b);
+///
+/// # let result = panic::catch_unwind(|| {
+/// let a: Poll<i8> = Ready(1);
+/// let b: Poll<i8> = Ready(1);
+/// assert_ready_ne!(a, b);
+/// # });
+/// // assertion failed: `assert_ready_ne!(a, b)`
+/// // https://docs.rs/assertables/8.11.0/assertables/macro.assert_ready_ne.html
+/// //  a label: `a`,
+/// //  a debug: `Ready(1)`,
+/// //  a inner: `1`,
+/// //  b label: `b`,
+/// //  b debug: `Ready(1)`,
+/// //  b inner: `1`
+/// # let actual = result.unwrap_err().downcast::<String>().unwrap().to_string();
+/// # let expect = concat!(
+/// #     "assertion failed: `assert_ready_ne!(a, b)`\n",
+/// #     "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ready_ne.html\n",
+/// #     " a label: `a`,\n",
+/// #     " a debug: `Ready(1)`,\n",
+/// #     " a inner: `1`,\n",
+/// #     " b label: `b`,\n",
+/// #     " b debug: `Ready(1)`,\n",
+/// #     " b inner: `1`",
+/// # );
+/// # assert_eq!(actual, expect);
+/// # }
+/// ```
+///
+/// # Module macros
+///
+/// * [`assert_ready_ne`](macro@crate::assert_ready_ne)
+/// * [`assert_ready_ne_as_result`](macro@crate::assert_ready_ne_as_result)
+/// * [`debug_assert_ready_ne`](macro@crate::debug_assert_ready_ne)
+///
+#[macro_export]
+macro_rules! assert_ready_ne {
+    ($a:expr, $b:expr $(,)?) => {{
+        match $crate::assert_ready_ne_as_result!($a, $b) {
+            Ok(()) => (),
+            Err(err) => panic!("{}", err),
+        }
+    }};
+    ($a:expr, $b:expr, $($message:tt)+) => {{
+        match $crate::assert_ready_ne_as_result!($a, $b) {
+            Ok(()) => (),
+            Err(_err) => panic!("{}", $($message)+),
+        }
+    }};
+}
+
+/// Assert two expressions are Ready(_) and their values are not equal.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Ready(a̅) ⇒ a̅) ≠ (b ⇒ Ready(b̅) ⇒ b̅)
+///
+/// This macro provides the same statements as [`assert_ready_ne`](macro.assert_ready_ne.html),
+/// except this macro's statements are only enabled in non-optimized
+/// builds by default. An optimized build will not execute this macro's
+/// statements unless `-C debug-assertions` is passed to the compiler.
+///
+/// This macro is useful for checks that are too expensive to be present
+/// in a release build but may be helpful during development.
+///
+/// The result of expanding this macro is always type checked.
+///
+/// An unchecked assertion allows a program in an inconsistent state to
+/// keep running, which might have unexpected consequences but does not
+/// introduce unsafety as long as this only happens in safe code. The
+/// performance cost of assertions, however, is not measurable in general.
+/// Replacing `assert*!` with `debug_assert*!` is thus only encouraged
+/// after thorough profiling, and more importantly, only in safe code!
+///
+/// This macro is intended to work in a similar way to
+/// [`std::debug_assert`](https://doc.rust-lang.org/std/macro.debug_assert.html).
+///
+/// # Module macros
+///
+/// * [`assert_ready_ne`](macro@crate::assert_ready_ne)
+/// * [`assert_ready_ne`](macro@crate::assert_ready_ne)
+/// * [`debug_assert_ready_ne`](macro@crate::debug_assert_ready_ne)
+///
+#[macro_export]
+macro_rules! debug_assert_ready_ne {
+    ($($arg:tt)*) => {
+        if $crate::cfg!(debug_assertions) {
+            $crate::assert_ready_ne!($($arg)*);
+        }
+    };
+}
+

\ No newline at end of file
diff --git a/doc/src/lib/assert_ready/assert_ready_ne_expr.rs.html b/doc/src/lib/assert_ready/assert_ready_ne_expr.rs.html
new file mode 100644
index 000000000..fcc67a928
--- /dev/null
+++ b/doc/src/lib/assert_ready/assert_ready_ne_expr.rs.html
@@ -0,0 +1,517 @@
+assert_ready_ne_expr.rs - source
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+144
+145
+146
+147
+148
+149
+150
+151
+152
+153
+154
+155
+156
+157
+158
+159
+160
+161
+162
+163
+164
+165
+166
+167
+168
+169
+170
+171
+172
+173
+174
+175
+176
+177
+178
+179
+180
+181
+182
+183
+184
+185
+186
+187
+188
+189
+190
+191
+192
+193
+194
+195
+196
+197
+198
+199
+200
+201
+202
+203
+204
+205
+206
+207
+208
+209
+210
+211
+212
+213
+214
+215
+216
+217
+218
+219
+220
+221
+222
+223
+224
+225
+226
+227
+228
+229
+230
+231
+232
+233
+234
+235
+236
+237
+238
+239
+240
+241
+242
+243
+244
+245
+246
+247
+248
+249
+250
+251
+252
+253
+254
+255
+256
+257
+258
+
//! Assert an expression is Ready(_) and its value is not equal to an expression.
+//!
+//! Pseudocode:<br>
+//! (a ⇒ Ready(a̅) ⇒ a̅) ≠ b
+//!
+//! # Example
+//!
+//! ```rust
+//! use assertables::*;
+//! use std::task::Poll;
+//! use std::task::Poll::*;
+//! # fn main() {
+//! let a: Poll<i8> = Ready(1);
+//! let b: i8 = 2;
+//! assert_ready_ne_expr!(a, b);
+//! # }
+//! ```
+//!
+//! # Module macros
+//!
+//! * [`assert_ready_ne_expr`](macro@crate::assert_ready_ne_expr)
+//! * [`assert_ready_ne_expr_as_result`](macro@crate::assert_ready_ne_expr_as_result)
+//! * [`debug_assert_ready_ne_expr`](macro@crate::debug_assert_ready_ne_expr)
+
+/// Assert an expression is Ready(_) and its value is not equal to an expression.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Ready(a̅) ⇒ a̅) ≠ b
+///
+/// * If true, return Result `Some(())`.
+///
+/// * Otherwise, return Result `Err` with a diagnostic message.
+///
+/// This macro provides the same statements as [`assert_ready_ne_expr`](macro.assert_ready_ne_expr.html),
+/// except this macro returns a Option, rather than doing a panic.
+///
+/// This macro is useful for runtime checks, such as checking parameters,
+/// or sanitizing inputs, or handling different results in different ways.
+///
+/// # Module macros
+///
+/// * [`assert_ready_ne_expr`](macro@crate::assert_ready_ne_expr)
+/// * [`assert_ready_ne_expr_as_result`](macro@crate::assert_ready_ne_expr_as_result)
+/// * [`debug_assert_ready_ne_expr`](macro@crate::debug_assert_ready_ne_expr)
+///
+#[macro_export]
+macro_rules! assert_ready_ne_expr_as_result {
+    ($a:expr, $b:expr $(,)?) => {{
+        match (&$a, &$b) {
+            (a, b) => {
+                match a {
+                    Ready(a_inner) => {
+                        if a_inner != b {
+                            Ok(())
+                        } else {
+                            Err(format!(
+                                concat!(
+                                    "assertion failed: `assert_ready_ne_expr!(a, b)`\n",
+                                    "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ready_ne_expr.html\n",
+                                    " a label: `{}`,\n",
+                                    " a debug: `{:?}`,\n",
+                                    " a inner: `{:?}`,\n",
+                                    " b label: `{}`,\n",
+                                    " b debug: `{:?}`",
+                                ),
+                                stringify!($a),
+                                a,
+                                a_inner,
+                                stringify!($b),
+                                b
+                            ))
+                        }
+                    },
+                    _ => {
+                        Err(format!(
+                            concat!(
+                                "assertion failed: `assert_ready_ne_expr!(a, b)`\n",
+                                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ready_ne_expr.html\n",
+                                " a label: `{}`,\n",
+                                " a debug: `{:?}`,\n",
+                                " b label: `{}`,\n",
+                                " b debug: `{:?}`",
+                            ),
+                            stringify!($a),
+                            a,
+                            stringify!($b),
+                            $b
+                        ))
+                    }
+                }
+            }
+        }
+    }};
+}
+
+#[cfg(test)]
+mod tests {
+    use std::task::Poll;
+    use std::task::Poll::*;
+
+    #[test]
+    fn test_assert_ready_ne_expr_as_result_x_success() {
+        let a: Poll<i8> = Ready(1);
+        let b: i8 = 2;
+        let result = assert_ready_ne_expr_as_result!(a, b);
+        assert_eq!(result, Ok(()));
+    }
+
+    #[test]
+    fn test_assert_ready_ne_expr_as_result_x_failure_because_ne() {
+        let a: Poll<i8> = Ready(1);
+        let b: i8 = 1;
+        let result = assert_ready_ne_expr_as_result!(a, b);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err(),
+            concat!(
+                "assertion failed: `assert_ready_ne_expr!(a, b)`\n",
+                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ready_ne_expr.html\n",
+                " a label: `a`,\n",
+                " a debug: `Ready(1)`,\n",
+                " a inner: `1`,\n",
+                " b label: `b`,\n",
+                " b debug: `1`"
+            )
+        );
+    }
+
+    #[test]
+    fn test_assert_ready_ne_expr_as_result_x_failure_because_not_ready() {
+        let a: Poll<i8> = Pending;
+        let b: i8 = 1;
+        let result = assert_ready_ne_expr_as_result!(a, b);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err(),
+            concat!(
+                "assertion failed: `assert_ready_ne_expr!(a, b)`\n",
+                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ready_ne_expr.html\n",
+                " a label: `a`,\n",
+                " a debug: `Pending`,\n",
+                " b label: `b`,\n",
+                " b debug: `1`"
+            )
+        );
+    }
+
+}
+
+/// Assert an expression is Ready(_) and its value is not equal to an expression.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Ready(a̅) ⇒ a̅) ≠ b
+///
+/// * If true, return `()`.
+///
+/// * Otherwise, call [`panic!`] with a message and the values of the
+///   expressions with their debug representations.
+///
+/// # Examples
+///
+/// ```rust
+/// use assertables::*;
+/// # use std::panic;
+/// use std::task::Poll;
+/// use std::task::Poll::*;
+/// # fn main() {
+/// let a: Poll<i8> = Ready(1);
+/// let b: i8 = 2;
+/// assert_ready_ne_expr!(a, b);
+///
+/// # let result = panic::catch_unwind(|| {
+/// let a: Poll<i8> = Ready(1);
+/// let b: i8 = 1;
+/// assert_ready_ne_expr!(a, b);
+/// # });
+/// // assertion failed: `assert_ready_ne_expr!(a, b)`
+/// // https://docs.rs/assertables/8.11.0/assertables/macro.assert_ready_ne_expr.html
+/// //  a label: `a`,
+/// //  a debug: `Ready(1)`,
+/// //  a inner: `1`,
+/// //  b label: `b`,
+/// //  b debug: `1`
+/// # let actual = result.unwrap_err().downcast::<String>().unwrap().to_string();
+/// # let expect = concat!(
+/// #     "assertion failed: `assert_ready_ne_expr!(a, b)`\n",
+/// #     "https://docs.rs/assertables/8.11.0/assertables/macro.assert_ready_ne_expr.html\n",
+/// #     " a label: `a`,\n",
+/// #     " a debug: `Ready(1)`,\n",
+/// #     " a inner: `1`,\n",
+/// #     " b label: `b`,\n",
+/// #     " b debug: `1`"
+/// # );
+/// # assert_eq!(actual, expect);
+/// # }
+/// ```
+///
+/// # Module macros
+///
+/// * [`assert_ready_ne_expr`](macro@crate::assert_ready_ne_expr)
+/// * [`assert_ready_ne_expr_as_result`](macro@crate::assert_ready_ne_expr_as_result)
+/// * [`debug_assert_ready_ne_expr`](macro@crate::debug_assert_ready_ne_expr)
+///
+#[macro_export]
+macro_rules! assert_ready_ne_expr {
+    ($a:expr, $b:expr $(,)?) => {{
+        match $crate::assert_ready_ne_expr_as_result!($a, $b) {
+            Ok(()) => (),
+            Err(err) => panic!("{}", err),
+        }
+    }};
+    ($a:expr, $b:expr, $($message:tt)+) => {{
+        match $crate::assert_ready_ne_expr_as_result!($a, $b) {
+            Ok(()) => (),
+            Err(_err) => panic!("{}", $($message)+),
+        }
+    }};
+}
+
+/// Assert an expression is Ready(_) and its value is not equal to an expression.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Ready(a̅) ⇒ a̅) ≠ b
+///
+/// This macro provides the same statements as [`assert_ready_ne_expr`](macro.assert_ready_ne_expr.html),
+/// except this macro's statements are only enabled in non-optimized
+/// builds by default. An optimized build will not execute this macro's
+/// statements unless `-C debug-assertions` is passed to the compiler.
+///
+/// This macro is useful for checks that are too expensive to be present
+/// in a release build but may be helpful during development.
+///
+/// The result of expanding this macro is always type checked.
+///
+/// An unchecked assertion allows a program in an inconsistent state to
+/// keep running, which might have unexpected consequences but does not
+/// introduce unsafety as long as this only happens in safe code. The
+/// performance cost of assertions, however, is not measurable in general.
+/// Replacing `assert*!` with `debug_assert*!` is thus only encouraged
+/// after thorough profiling, and more importantly, only in safe code!
+///
+/// This macro is intended to work in a similar way to
+/// [`std::debug_assert`](https://doc.rust-lang.org/std/macro.debug_assert.html).
+///
+/// # Module macros
+///
+/// * [`assert_ready_ne_expr`](macro@crate::assert_ready_ne_expr)
+/// * [`assert_ready_ne_expr`](macro@crate::assert_ready_ne_expr)
+/// * [`debug_assert_ready_ne_expr`](macro@crate::debug_assert_ready_ne_expr)
+///
+#[macro_export]
+macro_rules! debug_assert_ready_ne_expr {
+    ($($arg:tt)*) => {
+        if $crate::cfg!(debug_assertions) {
+            $crate::assert_ready_ne_expr!($($arg)*);
+        }
+    };
+}
+

\ No newline at end of file
diff --git a/doc/src/lib/assert_ready/mod.rs.html b/doc/src/lib/assert_ready/mod.rs.html
new file mode 100644
index 000000000..76acdb6b7
--- /dev/null
+++ b/doc/src/lib/assert_ready/mod.rs.html
@@ -0,0 +1,71 @@
+mod.rs - source
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+
//! Assert macros for Ready(_) items.
+//!
+//! These macros help compare Ready(…) items, such as `std::Ready::Ready` or similar.
+//!
+//! Assert expression is Ready(_):
+//! 
+//! * [`assert_ready!(a)`](macro@crate::assert_ready) 
+//!   ≈ a is Ready(_)
+//! 
+//! Compare Ready(…) to another Ready(…):
+//! 
+//! * [`assert_ready_eq!(a, b)`](macro@crate::assert_ready_eq) 
+//!   ≈ (a ⇒ Ready(a̅) ⇒ a̅) = (b ⇒ Ready(b̅) ⇒ b̅)
+//!
+//! * [`assert_ready_ne!(a, b)`](macro@crate::assert_ready_ne) 
+//!   ≈ (a ⇒ Ready(a̅) ⇒ a̅) ≠ (b ⇒ Ready(b̅) ⇒ b̅)
+//!
+//! Compare Ready(…) to an expression:
+//! 
+//! * [`assert_ready_eq_expr!(a, expr)`](macro@crate::assert_ready_eq_expr) 
+//!   ≈ (a ⇒ Ready(a̅) ⇒ a̅) = b
+//!
+//! * [`assert_ready_ne_expr!(a, b)`](macro@crate::assert_ready_ne_expr) 
+//!   ≈ (a ⇒ Ready(a̅) ⇒ a̅) ≠ b
+
+// Verify Ready(_)
+pub mod assert_ready;
+
+// Compare with another
+pub mod assert_ready_eq;
+pub mod assert_ready_ne;
+
+// Compare with expression
+pub mod assert_ready_eq_expr;
+pub mod assert_ready_ne_expr;
+

\ No newline at end of file
diff --git a/doc/src/lib/assert_some/assert_some.rs.html b/doc/src/lib/assert_some/assert_some.rs.html
new file mode 100644
index 000000000..a3be26239
--- /dev/null
+++ b/doc/src/lib/assert_some/assert_some.rs.html
@@ -0,0 +1,391 @@
+assert_some.rs - source
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+144
+145
+146
+147
+148
+149
+150
+151
+152
+153
+154
+155
+156
+157
+158
+159
+160
+161
+162
+163
+164
+165
+166
+167
+168
+169
+170
+171
+172
+173
+174
+175
+176
+177
+178
+179
+180
+181
+182
+183
+184
+185
+186
+187
+188
+189
+190
+191
+192
+193
+194
+195
+
//!Assert expression is Some(_).
+//!
+//! Pseudocode:<br>
+//! a is Some(_)
+//!
+//! # Example
+//!
+//! ```rust
+//! use assertables::*;
+//! # fn main() {
+//! let a: Option<i8> = Option::Some(1);
+//! assert_some!(a);
+//! # }
+//! ```
+//!
+//! # Module macros
+//!
+//! * [`assert_some`](macro@crate::assert_some)
+//! * [`assert_some_as_result`](macro@crate::assert_some_as_result)
+//! * [`debug_assert_some`](macro@crate::debug_assert_some)
+
+/// Assert an expression.is_some() is true.
+///
+/// Pseudocode:<br>
+/// a is Some(_)
+///
+/// * If true, return Result `Ok(())`.
+///
+/// * Otherwise, return Result `Err` with a diagnostic message.
+///
+/// This macro provides the same statements as [`assert_some`](macro.assert_some.html),
+/// except this macro returns a Result, rather than doing a panic.
+///
+/// This macro is useful for runtime checks, such as checking parameters,
+/// or sanitizing inputs, or handling different results in different ways.
+///
+/// # Module macros
+///
+/// * [`assert_some`](macro@crate::assert_some)
+/// * [`assert_some_as_result`](macro@crate::assert_some_as_result)
+/// * [`debug_assert_some`](macro@crate::debug_assert_some)
+///
+#[macro_export]
+macro_rules! assert_some_as_result {
+    ($a:expr $(,)?) => {{
+        match (&$a) {
+            option => {
+                match (option) {
+                    Some(_) => {
+                        Ok(())
+                    },
+                    _ => {
+                        Err(format!(
+                            concat!(
+                                "assertion failed: `assert_some!(a)`\n",
+                                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_some.html\n",
+                                " option label: `{}`,\n",
+                                " option debug: `{:?}`",
+                            ),
+                            stringify!($a),
+                            option
+                        ))
+                    }
+                }
+            }
+        }
+    }};
+}
+
+#[cfg(test)]
+mod tests {
+
+    #[test]
+    fn test_assert_some_as_result_x_success() {
+        let a: Option<i8> = Option::Some(1);
+        let result = assert_some_as_result!(a);
+        assert_eq!(result, Ok(()));
+    }
+
+    #[test]
+    fn test_assert_some_as_result_x_failure() {
+        let a: Option<i8> = Option::None;
+        let result = assert_some_as_result!(a);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err(),
+            concat!(
+                "assertion failed: `assert_some!(a)`\n",
+                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_some.html\n",
+                " option label: `a`,\n",
+                " option debug: `None`",
+            )
+        );
+    }
+}
+
+/// Assert expression is Some(_).
+///
+/// Pseudocode:<br>
+/// a is Some(_)
+///
+/// * If true, return `()`.
+///
+/// * Otherwise, call [`panic!`] with a message and the values of the
+///   expressions with their debug representations.
+///
+/// # Examples
+///
+/// ```rust
+/// use assertables::*;
+/// # use std::panic;
+/// # fn main() {
+/// let a: Option<i8> = Option::Some(1);
+/// assert_some!(a);
+///
+/// # let result = panic::catch_unwind(|| {
+/// let a: Option<i8> = Option::None;
+/// assert_some!(a);
+/// # });
+/// // assertion failed: `assert_some!(a)`
+/// // https://docs.rs/assertables/8.11.0/assertables/macro.assert_some.html
+/// //  option label: `a`,
+/// //  option debug: `None`
+/// # let actual = result.unwrap_err().downcast::<String>().unwrap().to_string();
+/// # let expect = concat!(
+/// #     "assertion failed: `assert_some!(a)`\n",
+/// #     "https://docs.rs/assertables/8.11.0/assertables/macro.assert_some.html\n",
+/// #     " option label: `a`,\n",
+/// #     " option debug: `None`",
+/// # );
+/// # assert_eq!(actual, expect);
+/// # }
+/// ```
+///
+/// # Module macros
+///
+/// * [`assert_some`](macro@crate::assert_some)
+/// * [`assert_some_as_result`](macro@crate::assert_some_as_result)
+/// * [`debug_assert_some`](macro@crate::debug_assert_some)
+///
+#[macro_export]
+macro_rules! assert_some {
+    ($a:expr $(,)?) => {{
+        match $crate::assert_some_as_result!($a) {
+            Ok(()) => (),
+            Err(err) => panic!("{}", err),
+        }
+    }};
+    ($a:expr, $($message:tt)+) => {{
+        match $crate::assert_some_as_result!($a) {
+            Ok(()) => (),
+            Err(_err) => panic!("{}", $($message)+),
+        }
+    }};
+}
+
+/// Assert expression is Some(_).
+///
+/// Pseudocode:<br>
+/// a is Some(_)
+///
+/// This macro provides the same statements as [`assert_some`](macro.assert_some.html),
+/// except this macro's statements are only enabled in non-optimized
+/// builds by default. An optimized build will not execute this macro's
+/// statements unless `-C debug-assertions` is passed to the compiler.
+///
+/// This macro is useful for checks that are too expensive to be present
+/// in a release build but may be helpful during development.
+///
+/// The result of expanding this macro is always type checked.
+///
+/// An unchecked assertion allows a program in an inconsistent state to
+/// keep running, which might have unexpected consequences but does not
+/// introduce unsafety as long as this only happens in safe code. The
+/// performance cost of assertions, however, is not measurable in general.
+/// Replacing `assert*!` with `debug_assert*!` is thus only encouraged
+/// after thorough profiling, and more importantly, only in safe code!
+///
+/// This macro is intended to work in a similar way to
+/// [`std::debug_assert`](https://doc.rust-lang.org/std/macro.debug_assert.html).
+///
+/// # Module macros
+///
+/// * [`assert_some`](macro@crate::assert_some)
+/// * [`assert_some`](macro@crate::assert_some)
+/// * [`debug_assert_some`](macro@crate::debug_assert_some)
+///
+#[macro_export]
+macro_rules! debug_assert_some {
+    ($($arg:tt)*) => {
+        if $crate::cfg!(debug_assertions) {
+            $crate::assert_some!($($arg)*);
+        }
+    };
+}
+

\ No newline at end of file
diff --git a/doc/src/lib/assert_some/assert_some_eq.rs.html b/doc/src/lib/assert_some/assert_some_eq.rs.html
new file mode 100644
index 000000000..33d5c6e89
--- /dev/null
+++ b/doc/src/lib/assert_some/assert_some_eq.rs.html
@@ -0,0 +1,515 @@
+assert_some_eq.rs - source
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+144
+145
+146
+147
+148
+149
+150
+151
+152
+153
+154
+155
+156
+157
+158
+159
+160
+161
+162
+163
+164
+165
+166
+167
+168
+169
+170
+171
+172
+173
+174
+175
+176
+177
+178
+179
+180
+181
+182
+183
+184
+185
+186
+187
+188
+189
+190
+191
+192
+193
+194
+195
+196
+197
+198
+199
+200
+201
+202
+203
+204
+205
+206
+207
+208
+209
+210
+211
+212
+213
+214
+215
+216
+217
+218
+219
+220
+221
+222
+223
+224
+225
+226
+227
+228
+229
+230
+231
+232
+233
+234
+235
+236
+237
+238
+239
+240
+241
+242
+243
+244
+245
+246
+247
+248
+249
+250
+251
+252
+253
+254
+255
+256
+257
+
//! Assert two expressions are Some(_) and their values are equal.
+//!
+//! Pseudocode:<br>
+//! (a ⇒ Some(a̅) ⇒ a̅) = (b ⇒ Some(b̅) ⇒ b̅)
+//!
+//! # Example
+//!
+//! ```rust
+//! use assertables::*;
+//! # fn main() {
+//! let a: Option<i8> = Option::Some(1);
+//! let b: Option<i8> = Option::Some(1);
+//! assert_some_eq!(a, b);
+//! # }
+//! ```
+//!
+//! # Module macros
+//!
+//! * [`assert_some_eq`](macro@crate::assert_some_eq)
+//! * [`assert_some_eq_as_result`](macro@crate::assert_some_eq_as_result)
+//! * [`debug_assert_some_eq`](macro@crate::debug_assert_some_eq)
+
+/// Assert a.is_some() and a.unwrap() are equal to another.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Some(a̅) ⇒ a̅) = (b ⇒ Some(b̅) ⇒ b̅)
+///
+/// * If true, return Result `Ok(())`.
+///
+/// * Otherwise, return Result `Err` with a diagnostic message.
+///
+/// This macro provides the same statements as [`assert_some_eq`](macro.assert_some_eq.html),
+/// except this macro returns a Option, rather than doing a panic.
+///
+/// This macro is useful for runtime checks, such as checking parameters,
+/// or sanitizing inputs, or handling different results in different ways.
+///
+/// # Module macros
+///
+/// * [`assert_some_eq`](macro@crate::assert_some_eq)
+/// * [`assert_some_eq_as_result`](macro@crate::assert_some_eq_as_result)
+/// * [`debug_assert_some_eq`](macro@crate::debug_assert_some_eq)
+///
+#[macro_export]
+macro_rules! assert_some_eq_as_result {
+    ($a:expr, $b:expr $(,)?) => {{
+        match (&$a, &$b) {
+            (a, b) => {
+                match (a, b) {
+                    (Some(a_inner), Some(b_inner)) => {
+                        if a_inner == b_inner {
+                            Ok(())
+                        } else {
+                            Err(format!(
+                                concat!(
+                                    "assertion failed: `assert_some_eq!(a, b)`\n",
+                                    "https://docs.rs/assertables/8.11.0/assertables/macro.assert_some_eq.html\n",
+                                    " a label: `{}`,\n",
+                                    " a debug: `{:?}`,\n",
+                                    " a inner: `{:?}`,\n",
+                                    " b label: `{}`,\n",
+                                    " b debug: `{:?}`,\n",
+                                    " b inner: `{:?}`"
+                                ),
+                                stringify!($a),
+                                a,
+                                a_inner,
+                                stringify!($b),
+                                b,
+                                b_inner
+                            ))
+                        }
+                    },
+                    _ => {
+                        Err(format!(
+                            concat!(
+                                "assertion failed: `assert_some_eq!(a, b)`\n",
+                                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_some_eq.html\n",
+                                " a label: `{}`,\n",
+                                " a debug: `{:?}`,\n",
+                                " b label: `{}`,\n",
+                                " b debug: `{:?}`",
+                            ),
+                            stringify!($a),
+                            a,
+                            stringify!($b),
+                            b,
+                        ))
+                    }
+                }
+            }
+        }
+    }};
+}
+
+#[cfg(test)]
+mod tests {
+
+    #[test]
+    fn test_assert_some_eq_as_result_x_success() {
+        let a: Option<i8> = Option::Some(1);
+        let b: Option<i8> = Option::Some(1);
+        let result = assert_some_eq_as_result!(a, b);
+        assert_eq!(result, Ok(()));
+    }
+
+    #[test]
+    fn test_assert_some_eq_as_result_x_failure_because_ne() {
+        let a: Option<i8> = Option::Some(1);
+        let b: Option<i8> = Option::Some(2);
+        let result = assert_some_eq_as_result!(a, b);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err(),
+            concat!(
+                "assertion failed: `assert_some_eq!(a, b)`\n",
+                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_some_eq.html\n",
+                " a label: `a`,\n",
+                " a debug: `Some(1)`,\n",
+                " a inner: `1`,\n",
+                " b label: `b`,\n",
+                " b debug: `Some(2)`,\n",
+                " b inner: `2`",
+            )
+        );
+    }
+
+    #[test]
+    fn test_assert_some_eq_as_result_x_failure_because_not_some() {
+        let a: Option<i8> = Option::None;
+        let b: Option<i8> = Option::Some(1);
+        let result = assert_some_eq_as_result!(a, b);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err(),
+            concat!(
+                "assertion failed: `assert_some_eq!(a, b)`\n",
+                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_some_eq.html\n",
+                " a label: `a`,\n",
+                " a debug: `None`,\n",
+                " b label: `b`,\n",
+                " b debug: `Some(1)`",
+            )
+        );
+    }
+
+}
+
+/// Assert two expressions are Some(_) and their values are equal.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Some(a̅) ⇒ a̅) = (b ⇒ Some(b̅) ⇒ b̅)
+///
+/// * If true, return `()`.
+///
+/// * Otherwise, call [`panic!`] with a message and the values of the
+///   expressions with their debug representations.
+///
+/// # Examples
+///
+/// ```rust
+/// use assertables::*;
+/// # use std::panic;
+/// # fn main() {
+/// let a: Option<i8> = Option::Some(1);
+/// let b: Option<i8> = Option::Some(1);
+/// assert_some_eq!(a, b);
+///
+/// # let result = panic::catch_unwind(|| {
+/// let a: Option<i8> = Option::Some(1);
+/// let b: Option<i8> = Option::Some(2);
+/// assert_some_eq!(a, b);
+/// # });
+/// // assertion failed: `assert_some_eq!(a, b)`
+/// // https://docs.rs/assertables/8.11.0/assertables/macro.assert_some_eq.html
+/// //  a label: `a`,
+/// //  a debug: `Some(1)`,
+/// //  a inner: `1`,
+/// //  b label: `b`,
+/// //  b debug: `Some(2)`,
+/// //  b inner: `2`
+/// # let actual = result.unwrap_err().downcast::<String>().unwrap().to_string();
+/// # let expect = concat!(
+/// #     "assertion failed: `assert_some_eq!(a, b)`\n",
+/// #     "https://docs.rs/assertables/8.11.0/assertables/macro.assert_some_eq.html\n",
+/// #     " a label: `a`,\n",
+/// #     " a debug: `Some(1)`,\n",
+/// #     " a inner: `1`,\n",
+/// #     " b label: `b`,\n",
+/// #     " b debug: `Some(2)`,\n",
+/// #     " b inner: `2`",
+/// # );
+/// # assert_eq!(actual, expect);
+/// # }
+/// ```
+///
+/// # Module macros
+///
+/// * [`assert_some_eq`](macro@crate::assert_some_eq)
+/// * [`assert_some_eq_as_result`](macro@crate::assert_some_eq_as_result)
+/// * [`debug_assert_some_eq`](macro@crate::debug_assert_some_eq)
+///
+#[macro_export]
+macro_rules! assert_some_eq {
+    ($a:expr, $b:expr $(,)?) => {{
+        match $crate::assert_some_eq_as_result!($a, $b) {
+            Ok(()) => (),
+            Err(err) => panic!("{}", err),
+        }
+    }};
+    ($a:expr, $b:expr, $($message:tt)+) => {{
+        match $crate::assert_some_eq_as_result!($a, $b) {
+            Ok(()) => (),
+            Err(_err) => panic!("{}", $($message)+),
+        }
+    }};
+}
+
+/// Assert two expressions are Some(_) and their values are equal.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Some(a̅) ⇒ a̅) = (b ⇒ Some(b̅) ⇒ b̅)
+///
+/// This macro provides the same statements as [`assert_some_eq`](macro.assert_some_eq.html),
+/// except this macro's statements are only enabled in non-optimized
+/// builds by default. An optimized build will not execute this macro's
+/// statements unless `-C debug-assertions` is passed to the compiler.
+///
+/// This macro is useful for checks that are too expensive to be present
+/// in a release build but may be helpful during development.
+///
+/// The result of expanding this macro is always type checked.
+///
+/// An unchecked assertion allows a program in an inconsistent state to
+/// keep running, which might have unexpected consequences but does not
+/// introduce unsafety as long as this only happens in safe code. The
+/// performance cost of assertions, however, is not measurable in general.
+/// Replacing `assert*!` with `debug_assert*!` is thus only encouraged
+/// after thorough profiling, and more importantly, only in safe code!
+///
+/// This macro is intended to work in a similar way to
+/// [`std::debug_assert`](https://doc.rust-lang.org/std/macro.debug_assert.html).
+///
+/// # Module macros
+///
+/// * [`assert_some_eq`](macro@crate::assert_some_eq)
+/// * [`assert_some_eq`](macro@crate::assert_some_eq)
+/// * [`debug_assert_some_eq`](macro@crate::debug_assert_some_eq)
+///
+#[macro_export]
+macro_rules! debug_assert_some_eq {
+    ($($arg:tt)*) => {
+        if $crate::cfg!(debug_assertions) {
+            $crate::assert_some_eq!($($arg)*);
+        }
+    };
+}
+

\ No newline at end of file
diff --git a/doc/src/lib/assert_some/assert_some_eq_expr.rs.html b/doc/src/lib/assert_some/assert_some_eq_expr.rs.html
new file mode 100644
index 000000000..7f656ccd1
--- /dev/null
+++ b/doc/src/lib/assert_some/assert_some_eq_expr.rs.html
@@ -0,0 +1,505 @@
+assert_some_eq_expr.rs - source
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+144
+145
+146
+147
+148
+149
+150
+151
+152
+153
+154
+155
+156
+157
+158
+159
+160
+161
+162
+163
+164
+165
+166
+167
+168
+169
+170
+171
+172
+173
+174
+175
+176
+177
+178
+179
+180
+181
+182
+183
+184
+185
+186
+187
+188
+189
+190
+191
+192
+193
+194
+195
+196
+197
+198
+199
+200
+201
+202
+203
+204
+205
+206
+207
+208
+209
+210
+211
+212
+213
+214
+215
+216
+217
+218
+219
+220
+221
+222
+223
+224
+225
+226
+227
+228
+229
+230
+231
+232
+233
+234
+235
+236
+237
+238
+239
+240
+241
+242
+243
+244
+245
+246
+247
+248
+249
+250
+251
+252
+
//! Assert an expression is Some(_) and its value is equal to an expression.
+//!
+//! Pseudocode:<br>
+//! (a ⇒ Some(a̅) ⇒ a̅) = b
+//!
+//! # Example
+//!
+//! ```rust
+//! use assertables::*;
+//! # fn main() {
+//! let a: Option<i8> = Option::Some(1);
+//! let b: i8 = 1;
+//! assert_some_eq_expr!(a, b);
+//! # }
+//! ```
+//!
+//! # Module macros
+//!
+//! * [`assert_some_eq_expr`](macro@crate::assert_some_eq_expr)
+//! * [`assert_some_eq_expr_as_result`](macro@crate::assert_some_eq_expr_as_result)
+//! * [`debug_assert_some_eq_expr`](macro@crate::debug_assert_some_eq_expr)
+
+/// Assert a.is_some() and a.unwrap() are equal to another.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Some(a̅) ⇒ a̅) = b
+///
+/// * If true, return Result `Ok(())`.
+///
+/// * Otherwise, return Result `Err` with a diagnostic message.
+///
+/// This macro provides the same statements as [`assert_some_eq_expr`](macro.assert_some_eq_expr.html),
+/// except this macro returns a Option, rather than doing a panic.
+///
+/// This macro is useful for runtime checks, such as checking parameters,
+/// or sanitizing inputs, or handling different results in different ways.
+///
+/// # Module macros
+///
+/// * [`assert_some_eq_expr`](macro@crate::assert_some_eq_expr)
+/// * [`assert_some_eq_expr_as_result`](macro@crate::assert_some_eq_expr_as_result)
+/// * [`debug_assert_some_eq_expr`](macro@crate::debug_assert_some_eq_expr)
+///
+#[macro_export]
+macro_rules! assert_some_eq_expr_as_result {
+    ($a:expr, $b:expr $(,)?) => {{
+        match (&$a, &$b) {
+            (a, b) => {
+                match a {
+                    Some(a_inner) => {
+                        if a_inner == b {
+                            Ok(())
+                        } else {
+                            Err(format!(
+                                concat!(
+                                    "assertion failed: `assert_some_eq_expr!(a, b)`\n",
+                                    "https://docs.rs/assertables/8.11.0/assertables/macro.assert_some_eq_expr.html\n",
+                                    " a label: `{}`,\n",
+                                    " a debug: `{:?}`,\n",
+                                    " a inner: `{:?}`,\n",
+                                    " b label: `{}`,\n",
+                                    " b debug: `{:?}`"
+                                ),
+                                stringify!($a),
+                                a,
+                                a_inner,
+                                stringify!($b),
+                                b
+                            ))
+                        }
+                    },
+                    _ => {
+                        Err(format!(
+                            concat!(
+                                "assertion failed: `assert_some_eq_expr!(a, b)`\n",
+                                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_some_eq_expr.html\n",
+                                " a label: `{}`,\n",
+                                " a debug: `{:?}`,\n",
+                                " b label: `{}`,\n",
+                                " b debug: `{:?}`",
+                            ),
+                            stringify!($a),
+                            a,
+                            stringify!($b),
+                            b,
+                        ))
+                    }
+                }
+            }
+        }
+    }};
+}
+
+#[cfg(test)]
+mod tests {
+
+    #[test]
+    fn test_assert_some_eq_expr_as_result_x_success() {
+        let a: Option<i8> = Option::Some(1);
+        let b: i8 = 1;
+        let result = assert_some_eq_expr_as_result!(a, b);
+        assert_eq!(result, Ok(()));
+    }
+
+    #[test]
+    fn test_assert_some_eq_expr_as_result_x_failure_because_ne() {
+        let a: Option<i8> = Option::Some(1);
+        let b: i8 = 2;
+        let result = assert_some_eq_expr_as_result!(a, b);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err(),
+            concat!(
+                "assertion failed: `assert_some_eq_expr!(a, b)`\n",
+                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_some_eq_expr.html\n",
+                " a label: `a`,\n",
+                " a debug: `Some(1)`,\n",
+                " a inner: `1`,\n",
+                " b label: `b`,\n",
+                " b debug: `2`"
+            )
+        );
+    }
+
+    #[test]
+    fn test_assert_some_eq_expr_as_result_x_failure_because_not_some() {
+        let a: Option<i8> = Option::None;
+        let b: i8 = 1;
+        let result = assert_some_eq_expr_as_result!(a, b);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err(),
+            concat!(
+                "assertion failed: `assert_some_eq_expr!(a, b)`\n",
+                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_some_eq_expr.html\n",
+                " a label: `a`,\n",
+                " a debug: `None`,\n",
+                " b label: `b`,\n",
+                " b debug: `1`",
+            )
+        );
+    }
+
+}
+
+/// Assert an expression is Some(_) and its value is equal to an expression.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Some(a̅) ⇒ a̅) = b
+///
+/// * If true, return `()`.
+///
+/// * Otherwise, call [`panic!`] with a message and the values of the
+///   expressions with their debug representations.
+///
+/// # Examples
+///
+/// ```rust
+/// use assertables::*;
+/// # use std::panic;
+/// # fn main() {
+/// let a: Option<i8> = Option::Some(1);
+/// let b: i8 = 1;
+/// assert_some_eq_expr!(a, b);
+///
+/// # let result = panic::catch_unwind(|| {
+/// let a: Option<i8> = Option::Some(1);
+/// let b: i8 = 2;
+/// assert_some_eq_expr!(a, b);
+/// # });
+/// // assertion failed: `assert_some_eq_expr!(a, b)`
+/// // https://docs.rs/assertables/8.11.0/assertables/macro.assert_some_eq_expr.html
+/// //  a label: `a`,
+/// //  a debug: `Some(1)`,
+/// //  a inner: `1`,
+/// //  b label: `b`,
+/// //  b debug: `2`
+/// # let actual = result.unwrap_err().downcast::<String>().unwrap().to_string();
+/// # let expect = concat!(
+/// #     "assertion failed: `assert_some_eq_expr!(a, b)`\n",
+/// #     "https://docs.rs/assertables/8.11.0/assertables/macro.assert_some_eq_expr.html\n",
+/// #     " a label: `a`,\n",
+/// #     " a debug: `Some(1)`,\n",
+/// #     " a inner: `1`,\n",
+/// #     " b label: `b`,\n",
+/// #     " b debug: `2`",
+/// # );
+/// # assert_eq!(actual, expect);
+/// # }
+/// ```
+///
+/// # Module macros
+///
+/// * [`assert_some_eq_expr`](macro@crate::assert_some_eq_expr)
+/// * [`assert_some_eq_expr_as_result`](macro@crate::assert_some_eq_expr_as_result)
+/// * [`debug_assert_some_eq_expr`](macro@crate::debug_assert_some_eq_expr)
+///
+#[macro_export]
+macro_rules! assert_some_eq_expr {
+    ($a:expr, $b:expr $(,)?) => {{
+        match $crate::assert_some_eq_expr_as_result!($a, $b) {
+            Ok(()) => (),
+            Err(err) => panic!("{}", err),
+        }
+    }};
+    ($a:expr, $b:expr, $($message:tt)+) => {{
+        match $crate::assert_some_eq_expr_as_result!($a, $b) {
+            Ok(()) => (),
+            Err(_err) => panic!("{}", $($message)+),
+        }
+    }};
+}
+
+/// Assert an expression is Some(_) and its value is equal to an expression.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Some(a̅) ⇒ a̅) = b
+///
+/// This macro provides the same statements as [`assert_some_eq_expr`](macro.assert_some_eq_expr.html),
+/// except this macro's statements are only enabled in non-optimized
+/// builds by default. An optimized build will not execute this macro's
+/// statements unless `-C debug-assertions` is passed to the compiler.
+///
+/// This macro is useful for checks that are too expensive to be present
+/// in a release build but may be helpful during development.
+///
+/// The result of expanding this macro is always type checked.
+///
+/// An unchecked assertion allows a program in an inconsistent state to
+/// keep running, which might have unexpected consequences but does not
+/// introduce unsafety as long as this only happens in safe code. The
+/// performance cost of assertions, however, is not measurable in general.
+/// Replacing `assert*!` with `debug_assert*!` is thus only encouraged
+/// after thorough profiling, and more importantly, only in safe code!
+///
+/// This macro is intended to work in a similar way to
+/// [`std::debug_assert`](https://doc.rust-lang.org/std/macro.debug_assert.html).
+///
+/// # Module macros
+///
+/// * [`assert_some_eq_expr`](macro@crate::assert_some_eq_expr)
+/// * [`assert_some_eq_expr`](macro@crate::assert_some_eq_expr)
+/// * [`debug_assert_some_eq_expr`](macro@crate::debug_assert_some_eq_expr)
+///
+#[macro_export]
+macro_rules! debug_assert_some_eq_expr {
+    ($($arg:tt)*) => {
+        if $crate::cfg!(debug_assertions) {
+            $crate::assert_some_eq_expr!($($arg)*);
+        }
+    };
+}
+

\ No newline at end of file
diff --git a/doc/src/lib/assert_some/assert_some_ne.rs.html b/doc/src/lib/assert_some/assert_some_ne.rs.html
new file mode 100644
index 000000000..a729fc439
--- /dev/null
+++ b/doc/src/lib/assert_some/assert_some_ne.rs.html
@@ -0,0 +1,515 @@
+assert_some_ne.rs - source
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+144
+145
+146
+147
+148
+149
+150
+151
+152
+153
+154
+155
+156
+157
+158
+159
+160
+161
+162
+163
+164
+165
+166
+167
+168
+169
+170
+171
+172
+173
+174
+175
+176
+177
+178
+179
+180
+181
+182
+183
+184
+185
+186
+187
+188
+189
+190
+191
+192
+193
+194
+195
+196
+197
+198
+199
+200
+201
+202
+203
+204
+205
+206
+207
+208
+209
+210
+211
+212
+213
+214
+215
+216
+217
+218
+219
+220
+221
+222
+223
+224
+225
+226
+227
+228
+229
+230
+231
+232
+233
+234
+235
+236
+237
+238
+239
+240
+241
+242
+243
+244
+245
+246
+247
+248
+249
+250
+251
+252
+253
+254
+255
+256
+257
+
//! Assert two expressions are Some(_) and their values are not equal.
+//!
+//! Pseudocode:<br>
+//! (a ⇒ Some(a̅) ⇒ a̅) ≠ (b ⇒ Some(b̅) ⇒ b̅)
+//!
+//! # Example
+//!
+//! ```rust
+//! use assertables::*;
+//! # fn main() {
+//! let a: Option<i8> = Option::Some(1);
+//! let b: Option<i8> = Option::Some(2);
+//! assert_some_ne!(a, b);
+//! # }
+//! ```
+//!
+//! # Module macros
+//!
+//! * [`assert_some_ne`](macro@crate::assert_some_ne)
+//! * [`assert_some_ne_as_result`](macro@crate::assert_some_ne_as_result)
+//! * [`debug_assert_some_ne`](macro@crate::debug_assert_some_ne)
+
+/// Assert two expressions are Some(_) and their values are not equal.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Some(a̅) ⇒ a̅) ≠ (b ⇒ Some(b̅) ⇒ b̅)
+///
+/// * If true, return Result `Ok(())`.
+///
+/// * Otherwise, return Result `Err` with a diagnostic message.
+///
+/// This macro provides the same statements as [`assert_some_ne`](macro.assert_some_ne.html),
+/// except this macro returns a Option, rather than doing a panic.
+///
+/// This macro is useful for runtime checks, such as checking parameters,
+/// or sanitizing inputs, or handling different results in different ways.
+///
+/// # Module macros
+///
+/// * [`assert_some_ne`](macro@crate::assert_some_ne)
+/// * [`assert_some_ne_as_result`](macro@crate::assert_some_ne_as_result)
+/// * [`debug_assert_some_ne`](macro@crate::debug_assert_some_ne)
+///
+#[macro_export]
+macro_rules! assert_some_ne_as_result {
+    ($a:expr, $b:expr $(,)?) => {{
+        match (&$a, &$b) {
+            (a, b) => {
+                match (a, b) {
+                    (Some(a_inner), Some(b_inner)) => {
+                        if a_inner != b_inner {
+                            Ok(())
+                        } else {
+                            Err(format!(
+                                concat!(
+                                    "assertion failed: `assert_some_ne!(a, b)`\n",
+                                    "https://docs.rs/assertables/8.11.0/assertables/macro.assert_some_ne.html\n",
+                                    " a label: `{}`,\n",
+                                    " a debug: `{:?}`,\n",
+                                    " a inner: `{:?}`,\n",
+                                    " b label: `{}`,\n",
+                                    " b debug: `{:?}`,\n",
+                                    " b inner: `{:?}`"
+                                ),
+                                stringify!($a),
+                                a,
+                                a_inner,
+                                stringify!($b),
+                                b,
+                                b_inner
+                            ))
+                        }
+                    },
+                    _ => {
+                        Err(format!(
+                            concat!(
+                                "assertion failed: `assert_some_ne!(a, b)`\n",
+                                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_some_ne.html\n",
+                                " a label: `{}`,\n",
+                                " a debug: `{:?}`,\n",
+                                " b label: `{}`,\n",
+                                " b debug: `{:?}`",
+                            ),
+                            stringify!($a),
+                            a,
+                            stringify!($b),
+                            b,
+                        ))
+                    }
+                }
+            }
+        }
+    }};
+}
+
+#[cfg(test)]
+mod tests {
+
+    #[test]
+    fn test_assert_some_ne_as_result_x_success() {
+        let a: Option<i8> = Option::Some(1);
+        let b: Option<i8> = Option::Some(2);
+        let result = assert_some_ne_as_result!(a, b);
+        assert_eq!(result, Ok(()));
+    }
+
+    #[test]
+    fn test_assert_some_ne_as_result_x_failure_because_eq() {
+        let a: Option<i8> = Option::Some(1);
+        let b: Option<i8> = Option::Some(1);
+        let result = assert_some_ne_as_result!(a, b);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err(),
+            concat!(
+                "assertion failed: `assert_some_ne!(a, b)`\n",
+                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_some_ne.html\n",
+                " a label: `a`,\n",
+                " a debug: `Some(1)`,\n",
+                " a inner: `1`,\n",
+                " b label: `b`,\n",
+                " b debug: `Some(1)`,\n",
+                " b inner: `1`",
+            )
+        );
+    }
+
+    #[test]
+    fn test_assert_some_ne_as_result_x_failure_because_not_some() {
+        let a: Option<i8> = Option::None;
+        let b: Option<i8> = Option::Some(1);
+        let result = assert_some_ne_as_result!(a, b);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err(),
+            concat!(
+                "assertion failed: `assert_some_ne!(a, b)`\n",
+                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_some_ne.html\n",
+                " a label: `a`,\n",
+                " a debug: `None`,\n",
+                " b label: `b`,\n",
+                " b debug: `Some(1)`",
+            )
+        );
+    }
+
+}
+
+/// Assert two expressions are Some(_) and their values are not equal.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Some(a̅) ⇒ a̅) ≠ (b ⇒ Some(b̅) ⇒ b̅)
+///
+/// * If true, return `()`.
+///
+/// * Otherwise, call [`panic!`] with a message and the values of the
+///   expressions with their debug representations.
+///
+/// # Examples
+///
+/// ```rust
+/// use assertables::*;
+/// # use std::panic;
+/// # fn main() {
+/// let a: Option<i8> = Option::Some(1);
+/// let b: Option<i8> = Option::Some(2);
+/// assert_some_ne!(a, b);
+///
+/// # let result = panic::catch_unwind(|| {
+/// let a: Option<i8> = Option::Some(1);
+/// let b: Option<i8> = Option::Some(1);
+/// assert_some_ne!(a, b);
+/// # });
+/// // assertion failed: `assert_some_ne!(a, b)`
+/// // https://docs.rs/assertables/8.11.0/assertables/macro.assert_some_ne.html
+/// //  a label: `a`,
+/// //  a debug: `Some(1)`,
+/// //  b label: `b`,
+/// //  b debug: `Some(1)`,
+/// //  a inner: `1`,
+/// //  b inner: `1`
+/// # let actual = result.unwrap_err().downcast::<String>().unwrap().to_string();
+/// # let expect = concat!(
+/// #     "assertion failed: `assert_some_ne!(a, b)`\n",
+/// #     "https://docs.rs/assertables/8.11.0/assertables/macro.assert_some_ne.html\n",
+/// #     " a label: `a`,\n",
+/// #     " a debug: `Some(1)`,\n",
+/// #     " a inner: `1`,\n",
+/// #     " b label: `b`,\n",
+/// #     " b debug: `Some(1)`,\n",
+/// #     " b inner: `1`",
+/// # );
+/// # assert_eq!(actual, expect);
+/// # }
+/// ```
+///
+/// # Module macros
+///
+/// * [`assert_some_ne`](macro@crate::assert_some_ne)
+/// * [`assert_some_ne_as_result`](macro@crate::assert_some_ne_as_result)
+/// * [`debug_assert_some_ne`](macro@crate::debug_assert_some_ne)
+///
+#[macro_export]
+macro_rules! assert_some_ne {
+    ($a:expr, $b:expr $(,)?) => {{
+        match $crate::assert_some_ne_as_result!($a, $b) {
+            Ok(()) => (),
+            Err(err) => panic!("{}", err),
+        }
+    }};
+    ($a:expr, $b:expr, $($message:tt)+) => {{
+        match $crate::assert_some_ne_as_result!($a, $b) {
+            Ok(()) => (),
+            Err(_err) => panic!("{}", $($message)+),
+        }
+    }};
+}
+
+/// Assert two expressions are Some(_) and their values are not equal.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Some(a̅) ⇒ a̅) ≠ (b ⇒ Some(b̅) ⇒ b̅)
+///
+/// This macro provides the same statements as [`assert_some_ne`](macro.assert_some_ne.html),
+/// except this macro's statements are only enabled in non-optimized
+/// builds by default. An optimized build will not execute this macro's
+/// statements unless `-C debug-assertions` is passed to the compiler.
+///
+/// This macro is useful for checks that are too expensive to be present
+/// in a release build but may be helpful during development.
+///
+/// The result of expanding this macro is always type checked.
+///
+/// An unchecked assertion allows a program in an inconsistent state to
+/// keep running, which might have unexpected consequences but does not
+/// introduce unsafety as long as this only happens in safe code. The
+/// performance cost of assertions, however, is not measurable in general.
+/// Replacing `assert*!` with `debug_assert*!` is thus only encouraged
+/// after thorough profiling, and more importantly, only in safe code!
+///
+/// This macro is intended to work in a similar way to
+/// [`std::debug_assert`](https://doc.rust-lang.org/std/macro.debug_assert.html).
+///
+/// # Module macros
+///
+/// * [`assert_some_ne`](macro@crate::assert_some_ne)
+/// * [`assert_some_ne`](macro@crate::assert_some_ne)
+/// * [`debug_assert_some_ne`](macro@crate::debug_assert_some_ne)
+///
+#[macro_export]
+macro_rules! debug_assert_some_ne {
+    ($($arg:tt)*) => {
+        if $crate::cfg!(debug_assertions) {
+            $crate::assert_some_ne!($($arg)*);
+        }
+    };
+}
+

\ No newline at end of file
diff --git a/doc/src/lib/assert_some/assert_some_ne_expr.rs.html b/doc/src/lib/assert_some/assert_some_ne_expr.rs.html
new file mode 100644
index 000000000..7f5c0851e
--- /dev/null
+++ b/doc/src/lib/assert_some/assert_some_ne_expr.rs.html
@@ -0,0 +1,505 @@
+assert_some_ne_expr.rs - source
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+144
+145
+146
+147
+148
+149
+150
+151
+152
+153
+154
+155
+156
+157
+158
+159
+160
+161
+162
+163
+164
+165
+166
+167
+168
+169
+170
+171
+172
+173
+174
+175
+176
+177
+178
+179
+180
+181
+182
+183
+184
+185
+186
+187
+188
+189
+190
+191
+192
+193
+194
+195
+196
+197
+198
+199
+200
+201
+202
+203
+204
+205
+206
+207
+208
+209
+210
+211
+212
+213
+214
+215
+216
+217
+218
+219
+220
+221
+222
+223
+224
+225
+226
+227
+228
+229
+230
+231
+232
+233
+234
+235
+236
+237
+238
+239
+240
+241
+242
+243
+244
+245
+246
+247
+248
+249
+250
+251
+252
+
//! Assert an expression is Some(_) and its value is not equal to an expression.
+//!
+//! Pseudocode:<br>
+//! (a ⇒ Some(a̅) ⇒ a̅) ≠ b
+//!
+//! # Example
+//!
+//! ```rust
+//! use assertables::*;
+//! # fn main() {
+//! let a: Option<i8> = Option::Some(1);
+//! let b: i8 = 2;
+//! assert_some_ne_expr!(a, b);
+//! # }
+//! ```
+//!
+//! # Module macros
+//!
+//! * [`assert_some_ne_expr`](macro@crate::assert_some_ne_expr)
+//! * [`assert_some_ne_expr_as_result`](macro@crate::assert_some_ne_expr_as_result)
+//! * [`debug_assert_some_ne_expr`](macro@crate::debug_assert_some_ne_expr)
+
+/// Assert a.is_some() and a.unwrap() are equal to another.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Some(a̅) ⇒ a̅) ≠ b
+///
+/// * If true, return Result `Ok(())`.
+///
+/// * Otherwise, return Result `Err` with a diagnostic message.
+///
+/// This macro provides the same statements as [`assert_some_ne_expr`](macro.assert_some_ne_expr.html),
+/// except this macro returns a Option, rather than doing a panic.
+///
+/// This macro is useful for runtime checks, such as checking parameters,
+/// or sanitizing inputs, or handling different results in different ways.
+///
+/// # Module macros
+///
+/// * [`assert_some_ne_expr`](macro@crate::assert_some_ne_expr)
+/// * [`assert_some_ne_expr_as_result`](macro@crate::assert_some_ne_expr_as_result)
+/// * [`debug_assert_some_ne_expr`](macro@crate::debug_assert_some_ne_expr)
+///
+#[macro_export]
+macro_rules! assert_some_ne_expr_as_result {
+    ($a:expr, $b:expr $(,)?) => {{
+        match (&$a, &$b) {
+            (a, b) => {
+                match a {
+                    Some(a_inner) => {
+                        if a_inner != b {
+                            Ok(())
+                        } else {
+                            Err(format!(
+                                concat!(
+                                    "assertion failed: `assert_some_ne_expr!(a, b)`\n",
+                                    "https://docs.rs/assertables/8.11.0/assertables/macro.assert_some_ne_expr.html\n",
+                                    " a label: `{}`,\n",
+                                    " a debug: `{:?}`,\n",
+                                    " a inner: `{:?}`,\n",
+                                    " b label: `{}`,\n",
+                                    " b debug: `{:?}`"
+                                ),
+                                stringify!($a),
+                                a,
+                                a_inner,
+                                stringify!($b),
+                                b
+                            ))
+                        }
+                    },
+                    _ => {
+                        Err(format!(
+                            concat!(
+                                "assertion failed: `assert_some_ne_expr!(a, b)`\n",
+                                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_some_ne_expr.html\n",
+                                " a label: `{}`,\n",
+                                " a debug: `{:?}`,\n",
+                                " b label: `{}`,\n",
+                                " b debug: `{:?}`",
+                            ),
+                            stringify!($a),
+                            a,
+                            stringify!($b),
+                            b,
+                        ))
+                    }
+                }
+            }
+        }
+    }};
+}
+
+#[cfg(test)]
+mod tests {
+
+    #[test]
+    fn test_assert_some_ne_expr_as_result_x_success() {
+        let a: Option<i8> = Option::Some(1);
+        let b: i8 = 2;
+        let result = assert_some_ne_expr_as_result!(a, b);
+        assert_eq!(result, Ok(()));
+    }
+
+    #[test]
+    fn test_assert_some_ne_expr_as_result_x_failure_because_ne() {
+        let a: Option<i8> = Option::Some(1);
+        let b: i8 = 1;
+        let result = assert_some_ne_expr_as_result!(a, b);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err(),
+            concat!(
+                "assertion failed: `assert_some_ne_expr!(a, b)`\n",
+                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_some_ne_expr.html\n",
+                " a label: `a`,\n",
+                " a debug: `Some(1)`,\n",
+                " a inner: `1`,\n",
+                " b label: `b`,\n",
+                " b debug: `1`"
+            )
+        );
+    }
+
+    #[test]
+    fn test_assert_some_ne_expr_as_result_x_failure_because_not_some() {
+        let a: Option<i8> = Option::None;
+        let b: i8 = 1;
+        let result = assert_some_ne_expr_as_result!(a, b);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err(),
+            concat!(
+                "assertion failed: `assert_some_ne_expr!(a, b)`\n",
+                "https://docs.rs/assertables/8.11.0/assertables/macro.assert_some_ne_expr.html\n",
+                " a label: `a`,\n",
+                " a debug: `None`,\n",
+                " b label: `b`,\n",
+                " b debug: `1`",
+            )
+        );
+    }
+
+}
+
+/// Assert an expression is Some(_) and its value is not equal to an expression.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Some(a̅) ⇒ a̅) ≠ b
+///
+/// * If true, return `()`.
+///
+/// * Otherwise, call [`panic!`] with a message and the values of the
+///   expressions with their debug representations.
+///
+/// # Examples
+///
+/// ```rust
+/// use assertables::*;
+/// # use std::panic;
+/// # fn main() {
+/// let a: Option<i8> = Option::Some(1);
+/// let b: i8 = 2;
+/// assert_some_ne_expr!(a, b);
+///
+/// # let result = panic::catch_unwind(|| {
+/// let a: Option<i8> = Option::Some(1);
+/// let b: i8 = 1;
+/// assert_some_ne_expr!(a, b);
+/// # });
+/// // assertion failed: `assert_some_ne_expr!(a, b)`
+/// // https://docs.rs/assertables/8.11.0/assertables/macro.assert_some_ne_expr.html
+/// //  a label: `a`,
+/// //  a debug: `Some(1)`,
+/// //  a inner: `1`,
+/// //  b label: `b`,
+/// //  b debug: `1`
+/// # let actual = result.unwrap_err().downcast::<String>().unwrap().to_string();
+/// # let expect = concat!(
+/// #     "assertion failed: `assert_some_ne_expr!(a, b)`\n",
+/// #     "https://docs.rs/assertables/8.11.0/assertables/macro.assert_some_ne_expr.html\n",
+/// #     " a label: `a`,\n",
+/// #     " a debug: `Some(1)`,\n",
+/// #     " a inner: `1`,\n",
+/// #     " b label: `b`,\n",
+/// #     " b debug: `1`",
+/// # );
+/// # assert_eq!(actual, expect);
+/// # }
+/// ```
+///
+/// # Module macros
+///
+/// * [`assert_some_ne_expr`](macro@crate::assert_some_ne_expr)
+/// * [`assert_some_ne_expr_as_result`](macro@crate::assert_some_ne_expr_as_result)
+/// * [`debug_assert_some_ne_expr`](macro@crate::debug_assert_some_ne_expr)
+///
+#[macro_export]
+macro_rules! assert_some_ne_expr {
+    ($a:expr, $b:expr $(,)?) => {{
+        match $crate::assert_some_ne_expr_as_result!($a, $b) {
+            Ok(()) => (),
+            Err(err) => panic!("{}", err),
+        }
+    }};
+    ($a:expr, $b:expr, $($message:tt)+) => {{
+        match $crate::assert_some_ne_expr_as_result!($a, $b) {
+            Ok(()) => (),
+            Err(_err) => panic!("{}", $($message)+),
+        }
+    }};
+}
+
+/// Assert an expression is Some(_) and its value is not equal to an expression.
+///
+/// Pseudocode:<br>
+/// (a ⇒ Some(a̅) ⇒ a̅) ≠ b
+///
+/// This macro provides the same statements as [`assert_some_ne_expr`](macro.assert_some_ne_expr.html),
+/// except this macro's statements are only enabled in non-optimized
+/// builds by default. An optimized build will not execute this macro's
+/// statements unless `-C debug-assertions` is passed to the compiler.
+///
+/// This macro is useful for checks that are too expensive to be present
+/// in a release build but may be helpful during development.
+///
+/// The result of expanding this macro is always type checked.
+///
+/// An unchecked assertion allows a program in an inconsistent state to
+/// keep running, which might have unexpected consequences but does not
+/// introduce unsafety as long as this only happens in safe code. The
+/// performance cost of assertions, however, is not measurable in general.
+/// Replacing `assert*!` with `debug_assert*!` is thus only encouraged
+/// after thorough profiling, and more importantly, only in safe code!
+///
+/// This macro is intended to work in a similar way to
+/// [`std::debug_assert`](https://doc.rust-lang.org/std/macro.debug_assert.html).
+///
+/// # Module macros
+///
+/// * [`assert_some_ne_expr`](macro@crate::assert_some_ne_expr)
+/// * [`assert_some_ne_expr`](macro@crate::assert_some_ne_expr)
+/// * [`debug_assert_some_ne_expr`](macro@crate::debug_assert_some_ne_expr)
+///
+#[macro_export]
+macro_rules! debug_assert_some_ne_expr {
+    ($($arg:tt)*) => {
+        if $crate::cfg!(debug_assertions) {
+            $crate::assert_some_ne_expr!($($arg)*);
+        }
+    };
+}
+

\ No newline at end of file
diff --git a/doc/src/lib/assert_some/mod.rs.html b/doc/src/lib/assert_some/mod.rs.html
new file mode 100644
index 000000000..bdd377d97
--- /dev/null
+++ b/doc/src/lib/assert_some/mod.rs.html
@@ -0,0 +1,71 @@
+mod.rs - source
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+
//! Assert macros for Some(_) items.
+//!
+//! These macros help compare Some(…) items, such as `std::Option::Some` or similar.
+//!
+//! Assert expression is Some(_):
+//! 
+//! * [`assert_some!(a)`](macro@crate::assert_some) 
+//!   ≈ a is Some(_)
+//! 
+//! Compare Some(…) to another Some(…):
+//! 
+//! * [`assert_some_eq!(a, b)`](macro@crate::assert_some_eq) 
+//!   ≈ (a ⇒ Some(a̅) ⇒ a̅) = (b ⇒ Some(b̅) ⇒ b̅)
+//!
+//! * [`assert_some_ne!(a, b)`](macro@crate::assert_some_ne) 
+//!   ≈ (a ⇒ Some(a̅) ⇒ a̅) ≠ (b ⇒ Some(b̅) ⇒ b̅)
+//!
+//! Compare Some(…) to an expression:
+//! 
+//! * [`assert_some_eq_expr!(a, expr)`](macro@crate::assert_some_eq_expr) 
+//!   ≈ (a ⇒ Some(a̅) ⇒ a̅) = b
+//!
+//! * [`assert_some_ne_expr!(a, b)`](macro@crate::assert_some_ne_expr) 
+//!   ≈ (a ⇒ Some(a̅) ⇒ a̅) ≠ b
+
+// Verify Some(_)
+pub mod assert_some;
+
+// Compare with another
+pub mod assert_some_eq;
+pub mod assert_some_ne;
+
+// Compare with expression
+pub mod assert_some_eq_expr;
+pub mod assert_some_ne_expr;
+

\ No newline at end of file
diff --git a/doc/src/lib/lib.rs.html b/doc/src/lib/lib.rs.html
index 497cd254d..bad6df8e2 100644
--- a/doc/src/lib/lib.rs.html
+++ b/doc/src/lib/lib.rs.html
@@ -229,57 +229,6 @@
 229
 230
 231
-232
-233
-234
-235
-236
-237
-238
-239
-240
-241
-242
-243
-244
-245
-246
-247
-248
-249
-250
-251
-252
-253
-254
-255
-256
-257
-258
-259
-260
-261
-262
-263
-264
-265
-266
-267
-268
-269
-270
-271
-272
-273
-274
-275
-276
-277
-278
-279
-280
-281
-282
 
//! # Assertables: Rust crate of assert macros for testing
 //!
 //! The `assertables` Rust crate provides many assert macros to improve your
@@ -364,27 +313,17 @@
 //!
 //! For Result Ok/Err:
 //!
-//! * [`assert_ok!(a)`](macro@crate::assert_ok)
-//! * [`assert_ok_eq!(a, b)`](macro@crate::assert_ok_eq)
-//! * [`assert_ok_eq_expr!(a, expr)`](macro@crate::assert_ok_eq_expr)
-//! * [`assert_ok_ne!(a, b)`](macro@crate::assert_ok_ne)
-//! * [`assert_ok_ne_expr!(a, expr)`](macro@crate::assert_ok_ne_expr)
-//! * [`assert_err!(a)`](macro@crate::assert_err)
+//! * [`assert_ok!(a)`](macro@crate::assert_ok) ([eq, ne, etc.](module@crate::assert_ok))
+//! * [`assert_err!(a)`](macro@crate::assert_err) ([eq, ne, etc.](module@crate::assert_err))
 //!
 //! For Option Some/None:
 //!
-//! * [`assert_some!(a)`](macro@crate::assert_some)
-//! * [`assert_some_eq!(a, b)`](macro@crate::assert_some_eq)
-//! * [`assert_some_eq_expr!(a, expr)`](macro@crate::assert_some_eq_expr)
-//! * [`assert_some_ne!(a, b)`](macro@crate::assert_some_ne)
-//! * [`assert_some_ne_expr!(a, expr)`](macro@crate::assert_some_ne_expr)
+//! * [`assert_some!(a)`](macro@crate::assert_some) [eq, ne, etc.](module@crate::assert_some)
 //! * [`assert_none!(a)`](macro@crate::assert_none)
 //!
 //! For Poll Ready/Pending:
 //!
-//! * [`assert_ready!(a)`](macro@crate::assert_ready)
-//! * [`assert_ready_eq!(a, b)`](macro@crate::assert_ready_eq)
-//! * [`assert_ready_ne!(a, b)`](macro@crate::assert_ready_ne)
+//! * [`assert_ready!(a)`](macro@crate::assert_ready) [eq, ne, etc.](module@crate::assert_ready)
 //! * [`assert_pending!(a)`](macro@crate::assert_pending)
 //!
 //! For collections such as arrays, vectors, maps, sets:
@@ -403,11 +342,11 @@
 //! * [`assert_program_args_stdout_eq!(program1, args1, program2, args2)`](macro@crate::assert_program_args_stdout_eq);
 //!
 //! There are many more macros that are grouped into modules.
-//!
+//! 
 //! Modules for collections, such as arrays, vectors, lists, maps:
 //!
-//! * [`assert_set`](module@crate::assert_set) for set collections
-//! * [`assert_bag`](module@crate::assert_bag) for bag collections
+//! * [`assert_set`](module@crate::assert_set) for set collections.
+//! * [`assert_bag`](module@crate::assert_bag) for bag collections.
 //!
 //! Modules for functions:
 //!
@@ -425,51 +364,26 @@
 //! * [`assert_command`](module@crate::assert_command) for commands and their stdout & stderr.
 //! * [`assert_program_args`](module@crate::assert_program_args) for programs with args and their stdout & stderr.
 //!
-//!
+//! 
 //! ## Forms
-//!
-//!
-//! ### Forms for panic versus error
-//!
-//! All the assert macros have 3 forms for different purposes:
-//!
-//! * Panic form for typical tests.
-//! * Debug form for debugging runtimes.
-//! * Result form for runtime checks, verifications, validations, etc.
-//!
-//! Examples:
-//!
-//! * [`assert_starts_with!(a, b)`](https://docs.rs/assertables/latest/assertables/macro.assert_starts_with.html) // panic!
-//! * [`debug_assert_starts_with!(a, b)`](https://docs.rs/assertables/latest/assertables/macro.debug_assert_starts_with.html) // panic! in debug mode
-//! * [`assert_starts_with_as_result!(a, b)`](https://docs.rs/assertables/latest/assertables/macro.assert_starts_with_as_result.html) // return Ok or Err
-//!
-//!
-//! ### Forms for messages
-//!
-//! All the assert macros have 2 forms for messages.
-//!
-//! * Default message form.
-//! * Custom message form.
-//!
-//! Examples:
-//!
-//! * [`assert_starts_with!(a, b)`](https://docs.rs/assertables/latest/assertables/macro.assert_starts_with.html)
-//! * [`assert_starts_with!(a, b, "Your custom message here")`](https://docs.rs/assertables/latest/assertables/macro.assert_starts_with.html)
-//!
-//!
-//! ### Forms for other versus expression
-//!
-//! Many of the assert macros have 2 forms for comparing left hand side and right hand side.
-//!
-//! * Comparing a LHS item to a RHS other of the same type.
-//! * Comparing a LHS item to a RHS expression.
-//!
-//! Examples:
-//!
-//! * [`assert_io_read_to_string_eq!(reader1, reader2)`](https://docs.rs/assertables/latest/assertables/macro.assert_io_read_to_string_eq.html)
-//! * [`assert_io_read_to_string_eq_expr!(reader, expr)`](https://docs.rs/assertables/latest/assertables/macro.assert_io_read_to_string_eq_expr.html)
-//!
-//!
+//! 
+//! All assertables macros have forms for different outcomes:
+//! 
+//! * [`assert_gt!(a, b)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_gt.html) // panic during typical test
+//! * [`assert_gt_as_result!(a, b)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_gt_as_result.html) // return Ok or Err
+//! * [`debug_assert_gt!(a, b)`](https://docs.rs/assertables/8.11.0/assertables/macro.debug_assert_gt.html) // panic when in debug mode
+//! 
+//! All assertables macros have forms for an optional message:
+//! 
+//! * [`assert_gt!(a, b)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_gt.html) // automatic message
+//! * [`assert_gt!(a, b, "Your text")`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_gt.html) // custom message
+//! 
+//! Many assertables macros have forms for comparing left hand side (LHS) and right hand side (RHS) as the same type or as an expression:
+//! 
+//! * [`assert_ok_eq!(a, b)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_ok_eq.html) // Ok(…) = Ok(…)
+//! * [`assert_ok_eq_expr!(a, b)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_ok_eq_expr.html) // Ok(…) = expression
+//! 
+//! 
 //! ## Tracking
 //!
 //! * Package: assertables-rust-crate
@@ -514,32 +428,16 @@
 
 // For Result Ok/Err
 pub mod assert_ok;
-pub mod assert_ok_eq;
-pub mod assert_ok_eq_expr;
-pub mod assert_ok_ne;
-pub mod assert_ok_ne_expr;
 pub mod assert_err;
-pub mod assert_err_eq;
-pub mod assert_err_eq_expr;
-pub mod assert_err_ne;
-pub mod assert_err_ne_expr;
 pub mod assert_result; // Deprecated
 
 // For Option Some/None
 pub mod assert_some;
-pub mod assert_some_eq;
-pub mod assert_some_eq_expr;
-pub mod assert_some_ne;
-pub mod assert_some_ne_expr;
 pub mod assert_none;
 pub mod assert_option; // Deprecated
 
 // For Poll Ready/Pending
 pub mod assert_ready;
-pub mod assert_ready_eq;
-pub mod assert_ready_eq_expr;
-pub mod assert_ready_ne;
-pub mod assert_ready_ne_expr;
 pub mod assert_pending;
 pub mod assert_poll; // Deprecated
 
diff --git a/src/assert_err/mod.rs b/src/assert_err/mod.rs
index a9735929d..80ce9684d 100644
--- a/src/assert_err/mod.rs
+++ b/src/assert_err/mod.rs
@@ -22,23 +22,11 @@
 //!
 //! * [`assert_err_ne_expr!(a, b)`](macro@crate::assert_err_ne_expr) 
 //!   ≈ (a ⇒ Err(a̅) ⇒ a̅) ≠ b
-//!
-//! # Example
-//!
-//! ```rust
-//! use assertables::*;
-//! # fn main() {
-//! let a: Result = Err(1);
-//! let b: Result = Err(1);
-//! assert_err_eq!(a, b);
-//! # }
-//! ```
-
 
 // Verify Err(_)
 pub mod assert_err;
 
-// Compare with other
+// Compare with another
 pub mod assert_err_eq;
 pub mod assert_err_ne;
 
diff --git a/src/assert_none/mod.rs b/src/assert_none/mod.rs
index b248c7ef4..45fd63af3 100644
--- a/src/assert_none/mod.rs
+++ b/src/assert_none/mod.rs
@@ -1 +1,10 @@
+//! Assert macro for None items.
+//!
+//! These macros help compare None items, such as `std::Option::None` or similar.
+//!
+//! Assert expression is None:
+//! 
+//! * [`assert_none!(a)`](macro@crate::assert_none) 
+//!   ≈ a is None
+
 pub mod assert_none;
diff --git a/src/assert_ok/mod.rs b/src/assert_ok/mod.rs
index 0dfc516ee..7fe71b71d 100644
--- a/src/assert_ok/mod.rs
+++ b/src/assert_ok/mod.rs
@@ -22,22 +22,11 @@
 //!
 //! * [`assert_ok_ne_expr!(a, b)`](macro@crate::assert_ok_ne_expr) 
 //!   ≈ (a ⇒ Ok(a̅) ⇒ a̅) ≠ b
-//!
-//! # Example
-//!
-//! ```rust
-//! use assertables::*;
-//! # fn main() {
-//! let a: Result = Ok(1);
-//! let b: Result = Ok(1);
-//! assert_ok_eq!(a, b);
-//! # }
-//! ```
 
 // Verify Ok(_)
 pub mod assert_ok;
 
-// Compare with other
+// Compare with another
 pub mod assert_ok_eq;
 pub mod assert_ok_ne;
 
diff --git a/src/assert_some/mod.rs b/src/assert_some/mod.rs
index 3fe4de803..7aaa81381 100644
--- a/src/assert_some/mod.rs
+++ b/src/assert_some/mod.rs
@@ -22,22 +22,11 @@
 //!
 //! * [`assert_some_ne_expr!(a, b)`](macro@crate::assert_some_ne_expr) 
 //!   ≈ (a ⇒ Some(a̅) ⇒ a̅) ≠ b
-//!
-//! # Example
-//!
-//! ```rust
-//! use assertables::*;
-//! # fn main() {
-//! let a: Option = Some(1);
-//! let b: Option = Some(1);
-//! assert_some_eq!(a, b);
-//! # }
-//! ```
 
 // Verify Some(_)
 pub mod assert_some;
 
-// Compare with other
+// Compare with another
 pub mod assert_some_eq;
 pub mod assert_some_ne;
 
diff --git a/src/lib.rs b/src/lib.rs
index a0201af99..c5304e120 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -82,27 +82,17 @@
 //!
 //! For Result Ok/Err:
 //!
-//! * [`assert_ok!(a)`](macro@crate::assert_ok)
-//! * [`assert_ok_eq!(a, b)`](macro@crate::assert_ok_eq)
-//! * [`assert_ok_eq_expr!(a, expr)`](macro@crate::assert_ok_eq_expr)
-//! * [`assert_ok_ne!(a, b)`](macro@crate::assert_ok_ne)
-//! * [`assert_ok_ne_expr!(a, expr)`](macro@crate::assert_ok_ne_expr)
-//! * [`assert_err!(a)`](macro@crate::assert_err)
+//! * [`assert_ok!(a)`](macro@crate::assert_ok) ([eq, ne, etc.](module@crate::assert_ok))
+//! * [`assert_err!(a)`](macro@crate::assert_err) ([eq, ne, etc.](module@crate::assert_err))
 //!
 //! For Option Some/None:
 //!
-//! * [`assert_some!(a)`](macro@crate::assert_some)
-//! * [`assert_some_eq!(a, b)`](macro@crate::assert_some_eq)
-//! * [`assert_some_eq_expr!(a, expr)`](macro@crate::assert_some_eq_expr)
-//! * [`assert_some_ne!(a, b)`](macro@crate::assert_some_ne)
-//! * [`assert_some_ne_expr!(a, expr)`](macro@crate::assert_some_ne_expr)
+//! * [`assert_some!(a)`](macro@crate::assert_some) [eq, ne, etc.](module@crate::assert_some)
 //! * [`assert_none!(a)`](macro@crate::assert_none)
 //!
 //! For Poll Ready/Pending:
 //!
-//! * [`assert_ready!(a)`](macro@crate::assert_ready)
-//! * [`assert_ready_eq!(a, b)`](macro@crate::assert_ready_eq)
-//! * [`assert_ready_ne!(a, b)`](macro@crate::assert_ready_ne)
+//! * [`assert_ready!(a)`](macro@crate::assert_ready) [eq, ne, etc.](module@crate::assert_ready)
 //! * [`assert_pending!(a)`](macro@crate::assert_pending)
 //!
 //! For collections such as arrays, vectors, maps, sets:
@@ -121,11 +111,6 @@
 //! * [`assert_program_args_stdout_eq!(program1, args1, program2, args2)`](macro@crate::assert_program_args_stdout_eq);
 //!
 //! There are many more macros that are grouped into modules.
-//!
-//! Modules for `Result` such as `Ok` and `Err``:
-//!
-//! * [`assert_ok`](module@crate::assert_ok) for Ok(…) variants.
-//! * [`assert_err`](module@crate::assert_err) for Err(…) variants.
 //! 
 //! Modules for collections, such as arrays, vectors, lists, maps:
 //!
@@ -148,51 +133,26 @@
 //! * [`assert_command`](module@crate::assert_command) for commands and their stdout & stderr.
 //! * [`assert_program_args`](module@crate::assert_program_args) for programs with args and their stdout & stderr.
 //!
-//!
+//! 
 //! ## Forms
-//!
-//!
-//! ### Forms for panic versus error
-//!
-//! All the assert macros have 3 forms for different purposes:
-//!
-//! * Panic form for typical tests.
-//! * Debug form for debugging runtimes.
-//! * Result form for runtime checks, verifications, validations, etc.
-//!
-//! Examples:
-//!
-//! * [`assert_starts_with!(a, b)`](https://docs.rs/assertables/latest/assertables/macro.assert_starts_with.html) // panic!
-//! * [`debug_assert_starts_with!(a, b)`](https://docs.rs/assertables/latest/assertables/macro.debug_assert_starts_with.html) // panic! in debug mode
-//! * [`assert_starts_with_as_result!(a, b)`](https://docs.rs/assertables/latest/assertables/macro.assert_starts_with_as_result.html) // return Ok or Err
-//!
-//!
-//! ### Forms for messages
-//!
-//! All the assert macros have 2 forms for messages.
-//!
-//! * Default message form.
-//! * Custom message form.
-//!
-//! Examples:
-//!
-//! * [`assert_starts_with!(a, b)`](https://docs.rs/assertables/latest/assertables/macro.assert_starts_with.html)
-//! * [`assert_starts_with!(a, b, "Your custom message here")`](https://docs.rs/assertables/latest/assertables/macro.assert_starts_with.html)
-//!
-//!
-//! ### Forms for other versus expression
-//!
-//! Many of the assert macros have 2 forms for comparing left hand side and right hand side.
-//!
-//! * Comparing a LHS item to a RHS other of the same type.
-//! * Comparing a LHS item to a RHS expression.
-//!
-//! Examples:
-//!
-//! * [`assert_io_read_to_string_eq!(reader1, reader2)`](https://docs.rs/assertables/latest/assertables/macro.assert_io_read_to_string_eq.html)
-//! * [`assert_io_read_to_string_eq_expr!(reader, expr)`](https://docs.rs/assertables/latest/assertables/macro.assert_io_read_to_string_eq_expr.html)
-//!
-//!
+//! 
+//! All assertables macros have forms for different outcomes:
+//! 
+//! * [`assert_gt!(a, b)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_gt.html) // panic during typical test
+//! * [`assert_gt_as_result!(a, b)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_gt_as_result.html) // return Ok or Err
+//! * [`debug_assert_gt!(a, b)`](https://docs.rs/assertables/8.11.0/assertables/macro.debug_assert_gt.html) // panic when in debug mode
+//! 
+//! All assertables macros have forms for an optional message:
+//! 
+//! * [`assert_gt!(a, b)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_gt.html) // automatic message
+//! * [`assert_gt!(a, b, "Your text")`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_gt.html) // custom message
+//! 
+//! Many assertables macros have forms for comparing left hand side (LHS) and right hand side (RHS) as the same type or as an expression:
+//! 
+//! * [`assert_ok_eq!(a, b)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_ok_eq.html) // Ok(…) = Ok(…)
+//! * [`assert_ok_eq_expr!(a, b)`](https://docs.rs/assertables/8.11.0/assertables/macro.assert_ok_eq_expr.html) // Ok(…) = expression
+//! 
+//! 
 //! ## Tracking
 //!
 //! * Package: assertables-rust-crate
@@ -242,19 +202,11 @@ pub mod assert_result; // Deprecated
 
 // For Option Some/None
 pub mod assert_some;
-pub mod assert_some_eq;
-pub mod assert_some_eq_expr;
-pub mod assert_some_ne;
-pub mod assert_some_ne_expr;
 pub mod assert_none;
 pub mod assert_option; // Deprecated
 
 // For Poll Ready/Pending
 pub mod assert_ready;
-pub mod assert_ready_eq;
-pub mod assert_ready_eq_expr;
-pub mod assert_ready_ne;
-pub mod assert_ready_ne_expr;
 pub mod assert_pending;
 pub mod assert_poll; // Deprecated