Fatal errors

- Makes errors fatal, so that a phase is only reached when all previous phases were error-free
- Parsing still recovers and can produce multiple errors
- Evaluation fails fast and can thus produce only a single error (except for parse errors due to an import)
- The single error that could occur during execution is removed for now
- Removes Value::Error variant

6 files changed, 405 insertions, 444 deletions

diff --git a/src/eval/function.rs b/src/eval/function.rs
index ca447a48..b9a168d2 100644
--- a/src/eval/function.rs
+++ b/src/eval/function.rs
@@ -3,8 +3,10 @@ use std::ops::Deref;
 use std::rc::Rc;
 
 use super::{Cast, EvalContext, Value};
-use crate::util::EcoString;
+use crate::diag::{Error, TypResult};
+use crate::loading::FileId;
 use crate::syntax::{Span, Spanned};
+use crate::util::EcoString;
 
 /// An evaluatable function.
 #[derive(Clone)]
@@ -16,13 +18,13 @@ struct Repr<T: ?Sized> {
     func: T,
 }
 
-type Func = dyn Fn(&mut EvalContext, &mut FuncArgs) -> Value;
+type Func = dyn Fn(&mut EvalContext, &mut FuncArgs) -> TypResult<Value>;
 
 impl Function {
     /// Create a new function from a rust closure.
     pub fn new<F>(name: Option<EcoString>, func: F) -> Self
     where
-        F: Fn(&mut EvalContext, &mut FuncArgs) -> Value + 'static,
+        F: Fn(&mut EvalContext, &mut FuncArgs) -> TypResult<Value> + 'static,
     {
         Self(Rc::new(Repr { name, func }))
     }
@@ -57,6 +59,8 @@ impl PartialEq for Function {
 /// Evaluated arguments to a function.
 #[derive(Debug, Clone, PartialEq)]
 pub struct FuncArgs {
+    /// The file in which the function was called.
+    pub file: FileId,
     /// The span of the whole argument list.
     pub span: Span,
     /// The positional arguments.
@@ -80,32 +84,30 @@ impl FuncArgs {
     where
         T: Cast<Spanned<Value>>,
     {
-        (0 .. self.items.len()).find_map(|index| {
-            let slot = self.items.get_mut(index)?;
+        for (i, slot) in self.items.iter().enumerate() {
             if slot.name.is_none() {
                 if T::is(&slot.value) {
-                    let value = self.items.remove(index).value;
+                    let value = self.items.remove(i).value;
                     return T::cast(value).ok();
                 }
             }
-            None
-        })
+        }
+        None
     }
 
-    /// Find and consume the first castable positional argument, producing a
+    /// Find and consume the first castable positional argument, returning a
     /// `missing argument: {what}` error if no match was found.
-    pub fn expect<T>(&mut self, ctx: &mut EvalContext, what: &str) -> Option<T>
+    pub fn expect<T>(&mut self, what: &str) -> TypResult<T>
     where
         T: Cast<Spanned<Value>>,
     {
-        let found = self.eat();
-        if found.is_none() {
-            ctx.diag(error!(self.span, "missing argument: {}", what));
+        match self.eat() {
+            Some(found) => Ok(found),
+            None => bail!(self.file, self.span, "missing argument: {}", what),
         }
-        found
     }
 
-    /// Find, consume and collect all castable positional arguments.
+    /// Find and consume all castable positional arguments.
     pub fn all<T>(&mut self) -> impl Iterator<Item = T> + '_
     where
         T: Cast<Spanned<Value>>,
@@ -113,35 +115,34 @@ impl FuncArgs {
         std::iter::from_fn(move || self.eat())
     }
 
-    /// Cast and remove the value for the given named argument, producing an
+    /// Cast and remove the value for the given named argument, returning an
     /// error if the conversion fails.
-    pub fn named<T>(&mut self, ctx: &mut EvalContext, name: &str) -> Option<T>
+    pub fn named<T>(&mut self, name: &str) -> TypResult<Option<T>>
     where
         T: Cast<Spanned<Value>>,
     {
-        let index = self
+        let index = match self
             .items
             .iter()
-            .position(|arg| arg.name.as_ref().map_or(false, |other| other == name))?;
+            .filter_map(|arg| arg.name.as_deref())
+            .position(|other| name == other)
+        {
+            Some(index) => index,
+            None => return Ok(None),
+        };
 
         let value = self.items.remove(index).value;
         let span = value.span;
 
-        match T::cast(value) {
-            Ok(t) => Some(t),
-            Err(msg) => {
-                ctx.diag(error!(span, "{}", msg));
-                None
-            }
-        }
+        T::cast(value).map(Some).map_err(Error::partial(self.file, span))
     }
 
-    /// Produce "unexpected argument" errors for all remaining arguments.
-    pub fn finish(self, ctx: &mut EvalContext) {
-        for arg in &self.items {
-            if arg.value.v != Value::Error {
-                ctx.diag(error!(arg.span, "unexpected argument"));
-            }
+    /// Return an "unexpected argument" error if there is any remaining
+    /// argument.
+    pub fn finish(self) -> TypResult<()> {
+        if let Some(arg) = self.items.first() {
+            bail!(self.file, arg.span, "unexpected argument");
         }
+        Ok(())
     }
 }
diff --git a/src/eval/mod.rs b/src/eval/mod.rs
index 682a3855..decd4281 100644
--- a/src/eval/mod.rs
+++ b/src/eval/mod.rs
@@ -25,22 +25,21 @@ use std::mem;
 use std::path::Path;
 use std::rc::Rc;
 
-use crate::diag::{Diag, DiagSet, Pass};
-use crate::util::EcoString;
+use crate::diag::{Error, StrResult, TypResult};
 use crate::geom::{Angle, Fractional, Length, Relative};
 use crate::image::ImageCache;
 use crate::loading::{FileId, Loader};
 use crate::parse::parse;
 use crate::syntax::visit::Visit;
 use crate::syntax::*;
+use crate::util::EcoString;
 use crate::Context;
 
 /// Evaluate a parsed source file into a module.
-pub fn eval(ctx: &mut Context, file: FileId, ast: Rc<SyntaxTree>) -> Pass<Module> {
+pub fn eval(ctx: &mut Context, file: FileId, ast: Rc<SyntaxTree>) -> TypResult<Module> {
     let mut ctx = EvalContext::new(ctx, file);
-    let template = ast.eval(&mut ctx);
-    let module = Module { scope: ctx.scopes.top, template };
-    Pass::new(module, ctx.diags)
+    let template = ast.eval(&mut ctx)?;
+    Ok(Module { scope: ctx.scopes.top, template })
 }
 
 /// Caches evaluated modules.
@@ -61,7 +60,7 @@ pub trait Eval {
     type Output;
 
     /// Evaluate the expression to the output value.
-    fn eval(&self, ctx: &mut EvalContext) -> Self::Output;
+    fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output>;
 }
 
 /// The context for evaluation.
@@ -74,10 +73,12 @@ pub struct EvalContext<'a> {
     pub modules: &'a mut ModuleCache,
     /// The active scopes.
     pub scopes: Scopes<'a>,
-    /// Evaluation diagnostics.
-    pub diags: DiagSet,
+    /// The currently evaluated file.
+    pub file: FileId,
     /// The stack of imported files that led to evaluation of the current file.
     pub route: Vec<FileId>,
+    /// The expression map for the currently built template.
+    pub map: ExprMap,
 }
 
 impl<'a> EvalContext<'a> {
@@ -88,141 +89,123 @@ impl<'a> EvalContext<'a> {
             images: &mut ctx.images,
             modules: &mut ctx.modules,
             scopes: Scopes::new(Some(&ctx.std)),
-            diags: DiagSet::new(),
-            route: vec![file],
+            file,
+            route: vec![],
+            map: ExprMap::new(),
         }
     }
 
     /// Resolve a path relative to the current file.
     ///
-    /// Generates an error if the file is not found.
-    pub fn resolve(&mut self, path: &str, span: Span) -> Option<FileId> {
-        let base = *self.route.last()?;
-        self.loader.resolve_from(base, Path::new(path)).ok().or_else(|| {
-            self.diag(error!(span, "file not found"));
-            None
-        })
+    /// Returns an error if the file is not found.
+    pub fn resolve(&mut self, path: &str, span: Span) -> TypResult<FileId> {
+        self.loader
+            .resolve_from(self.file, Path::new(path))
+            .map_err(|_| Error::boxed(self.file, span, "file not found"))
     }
 
     /// Process an import of a module relative to the current location.
-    pub fn import(&mut self, path: &str, span: Span) -> Option<FileId> {
+    pub fn import(&mut self, path: &str, span: Span) -> TypResult<FileId> {
         let id = self.resolve(path, span)?;
 
         // Prevent cyclic importing.
-        if self.route.contains(&id) {
-            self.diag(error!(span, "cyclic import"));
-            return None;
+        if self.file == id || self.route.contains(&id) {
+            bail!(self.file, span, "cyclic import");
         }
 
         // Check whether the module was already loaded.
         if self.modules.get(&id).is_some() {
-            return Some(id);
+            return Ok(id);
         }
 
-        let buffer = self.loader.load_file(id).ok().or_else(|| {
-            self.diag(error!(span, "failed to load file"));
-            None
-        })?;
+        // Load the source file.
+        let buffer = self
+            .loader
+            .load_file(id)
+            .map_err(|_| Error::boxed(self.file, span, "failed to load file"))?;
 
-        let string = std::str::from_utf8(&buffer).ok().or_else(|| {
-            self.diag(error!(span, "file is not valid utf-8"));
-            None
-        })?;
+        // Decode UTF-8.
+        let string = std::str::from_utf8(&buffer)
+            .map_err(|_| Error::boxed(self.file, span, "file is not valid utf-8"))?;
 
         // Parse the file.
-        let parsed = parse(string);
+        let ast = parse(id, string)?;
 
         // Prepare the new context.
         let new_scopes = Scopes::new(self.scopes.base);
         let old_scopes = mem::replace(&mut self.scopes, new_scopes);
-        let old_diags = mem::replace(&mut self.diags, parsed.diags);
-        self.route.push(id);
+        self.route.push(self.file);
+        self.file = id;
 
         // Evaluate the module.
-        let ast = Rc::new(parsed.output);
-        let template = ast.eval(self);
+        let template = Rc::new(ast).eval(self)?;
 
         // Restore the old context.
         let new_scopes = mem::replace(&mut self.scopes, old_scopes);
-        let new_diags = mem::replace(&mut self.diags, old_diags);
-        self.route.pop();
-
-        // Put all diagnostics from the module on the import.
-        for mut diag in new_diags {
-            diag.span = span;
-            self.diag(diag);
-        }
+        self.file = self.route.pop().unwrap();
 
         // Save the evaluated module.
         let module = Module { scope: new_scopes.top, template };
         self.modules.insert(id, module);
 
-        Some(id)
-    }
-
-    /// Add a diagnostic.
-    pub fn diag(&mut self, diag: Diag) {
-        self.diags.insert(diag);
-    }
-
-    /// Cast a value to a type and diagnose a possible error / warning.
-    pub fn cast<T>(&mut self, value: Value, span: Span) -> Option<T>
-    where
-        T: Cast<Value>,
-    {
-        if value == Value::Error {
-            return None;
-        }
-
-        match T::cast(value) {
-            Ok(value) => Some(value),
-            Err(msg) => {
-                self.diag(error!(span, "{}", msg));
-                None
-            }
-        }
-    }
-
-    /// Join with another value.
-    pub fn join(&mut self, lhs: Value, rhs: Value, span: Span) -> Value {
-        let (a, b) = (lhs.type_name(), rhs.type_name());
-        match ops::join(lhs, rhs) {
-            Ok(joined) => joined,
-            Err(prev) => {
-                self.diag(error!(span, "cannot join {} with {}", a, b));
-                prev
-            }
-        }
+        Ok(id)
     }
 }
 
 impl Eval for Rc<SyntaxTree> {
     type Output = Template;
 
-    fn eval(&self, ctx: &mut EvalContext) -> Self::Output {
-        struct ExprVisitor<'a, 'b> {
-            ctx: &'a mut EvalContext<'b>,
-            map: ExprMap,
+    fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
+        trait Walk {
+            fn walk(&self, ctx: &mut EvalContext) -> TypResult<()>;
         }
 
-        impl<'ast> Visit<'ast> for ExprVisitor<'_, '_> {
-            fn visit_expr(&mut self, node: &'ast Expr) {
-                self.map.insert(node as *const _, node.eval(self.ctx));
+        impl Walk for SyntaxTree {
+            fn walk(&self, ctx: &mut EvalContext) -> TypResult<()> {
+                for node in self.iter() {
+                    node.walk(ctx)?;
+                }
+                Ok(())
             }
         }
 
-        let mut visitor = ExprVisitor { ctx, map: ExprMap::new() };
-        visitor.visit_tree(self);
+        impl Walk for SyntaxNode {
+            fn walk(&self, ctx: &mut EvalContext) -> TypResult<()> {
+                match self {
+                    Self::Text(_) => {}
+                    Self::Space => {}
+                    Self::Linebreak(_) => {}
+                    Self::Parbreak(_) => {}
+                    Self::Strong(_) => {}
+                    Self::Emph(_) => {}
+                    Self::Raw(_) => {}
+                    Self::Heading(n) => n.body.walk(ctx)?,
+                    Self::List(n) => n.body.walk(ctx)?,
+                    Self::Enum(n) => n.body.walk(ctx)?,
+                    Self::Expr(n) => {
+                        let value = n.eval(ctx)?;
+                        ctx.map.insert(n as *const _, value);
+                    }
+                }
+                Ok(())
+            }
+        }
+
+        let map = {
+            let prev = mem::take(&mut ctx.map);
+            self.walk(ctx)?;
+            mem::replace(&mut ctx.map, prev)
+        };
 
-        TemplateTree { tree: Rc::clone(self), map: visitor.map }.into()
+        Ok(TemplateTree { tree: Rc::clone(self), map }.into())
     }
 }
 
 impl Eval for Expr {
     type Output = Value;
 
-    fn eval(&self, ctx: &mut EvalContext) -> Self::Output {
-        match *self {
+    fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
+        Ok(match *self {
             Self::None(_) => Value::None,
             Self::Auto(_) => Value::Auto,
             Self::Bool(_, v) => Value::Bool(v),
@@ -235,35 +218,32 @@ impl Eval for Expr {
             Self::Str(_, ref v) => Value::Str(v.clone()),
             Self::Ident(ref v) => match ctx.scopes.get(&v) {
                 Some(slot) => slot.borrow().clone(),
-                None => {
-                    ctx.diag(error!(v.span, "unknown variable"));
-                    Value::Error
-                }
+                None => bail!(ctx.file, v.span, "unknown variable"),
             },
-            Self::Array(ref v) => Value::Array(v.eval(ctx)),
-            Self::Dict(ref v) => Value::Dict(v.eval(ctx)),
-            Self::Template(ref v) => Value::Template(v.eval(ctx)),
-            Self::Group(ref v) => v.eval(ctx),
-            Self::Block(ref v) => v.eval(ctx),
-            Self::Call(ref v) => v.eval(ctx),
-            Self::Closure(ref v) => v.eval(ctx),
-            Self::With(ref v) => v.eval(ctx),
-            Self::Unary(ref v) => v.eval(ctx),
-            Self::Binary(ref v) => v.eval(ctx),
-            Self::Let(ref v) => v.eval(ctx),
-            Self::If(ref v) => v.eval(ctx),
-            Self::While(ref v) => v.eval(ctx),
-            Self::For(ref v) => v.eval(ctx),
-            Self::Import(ref v) => v.eval(ctx),
-            Self::Include(ref v) => v.eval(ctx),
-        }
+            Self::Array(ref v) => Value::Array(v.eval(ctx)?),
+            Self::Dict(ref v) => Value::Dict(v.eval(ctx)?),
+            Self::Template(ref v) => Value::Template(v.eval(ctx)?),
+            Self::Group(ref v) => v.eval(ctx)?,
+            Self::Block(ref v) => v.eval(ctx)?,
+            Self::Call(ref v) => v.eval(ctx)?,
+            Self::Closure(ref v) => v.eval(ctx)?,
+            Self::With(ref v) => v.eval(ctx)?,
+            Self::Unary(ref v) => v.eval(ctx)?,
+            Self::Binary(ref v) => v.eval(ctx)?,
+            Self::Let(ref v) => v.eval(ctx)?,
+            Self::If(ref v) => v.eval(ctx)?,
+            Self::While(ref v) => v.eval(ctx)?,
+            Self::For(ref v) => v.eval(ctx)?,
+            Self::Import(ref v) => v.eval(ctx)?,
+            Self::Include(ref v) => v.eval(ctx)?,
+        })
     }
 }
 
 impl Eval for ArrayExpr {
     type Output = Array;
 
-    fn eval(&self, ctx: &mut EvalContext) -> Self::Output {
+    fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
         self.items.iter().map(|expr| expr.eval(ctx)).collect()
     }
 }
@@ -271,10 +251,10 @@ impl Eval for ArrayExpr {
 impl Eval for DictExpr {
     type Output = Dict;
 
-    fn eval(&self, ctx: &mut EvalContext) -> Self::Output {
+    fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
         self.items
             .iter()
-            .map(|Named { name, expr }| (name.string.clone(), expr.eval(ctx)))
+            .map(|Named { name, expr }| Ok((name.string.clone(), expr.eval(ctx)?)))
             .collect()
     }
 }
@@ -282,7 +262,7 @@ impl Eval for DictExpr {
 impl Eval for TemplateExpr {
     type Output = Template;
 
-    fn eval(&self, ctx: &mut EvalContext) -> Self::Output {
+    fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
         self.tree.eval(ctx)
     }
 }
@@ -290,7 +270,7 @@ impl Eval for TemplateExpr {
 impl Eval for GroupExpr {
     type Output = Value;
 
-    fn eval(&self, ctx: &mut EvalContext) -> Self::Output {
+    fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
         self.expr.eval(ctx)
     }
 }
@@ -298,58 +278,44 @@ impl Eval for GroupExpr {
 impl Eval for BlockExpr {
     type Output = Value;
 
-    fn eval(&self, ctx: &mut EvalContext) -> Self::Output {
+    fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
         if self.scoping {
             ctx.scopes.enter();
         }
 
         let mut output = Value::None;
         for expr in &self.exprs {
-            let value = expr.eval(ctx);
-            output = ctx.join(output, value, expr.span());
+            let value = expr.eval(ctx)?;
+            output = ops::join(output, value)
+                .map_err(Error::partial(ctx.file, expr.span()))?;
         }
 
         if self.scoping {
             ctx.scopes.exit();
         }
 
-        output
+        Ok(output)
     }
 }
 
 impl Eval for UnaryExpr {
     type Output = Value;
 
-    fn eval(&self, ctx: &mut EvalContext) -> Self::Output {
-        let value = self.expr.eval(ctx);
-        if value == Value::Error {
-            return Value::Error;
-        }
-
-        let ty = value.type_name();
-        let out = match self.op {
+    fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
+        let value = self.expr.eval(ctx)?;
+        let result = match self.op {
             UnOp::Pos => ops::pos(value),
             UnOp::Neg => ops::neg(value),
             UnOp::Not => ops::not(value),
         };
-
-        if out == Value::Error {
-            ctx.diag(error!(
-                self.span,
-                "cannot apply '{}' to {}",
-                self.op.as_str(),
-                ty,
-            ));
-        }
-
-        out
+        result.map_err(Error::partial(ctx.file, self.span))
     }
 }
 
 impl Eval for BinaryExpr {
     type Output = Value;
 
-    fn eval(&self, ctx: &mut EvalContext) -> Self::Output {
+    fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
         match self.op {
             BinOp::Add => self.apply(ctx, ops::add),
             BinOp::Sub => self.apply(ctx, ops::sub),
@@ -363,7 +329,7 @@ impl Eval for BinaryExpr {
             BinOp::Leq => self.apply(ctx, ops::leq),
             BinOp::Gt => self.apply(ctx, ops::gt),
             BinOp::Geq => self.apply(ctx, ops::geq),
-            BinOp::Assign => self.assign(ctx, |_, b| b),
+            BinOp::Assign => self.assign(ctx, |_, b| Ok(b)),
             BinOp::AddAssign => self.assign(ctx, ops::add),
             BinOp::SubAssign => self.assign(ctx, ops::sub),
             BinOp::MulAssign => self.assign(ctx, ops::mul),
@@ -375,131 +341,110 @@ impl Eval for BinaryExpr {
 
 impl BinaryExpr {
     /// Apply a basic binary operation.
-    fn apply<F>(&self, ctx: &mut EvalContext, op: F) -> Value
+    fn apply<F>(&self, ctx: &mut EvalContext, op: F) -> TypResult<Value>
     where
-        F: FnOnce(Value, Value) -> Value,
+        F: FnOnce(Value, Value) -> StrResult<Value>,
     {
-        // Short-circuit boolean operations.
-        let lhs = self.lhs.eval(ctx);
-        match (self.op, &lhs) {
-            (BinOp::And, Value::Bool(false)) => return lhs,
-            (BinOp::Or, Value::Bool(true)) => return lhs,
-            _ => {}
-        }
+        let lhs = self.lhs.eval(ctx)?;
 
-        let rhs = self.rhs.eval(ctx);
-        if lhs == Value::Error || rhs == Value::Error {
-            return Value::Error;
-        }
-
-        // Save type names before we consume the values in case of error.
-        let types = (lhs.type_name(), rhs.type_name());
-        let out = op(lhs, rhs);
-        if out == Value::Error {
-            self.error(ctx, types);
+        // Short-circuit boolean operations.
+        if (self.op == BinOp::And && lhs == Value::Bool(false))
+            || (self.op == BinOp::Or && lhs == Value::Bool(true))
+        {
+            return Ok(lhs);
         }
 
-        out
+        let rhs = self.rhs.eval(ctx)?;
+        op(lhs, rhs).map_err(Error::partial(ctx.file, self.span))
     }
 
     /// Apply an assignment operation.
-    fn assign<F>(&self, ctx: &mut EvalContext, op: F) -> Value
+    fn assign<F>(&self, ctx: &mut EvalContext, op: F) -> TypResult<Value>
     where
-        F: FnOnce(Value, Value) -> Value,
+        F: FnOnce(Value, Value) -> StrResult<Value>,
     {
+        let lspan = self.lhs.span();
         let slot = if let Expr::Ident(id) = self.lhs.as_ref() {
             match ctx.scopes.get(id) {
                 Some(slot) => Rc::clone(slot),
-                None => {
-                    ctx.diag(error!(self.lhs.span(), "unknown variable"));
-                    return Value::Error;
-                }
+                None => bail!(ctx.file, lspan, "unknown variable"),
             }
         } else {
-            ctx.diag(error!(self.lhs.span(), "cannot assign to this expression"));
-            return Value::Error;
+            bail!(ctx.file, lspan, "cannot assign to this expression",);
         };
 
-        let rhs = self.rhs.eval(ctx);
+        let rhs = self.rhs.eval(ctx)?;
         let mut mutable = match slot.try_borrow_mut() {
             Ok(mutable) => mutable,
             Err(_) => {
-                ctx.diag(error!(self.lhs.span(), "cannot assign to a constant"));
-                return Value::Error;
+                bail!(ctx.file, lspan, "cannot assign to a constant",);
             }
         };
 
         let lhs = mem::take(&mut *mutable);
-        let types = (lhs.type_name(), rhs.type_name());
-        *mutable = op(lhs, rhs);
+        *mutable = op(lhs, rhs).map_err(Error::partial(ctx.file, self.span))?;
 
-        if *mutable == Value::Error {
-            self.error(ctx, types);
-            return Value::Error;
-        }
-
-        Value::None
-    }
-
-    fn error(&self, ctx: &mut EvalContext, (a, b): (&str, &str)) {
-        ctx.diag(error!(self.span, "{}", match self.op {
-            BinOp::Add => format!("cannot add {} and {}", a, b),
-            BinOp::Sub => format!("cannot subtract {1} from {0}", a, b),
-            BinOp::Mul => format!("cannot multiply {} with {}", a, b),
-            BinOp::Div => format!("cannot divide {} by {}", a, b),
-            _ => format!("cannot apply '{}' to {} and {}", self.op.as_str(), a, b),
-        }));
+        Ok(Value::None)
     }
 }
 
 impl Eval for CallExpr {
     type Output = Value;
 
-    fn eval(&self, ctx: &mut EvalContext) -> Self::Output {
-        let callee = self.callee.eval(ctx);
-        if let Some(func) = ctx.cast::<Function>(callee, self.callee.span()) {
-            let mut args = self.args.eval(ctx);
-            let returned = func(ctx, &mut args);
-            args.finish(ctx);
-            returned
-        } else {
-            Value::Error
-        }
+    fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
+        let callee = self
+            .callee
+            .eval(ctx)?
+            .cast::<Function>()
+            .map_err(Error::partial(ctx.file, self.callee.span()))?;
+
+        let mut args = self.args.eval(ctx)?;
+        let returned = callee(ctx, &mut args)?;
+        args.finish()?;
+
+        Ok(returned)
     }
 }
 
 impl Eval for CallArgs {
     type Output = FuncArgs;
 
-    fn eval(&self, ctx: &mut EvalContext) -> Self::Output {
-        let items = self.items.iter().map(|arg| arg.eval(ctx)).collect();
-        FuncArgs { span: self.span, items }
+    fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
+        Ok(FuncArgs {
+            file: ctx.file,
+            span: self.span,
+            items: self
+                .items
+                .iter()
+                .map(|arg| arg.eval(ctx))
+                .collect::<TypResult<Vec<_>>>()?,
+        })
     }
 }
 
 impl Eval for CallArg {
     type Output = FuncArg;
 
-    fn eval(&self, ctx: &mut EvalContext) -> Self::Output {
-        match self {
+    fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
+        Ok(match self {
             Self::Pos(expr) => FuncArg {
                 span: self.span(),
                 name: None,
-                value: Spanned::new(expr.eval(ctx), expr.span()),
+                value: Spanned::new(expr.eval(ctx)?, expr.span()),
             },
             Self::Named(Named { name, expr }) => FuncArg {
                 span: self.span(),
                 name: Some(name.string.clone()),
-                value: Spanned::new(expr.eval(ctx), expr.span()),
+                value: Spanned::new(expr.eval(ctx)?, expr.span()),
             },
-        }
+        })
     }
 }
 
 impl Eval for ClosureExpr {
     type Output = Value;
 
-    fn eval(&self, ctx: &mut EvalContext) -> Self::Output {
+    fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
         let params = Rc::clone(&self.params);
         let body = Rc::clone(&self.body);
 
@@ -511,86 +456,92 @@ impl Eval for ClosureExpr {
         };
 
         let name = self.name.as_ref().map(|name| name.string.clone());
-        Value::Func(Function::new(name, move |ctx, args| {
+        let func = Function::new(name, move |ctx, args| {
             // Don't leak the scopes from the call site. Instead, we use the
             // scope of captured variables we collected earlier.
             let prev = mem::take(&mut ctx.scopes);
             ctx.scopes.top = captured.clone();
 
             for param in params.iter() {
-                // Set the parameter to `none` if the argument is missing.
-                let value = args.expect::<Value>(ctx, param.as_str()).unwrap_or_default();
+                let value = args.expect::<Value>(param.as_str())?;
                 ctx.scopes.def_mut(param.as_str(), value);
             }
 
-            let value = body.eval(ctx);
+            let result = body.eval(ctx);
             ctx.scopes = prev;
-            value
-        }))
+            result
+        });
+
+        Ok(Value::Func(func))
     }
 }
 
 impl Eval for WithExpr {
     type Output = Value;
 
-    fn eval(&self, ctx: &mut EvalContext) -> Self::Output {
-        let callee = self.callee.eval(ctx);
-        if let Some(func) = ctx.cast::<Function>(callee, self.callee.span()) {
-            let applied = self.args.eval(ctx);
-            let name = func.name().cloned();
-            Value::Func(Function::new(name, move |ctx, args| {
-                // Remove named arguments that were overridden.
-                let kept: Vec<_> = applied
-                    .items
-                    .iter()
-                    .filter(|arg| {
-                        arg.name.is_none()
-                            || args.items.iter().all(|other| arg.name != other.name)
-                    })
-                    .cloned()
-                    .collect();
-
-                // Preprend the applied arguments so that the positional arguments
-                // are in the right order.
-                args.items.splice(.. 0, kept);
-
-                // Call the original function.
-                func(ctx, args)
-            }))
-        } else {
-            Value::Error
-        }
+    fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
+        let callee = self
+            .callee
+            .eval(ctx)?
+            .cast::<Function>()
+            .map_err(Error::partial(ctx.file, self.callee.span()))?;
+
+        let applied = self.args.eval(ctx)?;
+
+        let name = callee.name().cloned();
+        let func = Function::new(name, move |ctx, args| {
+            // Remove named arguments that were overridden.
+            let kept: Vec<_> = applied
+                .items
+                .iter()
+                .filter(|arg| {
+                    arg.name.is_none()
+                        || args.items.iter().all(|other| arg.name != other.name)
+                })
+                .cloned()
+                .collect();
+
+            // Preprend the applied arguments so that the positional arguments
+            // are in the right order.
+            args.items.splice(.. 0, kept);
+
+            // Call the original function.
+            callee(ctx, args)
+        });
+
+        Ok(Value::Func(func))
     }
 }
 
 impl Eval for LetExpr {
     type Output = Value;
 
-    fn eval(&self, ctx: &mut EvalContext) -> Self::Output {
+    fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
         let value = match &self.init {
-            Some(expr) => expr.eval(ctx),
+            Some(expr) => expr.eval(ctx)?,
             None => Value::None,
         };
         ctx.scopes.def_mut(self.binding.as_str(), value);
-        Value::None
+        Ok(Value::None)
     }
 }
 
 impl Eval for IfExpr {
     type Output = Value;
 
-    fn eval(&self, ctx: &mut EvalContext) -> Self::Output {
-        let condition = self.condition.eval(ctx);
-        if let Some(condition) = ctx.cast(condition, self.condition.span()) {
-            if condition {
-                self.if_body.eval(ctx)
-            } else if let Some(else_body) = &self.else_body {
-                else_body.eval(ctx)
-            } else {
-                Value::None
-            }
+    fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
+        let condition = self
+            .condition
+            .eval(ctx)?
+            .cast::<bool>()
+            .map_err(Error::partial(ctx.file, self.condition.span()))?;
+
+        if condition {
+            self.if_body.eval(ctx)
+        } else if let Some(else_body) = &self.else_body {
+            else_body.eval(ctx)
         } else {
-            Value::Error
+            Ok(Value::None)
         }
     }
 }
@@ -598,28 +549,28 @@ impl Eval for IfExpr {
 impl Eval for WhileExpr {
     type Output = Value;
 
-    fn eval(&self, ctx: &mut EvalContext) -> Self::Output {
+    fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
         let mut output = Value::None;
-        loop {
-            let condition = self.condition.eval(ctx);
-            if let Some(condition) = ctx.cast(condition, self.condition.span()) {
-                if condition {
-                    let value = self.body.eval(ctx);
-                    output = ctx.join(output, value, self.body.span());
-                } else {
-                    return output;
-                }
-            } else {
-                return Value::Error;
-            }
+
+        while self
+            .condition
+            .eval(ctx)?
+            .cast::<bool>()
+            .map_err(Error::partial(ctx.file, self.condition.span()))?
+        {
+            let value = self.body.eval(ctx)?;
+            output = ops::join(output, value)
+                .map_err(Error::partial(ctx.file, self.body.span()))?;
         }
+
+        Ok(output)
     }
 }
 
 impl Eval for ForExpr {
     type Output = Value;
 
-    fn eval(&self, ctx: &mut EvalContext) -> Self::Output {
+    fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
         macro_rules! iter {
             (for ($($binding:ident => $value:ident),*) in $iter:expr) => {{
                 let mut output = Value::None;
@@ -629,17 +580,18 @@ impl Eval for ForExpr {
                 for ($($value),*) in $iter {
                     $(ctx.scopes.def_mut($binding.as_str(), $value);)*
 
-                    let value = self.body.eval(ctx);
-                    output = ctx.join(output, value, self.body.span());
+                    let value = self.body.eval(ctx)?;
+                    output = ops::join(output, value)
+                        .map_err(Error::partial(ctx.file, self.body.span()))?;
                 }
 
                 ctx.scopes.exit();
-                output
+                Ok(output)
             }};
         }
 
-        let iter = self.iter.eval(ctx);
-        match (self.pattern.clone(), iter) {
+        let iter = self.iter.eval(ctx)?;
+        match (&self.pattern, iter) {
             (ForPattern::Value(v), Value::Str(string)) => {
                 iter!(for (v => value) in string.chars().map(|c| Value::Str(c.into())))
             }
@@ -655,22 +607,15 @@ impl Eval for ForExpr {
             (ForPattern::KeyValue(k, v), Value::Dict(dict)) => {
                 iter!(for (k => key, v => value) in dict.into_iter())
             }
-
             (ForPattern::KeyValue(_, _), Value::Str(_)) => {
-                ctx.diag(error!(self.pattern.span(), "mismatched pattern"));
-                Value::Error
-            }
-
-            (_, iter) => {
-                if iter != Value::Error {
-                    ctx.diag(error!(
-                        self.iter.span(),
-                        "cannot loop over {}",
-                        iter.type_name(),
-                    ));
-                }
-                Value::Error
+                bail!(ctx.file, self.pattern.span(), "mismatched pattern");
             }
+            (_, iter) => bail!(
+                ctx.file,
+                self.iter.span(),
+                "cannot loop over {}",
+                iter.type_name(),
+            ),
         }
     }
 }
@@ -678,50 +623,50 @@ impl Eval for ForExpr {
 impl Eval for ImportExpr {
     type Output = Value;
 
-    fn eval(&self, ctx: &mut EvalContext) -> Self::Output {
-        let path = self.path.eval(ctx);
-        if let Some(path) = ctx.cast::<EcoString>(path, self.path.span()) {
-            if let Some(hash) = ctx.import(&path, self.path.span()) {
-                let mut module = &ctx.modules[&hash];
-                match &self.imports {
-                    Imports::Wildcard => {
-                        for (var, slot) in module.scope.iter() {
-                            let value = slot.borrow().clone();
-                            ctx.scopes.def_mut(var, value);
-                        }
-                    }
-                    Imports::Idents(idents) => {
-                        for ident in idents {
-                            if let Some(slot) = module.scope.get(&ident) {
-                                let value = slot.borrow().clone();
-                                ctx.scopes.def_mut(ident.as_str(), value);
-                            } else {
-                                ctx.diag(error!(ident.span, "unresolved import"));
-                                module = &ctx.modules[&hash];
-                            }
-                        }
+    fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
+        let path = self
+            .path
+            .eval(ctx)?
+            .cast::<EcoString>()
+            .map_err(Error::partial(ctx.file, self.path.span()))?;
+
+        let id = ctx.import(&path, self.path.span())?;
+        let module = &ctx.modules[&id];
+
+        match &self.imports {
+            Imports::Wildcard => {
+                for (var, slot) in module.scope.iter() {
+                    ctx.scopes.def_mut(var, slot.borrow().clone());
+                }
+            }
+            Imports::Idents(idents) => {
+                for ident in idents {
+                    if let Some(slot) = module.scope.get(&ident) {
+                        ctx.scopes.def_mut(ident.as_str(), slot.borrow().clone());
+                    } else {
+                        bail!(ctx.file, ident.span, "unresolved import");
                     }
                 }
-
-                return Value::None;
             }
         }
 
-        Value::Error
+        Ok(Value::None)
     }
 }
 
 impl Eval for IncludeExpr {
     type Output = Value;
 
-    fn eval(&self, ctx: &mut EvalContext) -> Self::Output {
-        let path = self.path.eval(ctx);
-        if let Some(path) = ctx.cast::<EcoString>(path, self.path.span()) {
-            if let Some(hash) = ctx.import(&path, self.path.span()) {
-                return Value::Template(ctx.modules[&hash].template.clone());
-            }
-        }
+    fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
+        let path = self
+            .path
+            .eval(ctx)?
+            .cast::<EcoString>()
+            .map_err(Error::partial(ctx.file, self.path.span()))?;
+
+        let id = ctx.import(&path, self.path.span())?;
+        let module = &ctx.modules[&id];
 
-        Value::Error
+        Ok(Value::Template(module.template.clone()))
     }
 }
diff --git a/src/eval/ops.rs b/src/eval/ops.rs
index df8babe2..2bf1c189 100644
--- a/src/eval/ops.rs
+++ b/src/eval/ops.rs
@@ -1,30 +1,34 @@
 use std::cmp::Ordering;
 
 use super::Value;
+use crate::diag::StrResult;
 use Value::*;
 
+/// Bail with a type mismatch error.
+macro_rules! mismatch {
+    ($fmt:expr, $($value:expr),* $(,)?) => {
+        return Err(format!($fmt, $($value.type_name()),*));
+    };
+}
+
 /// Join a value with another value.
-pub fn join(lhs: Value, rhs: Value) -> Result<Value, Value> {
+pub fn join(lhs: Value, rhs: Value) -> StrResult<Value> {
     Ok(match (lhs, rhs) {
-        (_, Error) => Error,
-        (Error, _) => Error,
         (a, None) => a,
         (None, b) => b,
-
         (Str(a), Str(b)) => Str(a + b),
         (Array(a), Array(b)) => Array(a + b),
         (Dict(a), Dict(b)) => Dict(a + b),
         (Template(a), Template(b)) => Template(a + b),
         (Template(a), Str(b)) => Template(a + b),
         (Str(a), Template(b)) => Template(a + b),
-
-        (lhs, _) => return Err(lhs),
+        (a, b) => mismatch!("cannot join {} with {}", a, b),
     })
 }
 
 /// Apply the plus operator to a value.
-pub fn pos(value: Value) -> Value {
-    match value {
+pub fn pos(value: Value) -> StrResult<Value> {
+    Ok(match value {
         Int(v) => Int(v),
         Float(v) => Float(v),
         Length(v) => Length(v),
@@ -32,13 +36,13 @@ pub fn pos(value: Value) -> Value {
         Relative(v) => Relative(v),
         Linear(v) => Linear(v),
         Fractional(v) => Fractional(v),
-        _ => Error,
-    }
+        v => mismatch!("cannot apply '+' to {}", v),
+    })
 }
 
 /// Compute the negation of a value.
-pub fn neg(value: Value) -> Value {
-    match value {
+pub fn neg(value: Value) -> StrResult<Value> {
+    Ok(match value {
         Int(v) => Int(-v),
         Float(v) => Float(-v),
         Length(v) => Length(-v),
@@ -46,13 +50,13 @@ pub fn neg(value: Value) -> Value {
         Relative(v) => Relative(-v),
         Linear(v) => Linear(-v),
         Fractional(v) => Fractional(-v),
-        _ => Error,
-    }
+        v => mismatch!("cannot apply '-' to {}", v),
+    })
 }
 
 /// Compute the sum of two values.
-pub fn add(lhs: Value, rhs: Value) -> Value {
-    match (lhs, rhs) {
+pub fn add(lhs: Value, rhs: Value) -> StrResult<Value> {
+    Ok(match (lhs, rhs) {
         (Int(a), Int(b)) => Int(a + b),
         (Int(a), Float(b)) => Float(a as f64 + b),
         (Float(a), Int(b)) => Float(a + b as f64),
@@ -81,13 +85,13 @@ pub fn add(lhs: Value, rhs: Value) -> Value {
         (Template(a), Str(b)) => Template(a + b),
         (Str(a), Template(b)) => Template(a + b),
 
-        _ => Error,
-    }
+        (a, b) => mismatch!("cannot add {} and {}", a, b),
+    })
 }
 
 /// Compute the difference of two values.
-pub fn sub(lhs: Value, rhs: Value) -> Value {
-    match (lhs, rhs) {
+pub fn sub(lhs: Value, rhs: Value) -> StrResult<Value> {
+    Ok(match (lhs, rhs) {
         (Int(a), Int(b)) => Int(a - b),
         (Int(a), Float(b)) => Float(a as f64 - b),
         (Float(a), Int(b)) => Float(a - b as f64),
@@ -109,13 +113,13 @@ pub fn sub(lhs: Value, rhs: Value) -> Value {
 
         (Fractional(a), Fractional(b)) => Fractional(a - b),
 
-        _ => Error,
-    }
+        (a, b) => mismatch!("cannot subtract {1} from {0}", a, b),
+    })
 }
 
 /// Compute the product of two values.
-pub fn mul(lhs: Value, rhs: Value) -> Value {
-    match (lhs, rhs) {
+pub fn mul(lhs: Value, rhs: Value) -> StrResult<Value> {
+    Ok(match (lhs, rhs) {
         (Int(a), Int(b)) => Int(a * b),
         (Int(a), Float(b)) => Float(a as f64 * b),
         (Float(a), Int(b)) => Float(a * b as f64),
@@ -150,14 +154,16 @@ pub fn mul(lhs: Value, rhs: Value) -> Value {
         (Int(a), Str(b)) => Str(b.repeat(a.max(0) as usize)),
         (Array(a), Int(b)) => Array(a.repeat(b.max(0) as usize)),
         (Int(a), Array(b)) => Array(b.repeat(a.max(0) as usize)),
+        (Template(a), Int(b)) => Template(a.repeat(b.max(0) as usize)),
+        (Int(a), Template(b)) => Template(b.repeat(a.max(0) as usize)),
 
-        _ => Error,
-    }
+        (a, b) => mismatch!("cannot multiply {} with {}", a, b),
+    })
 }
 
 /// Compute the quotient of two values.
-pub fn div(lhs: Value, rhs: Value) -> Value {
-    match (lhs, rhs) {
+pub fn div(lhs: Value, rhs: Value) -> StrResult<Value> {
+    Ok(match (lhs, rhs) {
         (Int(a), Int(b)) => Float(a as f64 / b as f64),
         (Int(a), Float(b)) => Float(a as f64 / b),
         (Float(a), Int(b)) => Float(a / b as f64),
@@ -182,31 +188,67 @@ pub fn div(lhs: Value, rhs: Value) -> Value {
         (Linear(a), Int(b)) => Linear(a / b as f64),
         (Linear(a), Float(b)) => Linear(a / b),
 
-        _ => Error,
-    }
+        (a, b) => mismatch!("cannot divide {} by {}", a, b),
+    })
 }
 
 /// Compute the logical "not" of a value.
-pub fn not(value: Value) -> Value {
+pub fn not(value: Value) -> StrResult<Value> {
     match value {
-        Bool(b) => Bool(!b),
-        _ => Error,
+        Bool(b) => Ok(Bool(!b)),
+        v => mismatch!("cannot apply 'not' to {}", v),
     }
 }
 
 /// Compute the logical "and" of two values.
-pub fn and(lhs: Value, rhs: Value) -> Value {
+pub fn and(lhs: Value, rhs: Value) -> StrResult<Value> {
     match (lhs, rhs) {
-        (Bool(a), Bool(b)) => Bool(a && b),
-        _ => Error,
+        (Bool(a), Bool(b)) => Ok(Bool(a && b)),
+        (a, b) => mismatch!("cannot apply 'and' to {} and {}", a, b),
     }
 }
 
 /// Compute the logical "or" of two values.
-pub fn or(lhs: Value, rhs: Value) -> Value {
+pub fn or(lhs: Value, rhs: Value) -> StrResult<Value> {
     match (lhs, rhs) {
-        (Bool(a), Bool(b)) => Bool(a || b),
-        _ => Error,
+        (Bool(a), Bool(b)) => Ok(Bool(a || b)),
+        (a, b) => mismatch!("cannot apply 'or' to {} and {}", a, b),
+    }
+}
+
+/// Compute whether two values are equal.
+pub fn eq(lhs: Value, rhs: Value) -> StrResult<Value> {
+    Ok(Bool(equal(&lhs, &rhs)))
+}
+
+/// Compute whether two values are equal.
+pub fn neq(lhs: Value, rhs: Value) -> StrResult<Value> {
+    Ok(Bool(!equal(&lhs, &rhs)))
+}
+
+macro_rules! comparison {
+    ($name:ident, $op:tt, $($pat:tt)*) => {
+        /// Compute how a value compares with another value.
+        pub fn $name(lhs: Value, rhs: Value) -> StrResult<Value> {
+            if let Some(ordering) = compare(&lhs, &rhs) {
+                Ok(Bool(matches!(ordering, $($pat)*)))
+            } else {
+                mismatch!(concat!("cannot apply '", $op, "' to {} and {}"), lhs, rhs);
+            }
+        }
+    };
+}
+
+comparison!(lt, "<", Ordering::Less);
+comparison!(leq, "<=", Ordering::Less | Ordering::Equal);
+comparison!(gt, ">", Ordering::Greater);
+comparison!(geq, ">=", Ordering::Greater | Ordering::Equal);
+
+/// Compute the range from `lhs` to `rhs`.
+pub fn range(lhs: Value, rhs: Value) -> StrResult<Value> {
+    match (lhs, rhs) {
+        (Int(a), Int(b)) => Ok(Array((a ..= b).map(Int).collect())),
+        (a, b) => mismatch!("cannot apply '..' to {} and {}", a, b),
     }
 }
 
@@ -231,7 +273,6 @@ pub fn equal(lhs: &Value, rhs: &Value) -> bool {
         (Template(a), Template(b)) => a == b,
         (Func(a), Func(b)) => a == b,
         (Dyn(a), Dyn(b)) => a == b,
-        (Error, Error) => true,
 
         // Some technically different things should compare equal.
         (&Int(a), &Float(b)) => a as f64 == b,
@@ -245,16 +286,6 @@ pub fn equal(lhs: &Value, rhs: &Value) -> bool {
     }
 }
 
-/// Compute whether two values are equal.
-pub fn eq(lhs: Value, rhs: Value) -> Value {
-    Bool(equal(&lhs, &rhs))
-}
-
-/// Compute whether two values are equal.
-pub fn neq(lhs: Value, rhs: Value) -> Value {
-    Bool(!equal(&lhs, &rhs))
-}
-
 /// Compare two values.
 pub fn compare(lhs: &Value, rhs: &Value) -> Option<Ordering> {
     match (lhs, rhs) {
@@ -269,26 +300,3 @@ pub fn compare(lhs: &Value, rhs: &Value) -> Option<Ordering> {
         _ => Option::None,
     }
 }
-
-macro_rules! comparison {
-    ($name:ident, $($pat:tt)*) => {
-        /// Compute how a value compares with another value.
-        pub fn $name(lhs: Value, rhs: Value) -> Value {
-            compare(&lhs, &rhs)
-                .map_or(Error, |x| Bool(matches!(x, $($pat)*)))
-        }
-    };
-}
-
-comparison!(lt, Ordering::Less);
-comparison!(leq, Ordering::Less | Ordering::Equal);
-comparison!(gt, Ordering::Greater);
-comparison!(geq, Ordering::Greater | Ordering::Equal);
-
-/// Compute the range from `lhs` to `rhs`.
-pub fn range(lhs: Value, rhs: Value) -> Value {
-    match (lhs, rhs) {
-        (Int(a), Int(b)) => Array((a ..= b).map(Int).collect()),
-        _ => Error,
-    }
-}
diff --git a/src/eval/scope.rs b/src/eval/scope.rs
index 72b524cf..2eb048fa 100644
--- a/src/eval/scope.rs
+++ b/src/eval/scope.rs
@@ -4,7 +4,9 @@ use std::fmt::{self, Debug, Formatter};
 use std::iter;
 use std::rc::Rc;
 
-use super::{EcoString, EvalContext, FuncArgs, Function, Value};
+use super::{EvalContext, FuncArgs, Function, Value};
+use crate::diag::TypResult;
+use crate::util::EcoString;
 
 /// A slot where a variable is stored.
 pub type Slot = Rc<RefCell<Value>>;
@@ -89,7 +91,7 @@ impl Scope {
     /// Define a constant function.
     pub fn def_func<F>(&mut self, name: impl Into<EcoString>, f: F)
     where
-        F: Fn(&mut EvalContext, &mut FuncArgs) -> Value + 'static,
+        F: Fn(&mut EvalContext, &mut FuncArgs) -> TypResult<Value> + 'static,
     {
         let name = name.into();
         self.def_const(name.clone(), Function::new(Some(name), f));
diff --git a/src/eval/template.rs b/src/eval/template.rs
index 9a71ada4..29b5663d 100644
--- a/src/eval/template.rs
+++ b/src/eval/template.rs
@@ -21,9 +21,16 @@ impl Template {
     }
 
     /// Iterate over the contained template nodes.
-    pub fn iter(&self) -> impl Iterator<Item = &TemplateNode> + '_ {
+    pub fn iter(&self) -> std::slice::Iter<TemplateNode> {
         self.nodes.iter()
     }
+
+    /// Repeat this template `n` times.
+    pub fn repeat(&self, n: usize) -> Self {
+        let len = self.nodes.len().checked_mul(n).expect("capacity overflow");
+        let nodes = self.iter().cloned().cycle().take(len).collect();
+        Self { nodes: Rc::new(nodes) }
+    }
 }
 
 impl From<TemplateTree> for Template {
diff --git a/src/eval/value.rs b/src/eval/value.rs
index b7fdcbc2..9bab067c 100644
--- a/src/eval/value.rs
+++ b/src/eval/value.rs
@@ -5,10 +5,11 @@ use std::rc::Rc;
 
 use super::{ops, Array, Dict, Function, Template, TemplateFunc};
 use crate::color::{Color, RgbaColor};
-use crate::util::EcoString;
+use crate::diag::StrResult;
 use crate::exec::ExecContext;
 use crate::geom::{Angle, Fractional, Length, Linear, Relative};
 use crate::syntax::Spanned;
+use crate::util::EcoString;
 
 /// A computational value.
 #[derive(Debug, Clone)]
@@ -47,8 +48,6 @@ pub enum Value {
     Func(Function),
     /// A dynamic value.
     Dyn(Dynamic),
-    /// The result of invalid operations.
-    Error,
 }
 
 impl Value {
@@ -80,7 +79,6 @@ impl Value {
             Self::Template(_) => Template::TYPE_NAME,
             Self::Func(_) => Function::TYPE_NAME,
             Self::Dyn(v) => v.type_name(),
-            Self::Error => "error",
         }
     }
 
@@ -93,7 +91,7 @@ impl Value {
     }
 
     /// Try to cast the value into a specific type.
-    pub fn cast<T>(self) -> Result<T, String>
+    pub fn cast<T>(self) -> StrResult<T>
     where
         T: Cast<Value>,
     {
@@ -241,7 +239,7 @@ pub trait Cast<V>: Sized {
     fn is(value: &V) -> bool;
 
     /// Try to cast the value into an instance of `Self`.
-    fn cast(value: V) -> Result<Self, String>;
+    fn cast(value: V) -> StrResult<Self>;
 }
 
 impl Cast<Value> for Value {
@@ -249,7 +247,7 @@ impl Cast<Value> for Value {
         true
     }
 
-    fn cast(value: Value) -> Result<Self, String> {
+    fn cast(value: Value) -> StrResult<Self> {
         Ok(value)
     }
 }
@@ -262,7 +260,7 @@ where
         T::is(&value.v)
     }
 
-    fn cast(value: Spanned<Value>) -> Result<Self, String> {
+    fn cast(value: Spanned<Value>) -> StrResult<Self> {
         T::cast(value.v)
     }
 }
@@ -275,7 +273,7 @@ where
         T::is(&value.v)
     }
 
-    fn cast(value: Spanned<Value>) -> Result<Self, String> {
+    fn cast(value: Spanned<Value>) -> StrResult<Self> {
         let span = value.span;
         T::cast(value.v).map(|t| Spanned::new(t, span))
     }
@@ -302,7 +300,7 @@ macro_rules! primitive {
                 matches!(value, Value::$variant(_) $(| Value::$other(_))*)
             }
 
-            fn cast(value: Value) -> Result<Self, String> {
+            fn cast(value: Value) -> StrResult<Self> {
                 match value {
                     Value::$variant(v) => Ok(v),
                     $(Value::$other($binding) => Ok($out),)*
@@ -358,7 +356,7 @@ macro_rules! castable {
                 }
             }
 
-            fn cast(value: $crate::eval::Value) -> Result<Self, String> {
+            fn cast(value: $crate::eval::Value) -> $crate::diag::StrResult<Self> {
                 let found = match value {
                     $($pattern => return Ok($out),)*
                     $crate::eval::Value::Dyn(dynamic) => {
@@ -387,6 +385,6 @@ primitive! { Color: "color", Color }
 primitive! { EcoString: "string", Str }
 primitive! { Array: "array", Array }
 primitive! { Dict: "dictionary", Dict }
-primitive! { Template: "template", Template, Str(v) => v.into() }
+primitive! { Template: "template", Template }
 primitive! { Function: "function", Func }
 primitive! { f64: "float", Float, Int(v) => v as f64 }