Struct Arc 

pub struct Arc<W: Semiring> {
    pub ilabel: Label,
    pub olabel: Label,
    pub weight: W,
    pub nextstate: StateId,
}

A weighted arc (transition) in a finite-state transducer.

Arcs are the fundamental building blocks of FSTs, representing labeled, weighted transitions between states. Each arc specifies:

• An input symbol to consume (or epsilon if ilabel == 0)
• An output symbol to produce (or epsilon if olabel == 0)
• A weight from the semiring W
• The destination state

Type Parameters

• W - The semiring type for arc weights (e.g., TropicalWeight, LogWeight)

Fields

Field	Type	Description
ilabel	Label	Input symbol (0 = epsilon)
olabel	Label	Output symbol (0 = epsilon)
weight	W	Transition weight
nextstate	StateId	Destination state ID

Examples

Creating different types of arcs:

use arcweight::prelude::*;

// Regular arc with different input/output labels
let arc1 = Arc::new(1, 2, TropicalWeight::new(0.5), 3);

// Acceptor arc (same input/output)
let arc2 = Arc::new(1, 1, TropicalWeight::one(), 2);

// Epsilon arc (input=0, output=0)
let epsilon = Arc::epsilon(TropicalWeight::new(0.1), 1);

assert_eq!(arc1.ilabel, 1);
assert_eq!(arc1.olabel, 2);
assert!(epsilon.is_epsilon());

Using arcs in FST construction:

use arcweight::prelude::*;

let mut fst = VectorFst::<TropicalWeight>::new();
let s0 = fst.add_state();
let s1 = fst.add_state();

// Add a transducer arc
fst.add_arc(s0, Arc::new(1, 2, TropicalWeight::new(0.5), s1));

Fields

ilabel: Label

Input label consumed by this transition.

A value of 0 indicates an epsilon transition on the input tape, meaning no symbol is consumed.

olabel: Label

Output label produced by this transition.

A value of 0 indicates an epsilon transition on the output tape, meaning no symbol is produced.

weight: W

Weight of this transition in the semiring W.

The weight represents the cost, probability, or other measure associated with taking this transition, as defined by the semiring.

nextstate: StateId

Destination state ID.

The state that becomes current after taking this transition.

Implementations

impl<W: Semiring> Arc<W>

pub fn new(ilabel: Label, olabel: Label, weight: W, nextstate: StateId) -> Self

Creates a new arc with the specified labels, weight, and destination.

This is the primary constructor for arcs in FST construction.

Arguments

• ilabel - Input label (0 for epsilon)
• olabel - Output label (0 for epsilon)
• weight - Arc weight in the semiring
• nextstate - Destination state ID

Returns

A new Arc with the specified components.

Examples

use arcweight::prelude::*;

let arc = Arc::new(1, 2, TropicalWeight::new(0.5), 3);

assert_eq!(arc.ilabel, 1);
assert_eq!(arc.olabel, 2);
assert_eq!(arc.weight, TropicalWeight::new(0.5));
assert_eq!(arc.nextstate, 3);

Examples found in repository

examples/morphological_analyzer.rs (line 732)

fn build_morphotactic_fst() -> VectorFst<TropicalWeight> {
    let mut fst = VectorFst::new();
    let start = fst.add_state();
    let noun_stem = fst.add_state();
    let noun_inflected = fst.add_state();
    let final_state = fst.add_state();

    fst.set_start(start);
    fst.set_final(final_state, TropicalWeight::one());

    // Simplified morphotactic FST structure
    // Start → NounStem → NounInflected → Final

    // Add noun stem "cat"
    for ch in "cat".chars() {
        let next = fst.add_state();
        fst.add_arc(
            start,
            Arc::new(ch as u32, ch as u32, TropicalWeight::one(), next),
        );
    }

    // Add morpheme boundary
    fst.add_arc(
        noun_stem,
        Arc::new(
            '+' as u32,
            0, // epsilon output
            TropicalWeight::one(),
            noun_inflected,
        ),
    );

    // Add plural suffix "s"
    fst.add_arc(
        noun_inflected,
        Arc::new('s' as u32, 's' as u32, TropicalWeight::one(), final_state),
    );

    fst
}

examples/spell_checking.rs (line 55)

