diff --git a/rust/Cargo.toml b/rust/Cargo.toml
index b513df66..683f708b 100644
--- a/rust/Cargo.toml
+++ b/rust/Cargo.toml
@@ -2,13 +2,16 @@
 # Generated by TypeDB Cargo sync tool.
 # Do not modify this file.
 
-features = {}
-
 [package]
 	name = "typeql"
 	edition = "2021"
 	version = "0.0.0"
 
+[features]
+    default = ["quine"]
+    quine = ["dep:polyquine", "dep:proc-macro2", "dep:quote"]
+
+
 [lib]
 	path = "typeql.rs"
 
@@ -35,6 +38,15 @@ features = {}
 		default-features = false
 
 [dependencies]
+quote = { version = "1.0.40", default-features = false, optional = true }
+    [dependencies.proc-macro2]
+        version = "1.0.94"
+        default-features = false
+        optional = true
+
+    [dependencies.polyquine]
+      version = "0.0.3"
+      optional = true
 
 	[dependencies.pest]
 		features = ["default", "memchr", "std"]
@@ -68,4 +80,3 @@ features = {}
 [[test]]
 	path = "tests/behaviour/test_debug.rs"
 	name = "test_debug"
-
diff --git a/rust/annotation.rs b/rust/annotation.rs
index 05491817..a9d1c99b 100644
--- a/rust/annotation.rs
+++ b/rust/annotation.rs
@@ -6,6 +6,9 @@
 
 use std::fmt::{self, Write};
 
