Struct Build

Source

pub struct Build<'a, S> { /* private fields */ }

Expand description

A builder for a Unit.

See rune::prepare for more.

Implementations§

Source §

impl<'a, S> Build<'a, S>

Source

pub fn with_context(self, context: &'a Context) -> Self

Modify the current Build to use the given Context while building.

If unspecified the empty context constructed with Context::new will be used. Since this counts as building without a context, Vm::without_runtime can be used when running the produced Unit.

Source

pub fn with_diagnostics(self, diagnostics: &'a mut Diagnostics) -> Self

Modify the current Build to use the given Diagnostics collection.

Source

pub fn with_options(self, options: &'a Options) -> Self

Modify the current Build to use the given Options.

Source

pub fn with_arg(self, arg: impl AsRef<str>) -> Result<Self>

Associate an implicit argument with the build.

When the produced unit is executed as a script, this argument will be part of the top-level function that is being defined.

This requires Options::script to be set. See the scripts example.

§Examples

use rune::{Source, Sources, Options};

let mut sources = Sources::new();
sources.insert(Source::memory("(a + b * 2) / c")?)?;

let mut options = Options::from_default_env()?;
options.script(true);

let result = rune::prepare(&mut sources)
    .with_args(["a", "b"])?
    .with_arg("c")?
    .with_options(&options)
    .build()?;

Source

pub fn with_args( self, args: impl IntoIterator<Item: AsRef<str>>, ) -> Result<Self>

Associate a collection of implicit arguments with the build.

When the produced unit is executed as a script, this argument will be part of the top-level function that is being defined.

This requires Options::script to be set. See the scripts example.

§Examples

use rune::{Source, Sources, Options};

let mut sources = Sources::new();
sources.insert(Source::memory("(a + b * 2) / c")?)?;

let mut options = Options::from_default_env()?;
options.script(true);

let result = rune::prepare(&mut sources)
    .with_args(["a", "b"])?
    .with_arg("c")?
    .with_options(&options)
    .build()?;

Source

pub fn with_statics(self, statics: &'a Statics) -> Self

Declare a collection of Statics with the build.

Every static declared this way is added to the unit as if the source had declared it, which lets a script use a static the host owns without declaring it itself. Such a static has no initializer, so the caller has to assign it through Globals::set before anything reads it.

§Examples

use rune::{Source, Sources, Statics};
use rune::runtime::Globals;
use rune::sync::Arc;

let mut sources = Sources::new();
sources.insert(Source::memory("pub fn main() { LIMIT }")?)?;

let mut statics = Statics::new();
statics.insert(["LIMIT"])?;

let unit = rune::prepare(&mut sources)
    .with_statics(&statics)
    .build()?;

let globals = Globals::new(Arc::try_new(unit)?)?;
globals.set(["LIMIT"], rune::to_value(42i64)?)?;

Source

pub fn with_visitor(self, visitor: &'a mut dyn CompileVisitor) -> Result<Self>

Modify the current Build to configure the given CompileVisitor.

A compile visitor allows for custom collecting of compile-time metadata. Like if you want to collect every function that is discovered in the project.

Source