Trait PieceSeq 

pub trait PieceSeq: 'static {
    // Required method
    fn build_each(self, cx: &mut BuildCx);
}

Children of a container (§5.1): a tuple of pieces (the floem ViewTuple pattern), a Vec or array of one piece type, or an Option of a piece. Implemented for exactly those shapes, never via a blanket, to stay coherent. All of them are build-time children: evaluated once when the parent builds, with no keyed identity or reconciliation. A child that must come and go at runtime is a when, a keyed, or an each.

Required Methods

fn build_each(self, cx: &mut BuildCx)

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl PieceSeq for ()

fn build_each(self, _cx: &mut BuildCx)

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Q> PieceSeq for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Q)

where A: Piece, B: Piece, C: Piece, D: Piece, E: Piece, F: Piece, G: Piece, H: Piece, I: Piece, J: Piece, K: Piece, L: Piece, M: Piece, N: Piece, O: Piece, Q: Piece,

fn build_each(self, cx: &mut BuildCx)

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> PieceSeq for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)

where A: Piece, B: Piece, C: Piece, D: Piece, E: Piece, F: Piece, G: Piece, H: Piece, I: Piece, J: Piece, K: Piece, L: Piece, M: Piece, N: Piece, O: Piece,

fn build_each(self, cx: &mut BuildCx)

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N> PieceSeq for (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

where A: Piece, B: Piece, C: Piece, D: Piece, E: Piece, F: Piece, G: Piece, H: Piece, I: Piece, J: Piece, K: Piece, L: Piece, M: Piece, N: Piece,

fn build_each(self, cx: &mut BuildCx)

impl<A, B, C, D, E, F, G, H, I, J, K, L, M> PieceSeq for (A, B, C, D, E, F, G, H, I, J, K, L, M)

where A: Piece, B: Piece, C: Piece, D: Piece, E: Piece, F: Piece, G: Piece, H: Piece, I: Piece, J: Piece, K: Piece, L: Piece, M: Piece,

fn build_each(self, cx: &mut BuildCx)

impl<A, B, C, D, E, F, G, H, I, J, K, L> PieceSeq for (A, B, C, D, E, F, G, H, I, J, K, L)

where A: Piece, B: Piece, C: Piece, D: Piece, E: Piece, F: Piece, G: Piece, H: Piece, I: Piece, J: Piece, K: Piece, L: Piece,

fn build_each(self, cx: &mut BuildCx)

impl<A, B, C, D, E, F, G, H, I, J, K> PieceSeq for (A, B, C, D, E, F, G, H, I, J, K)

where A: Piece, B: Piece, C: Piece, D: Piece, E: Piece, F: Piece, G: Piece, H: Piece, I: Piece, J: Piece, K: Piece,

fn build_each(self, cx: &mut BuildCx)

impl<A, B, C, D, E, F, G, H, I, J> PieceSeq for (A, B, C, D, E, F, G, H, I, J)

where A: Piece, B: Piece, C: Piece, D: Piece, E: Piece, F: Piece, G: Piece, H: Piece, I: Piece, J: Piece,

fn build_each(self, cx: &mut BuildCx)

impl<A, B, C, D, E, F, G, H, I> PieceSeq for (A, B, C, D, E, F, G, H, I)

where A: Piece, B: Piece, C: Piece, D: Piece, E: Piece, F: Piece, G: Piece, H: Piece, I: Piece,

fn build_each(self, cx: &mut BuildCx)

impl<A, B, C, D, E, F, G, H> PieceSeq for (A, B, C, D, E, F, G, H)

where A: Piece, B: Piece, C: Piece, D: Piece, E: Piece, F: Piece, G: Piece, H: Piece,

fn build_each(self, cx: &mut BuildCx)

impl<A, B, C, D, E, F, G> PieceSeq for (A, B, C, D, E, F, G)

where A: Piece, B: Piece, C: Piece, D: Piece, E: Piece, F: Piece, G: Piece,

fn build_each(self, cx: &mut BuildCx)

impl<A, B, C, D, E, F> PieceSeq for (A, B, C, D, E, F)

where A: Piece, B: Piece, C: Piece, D: Piece, E: Piece, F: Piece,

fn build_each(self, cx: &mut BuildCx)

impl<A, B, C, D, E> PieceSeq for (A, B, C, D, E)

where A: Piece, B: Piece, C: Piece, D: Piece, E: Piece,

fn build_each(self, cx: &mut BuildCx)

impl<A, B, C, D> PieceSeq for (A, B, C, D)

where A: Piece, B: Piece, C: Piece, D: Piece,

fn build_each(self, cx: &mut BuildCx)

impl<A, B, C> PieceSeq for (A, B, C)

where A: Piece, B: Piece, C: Piece,

fn build_each(self, cx: &mut BuildCx)

impl<A, B> PieceSeq for (A, B)

where A: Piece, B: Piece,

fn build_each(self, cx: &mut BuildCx)

impl<A> PieceSeq for (A,)

where A: Piece,

fn build_each(self, cx: &mut BuildCx)

impl<P, const N: usize> PieceSeq for [P; N]

where P: Piece,

fn build_each(self, cx: &mut BuildCx)

impl<P> PieceSeq for Option<P>

where P: Piece,

A child that may be absent: None builds nothing at all (no node).

fn build_each(self, cx: &mut BuildCx)

impl<P> PieceSeq for Vec<P>

where P: Piece,

A homogeneous list of children, which is also how a runtime-heterogeneous list reads: row(items.iter().map(cell).collect::<Vec<_>>()), or a Vec<AnyPiece> when the children differ in type.

fn build_each(self, cx: &mut BuildCx)

Implementors