fn build_dictionary_fst(words: &[&str]) -> VectorFst<TropicalWeight> {
    let mut fst = VectorFst::new();
    let start = fst.add_state();
    fst.set_start(start);

    // Build a trie structure
    let mut state_map: HashMap<Vec<char>, u32> = HashMap::new();
    state_map.insert(vec![], start);

    for word in words {
        let chars: Vec<char> = word.chars().collect();
        let mut prefix = vec![];

        for (i, &ch) in chars.iter().enumerate() {
            let current_state = *state_map.get(&prefix).unwrap();
            prefix.push(ch);

            if !state_map.contains_key(&prefix) {
                let new_state = fst.add_state();
                state_map.insert(prefix.clone(), new_state);
                fst.add_arc(
                    current_state,
                    Arc::new(ch as u32, ch as u32, TropicalWeight::one(), new_state),
                );
            }

            // If this is the last character, mark as final
            if i == chars.len() - 1 {
                let final_state = *state_map.get(&prefix).unwrap();
                fst.set_final(final_state, TropicalWeight::one());
            }
        }
    }

    fst
}

/// Creates an FST that accepts all words within edit distance k of a target word
///
/// # Arguments
/// * `target` - The target word to match against
/// * `k` - Maximum allowed edit distance
///
/// # Returns
/// An FST that accepts words within edit distance k of target
fn build_edit_distance_fst(target: &str, k: usize) -> VectorFst<TropicalWeight> {
    let mut fst = VectorFst::new();
    let target_chars: Vec<char> = target.chars().collect();
    let n = target_chars.len();

    // Create states: (position in target, edits used)
    let mut states = vec![vec![]; n + 1];
    for (i, state_row) in states.iter_mut().enumerate().take(n + 1) {
        for _j in 0..=k.min(i + k) {
            state_row.push(fst.add_state());
        }
    }

    // Start state
    fst.set_start(states[0][0]);

    // Final states - at end of target with <= k edits
    for j in 0..=k.min(n + k) {
        if j < states[n].len() {
            fst.set_final(states[n][j], TropicalWeight::new(j as f32));
        }
    }

    // Add transitions
    for i in 0..n {
        for j in 0..states[i].len() {
            if j > i + k {
                continue; // Skip impossible states
            }

            let current = states[i][j];

            // Match (no cost)
            if j < states[i + 1].len() {
                fst.add_arc(
                    current,
                    Arc::new(
                        target_chars[i] as u32,
                        target_chars[i] as u32,
                        TropicalWeight::one(),
                        states[i + 1][j],
                    ),
                );
            }

            // If we can still make edits
            if j < k {
                // Substitution (cost 1)
                if j + 1 < states[i + 1].len() {
                    for c in b'a'..=b'z' {
                        if c as char != target_chars[i] {
                            fst.add_arc(
                                current,
                                Arc::new(
                                    c as u32,
                                    c as u32,
                                    TropicalWeight::new(1.0),
                                    states[i + 1][j + 1],
                                ),
                            );
                        }
                    }
                }

                // Deletion in target (consume target char with epsilon)
                if j + 1 < states[i + 1].len() {
                    fst.add_arc(
                        current,
                        Arc::new(
                            0, // epsilon
                            0, // epsilon
                            TropicalWeight::new(1.0),
                            states[i + 1][j + 1],
                        ),
                    );
                }

                // Insertion (consume input char)
                if j + 1 < states[i].len() {
                    for c in b'a'..=b'z' {
                        fst.add_arc(
                            current,
                            Arc::new(
                                c as u32,
                                c as u32,
                                TropicalWeight::new(1.0),
                                states[i][j + 1],
                            ),
                        );
                    }
                }
            }
        }
    }

    // Handle insertions at the end
    for j in 0..states[n].len() {
        if j < k && j + 1 < states[n].len() {
            let current = states[n][j];
            for c in b'a'..=b'z' {
                fst.add_arc(
                    current,
                    Arc::new(
                        c as u32,
                        c as u32,
                        TropicalWeight::new(1.0),
                        states[n][j + 1],
                    ),
                );
            }
        }
    }

    fst
}

examples/number_date_normalizer.rs (lines 380-385)

