Struct FragmentComponent 

pub struct FragmentComponent {
    pub name: String,
    pub params: Vec<String>,
    pub inlinable: bool,
}

A candela function name that reaches a fragment.

A candela function returns an lmn! block, and a use site names that function as a tag. Nothing parses markup while an app runs, so the tree a use site stands for is baked before the app starts; inlinable is whether baking it is the whole story.

It is set when instantiating the fragment is the same as calling the function: the block is the function’s whole body, and every value the block reads is one the caller passed. The build then puts the body at the use site and the subtree is there from the first frame.

It is clear when the function has to run, because it works a value out or picks between blocks. Every block it may return is compiled just the same; what stands at the use site is a marker the runtime fills on the first tick, by calling the function with params and putting the node it returns in the marker’s place.

Fields

name: String

The candela function’s name, as a use site writes it.

params: Vec<String>

The function’s parameters, in declaration order. A use site binds props by name; a call passes them in this order.

inlinable: bool

Whether the baked body is what the call would have returned.

Trait Implementations

impl Clone for FragmentComponent

fn clone(&self) -> FragmentComponent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FragmentComponent

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for FragmentComponent

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for FragmentComponent

fn eq(&self, other: &FragmentComponent) -> 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 Serialize for FragmentComponent

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for FragmentComponent

impl StructuralPartialEq for FragmentComponent