optempty 0.1.13

Tools for working types that may be empty. E.g., an empty `String`, `Vec`, `HashMap`, etc.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
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

//! Helpers for dealing with `Option`s/`Result`s of collections or other things
//! (like `String`s) that may be empty.
//!
//! # Examples
//!
//! Always start by including the traits:
//!
//! ```
//! use optempty::*;
//! ```
//!
//! These examples only show `Vec<T>`, but they support any type that implements
//! [`IsEmpty`].
//!
//! ## `empty_into_none`
//!
//! `Some` with an empty `Vec` becomes `None`.
//! ```
//! use optempty::*;
//!
//! let some: Option<Vec<&str>> = Some(vec![]);
//! let none = some.empty_into_none();
//! assert_eq!(None, none);
//! ```
//!
//! `Some` with a non-empty `Vec` remains unchanged.
//! ```
//! # use optempty::*;
//! #
//! let some = Some(vec!["a", "b", "c"]);
//! let still_some = some.clone().empty_into_none();
//! assert_eq!(some, still_some);
//! ```
//!
//! `None` remains unchanged.
//! ```
//! # use optempty::*;
//! #
//! let none: Option<Vec<&str>> = None;
//! let still_none = none.empty_into_none();
//! assert_eq!(None, still_none);
//! ```
//!
//! ## `empty_into_err`
//!
//! `Ok` with an empty `Vec` becomes `Err`.
//! ```
//! use optempty::*;
//!
//! let ok: Result<Vec<&str>, &str> = Ok(vec![]);
//! let err = ok.empty_into_err(|| "was empty");
//! assert_eq!(Err("was empty"), err);
//! ```
//!
//! `Ok` with a non-empty `Vec` remains unchanged.
//! ```
//! # use optempty::*;
//! #
//! let ok = Ok(vec!["a", "b", "c"]);
//! let still_ok = ok.empty_into_err(|| "was empty");
//! assert_eq!(Ok(vec!["a", "b", "c"]), still_ok);
//! ```
//!
//! `Err` remains unchanged.
//! ```
//! # use optempty::*;
//! #
//! let err: Result<Vec<&str>, &str> = Err("failed");
//! let still_err = err.empty_into_err(|| "was empty");
//! assert_eq!(Err("failed"), still_err);
//! ```
//!
//! See more examples at:
//! * [`IsEmpty`]
//! * [`EmptyIntoNone`]
//! * [`EmptyIntoErr`]
//!
//! # Features
//!
//! Available features are:
//! * `querymap`
//!   * Adds support for [`query_map::QueryMap`]
//! * `serdejson`
//!   * Adds support for [`serde_json::Map`]
//! * `std`
//!   * Adds support for types in `std::collections` in addition to types from `alloc`.
//!
//! Default features:
//! * `std`
//!
//! [Option]: std::option::Option
//! [IsEmpty]: crate::is_empty::IsEmpty
//! [EmptyIntoNone]: crate::empty_into_none::EmptyIntoNone
//! [EmptyIntoErr]: crate::empty_into_err::EmptyIntoErr

#![deny(warnings)]
#![cfg_attr(not(feature = "use_std"), no_std)]

pub mod empty_into_err;
pub mod empty_into_none;
pub mod is_empty;

pub use empty_into_err::EmptyIntoErr;
pub use empty_into_none::EmptyIntoNone;
pub use is_empty::IsEmpty;