Struct Tabs 

pub struct Tabs<M = ()>(/* private fields */);

tabs: a tab strip.

Implementations

impl<M> Tabs<M>

pub fn key(self, key: impl Into<NodeKey>) -> Self

Identity among siblings: keeps the node’s id (and Tern’s view state) across reorders. A string, or an integer.

Examples found in repository

examples/dashboard.rs (line 773)

	fn nav(&self) -> ui::Tabs<Msg> {
		let count = |n: usize| ui::span(n.to_string()).style("muted");
		let open = self
			.incidents
			.iter()
			.filter(|i| i.phase != Phase::Resolved)
			.count();
		ui::tabs()
			.key("nav")
			.active(self.page.id())
			.tab("services", spans!["Services ", count(self.services.len())])
			.tab("deploys", spans!["Deploys ", count(self.deploys.len())])
			.tab("incidents", spans!["Incidents ", count(open)])
			.on_select(|id| Msg::Page(id.to_owned()))
	}

	/// The active view: its table beside the selected row's detail card
	/// (under it when `plain`).
	fn body(&self, plain: bool) -> Node<Msg> {
		let page = self.page;
		let selected = self.selected[page.index()];
		let (list, detail) = match page {
			Page::Services => (
				nodes![self.services_table()],
				selected
					.and_then(|id| self.services.iter().find(|s| s.id == id))
					.map(service_card),
			),
			Page::Deploys => (
				nodes![self.deploys_bar(), self.deploys_table()],
				selected
					.and_then(|id| self.deploys.iter().find(|d| d.id == id))
					.map(deploy_card),
			),
			Page::Incidents => (
				nodes![self.incidents_table()],
				selected
					.and_then(|id| self.incidents.iter().find(|i| i.id == id))
					.map(incident_card),
			),
		};
		let mut parts: Vec<Node<Msg>> = nodes![
			ui::col()
				.key("list")
				.gap("sm")
				.grow(1.0)
				.basis(0.0)
				.children(list)
		];
		if let Some(card) = detail {
			parts.push(
				card
					.key("detail")
					.min(Bound::w(Extent::Ch(44.0)))
					.max(Bound::w(Extent::Ch(56.0)))
					.into(),
			);
		}
		if plain {
			ui::col().key(page.id()).gap("md").children(parts).into()
		} else {
			ui::row()
				.key(page.id())
				.align("stretch")
				.gap("lg")
				.children(parts)
				.into()
		}
	}

	/// A selectable table of `page` with its handlers and selection.
	fn table(&self, page: Page, empty: &str) -> ui::Table<Msg> {
		let mut table = ui::table()
			.key("table")
			.selectable(true)
			.empty(empty)
			.on_select(move |id| Msg::Select(page, id.to_owned()))
			.on_activate(move |id| Msg::Open(page, id.to_owned()));
		if let Some(id) = self.selected[page.index()] {
			table = table.selected(id);
		}
		table
	}

	/// The services table.
	fn services_table(&self) -> ui::Table<Msg> {
		let mut table = self
			.table(Page::Services, "No services yet")
			.col(Column::new("name", "Service").grow(1.0).priority(6.0))
			.col(Column::new("region", "Region").priority(3.0))
			.col(Column::new("version", "Version").mono(true).priority(2.0))
			.col(Column::new("traffic", "Traffic").priority(1.0))
			.col(
				Column::new("rps", "req/s")
					.align(TextAlign::End)
					.mono(true)
					.priority(4.0),
			)
			.col(
				Column::new("p95", "p95")
					.align(TextAlign::End)
					.mono(true)
					.priority(4.0),
			)
			.col(
				Column::new("errors", "Errors")
					.align(TextAlign::End)
					.mono(true)
					.priority(4.0),
			)
			.col(Column::new("health", "Health").priority(5.0));
		for s in &self.services {
			let (label, tone) = s.health.look();
			let mut errors = TextCell::new(format!("{:.1}%", s.errors));
			if s.errors >= 1.0 {
				errors = errors.tone(Tone::Error);
			}
			table = table.row(
				TableRow::new(s.id)
					.cell("name", TextCell::new(s.id).dot(tone.clone()))
					.cell("region", s.region)
					.cell("version", s.version)
					.cell("traffic", SparkCell::new(s.rps.clone()))
					.cell("rps", format!("{:.0}", s.rps.last().copied().unwrap_or_default()))
					.cell("p95", format!("{:.0} ms", s.p95))
					.cell("errors", errors)
					.cell("health", BadgeSpec::new(label).tone(tone)),
			);
		}
		table
	}

	/// The deploys toolbar: a muted description and the filter.
	fn deploys_bar(&self) -> ui::Row<Msg> {
		let attention = self
			.deploys
			.iter()
			.filter(|d| matches!(d.state, State::Waiting | State::Failed))
			.count();
		ui::row()
			.key("bar")
			.justify("between")
			.align("center")
			.child(
				ui::text(ui::span("Rollouts to production, newest first").style("muted")).key("about"),
			)
			.child(
				ui::tabs()
					.key("filter")
					.variant("segmented")
					.active(self.filter.clone())
					.tab("all", "All")
					.tab("attention", spans![
						"Needs you ",
						ui::span(attention.to_string()).style("muted")
					])
					.on_select(|id| Msg::Filter(id.to_owned())),
			)
	}

