Struct Ligature 

pub struct Ligature {
    pub char: char,
    pub font: FontId,
    pub original_chars: Rc<str>,
    pub includes_left_boundary: bool,
    pub includes_right_boundary: bool,
}

A ligature.

Described in TeX.2021.143.

Fields

char: char

font: FontId

original_chars: Rc<str>

The original characters that were replaced by the ligature. This is used if the engine needs to break apart the ligature in order to perform hyphenation.

While most ligatures come from 2 characters (e.g. ff), TeX’s lig/kern programming language allows for a single ligature to come from arbitrarily many characters.

includes_left_boundary: bool

includes_right_boundary: bool

Implementations

impl Ligature

pub fn standardize_lossy(&mut self)

Puts the ligature into a lossy standard form.

What follows is the motivation for this method.

TeX supports logging its internal typesetting data structures. All of these data structures are reimplemented in this module, and can be reconstructed from TeX’s log output using the Boxworks TeX log parsing logic. This system used throughout Boxworks to verify that Boxworks’s typesetting code gives the identical results to TeX’s.

Unfortunately, however, TeX’s display logic for ligatures specifically is lossy. In the TeX’s logging format the line

..\tenrm a (ligature |)

can mean one of three things:

• a ligature ‘a’ that replaces the character |,
• a ligature ‘a’ that replaces the left boundary, or
• a ligature ‘a’ that replaces the right boundary.

This means that it’s not possible to reconstruct fully the internal ligature data structure from the logging output. Boxworks TeX log parsing logic assumes the first interpretation holds: the log line is parsed into the following value:

Ligature {
    char: 'a',
    font: common::FontId::ONE,
    original_chars: "|".into(),
    includes_left_boundary: false,
    includes_right_boundary: false,
};

This specifically presents issues when we want to verify TeX’s output with Boxworks where the correct value is, say,

Ligature {
    char: 'a',
    font: common::FontId::ONE,
    original_chars: "".into(),
    includes_left_boundary: false,
    includes_right_boundary: true,
};

A unit test that compares these outputs will fail.

This method is designed to help write unit tests that pass. It standardizes the ligature into the from parse from TeX. We can then compare the standardized form with TeX’s output. This does mean that such unit tests can’t verify which form is the right one.

Trait Implementations

impl Clone for Ligature

fn clone(&self) -> Ligature

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Ligature

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

Formats the value using the given formatter.

impl From<Ligature> for DiscretionaryElem

fn from(value: Ligature) -> Self

Converts to this type from the input type.

impl From<Ligature> for Horizontal

fn from(value: Ligature) -> Self

Converts to this type from the input type.

impl PartialEq for Ligature

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

type Output = Ligature<'static>

fn to_box_lang(&self) -> Self::Output

impl Eq for Ligature

impl StructuralPartialEq for Ligature