Struct ParElem 

pub struct ParElem {
    pub leading: Settable<Self, 0u8>,
    pub spacing: Settable<Self, 1u8>,
    pub justify: Settable<Self, 2u8>,
    pub justification_limits: Settable<Self, 3u8>,
    pub linebreaks: Settable<Self, 4u8>,
    pub first_line_indent: Settable<Self, 5u8>,
    pub hanging_indent: Settable<Self, 6u8>,
    pub body: Content,
}

A logical subdivison of textual content.

Typst automatically collects inline-level elements into paragraphs. Inline-level elements include [text], horizontal spacing, boxes, and inline equations.

To separate paragraphs, use a blank line (or an explicit [parbreak]). Paragraphs are also automatically interrupted by any block-level element (like [block], [place], or anything that shows itself as one of these).

The par element is primarily used in set rules to affect paragraph properties, but it can also be used to explicitly display its argument as a paragraph of its own. Then, the paragraph’s body may not contain any block-level content.

Boxes and blocks

As explained above, usually paragraphs only contain inline-level content. However, you can integrate any kind of block-level content into a paragraph by wrapping it in a [box].

Conversely, you can separate inline-level content from a paragraph by wrapping it in a [block]. In this case, it will not become part of any paragraph at all. Read the following section for an explanation of why that matters and how it differs from just adding paragraph breaks around the content.

What becomes a paragraph?

When you add inline-level content to your document, Typst will automatically wrap it in paragraphs. However, a typical document also contains some text that is not semantically part of a paragraph, for example in a heading or caption.

The rules for when Typst wraps inline-level content in a paragraph are as follows:

• All text at the root of a document is wrapped in paragraphs.

• Text in a container (like a block) is only wrapped in a paragraph if the container holds any block-level content. If all of the contents are inline-level, no paragraph is created.

In the laid-out document, it’s not immediately visible whether text became part of a paragraph. However, it is still important for various reasons:

• Certain paragraph styling like first-line-indent will only apply to proper paragraphs, not any text. Similarly, par show rules of course only trigger on paragraphs.

• A proper distinction between paragraphs and other text helps people who rely on Assistive Technology (AT) (such as screen readers) navigate and understand the document properly.

• PDF export will generate a P tag only for paragraphs.

• HTML export will generate a <p> tag only for paragraphs.

When creating custom reusable components, you can and should take charge over whether Typst creates paragraphs. By wrapping text in a [block] instead of just adding paragraph breaks around it, you can force the absence of a paragraph. Conversely, by adding a [parbreak] after some content in a container, you can force it to become a paragraph even if it’s just one word. This is, for example, what non-tight lists do to force their items to become paragraphs.

Example

#set par(
  first-line-indent: 1em,
  spacing: 0.65em,
  justify: true,
)

We proceed by contradiction.
Suppose that there exists a set
of positive integers $a$, $b$, and
$c$ that satisfies the equation
$a^n + b^n = c^n$ for some
integer value of $n > 2$.

Without loss of generality,
let $a$ be the smallest of the
three integers. Then, we ...

Fields

leading: Settable<Self, 0u8>

spacing: Settable<Self, 1u8>

justify: Settable<Self, 2u8>

justification_limits: Settable<Self, 3u8>

linebreaks: Settable<Self, 4u8>

first_line_indent: Settable<Self, 5u8>

hanging_indent: Settable<Self, 6u8>

body: Content

Implementations

impl ParElem

pub fn new(body: Content) -> Self

Create a new instance of the element.

pub fn with_leading(self, leading: Length) -> Self

Builder-style setter for the leading field.

pub fn with_spacing(self, spacing: Length) -> Self

Builder-style setter for the spacing field.

pub fn with_justify(self, justify: bool) -> Self

Builder-style setter for the justify field.

pub fn with_justification_limits( self, justification_limits: JustificationLimits, ) -> Self

Builder-style setter for the justification-limits field.

pub fn with_linebreaks(self, linebreaks: Smart<Linebreaks>) -> Self

Builder-style setter for the linebreaks field.

pub fn with_first_line_indent(self, first_line_indent: FirstLineIndent) -> Self

Builder-style setter for the first-line-indent field.

pub fn with_hanging_indent(self, hanging_indent: Length) -> Self

Builder-style setter for the hanging-indent field.

impl ParElem

pub const leading: Field<Self, 0u8>

pub const spacing: Field<Self, 1u8>

pub const justify: Field<Self, 2u8>

pub const justification_limits: Field<Self, 3u8>

pub const linebreaks: Field<Self, 4u8>

pub const first_line_indent: Field<Self, 5u8>

pub const hanging_indent: Field<Self, 6u8>

pub const body: Field<Self, 7u8>

Trait Implementations

impl Clone for ParElem

fn clone(&self) -> ParElem

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Construct for ParElem

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

Construct an element from the arguments.

impl Debug for ParElem

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

Formats the value using the given formatter.

impl Hash for ParElem

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 ParElem

const ELEM: Element

The associated element.

fn pack(self) -> Content

Pack the element into type-erased content.

impl NativeScope for ParElem

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

The constructor function for the type, if any.

fn scope() -> Scope

Get the associated scope for the type.

impl RequiredField<7> for ParElem

const FIELD: RequiredFieldData<Self, 7u8>

type Type = Content

impl Set for ParElem

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

Parse relevant arguments into style properties for this element.

impl SettableField<0> for ParElem

const FIELD: SettableFieldData<Self, 0u8>

type Type = Length

impl SettableField<1> for ParElem

const FIELD: SettableFieldData<Self, 1u8>

type Type = Length

impl SettableField<2> for ParElem

const FIELD: SettableFieldData<Self, 2u8>

type Type = bool

impl SettableField<3> for ParElem

const FIELD: SettableFieldData<Self, 3u8>

type Type = JustificationLimits

impl SettableField<4> for ParElem

const FIELD: SettableFieldData<Self, 4u8>

type Type = Smart<Linebreaks>

impl SettableField<5> for ParElem

const FIELD: SettableFieldData<Self, 5u8>

type Type = FirstLineIndent

impl SettableField<6> for ParElem

const FIELD: SettableFieldData<Self, 6u8>

type Type = Length

impl RefableProperty<0> for ParElem

impl RefableProperty<1> for ParElem

impl RefableProperty<2> for ParElem

impl RefableProperty<4> for ParElem

impl RefableProperty<5> for ParElem

impl RefableProperty<6> for ParElem