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
//! `strong-kleene` provides [`Trit`], a three-valued logic value with strong
//! Kleene semantics.
//!
//! Compatibility: this crate is `no_std`.
//!
//! # Quickstart
//! ```rust
//! use strong_kleene::Trit;
//!
//! let a = Trit::True;
//! let b = Trit::Unknown;
//!
//! assert_eq!(!a, Trit::False);
//! assert_eq!(a & b, Trit::Unknown);
//! assert_eq!(Trit::False | b, Trit::Unknown);
//! assert_eq!(a ^ Trit::False, Trit::True);
//! ```
//!
//! # How-To
//! ## Convert from `bool`
//! ```rust
//! use strong_kleene::Trit;
//!
//! let trit_true: Trit = true.into();
//! let trit_false: Trit = false.into();
//! assert_eq!(trit_true, Trit::True);
//! assert_eq!(trit_false, Trit::False);
//! ```
//!
//! ## Convert into `bool` safely
//! ```rust
//! use strong_kleene::{Trit, UnknownToBoolError};
//!
//! let known = Trit::True;
//! let unknown = Trit::Unknown;
//!
//! assert_eq!(bool::try_from(known), Ok(true));
//! assert_eq!(bool::try_from(unknown), Err(UnknownToBoolError));
//! ```
//!
//! ## Branch on `Unknown`
//! ```rust
//! use strong_kleene::Trit;
//!
//! let value = Trit::Unknown;
//!
//! match value {
//! Trit::True => {}
//! Trit::False => {}
//! Trit::Unknown => {}
//! }
//! assert!(value.is_unknown());
//! ```
//!
//! # Semantics
//! [Strong Kleene logic](https://en.wikipedia.org/wiki/Three-valued_logic#Kleene_and_Priest_logics)
//! extends classical two-valued logic with `Unknown` for values that are not
//! currently known.
//!
//! Legend: `F = false`, `U = unknown`, `T = true`.
//!
//! ## `NOT(A)`
//! | A | `!A` |
//! |:-:|:----:|
//! | F | T |
//! | U | U |
//! | T | F |
//!
//! ## `AND(A, B)`
//! | A \\ B | F | U | T |
//! |:------:|:--:|:--:|:--:|
//! | **F** | F | F | F |
//! | **U** | F | U | U |
//! | **T** | F | U | T |
//!
//! ## `OR(A, B)`
//! | A \\ B | F | U | T |
//! |:------:|:--:|:--:|:--:|
//! | **F** | F | U | T |
//! | **U** | U | U | T |
//! | **T** | T | T | T |
//!
//! ## `XOR(A, B)`
//! | A \\ B | F | U | T |
//! |:------:|:--:|:--:|:--:|
//! | **F** | F | U | T |
//! | **U** | U | U | U |
//! | **T** | T | U | F |
//!
//! # Reference
//! - [`Trit`] is the primary type and supports `!`, `&`, `|`, and `^`.
//! - [`UnknownToBoolError`] is returned by `bool::try_from(Trit::Unknown)`.
pub use ;