Struct TableElem 

pub struct TableElem {
    pub columns: Settable<Self, 0u8>,
    pub rows: Settable<Self, 1u8>,
    pub column_gutter: Settable<Self, 3u8>,
    pub row_gutter: Settable<Self, 4u8>,
    pub inset: Settable<Self, 5u8>,
    pub align: Settable<Self, 6u8>,
    pub fill: Settable<Self, 7u8>,
    pub stroke: Settable<Self, 8u8>,
    pub children: Vec<TableChild>,
    pub summary: Settable<Self, 10u8>,
    pub grid: Option<Arc<CellGrid>>,
}

A table of items.

Tables are used to arrange content in cells. Cells can contain arbitrary content, including multiple paragraphs and are specified in row-major order. For a hands-on explanation of all the ways you can use and customize tables in Typst, check out the Table Guide.

Because tables are just grids with different defaults for some cell properties (notably stroke and inset), refer to the grid documentation for more information on how to size the table tracks and specify the cell appearance properties.

If you are unsure whether you should be using a table or a grid, consider whether the content you are arranging semantically belongs together as a set of related data points or similar or whether you are just want to enhance your presentation by arranging unrelated content in a grid. In the former case, a table is the right choice, while in the latter case, a grid is more appropriate. Furthermore, Assistive Technology (AT) like screen readers will announce content in a table as tabular while a grid’s content will be announced no different than multiple content blocks in the document flow. AT users will be able to navigate tables two-dimensionally by cell.

Note that, to override a particular cell’s properties or apply show rules on table cells, you can use the [table.cell] element. See its documentation for more information.

Although the table and the grid share most properties, set and show rules on one of them do not affect the other. Locating most of your styling in set and show rules is recommended, as it keeps the table’s actual usages clean and easy to read. It also allows you to easily change the appearance of all tables in one place.

To give a table a caption and make it referenceable, put it into a [figure].

Example

The example below demonstrates some of the most common table options.

#table(
  columns: (1fr, auto, auto),
  inset: 10pt,
  align: horizon,
  table.header(
    [], [*Volume*], [*Parameters*],
  ),
  image("cylinder.svg"),
  $ pi h (D^2 - d^2) / 4 $,
  [
    $h$: height \
    $D$: outer radius \
    $d$: inner radius
  ],
  image("tetrahedron.svg"),
  $ sqrt(2) / 12 a^3 $,
  [$a$: edge length]
)

Much like with grids, you can use [table.cell] to customize the appearance and the position of each cell.

>>> #set page(width: auto)
>>> #set text(font: "IBM Plex Sans")
>>> #let gray = rgb("#565565")
>>>
#set table(
  stroke: none,
  gutter: 0.2em,
  fill: (x, y) =>
    if x == 0 or y == 0 { gray },
  inset: (right: 1.5em),
)

#show table.cell: it => {
  if it.x == 0 or it.y == 0 {
    set text(white)
    strong(it)
  } else if it.body == [] {
    // Replace empty cells with 'N/A'
    pad(..it.inset)[_N/A_]
  } else {
    it
  }
}

#let a = table.cell(
  fill: green.lighten(60%),
)[A]
#let b = table.cell(
  fill: aqua.lighten(60%),
)[B]

#table(
  columns: 4,
  [], [Exam 1], [Exam 2], [Exam 3],

  [John], [], a, [],
  [Mary], [], a, a,
  [Robert], b, a, b,
)

Accessibility

Tables are challenging to consume for users of Assistive Technology (AT). To make the life of AT users easier, we strongly recommend that you use [table.header] and [table.footer] to mark the header and footer sections of your table. This will allow AT to announce the column labels for each cell.

Because navigating a table by cell is more cumbersome than reading it visually, you should consider making the core information in your table available as text as well. You can do this by wrapping your table in a [figure] and using its caption to summarize the table’s content.

Fields

columns: Settable<Self, 0u8>

rows: Settable<Self, 1u8>

column_gutter: Settable<Self, 3u8>

row_gutter: Settable<Self, 4u8>

inset: Settable<Self, 5u8>

align: Settable<Self, 6u8>

fill: Settable<Self, 7u8>

stroke: Settable<Self, 8u8>

children: Vec<TableChild>

summary: Settable<Self, 10u8>

grid: Option<Arc<CellGrid>>

Implementations

impl TableElem

pub fn new(children: Vec<TableChild>) -> Self

Create a new instance of the element.

pub fn with_columns(self, columns: TrackSizings) -> Self

Builder-style setter for the columns field.

pub fn with_rows(self, rows: TrackSizings) -> Self

Builder-style setter for the rows field.

pub fn with_column_gutter(self, column_gutter: TrackSizings) -> Self

