Struct Engine 

pub struct Engine<'a> {
    pub world: Tracked<'a, dyn World + 'a>,
    pub library: &'a LazyHash<Library>,
    pub introspector: Protected<Tracked<'a, dyn Introspector + 'a>>,
    pub traced: Tracked<'a, Traced>,
    pub sink: TrackedMut<'a, Sink>,
    pub route: Route<'a>,
}

Holds all data needed during compilation.

Fields

world: Tracked<'a, dyn World + 'a>

The compilation environment.

library: &'a LazyHash<Library>

Definition of Typst’s standard library.

Can be accessed via world.library(), but we fetch it once upfront because it’s accessed so frequently and we want to avoid the overhead of the tracked call.

introspector: Protected<Tracked<'a, dyn Introspector + 'a>>

Provides access to information about the document.

traced: Tracked<'a, Traced>

May hold a span that is currently under inspection.

sink: TrackedMut<'a, Sink>

A pure sink for warnings, delayed errors, and spans under inspection.

route: Route<'a>

The route the engine took during compilation. This is used to detect cyclic imports and excessive nesting.

Implementations

impl Engine<'_>

pub fn delay<T: Default>(&mut self, result: SourceResult<T>) -> T

Handles a result without immediately terminating execution. Instead, it produces a delayed error that is only promoted to a fatal one if it remains by the end of the introspection loop.

pub fn parallelize<P, I, T, U, F>( &mut self, iter: P, f: F, ) -> impl Iterator<Item = U> + use<P, I, T, U, F>

where P: IntoIterator<IntoIter = I>, I: Iterator<Item = T>, T: Send, U: Send, F: Fn(&mut Engine<'_>, T) -> U + Send + Sync,

Runs tasks on the engine in parallel.

pub fn introspect<I>(&mut self, introspection: I) -> I::Output

where I: Introspect,

Performs an introspection on the introspector and returns its result.

As a side effect, the introspection is stored in the sink. If the document does not converge, the recorded introspections are used to determine the cause of non-convergence.