fn build_number_normalization_fst() -> VectorFst<TropicalWeight> {
    let mut fst = VectorFst::new();
    let start = fst.add_state();
    fst.set_start(start);
    fst.set_final(start, TropicalWeight::one());

    // Add some simple number transformations
    let number_rules = vec![
        ("one", "1"),
        ("two", "2"),
        ("three", "3"),
        ("four", "4"),
        ("five", "5"),
    ];

    for (word, digit) in number_rules {
        let mut current = start;

        // Accept the word
        for ch in word.chars() {
            let next = fst.add_state();
            fst.add_arc(
                current,
                Arc::new(
                    ch as u32,
                    0, // epsilon output during word
                    TropicalWeight::one(),
                    next,
                ),
            );
            current = next;
        }

        // Output the digit
        for ch in digit.chars() {
            let next = fst.add_state();
            fst.add_arc(
                current,
                Arc::new(
                    0, // epsilon input
                    ch as u32,
                    TropicalWeight::one(),
                    next,
                ),
            );
            current = next;
        }

        // Connect back to start for more normalizations
        fst.add_arc(
            current,
            Arc::new(
                0, // epsilon
                0, // epsilon
                TropicalWeight::one(),
                start,
            ),
        );
    }

    fst
}

examples/pronunciation_lexicon.rs (lines 195-200)

fn build_simple_lexicon(entries: &[LexiconEntry]) -> VectorFst<TropicalWeight> {
    let mut fst = VectorFst::new();
    let start = fst.add_state();
    fst.set_start(start);

    for entry in entries {
        // For each pronunciation, create a separate path
        for pronunciation in &entry.pronunciations {
            let mut states = vec![start];

            // Create states for each character in the word
            for _ in 0..entry.word.len() {
                states.push(fst.add_state());
            }

            // Add transitions for each character
            for (i, ch) in entry.word.chars().enumerate() {
                fst.add_arc(
                    states[i],
                    Arc::new(
                        ch as u32,
                        ch as u32, // Output the same character for now
                        TropicalWeight::one(),
                        states[i + 1],
                    ),
                );
            }

            // At the end of the word, output the pronunciation
            let mut current = states[entry.word.len()];
            for phoneme in pronunciation {
                let next = fst.add_state();
                fst.add_arc(
                    current,
                    Arc::new(
                        0, // epsilon input
                        phoneme.to_label(),
                        TropicalWeight::one(),
                        next,
                    ),
                );
                current = next;
            }

            fst.set_final(current, TropicalWeight::one());
        }
    }

    fst
}

/// Build an FST that accepts a single word
fn word_acceptor(word: &str) -> VectorFst<TropicalWeight> {
    let mut fst = VectorFst::new();
    let mut current = fst.add_state();
    fst.set_start(current);

    for ch in word.chars() {
        let next = fst.add_state();
        fst.add_arc(
            current,
            Arc::new(ch as u32, ch as u32, TropicalWeight::one(), next),
        );
        current = next;
    }

    fst.set_final(current, TropicalWeight::one());
    fst
}

/// Look up pronunciations for a word using the lexicon
fn lookup_word_in_lexicon(entries: &[LexiconEntry], word: &str) -> Option<Vec<Vec<Phoneme>>> {
    for entry in entries {
        if entry.word == word {
            return Some(entry.pronunciations.clone());
        }
    }
    None
}

/// Build a G2P (Grapheme-to-Phoneme) FST for unknown words
fn build_g2p_rules() -> VectorFst<TropicalWeight> {
    let mut fst = VectorFst::new();
    let start = fst.add_state();
    fst.set_start(start);
    fst.set_final(start, TropicalWeight::one());

    // Simple G2P rules - in practice this would be much more sophisticated
    let rules = vec![
        ('a', Phoneme::AE),
        ('e', Phoneme::EH),
        ('i', Phoneme::IH),
        ('o', Phoneme::AO),
        ('u', Phoneme::AH),
        ('b', Phoneme::B),
        ('c', Phoneme::K),
        ('d', Phoneme::D),
        ('f', Phoneme::F),
        ('g', Phoneme::G),
        ('h', Phoneme::HH),
        ('j', Phoneme::JH),
        ('k', Phoneme::K),
        ('l', Phoneme::L),
        ('m', Phoneme::M),
        ('n', Phoneme::N),
        ('p', Phoneme::P),
        ('r', Phoneme::R),
        ('s', Phoneme::S),
        ('t', Phoneme::T),
        ('v', Phoneme::V),
        ('w', Phoneme::W),
        ('y', Phoneme::Y),
        ('z', Phoneme::Z),
    ];

    for (grapheme, phoneme) in rules {
        fst.add_arc(
            start,
            Arc::new(
                grapheme as u32,
                phoneme.to_label(),
                TropicalWeight::new(1.0),
                start,
            ),
        );
    }

    fst
}