pub fn role(self, role: impl Into<String>) -> Self

A name of yours, exposed to CSS as data-role.

pub fn tone(self, tone: impl Into<Tone>) -> Self

The semantic color of the node’s chrome.

pub fn hidden(self, hidden: bool) -> Self

Keeps the node mounted but not laid out.

pub fn mark(self, mark: impl Into<Mark>) -> Self

A transient selection mark drawn over the node.

pub fn aria(self, aria: impl Into<String>) -> Self

The accessible name of a node that shows no text.

pub fn hovercard<N>(self, card: impl Into<Node<N>>) -> Self

A floating card of card’s tree shown while the pointer rests on the node, in place of title. Sent id-less (ids, keys and handlers inside are ignored); an older Tern ignores it.

pub fn href(self, href: impl Into<String>) -> Self

A link: ⌘-click opens it; copy and open use it.

pub fn grow(self, grow: f64) -> Self

Flex grow inside a row or col.

pub fn shrink(self, shrink: f64) -> Self

Flex shrink inside a row or col.

pub fn basis(self, basis: impl Into<Basis>) -> Self

Flex basis: a fraction of the parent, or the content’s size.

pub fn prop(self, name: &str, value: impl Serialize) -> Self

Sets any prop untyped; null removes it.

pub fn min(self, min: Bound) -> Self

Lower size bounds.

pub fn title(self, title: impl Into<String>) -> Self

A tooltip.

pub fn max(self, max: Bound) -> Self

Upper size bounds (a max.h also clips the node).

pub fn actions(self, actions: Actions) -> Self

What a pointer does, by action name.

pub fn on_click(self, msg: M) -> Self

where M: Clone + Send + Sync + 'static,

Sends msg on a click (sets actions.click to "click" unless the node names its click action itself).

pub fn on_dblclick(self, msg: M) -> Self

where M: Clone + Send + Sync + 'static,

Sends msg on a double click (sets actions.dblclick to "dblclick" unless the node names it).

pub fn on_menu(self, act: impl Into<String>, msg: M) -> Self

where M: Clone + Send + Sync + 'static,

Adds act to the context menu and sends msg when it is picked.

pub fn on_action(self, act: impl Into<String>, msg: M) -> Self

where M: Clone + Send + Sync + 'static,

Sends msg on action events whose action is act (name or name=value).

