From e01970b20a058ab1b4ebea916f229c9b706c84e4 Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Fri, 18 Feb 2022 15:02:02 +0100
Subject: [PATCH] Basic show rules

---
 src/eval/capture.rs      |   2 +-
 src/eval/class.rs        |   8 +
 src/eval/mod.rs          |  52 ++-
 src/eval/styles.rs       | 387 ++++++++++++---------
 src/eval/template.rs     |  13 +-
 src/eval/value.rs        |  12 +-
 src/lib.rs               |   7 +-
 src/library/deco.rs      |  22 +-
 src/library/heading.rs   |  20 +-
 src/library/link.rs      |  36 +-
 src/library/list.rs      |  35 +-
 src/library/math.rs      |  19 +-
 src/library/raw.rs       |  14 +-
 src/library/table.rs     |  16 +-
 src/library/text.rs      |  12 +-
 src/parse/mod.rs         |  17 +-
 src/syntax/ast.rs        |  12 +-
 src/syntax/highlight.rs  |   1 +
 src/syntax/mod.rs        |   2 -
 src/syntax/pretty.rs     | 730 ---------------------------------------
 tests/ref/style/show.png | Bin 0 -> 19940 bytes
 tests/typ/style/set.typ  |   2 +-
 tests/typ/style/show.typ |  54 ++-
 tests/typ/style/wrap.typ |   2 +-
 tests/typeset.rs         |  33 +-
 25 files changed, 481 insertions(+), 1027 deletions(-)
 delete mode 100644 src/syntax/pretty.rs
 create mode 100644 tests/ref/style/show.png