examples/transliteration.rs (line 1007)

fn build_transliteration_fst(rules: &[TransliterationRule]) -> VectorFst<TropicalWeight> {
    let mut fst = VectorFst::new();
    let start = fst.add_state();
    fst.set_start(start);
    fst.set_final(start, TropicalWeight::one());

    // Sort rules by source length (longest first) to handle digraphs
    let mut sorted_rules = rules.to_vec();
    sorted_rules.sort_by(|a, b| b.source.len().cmp(&a.source.len()));

    for rule in &sorted_rules {
        let mut current = start;

        // Process each character in the source
        let source_chars: Vec<char> = rule.source.chars().collect();
        for (i, &ch) in source_chars.iter().enumerate() {
            if i == source_chars.len() - 1 {
                // Last character - output the target
                let target_chars: Vec<char> = rule.target.chars().collect();
                let _target_state = start;

                for &target_ch in &target_chars {
                    let next = fst.add_state();
                    fst.add_arc(
                        current,
                        Arc::new(ch as u32, target_ch as u32, TropicalWeight::one(), next),
                    );
                    current = next;
                }

                // Connect back to start for more characters
                fst.add_arc(
                    current,
                    Arc::new(
                        0, // epsilon
                        0, // epsilon
                        TropicalWeight::one(),
                        start,
                    ),
                );
            } else {
                // Intermediate character
                let next = fst.add_state();
                fst.add_arc(
                    current,
                    Arc::new(
                        ch as u32,
                        0, // epsilon output
                        TropicalWeight::one(),
                        next,
                    ),
                );
                current = next;
            }
        }
    }

    // Add pass-through for unknown characters
    for ch in 0..=127u8 {
        if ch.is_ascii() {
            fst.add_arc(
                start,
                Arc::new(ch as u32, ch as u32, TropicalWeight::one(), start),
            );
        }
    }

    fst
}

examples/phonological_rules.rs (lines 106-111)

fn build_vowel_harmony_fst() -> VectorFst<TropicalWeight> {
    let mut fst = VectorFst::new();
    let start = fst.add_state();
    let back_state = fst.add_state();
    let front_state = fst.add_state();

    fst.set_start(start);
    fst.set_final(start, TropicalWeight::one());
    fst.set_final(back_state, TropicalWeight::one());
    fst.set_final(front_state, TropicalWeight::one());

    // Back vowels trigger back harmony
    let back_vowels = ['a', 'o', 'u'];
    let front_vowels = ['e', 'i'];

    for &vowel in &back_vowels {
        fst.add_arc(
            start,
            Arc::new(
                vowel as u32,
                vowel as u32,
                TropicalWeight::one(),
                back_state,
            ),
        );
        fst.add_arc(
            back_state,
            Arc::new(
                vowel as u32,
                vowel as u32,
                TropicalWeight::one(),
                back_state,
            ),
        );
    }

    for &vowel in &front_vowels {
        fst.add_arc(
            start,
            Arc::new(
                vowel as u32,
                vowel as u32,
                TropicalWeight::one(),
                front_state,
            ),
        );
        fst.add_arc(
            front_state,
            Arc::new(
                vowel as u32,
                vowel as u32,
                TropicalWeight::one(),
                front_state,
            ),
        );
    }

    // Harmonizing vowel: 'E' becomes 'e' in front context, 'a' in back context
    fst.add_arc(
        back_state,
        Arc::new('E' as u32, 'a' as u32, TropicalWeight::one(), back_state),
    );

    fst.add_arc(
        front_state,
        Arc::new('E' as u32, 'e' as u32, TropicalWeight::one(), front_state),
    );

    // Consonants are transparent
    let consonants = "bcdfghjklmnpqrstvwxyz";
    for ch in consonants.chars() {
        fst.add_arc(
            start,
            Arc::new(ch as u32, ch as u32, TropicalWeight::one(), start),
        );
        fst.add_arc(
            back_state,
            Arc::new(ch as u32, ch as u32, TropicalWeight::one(), back_state),
        );
        fst.add_arc(
            front_state,
            Arc::new(ch as u32, ch as u32, TropicalWeight::one(), front_state),
        );
    }

    fst
}

