Vectors
A vector is a native data structure of Rune which is a dynamic list of values. A vector isn't typed, and can store any Rune values.
pub fn main() {
let values = ["Hello", 42];
println!("{}", values[0]);
println!("{}", values.1); // items in vectors can be accessed like tuple fields.
for v in values {
println!("{}", v);
}
}
$> cargo run -- run scripts/book/vectors/vectors.rn
Hello
42
Hello
42
As you can see, you can iterate over a vector because it implements the iterator
protocol. It is also possible to create and use an iterator manually using
Vec::iter
, giving you more control over it.
pub fn main() {
let values = ["Hello", 42];
for v in values.iter().rev() {
println!("{}", v);
}
}
$> cargo run -- run scripts/book/vectors/vectors_rev.rn
42
Hello
Using vectors from Rust
Vectors are represented externally as the standard Vec
.
use rune::termcolor::{ColorChoice, StandardStream};
use rune::{Diagnostics, Vm};
use std::sync::Arc;
fn main() -> rune::support::Result<()> {
let context = rune_modules::default_context()?;
let runtime = Arc::new(context.runtime()?);
let mut sources = rune::sources! {
entry => {
pub fn calc(input) {
let output = 0;
for value in input {
output += value;
}
[output]
}
}
};
let mut diagnostics = Diagnostics::new();
let result = rune::prepare(&mut sources)
.with_context(&context)
.with_diagnostics(&mut diagnostics)
.build();
if !diagnostics.is_empty() {
let mut writer = StandardStream::stderr(ColorChoice::Always);
diagnostics.emit(&mut writer, &sources)?;
}
let unit = result?;
let mut vm = Vm::new(runtime, Arc::new(unit));
let input = vec![1, 2, 3, 4];
let output = vm.call(["calc"], (input,))?;
let output: Vec<i64> = rune::from_value(output)?;
println!("{:?}", output);
Ok(())
}
$> cargo run --example vector
[10]
If you have a vector which has values of non-uniform types, you can use
VecTuple
to deal with them.
use rune::runtime::VecTuple;
use rune::termcolor::{ColorChoice, StandardStream};
use rune::{Diagnostics, Vm};
use std::sync::Arc;
fn main() -> rune::support::Result<()> {
let context = rune_modules::default_context()?;
let runtime = Arc::new(context.runtime()?);
let mut sources = rune::sources! {
entry => {
pub fn calc(input) {
let a = input[0] + 1;
let b = format!("{} World", input[1]);
[a, b]
}
}
};
let mut diagnostics = Diagnostics::new();
let result = rune::prepare(&mut sources)
.with_context(&context)
.with_diagnostics(&mut diagnostics)
.build();
if !diagnostics.is_empty() {
let mut writer = StandardStream::stderr(ColorChoice::Always);
diagnostics.emit(&mut writer, &sources)?;
}
let unit = result?;
let mut vm = Vm::new(runtime, Arc::new(unit));
let input: VecTuple<(i64, String)> = VecTuple::new((1, String::from("Hello")));
let output = vm.call(["calc"], (input,))?;
let VecTuple((a, b)): VecTuple<(u32, String)> = rune::from_value(output)?;
println!("({:?}, {:?})", a, b);
Ok(())
}
$> cargo run --example vec_tuple
(2, "Hello World")