pddl/parsers/timeless_def.rs
1//! Provides parsers for timeless definitions.
2
3use crate::parsers::{literal, parse_name, prefix_expr, space_separated_list1, ParseResult, Span};
4use crate::types::Timeless;
5use nom::combinator::map;
6
7/// Parser for timeless definitions.
8/// This is a PDDL 1.2 construct.
9///
10/// ## Example
11/// ```
12/// # use pddl::parsers::{parse_timeless_def, preamble::*};
13/// # use pddl::{AtomicFormula, EqualityAtomicFormula, Literal, Name, Objects, Timeless, ToTyped, Type};
14/// let input = "(:timeless (= x y) (= a b))";
15/// assert!(parse_timeless_def(input).is_value(
16///     Timeless::from_iter([
17///         Literal::AtomicFormula(
18///             AtomicFormula::Equality(
19///                 EqualityAtomicFormula::new(
20///                     "x".into(),
21///                     "y".into()
22///                 )
23///             )
24///         ),
25///         Literal::AtomicFormula(
26///             // ...
27///             # AtomicFormula::Equality(
28///             #     EqualityAtomicFormula::new(
29///             #         "a".into(),
30///             #         "b".into()
31///             #     )
32///             # )
33///         )
34///     ])
35/// ));
36/// ```
37pub fn parse_timeless_def<'a, T: Into<Span<'a>>>(input: T) -> ParseResult<'a, Timeless> {
38    map(
39        prefix_expr(":timeless", space_separated_list1(literal(parse_name))),
40        Timeless::from_iter,
41    )(input.into())
42}
43
44impl crate::parsers::Parser for Timeless {
45    type Item = Timeless;
46
47    /// See [`parse_timeless_def`].
48    fn parse<'a, S: Into<Span<'a>>>(input: S) -> ParseResult<'a, Self::Item> {
49        parse_timeless_def(input)
50    }
51}
52
53#[cfg(test)]
54mod tests {
55    use crate::parsers::preamble::*;
56    use crate::{AtomicFormula, EqualityAtomicFormula, Literal, Timeless};
57
58    #[test]
59    fn test_parse() {
60        let input = "(:timeless (= x y) (= a b))";
61        assert!(Timeless::parse(input).is_value(Timeless::from_iter([
62            Literal::AtomicFormula(AtomicFormula::Equality(EqualityAtomicFormula::new(
63                "x".into(),
64                "y".into()
65            ))),
66            Literal::AtomicFormula(AtomicFormula::Equality(EqualityAtomicFormula::new(
67                "a".into(),
68                "b".into()
69            )))
70        ])));
71    }
72}