Add outlined digits

Author: bash

readme.md

@@ -20,7 +20,7 @@ assert_eq!("¼", format!("{}", VulgarFraction::new(1, 4)));
 ```
 
 ### Sub- and superscript
-Formats integers as sub- or superscript. 
+Formats integers as sub- or superscript.
 
 ```rust
 use fmtastic::{Subscript, Superscript};
@@ -51,6 +51,16 @@ use fmtastic::Segmented;
 assert_eq!("🯶🯲🯸", format!("{}", Segmented(628_u32)));
 ```
 
+### Outlined
+Formats an unsigned integer using outlined digits
+from the [Legacy Computing Supplement] block.
+
+```rust
+use fmtastic::Outlined;
+
+assert_eq!("𜳶𜳲𜳸", format!("{}", Outlined(628_u32)));
+```
+
 ### Tally Marks
 Formats an unsigned integer as tally marks.
 ```rust
@@ -71,8 +81,6 @@ assert_eq!("☐ Do the dishes", format!("{} Do the dishes", BallotBox(false)));
 assert_eq!("☒ Laundry", format!("{:#} Laundry", BallotBox(true)));
 ```
 
-[Legacy Computing]: https://www.unicode.org/charts/PDF/U1FB00.pdf
-
 ## [Docs](https://docs.rs/fmtastic)
 
 ## License
@@ -93,5 +101,7 @@ for inclusion in the work by you, as defined in the Apache-2.0 license, shall be
 multi-licensed as above, without any additional terms or conditions.
 
 
+[Legacy Computing]: https://www.unicode.org/charts/PDF/U1FB00.pdf
+[Legacy Computing Supplement]: https://www.unicode.org/charts/PDF/U1CC00.pdf
 [Vulgar Fractions]: https://en.wikipedia.org/wiki/Fraction_(mathematics)#Simple,_common,_or_vulgar_fractions
 [`Display`]: https://doc.rust-lang.org/std/fmt/trait.Display.html

src/integer.rs

@@ -20,6 +20,7 @@ where
     type Public: crate::Integer;
     type BaseTwo: Base<Self>;
     type BaseTen: Base<Self>;
+    type BaseSixteen: Base<Self>;
 
     fn range(from: Self, to: Self) -> impl DoubleEndedIterator<Item = Self>;
 
@@ -68,6 +69,9 @@ pub(crate) struct Ten;
 #[derive(Debug)]
 pub(crate) struct Two;
 
+#[derive(Debug)]
+pub(crate) struct Sixteen;
+
 pub(crate) trait Base<I: IntegerImpl>: fmt::Debug {
     const VALUE: I;
 
@@ -88,6 +92,7 @@ macro_rules! common_integer_items {
         type Public = $ty;
         type BaseTwo = Two;
         type BaseTen = Ten;
+        type BaseSixteen = Sixteen;
 
         fn range(from: Self, to: Self) -> impl DoubleEndedIterator<Item = Self> {
             from..to
@@ -124,6 +129,14 @@ macro_rules! impl_bases {
                 x.ilog10()
             }
         }
+
+        impl Base<$ty> for Sixteen {
+            const VALUE: $ty = 16;
+
+            fn ilog(x: $ty) -> u32 {
+                x.ilog(Self::VALUE)
+            }
+        }
     };
 }
 

src/lib.rs

@@ -41,6 +41,17 @@
 //!
 //! [Legacy Computing]: https://www.unicode.org/charts/PDF/U1FB00.pdf
 //!
+//! # Outlined
+//! Formats an unsigned integer using outlined digits
+//! from the [Legacy Computing Supplement] block.
+//!
+//! ```
+//! # use fmtastic::Outlined;
+//! assert_eq!("𜳶𜳲𜳸", format!("{}", Outlined(628_u32)));
+//! ```
+//!
+//! [Legacy Computing Supplement]: https://www.unicode.org/charts/PDF/U1CC00.pdf
+//!
 //! # Tally Marks
 //! Formats an unsigned integer as tally marks.
 //!
@@ -114,6 +125,8 @@ mod ballot_box;
 pub use ballot_box::*;
 mod roman;
 pub use roman::*;
+mod outlined;
+pub use outlined::*;
 
 mod digits;
 

src/outlined.rs

