Struct BlockCall

pub struct BlockCall { /* private fields */ }

A pair of a Block and its arguments, stored in a single EntityList internally.

NOTE: We don’t expose either value_to_block or block_to_value outside of this module because this operation is not generally safe. However, as the two share the same underlying layout, they can be stored in the same value pool.

BlockCall makes use of this shared layout by storing all of its contents (a block and its argument) in a single EntityList. This is a bit better than introducing a new entity type for the pair of a block name and the arguments entity list, as we don’t pay any indirection penalty to get to the argument values – they’re stored in-line with the block in the same list.

The BlockCall::new function guarantees this layout by requiring a block argument that’s written in as the first element of the EntityList. Any subsequent entries are always assumed to be real Values.

Implementations

impl BlockCall

pub fn new(block: Block, args: &[Value], pool: &mut ValueListPool) -> Self

Construct a BlockCall with the given block and arguments.

pub fn block(&self, pool: &ValueListPool) -> Block

Return the block for this BlockCall.

pub fn set_block(&mut self, block: Block, pool: &mut ValueListPool)

Replace the block for this BlockCall.

pub fn append_argument(&mut self, arg: Value, pool: &mut ValueListPool)

Append an argument to the block args.

pub fn args_slice<'a>(&self, pool: &'a ValueListPool) -> &'a [Value]

Return a slice for the arguments of this block.

pub fn args_slice_mut<'a>( &'a mut self, pool: &'a mut ValueListPool, ) -> &'a mut [Value]

Return a slice for the arguments of this block.

pub fn remove(&mut self, ix: usize, pool: &mut ValueListPool)

Remove the argument at ix from the argument list.

pub fn clear(&mut self, pool: &mut ValueListPool)

Clear out the arguments list.

pub fn extend<I>(&mut self, elements: I, pool: &mut ValueListPool)

where I: IntoIterator<Item = Value>,

Appends multiple elements to the arguments.

pub fn display<'a>(&self, pool: &'a ValueListPool) -> DisplayBlockCall<'a>

Return a value that can display this block call.

pub fn deep_clone(&self, pool: &mut ValueListPool) -> Self

Deep-clone the underlying list in the same pool. The returned list will have identical contents but changes to this list will not change its contents or vice-versa.

Trait Implementations

impl Clone for BlockCall

fn clone(&self) -> BlockCall

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BlockCall

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for BlockCall

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for BlockCall

fn eq(&self, other: &BlockCall) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for BlockCall

impl Eq for BlockCall

impl StructuralPartialEq for BlockCall