Builder-style setter for the column-gutter field.

pub fn with_row_gutter(self, row_gutter: TrackSizings) -> Self

Builder-style setter for the row-gutter field.

pub fn with_inset(self, inset: Celled<Sides<Option<Rel<Length>>>>) -> Self

Builder-style setter for the inset field.

pub fn with_align(self, align: Celled<Smart<Alignment>>) -> Self

Builder-style setter for the align field.

pub fn with_fill(self, fill: Celled<Option<Paint>>) -> Self

Builder-style setter for the fill field.

pub fn with_stroke( self, stroke: Celled<Sides<Option<Option<Arc<Stroke>>>>>, ) -> Self

Builder-style setter for the stroke field.

pub fn with_summary(self, summary: Option<EcoString>) -> Self

Builder-style setter for the summary field.

pub fn with_grid(self, grid: Arc<CellGrid>) -> Self

Builder-style setter for the grid field.

impl TableElem

pub const columns: Field<Self, 0u8>

pub const rows: Field<Self, 1u8>

pub const column_gutter: Field<Self, 3u8>

pub const row_gutter: Field<Self, 4u8>

pub const inset: Field<Self, 5u8>

pub const align: Field<Self, 6u8>

pub const fill: Field<Self, 7u8>

pub const stroke: Field<Self, 8u8>

pub const children: Field<Self, 9u8>

pub const summary: Field<Self, 10u8>

pub const grid: Field<Self, 11u8>

Trait Implementations

impl Clone for TableElem

fn clone(&self) -> TableElem

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Construct for TableElem

fn construct(engine: &mut Engine<'_>, args: &mut Args) -> SourceResult<Content>

Construct an element from the arguments.

impl Debug for TableElem

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

Formats the value using the given formatter.

impl ExternalField<2> for TableElem

const FIELD: ExternalFieldData<Self, 2u8>

type Type = TrackSizings

impl FromValue for TableElem

fn from_value(value: Value) -> HintedStrResult<Self>

Try to cast the value into an instance of Self.

impl Hash for TableElem

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 NativeElement for TableElem

const ELEM: Element

The associated element.

fn pack(self) -> Content

Pack the element into type-erased content.

impl NativeScope for TableElem

fn constructor() -> Option<&'static NativeFuncData>

The constructor function for the type, if any.

fn scope() -> Scope

Get the associated scope for the type.

impl Reflect for TableElem

fn input() -> CastInfo

Describe what can be cast into this value.

fn output() -> CastInfo

Describe what this value can be cast into.

fn castable(value: &Value) -> bool

Whether the given value can be converted to T.

fn error(found: &Value) -> HintedString

Produce an error message for an unacceptable value type.

impl RequiredField<9> for TableElem

const FIELD: RequiredFieldData<Self, 9u8>

type Type = Vec<TableChild>

impl Set for TableElem

fn set(engine: &mut Engine<'_>, args: &mut Args) -> SourceResult<Styles>

Parse relevant arguments into style properties for this element.

impl SettableField<0> for TableElem

const FIELD: SettableFieldData<Self, 0u8>

type Type = TrackSizings

impl SettableField<1> for TableElem

const FIELD: SettableFieldData<Self, 1u8>

type Type = TrackSizings

impl SettableField<10> for TableElem

const FIELD: SettableFieldData<Self, 10u8>

type Type = Option<EcoString>

impl SettableField<3> for TableElem

const FIELD: SettableFieldData<Self, 3u8>

type Type = TrackSizings

impl SettableField<4> for TableElem

const FIELD: SettableFieldData<Self, 4u8>

type Type = TrackSizings

impl SettableField<5> for TableElem

const FIELD: SettableFieldData<Self, 5u8>

type Type = Celled<Sides<Option<Rel>>>

impl SettableField<6> for TableElem

const FIELD: SettableFieldData<Self, 6u8>

type Type = Celled<Smart<Alignment>>

impl SettableField<7> for TableElem

const FIELD: SettableFieldData<Self, 7u8>

type Type = Celled<Option<Paint>>

impl SettableField<8> for TableElem

const FIELD: SettableFieldData<Self, 8u8>

type Type = Celled<Sides<Option<Option<Arc<Stroke>>>>>

impl SynthesizedField<11> for TableElem

const FIELD: SynthesizedFieldData<Self, 11u8>

type Type = Arc<CellGrid>

impl RefableProperty<0> for TableElem

impl RefableProperty<1> for TableElem

impl RefableProperty<10> for TableElem

impl RefableProperty<3> for TableElem

impl RefableProperty<4> for TableElem

impl RefableProperty<6> for TableElem

impl RefableProperty<7> for TableElem