@@ -0,0 +1,99 @@
+use crate::digits::iter_digits;
+use crate::integer::{Base, IntegerImpl};
+use crate::UnsignedInteger;
+use core::fmt;
+
+/// Formats an unsigned integer using outlined digits
+/// from the [Legacy Computing Supplement] block.
+///
+/// You may need to install an extra font such as [Kreative Square] to display these digits.
+///
+/// [Legacy Computing Supplement]: https://www.unicode.org/charts/PDF/U1CC00.pdf
+/// [Kreative Square]: http://www.kreativekorp.com/software/fonts/ksquare/
+///
+/// ```
+/// use fmtastic::Outlined;
+///
+/// assert_eq!("𜳶𜳲𜳸", Outlined(628_u32).to_string());
+///
+/// assert_eq!("𜳰", Outlined(0_u32).to_string());
+/// assert_eq!("𜳱", Outlined(1_u32).to_string());
+/// assert_eq!("𜳲", Outlined(2_u32).to_string());
+/// assert_eq!("𜳳", Outlined(3_u32).to_string());
+/// assert_eq!("𜳴", Outlined(4_u32).to_string());
+/// assert_eq!("𜳵", Outlined(5_u32).to_string());
+/// assert_eq!("𜳶", Outlined(6_u32).to_string());
+/// assert_eq!("𜳷", Outlined(7_u32).to_string());
+/// assert_eq!("𜳸", Outlined(8_u32).to_string());
+/// assert_eq!("𜳹", Outlined(9_u32).to_string());
+///
+/// // Binary
+/// assert_eq!("𜳰", format!("{:b}", Outlined(0_u8)));
+/// assert_eq!("𜳱𜳰𜳱𜳰𜳱𜳰", format!("{:+b}", Outlined(0b101010_u8)));
+///
+/// // Hexadecimal
+/// assert_eq!("𜳱𜳘𜳘𜳛𜳰", format!("{:X}", Outlined(0x1CCF0_u32)));
+/// ```
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+pub struct Outlined<T>(pub T);
+
+impl<T> From<T> for Outlined<T>
+where
+    T: UnsignedInteger,
+{
+    fn from(value: T) -> Self {
+        Outlined(value)
+    }
+}
+
+impl<T> fmt::Binary for Outlined<T>
+where
+    T: UnsignedInteger,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt_outlined::<_, <T::Impl as IntegerImpl>::BaseTwo>(self.0.into_impl(), f)
+    }
+}
+
+impl<T> fmt::Display for Outlined<T>
+where
+    T: UnsignedInteger,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt_outlined::<_, <T::Impl as IntegerImpl>::BaseTen>(self.0.into_impl(), f)
+    }
+}
+
+impl<T> fmt::UpperHex for Outlined<T>
+where
+    T: UnsignedInteger,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt_outlined::<_, <T::Impl as IntegerImpl>::BaseSixteen>(self.0.into_impl(), f)
+    }
+}
+
+fn fmt_outlined<T: IntegerImpl, B: Base<T>>(n: T, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    iter_digits::<_, B>(n).try_for_each(|digit| write!(f, "{}", DIGITS[digit]))
+}
+
+const DIGITS: [&str; 16] = [
+    // Outlined digits 0-9
+    "\u{1CCF0}",
+    "\u{1CCF1}",
+    "\u{1CCF2}",
+    "\u{1CCF3}",
+    "\u{1CCF4}",
+    "\u{1CCF5}",
+    "\u{1CCF6}",
+    "\u{1CCF7}",
+    "\u{1CCF8}",
+    "\u{1CCF9}",
+    // Outlined uppercase Latin alphabet A-F
+    "\u{1CCD6}",
+    "\u{1CCD7}",
+    "\u{1CCD8}",
+    "\u{1CCD9}",
+    "\u{1CCDA}",
+    "\u{1CCDB}",
+];

src/seven_segment.rs

@@ -6,12 +6,13 @@ use core::fmt;
 /// Formats an unsigned integer using seven-segment digits
 /// from the [Legacy Computing] block.
 ///
-/// You may need to install an extra font such as [Sieben 7] or [Noto Sans Symbols 2]
+/// You may need to install an extra font such as [Sieben 7], [Cascadia Code], or [Noto Sans Symbols 2]
 /// since most other fonts do not support these digits.
 ///
 /// [Legacy Computing]: https://www.unicode.org/charts/PDF/U1FB00.pdf
 /// [Sieben 7]: https://github.com/bash/sieben-7
 /// [Noto Sans Symbols 2]: https://fonts.google.com/noto/specimen/Noto+Sans+Symbols+2
+/// [Cascadia Code]: https://github.com/microsoft/cascadia-code
 ///
 /// ```
 /// use fmtastic::Segmented;