/// Build FST for consonant cluster simplification
/// Example: /kt/ -> /t/ (cluster reduction)
fn build_cluster_simplification_fst() -> VectorFst<TropicalWeight> {
    let mut fst = VectorFst::new();
    let start = fst.add_state();
    let k_state = fst.add_state();

    fst.set_start(start);
    fst.set_final(start, TropicalWeight::one());

    // /k/ followed by /t/ becomes just /t/
    fst.add_arc(
        start,
        Arc::new(
            'k' as u32,
            0, // epsilon output (delete k)
            TropicalWeight::one(),
            k_state,
        ),
    );

    fst.add_arc(
        k_state,
        Arc::new('t' as u32, 't' as u32, TropicalWeight::one(), start),
    );

    // All other characters pass through unchanged
    for ch in b'a'..=b'z' {
        let ch = ch as char;
        if ch != 'k' {
            fst.add_arc(
                start,
                Arc::new(ch as u32, ch as u32, TropicalWeight::one(), start),
            );
        }
    }

    // k in other contexts passes through
    for ch in b'a'..=b'z' {
        let ch = ch as char;
        if ch != 't' {
            fst.add_arc(
                k_state,
                Arc::new(
                    ch as u32,
                    'k' as u32, // output the k we held
                    TropicalWeight::one(),
                    start,
                ),
            );
            // Then process the current character
            fst.add_arc(
                start,
                Arc::new(ch as u32, ch as u32, TropicalWeight::one(), start),
            );
        }
    }

    fst
}

/// Build FST for vowel epenthesis (insertion)
/// Example: Insert 'i' to break consonant clusters
fn build_epenthesis_fst() -> VectorFst<TropicalWeight> {
    let mut fst = VectorFst::new();
    let start = fst.add_state();
    let consonant_state = fst.add_state();

    fst.set_start(start);
    fst.set_final(start, TropicalWeight::one());
    fst.set_final(consonant_state, TropicalWeight::one());

    let vowels = "aeiou";
    let consonants = "bcdfghjklmnpqrstvwxyz";

    // Vowels pass through and reset to start
    for ch in vowels.chars() {
        fst.add_arc(
            start,
            Arc::new(ch as u32, ch as u32, TropicalWeight::one(), start),
        );
        fst.add_arc(
            consonant_state,
            Arc::new(ch as u32, ch as u32, TropicalWeight::one(), start),
        );
    }

    // First consonant goes to consonant state
    for ch in consonants.chars() {
        fst.add_arc(
            start,
            Arc::new(ch as u32, ch as u32, TropicalWeight::one(), consonant_state),
        );
    }

    // Second consonant triggers epenthesis
    for ch in consonants.chars() {
        fst.add_arc(
            consonant_state,
            Arc::new(
                ch as u32,
                'i' as u32, // insert epenthetic vowel
                TropicalWeight::one(),
                start,
            ),
        );
        // Then output the consonant
        fst.add_arc(
            start,
            Arc::new(
                0, // epsilon input
                ch as u32,
                TropicalWeight::one(),
                consonant_state,
            ),
        );
    }

    fst
}

/// Build FST for final devoicing (German-style)
/// Example: /d/ -> /t/ / _#
fn build_final_devoicing_fst() -> VectorFst<TropicalWeight> {
    let mut fst = VectorFst::new();
    let start = fst.add_state();
    let voiced_state = fst.add_state();

    fst.set_start(start);
    fst.set_final(start, TropicalWeight::one());

    // Final voiced consonants become voiceless
    fst.set_final(voiced_state, TropicalWeight::new(0.0)); // Cost for devoicing

    let voiced_obstruents = ['b', 'd', 'g', 'z', 'v'];
    let voiceless_obstruents = ['p', 't', 'k', 's', 'f'];

    // Map voiced to voiceless at word end
    for (&voiced, &voiceless) in voiced_obstruents.iter().zip(voiceless_obstruents.iter()) {
        fst.add_arc(
            start,
            Arc::new(
                voiced as u32,
                voiceless as u32,
                TropicalWeight::one(),
                voiced_state,
            ),
        );
    }

    // All other characters pass through
    for ch in b'a'..=b'z' {
        let ch = ch as char;
        if !voiced_obstruents.contains(&ch) {
            fst.add_arc(
                start,
                Arc::new(ch as u32, ch as u32, TropicalWeight::one(), start),
            );
        }
    }

    // Non-final voiced consonants pass through unchanged
    for ch in b'a'..=b'z' {
        let ch = ch as char;
        fst.add_arc(
            voiced_state,
            Arc::new(ch as u32, ch as u32, TropicalWeight::one(), start),
        );
    }

    fst
}

