datalog-structural-model 1.0.0

Typed Datalog rule IR, validation, and stratification
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

//! Portable validation reports preserve typed failure details.
use datalog_structural_model::{
    PredicateSymbol, ProgramValidationError, StratificationError, TermShapeError, VariableSymbol,
};
fn round_trip<T: serde::Serialize + serde::de::DeserializeOwned + PartialEq + std::fmt::Debug>(
    value: &T,
) {
    assert_eq!(
        &serde_json::from_str::<T>(&serde_json::to_string(value).unwrap()).unwrap(),
        value
    );
    assert_eq!(
        &postcard::from_bytes::<T>(&postcard::to_allocvec(value).unwrap()).unwrap(),
        value
    );
}
#[test]
fn every_program_failure_round_trips() {
    let vars = vec![VariableSymbol::new("missing")];
    for error in [
        ProgramValidationError::UnsafeRule {
            rule_index: 3,
            variables: vars.clone(),
        },
        ProgramValidationError::UnsafeNegation {
            rule_index: 3,
            variables: vars.clone(),
        },
        ProgramValidationError::UnsafeFilter {
            rule_index: 3,
            variables: vars.clone(),
        },
        ProgramValidationError::UnsafeBind {
            rule_index: 3,
            variables: vars.clone(),
        },
        ProgramValidationError::UnsafeAggregate {
            rule_index: 3,
            variables: vars,
        },
        ProgramValidationError::NestedAggregateInInnerBody { rule_index: 3 },
        ProgramValidationError::UnstratifiableNegation {
            predicates: vec![PredicateSymbol::new("cycle")],
        },
        ProgramValidationError::NegationUnderEqualityMode { rule_index: 3 },
        ProgramValidationError::AggregationUnderEqualityMode { rule_index: 3 },
        ProgramValidationError::SkolemInBodyAtom { rule_index: 3 },
        ProgramValidationError::TripleTermNestingExceeded {
            rule_index: 3,
            depth: 5,
            limit: 4,
        },
        ProgramValidationError::InvalidSkolemArguments { rule_index: 3 },
    ] {
        round_trip(&error);
    }
}
#[test]
fn structural_and_stratification_errors_round_trip() {
    round_trip(&TermShapeError::InvalidSkolemArguments);
    round_trip(&TermShapeError::TripleTermNestingExceeded { depth: 5, limit: 4 });
    round_trip(&StratificationError::UnstratifiableCycle {
        predicates: vec![PredicateSymbol::new("cycle")],
    });
}