+#[cfg(feature = "quine")]
+use {polyquine::Quine, proc_macro2::TokenStream};
+
 use crate::{
     common::{identifier::Identifier, token, Span, Spanned},
     util::write_joined,
@@ -13,6 +16,7 @@ use crate::{
 };
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum Annotation {
     Abstract(Abstract),
     Cardinality(Cardinality),
@@ -64,6 +68,7 @@ impl fmt::Display for Annotation {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Abstract {
     pub span: Option<Span>,
 }
@@ -87,6 +92,7 @@ impl fmt::Display for Abstract {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Cardinality {
     pub span: Option<Span>,
     pub range: CardinalityRange,
@@ -111,6 +117,7 @@ impl fmt::Display for Cardinality {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum CardinalityRange {
     Exact(IntegerLiteral),
     Range(IntegerLiteral, Option<IntegerLiteral>),
@@ -127,6 +134,7 @@ impl fmt::Display for CardinalityRange {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Cascade {
     pub span: Option<Span>,
 }
@@ -150,6 +158,7 @@ impl fmt::Display for Cascade {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Distinct {
     pub span: Option<Span>,
 }
@@ -173,6 +182,7 @@ impl fmt::Display for Distinct {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Independent {
     pub span: Option<Span>,
 }
@@ -196,6 +206,7 @@ impl fmt::Display for Independent {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Key {
     pub span: Option<Span>,
 }
@@ -219,6 +230,7 @@ impl fmt::Display for Key {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Range {
     pub span: Option<Span>,
     pub min: Option<Literal>,
@@ -253,6 +265,7 @@ impl fmt::Display for Range {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Regex {
     pub span: Option<Span>,
     pub regex: StringLiteral,
@@ -277,6 +290,7 @@ impl fmt::Display for Regex {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Subkey {
     pub span: Option<Span>,
     pub ident: Identifier,
@@ -301,6 +315,7 @@ impl fmt::Display for Subkey {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Unique {
     pub span: Option<Span>,
 }
@@ -324,6 +339,7 @@ impl fmt::Display for Unique {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Values {
     pub span: Option<Span>,
     pub values: Vec<Literal>,
diff --git a/rust/common/date_time.rs b/rust/common/date_time.rs
index 8d56f654..3e503642 100644
--- a/rust/common/date_time.rs
+++ b/rust/common/date_time.rs
@@ -6,6 +6,7 @@
 
 use chrono::{NaiveDateTime, Timelike};
 
+#[allow(dead_code)]
 pub(crate) fn parse(date_time_text: &str) -> Option<NaiveDateTime> {
     let has_seconds = date_time_text.matches(':').count() == 2;
     if has_seconds {
@@ -23,7 +24,7 @@ pub(crate) fn parse(date_time_text: &str) -> Option<NaiveDateTime> {
         NaiveDateTime::parse_from_str(date_time_text, "%Y-%m-%dT%H:%M").ok()
     }
 }
-
+#[allow(dead_code)]
 pub(crate) fn format(date_time: &NaiveDateTime) -> String {
     if date_time.time().nanosecond() > 0 {
         date_time.format("%Y-%m-%dT%H:%M:%S.%3f").to_string()
diff --git a/rust/common/identifier.rs b/rust/common/identifier.rs
index d4a44930..44f2d9b7 100644
--- a/rust/common/identifier.rs
+++ b/rust/common/identifier.rs
@@ -8,6 +8,9 @@ use std::{fmt, sync::OnceLock};
 
 use regex::{Regex, RegexBuilder};
 
+#[cfg(feature = "quine")]
+use {polyquine::Quine, proc_macro2::TokenStream};
+
 use crate::{
     common::{error::TypeQLError, Span, Spanned},
     is_reserved_keyword,
@@ -15,6 +18,7 @@ use crate::{
 };
 
 #[derive(Debug, Clone, Eq, PartialEq, Hash)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Identifier {
     pub span: Option<Span>,
     ident: String,
diff --git a/rust/common/mod.rs b/rust/common/mod.rs
index 90f34d21..66ce31f8 100644
--- a/rust/common/mod.rs
+++ b/rust/common/mod.rs
@@ -21,6 +21,9 @@ pub mod token;
 
 pub type Result<T = ()> = std::result::Result<T, Error>;
 
+#[cfg(feature = "quine")]
+use {polyquine::Quine, proc_macro2::TokenStream};
+
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
 pub struct LineColumn {
     pub line: u32,
@@ -28,6 +31,7 @@ pub struct LineColumn {
 }
 
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Span {
     pub begin_offset: usize,
     pub end_offset: usize,
diff --git a/rust/common/token.rs b/rust/common/token.rs
index 2aab37f3..65bfd937 100644
--- a/rust/common/token.rs
+++ b/rust/common/token.rs
@@ -6,9 +6,13 @@
 
 use std::fmt;
 
+#[cfg(feature = "quine")]
+use {polyquine::Quine, proc_macro2::TokenStream};
+
 macro_rules! string_enum {
     {$name:ident $($item:ident = $value:tt),* $(,)?} => {
         #[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
+        #[cfg_attr(feature = "quine", derive(Quine))]
         pub enum $name {
             $($item),*
         }
diff --git a/rust/expression/mod.rs b/rust/expression/mod.rs
index 5009262b..389c38b3 100644
--- a/rust/expression/mod.rs
+++ b/rust/expression/mod.rs
@@ -6,6 +6,9 @@
 
 use std::fmt::{self, Write};
 
+#[cfg(feature = "quine")]
+use {polyquine::Quine, proc_macro2::TokenStream};
+
 use crate::{
     common::{
         identifier::Identifier,
@@ -19,6 +22,7 @@ use crate::{
 };
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct BuiltinFunctionName {
     pub span: Option<Span>,
     pub token: token::Function,
@@ -45,6 +49,7 @@ impl fmt::Display for BuiltinFunctionName {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum FunctionName {
     Builtin(BuiltinFunctionName),
     Identifier(Identifier),
@@ -71,6 +76,7 @@ impl fmt::Display for FunctionName {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct FunctionCall {
     pub span: Option<Span>,
     pub name: FunctionName,
@@ -101,6 +107,7 @@ impl fmt::Display for FunctionCall {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Operation {
     pub op: ArithmeticOperator,
     pub left: Expression,
@@ -132,6 +139,7 @@ impl fmt::Display for Operation {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Paren {
     pub span: Option<Span>,
     pub inner: Expression,
@@ -158,6 +166,7 @@ impl fmt::Display for Paren {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct ListIndex {
     pub span: Option<Span>,
     pub variable: Variable,
@@ -185,6 +194,7 @@ impl fmt::Display for ListIndex {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct List {
     pub span: Option<Span>,
     pub items: Vec<Expression>,
@@ -214,6 +224,7 @@ impl fmt::Display for List {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct ListIndexRange {
     pub span: Option<Span>,
     pub var: Variable,
@@ -242,6 +253,7 @@ impl fmt::Display for ListIndexRange {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum Expression {
     Variable(Variable),
     ListIndex(Box<ListIndex>),
diff --git a/rust/pattern/mod.rs b/rust/pattern/mod.rs
index ed22d8a8..90224ff9 100644
--- a/rust/pattern/mod.rs
+++ b/rust/pattern/mod.rs
@@ -6,6 +6,9 @@
 
 use std::fmt::{self, Write};
 
+#[cfg(feature = "quine")]
+use {polyquine::Quine, proc_macro2::TokenStream};
+
 use crate::{
     common::{token, Span},
     pretty::{indent, Pretty},
@@ -13,6 +16,7 @@ use crate::{
 };
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Conjunction {
     pub span: Option<Span>,
     pub patterns: Vec<Pattern>,
@@ -42,6 +46,7 @@ impl fmt::Display for Conjunction {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Negation {
     pub span: Option<Span>,
     pub patterns: Vec<Pattern>,
@@ -73,6 +78,7 @@ impl fmt::Display for Negation {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Optional {
     pub span: Option<Span>,
     pub patterns: Vec<Pattern>,
@@ -104,6 +110,7 @@ impl fmt::Display for Optional {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Disjunction {
     pub span: Option<Span>,
     pub branches: Vec<Vec<Pattern>>,
@@ -164,6 +171,7 @@ impl fmt::Display for Disjunction {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum Pattern {
     Conjunction(Conjunction),
     Disjunction(Disjunction),
diff --git a/rust/query/mod.rs b/rust/query/mod.rs
index 1c42b429..37d05040 100644
--- a/rust/query/mod.rs
+++ b/rust/query/mod.rs
@@ -6,6 +6,9 @@
 
 use std::fmt;
 
+#[cfg(feature = "quine")]
+use {polyquine::Quine, proc_macro2::TokenStream};
+
 use self::pipeline::stage::{Match, Stage};
 pub use self::{
     pipeline::{stage, Pipeline},
@@ -20,6 +23,7 @@ pub mod pipeline;
 pub mod schema;
 
 #[derive(Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Query {
     pub span: Option<Span>,
     pub structure: QueryStructure,
@@ -56,6 +60,7 @@ impl fmt::Display for Query {
 }
 
 #[derive(Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum QueryStructure {
     Schema(SchemaQuery),
     Pipeline(Pipeline),
diff --git a/rust/query/pipeline/mod.rs b/rust/query/pipeline/mod.rs
index 7a11d5ae..c106f85d 100644
--- a/rust/query/pipeline/mod.rs
+++ b/rust/query/pipeline/mod.rs
@@ -6,6 +6,9 @@
 
 use std::fmt;
 
+#[cfg(feature = "quine")]
+use {polyquine::Quine, proc_macro2::TokenStream};
+
 use self::stage::Stage;
 use crate::{
     common::{Span, Spanned},
@@ -17,6 +20,7 @@ use crate::{
 pub mod stage;
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Preamble {
     pub span: Option<Span>,
     pub function: definable::Function,
@@ -44,6 +48,7 @@ impl fmt::Display for Preamble {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Pipeline {
     pub span: Option<Span>,
     pub preambles: Vec<Preamble>,
diff --git a/rust/query/pipeline/stage/delete.rs b/rust/query/pipeline/stage/delete.rs
index 9c064b53..22bc4c60 100644
--- a/rust/query/pipeline/stage/delete.rs
+++ b/rust/query/pipeline/stage/delete.rs
@@ -6,6 +6,9 @@
 
 use std::fmt::{self, Write};
 
+#[cfg(feature = "quine")]
+use {polyquine::Quine, proc_macro2::TokenStream};
+
 use crate::{
     common::{token, Span, Spanned},
     pretty::{indent, Pretty},
@@ -14,6 +17,7 @@ use crate::{
 };
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Delete {
     pub span: Option<Span>,
     pub deletables: Vec<Deletable>,
@@ -59,6 +63,7 @@ impl fmt::Display for Delete {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Deletable {
     pub span: Option<Span>,
     pub kind: DeletableKind,
@@ -89,6 +94,7 @@ impl fmt::Display for Deletable {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum DeletableKind {
     Has { attribute: Variable, owner: Variable },
     Links { players: Relation, relation: Variable },
diff --git a/rust/query/pipeline/stage/fetch.rs b/rust/query/pipeline/stage/fetch.rs
index 2ac0f996..d1ebf7a5 100644
--- a/rust/query/pipeline/stage/fetch.rs
+++ b/rust/query/pipeline/stage/fetch.rs
@@ -6,6 +6,9 @@
 
 use std::{fmt, fmt::Formatter};
 
+#[cfg(feature = "quine")]
+use {polyquine::Quine, proc_macro2::TokenStream};
+
 use crate::{
     common::{token, Span, Spanned},
     expression::{Expression, FunctionCall},
@@ -17,6 +20,7 @@ use crate::{
 };
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Fetch {
     pub span: Option<Span>,
     pub object: FetchObject,
@@ -52,6 +56,7 @@ impl fmt::Display for Fetch {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum FetchSome {
     Object(FetchObject),
     List(FetchList),
@@ -85,6 +90,7 @@ impl fmt::Display for FetchSome {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct FetchObject {
     pub span: Option<Span>,
     pub body: FetchObjectBody,
@@ -115,6 +121,7 @@ impl fmt::Display for FetchObject {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum FetchObjectBody {
     Entries(Vec<FetchObjectEntry>),
     AttributesAll(Variable),
@@ -166,6 +173,7 @@ impl fmt::Display for FetchObjectBody {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct FetchObjectEntry {
     pub span: Option<Span>,
     pub key: StringLiteral,
@@ -199,6 +207,7 @@ impl fmt::Display for FetchObjectEntry {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct FetchList {
     pub span: Option<Span>,
     pub stream: FetchStream,
@@ -229,6 +238,7 @@ impl fmt::Display for FetchList {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum FetchSingle {
     Attribute(FetchAttribute),
     Expression(Expression),
@@ -272,6 +282,7 @@ impl fmt::Display for FetchSingle {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum FetchStream {
     Attribute(FetchAttribute),
     Function(FunctionCall),
@@ -335,6 +346,7 @@ impl fmt::Display for FetchStream {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct FetchAttribute {
     pub span: Option<Span>,
     pub owner: Variable,
diff --git a/rust/query/pipeline/stage/insert.rs b/rust/query/pipeline/stage/insert.rs
index e07f9549..5a3f36cb 100644
--- a/rust/query/pipeline/stage/insert.rs
+++ b/rust/query/pipeline/stage/insert.rs
@@ -6,6 +6,9 @@
 
 use std::fmt::{self, Write};
 
+#[cfg(feature = "quine")]
+use {polyquine::Quine, proc_macro2::TokenStream};
+
 use crate::{
     common::{token, Span, Spanned},
     pretty::{indent, Pretty},
@@ -13,6 +16,7 @@ use crate::{
 };
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Insert {
     pub span: Option<Span>,
     pub statements: Vec<Statement>,
diff --git a/rust/query/pipeline/stage/match_.rs b/rust/query/pipeline/stage/match_.rs
index 7de94b79..84a73b62 100644
--- a/rust/query/pipeline/stage/match_.rs
+++ b/rust/query/pipeline/stage/match_.rs
@@ -6,6 +6,9 @@
 
 use std::fmt::{self, Write};
 
+#[cfg(feature = "quine")]
+use {polyquine::Quine, proc_macro2::TokenStream};
+
 use crate::{
     common::{token, Span, Spanned},
     pattern::Pattern,
@@ -13,6 +16,7 @@ use crate::{
 };
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Match {
     pub span: Option<Span>,
     pub patterns: Vec<Pattern>,
diff --git a/rust/query/pipeline/stage/mod.rs b/rust/query/pipeline/stage/mod.rs
index 0543e97e..918a5a4e 100644
--- a/rust/query/pipeline/stage/mod.rs
+++ b/rust/query/pipeline/stage/mod.rs
@@ -6,6 +6,9 @@
 
 use std::fmt;
 
+#[cfg(feature = "quine")]
+use {polyquine::Quine, proc_macro2::TokenStream};
+
 pub use self::{
     delete::Delete, fetch::Fetch, insert::Insert, match_::Match, modifier::Operator, put::Put, reduce::Reduce,
     update::Update,
@@ -26,6 +29,7 @@ pub mod reduce;
 mod update;
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum Stage {
     Match(Match),
     Insert(Insert),
diff --git a/rust/query/pipeline/stage/modifier.rs b/rust/query/pipeline/stage/modifier.rs
index 8beca1c5..4af69917 100644
--- a/rust/query/pipeline/stage/modifier.rs
+++ b/rust/query/pipeline/stage/modifier.rs
@@ -6,6 +6,9 @@
 
 use std::fmt::{self, Write};
 
+#[cfg(feature = "quine")]
+use {polyquine::Quine, proc_macro2::TokenStream};
+
 use crate::{
     common::{
         token::{self, Order},
@@ -19,6 +22,7 @@ use crate::{
 };
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct OrderedVariable {
     pub span: Option<Span>,
     pub variable: Variable,
@@ -50,6 +54,7 @@ impl fmt::Display for OrderedVariable {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Sort {
     pub span: Option<Span>,
     pub ordered_variables: Vec<OrderedVariable>,
@@ -79,6 +84,7 @@ impl fmt::Display for Sort {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Select {
     pub span: Option<Span>,
     pub variables: Vec<Variable>,
@@ -108,6 +114,7 @@ impl fmt::Display for Select {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Offset {
     pub span: Option<Span>,
     pub offset: IntegerLiteral,
@@ -134,6 +141,7 @@ impl fmt::Display for Offset {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Limit {
     pub span: Option<Span>,
     pub limit: IntegerLiteral,
@@ -160,6 +168,7 @@ impl fmt::Display for Limit {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Require {
     pub span: Option<Span>,
     pub variables: Vec<Variable>,
@@ -189,6 +198,7 @@ impl fmt::Display for Require {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Distinct {
     span: Option<Span>,
 }
@@ -214,6 +224,7 @@ impl fmt::Display for Distinct {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum Operator {
     Select(Select),
     Sort(Sort),
diff --git a/rust/query/pipeline/stage/put.rs b/rust/query/pipeline/stage/put.rs
index ca384316..57934f58 100644
--- a/rust/query/pipeline/stage/put.rs
+++ b/rust/query/pipeline/stage/put.rs
@@ -6,6 +6,9 @@
 
 use std::fmt::{self, Write};
 
+#[cfg(feature = "quine")]
+use {polyquine::Quine, proc_macro2::TokenStream};
+
 use crate::{
     common::{token, Span, Spanned},
     pretty::{indent, Pretty},
@@ -13,6 +16,7 @@ use crate::{
 };
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Put {
     pub span: Option<Span>,
     pub statements: Vec<Statement>,
diff --git a/rust/query/pipeline/stage/reduce.rs b/rust/query/pipeline/stage/reduce.rs
index 085a4823..bf565581 100644
--- a/rust/query/pipeline/stage/reduce.rs
+++ b/rust/query/pipeline/stage/reduce.rs
@@ -6,6 +6,9 @@
 
 use std::fmt;
 
+#[cfg(feature = "quine")]
+use {polyquine::Quine, proc_macro2::TokenStream};
+
 use crate::{
     common::{token, Span, Spanned},
     pretty::{indent, Pretty},
@@ -14,6 +17,7 @@ use crate::{
 };
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Reduce {
     pub span: Option<Span>,
     pub reduce_assignments: Vec<ReduceAssign>,
@@ -61,6 +65,7 @@ impl fmt::Display for Reduce {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct ReduceAssign {
     pub variable: Variable,
     pub reducer: Reducer,
@@ -80,6 +85,7 @@ impl fmt::Display for ReduceAssign {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum Reducer {
     Count(Count),
     Stat(Stat),
@@ -104,6 +110,7 @@ impl fmt::Display for Reducer {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Count {
     pub span: Option<Span>,
     pub variable: Option<Variable>,
@@ -134,6 +141,7 @@ impl fmt::Display for Count {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Stat {
     pub span: Option<Span>,
     pub reduce_operator: token::ReduceOperator,
diff --git a/rust/query/pipeline/stage/update.rs b/rust/query/pipeline/stage/update.rs
index faf119fe..1ab498c7 100644
--- a/rust/query/pipeline/stage/update.rs
+++ b/rust/query/pipeline/stage/update.rs
@@ -6,6 +6,9 @@
 
 use std::fmt::{self, Write};
 
+#[cfg(feature = "quine")]
+use {polyquine::Quine, proc_macro2::TokenStream};
+
 use crate::{
     common::{token, Span, Spanned},
     pretty::{indent, Pretty},
@@ -13,6 +16,7 @@ use crate::{
 };
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Update {
     pub span: Option<Span>,
     pub statements: Vec<Statement>,
diff --git a/rust/query/schema/define.rs b/rust/query/schema/define.rs
index cf0289ad..b9544693 100644
--- a/rust/query/schema/define.rs
+++ b/rust/query/schema/define.rs
@@ -6,6 +6,9 @@
 
 use std::fmt;
 
+#[cfg(feature = "quine")]
+use {polyquine::Quine, proc_macro2::TokenStream};
+
 use crate::{
     common::{token, Span, Spanned},
     pretty::{indent, Pretty},
@@ -13,6 +16,7 @@ use crate::{
 };
 
 #[derive(Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Define {
     pub span: Option<Span>,
     pub definables: Vec<Definable>,
diff --git a/rust/query/schema/mod.rs b/rust/query/schema/mod.rs
index e2b42209..826e1068 100644
--- a/rust/query/schema/mod.rs
+++ b/rust/query/schema/mod.rs
@@ -6,6 +6,9 @@
 
 use std::fmt;
 
+#[cfg(feature = "quine")]
+use {polyquine::Quine, proc_macro2::TokenStream};
+
 pub use self::{define::Define, redefine::Redefine, undefine::Undefine};
 use crate::common::{Span, Spanned};
 
@@ -14,6 +17,7 @@ mod redefine;
 mod undefine;
 
 #[derive(Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum SchemaQuery {
     Define(Define),
     Redefine(Redefine),
diff --git a/rust/query/schema/redefine.rs b/rust/query/schema/redefine.rs
index 3a5e6ca6..ff00e4aa 100644
--- a/rust/query/schema/redefine.rs
+++ b/rust/query/schema/redefine.rs
@@ -6,6 +6,9 @@
 
 use std::fmt::{self, Write};
 
+#[cfg(feature = "quine")]
+use {polyquine::Quine, proc_macro2::TokenStream};
+
 use crate::{
     common::{token, Span, Spanned},
     schema::definable::Definable,
@@ -13,6 +16,7 @@ use crate::{
 };
 
 #[derive(Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Redefine {
     pub span: Option<Span>,
     pub definables: Vec<Definable>,
diff --git a/rust/query/schema/undefine.rs b/rust/query/schema/undefine.rs
index c010ac12..570be2bb 100644
--- a/rust/query/schema/undefine.rs
+++ b/rust/query/schema/undefine.rs
@@ -6,6 +6,9 @@
 
 use std::fmt::{self, Write};
 
+#[cfg(feature = "quine")]
+use {polyquine::Quine, proc_macro2::TokenStream};
+
 use crate::{
     common::{token, Span, Spanned},
     pretty::{indent, Pretty},
@@ -13,6 +16,7 @@ use crate::{
 };
 
 #[derive(Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Undefine {
     pub span: Option<Span>,
     pub undefinables: Vec<Undefinable>,
diff --git a/rust/schema/definable/function.rs b/rust/schema/definable/function.rs
index d13957e3..9056a4dd 100644
--- a/rust/schema/definable/function.rs
+++ b/rust/schema/definable/function.rs
@@ -6,6 +6,9 @@
 
 use std::fmt::{self, Debug, Formatter, Write};
 
+#[cfg(feature = "quine")]
+use {polyquine::Quine, proc_macro2::TokenStream};
+
 use crate::{
     common::{identifier::Identifier, token, Span, Spanned},
     pretty::{indent, Pretty},
@@ -16,6 +19,7 @@ use crate::{
 };
 
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Function {
     pub span: Option<Span>,
     pub signature: Signature,
@@ -59,6 +63,7 @@ impl fmt::Display for Function {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Signature {
     pub span: Option<Span>,
     pub ident: Identifier,
@@ -105,6 +110,7 @@ impl fmt::Display for Signature {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Argument {
     pub span: Option<Span>,
     pub var: Variable,
@@ -125,6 +131,7 @@ impl fmt::Display for Argument {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum Output {
     Stream(Stream),
     Single(Single),
@@ -158,6 +165,7 @@ impl fmt::Display for Output {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Stream {
     pub span: Option<Span>,
     pub types: Vec<NamedTypeAny>,
@@ -186,6 +194,7 @@ impl fmt::Display for Stream {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Single {
     pub span: Option<Span>,
     pub types: Vec<NamedTypeAny>,
@@ -212,6 +221,7 @@ impl fmt::Display for Single {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct FunctionBlock {
     pub span: Option<Span>,
     pub stages: Vec<Stage>,
@@ -244,6 +254,7 @@ impl fmt::Display for FunctionBlock {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum ReturnStatement {
     Stream(ReturnStream),
     Single(ReturnSingle),
@@ -274,6 +285,7 @@ impl fmt::Display for ReturnStatement {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct ReturnStream {
     pub span: Option<Span>,
     pub vars: Vec<Variable>,
@@ -305,6 +317,7 @@ impl fmt::Display for ReturnStream {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct ReturnSingle {
     pub span: Option<Span>,
     pub selector: SingleSelector,
@@ -338,6 +351,7 @@ impl fmt::Display for ReturnSingle {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum SingleSelector {
     First,
     Last,
@@ -353,6 +367,7 @@ impl fmt::Display for SingleSelector {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum ReturnReduction {
     Check(Check),
     Value(Vec<Reducer>, Option<Span>),
@@ -386,6 +401,7 @@ impl fmt::Display for ReturnReduction {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Check {
     pub span: Option<Span>,
 }
diff --git a/rust/schema/definable/mod.rs b/rust/schema/definable/mod.rs
index cde14f4a..c13ab755 100644
--- a/rust/schema/definable/mod.rs
+++ b/rust/schema/definable/mod.rs
@@ -6,6 +6,9 @@
 
 use std::fmt;
 
+#[cfg(feature = "quine")]
+use {polyquine::Quine, proc_macro2::TokenStream};
+
 pub use self::{function::Function, struct_::Struct, type_::Type};
 use crate::pretty::Pretty;
 
@@ -14,6 +17,7 @@ pub mod struct_;
 pub mod type_;
 
 #[derive(Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum Definable {
     TypeDeclaration(Type),
     Function(Function),
diff --git a/rust/schema/definable/struct_.rs b/rust/schema/definable/struct_.rs
index 39cff9c8..bdb8f994 100644
--- a/rust/schema/definable/struct_.rs
+++ b/rust/schema/definable/struct_.rs
@@ -6,6 +6,9 @@
 
 use std::{fmt, fmt::Formatter};
 
+#[cfg(feature = "quine")]
+use {polyquine::Quine, proc_macro2::TokenStream};
+
 use crate::{
     common::{identifier::Identifier, Span, Spanned},
     pretty::{indent, Pretty},
@@ -14,6 +17,7 @@ use crate::{
 };
 
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Struct {
     pub span: Option<Span>,
     pub ident: Identifier,
@@ -61,6 +65,7 @@ impl fmt::Display for Struct {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Field {
     pub span: Option<Span>,
     pub key: Identifier,
diff --git a/rust/schema/definable/type_/capability.rs b/rust/schema/definable/type_/capability.rs
index d3569ec6..db001073 100644
--- a/rust/schema/definable/type_/capability.rs
+++ b/rust/schema/definable/type_/capability.rs
@@ -6,6 +6,9 @@
 
 use std::fmt;
 
+#[cfg(feature = "quine")]
+use {polyquine::Quine, proc_macro2::TokenStream};
+
 use crate::{
     common::{identifier::Identifier, token, Span, Spanned},
     pretty::Pretty,
@@ -14,6 +17,7 @@ use crate::{
 };
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Alias {
     pub span: Option<Span>,
     pub aliases: Vec<Label>,
@@ -40,6 +44,7 @@ impl fmt::Display for Alias {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Sub {
     pub span: Option<Span>,
     pub supertype_label: Label,
@@ -70,6 +75,7 @@ impl fmt::Display for Sub {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct ValueType {
     pub span: Option<Span>,
     pub value_type: NamedType,
@@ -96,6 +102,7 @@ impl fmt::Display for ValueType {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Owns {
     pub span: Option<Span>,
     pub owned: TypeRefAny,
@@ -123,6 +130,7 @@ impl fmt::Display for Owns {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Relates {
     pub span: Option<Span>,
     pub related: TypeRefAny,
@@ -152,6 +160,7 @@ impl fmt::Display for Relates {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Plays {
     pub span: Option<Span>,
     pub role: ScopedLabel,
diff --git a/rust/schema/definable/type_/mod.rs b/rust/schema/definable/type_/mod.rs
index fe03891b..f16960df 100644
--- a/rust/schema/definable/type_/mod.rs
+++ b/rust/schema/definable/type_/mod.rs
@@ -6,6 +6,9 @@
 
 use std::fmt::{self, Write};
 
+#[cfg(feature = "quine")]
+use {polyquine::Quine, proc_macro2::TokenStream};
+
 use self::capability::{Alias, Owns, Plays, Relates, Sub, ValueType};
 use crate::{
     annotation::Annotation,
@@ -18,6 +21,7 @@ use crate::{
 pub mod capability;
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Type {
     pub span: Option<Span>,
     pub kind: Option<token::Kind>,
@@ -51,26 +55,24 @@ impl Spanned for Type {
 impl Pretty for Type {
     fn fmt(&self, indent_level: usize, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         if let Some(kind) = &self.kind {
-            write!(f, "{} ", kind)?;
+            write!(f, "{kind} ")?;
         }
         write!(f, "{}", self.label)?;
         let rest = if !self.annotations.is_empty() {
             for annotation in &self.annotations {
-                write!(f, " {}", annotation)?;
+                write!(f, " {annotation}")?;
             }
             self.capabilities.as_slice()
+        } else if let Some((first, rest)) = self.capabilities.split_first() {
+            write!(f, " {first}")?;
+            rest
         } else {
-            if let Some((first, rest)) = self.capabilities.split_first() {
-                write!(f, " {}", first)?;
-                rest
-            } else {
-                self.capabilities.as_slice()
-            }
+            self.capabilities.as_slice()
         };
         for cap in rest {
             writeln!(f, ",")?;
             indent(indent_level, f)?;
-            write!(f, "{}", cap)?;
+            write!(f, "{cap}")?;
         }
         f.write_char(';')?;
         Ok(())
@@ -80,13 +82,24 @@ impl Pretty for Type {
 impl fmt::Display for Type {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Display::fmt(&self.label, f)?;
-        f.write_char(' ')?;
-        write_joined!(f, ", ", &self.capabilities)?;
+        // Include annotations after the label, before capabilities
+        for annotation in &self.annotations {
+            write!(f, " {annotation}")?;
+        }
+        // Add comma and space before capabilities if both annotations and capabilities exist
+        if !self.annotations.is_empty() && !self.capabilities.is_empty() {
+            write!(f, ", ")?;
+            write_joined!(f, ", ", &self.capabilities)?;
+        } else if !self.capabilities.is_empty() {
+            f.write_char(' ')?;
+            write_joined!(f, ", ", &self.capabilities)?;
+        }
         Ok(())
     }
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Capability {
     pub span: Option<Span>,
     pub base: CapabilityBase,
@@ -111,13 +124,14 @@ impl fmt::Display for Capability {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{}", self.base)?;
         for annotation in &self.annotations {
-            write!(f, " {}", annotation)?;
+            write!(f, " {annotation}")?;
         }
         Ok(())
     }
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum CapabilityBase {
     Sub(Sub),
     Alias(Alias),
diff --git a/rust/schema/undefinable/mod.rs b/rust/schema/undefinable/mod.rs
index a3961217..01f41593 100644
--- a/rust/schema/undefinable/mod.rs
+++ b/rust/schema/undefinable/mod.rs
@@ -6,6 +6,9 @@
 
 use std::fmt;
 
+#[cfg(feature = "quine")]
+use {polyquine::Quine, proc_macro2::TokenStream};
+
 use super::definable::type_::CapabilityBase;
 use crate::{
     common::{identifier::Identifier, token, Span, Spanned},
@@ -15,6 +18,7 @@ use crate::{
 };
 
 #[derive(Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum Undefinable {
     Type(Label),                                // undefine person;
     AnnotationType(AnnotationType),             // undefine @independent from name;
@@ -43,6 +47,7 @@ impl fmt::Display for Undefinable {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct AnnotationType {
     pub span: Option<Span>,
     pub annotation_category: token::Annotation,
@@ -70,6 +75,7 @@ impl fmt::Display for AnnotationType {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct AnnotationCapability {
     pub span: Option<Span>,
     pub annotation_category: token::Annotation,
@@ -103,6 +109,7 @@ impl fmt::Display for AnnotationCapability {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct CapabilityType {
     pub span: Option<Span>,
     pub capability: CapabilityBase,
@@ -130,6 +137,7 @@ impl fmt::Display for CapabilityType {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Specialise {
     pub span: Option<Span>,
     pub specialised: Label,
@@ -166,6 +174,7 @@ impl fmt::Display for Specialise {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Function {
     pub span: Option<Span>,
     pub ident: Identifier,
@@ -192,6 +201,7 @@ impl fmt::Display for Function {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Struct {
     pub span: Option<Span>,
     pub ident: Identifier,
diff --git a/rust/statement/comparison.rs b/rust/statement/comparison.rs
index a49c8608..66a4fadb 100644
--- a/rust/statement/comparison.rs
+++ b/rust/statement/comparison.rs
@@ -6,6 +6,9 @@
 
 use std::fmt;
 
+#[cfg(feature = "quine")]
+use {polyquine::Quine, proc_macro2::TokenStream};
+
 use crate::{
     common::{token, Span, Spanned},
     expression::Expression,
@@ -13,6 +16,7 @@ use crate::{
 };
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct ComparisonStatement {
     pub span: Option<Span>,
     pub lhs: Expression,
@@ -40,6 +44,7 @@ impl fmt::Display for ComparisonStatement {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Comparison {
     pub span: Option<Span>,
     pub comparator: token::Comparator,
diff --git a/rust/statement/mod.rs b/rust/statement/mod.rs
index b34fea6d..97f3ad96 100644
--- a/rust/statement/mod.rs
+++ b/rust/statement/mod.rs
@@ -6,6 +6,9 @@
 
 use std::{collections::HashMap, fmt};
 
+#[cfg(feature = "quine")]
+use {polyquine::Quine, proc_macro2::TokenStream};
+
 use self::comparison::ComparisonStatement;
 pub use self::{thing::Thing, type_::Type};
 use crate::{
@@ -21,6 +24,7 @@ pub mod thing;
 pub mod type_;
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Is {
     pub span: Option<Span>,
     pub lhs: Variable,
@@ -48,6 +52,7 @@ impl fmt::Display for Is {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct InIterable {
     pub span: Option<Span>,
     pub lhs: Vec<Variable>,
@@ -77,6 +82,7 @@ impl fmt::Display for InIterable {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum DeconstructField {
     Variable(Variable),
     Deconstruct(StructDeconstruct),
@@ -101,6 +107,7 @@ impl fmt::Display for DeconstructField {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct StructDeconstruct {
     pub span: Option<Span>,
     field_map: HashMap<Identifier, DeconstructField>,
@@ -136,6 +143,7 @@ impl fmt::Display for StructDeconstruct {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum AssignmentPattern {
     Variables(Vec<Variable>),
     Deconstruct(StructDeconstruct),
@@ -153,6 +161,7 @@ impl fmt::Display for AssignmentPattern {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Assignment {
     pub span: Option<Span>,
     pub lhs: AssignmentPattern,
@@ -180,6 +189,7 @@ impl fmt::Display for Assignment {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum Statement {
     Is(Is),
     InIterable(InIterable),
diff --git a/rust/statement/thing/isa.rs b/rust/statement/thing/isa.rs
index 0a2f04ec..549e5ccb 100644
--- a/rust/statement/thing/isa.rs
+++ b/rust/statement/thing/isa.rs
@@ -6,6 +6,9 @@
 
 use std::fmt;
 
+#[cfg(feature = "quine")]
+use {polyquine::Quine, proc_macro2::TokenStream};
+
 use crate::{
     common::{token, Span, Spanned},
     pretty::Pretty,
@@ -15,6 +18,7 @@ use crate::{
 };
 
 #[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Isa {
     pub span: Option<Span>,
     pub kind: IsaKind,
@@ -47,6 +51,7 @@ impl fmt::Display for Isa {
 }
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum IsaKind {
     Exact,
     Subtype,
@@ -65,6 +70,7 @@ impl fmt::Display for IsaKind {
 }
 
 #[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum IsaInstanceConstraint {
     Relation(Relation),
     Value(Literal),
diff --git a/rust/statement/thing/mod.rs b/rust/statement/thing/mod.rs
index 5575ea46..8eefb62b 100644
--- a/rust/statement/thing/mod.rs
+++ b/rust/statement/thing/mod.rs
@@ -6,6 +6,9 @@
 
 use std::fmt::{self, Write};
 
+#[cfg(feature = "quine")]
+use {polyquine::Quine, proc_macro2::TokenStream};
+
 use self::isa::Isa;
 use super::{comparison, Statement};
 use crate::{
@@ -21,6 +24,7 @@ use crate::{
 pub mod isa;
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Thing {
     pub span: Option<Span>,
     pub head: Head,
@@ -75,6 +79,7 @@ impl fmt::Display for Thing {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum Head {
     Variable(Variable),
     Relation(Option<TypeRef>, Relation),
@@ -101,6 +106,7 @@ impl fmt::Display for Head {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Relation {
     pub span: Option<Span>,
     pub role_players: Vec<RolePlayer>,
@@ -130,6 +136,7 @@ impl fmt::Display for Relation {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum RolePlayer {
     Typed(TypeRefAny, Variable),
     Untyped(Variable),
@@ -147,6 +154,7 @@ impl fmt::Display for RolePlayer {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum Constraint {
     Isa(Isa),
     Iid(Iid),
@@ -177,6 +185,7 @@ impl fmt::Display for Constraint {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Iid {
     pub span: Option<Span>,
     pub iid: String,
@@ -203,6 +212,7 @@ impl fmt::Display for Iid {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Has {
     pub span: Option<Span>,
     pub type_: Option<TypeRefAny>,
@@ -235,6 +245,7 @@ impl fmt::Display for Has {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum HasValue {
     Variable(Variable),
     Expression(Expression),
@@ -262,6 +273,7 @@ impl fmt::Display for HasValue {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Links {
     pub span: Option<Span>,
     pub relation: Relation,
diff --git a/rust/statement/type_.rs b/rust/statement/type_.rs
index 669c1db0..416cfacf 100644
--- a/rust/statement/type_.rs
+++ b/rust/statement/type_.rs
@@ -6,6 +6,9 @@
 
 use std::fmt::{self, Write};
 
+#[cfg(feature = "quine")]
+use {polyquine::Quine, proc_macro2::TokenStream};
+
 use crate::{
     annotation::Annotation,
     common::{token, Span, Spanned},
@@ -14,6 +17,7 @@ use crate::{
 };
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Type {
     pub span: Option<Span>,
     pub kind: Option<token::Kind>,
@@ -63,6 +67,7 @@ impl fmt::Display for Type {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Constraint {
     pub span: Option<Span>,
     pub base: ConstraintBase,
@@ -94,6 +99,7 @@ impl fmt::Display for Constraint {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum ConstraintBase {
     Sub(Sub),
     Label(LabelConstraint),
@@ -130,6 +136,7 @@ impl fmt::Display for ConstraintBase {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum LabelConstraint {
     Name(Label),
     Scoped(ScopedLabel),
@@ -147,6 +154,7 @@ impl fmt::Display for LabelConstraint {
 }
 
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum SubKind {
     Direct,
     Transitive,
@@ -165,6 +173,7 @@ impl fmt::Display for SubKind {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Sub {
     pub span: Option<Span>,
     pub kind: SubKind,
@@ -192,6 +201,7 @@ impl fmt::Display for Sub {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct ValueType {
     pub span: Option<Span>,
     pub value_type: NamedType,
@@ -218,6 +228,7 @@ impl fmt::Display for ValueType {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Owns {
     pub span: Option<Span>,
     pub owned: TypeRefAny,
@@ -245,6 +256,7 @@ impl fmt::Display for Owns {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Relates {
     pub span: Option<Span>,
     pub related: TypeRefAny,
@@ -276,6 +288,7 @@ impl fmt::Display for Relates {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Plays {
     pub span: Option<Span>,
     pub role: TypeRef,
diff --git a/rust/type_.rs b/rust/type_.rs
index a988ed04..34f65ea5 100644
--- a/rust/type_.rs
+++ b/rust/type_.rs
@@ -6,6 +6,9 @@
 
 use std::fmt;
 
+#[cfg(feature = "quine")]
+use {polyquine::Quine, proc_macro2::TokenStream};
+
 use crate::{
     common::{identifier::Identifier, token, Span, Spanned},
     pretty::Pretty,
@@ -13,6 +16,7 @@ use crate::{
 };
 
 #[derive(Clone, Debug, Hash, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct BuiltinValueType {
     pub span: Option<Span>,
     pub token: token::ValueType,
@@ -39,6 +43,7 @@ impl fmt::Display for BuiltinValueType {
 }
 
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Label {
     pub span: Option<Span>,
     pub ident: Identifier,
@@ -65,6 +70,7 @@ impl fmt::Display for Label {
 }
 
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct ScopedLabel {
     pub span: Option<Span>,
     pub scope: Label,
@@ -92,6 +98,7 @@ impl fmt::Display for ScopedLabel {
 }
 
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum NamedType {
     Label(Label),
     BuiltinValueType(BuiltinValueType),
@@ -116,6 +123,7 @@ impl fmt::Display for NamedType {
 }
 
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum NamedTypeAny {
     Simple(NamedType),
     List(NamedTypeList),
@@ -145,6 +153,7 @@ impl fmt::Display for NamedTypeAny {
 }
 
 #[derive(Debug, Clone, Hash, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct NamedTypeList {
     pub span: Option<Span>,
     pub inner: NamedType,
@@ -170,6 +179,7 @@ impl fmt::Display for NamedTypeList {
 }
 
 #[derive(Debug, Clone, Hash, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct NamedTypeOptional {
     pub span: Option<Span>,
     pub inner: NamedType,
@@ -195,6 +205,7 @@ impl fmt::Display for NamedTypeOptional {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum TypeRef {
     Label(Label), // person OR friendship:friend OR string
     Scoped(ScopedLabel),
@@ -224,6 +235,7 @@ impl fmt::Display for TypeRef {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum TypeRefAny {
     Type(TypeRef),     // person, friendship:friend, or $t
     List(TypeRefList), // person[], friendship:friend[], or $t[]
@@ -249,6 +261,7 @@ impl fmt::Display for TypeRefAny {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct TypeRefList {
     pub span: Option<Span>,
     pub inner: TypeRef,
diff --git a/rust/typeql.rs b/rust/typeql.rs
index 7780212e..2f5d3e10 100644
--- a/rust/typeql.rs
+++ b/rust/typeql.rs
@@ -41,7 +41,7 @@ pub mod common;
 pub mod expression;
 pub mod parser;
 pub mod pattern;
-mod pretty;
+pub mod pretty;
 pub mod query;
 pub mod schema;
 pub mod statement;
diff --git a/rust/value.rs b/rust/value.rs
index 1e5d86e3..9fa10206 100644
--- a/rust/value.rs
+++ b/rust/value.rs
@@ -6,6 +6,9 @@
 
 use std::fmt::{self, Formatter};
 
+#[cfg(feature = "quine")]
+use {polyquine::Quine, proc_macro2::TokenStream};
+
 use crate::{
     common::{error::TypeQLError, Span, Spanned},
     pretty::Pretty,
@@ -13,50 +16,59 @@ use crate::{
 };
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct BooleanLiteral {
     pub value: String,
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct StringLiteral {
     pub value: String,
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct IntegerLiteral {
     pub value: String,
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct NumericLiteral {
     pub value: String,
 }
 
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum Sign {
     Plus,
     Minus,
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct SignedIntegerLiteral {
     pub sign: Option<Sign>,
     pub integral: String,
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct SignedDoubleLiteral {
     pub sign: Option<Sign>,
     pub double: String,
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct SignedDecimalLiteral {
     pub sign: Option<Sign>,
     pub decimal: String,
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct DateFragment {
     pub year: String,
     pub month: String,
@@ -64,6 +76,7 @@ pub struct DateFragment {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct TimeFragment {
     pub hour: String,
     pub minute: String,
@@ -72,6 +85,7 @@ pub struct TimeFragment {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct DateTimeTZLiteral {
     pub date: DateFragment,
     pub time: TimeFragment,
@@ -79,23 +93,27 @@ pub struct DateTimeTZLiteral {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct DateTimeLiteral {
     pub date: DateFragment,
     pub time: TimeFragment,
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct DateLiteral {
     pub date: DateFragment,
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum TimeZone {
     IANA(String),
     ISO(String),
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum DurationLiteral {
     Weeks(IntegerLiteral),
     DateAndTime(DurationDate, Option<DurationTime>),
@@ -103,11 +121,13 @@ pub enum DurationLiteral {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct StructLiteral {
     pub inner: String, // TODO
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct DurationDate {
     pub years: Option<IntegerLiteral>,
     pub months: Option<IntegerLiteral>,
@@ -115,6 +135,7 @@ pub struct DurationDate {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct DurationTime {
     pub hours: Option<IntegerLiteral>,
     pub minutes: Option<IntegerLiteral>,
@@ -122,6 +143,7 @@ pub struct DurationTime {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum ValueLiteral {
     Boolean(BooleanLiteral),
     Integer(SignedIntegerLiteral),
@@ -136,6 +158,7 @@ pub enum ValueLiteral {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Literal {
     pub span: Option<Span>,
     pub inner: ValueLiteral,
diff --git a/rust/variable.rs b/rust/variable.rs
index 0f9ccf7a..fa149bfe 100644
--- a/rust/variable.rs
+++ b/rust/variable.rs
@@ -6,15 +6,20 @@
 
 use std::fmt;
 
+#[cfg(feature = "quine")]
+use {polyquine::Quine, proc_macro2::TokenStream};
+
 use crate::{
     common::{identifier::Identifier, Span, Spanned},
     pretty::Pretty,
 };
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub struct Optional;
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "quine", derive(Quine))]
 pub enum Variable {
     Anonymous { span: Option<Span>, optional: Option<Optional> },
     Named { span: Option<Span>, ident: Identifier, optional: Option<Optional> },