/// Build FST that accepts a word
fn build_word_fst(word: &str) -> VectorFst<TropicalWeight> {
    let mut fst = VectorFst::new();
    let mut current = fst.add_state();
    fst.set_start(current);

    for ch in word.chars() {
        let next = fst.add_state();
        fst.add_arc(
            current,
            Arc::new(ch as u32, ch as u32, TropicalWeight::one(), next),
        );
        current = next;
    }

    fst.set_final(current, TropicalWeight::one());
    fst
}

Additional examples can be found in:

• examples/edit_distance.rs
• examples/string_alignment.rs

pub fn epsilon(weight: W, nextstate: StateId) -> Self

Creates an epsilon arc (no input or output symbol).

Epsilon arcs have input and output labels of 0, representing transitions that neither consume nor produce symbols. These are commonly used in NFA-to-DFA conversions and composition algorithms.

Arguments

• weight - Arc weight in the semiring
• nextstate - Destination state ID

Returns

A new Arc with ilabel = 0 and olabel = 0.

Examples

use arcweight::prelude::*;

let epsilon = Arc::epsilon(TropicalWeight::one(), 2);

assert_eq!(epsilon.ilabel, 0);
assert_eq!(epsilon.olabel, 0);
assert!(epsilon.is_epsilon());
assert!(epsilon.is_epsilon_input());
assert!(epsilon.is_epsilon_output());

pub fn is_epsilon_input(&self) -> bool

Returns true if the input label is epsilon (0).

An epsilon input means this transition does not consume any symbol from the input tape.

Returns

true if ilabel == 0, false otherwise.

Examples

use arcweight::prelude::*;

let eps = Arc::new(0, 5, TropicalWeight::one(), 1);
let regular = Arc::new(1, 5, TropicalWeight::one(), 1);

assert!(eps.is_epsilon_input());
assert!(!regular.is_epsilon_input());

pub fn is_epsilon_output(&self) -> bool

Returns true if the output label is epsilon (0).

An epsilon output means this transition does not produce any symbol on the output tape.

Returns

true if olabel == 0, false otherwise.

Examples

use arcweight::prelude::*;

let eps = Arc::new(5, 0, TropicalWeight::one(), 1);
let regular = Arc::new(5, 1, TropicalWeight::one(), 1);

assert!(eps.is_epsilon_output());
assert!(!regular.is_epsilon_output());

pub fn is_epsilon(&self) -> bool

Returns true if both input and output labels are epsilon.

A fully epsilon arc neither consumes input nor produces output, representing a “free” transition between states. Such arcs are commonly removed during epsilon removal optimization.

Returns

true if both ilabel == 0 and olabel == 0, false otherwise.

Examples

use arcweight::prelude::*;

let full_eps = Arc::epsilon(TropicalWeight::one(), 1);
let input_eps = Arc::new(0, 5, TropicalWeight::one(), 1);
let regular = Arc::new(1, 2, TropicalWeight::one(), 1);

assert!(full_eps.is_epsilon());
assert!(!input_eps.is_epsilon());  // Only input is epsilon
assert!(!regular.is_epsilon());

Trait Implementations

impl<W: Clone + Semiring> Clone for Arc<W>

fn clone(&self) -> Arc<W>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<W: Debug + Semiring> Debug for Arc<W>

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

Formats the value using the given formatter.

impl<'de, W> Deserialize<'de> for Arc<W>

where W: Deserialize<'de> + Semiring,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<W: Semiring> Display for Arc<W>

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

Formats the value using the given formatter.

impl<W: Eq + Semiring> Eq for Arc<W>

impl<W: Hash + Semiring> Hash for Arc<W>

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<W: PartialEq + Semiring> PartialEq for Arc<W>

fn eq(&self, other: &Arc<W>) -> 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<W> Serialize for Arc<W>

where W: Serialize + Semiring,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<W: PartialEq + Semiring> StructuralPartialEq for Arc<W>