anthem 2.0.0-rc.1

A command-line application for assisting in the verification of answer set programs
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

use std::fmt::{self, Display, Formatter};

pub mod asp;
pub mod fol;

#[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub enum Associativity {
    Left,
    Right,
}

pub trait Precedence: Display {
    fn precedence(&self) -> usize;

    fn associativity(&self) -> Associativity;

    fn mandatory_parentheses(&self) -> bool {
        false
    }

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

    fn fmt_unary(&self, inner: impl Precedence, f: &mut Formatter<'_>) -> fmt::Result {
        if self.associativity() == Associativity::Left {
            self.fmt_operator(f)?;
        }

        if inner.mandatory_parentheses() || self.precedence() < inner.precedence() {
            write!(f, "({inner})")?;
        } else {
            write!(f, "{inner}")?;
        }

        if self.associativity() == Associativity::Right {
            self.fmt_operator(f)?;
        }

        Ok(())
    }

    fn fmt_binary(
        &self,
        lhs: impl Precedence,
        rhs: impl Precedence,
        f: &mut Formatter<'_>,
    ) -> fmt::Result {
        if lhs.mandatory_parentheses()
            || self.precedence() < lhs.precedence()
            || self.precedence() == lhs.precedence() && lhs.associativity() == Associativity::Right
        {
            write!(f, "({lhs})")?;
        } else {
            write!(f, "{lhs}")?;
        }

        self.fmt_operator(f)?;

        if rhs.mandatory_parentheses()
            || self.precedence() < rhs.precedence()
            || self.precedence() == rhs.precedence() && self.associativity() == Associativity::Left
        {
            write!(f, "({rhs})")
        } else {
            write!(f, "{rhs}")
        }
    }
}