pddl 0.2.0

A PDDL 3.1 parser, strongly typed
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

use crate::pretty_print::{sealed, PrettyRenderer};
use crate::types::{PrimitiveType, Type};
use crate::visitor::{Accept, Visitor};
use pretty::RcDoc;

impl sealed::Sealed for PrimitiveType {}
impl sealed::Sealed for Type {}

impl Visitor<PrimitiveType, RcDoc<'static>> for PrettyRenderer {
    fn visit(&self, value: &PrimitiveType) -> RcDoc<'static> {
        RcDoc::text(value.to_string())
    }
}

impl Visitor<Type, RcDoc<'static>> for PrettyRenderer {
    fn visit(&self, value: &Type) -> RcDoc<'static> {
        match value {
            Type::Exactly(t) => RcDoc::text(t.to_string()),
            Type::EitherOf(ts) => RcDoc::text("(either")
                .append(RcDoc::softline())
                .group()
                .nest(4)
                .append(RcDoc::intersperse(
                    ts.iter().map(|t| t.accept(self)),
                    RcDoc::softline(),
                ))
                .nest(4)
                .group()
                .append(")"),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::pretty_print::prettify;
    use crate::visitor::Accept;

    #[test]
    fn primitive_type_works() {
        let x = PrimitiveType::from("pt");
        assert_eq!(prettify!(x, 10), "pt");
    }

    #[test]
    fn simple_type_works() {
        let x = Type::from("a");
        assert_eq!(prettify!(x, 10), "a");
    }

    #[test]
    fn either_type_works() {
        let x = Type::from_iter(["a", "b"]);
        assert_eq!(prettify!(x, 12), "(either a b)");
        assert_eq!(prettify!(x, 10), "(either a\n    b)");
        assert_eq!(prettify!(x, 8), "(either\n    a b)");
    }
}