Enum Type 

pub enum Type {
    Text,
    Int,
    Float,
    Bool,
    Principal,
    Resource,
    Time,
    Icon,
    Picture,
    RichText,
    Choice {
        name: String,
        cases: Vec<String>,
    },
    Option(Box<Type>),
    List(Box<Type>),
    Set(Box<Type>),
    Map {
        key: Box<Type>,
        value: Box<Type>,
    },
    Action,
    Cases {
        name: String,
    },
    Enum,
}

The type of a prop, an event’s value, a binding or a piece of state: the language’s types.

Variants

Text

Int

Float

Bool

Principal

A participant: a person or an agent.

Resource

A resource the component presents.

Time

A moment: a date and a time of day, as the language’s Time.

Icon

One of the platform’s icons, by its kebab-case name.

Picture

A picture: where its bytes are read from, and what it shows the person.

RichText

Rich text, with how its references read for the person reading it.

Choice

One of a closed set of cases: the design system’s roles and tokens.

Fields

name: String

cases: Vec<String>

Option(Box<Type>)

List(Box<Type>)

Set(Box<Type>)

Distinct values in no order the component relies on: who reacted with an emoji.

Map

Values by key: the people who reacted, by emoji.

Fields

key: Box<Type>

value: Box<Type>

Action

An action offered to the person, as a control shows it: what it is called, its icon and role, and what choosing it runs (an event of the instance, never a closure).

Cases

One case of the catalogue’s closed set name whose cases carry fields (Catalogue::enums): a drawing’s shape.

Fields

name: String

Enum

A case of one of the app’s own enums, by its name: which cases it holds is the field the binding names, so a description says only that it takes such a field.

Implementations

impl Type

pub fn show(&self) -> String

How the type reads in messages: Option<Text>, TextRole.

Trait Implementations

impl Clone for Type

fn clone(&self) -> Type

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Type

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Type

fn deserialize<__D>( __deserializer: __D, ) -> Result<Type, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Type

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Type

impl StructuralPartialEq for Type