diff --git a/src/elements/mi/dict.rs b/src/elements/mi/dict.rs
index dd21c16..5cb7518 100644
--- a/src/elements/mi/dict.rs
+++ b/src/elements/mi/dict.rs
@@ -1,183 +1,227 @@
 use super::Ident;
 
-#[allow(missing_docs)]
 impl Ident {
+    /// Create a '∅' identifier.
     pub fn empty_set() -> Self {
         Self::from("\u{2205}")
     }
 
+    /// Create a '∞' identifier.
     pub fn infinity() -> Self {
         Self::from("∞")
     }
 
+    /// Create a 'ℵ' identifier.
     pub fn aleph() -> Self {
         Self::from("ℵ")
     }
 
+    /// Create a 'ℕ' identifier.
     pub fn set_natural() -> Self {
         Self::from("\u{2115}")
     }
 
+    /// Create a 'ℤ' identifier.
     pub fn set_integer() -> Self {
         Self::from("\u{2124}")
     }
 
+    /// Create a 'ℚ' identifier.
     pub fn set_rational() -> Self {
         Self::from("\u{211A}")
     }
 
+    /// Create a 'ℝ' identifier.
     pub fn set_irrational() -> Self {
         Self::from("\u{211D}")
     }
 
+    /// Create a 'ℂ' identifier.
     pub fn set_complex() -> Self {
         Self::from("\u{2102}")
     }
 
+    /// Create a '𝕂' identifier.
     pub fn set_body() -> Self {
         Self::from("\u{1D542}")
     }
 
+    /// Create a '𝛼' identifier.
     pub fn alpha() -> Self {
         Self::from("\u{1D6FC}")
     }
 
+    /// Create a '𝛽' identifier.
     pub fn beta() -> Self {
         Self::from("\u{1D6FD}")
     }
 
+    /// Create a '𝛾' identifier.
     pub fn gamma() -> Self {
         Self::from("\u{1D6FE}")
     }
 
+    /// Create a 'Γ' identifier.
     pub fn big_gamma() -> Self {
         Self::from("\u{0393}")
     }
 
+    /// Create a '𝛿' identifier.
     pub fn delta() -> Self {
         Self::from("\u{1D6FF}")
     }
 
+    /// Create a 'Δ' identifier.
     pub fn big_delta() -> Self {
         Self::from("\u{0394}")
     }
 
+    /// Create a '𝜀' identifier.
     pub fn epsilon() -> Self {
         Self::from("\u{1D700}")
     }
 
+    /// Create a '𝜖' identifier.
     pub fn varepsilon() -> Self {
         Self::from("\u{1D716}")
     }
 
+    /// Create a '𝜁' identifier.
     pub fn zeta() -> Self {
         Self::from("\u{1D701}")
     }
 
+    /// Create a '𝜂' identifier.
     pub fn eta() -> Self {
         Self::from("\u{1D702}")
     }
 
+    /// Create a '𝜃' identifier.
     pub fn theta() -> Self {
         Self::from("\u{1D703}")
     }
 
+    /// Create a 'Θ' identifier.
     pub fn big_theta() -> Self {
         Self::from("\u{0398}")
     }
 
+    /// Create a '𝜗' identifier.
     pub fn vartheta() -> Self {
         Self::from("\u{1D717}")
     }
 
+    /// Create a '𝜄' identifier.
     pub fn iota() -> Self {
         Self::from("\u{1D704}")
     }
 
+    /// Create a '𝜅' identifier.
     pub fn kappa() -> Self {
         Self::from("\u{1D705}")
     }
 
+    /// Create a '𝜆' identifier.
     pub fn lambda() -> Self {
         Self::from("\u{1D706}")
     }
 
+    /// Create a 'Λ' identifier.
     pub fn big_lambda() -> Self {
         Self::from("\u{039B}")
     }
 
+    /// Create a '𝜇' identifier.
     pub fn mu() -> Self {
         Self::from("\u{1D707}")
     }
 
+    /// Create a '𝜈' identifier.
     pub fn nu() -> Self {
         Self::from("\u{1D708}")
     }
 
+    /// Create a '𝜉' identifier.
     pub fn xi() -> Self {
         Self::from("\u{1D709}")
     }
 
+    /// Create a 'Ξ' identifier.
     pub fn big_xi() -> Self {
         Self::from("\u{039E}")
     }
 
+    /// Create a '𝜋' identifier.
     pub fn pi() -> Self {
         Self::from("\u{1D70B}")
     }
 
+    /// Create a 'Π' identifier.
     pub fn big_pi() -> Self {
         Self::from("\u{03A0}")
     }
 
+    /// Create a '𝜌' identifier.
     pub fn rho() -> Self {
         Self::from("\u{1D70C}")
     }
 
+    /// Create a '𝜎' identifier.
     pub fn sigma() -> Self {
         Self::from("\u{1D70E}")
     }
 
+    /// Create a 'Σ' identifier.
     pub fn big_sigma() -> Self {
         Self::from("\u{03A3}")
     }
 
+    /// Create a '𝜏' identifier.
     pub fn tau() -> Self {
         Self::from("\u{1D70F}")
     }
 
+    /// Create a '𝜐' identifier.
     pub fn upsilon() -> Self {
         Self::from("\u{1D710}")
     }
 
+    /// Create a '𝜑' identifier.
     pub fn phi() -> Self {
         Self::from("\u{1D711}")
     }
 
+    /// Create a 'Φ' identifier.
     pub fn big_phi() -> Self {
         Self::from("\u{03A6}")
     }
 
+    /// Create a '𝜙' identifier.
     pub fn varphi() -> Self {
         Self::from("\u{1D719}")
     }
 
+    /// Create a '𝜓' identifier.
     pub fn chi() -> Self {
         Self::from("\u{1D713}")
     }
 
+    /// Create a 'ψ' identifier.
     pub fn psi() -> Self {
-        Self::from("\u{1D714}")
+        Self::from("\u{03C8}")
     }
 
+    /// Create a 'Ψ' identifier.
     pub fn big_psi() -> Self {
         Self::from("\u{03A8}")
     }
 
+    /// Create a 'ω' identifier.
     pub fn omega() -> Self {
-        Self::from("\u{1D715}")
+        Self::from("\u{03C9}")
     }
 
+    /// Create a 'Ω' identifier.
     pub fn big_omega() -> Self {
         Self::from("\u{03A9}")
     }
diff --git a/src/elements/mo/dict.rs b/src/elements/mo/dict.rs
index ab36ef4..b3004f7 100644
--- a/src/elements/mo/dict.rs
+++ b/src/elements/mo/dict.rs
@@ -1,359 +1,447 @@
 use super::Operator;
 
-#[allow(missing_docs)]
 impl Operator {
+    /// Create a '+' operator.
     pub fn plus() -> Self {
         Self::from("\u{002B}")
     }
 
+    /// Create a '-' operator.
     pub fn minus() -> Self {
         Self::from("\u{002D}")
     }
 
+    /// Create a '⋅' operator.
     pub fn dot() -> Self {
         Self::from("\u{22C5}")
     }
 
+    /// Create a '∗' operator.
     pub fn asterisk() -> Self {
         Self::from("\u{2217}")
     }
 
+    /// Create a '⋆' operator.
     pub fn star() -> Self {
         Self::from("\u{22C6}")
     }
 
+    /// Create a '/' operator.
     pub fn solidus() -> Self {
         Self::from("\u{002F}")
     }
 
+    /// Create a '∖' operator.
     pub fn set_minus() -> Self {
         Self::from("\u{2216}")
     }
 
+    /// Create a '×' operator.
     pub fn mult() -> Self {
         Self::from("\u{00D7}")
     }
 
+    /// Create a '÷' operator.
     pub fn div() -> Self {
         Self::from("\u{00F7}")
     }
 
+    /// Create a '⋉' operator.
     pub fn lfactor() -> Self {
         Self::from("\u{22C9}")
     }
 
+    /// Create a '⋊' operator.
     pub fn rfactor() -> Self {
         Self::from("\u{22CA}")
     }
 
+    /// Create a '⋈' operator.
     pub fn bowtie() -> Self {
         Self::from("\u{22C8}")
     }
 
+    /// Create a '∘' operator.
     pub fn ring() -> Self {
         Self::from("\u{2218}")
     }
 
+    /// Create a '⊕' operator.
     pub fn circle_plus() -> Self {
         Self::from("\u{2295}")
     }
 
+    /// Create a '⊗' operator.
     pub fn circle_times() -> Self {
         Self::from("\u{2297}")
     }
 
+    /// Create a '⊙' operator.
     pub fn circle_dot() -> Self {
         Self::from("\u{2299}")
     }
 
+    /// Create a '∑' operator.
     pub fn sum() -> Self {
         Self::from("\u{2211}")
     }
 
+    /// Create a '∏' operator.
     pub fn prod() -> Self {
         Self::from("\u{220F}")
     }
 
+    /// Create a '∧' operator.
     pub fn wedge() -> Self {
         Self::from("\u{2227}")
     }
 
+    /// Create a '⋀' operator.
     pub fn big_wedge() -> Self {
         Self::from("\u{22C0}")
     }
 
+    /// Create a '∨' operator.
     pub fn vee() -> Self {
         Self::from("\u{2228}")
     }
 
+    /// Create a '⋁' operator.
     pub fn big_vee() -> Self {
         Self::from("\u{22C1}")
     }
 
+    /// Create a '∩' operator.
     pub fn cap() -> Self {
         Self::from("\u{2229}")
     }
 
+    /// Create a '⋂' operator.
     pub fn big_cap() -> Self {
         Self::from("\u{22C2}")
     }
 
+    /// Create a '∪' operator.
     pub fn cup() -> Self {
         Self::from("\u{222A}")
     }
 
+    /// Create a '⋃' operator.
     pub fn big_cup() -> Self {
         Self::from("\u{22C3}")
     }
 
+    /// Create a '∫' operator.
     pub fn integral() -> Self {
         Self::from("\u{222B}")
     }
 
+    /// Create a '∮' operator.
     pub fn circle_integral() -> Self {
         Self::from("\u{222E}")
     }
 
+    /// Create a '∂' operator.
     pub fn partial_diff() -> Self {
         Self::from("\u{2202}")
     }
 
+    /// Create a '∇' operator.
     pub fn nabla() -> Self {
         Self::from("\u{2207}")
     }
 
+    /// Create a '±' operator.
     pub fn plus_minus() -> Self {
         Self::from("\u{00B1}")
     }
 
+    /// Create a '∴' operator.
     pub fn therefore() -> Self {
         Self::from("\u{2234}")
     }
 
+    /// Create a '∵' operator.
     pub fn because() -> Self {
         Self::from("\u{2235}")
     }
 
+    /// Create a '∠' operator.
     pub fn angle() -> Self {
         Self::from("\u{2220}")
     }
 
+    /// Create a '⌊' operator.
     pub fn lfloor() -> Self {
         Self::from("\u{230A}")
     }
 
+    /// Create a '⌋' operator.
     pub fn rfloor() -> Self {
         Self::from("\u{230B}")
     }
 
+    /// Create a '⌈' operator.
     pub fn lceiling() -> Self {
         Self::from("\u{2308}")
     }
 
+    /// Create a '⌉' operator.
     pub fn rceiling() -> Self {
         Self::from("\u{2309}")
     }
 
+    /// Create a '=' operator.
     pub fn eq() -> Self {
         Self::from("\u{003D}")
     }
 
+    /// Create a '≠' operator.
     pub fn not_eq() -> Self {
         Self::from("\u{2260}")
     }
 
+    /// Create a '<' operator.
     pub fn lt() -> Self {
         Self::from("\u{003C}")
     }
 
+    /// Create a '>' operator.
     pub fn gt() -> Self {
         Self::from("\u{003E}")
     }
 
+    /// Create a '≤' operator.
     pub fn le() -> Self {
         Self::from("\u{2264}")
     }
 
+    /// Create a '≥' operator.
     pub fn ge() -> Self {
         Self::from("\u{2265}")
     }
 
+    /// Create a '≺' operator.
     pub fn prec() -> Self {
         Self::from("\u{227A}")
     }
 
+    /// Create a '≻' operator.
     pub fn succ() -> Self {
         Self::from("\u{227B}")
     }
 
+    /// Create a '≼' operator.
     pub fn preceq() -> Self {
         Self::from("\u{227C}")
     }
 
+    /// Create a '≽' operator.
     pub fn succeq() -> Self {
         Self::from("\u{227D}")
     }
 
+    /// Create a '∈' operator.
     pub fn in_set() -> Self {
         Self::from("\u{2208}")
     }
 
+    /// Create a '∉' operator.
     pub fn not_in_set() -> Self {
         Self::from("\u{2209}")
     }
 
+    /// Create a '⊂' operator.
     pub fn subset() -> Self {
         Self::from("\u{2282}")
     }
 
+    /// Create a '⊃' operator.
     pub fn supset() -> Self {
         Self::from("\u{2283}")
     }
 
+    /// Create a '⊆' operator.
     pub fn subseteq() -> Self {
         Self::from("\u{2286}")
     }
 
+    /// Create a '⊇' operator.
     pub fn supseteq() -> Self {
         Self::from("\u{2287}")
     }
 
+    /// Create a '≡' operator.
     pub fn equivalent() -> Self {
         Self::from("\u{2261}")
     }
 
+    /// Create a '≅' operator.
     pub fn congruent() -> Self {
         Self::from("\u{2245}")
     }
 
+    /// Create a '≈' operator.
     pub fn approx() -> Self {
         Self::from("\u{2248}")
     }
 
+    /// Create a '∝' operator.
     pub fn propto() -> Self {
         Self::from("\u{221D}")
     }
 
+    /// Create a '¬' operator.
     pub fn not() -> Self {
         Self::from("\u{00AC}")
     }
 
+    /// Create a '⇒' operator.
     pub fn implies() -> Self {
         Self::from("\u{21D2}")
     }
 
+    /// Create a '⇐' operator.
     pub fn log_if() -> Self {
         Self::from("\u{21D0}")
     }
 
+    /// Create a '⇔' operator.
     pub fn iff() -> Self {
         Self::from("\u{21D4}")
     }
 
+    /// Create a '∀' operator.
     pub fn forall() -> Self {
         Self::from("\u{2200}")
     }
 
+    /// Create a '∃' operator.
     pub fn exists() -> Self {
         Self::from("\u{2203}")
     }
 
+    /// Create a '⊥' operator.
     pub fn bottom() -> Self {
         Self::from("\u{22A5}")
     }
 
+    /// Create a '⊤' operator.
     pub fn top() -> Self {
         Self::from("\u{22A4}")
     }
 
+    /// Create a '⊢' operator.
     pub fn vdash() -> Self {
         Self::from("\u{22A2}")
     }
 
+    /// Create a '⊨' operator.
     pub fn models() -> Self {
         Self::from("\u{22A8}")
     }
 
+    /// Create a '(' operator.
     pub fn lparens() -> Self {
         Self::from("\u{0028}")
     }
 
+    /// Create a ')' operator.
     pub fn rparens() -> Self {
         Self::from("\u{0029}")
     }
 
+    /// Create a '⌢' operator.
     pub fn oparens() -> Self {
         Self::from("\u{2322}")
     }
 
+    /// Create a '⌣' operator.
     pub fn uparens() -> Self {
         Self::from("\u{2323}")
     }
 
+    /// Create a '[' operator.
     pub fn lbracket() -> Self {
         Self::from("\u{005B}")
     }
 
+    /// Create a ']' operator.
     pub fn rbracket() -> Self {
         Self::from("\u{005D}")
     }
 
+    /// Create a '⎴' operator.
     pub fn obracket() -> Self {
         Self::from("\u{23B4}")
     }
 
+    /// Create a '⎵' operator.
     pub fn ubracket() -> Self {
         Self::from("\u{23B5}")
     }
 
+    /// Create a '{' operator.
     pub fn lbrace() -> Self {
         Self::from("\u{007B}")
     }
 
+    /// Create a '}' operator.
     pub fn rbrace() -> Self {
         Self::from("\u{007D}")
     }
 
+    /// Create a '⏞' operator.
     pub fn obrace() -> Self {
         Self::from("\u{23DE}")
     }
 
+    /// Create a '⏟' operator.
     pub fn ubrace() -> Self {
         Self::from("\u{23DF}")
     }
 
+    /// Create a '⟨' operator.
     pub fn langle() -> Self {
         Self::from("\u{27E8}")
     }
 
+    /// Create a '⟩' operator.
     pub fn rangle() -> Self {
         Self::from("\u{27E9}")
     }
 
+    /// Create a '|' operator.
     pub fn vert_bar() -> Self {
         Self::from("\u{007C}")
     }
 
+    /// Create a '^' operator.
     pub fn hat() -> Self {
         Self::from("\u{005E}")
     }
 
+    /// Create a '^' operator.
     pub fn circumflex() -> Self {
         Self::hat()
     }
 
+    /// Create a '¯' operator.
     pub fn bar() -> Self {
         Self::from("\u{00AF}")
     }
 
+    /// Create a '¯' operator.
     pub fn macron() -> Self {
         Self::bar()
     }
 
+    /// Create a '→' operator.
     pub fn rarrow() -> Self {
         Self::from("\u{2192}")
     }
 
+    /// Create a '←' operator.
     pub fn larrow() -> Self {
         Self::from("\u{2190}")
     }