diff --git a/src/eval/capture.rs b/src/eval/capture.rs
index d62ec55c2..fd6b01018 100644
--- a/src/eval/capture.rs
+++ b/src/eval/capture.rs
@@ -50,7 +50,7 @@ impl<'a> CapturesVisitor<'a> {
             Some(Expr::Ident(ident)) => self.capture(ident),
 
             // A closure contains parameter bindings, which are bound before the
-            // body is evaluated. Take must be taken so that the default values
+            // body is evaluated. Care must be taken so that the default values
             // of named parameters cannot access previous parameter bindings.
             Some(Expr::Closure(expr)) => {
                 for param in expr.params() {
diff --git a/src/eval/class.rs b/src/eval/class.rs
index 28e49a999..5601fb0b6 100644
--- a/src/eval/class.rs
+++ b/src/eval/class.rs
@@ -1,3 +1,4 @@
+use std::any::TypeId;
 use std::fmt::{self, Debug, Formatter, Write};
 use std::hash::{Hash, Hasher};
 
@@ -36,6 +37,7 @@ use crate::diag::TypResult;
 #[derive(Clone)]
 pub struct Class {
     name: &'static str,
+    id: TypeId,
     construct: fn(&mut Vm, &mut Args) -> TypResult<Value>,
     set: fn(&mut Args, &mut StyleMap) -> TypResult<()>,
 }
@@ -48,6 +50,7 @@ impl Class {
     {
         Self {
             name,
+            id: TypeId::of::<T>(),
             construct: |ctx, args| {
                 let mut styles = StyleMap::new();
                 T::set(args, &mut styles)?;
@@ -63,6 +66,11 @@ impl Class {
         self.name
     }
 
+    /// The type id of the class.
+    pub fn id(&self) -> TypeId {
+        self.id
+    }
+
     /// Return the class constructor as a function.
     pub fn constructor(&self) -> Func {
         Func::native(self.name, self.construct)
diff --git a/src/eval/mod.rs b/src/eval/mod.rs
index 32ffb0c9b..1b61ac151 100644
--- a/src/eval/mod.rs
+++ b/src/eval/mod.rs
@@ -36,7 +36,6 @@ use unicode_segmentation::UnicodeSegmentation;
 
 use crate::diag::{At, Error, StrResult, Trace, Tracepoint, TypResult};
 use crate::geom::{Angle, Fractional, Length, Relative};
-use crate::layout::Layout;
 use crate::library;
 use crate::syntax::ast::*;
 use crate::syntax::{Span, Spanned};
@@ -80,15 +79,12 @@ fn eval_markup(
     while let Some(node) = nodes.next() {
         seq.push(match node {
             MarkupNode::Expr(Expr::Set(set)) => {
-                let class = set.class();
-                let class = class.eval(vm)?.cast::<Class>().at(class.span())?;
-                let args = set.args().eval(vm)?;
-                let styles = class.set(args)?;
-                let tail = eval_markup(vm, nodes)?;
-                tail.styled_with_map(styles)
+                let styles = set.eval(vm)?;
+                eval_markup(vm, nodes)?.styled_with_map(styles)
             }
             MarkupNode::Expr(Expr::Show(show)) => {
-                return Err("show rules are not yet implemented").at(show.span());
+                let styles = show.eval(vm)?;
+                eval_markup(vm, nodes)?.styled_with_map(styles)
             }
             MarkupNode::Expr(Expr::Wrap(wrap)) => {
                 let tail = eval_markup(vm, nodes)?;
@@ -182,7 +178,7 @@ impl Eval for ListNode {
     fn eval(&self, vm: &mut Vm) -> TypResult<Self::Output> {
         Ok(Template::List(library::ListItem {
             number: None,
-            body: self.body().eval(vm)?.pack(),
+            body: Box::new(self.body().eval(vm)?),
         }))
     }
 }
@@ -193,7 +189,7 @@ impl Eval for EnumNode {
     fn eval(&self, vm: &mut Vm) -> TypResult<Self::Output> {
         Ok(Template::Enum(library::ListItem {
             number: self.number(),
-            body: self.body().eval(vm)?.pack(),
+            body: Box::new(self.body().eval(vm)?),
         }))
     }
 }
@@ -216,9 +212,10 @@ impl Eval for Expr {
             Self::Unary(v) => v.eval(vm),
             Self::Binary(v) => v.eval(vm),
             Self::Let(v) => v.eval(vm),
-            Self::Set(v) => v.eval(vm),
-            Self::Show(v) => v.eval(vm),
-            Self::Wrap(v) => v.eval(vm),
+            Self::Set(_) | Self::Show(_) | Self::Wrap(_) => {
+                Err("set, show and wrap are only allowed directly in markup")
+                    .at(self.span())
+            }
             Self::If(v) => v.eval(vm),
             Self::While(v) => v.eval(vm),
             Self::For(v) => v.eval(vm),
@@ -551,26 +548,27 @@ impl Eval for LetExpr {
 }
 
 impl Eval for SetExpr {
-    type Output = Value;
+    type Output = StyleMap;
 
-    fn eval(&self, _: &mut Vm) -> TypResult<Self::Output> {
-        Err("set is only allowed directly in markup").at(self.span())
+    fn eval(&self, vm: &mut Vm) -> TypResult<Self::Output> {
+        let class = self.class();
+        let class = class.eval(vm)?.cast::<Class>().at(class.span())?;
+        let args = self.args().eval(vm)?;
+        class.set(args)
     }
 }
 
 impl Eval for ShowExpr {
-    type Output = Value;
+    type Output = StyleMap;
 
-    fn eval(&self, _: &mut Vm) -> TypResult<Self::Output> {
-        Err("show is only allowed directly in markup").at(self.span())
-    }
-}
-
-impl Eval for WrapExpr {
-    type Output = Value;
-
-    fn eval(&self, _: &mut Vm) -> TypResult<Self::Output> {
-        Err("wrap is only allowed directly in markup").at(self.span())
+    fn eval(&self, vm: &mut Vm) -> TypResult<Self::Output> {
+        let class = self.class();
+        let class = class.eval(vm)?.cast::<Class>().at(class.span())?;
+        let closure = self.closure();
+        let func = closure.eval(vm)?.cast::<Func>().at(closure.span())?;
+        let mut styles = StyleMap::new();
+        styles.set_recipe(class.id(), func, self.span());
+        Ok(styles)
     }
 }
 
diff --git a/src/eval/styles.rs b/src/eval/styles.rs
index 2bf3f239f..346eb784e 100644
--- a/src/eval/styles.rs
+++ b/src/eval/styles.rs
@@ -3,21 +3,28 @@ use std::fmt::{self, Debug, Formatter};
 use std::hash::{Hash, Hasher};
 use std::sync::Arc;
 
+use super::{Args, Func, Span, Template, Value, Vm};
+use crate::diag::{At, TypResult};
 use crate::library::{PageNode, ParNode};
 
 /// A map of style properties.
 #[derive(Default, Clone, PartialEq, Hash)]
-pub struct StyleMap(Vec<Entry>);
+pub struct StyleMap {
+    /// Settable properties.
+    props: Vec<Entry>,
+    /// Show rule recipes.
+    recipes: Vec<Recipe>,
+}
 
 impl StyleMap {
     /// Create a new, empty style map.
     pub fn new() -> Self {
-        Self(vec![])
+        Self { props: vec![], recipes: vec![] }
     }
 
     /// Whether this map contains no styles.
     pub fn is_empty(&self) -> bool {
-        self.0.is_empty()
+        self.props.is_empty() && self.recipes.is_empty()
     }
 
     /// Create a style map from a single property-value pair.
@@ -29,7 +36,7 @@ impl StyleMap {
 
     /// Set the value for a style property.
     pub fn set<P: Property>(&mut self, key: P, value: P::Value) {
-        self.0.push(Entry::new(key, value));
+        self.props.push(Entry::new(key, value));
     }
 
     /// Set a value for a style property if it is `Some(_)`.
@@ -39,11 +46,16 @@ impl StyleMap {
         }
     }
 
+    /// Set a recipe.
+    pub fn set_recipe(&mut self, node: TypeId, func: Func, span: Span) {
+        self.recipes.push(Recipe { node, func, span });
+    }
+
     /// Mark all contained properties as _scoped_. This means that they only
     /// apply to the first descendant node (of their type) in the hierarchy and
     /// not its children, too. This is used by class constructors.
     pub fn scoped(mut self) -> Self {
-        for entry in &mut self.0 {
+        for entry in &mut self.props {
             entry.scoped = true;
         }
         self
@@ -51,7 +63,7 @@ impl StyleMap {
 
     /// Whether this map contains scoped styles.
     pub fn has_scoped(&self) -> bool {
-        self.0.iter().any(|e| e.scoped)
+        self.props.iter().any(|e| e.scoped)
     }
 
     /// Make `self` the first link of the style chain `outer`.
@@ -78,20 +90,24 @@ impl StyleMap {
     /// lifetime, for example, because you want to store the style map inside a
     /// packed node.
     pub fn apply(&mut self, outer: &Self) {
-        self.0.splice(0 .. 0, outer.0.clone());
+        self.props.splice(0 .. 0, outer.props.iter().cloned());
+        self.recipes.splice(0 .. 0, outer.recipes.iter().cloned());
     }
 
     /// The highest-level interruption of the map.
     pub fn interruption(&self) -> Option<Interruption> {
-        self.0.iter().filter_map(|entry| entry.interruption()).max()
+        self.props.iter().filter_map(|entry| entry.interruption()).max()
     }
 }
 
 impl Debug for StyleMap {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        for entry in self.0.iter().rev() {
+        for entry in self.props.iter().rev() {
             writeln!(f, "{:#?}", entry)?;
         }
+        for recipe in self.recipes.iter().rev() {
+            writeln!(f, "#[Recipe for {:?} from {:?}]", recipe.node, recipe.span)?;
+        }
         Ok(())
     }
 }
@@ -105,6 +121,169 @@ pub enum Interruption {
     Page,
 }
 
+/// Style property keys.
+///
+/// This trait is not intended to be implemented manually, but rather through
+/// the `#[class]` proc-macro.
+pub trait Property: Sync + Send + 'static {
+    /// The type of value that is returned when getting this property from a
+    /// style map. For example, this could be [`Length`](crate::geom::Length)
+    /// for a `WIDTH` property.
+    type Value: Debug + Clone + PartialEq + Hash + Sync + Send + 'static;
+
+    /// The name of the property, used for debug printing.
+    const NAME: &'static str;
+
+    /// Whether the property needs folding.
+    const FOLDING: bool = false;
+
+    /// The type id of the node this property belongs to.
+    fn node_id() -> TypeId;
+
+    /// The default value of the property.
+    fn default() -> Self::Value;
+
+    /// A static reference to the default value of the property.
+    ///
+    /// This is automatically implemented through lazy-initialization in the
+    /// `#[class]` macro. This way, expensive defaults don't need to be
+    /// recreated all the time.
+    fn default_ref() -> &'static Self::Value;
+
+    /// Fold the property with an outer value.
+    ///
+    /// For example, this would fold a relative font size with an outer
+    /// absolute font size.
+    #[allow(unused_variables)]
+    fn fold(inner: Self::Value, outer: Self::Value) -> Self::Value {
+        inner
+    }
+}
+
+/// Marker trait that indicates that a property doesn't need folding.
+pub trait Nonfolding {}
+
+/// An entry for a single style property.
+#[derive(Clone)]
+struct Entry {
+    pair: Arc<dyn Bounds>,
+    scoped: bool,
+}
+
+impl Entry {
+    fn new<P: Property>(key: P, value: P::Value) -> Self {
+        Self {
+            pair: Arc::new((key, value)),
+            scoped: false,
+        }
+    }
+
+    fn is<P: Property>(&self) -> bool {
+        self.pair.style_id() == TypeId::of::<P>()
+    }
+
+    fn is_of<T: 'static>(&self) -> bool {
+        self.pair.node_id() == TypeId::of::<T>()
+    }
+
+    fn is_of_id(&self, node: TypeId) -> bool {
+        self.pair.node_id() == node
+    }
+
+    fn downcast<P: Property>(&self) -> Option<&P::Value> {
+        self.pair.as_any().downcast_ref()
+    }
+
+    fn interruption(&self) -> Option<Interruption> {
+        if self.is_of::<PageNode>() {
+            Some(Interruption::Page)
+        } else if self.is_of::<ParNode>() {
+            Some(Interruption::Par)
+        } else {
+            None
+        }
+    }
+}
+
+impl Debug for Entry {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        f.write_str("#[")?;
+        self.pair.dyn_fmt(f)?;
+        if self.scoped {
+            f.write_str(" (scoped)")?;
+        }
+        f.write_str("]")
+    }
+}
+
+impl PartialEq for Entry {
+    fn eq(&self, other: &Self) -> bool {
+        self.pair.dyn_eq(other) && self.scoped == other.scoped
+    }
+}
+
+impl Hash for Entry {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        state.write_u64(self.pair.hash64());
+        state.write_u8(self.scoped as u8);
+    }
+}
+
+/// This trait is implemented for pairs of zero-sized property keys and their
+/// value types below. Although it is zero-sized, the property `P` must be part
+/// of the implementing type so that we can use it in the methods (it must be a
+/// constrained type parameter).
+trait Bounds: Sync + Send + 'static {
+    fn as_any(&self) -> &dyn Any;
+    fn dyn_fmt(&self, f: &mut Formatter) -> fmt::Result;
+    fn dyn_eq(&self, other: &Entry) -> bool;
+    fn hash64(&self) -> u64;
+    fn node_id(&self) -> TypeId;
+    fn style_id(&self) -> TypeId;
+}
+
+impl<P: Property> Bounds for (P, P::Value) {
+    fn as_any(&self) -> &dyn Any {
+        &self.1
+    }
+
+    fn dyn_fmt(&self, f: &mut Formatter) -> fmt::Result {
+        write!(f, "{} = {:?}", P::NAME, self.1)
+    }
+
+    fn dyn_eq(&self, other: &Entry) -> bool {
+        self.style_id() == other.pair.style_id()
+            && if let Some(other) = other.downcast::<P>() {
+                &self.1 == other
+            } else {
+                false
+            }
+    }
+
+    fn hash64(&self) -> u64 {
+        let mut state = fxhash::FxHasher64::default();
+        self.style_id().hash(&mut state);
+        self.1.hash(&mut state);
+        state.finish()
+    }
+
+    fn node_id(&self) -> TypeId {
+        P::node_id()
+    }
+
+    fn style_id(&self) -> TypeId {
+        TypeId::of::<P>()
+    }
+}
+
+/// A show rule recipe.
+#[derive(Debug, Clone, PartialEq, Hash)]
+struct Recipe {
+    node: TypeId,
+    func: Func,
+    span: Span,
+}
+
 /// A chain of style maps, similar to a linked list.
 ///
 /// A style chain allows to conceptually merge (and fold) properties from
@@ -162,11 +341,18 @@ impl<'a> StyleChain<'a> {
         *self = self.outer.copied().unwrap_or_default();
     }
 
+    /// Return the span of a recipe for the given node.
+    pub(crate) fn recipe_span(self, node: TypeId) -> Option<Span> {
+        self.recipes(node).next().map(|recipe| recipe.span)
+    }
+
     /// Return the chain, but without the last link if that one contains only
     /// scoped styles. This is a hack.
     pub(crate) fn unscoped(mut self, node: TypeId) -> Self {
         if let Some(Link::Map(map)) = self.link {
-            if map.0.iter().all(|e| e.scoped && e.is_of_id(node)) {
+            if map.props.iter().all(|e| e.scoped && e.is_of_id(node))
+                && map.recipes.is_empty()
+            {
                 self.pop();
             }
         }
@@ -225,6 +411,21 @@ impl<'a> StyleChain<'a> {
         }
     }
 
+    /// Execute a user recipe for a node.
+    pub fn show(
+        self,
+        node: &dyn Any,
+        vm: &mut Vm,
+        values: impl IntoIterator<Item = Value>,
+    ) -> TypResult<Option<Template>> {
+        Ok(if let Some(recipe) = self.recipes(node.type_id()).next() {
+            let args = Args::from_values(recipe.span, values);
+            Some(recipe.func.call(vm, args)?.cast().at(recipe.span)?)
+        } else {
+            None
+        })
+    }
+
     /// Insert a barrier into the style chain.
     ///
     /// Barriers interact with [scoped](StyleMap::scoped) styles: A scoped style
@@ -233,7 +434,7 @@ impl<'a> StyleChain<'a> {
     pub fn barred<'b>(&'b self, node: TypeId) -> StyleChain<'b> {
         if self
             .maps()
-            .any(|map| map.0.iter().any(|entry| entry.scoped && entry.is_of_id(node)))
+            .any(|map| map.props.iter().any(|entry| entry.scoped && entry.is_of_id(node)))
         {
             StyleChain {
                 link: Some(Link::Barrier(node)),
@@ -252,7 +453,7 @@ impl<'a> StyleChain<'a> {
         self.links().flat_map(move |link| {
             let mut entries: &[Entry] = &[];
             match link {
-                Link::Map(map) => entries = &map.0,
+                Link::Map(map) => entries = &map.props,
                 Link::Barrier(id) => depth += (id == P::node_id()) as usize,
             }
             entries
@@ -263,6 +464,13 @@ impl<'a> StyleChain<'a> {
         })
     }
 
+    /// Iterate over the recipes for the given node.
+    fn recipes(self, node: TypeId) -> impl Iterator<Item = &'a Recipe> {
+        self.maps()
+            .flat_map(|map| map.recipes.iter().rev())
+            .filter(move |recipe| recipe.node == node)
+    }
+
     /// Iterate over the map links of the chain.
     fn maps(self) -> impl Iterator<Item = &'a StyleMap> {
         self.links().filter_map(|link| match link {
@@ -443,158 +651,3 @@ impl<'a, T> Default for StyleVecBuilder<'a, T> {
         Self::new()
     }
 }
-
-/// Style property keys.
-///
-/// This trait is not intended to be implemented manually, but rather through
-/// the `#[class]` proc-macro.
-pub trait Property: Sync + Send + 'static {
-    /// The type of value that is returned when getting this property from a
-    /// style map. For example, this could be [`Length`](crate::geom::Length)
-    /// for a `WIDTH` property.
-    type Value: Debug + Clone + PartialEq + Hash + Sync + Send + 'static;
-
-    /// The name of the property, used for debug printing.
-    const NAME: &'static str;
-
-    /// Whether the property needs folding.
-    const FOLDING: bool = false;
-
-    /// The type id of the node this property belongs to.
-    fn node_id() -> TypeId;
-
-    /// The default value of the property.
-    fn default() -> Self::Value;
-
-    /// A static reference to the default value of the property.
-    ///
-    /// This is automatically implemented through lazy-initialization in the
-    /// `#[class]` macro. This way, expensive defaults don't need to be
-    /// recreated all the time.
-    fn default_ref() -> &'static Self::Value;
-
-    /// Fold the property with an outer value.
-    ///
-    /// For example, this would fold a relative font size with an outer
-    /// absolute font size.
-    #[allow(unused_variables)]
-    fn fold(inner: Self::Value, outer: Self::Value) -> Self::Value {
-        inner
-    }
-}
-
-/// Marker trait that indicates that a property doesn't need folding.
-pub trait Nonfolding {}
-
-/// An entry for a single style property.
-#[derive(Clone)]
-struct Entry {
-    pair: Arc<dyn Bounds>,
-    scoped: bool,
-}
-
-impl Entry {
-    fn new<P: Property>(key: P, value: P::Value) -> Self {
-        Self {
-            pair: Arc::new((key, value)),
-            scoped: false,
-        }
-    }
-
-    fn is<P: Property>(&self) -> bool {
-        self.pair.style_id() == TypeId::of::<P>()
-    }
-
-    fn is_of<T: 'static>(&self) -> bool {
-        self.pair.node_id() == TypeId::of::<T>()
-    }
-
-    fn is_of_id(&self, node: TypeId) -> bool {
-        self.pair.node_id() == node
-    }
-
-    fn downcast<P: Property>(&self) -> Option<&P::Value> {
-        self.pair.as_any().downcast_ref()
-    }
-
-    fn interruption(&self) -> Option<Interruption> {
-        if self.is_of::<PageNode>() {
-            Some(Interruption::Page)
-        } else if self.is_of::<ParNode>() {
-            Some(Interruption::Par)
-        } else {
-            None
-        }
-    }
-}
-
-impl Debug for Entry {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        f.write_str("#[")?;
-        self.pair.dyn_fmt(f)?;
-        if self.scoped {
-            f.write_str(" (scoped)")?;
-        }
-        f.write_str("]")
-    }
-}
-
-impl PartialEq for Entry {
-    fn eq(&self, other: &Self) -> bool {
-        self.pair.dyn_eq(other) && self.scoped == other.scoped
-    }
-}
-
-impl Hash for Entry {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        state.write_u64(self.pair.hash64());
-        state.write_u8(self.scoped as u8);
-    }
-}
-
-/// This trait is implemented for pairs of zero-sized property keys and their
-/// value types below. Although it is zero-sized, the property `P` must be part
-/// of the implementing type so that we can use it in the methods (it must be a
-/// constrained type parameter).
-trait Bounds: Sync + Send + 'static {
-    fn as_any(&self) -> &dyn Any;
-    fn dyn_fmt(&self, f: &mut Formatter) -> fmt::Result;
-    fn dyn_eq(&self, other: &Entry) -> bool;
-    fn hash64(&self) -> u64;
-    fn node_id(&self) -> TypeId;
-    fn style_id(&self) -> TypeId;
-}
-
-impl<P: Property> Bounds for (P, P::Value) {
-    fn as_any(&self) -> &dyn Any {
-        &self.1
-    }
-
-    fn dyn_fmt(&self, f: &mut Formatter) -> fmt::Result {
-        write!(f, "{} = {:?}", P::NAME, self.1)
-    }
-
-    fn dyn_eq(&self, other: &Entry) -> bool {
-        self.style_id() == other.pair.style_id()
-            && if let Some(other) = other.downcast::<P>() {
-                &self.1 == other
-            } else {
-                false
-            }
-    }
-
-    fn hash64(&self) -> u64 {
-        let mut state = fxhash::FxHasher64::default();
-        self.style_id().hash(&mut state);
-        self.1.hash(&mut state);
-        state.finish()
-    }
-
-    fn node_id(&self) -> TypeId {
-        P::node_id()
-    }
-
-    fn style_id(&self) -> TypeId {
-        TypeId::of::<P>()
-    }
-}
diff --git a/src/eval/template.rs b/src/eval/template.rs
index 1f1544e64..465e91959 100644
--- a/src/eval/template.rs
+++ b/src/eval/template.rs
@@ -403,9 +403,16 @@ impl<'a> Builder<'a> {
                 }
             }
             Template::Show(node) => {
+                let id = node.id();
+                if vm.rules.contains(&id) {
+                    let span = styles.recipe_span(id).unwrap();
+                    return Err("show rule is recursive").at(span)?;
+                }
+                vm.rules.push(id);
                 let template = node.show(vm, styles)?;
                 let stored = self.tpa.alloc(template);
-                self.process(vm, stored, styles.unscoped(node.id()))?;
+                self.process(vm, stored, styles.unscoped(id))?;
+                vm.rules.pop();
             }
             Template::Styled(styled) => {
                 let (sub, map) = styled.as_ref();
@@ -455,8 +462,8 @@ impl<'a> Builder<'a> {
         };
 
         let template = match kind {
-            UNORDERED => Template::show(ListNode::<UNORDERED> { items, wide, start: 1 }),
-            ORDERED | _ => Template::show(ListNode::<ORDERED> { items, wide, start: 1 }),
+            UNORDERED => Template::show(ListNode::<UNORDERED> { start: 1, wide, items }),
+            ORDERED | _ => Template::show(ListNode::<ORDERED> { start: 1, wide, items }),
         };
 
         let stored = self.tpa.alloc(template);
diff --git a/src/eval/value.rs b/src/eval/value.rs
index 2de210d57..952c7293d 100644
--- a/src/eval/value.rs
+++ b/src/eval/value.rs
@@ -336,7 +336,7 @@ pub trait Cast<V = Value>: Sized {
 macro_rules! primitive {
     (
         $type:ty: $name:literal, $variant:ident
-        $(, $other:ident($binding:ident) => $out:expr)*
+        $(, $other:ident$(($binding:ident))? => $out:expr)*
     ) => {
         impl Type for $type {
             const TYPE_NAME: &'static str = $name;
@@ -344,13 +344,14 @@ macro_rules! primitive {
 
         impl Cast for $type {
             fn is(value: &Value) -> bool {
-                matches!(value, Value::$variant(_) $(| Value::$other(_))*)
+                matches!(value, Value::$variant(_)
+                    $(|  primitive!(@$other $(($binding))?))*)
             }
 
             fn cast(value: Value) -> StrResult<Self> {
                 match value {
                     Value::$variant(v) => Ok(v),
-                    $(Value::$other($binding) => Ok($out),)*
+                    $(Value::$other$(($binding))? => Ok($out),)*
                     v => Err(format!(
                         "expected {}, found {}",
                         Self::TYPE_NAME,
@@ -366,6 +367,9 @@ macro_rules! primitive {
             }
         }
     };
+
+    (@$other:ident($binding:ident)) => { Value::$other(_) };
+    (@$other:ident) => { Value::$other };
 }
 
 /// Implement traits for dynamic types.
@@ -440,7 +444,7 @@ primitive! { Color: "color", Color }
 primitive! { EcoString: "string", Str }
 primitive! { Array: "array", Array }
 primitive! { Dict: "dictionary", Dict }
-primitive! { Template: "template", Template }
+primitive! { Template: "template", Template, None => Template::new() }
 primitive! { Func: "function", Func, Class(v) => v.constructor() }
 primitive! { Args: "arguments", Args }
 primitive! { Class: "class", Class }
diff --git a/src/lib.rs b/src/lib.rs
index 6ad30d2f6..be1bab0d6 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -25,7 +25,7 @@
 //! [evaluate]: Vm::evaluate
 //! [module]: eval::Module
 //! [template]: eval::Template
-//! [layouted]: eval::Template::layout
+//! [layouted]: eval::Template::layout_pages
 //! [cache]: layout::LayoutCache
 //! [PDF]: export::pdf
 
@@ -51,6 +51,7 @@ pub mod parse;
 pub mod source;
 pub mod syntax;
 
+use std::any::TypeId;
 use std::collections::HashMap;
 use std::path::PathBuf;
 use std::sync::Arc;
@@ -218,6 +219,9 @@ pub struct Vm<'a> {
     pub modules: HashMap<SourceId, Module>,
     /// The active scopes.
     pub scopes: Scopes<'a>,
+    /// Currently evaluated show rules. This is used to prevent recursive show
+    /// rules.
+    pub rules: Vec<TypeId>,
     /// How deeply nested the current layout tree position is.
     #[cfg(feature = "layout-cache")]
     pub level: usize,
@@ -236,6 +240,7 @@ impl<'a> Vm<'a> {
             route: vec![],
             modules: HashMap::new(),
             scopes: Scopes::new(Some(&ctx.std)),
+            rules: vec![],
             level: 0,
         }
     }
diff --git a/src/library/deco.rs b/src/library/deco.rs
index 790262889..aac79d05a 100644
--- a/src/library/deco.rs
+++ b/src/library/deco.rs
@@ -32,15 +32,19 @@ impl<const L: DecoLine> DecoNode<L> {
 }
 
 impl<const L: DecoLine> Show for DecoNode<L> {
-    fn show(&self, _: &mut Vm, styles: StyleChain) -> TypResult<Template> {
-        Ok(self.0.clone().styled(TextNode::LINES, vec![Decoration {
-            line: L,
-            stroke: styles.get(Self::STROKE),
-            thickness: styles.get(Self::THICKNESS),
-            offset: styles.get(Self::OFFSET),
-            extent: styles.get(Self::EXTENT),
-            evade: styles.get(Self::EVADE),
-        }]))
+    fn show(&self, vm: &mut Vm, styles: StyleChain) -> TypResult<Template> {
+        Ok(styles
+            .show(self, vm, [Value::Template(self.0.clone())])?
+            .unwrap_or_else(|| {
+                self.0.clone().styled(TextNode::LINES, vec![Decoration {
+                    line: L,
+                    stroke: styles.get(Self::STROKE),
+                    thickness: styles.get(Self::THICKNESS),
+                    offset: styles.get(Self::OFFSET),
+                    extent: styles.get(Self::EXTENT),
+                    evade: styles.get(Self::EVADE),
+                }])
+            }))
     }
 }
 
diff --git a/src/library/heading.rs b/src/library/heading.rs
index 1b8fcef90..499756553 100644
--- a/src/library/heading.rs
+++ b/src/library/heading.rs
@@ -34,6 +34,8 @@ impl HeadingNode {
     pub const ABOVE: Leveled<Length> = Leveled::Value(Length::zero());
     /// The extra padding below the heading.
     pub const BELOW: Leveled<Length> = Leveled::Value(Length::zero());
+    /// Whether the heading is block-level.
+    pub const BLOCK: Leveled<bool> = Leveled::Value(true);
 
     fn construct(_: &mut Vm, args: &mut Args) -> TypResult<Template> {
         Ok(Template::show(Self {
@@ -51,6 +53,14 @@ impl Show for HeadingNode {
             };
         }
 
+        // Resolve the user recipe.
+        let mut body = styles
+            .show(self, vm, [
+                Value::Int(self.level as i64),
+                Value::Template(self.body.clone()),
+            ])?
+            .unwrap_or_else(|| self.body.clone());
+
         let mut map = StyleMap::new();
         map.set(TextNode::SIZE, resolve!(Self::SIZE));
 
@@ -76,7 +86,6 @@ impl Show for HeadingNode {
         }
 
         let mut seq = vec![];
-        let mut body = self.body.clone();
         if resolve!(Self::UNDERLINE) {
             body = body.underlined();
         }
@@ -93,9 +102,12 @@ impl Show for HeadingNode {
             seq.push(Template::Vertical(below.into()));
         }
 
-        Ok(Template::block(
-            Template::sequence(seq).styled_with_map(map),
-        ))
+        let mut template = Template::sequence(seq).styled_with_map(map);
+        if resolve!(Self::BLOCK) {
+            template = Template::block(template);
+        }
+
+        Ok(template)
     }
 }
 
diff --git a/src/library/link.rs b/src/library/link.rs
index 95fff089f..412095493 100644
--- a/src/library/link.rs
+++ b/src/library/link.rs
@@ -10,7 +10,7 @@ pub struct LinkNode {
     /// The url the link points to.
     pub url: EcoString,
     /// How the link is represented.
-    pub body: Template,
+    pub body: Option<Template>,
 }
 
 #[class]
@@ -22,22 +22,31 @@ impl LinkNode {
     pub const UNDERLINE: bool = true;
 
     fn construct(_: &mut Vm, args: &mut Args) -> TypResult<Template> {
-        let url = args.expect::<EcoString>("url")?;
-        let body = args.find()?.unwrap_or_else(|| {
-            let mut text = url.as_str();
-            for prefix in ["mailto:", "tel:"] {
-                text = text.trim_start_matches(prefix);
-            }
-            let shorter = text.len() < url.len();
-            Template::Text(if shorter { text.into() } else { url.clone() })
-        });
-
-        Ok(Template::show(Self { url, body }))
+        Ok(Template::show(Self {
+            url: args.expect::<EcoString>("url")?,
+            body: args.find()?,
+        }))
     }
 }
 
 impl Show for LinkNode {
-    fn show(&self, _: &mut Vm, styles: StyleChain) -> TypResult<Template> {
+    fn show(&self, vm: &mut Vm, styles: StyleChain) -> TypResult<Template> {
+        let mut body = styles
+            .show(self, vm, [Value::Str(self.url.clone()), match &self.body {
+                Some(body) => Value::Template(body.clone()),
+                None => Value::None,
+            }])?
+            .or_else(|| self.body.clone())
+            .unwrap_or_else(|| {
+                let url = &self.url;
+                let mut text = url.as_str();
+                for prefix in ["mailto:", "tel:"] {
+                    text = text.trim_start_matches(prefix);
+                }
+                let shorter = text.len() < url.len();
+                Template::Text(if shorter { text.into() } else { url.clone() })
+            });
+
         let mut map = StyleMap::new();
         map.set(TextNode::LINK, Some(self.url.clone()));
 
@@ -45,7 +54,6 @@ impl Show for LinkNode {
             map.set(TextNode::FILL, fill);
         }
 
-        let mut body = self.body.clone();
         if styles.get(Self::UNDERLINE) {
             body = body.underlined();
         }
diff --git a/src/library/list.rs b/src/library/list.rs
index 13f21a047..37dda843e 100644
--- a/src/library/list.rs
+++ b/src/library/list.rs
@@ -8,13 +8,13 @@ use crate::parse::Scanner;
 /// An unordered or ordered list.
 #[derive(Debug, Hash)]
 pub struct ListNode<const L: ListKind> {
-    /// The individual bulleted or numbered items.
-    pub items: Vec<ListItem>,
+    /// Where the list starts.
+    pub start: usize,
     /// If true, there is paragraph spacing between the items, if false
     /// there is list spacing between the items.
     pub wide: bool,
-    /// Where the list starts.
-    pub start: usize,
+    /// The individual bulleted or numbered items.
+    pub items: Vec<ListItem>,
 }
 
 /// An item in a list.
@@ -23,7 +23,7 @@ pub struct ListItem {
     /// The number of the item.
     pub number: Option<usize>,
     /// The node that produces the item's body.
-    pub body: LayoutNode,
+    pub body: Box<Template>,
 }
 
 #[class]
@@ -39,19 +39,27 @@ impl<const L: ListKind> ListNode<L> {
 
     fn construct(_: &mut Vm, args: &mut Args) -> TypResult<Template> {
         Ok(Template::show(Self {
+            start: args.named("start")?.unwrap_or(0),
+            wide: args.named("wide")?.unwrap_or(false),
             items: args
                 .all()?
                 .into_iter()
-                .map(|body| ListItem { number: None, body })
+                .map(|body| ListItem { number: None, body: Box::new(body) })
                 .collect(),
-            wide: args.named("wide")?.unwrap_or(false),
-            start: args.named("start")?.unwrap_or(0),
         }))
     }
 }
 
 impl<const L: ListKind> Show for ListNode<L> {
     fn show(&self, vm: &mut Vm, styles: StyleChain) -> TypResult<Template> {
+        if let Some(template) = styles.show(
+            self,
+            vm,
+            self.items.iter().map(|item| Value::Template((*item.body).clone())),
+        )? {
+            return Ok(template);
+        }
+
         let mut children = vec![];
         let mut number = self.start;
 
@@ -66,7 +74,7 @@ impl<const L: ListKind> Show for ListNode<L> {
             children.push(LayoutNode::default());
             children.push(label.resolve(vm, L, number)?.pack());
             children.push(LayoutNode::default());
-            children.push(item.body.clone());
+            children.push((*item.body).clone().pack());
             number += 1;
         }
 
@@ -119,8 +127,6 @@ pub enum Label {
     Pattern(EcoString, Numbering, bool, EcoString),
     /// A bare template.
     Template(Template),
-    /// A simple mapping from an item number to a template.
-    Mapping(fn(usize) -> Template),
     /// A closure mapping from an item number to a value.
     Func(Func, Span),
 }
@@ -144,10 +150,9 @@ impl Label {
                 Template::Text(format_eco!("{}{}{}", prefix, mid, suffix))
             }
             Self::Template(template) => template.clone(),
-            Self::Mapping(mapping) => mapping(number),
-            &Self::Func(ref func, span) => {
-                let args = Args::from_values(span, [Value::Int(number as i64)]);
-                func.call(vm, args)?.cast().at(span)?
+            Self::Func(func, span) => {
+                let args = Args::from_values(*span, [Value::Int(number as i64)]);
+                func.call(vm, args)?.cast().at(*span)?
             }
         })
     }
diff --git a/src/library/math.rs b/src/library/math.rs
index d3c8b5e5f..40a1990ec 100644
--- a/src/library/math.rs
+++ b/src/library/math.rs
@@ -22,11 +22,18 @@ impl MathNode {
 }
 
 impl Show for MathNode {
-    fn show(&self, _: &mut Vm, _: StyleChain) -> TypResult<Template> {
-        let mut template = Template::Text(self.formula.trim().into());
-        if self.display {
-            template = Template::Block(template.pack());
-        }
-        Ok(template.monospaced())
+    fn show(&self, vm: &mut Vm, styles: StyleChain) -> TypResult<Template> {
+        Ok(styles
+            .show(self, vm, [
+                Value::Str(self.formula.clone()),
+                Value::Bool(self.display),
+            ])?
+            .unwrap_or_else(|| {
+                let mut template = Template::Text(self.formula.trim().into());
+                if self.display {
+                    template = Template::Block(template.pack());
+                }
+                template.monospaced()
+            }))
     }
 }
diff --git a/src/library/raw.rs b/src/library/raw.rs
index da926679a..bb4e2c968 100644
--- a/src/library/raw.rs
+++ b/src/library/raw.rs
@@ -40,8 +40,20 @@ impl RawNode {
 }
 
 impl Show for RawNode {
-    fn show(&self, _: &mut Vm, styles: StyleChain) -> TypResult<Template> {
+    fn show(&self, vm: &mut Vm, styles: StyleChain) -> TypResult<Template> {
         let lang = styles.get_ref(Self::LANG).as_ref();
+
+        if let Some(template) = styles.show(self, vm, [
+            Value::Str(self.text.clone()),
+            match lang {
+                Some(lang) => Value::Str(lang.clone()),
+                None => Value::None,
+            },
+            Value::Bool(self.block),
+        ])? {
+            return Ok(template);
+        }
+
         let foreground = THEME
             .settings
             .foreground
diff --git a/src/library/table.rs b/src/library/table.rs
index 8c088c094..f4de0f551 100644
--- a/src/library/table.rs
+++ b/src/library/table.rs
@@ -11,7 +11,7 @@ pub struct TableNode {
     /// Defines sizing of gutter rows and columns between content.
     pub gutter: Spec<Vec<TrackSizing>>,
     /// The nodes to be arranged in the table.
-    pub children: Vec<LayoutNode>,
+    pub children: Vec<Template>,
 }
 
 #[class]
@@ -55,7 +55,15 @@ impl TableNode {
 }
 
 impl Show for TableNode {
-    fn show(&self, _: &mut Vm, styles: StyleChain) -> TypResult<Template> {
+    fn show(&self, vm: &mut Vm, styles: StyleChain) -> TypResult<Template> {
+        if let Some(template) = styles.show(
+            self,
+            vm,
+            self.children.iter().map(|child| Value::Template(child.clone())),
+        )? {
+            return Ok(template);
+        }
+
         let primary = styles.get(Self::PRIMARY);
         let secondary = styles.get(Self::SECONDARY);
         let thickness = styles.get(Self::THICKNESS);
@@ -68,8 +76,8 @@ impl Show for TableNode {
             .iter()
             .cloned()
             .enumerate()
-            .map(|(i, mut child)| {
-                child = child.padded(Sides::splat(padding));
+            .map(|(i, child)| {
+                let mut child = child.pack().padded(Sides::splat(padding));
 
                 if let Some(stroke) = stroke {
                     child = child.stroked(stroke);
diff --git a/src/library/text.rs b/src/library/text.rs
index 721a8eac6..a67fbcf59 100644
--- a/src/library/text.rs
+++ b/src/library/text.rs
@@ -123,8 +123,10 @@ impl StrongNode {
 }
 
 impl Show for StrongNode {
-    fn show(&self, _: &mut Vm, _: StyleChain) -> TypResult<Template> {
-        Ok(self.0.clone().styled(TextNode::STRONG, true))
+    fn show(&self, vm: &mut Vm, styles: StyleChain) -> TypResult<Template> {
+        Ok(styles
+            .show(self, vm, [Value::Template(self.0.clone())])?
+            .unwrap_or_else(|| self.0.clone().styled(TextNode::STRONG, true)))
     }
 }
 
@@ -140,8 +142,10 @@ impl EmphNode {
 }
 
 impl Show for EmphNode {
-    fn show(&self, _: &mut Vm, _: StyleChain) -> TypResult<Template> {
-        Ok(self.0.clone().styled(TextNode::EMPH, true))
+    fn show(&self, vm: &mut Vm, styles: StyleChain) -> TypResult<Template> {
+        Ok(styles
+            .show(self, vm, [Value::Template(self.0.clone())])?
+            .unwrap_or_else(|| self.0.clone().styled(TextNode::EMPH, true)))
     }
 }
 
diff --git a/src/parse/mod.rs b/src/parse/mod.rs
index fbace15b1..c14c45cf2 100644
--- a/src/parse/mod.rs
+++ b/src/parse/mod.rs
@@ -752,9 +752,20 @@ fn set_expr(p: &mut Parser) -> ParseResult {
 fn show_expr(p: &mut Parser) -> ParseResult {
     p.perform(NodeKind::ShowExpr, |p| {
         p.eat_assert(&NodeKind::Show);
-        expr(p)?;
-        p.eat_expect(&NodeKind::As)?;
-        expr(p)
+        ident(p)?;
+        if !p.at(&NodeKind::LeftParen) {
+            p.expected_found("parameter list");
+            return Err(ParseError);
+        }
+        p.perform(NodeKind::Closure, |p| {
+            let marker = p.marker();
+            p.start_group(Group::Paren);
+            collection(p);
+            p.end_group();
+            params(p, marker);
+            p.eat_expect(&NodeKind::As)?;
+            expr(p)
+        })
     })
 }
 
diff --git a/src/syntax/ast.rs b/src/syntax/ast.rs
index 8b88096a5..9d22121b9 100644
--- a/src/syntax/ast.rs
+++ b/src/syntax/ast.rs
@@ -919,14 +919,14 @@ node! {
 }
 
 impl ShowExpr {
-    /// The pattern that decides which node's appearence to redefine.
-    pub fn pattern(&self) -> Expr {
-        self.0.cast_first_child().expect("show expression is missing pattern")
+    /// The class to set the show rule for.
+    pub fn class(&self) -> Ident {
+        self.0.cast_first_child().expect("show expression is missing class")
     }
 
-    /// The expression that defines the node's appearence.
-    pub fn body(&self) -> Expr {
-        self.0.cast_last_child().expect("show expression is missing body")
+    /// The closure that defines the rule.
+    pub fn closure(&self) -> ClosureExpr {
+        self.0.cast_first_child().expect("show expression is missing closure")
     }
 }
 
diff --git a/src/syntax/highlight.rs b/src/syntax/highlight.rs
index b806b4e43..af6fb0dfb 100644
--- a/src/syntax/highlight.rs
+++ b/src/syntax/highlight.rs
@@ -181,6 +181,7 @@ impl Category {
                 }
                 NodeKind::WithExpr => Some(Category::Function),
                 NodeKind::SetExpr => Some(Category::Function),
+                NodeKind::ShowExpr => Some(Category::Function),
                 NodeKind::Call => Some(Category::Function),
                 _ => Some(Category::Variable),
             },
diff --git a/src/syntax/mod.rs b/src/syntax/mod.rs
index c0de081dc..c702199e6 100644
--- a/src/syntax/mod.rs
+++ b/src/syntax/mod.rs
@@ -2,7 +2,6 @@
 
 pub mod ast;
 mod highlight;
-mod pretty;
 mod span;
 
 use std::fmt::{self, Debug, Display, Formatter};
@@ -11,7 +10,6 @@ use std::ops::Range;
 use std::sync::Arc;
 
 pub use highlight::*;
-pub use pretty::*;
 pub use span::*;
 
 use self::ast::{MathNode, RawNode, TypedNode};
diff --git a/src/syntax/pretty.rs b/src/syntax/pretty.rs
deleted file mode 100644
index 07ab979b5..000000000
--- a/src/syntax/pretty.rs
+++ /dev/null
@@ -1,730 +0,0 @@
-//! Pretty printing.
-
-use std::fmt::{self, Arguments, Write};
-
-use super::ast::*;
-
-/// Pretty print an item and return the resulting string.
-pub fn pretty<T>(item: &T) -> String
-where
-    T: Pretty + ?Sized,
-{
-    let mut p = Printer::new();
-    item.pretty(&mut p);
-    p.finish()
-}
-
-/// Pretty print an item.
-pub trait Pretty {
-    /// Pretty print this item into the given printer.
-    fn pretty(&self, p: &mut Printer);
-}
-
-/// A buffer into which items can be pretty printed.
-#[derive(Default)]
-pub struct Printer {
-    buf: String,
-}
-
-impl Printer {
-    /// Create a new pretty printer.
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// Push a character into the buffer.
-    pub fn push(&mut self, c: char) {
-        self.buf.push(c);
-    }
-
-    /// Push a string into the buffer.
-    pub fn push_str(&mut self, string: &str) {
-        self.buf.push_str(string);
-    }
-
-    /// Write formatted items into the buffer.
-    pub fn write_fmt(&mut self, fmt: Arguments<'_>) -> fmt::Result {
-        Write::write_fmt(self, fmt)
-    }
-
-    /// Write a list of items joined by a joiner and return how many there were.
-    pub fn join<T, I, F>(&mut self, items: I, joiner: &str, mut write_item: F) -> usize
-    where
-        I: IntoIterator<Item = T>,
-        F: FnMut(T, &mut Self),
-    {
-        let mut count = 0;
-        let mut iter = items.into_iter();
-        if let Some(first) = iter.next() {
-            write_item(first, self);
-            count += 1;
-        }
-        for item in iter {
-            self.push_str(joiner);
-            write_item(item, self);
-            count += 1;
-        }
-        count
-    }
-
-    /// Finish pretty printing and return the underlying buffer.
-    pub fn finish(self) -> String {
-        self.buf
-    }
-}
-
-impl Write for Printer {
-    fn write_str(&mut self, s: &str) -> fmt::Result {
-        self.push_str(s);
-        Ok(())
-    }
-}
-
-impl Pretty for Markup {
-    fn pretty(&self, p: &mut Printer) {
-        for node in self.nodes() {
-            node.pretty(p);
-        }
-    }
-}
-
-impl Pretty for MarkupNode {
-    fn pretty(&self, p: &mut Printer) {
-        match self {
-            // TODO: Handle escaping.
-            Self::Space => p.push(' '),
-            Self::Linebreak => p.push_str(r"\"),
-            Self::Parbreak => p.push_str("\n\n"),
-            Self::Strong(strong) => strong.pretty(p),
-            Self::Emph(emph) => emph.pretty(p),
-            Self::Text(text) => p.push_str(text),
-            Self::Raw(raw) => raw.pretty(p),
-            Self::Math(math) => math.pretty(p),
-            Self::Heading(heading) => heading.pretty(p),
-            Self::List(list) => list.pretty(p),
-            Self::Enum(enum_) => enum_.pretty(p),
-            Self::Expr(expr) => {
-                if expr.has_short_form() {
-                    p.push('#');
-                }
-                expr.pretty(p);
-            }
-        }
-    }
-}
-
-impl Pretty for StrongNode {
-    fn pretty(&self, p: &mut Printer) {
-        p.push('*');
-        self.body().pretty(p);
-        p.push('*');
-    }
-}
-
-impl Pretty for EmphNode {
-    fn pretty(&self, p: &mut Printer) {
-        p.push('_');
-        self.body().pretty(p);
-        p.push('_');
-    }
-}
-
-impl Pretty for RawNode {
-    fn pretty(&self, p: &mut Printer) {
-        // Find out how many backticks we need.
-        let mut backticks = 1;
-
-        // Language tag and block-level are only possible with 3+ backticks.
-        if self.lang.is_some() || self.block {
-            backticks = 3;
-        }
-
-        // More backticks may be required if there are lots of consecutive
-        // backticks.
-        let mut count = 0;
-        for c in self.text.chars() {
-            if c == '`' {
-                count += 1;
-                backticks = backticks.max(3).max(count + 1);
-            } else {
-                count = 0;
-            }
-        }
-
-        // Starting backticks.
-        for _ in 0 .. backticks {
-            p.push('`');
-        }
-
-        // Language tag.
-        if let Some(lang) = &self.lang {
-            p.push_str(lang);
-        }
-
-        // Start untrimming.
-        if self.block {
-            p.push('\n');
-        } else if backticks >= 3 {
-            p.push(' ');
-        }
-
-        // The lines.
-        p.push_str(&self.text);
-
-        // End untrimming.
-        if self.block {
-            p.push('\n');
-        } else if self.text.trim_end().ends_with('`') {
-            p.push(' ');
-        }
-
-        // Ending backticks.
-        for _ in 0 .. backticks {
-            p.push('`');
-        }
-    }
-}
-
-impl Pretty for MathNode {
-    fn pretty(&self, p: &mut Printer) {
-        p.push('$');
-        if self.display {
-            p.push('[');
-        }
-        p.push_str(&self.formula);
-        if self.display {
-            p.push(']');
-        }
-        p.push('$');
-    }
-}
-
-impl Pretty for HeadingNode {
-    fn pretty(&self, p: &mut Printer) {
-        for _ in 0 .. self.level() {
-            p.push('=');
-        }
-        p.push(' ');
-        self.body().pretty(p);
-    }
-}
-
-impl Pretty for ListNode {
-    fn pretty(&self, p: &mut Printer) {
-        p.push_str("- ");
-        self.body().pretty(p);
-    }
-}
-
-impl Pretty for EnumNode {
-    fn pretty(&self, p: &mut Printer) {
-        if let Some(number) = self.number() {
-            write!(p, "{}", number).unwrap();
-        }
-        p.push_str(". ");
-        self.body().pretty(p);
-    }
-}
-
-impl Pretty for Expr {
-    fn pretty(&self, p: &mut Printer) {
-        match self {
-            Self::Lit(v) => v.pretty(p),
-            Self::Ident(v) => v.pretty(p),
-            Self::Array(v) => v.pretty(p),
-            Self::Dict(v) => v.pretty(p),
-            Self::Template(v) => v.pretty(p),
-            Self::Group(v) => v.pretty(p),
-            Self::Block(v) => v.pretty(p),
-            Self::Unary(v) => v.pretty(p),
-            Self::Binary(v) => v.pretty(p),
-            Self::Call(v) => v.pretty(p),
-            Self::Closure(v) => v.pretty(p),
-            Self::With(v) => v.pretty(p),
-            Self::Let(v) => v.pretty(p),
-            Self::Set(v) => v.pretty(p),
-            Self::Show(v) => v.pretty(p),
-            Self::Wrap(v) => v.pretty(p),
-            Self::If(v) => v.pretty(p),
-            Self::While(v) => v.pretty(p),
-            Self::For(v) => v.pretty(p),
-            Self::Import(v) => v.pretty(p),
-            Self::Include(v) => v.pretty(p),
-            Self::Break(v) => v.pretty(p),
-            Self::Continue(v) => v.pretty(p),
-            Self::Return(v) => v.pretty(p),
-        }
-    }
-}
-
-impl Pretty for Lit {
-    fn pretty(&self, p: &mut Printer) {
-        match self.kind() {
-            LitKind::None => p.push_str("none"),
-            LitKind::Auto => p.push_str("auto"),
-            LitKind::Bool(v) => write!(p, "{}", v).unwrap(),
-            LitKind::Int(v) => write!(p, "{}", v).unwrap(),
-            LitKind::Float(v) => write!(p, "{}", v).unwrap(),
-            LitKind::Length(v, u) => write!(p, "{}{:?}", v, u).unwrap(),
-            LitKind::Angle(v, u) => write!(p, "{}{:?}", v, u).unwrap(),
-            LitKind::Percent(v) => write!(p, "{}%", v).unwrap(),
-            LitKind::Fractional(v) => write!(p, "{}fr", v).unwrap(),
-            LitKind::Str(v) => write!(p, "{:?}", v).unwrap(),
-        }
-    }
-}
-
-impl Pretty for ArrayExpr {
-    fn pretty(&self, p: &mut Printer) {
-        p.push('(');
-
-        let items = self.items();
-        let len = p.join(items, ", ", |item, p| item.pretty(p));
-        if len == 1 {
-            p.push(',');
-        }
-        p.push(')');
-    }
-}
-
-impl Pretty for DictExpr {
-    fn pretty(&self, p: &mut Printer) {
-        p.push('(');
-        let len = p.join(self.items(), ", ", |named, p| named.pretty(p));
-        if len == 0 {
-            p.push(':');
-        }
-        p.push(')');
-    }
-}
-
-impl Pretty for Named {
-    fn pretty(&self, p: &mut Printer) {
-        self.name().pretty(p);
-        p.push_str(": ");
-        self.expr().pretty(p);
-    }
-}
-
-impl Pretty for TemplateExpr {
-    fn pretty(&self, p: &mut Printer) {
-        p.push('[');
-        self.body().pretty(p);
-        p.push(']');
-    }
-}
-
-impl Pretty for GroupExpr {
-    fn pretty(&self, p: &mut Printer) {
-        p.push('(');
-        self.expr().pretty(p);
-        p.push(')');
-    }
-}
-
-impl Pretty for BlockExpr {
-    fn pretty(&self, p: &mut Printer) {
-        p.push('{');
-        if self.exprs().count() > 1 {
-            p.push(' ');
-        }
-        let len = p.join(self.exprs(), "; ", |expr, p| expr.pretty(p));
-        if len > 1 {
-            p.push(' ');
-        }
-        p.push('}');
-    }
-}
-
-impl Pretty for UnaryExpr {
-    fn pretty(&self, p: &mut Printer) {
-        let op = self.op();
-        op.pretty(p);
-        if op == UnOp::Not {
-            p.push(' ');
-        }
-        self.expr().pretty(p);
-    }
-}
-
-impl Pretty for UnOp {
-    fn pretty(&self, p: &mut Printer) {
-        p.push_str(self.as_str());
-    }
-}
-
-impl Pretty for BinaryExpr {
-    fn pretty(&self, p: &mut Printer) {
-        self.lhs().pretty(p);
-        p.push(' ');
-        self.op().pretty(p);
-        p.push(' ');
-        self.rhs().pretty(p);
-    }
-}
-
-impl Pretty for BinOp {
-    fn pretty(&self, p: &mut Printer) {
-        p.push_str(self.as_str());
-    }
-}
-
-impl Pretty for CallExpr {
-    fn pretty(&self, p: &mut Printer) {
-        self.callee().pretty(p);
-
-        let mut write_args = |items: &[CallArg]| {
-            p.push('(');
-            p.join(items, ", ", |item, p| item.pretty(p));
-            p.push(')');
-        };
-
-        let args: Vec<_> = self.args().items().collect();
-        match args.as_slice() {
-            // This can be moved behind the arguments.
-            //
-            // Example: Transforms "#v(a, [b])" => "#v(a)[b]".
-            [head @ .., CallArg::Pos(Expr::Template(template))] => {
-                if !head.is_empty() {
-                    write_args(head);
-                }
-                template.pretty(p);
-            }
-            items => write_args(items),
-        }
-    }
-}
-
-impl Pretty for CallArgs {
-    fn pretty(&self, p: &mut Printer) {
-        p.join(self.items(), ", ", |item, p| item.pretty(p));
-    }
-}
-
-impl Pretty for CallArg {
-    fn pretty(&self, p: &mut Printer) {
-        match self {
-            Self::Pos(expr) => expr.pretty(p),
-            Self::Named(named) => named.pretty(p),
-            Self::Spread(expr) => {
-                p.push_str("..");
-                expr.pretty(p);
-            }
-        }
-    }
-}
-
-impl Pretty for ClosureExpr {
-    fn pretty(&self, p: &mut Printer) {
-        let params: Vec<_> = self.params().collect();
-        if let [param] = params.as_slice() {
-            param.pretty(p);
-        } else {
-            p.push('(');
-            p.join(params.iter(), ", ", |item, p| item.pretty(p));
-            p.push(')');
-        }
-        p.push_str(" => ");
-        self.body().pretty(p);
-    }
-}
-
-impl Pretty for ClosureParam {
-    fn pretty(&self, p: &mut Printer) {
-        match self {
-            Self::Pos(ident) => ident.pretty(p),
-            Self::Named(named) => named.pretty(p),
-            Self::Sink(ident) => {
-                p.push_str("..");
-                ident.pretty(p);
-            }
-        }
-    }
-}
-
-impl Pretty for WithExpr {
-    fn pretty(&self, p: &mut Printer) {
-        self.callee().pretty(p);
-        p.push_str(" with (");
-        self.args().pretty(p);
-        p.push(')');
-    }
-}
-
-impl Pretty for LetExpr {
-    fn pretty(&self, p: &mut Printer) {
-        p.push_str("let ");
-        self.binding().pretty(p);
-        if let Some(Expr::Closure(closure)) = self.init() {
-            p.push('(');
-            p.join(closure.params(), ", ", |item, p| item.pretty(p));
-            p.push_str(") = ");
-            closure.body().pretty(p);
-        } else if let Some(init) = self.init() {
-            p.push_str(" = ");
-            init.pretty(p);
-        }
-    }
-}
-
-impl Pretty for SetExpr {
-    fn pretty(&self, p: &mut Printer) {
-        p.push_str("set ");
-        self.class().pretty(p);
-        p.push_str("(");
-        self.args().pretty(p);
-        p.push(')');
-    }
-}
-
-impl Pretty for ShowExpr {
-    fn pretty(&self, p: &mut Printer) {
-        p.push_str("show ");
-        self.pattern().pretty(p);
-        p.push_str(" as ");
-        self.body().pretty(p);
-    }
-}
-
-impl Pretty for WrapExpr {
-    fn pretty(&self, p: &mut Printer) {
-        p.push_str("wrap ");
-        self.binding().pretty(p);
-        p.push_str(" in ");
-        self.body().pretty(p);
-    }
-}
-
-impl Pretty for IfExpr {
-    fn pretty(&self, p: &mut Printer) {
-        p.push_str("if ");
-        self.condition().pretty(p);
-        p.push(' ');
-        self.if_body().pretty(p);
-        if let Some(expr) = self.else_body() {
-            p.push_str(" else ");
-            expr.pretty(p);
-        }
-    }
-}
-
-impl Pretty for WhileExpr {
-    fn pretty(&self, p: &mut Printer) {
-        p.push_str("while ");
-        self.condition().pretty(p);
-        p.push(' ');
-        self.body().pretty(p);
-    }
-}
-
-impl Pretty for ForExpr {
-    fn pretty(&self, p: &mut Printer) {
-        p.push_str("for ");
-        self.pattern().pretty(p);
-        p.push_str(" in ");
-        self.iter().pretty(p);
-        p.push(' ');
-        self.body().pretty(p);
-    }
-}
-
-impl Pretty for ForPattern {
-    fn pretty(&self, p: &mut Printer) {
-        if let Some(key) = self.key() {
-            key.pretty(p);
-            p.push_str(", ");
-        }
-
-        self.value().pretty(p);
-    }
-}
-
-impl Pretty for ImportExpr {
-    fn pretty(&self, p: &mut Printer) {
-        p.push_str("import ");
-        self.imports().pretty(p);
-        p.push_str(" from ");
-        self.path().pretty(p);
-    }
-}
-
-impl Pretty for Imports {
-    fn pretty(&self, p: &mut Printer) {
-        match self {
-            Self::Wildcard => p.push('*'),
-            Self::Items(idents) => {
-                p.join(idents, ", ", |item, p| item.pretty(p));
-            }
-        }
-    }
-}
-
-impl Pretty for IncludeExpr {
-    fn pretty(&self, p: &mut Printer) {
-        p.push_str("include ");
-        self.path().pretty(p);
-    }
-}
-
-impl Pretty for BreakExpr {
-    fn pretty(&self, p: &mut Printer) {
-        p.push_str("break");
-    }
-}
-
-impl Pretty for ContinueExpr {
-    fn pretty(&self, p: &mut Printer) {
-        p.push_str("continue");
-    }
-}
-
-impl Pretty for ReturnExpr {
-    fn pretty(&self, p: &mut Printer) {
-        p.push_str("return");
-        if let Some(body) = self.body() {
-            p.push(' ');
-            body.pretty(p);
-        }
-    }
-}
-
-impl Pretty for Ident {
-    fn pretty(&self, p: &mut Printer) {
-        p.push_str(self);
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::source::SourceFile;
-
-    #[track_caller]
-    fn roundtrip(src: &str) {
-        test_parse(src, src);
-    }
-
-    #[track_caller]
-    fn test_parse(src: &str, expected: &str) {
-        let source = SourceFile::detached(src);
-        let ast = source.ast().unwrap();
-        let found = pretty(&ast);
-        if found != expected {
-            println!("tree:     {ast:#?}");
-            println!("expected: {expected}");
-            println!("found:    {found}");
-            panic!("test failed");
-        }
-    }
-
-    #[test]
-    fn test_pretty_print_markup() {
-        // Basic stuff.
-        roundtrip(" ");
-        roundtrip("*ab*");
-        roundtrip("\\ ");
-        roundtrip("\n\n");
-        roundtrip("hi");
-        roundtrip("_ab_");
-        roundtrip("= *Ok*");
-        roundtrip("- Ok");
-
-        // Raw node.
-        roundtrip("``");
-        roundtrip("`nolang 1`");
-        roundtrip("```lang 1```");
-        roundtrip("```lang 1 ```");
-        roundtrip("```hi  line  ```");
-        roundtrip("```py\ndef\n```");
-        roundtrip("```\n line \n```");
-        roundtrip("```\n`\n```");
-        roundtrip("``` ` ```");
-        roundtrip("````\n```\n```\n````");
-        test_parse("```lang```", "```lang ```");
-        test_parse("```1 ```", "``");
-        test_parse("``` 1```", "`1`");
-        test_parse("``` 1 ```", "`1 `");
-        test_parse("```` ` ````", "``` ` ```");
-
-        // Math node.
-        roundtrip("$$");
-        roundtrip("$a+b$");
-        roundtrip("$[ a^2 + b^2 = c^2 ]$");
-    }
-
-    #[test]
-    fn test_pretty_print_expr() {
-        // Basic expressions.
-        roundtrip("{none}");
-        roundtrip("{auto}");
-        roundtrip("{true}");
-        roundtrip("{10}");
-        roundtrip("{3.14}");
-        roundtrip("{10pt}");
-        roundtrip("{14.1deg}");
-        roundtrip("{20%}");
-        roundtrip("{0.5fr}");
-        roundtrip(r#"{"hi"}"#);
-        roundtrip(r#"{"let's \" go"}"#);
-        roundtrip("{hi}");
-
-        // Arrays.
-        roundtrip("{()}");
-        roundtrip("{(1)}");
-        roundtrip("{(1, 2, 3)}");
-
-        // Dictionaries.
-        roundtrip("{(:)}");
-        roundtrip("{(key: value)}");
-        roundtrip("{(a: 1, b: 2)}");
-
-        // Templates.
-        roundtrip("[]");
-        roundtrip("[*Ok*]");
-        roundtrip("{[f]}");
-
-        // Groups.
-        roundtrip("{(1)}");
-
-        // Blocks.
-        roundtrip("{}");
-        roundtrip("{1}");
-        roundtrip("{ let x = 1; x += 2; x + 1 }");
-        roundtrip("[{}]");
-
-        // Operators.
-        roundtrip("{-x}");
-        roundtrip("{not true}");
-        roundtrip("{1 + 3}");
-
-        // Functions.
-        roundtrip("{v()}");
-        roundtrip("{v()()}");
-        roundtrip("{v(1)}");
-        roundtrip("{v(a: 1, b)}");
-        roundtrip("#v()");
-        roundtrip("#v(1)");
-        roundtrip("#v(1, 2)[*Ok*]");
-        roundtrip("#v(1, f[2])");
-        roundtrip("{x => x + 1}");
-        roundtrip("{(a, b) => a + b}");
-
-        // Control flow.
-        roundtrip("#let x = 1 + 2");
-        roundtrip("#let f(x) = y");
-        roundtrip("#set text(size: 12pt)");
-        roundtrip("#show heading(body) as [*{body}*]");
-        roundtrip("#wrap body in columns(2, body)");
-        roundtrip("#if x [y] else [z]");
-        roundtrip("#if x {} else if y {} else {}");
-        roundtrip("#while x {y}");
-        roundtrip("#for x in y {z}");
-        roundtrip("#for k, x in y {z}");
-        roundtrip("#import * from \"file.typ\"");
-        roundtrip("#include \"chapter1.typ\"");
-        roundtrip("{break}");
-        roundtrip("{continue}");
-        roundtrip("{return}");
-        roundtrip("{return x + 1}");
-    }
-}
diff --git a/tests/ref/style/show.png b/tests/ref/style/show.png
new file mode 100644
index 0000000000000000000000000000000000000000..0f1a16a32e4ea6a50f10b5cc05cf6c4ac02ae835
GIT binary patch
literal 19940
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

literal 0
HcmV?d00001

diff --git a/tests/typ/style/set.typ b/tests/typ/style/set.typ
index 0d4d47cc0..6ce1d303e 100644
--- a/tests/typ/style/set.typ
+++ b/tests/typ/style/set.typ
@@ -1,5 +1,5 @@
 // General tests for set.
 
 ---
-// Error: 2-10 set is only allowed directly in markup
+// Error: 2-10 set, show and wrap are only allowed directly in markup
 {set f(x)}
diff --git a/tests/typ/style/show.typ b/tests/typ/style/show.typ
index 533e50f54..1055f9c76 100644
--- a/tests/typ/style/show.typ
+++ b/tests/typ/style/show.typ
@@ -1,9 +1,53 @@
 // Test show rules.
 
----
-// Error: 1-34 show rules are not yet implemented
-#show heading(body) as [*{body}*]
+#set page("a8", footer: p => v(-5pt) + align(right, [#p]))
+
+#let i = 1
+#set heading(size: 100%)
+#show heading(level, body) as {
+  if level == 1 {
+    v(10pt)
+    underline(text(150%, blue)[{i}. #body])
+    i += 1
+  } else {
+    text(red, body)
+  }
+}
+
+#v(-10pt)
+
+= Aufgabe
+Some text.
+
+== Subtask
+Some more text.
+
+== Another subtask
+Some more text.
+
+= Aufgabe
+Another text.
 
 ---
-// Error: 2-15 show is only allowed directly in markup
-{show (a) as b}
+#set heading(size: 100%, strong: false, block: false)
+#show heading(a, b) as [B]
+A [= Heading] C
+
+---
+// Error: 1-22 unexpected argument
+#show heading() as []
+= Heading
+
+---
+// Error: 1-28 expected template, found string
+#show heading(_, _) as "hi"
+= Heading
+
+---
+// Error: 1-29 show rule is recursive
+#show strong(x) as strong(x)
+*Hi*
+
+---
+// Error: 2-19 set, show and wrap are only allowed directly in markup
+{show list(a) as b}
diff --git a/tests/typ/style/wrap.typ b/tests/typ/style/wrap.typ
index 2fa7716e4..9c94b9aea 100644
--- a/tests/typ/style/wrap.typ
+++ b/tests/typ/style/wrap.typ
@@ -25,5 +25,5 @@ A [_B #wrap c in [*#c*]; C_] D
 Forest
 
 ---
-// Error: 6-17 wrap is only allowed directly in markup
+// Error: 6-17 set, show and wrap are only allowed directly in markup
 {1 + wrap x in y}
diff --git a/tests/typeset.rs b/tests/typeset.rs
index dadcfed34..98c85df93 100644
--- a/tests/typeset.rs
+++ b/tests/typeset.rs
@@ -23,7 +23,7 @@ use typst::{Context, Vm};
 use {
     filedescriptor::{FileDescriptor, StdioDescriptor::*},
     std::fs::File,
-    typst::eval::Template,
+    typst::source::SourceId,
 };
 
 const TYP_DIR: &str = "./typ";
@@ -110,7 +110,7 @@ fn main() {
             &png_path,
             &ref_path,
             pdf_path.as_deref(),
-            args.debug,
+            args.syntax,
         ) as usize;
     }
 
@@ -126,7 +126,7 @@ fn main() {
 struct Args {
     filter: Vec<String>,
     exact: bool,
-    debug: bool,
+    syntax: bool,
     pdf: bool,
 }
 
@@ -134,7 +134,7 @@ impl Args {
     fn new(args: impl Iterator<Item = String>) -> Self {
         let mut filter = Vec::new();
         let mut exact = false;
-        let mut debug = false;
+        let mut syntax = false;
         let mut pdf = false;
 
         for arg in args {
@@ -146,13 +146,13 @@ impl Args {
                 // Generate PDFs.
                 "--pdf" => pdf = true,
                 // Debug print the layout trees.
-                "--debug" | "-d" => debug = true,
+                "--syntax" => syntax = true,
                 // Everything else is a file filter.
                 _ => filter.push(arg),
             }
         }
 
-        Self { filter, pdf, debug, exact }
+        Self { filter, pdf, syntax, exact }
     }
 
     fn matches(&self, path: &Path) -> bool {
@@ -172,7 +172,7 @@ fn test(
     png_path: &Path,
     ref_path: &Path,
     pdf_path: Option<&Path>,
-    debug: bool,
+    syntax: bool,
 ) -> bool {
     let name = src_path.strip_prefix(TYP_DIR).unwrap_or(src_path);
     println!("Testing {}", name.display());
@@ -208,7 +208,7 @@ fn test(
                 i,
                 compare_ref,
                 line,
-                debug,
+                syntax,
                 &mut rng,
             );
             ok &= part_ok;
@@ -242,7 +242,7 @@ fn test(
     }
 
     if ok {
-        if !debug {
+        if !syntax {
             print!("\x1b[1A");
         }
         println!("Testing {} ✔", name.display());
@@ -258,14 +258,14 @@ fn test_part(
     i: usize,
     compare_ref: bool,
     line: usize,
-    debug: bool,
+    syntax: bool,
     rng: &mut LinearShift,
 ) -> (bool, bool, Vec<Arc<Frame>>) {
     let mut ok = true;
 
     let id = ctx.sources.provide(src_path, src);
     let source = ctx.sources.get(id);
-    if debug {
+    if syntax {
         println!("Syntax Tree: {:#?}", source.root())
     }
 
@@ -277,13 +277,8 @@ fn test_part(
     let mut vm = Vm::new(ctx);
     let (frames, mut errors) = match vm.typeset(id) {
         Ok(mut frames) => {
-            let module = vm.evaluate(id).unwrap();
-            if debug {
-                println!("Template: {:#?}", module.template);
-            }
-
             #[cfg(feature = "layout-cache")]
-            (ok &= test_incremental(ctx, i, &module.template, &frames));
+            (ok &= test_incremental(ctx, i, id, &frames));
 
             if !compare_ref {
                 frames.clear();
@@ -483,7 +478,7 @@ fn test_reparse(src: &str, i: usize, rng: &mut LinearShift) -> bool {
 fn test_incremental(
     ctx: &mut Context,
     i: usize,
-    template: &Template,
+    id: SourceId,
     frames: &[Arc<Frame>],
 ) -> bool {
     let mut ok = true;
@@ -498,7 +493,7 @@ fn test_incremental(
 
         ctx.layout_cache.turnaround();
 
-        let cached = silenced(|| template.layout_pages(&mut Vm::new(ctx)).unwrap());
+        let cached = silenced(|| ctx.typeset(id).unwrap());
         let total = reference.levels() - 1;
         let misses = ctx
             .layout_cache