lemma-engine 0.8.12

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
87
88
89
90
91
92
93

//! Target specification for inversion queries

use crate::evaluation::operations::VetoType;
use crate::planning::semantics::LiteralValue;
use crate::OperationResult;
use serde::Serialize;

/// Desired outcome for an inversion query
#[derive(Debug, Clone, PartialEq, Serialize)]
pub struct Target {
    /// The comparison operator
    pub op: TargetOp,

    /// The desired outcome (value or veto)
    /// None means "any value" (wildcard for non-veto results)
    pub outcome: Option<OperationResult>,
}

/// Comparison operators for targets
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize)]
pub enum TargetOp {
    /// Equal to (`is`)
    Eq,
    /// Not equal to (`is not`)
    Neq,
    /// Less than (<)
    Lt,
    /// Less than or equal to (<=)
    Lte,
    /// Greater than (>)
    Gt,
    /// Greater than or equal to (>=)
    Gte,
}

impl Target {
    /// Create a target for a specific value with equality operator
    pub fn value(value: LiteralValue) -> Self {
        Self {
            op: TargetOp::Eq,
            outcome: Some(OperationResult::Value(Box::new(value))),
        }
    }

    /// Create a target for a specific veto message
    pub fn veto(message: Option<String>) -> Self {
        Self {
            op: TargetOp::Eq,
            outcome: Some(OperationResult::Veto(VetoType::UserDefined { message })),
        }
    }

    /// Create a target for any veto
    pub fn any_veto() -> Self {
        Self::veto(None)
    }

    /// Create a target for any value (non-veto)
    pub fn any_value() -> Self {
        Self {
            op: TargetOp::Eq,
            outcome: None,
        }
    }

    /// Create a target with a custom operator
    pub fn with_op(op: TargetOp, outcome: OperationResult) -> Self {
        Self {
            op,
            outcome: Some(outcome),
        }
    }

    /// Format target for display
    pub fn format(&self) -> String {
        let op_str = match self.op {
            TargetOp::Eq => "=",
            TargetOp::Neq => "is not",
            TargetOp::Lt => "<",
            TargetOp::Lte => "<=",
            TargetOp::Gt => ">",
            TargetOp::Gte => ">=",
        };

        let value_str = match &self.outcome {
            None => "any".to_string(),
            Some(OperationResult::Value(v)) => v.to_string(),
            Some(OperationResult::Veto(reason)) => format!("veto({reason})"),
        };

        format!("{} {}", op_str, value_str)
    }
}