pub fn on_action_with( self, act: impl Into<String>, f: impl Fn(&Action) -> M + Send + Sync + 'static, ) -> Self

Maps action events whose action is act to a message.

pub fn on_toggle(self, f: impl Fn(bool) -> M + Send + Sync + 'static) -> Self

Maps toggle events (the new collapsed; a menu, select or trace line that opened is not collapsed) to a message.

pub fn on_select(self, f: impl Fn(&str) -> M + Send + Sync + 'static) -> Self

Maps select events (the item) to a message. On a list’s item the item’s own handler runs first.

Examples found in repository

examples/dashboard.rs (line 778)

	fn nav(&self) -> ui::Tabs<Msg> {
		let count = |n: usize| ui::span(n.to_string()).style("muted");
		let open = self
			.incidents
			.iter()
			.filter(|i| i.phase != Phase::Resolved)
			.count();
		ui::tabs()
			.key("nav")
			.active(self.page.id())
			.tab("services", spans!["Services ", count(self.services.len())])
			.tab("deploys", spans!["Deploys ", count(self.deploys.len())])
			.tab("incidents", spans!["Incidents ", count(open)])
			.on_select(|id| Msg::Page(id.to_owned()))
	}

	/// The active view: its table beside the selected row's detail card
	/// (under it when `plain`).
	fn body(&self, plain: bool) -> Node<Msg> {
		let page = self.page;
		let selected = self.selected[page.index()];
		let (list, detail) = match page {
			Page::Services => (
				nodes![self.services_table()],
				selected
					.and_then(|id| self.services.iter().find(|s| s.id == id))
					.map(service_card),
			),
			Page::Deploys => (
				nodes![self.deploys_bar(), self.deploys_table()],
				selected
					.and_then(|id| self.deploys.iter().find(|d| d.id == id))
					.map(deploy_card),
			),
			Page::Incidents => (
				nodes![self.incidents_table()],
				selected
					.and_then(|id| self.incidents.iter().find(|i| i.id == id))
					.map(incident_card),
			),
		};
		let mut parts: Vec<Node<Msg>> = nodes![
			ui::col()
				.key("list")
				.gap("sm")
				.grow(1.0)
				.basis(0.0)
				.children(list)
		];
		if let Some(card) = detail {
			parts.push(
				card
					.key("detail")
					.min(Bound::w(Extent::Ch(44.0)))
					.max(Bound::w(Extent::Ch(56.0)))
					.into(),
			);
		}
		if plain {
			ui::col().key(page.id()).gap("md").children(parts).into()
		} else {
			ui::row()
				.key(page.id())
				.align("stretch")
				.gap("lg")
				.children(parts)
				.into()
		}
	}

	/// A selectable table of `page` with its handlers and selection.
	fn table(&self, page: Page, empty: &str) -> ui::Table<Msg> {
		let mut table = ui::table()
			.key("table")
			.selectable(true)
			.empty(empty)
			.on_select(move |id| Msg::Select(page, id.to_owned()))
			.on_activate(move |id| Msg::Open(page, id.to_owned()));
		if let Some(id) = self.selected[page.index()] {
			table = table.selected(id);
		}
		table
	}

	/// The services table.
	fn services_table(&self) -> ui::Table<Msg> {
		let mut table = self
			.table(Page::Services, "No services yet")
			.col(Column::new("name", "Service").grow(1.0).priority(6.0))
			.col(Column::new("region", "Region").priority(3.0))
			.col(Column::new("version", "Version").mono(true).priority(2.0))
			.col(Column::new("traffic", "Traffic").priority(1.0))
			.col(
				Column::new("rps", "req/s")
					.align(TextAlign::End)
					.mono(true)
					.priority(4.0),
			)
			.col(
				Column::new("p95", "p95")
					.align(TextAlign::End)
					.mono(true)
					.priority(4.0),
			)
			.col(
				Column::new("errors", "Errors")
					.align(TextAlign::End)
					.mono(true)
					.priority(4.0),
			)
			.col(Column::new("health", "Health").priority(5.0));
		for s in &self.services {
			let (label, tone) = s.health.look();
			let mut errors = TextCell::new(format!("{:.1}%", s.errors));
			if s.errors >= 1.0 {
				errors = errors.tone(Tone::Error);
			}
			table = table.row(
				TableRow::new(s.id)
					.cell("name", TextCell::new(s.id).dot(tone.clone()))
					.cell("region", s.region)
					.cell("version", s.version)
					.cell("traffic", SparkCell::new(s.rps.clone()))
					.cell("rps", format!("{:.0}", s.rps.last().copied().unwrap_or_default()))
					.cell("p95", format!("{:.0} ms", s.p95))
					.cell("errors", errors)
					.cell("health", BadgeSpec::new(label).tone(tone)),
			);
		}
		table
	}

	/// The deploys toolbar: a muted description and the filter.
	fn deploys_bar(&self) -> ui::Row<Msg> {
		let attention = self
			.deploys
			.iter()
			.filter(|d| matches!(d.state, State::Waiting | State::Failed))
			.count();
		ui::row()
			.key("bar")
			.justify("between")
			.align("center")
			.child(
				ui::text(ui::span("Rollouts to production, newest first").style("muted")).key("about"),
			)
			.child(
				ui::tabs()
					.key("filter")
					.variant("segmented")
					.active(self.filter.clone())
					.tab("all", "All")
					.tab("attention", spans![
						"Needs you ",
						ui::span(attention.to_string()).style("muted")
					])
					.on_select(|id| Msg::Filter(id.to_owned())),
			)
	}

pub fn on_activate(self, f: impl Fn(&str) -> M + Send + Sync + 'static) -> Self

Maps activate events (the item) to a message.

pub fn on_change(self, f: impl Fn(&Change) -> M + Send + Sync + 'static) -> Self

Maps change events to a message.

pub fn on_focus(self, msg: M) -> Self

where M: Clone + Send + Sync + 'static,

Sends msg on focus events (a click asked for the keys).

pub fn on_edit(self, f: impl Fn(&Edit) -> M + Send + Sync + 'static) -> Self

Maps edit events (native editing) to a message.

pub fn on_undo(self, msg: M) -> Self

where M: Clone + Send + Sync + 'static,

Sends msg on undo events.

pub fn on_send(self, f: impl Fn(&str) -> M + Send + Sync + 'static) -> Self

Maps send events (the text to submit) to a message.

impl<M> Tabs<M>

pub fn items(self, value: impl Into<Vec<Tab>>) -> Self

All tabs.

pub fn active(self, value: impl Into<String>) -> Self

The active tab’s id.

Examples found in repository

examples/dashboard.rs (line 774)

	fn nav(&self) -> ui::Tabs<Msg> {
		let count = |n: usize| ui::span(n.to_string()).style("muted");
		let open = self
			.incidents
			.iter()
			.filter(|i| i.phase != Phase::Resolved)
			.count();
		ui::tabs()
			.key("nav")
			.active(self.page.id())
			.tab("services", spans!["Services ", count(self.services.len())])
			.tab("deploys", spans!["Deploys ", count(self.deploys.len())])
			.tab("incidents", spans!["Incidents ", count(open)])
			.on_select(|id| Msg::Page(id.to_owned()))
	}

	/// The active view: its table beside the selected row's detail card
	/// (under it when `plain`).
	fn body(&self, plain: bool) -> Node<Msg> {
		let page = self.page;
		let selected = self.selected[page.index()];
		let (list, detail) = match page {
			Page::Services => (
				nodes![self.services_table()],
				selected
					.and_then(|id| self.services.iter().find(|s| s.id == id))
					.map(service_card),
			),
			Page::Deploys => (
				nodes![self.deploys_bar(), self.deploys_table()],
				selected
					.and_then(|id| self.deploys.iter().find(|d| d.id == id))
					.map(deploy_card),
			),
			Page::Incidents => (
				nodes![self.incidents_table()],
				selected
					.and_then(|id| self.incidents.iter().find(|i| i.id == id))
					.map(incident_card),
			),
		};
		let mut parts: Vec<Node<Msg>> = nodes![
			ui::col()
				.key("list")
				.gap("sm")
				.grow(1.0)
				.basis(0.0)
				.children(list)
		];
		if let Some(card) = detail {
			parts.push(
				card
					.key("detail")
					.min(Bound::w(Extent::Ch(44.0)))
					.max(Bound::w(Extent::Ch(56.0)))
					.into(),
			);
		}
		if plain {
			ui::col().key(page.id()).gap("md").children(parts).into()
		} else {
			ui::row()
				.key(page.id())
				.align("stretch")
				.gap("lg")
				.children(parts)
				.into()
		}
	}

	/// A selectable table of `page` with its handlers and selection.
	fn table(&self, page: Page, empty: &str) -> ui::Table<Msg> {
		let mut table = ui::table()
			.key("table")
			.selectable(true)
			.empty(empty)
			.on_select(move |id| Msg::Select(page, id.to_owned()))
			.on_activate(move |id| Msg::Open(page, id.to_owned()));
		if let Some(id) = self.selected[page.index()] {
			table = table.selected(id);
		}
		table
	}

	/// The services table.
	fn services_table(&self) -> ui::Table<Msg> {
		let mut table = self
			.table(Page::Services, "No services yet")
			.col(Column::new("name", "Service").grow(1.0).priority(6.0))
			.col(Column::new("region", "Region").priority(3.0))
			.col(Column::new("version", "Version").mono(true).priority(2.0))
			.col(Column::new("traffic", "Traffic").priority(1.0))
			.col(
				Column::new("rps", "req/s")
					.align(TextAlign::End)
					.mono(true)
					.priority(4.0),
			)
			.col(
				Column::new("p95", "p95")
					.align(TextAlign::End)
					.mono(true)
					.priority(4.0),
			)
			.col(
				Column::new("errors", "Errors")
					.align(TextAlign::End)
					.mono(true)
					.priority(4.0),
			)
			.col(Column::new("health", "Health").priority(5.0));
		for s in &self.services {
			let (label, tone) = s.health.look();
			let mut errors = TextCell::new(format!("{:.1}%", s.errors));
			if s.errors >= 1.0 {
				errors = errors.tone(Tone::Error);
			}
			table = table.row(
				TableRow::new(s.id)
					.cell("name", TextCell::new(s.id).dot(tone.clone()))
					.cell("region", s.region)
					.cell("version", s.version)
					.cell("traffic", SparkCell::new(s.rps.clone()))
					.cell("rps", format!("{:.0}", s.rps.last().copied().unwrap_or_default()))
					.cell("p95", format!("{:.0} ms", s.p95))
					.cell("errors", errors)
					.cell("health", BadgeSpec::new(label).tone(tone)),
			);
		}
		table
	}

	/// The deploys toolbar: a muted description and the filter.
	fn deploys_bar(&self) -> ui::Row<Msg> {
		let attention = self
			.deploys
			.iter()
			.filter(|d| matches!(d.state, State::Waiting | State::Failed))
			.count();
		ui::row()
			.key("bar")
			.justify("between")
			.align("center")
			.child(
				ui::text(ui::span("Rollouts to production, newest first").style("muted")).key("about"),
			)
			.child(
				ui::tabs()
					.key("filter")
					.variant("segmented")
					.active(self.filter.clone())
					.tab("all", "All")
					.tab("attention", spans![
						"Needs you ",
						ui::span(attention.to_string()).style("muted")
					])
					.on_select(|id| Msg::Filter(id.to_owned())),
			)
	}

pub fn variant(self, value: impl Into<TabsVariant>) -> Self

Underline (default) or a segmented well.

Examples found in repository

examples/dashboard.rs (line 914)

	fn deploys_bar(&self) -> ui::Row<Msg> {
		let attention = self
			.deploys
			.iter()
			.filter(|d| matches!(d.state, State::Waiting | State::Failed))
			.count();
		ui::row()
			.key("bar")
			.justify("between")
			.align("center")
			.child(
				ui::text(ui::span("Rollouts to production, newest first").style("muted")).key("about"),
			)
			.child(
				ui::tabs()
					.key("filter")
					.variant("segmented")
					.active(self.filter.clone())
					.tab("all", "All")
					.tab("attention", spans![
						"Needs you ",
						ui::span(attention.to_string()).style("muted")
					])
					.on_select(|id| Msg::Filter(id.to_owned())),
			)
	}

pub fn tab(self, id: impl Into<String>, label: impl Into<Text>) -> Self

Adds a tab.

Examples found in repository

examples/dashboard.rs (line 775)

	fn nav(&self) -> ui::Tabs<Msg> {
		let count = |n: usize| ui::span(n.to_string()).style("muted");
		let open = self
			.incidents
			.iter()
			.filter(|i| i.phase != Phase::Resolved)
			.count();
		ui::tabs()
			.key("nav")
			.active(self.page.id())
			.tab("services", spans!["Services ", count(self.services.len())])
			.tab("deploys", spans!["Deploys ", count(self.deploys.len())])
			.tab("incidents", spans!["Incidents ", count(open)])
			.on_select(|id| Msg::Page(id.to_owned()))
	}

	/// The active view: its table beside the selected row's detail card
	/// (under it when `plain`).
	fn body(&self, plain: bool) -> Node<Msg> {
		let page = self.page;
		let selected = self.selected[page.index()];
		let (list, detail) = match page {
			Page::Services => (
				nodes![self.services_table()],
				selected
					.and_then(|id| self.services.iter().find(|s| s.id == id))
					.map(service_card),
			),
			Page::Deploys => (
				nodes![self.deploys_bar(), self.deploys_table()],
				selected
					.and_then(|id| self.deploys.iter().find(|d| d.id == id))
					.map(deploy_card),
			),
			Page::Incidents => (
				nodes![self.incidents_table()],
				selected
					.and_then(|id| self.incidents.iter().find(|i| i.id == id))
					.map(incident_card),
			),
		};
		let mut parts: Vec<Node<Msg>> = nodes![
			ui::col()
				.key("list")
				.gap("sm")
				.grow(1.0)
				.basis(0.0)
				.children(list)
		];
		if let Some(card) = detail {
			parts.push(
				card
					.key("detail")
					.min(Bound::w(Extent::Ch(44.0)))
					.max(Bound::w(Extent::Ch(56.0)))
					.into(),
			);
		}
		if plain {
			ui::col().key(page.id()).gap("md").children(parts).into()
		} else {
			ui::row()
				.key(page.id())
				.align("stretch")
				.gap("lg")
				.children(parts)
				.into()
		}
	}

	/// A selectable table of `page` with its handlers and selection.
	fn table(&self, page: Page, empty: &str) -> ui::Table<Msg> {
		let mut table = ui::table()
			.key("table")
			.selectable(true)
			.empty(empty)
			.on_select(move |id| Msg::Select(page, id.to_owned()))
			.on_activate(move |id| Msg::Open(page, id.to_owned()));
		if let Some(id) = self.selected[page.index()] {
			table = table.selected(id);
		}
		table
	}

	/// The services table.
	fn services_table(&self) -> ui::Table<Msg> {
		let mut table = self
			.table(Page::Services, "No services yet")
			.col(Column::new("name", "Service").grow(1.0).priority(6.0))
			.col(Column::new("region", "Region").priority(3.0))
			.col(Column::new("version", "Version").mono(true).priority(2.0))
			.col(Column::new("traffic", "Traffic").priority(1.0))
			.col(
				Column::new("rps", "req/s")
					.align(TextAlign::End)
					.mono(true)
					.priority(4.0),
			)
			.col(
				Column::new("p95", "p95")
					.align(TextAlign::End)
					.mono(true)
					.priority(4.0),
			)
			.col(
				Column::new("errors", "Errors")
					.align(TextAlign::End)
					.mono(true)
					.priority(4.0),
			)
			.col(Column::new("health", "Health").priority(5.0));
		for s in &self.services {
			let (label, tone) = s.health.look();
			let mut errors = TextCell::new(format!("{:.1}%", s.errors));
			if s.errors >= 1.0 {
				errors = errors.tone(Tone::Error);
			}
			table = table.row(
				TableRow::new(s.id)
					.cell("name", TextCell::new(s.id).dot(tone.clone()))
					.cell("region", s.region)
					.cell("version", s.version)
					.cell("traffic", SparkCell::new(s.rps.clone()))
					.cell("rps", format!("{:.0}", s.rps.last().copied().unwrap_or_default()))
					.cell("p95", format!("{:.0} ms", s.p95))
					.cell("errors", errors)
					.cell("health", BadgeSpec::new(label).tone(tone)),
			);
		}
		table
	}

	/// The deploys toolbar: a muted description and the filter.
	fn deploys_bar(&self) -> ui::Row<Msg> {
		let attention = self
			.deploys
			.iter()
			.filter(|d| matches!(d.state, State::Waiting | State::Failed))
			.count();
		ui::row()
			.key("bar")
			.justify("between")
			.align("center")
			.child(
				ui::text(ui::span("Rollouts to production, newest first").style("muted")).key("about"),
			)
			.child(
				ui::tabs()
					.key("filter")
					.variant("segmented")
					.active(self.filter.clone())
					.tab("all", "All")
					.tab("attention", spans![
						"Needs you ",
						ui::span(attention.to_string()).style("muted")
					])
					.on_select(|id| Msg::Filter(id.to_owned())),
			)
	}

Trait Implementations

impl<M> Clone for Tabs<M>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<M> Debug for Tabs<M>

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

Formats the value using the given formatter.

impl<M> From<Node<M>> for Tabs<M>

fn from(node: Node<M>) -> Self

Converts to this type from the input type.

impl<M> From<Tabs<M>> for Slot<M>

fn from(n: Tabs<M>) -> Self

Converts to this type from the input type.

impl<M> From<Tabs<M>> for Node<M>

fn from(n: Tabs<M>) -> Self

Converts to this type from the input type.

impl<M> From<Tabs<M>> for View<M>

A bare node is main’s one child.

fn from(n: Tabs<M>) -> Self

Converts to this type from the input type.