Add initial pretty-printing via pretty crate

Author: sunsided

Cargo.toml

@@ -4,6 +4,10 @@ version = "0.0.0"
 authors = ["Markus Mayer <[email protected]>"]
 edition = "2021"
 
+[features]
+default = ["pretty"]
+
 [dependencies]
 nom = "7.1.3"
+pretty = { version = "0.12.1", optional = true }
 thiserror = "1.0.40"

src/lib.rs

@@ -4,3 +4,6 @@ mod briefcase_world;
 pub mod parsers;
 pub mod types;
 pub(crate) mod visitor;
+
+#[cfg(feature = "pretty")]
+pub(crate) mod pretty_print;

src/pretty_print/mod.rs

@@ -0,0 +1,28 @@
+use pretty::RcDoc;
+
+mod name;
+mod r#type;
+
+#[derive(Default)]
+pub struct PrettyRenderer;
+
+impl PrettyRenderer {
+    pub fn to_pretty(&self, doc: RcDoc<'_>, width: usize) -> String {
+        let mut w = Vec::new();
+        doc.render(width, &mut w).unwrap();
+        String::from_utf8(w).unwrap()
+    }
+}
+
+/// Helper macro to quickly prettify an element.
+#[cfg(test)]
+macro_rules! prettify {
+    ($x:expr, $n:literal) => {{
+        let renderer = PrettyRenderer::default();
+        let doc = $x.accept(&renderer);
+        renderer.to_pretty(doc, $n)
+    }};
+}
+
+#[cfg(test)]
+pub(crate) use prettify;

src/pretty_print/name.rs

@@ -0,0 +1,47 @@
+use crate::pretty_print::PrettyRenderer;
+use crate::types::{FunctionSymbol, Name, Variable};
+use crate::visitor::Visitor;
+use pretty::RcDoc;
+
+impl<'a> Visitor<Name<'a>, RcDoc<'a>> for PrettyRenderer {
+    fn visit(&self, value: &Name<'a>) -> RcDoc<'a> {
+        RcDoc::text(value.as_str())
+    }
+}
+
+impl<'a> Visitor<Variable<'a>, RcDoc<'a>> for PrettyRenderer {
+    fn visit(&self, value: &Variable<'a>) -> RcDoc<'a> {
+        RcDoc::text("?").append(value.as_str())
+    }
+}
+
+impl<'a> Visitor<FunctionSymbol<'a>, RcDoc<'a>> for PrettyRenderer {
+    fn visit(&self, value: &FunctionSymbol<'a>) -> RcDoc<'a> {
+        RcDoc::text(value.as_str())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::pretty_print::prettify;
+    use crate::visitor::Accept;
+
+    #[test]
+    fn name_works() {
+        let x = Name::new("name");
+        assert_eq!(prettify!(x, 10), "name");
+    }
+
+    #[test]
+    fn variable_works() {
+        let x = Variable::new("var");
+        assert_eq!(prettify!(x, 10), "?var");
+    }
+
+    #[test]
+    fn function_symbol_works() {
+        let x = FunctionSymbol::new("fun-sym");
+        assert_eq!(prettify!(x, 10), "fun-sym");
+    }
+}

src/pretty_print/type.rs

@@ -0,0 +1,56 @@
+use crate::pretty_print::PrettyRenderer;
+use crate::types::{PrimitiveType, Type};
+use crate::visitor::{Accept, Visitor};
+use pretty::RcDoc;
+
+impl<'a> Visitor<PrimitiveType<'a>, RcDoc<'a>> for PrettyRenderer {
+    fn visit(&self, value: &PrimitiveType<'a>) -> RcDoc<'a> {
+        RcDoc::text(value.as_str())
+    }
+}
+
+impl<'a> Visitor<Type<'a>, RcDoc<'a>> for PrettyRenderer {
+    fn visit(&self, value: &Type<'a>) -> RcDoc<'a> {
+        match value {
+            Type::Exactly(t) => RcDoc::text(t.as_str()),
+            Type::EitherOf(ts) => RcDoc::text("(either")
+                .append(RcDoc::softline())
+                .group()
+                .nest(4)
+                .append(RcDoc::intersperse(
+                    ts.iter().map(|t| t.accept(self)),
+                    RcDoc::softline(),
+                ))
+                .nest(4)
+                .group()
+                .append(")"),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::pretty_print::prettify;
+    use crate::visitor::Accept;
+
+    #[test]
+    fn primitive_type_works() {
+        let x = PrimitiveType::new("pt");
+        assert_eq!(prettify!(x, 10), "pt");
+    }
+
+    #[test]
+    fn simple_type_works() {
+        let x = Type::from("a");
+        assert_eq!(prettify!(x, 10), "a");
+    }
+
+    #[test]
+    fn either_type_works() {
+        let x = Type::from_iter(["a", "b"]);
+        assert_eq!(prettify!(x, 12), "(either a b)");
+        assert_eq!(prettify!(x, 10), "(either a\n    b)");
+        assert_eq!(prettify!(x, 8), "(either\n    a b)");
+    }
+}

src/types/function_symbols.rs

@@ -8,6 +8,11 @@ use std::ops::Deref;
 pub struct FunctionSymbol<'a>(Name<'a>);
 
 impl<'a> FunctionSymbol<'a> {
+    #[inline(always)]
+    pub fn new<N: Into<Name<'a>>>(name: N) -> Self {
+        Self::from_name(name.into())
+    }
+
     #[inline(always)]
     pub const fn from_str(name: &'a str) -> Self {
         Self(Name::new(name))

src/types/name.rs

@@ -1,4 +1,4 @@
-//! Contains names.
+//! Contains the [`Name`] type.
 
 use crate::types::{PrimitiveType, ToTyped, Type, Typed};
 use std::fmt::{Display, Formatter};
@@ -14,6 +14,11 @@ impl<'a> Name<'a> {
         Self(name)
     }
 
+    #[inline(always)]
+    pub const fn as_str(&self) -> &'a str {
+        self.0
+    }
+
     pub const fn is_empty(&self) -> bool {
         self.0.is_empty()
     }

src/types/type.rs

@@ -47,6 +47,13 @@ impl<'a> Type<'a> {
     }
 }
 
+impl<'a> PrimitiveType<'a> {
+    #[inline(always)]
+    pub fn new<T: Into<Name<'a>>>(t: T) -> Self {
+        Self(t.into())
+    }
+}
+
 impl<'a> Default for Type<'a> {
     fn default() -> Self {
         Self::Exactly(TYPE_OBJECT)
@@ -105,7 +112,7 @@ impl<'a> AsRef<str> for PrimitiveType<'a> {
 }
 
 impl<'a> Deref for PrimitiveType<'a> {
-    type Target = str;
+    type Target = Name<'a>;
 
     fn deref(&self) -> &Self::Target {
         &self.0