lemma-engine 0.8.10

A language that means business.
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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

use crate::evaluation::operations::{ComputationKind, OperationResult};
use crate::planning::semantics::{FactPath, LiteralValue, RulePath, Source};
use serde::{Serialize, Serializer};
use std::sync::Arc;

fn serialize_arc<T, S>(value: &Arc<T>, serializer: S) -> Result<S::Ok, S::Error>
where
    T: Serialize,
    S: Serializer,
{
    value.as_ref().serialize(serializer)
}

#[derive(Debug, Clone, Serialize)]
pub struct Explanation {
    pub rule_path: RulePath,
    pub source: Option<Source>,
    pub result: OperationResult,
    #[serde(serialize_with = "serialize_arc")]
    pub tree: Arc<ExplanationNode>,
}

#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum ExplanationNode {
    Value {
        value: LiteralValue,
        source: ValueSource,
        source_location: Option<Source>,
    },
    RuleReference {
        rule_path: RulePath,
        result: OperationResult,
        source_location: Option<Source>,
        #[serde(serialize_with = "serialize_arc")]
        expansion: Arc<ExplanationNode>,
    },
    Computation {
        kind: ComputationKind,
        original_expression: String,
        expression: String,
        result: LiteralValue,
        source_location: Option<Source>,
        operands: Vec<ExplanationNode>,
    },
    Branches {
        matched: Box<Branch>,
        non_matched: Vec<NonMatchedBranch>,
        source_location: Option<Source>,
    },
    Condition {
        original_expression: String,
        expression: String,
        result: bool,
        source_location: Option<Source>,
        operands: Vec<ExplanationNode>,
    },
    Veto {
        message: Option<String>,
        source_location: Option<Source>,
    },
}

#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum ValueSource {
    Fact { fact_ref: FactPath },
    Literal,
    Computed,
}

#[derive(Debug, Clone, Serialize)]
pub struct Branch {
    pub condition: Option<Box<ExplanationNode>>,
    pub result: Box<ExplanationNode>,
    pub clause_index: Option<usize>,
    pub source_location: Option<Source>,
}

#[derive(Debug, Clone, Serialize)]
pub struct NonMatchedBranch {
    pub condition: Box<ExplanationNode>,
    pub result: Option<Box<ExplanationNode>>,
    pub clause_index: Option<usize>,
    pub source_location: Option<Source>,
}