idiolect-records 0.2.0

Rust record types mirroring the dev.idiolect.* Lexicon family.
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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170

// @generated by idiolect-codegen. do not edit.
// source: dev.idiolect.recommendation

//! A community-published opinionated path with structured applicability conditions and optional verification requirements. conditions/preconditions/caveats are structured ThCondition combinator trees and a typed caveat list; requiredVerifications is an array of LensProperty so consumers can check specific theorems, not just kinds. Narrative prose lives in `annotations` / `caveatsText`.

#![allow(
    missing_docs,
    clippy::doc_markdown,
    clippy::struct_excessive_bools,
    clippy::derive_partial_eq_without_eq
)]
use serde::{Deserialize, Serialize};

/// A community endorses a lens path under structured conditions. Consumers evaluate the condition tree against their invocation context to decide applicability; the caveats list gives structured failure modes to match on.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Recommendation {
    /// Why this path, how to use it, known strengths. Narrative; not consumed by machine matchers.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub annotations: Option<String>,
    /// Structured grounding for the endorsement — a community policy, an external standard, a derived record. Omit when the recommendation is self-asserted by the issuing community.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub basis: Option<super::defs::Basis>,
    /// Structured known-failure-mode list. Consumers match on `mode` / `affects` / `severity` without substring search.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub caveats: Option<Vec<super::defs::Caveat>>,
    /// Narrative commentary on the caveats. Companion to the structured `caveats` list, not a replacement.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub caveats_text: Option<String>,
    /// Structured applicability predicate in postfix-operator form: each item is either an atomic predicate over the invocation context or a combinator (and/or/not) that pops operands from the running stack. An empty array means 'always applies'. See dev.idiolect.theory.condition.
    pub conditions: Vec<RecommendationConditions>,
    pub issuing_community: String,
    /// Ordered sequence of lenses to compose. Length 1 means a single recommended lens.
    pub lens_path: Vec<super::defs::LensRef>,
    pub occurred_at: String,
    /// Additional structured assumptions the consumer must verify before adopting (same combinator shape as `conditions`). Empty array means no explicit preconditions.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub preconditions: Option<Vec<RecommendationPreconditions>>,
    /// Verification properties this recommendation assumes are in place. Each entry is a specific LensProperty, not just a verification kind, so consumers can check which roundtrip domain / theorem / standard has been established.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub required_verifications: Option<Vec<RecommendationRequiredVerifications>>,
    /// Prior recommendation this one replaces.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub supersedes: Option<String>,
}

impl crate::Record for Recommendation {
    const NSID: &'static str = "dev.idiolect.recommendation";
}

/// Atomic predicate: the invocation's use.action is subsumed by the given action under the referenced action-vocabulary. Reuses the same ThUse subsumption machinery that governs any action-based reasoning.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConditionActionSubsumedBy {
    /// Action identifier to check subsumption against.
    pub action: String,
    /// Action vocabulary the identifier resolves against. Omit to match the invocation's own vocabulary.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub vocabulary: Option<super::defs::VocabRef>,
}

/// Combinator: conjoin the top two predicates on the evaluation stack.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConditionAnd {}

/// Atomic predicate: the invocation's data has the named property.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConditionDataHas {
    /// Community-defined property identifier (e.g. 'length>1024', 'contains-pii', 'multilingual').
    pub property: String,
}

/// Combinator: negate the top predicate on the evaluation stack.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConditionNot {}

/// Combinator: disjoin the top two predicates on the evaluation stack.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConditionOr {}

/// Atomic predicate: the invocation's use.purpose is subsumed by the given purpose under the referenced purpose-vocabulary.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConditionPurposeSubsumedBy {
    /// Purpose identifier to check subsumption against.
    pub purpose: String,
    /// Purpose vocabulary the identifier resolves against. Omit to match the invocation's own vocabulary.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub vocabulary: Option<super::defs::VocabRef>,
}

/// Atomic predicate: the invocation's source schema is the given schema.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConditionSourceIs {
    pub schema: super::defs::SchemaRef,
}

/// Atomic predicate: the invocation's target schema is the given schema.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConditionTargetIs {
    pub schema: super::defs::SchemaRef,
}

/// RecommendationConditions tagged union.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "$type")]
pub enum RecommendationConditions {
    #[serde(rename = "dev.idiolect.recommendation#conditionSourceIs")]
    ConditionSourceIs(ConditionSourceIs),
    #[serde(rename = "dev.idiolect.recommendation#conditionTargetIs")]
    ConditionTargetIs(ConditionTargetIs),
    #[serde(rename = "dev.idiolect.recommendation#conditionActionSubsumedBy")]
    ConditionActionSubsumedBy(ConditionActionSubsumedBy),
    #[serde(rename = "dev.idiolect.recommendation#conditionPurposeSubsumedBy")]
    ConditionPurposeSubsumedBy(ConditionPurposeSubsumedBy),
    #[serde(rename = "dev.idiolect.recommendation#conditionDataHas")]
    ConditionDataHas(ConditionDataHas),
    #[serde(rename = "dev.idiolect.recommendation#conditionAnd")]
    ConditionAnd(ConditionAnd),
    #[serde(rename = "dev.idiolect.recommendation#conditionOr")]
    ConditionOr(ConditionOr),
    #[serde(rename = "dev.idiolect.recommendation#conditionNot")]
    ConditionNot(ConditionNot),
}

/// RecommendationPreconditions tagged union.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "$type")]
pub enum RecommendationPreconditions {
    #[serde(rename = "dev.idiolect.recommendation#conditionSourceIs")]
    ConditionSourceIs(ConditionSourceIs),
    #[serde(rename = "dev.idiolect.recommendation#conditionTargetIs")]
    ConditionTargetIs(ConditionTargetIs),
    #[serde(rename = "dev.idiolect.recommendation#conditionActionSubsumedBy")]
    ConditionActionSubsumedBy(ConditionActionSubsumedBy),
    #[serde(rename = "dev.idiolect.recommendation#conditionPurposeSubsumedBy")]
    ConditionPurposeSubsumedBy(ConditionPurposeSubsumedBy),
    #[serde(rename = "dev.idiolect.recommendation#conditionDataHas")]
    ConditionDataHas(ConditionDataHas),
    #[serde(rename = "dev.idiolect.recommendation#conditionAnd")]
    ConditionAnd(ConditionAnd),
    #[serde(rename = "dev.idiolect.recommendation#conditionOr")]
    ConditionOr(ConditionOr),
    #[serde(rename = "dev.idiolect.recommendation#conditionNot")]
    ConditionNot(ConditionNot),
}

/// RecommendationRequiredVerifications tagged union.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "$type")]
pub enum RecommendationRequiredVerifications {
    #[serde(rename = "dev.idiolect.defs#lpRoundtrip")]
    LpRoundtrip(super::defs::LpRoundtrip),
    #[serde(rename = "dev.idiolect.defs#lpGenerator")]
    LpGenerator(super::defs::LpGenerator),
    #[serde(rename = "dev.idiolect.defs#lpTheorem")]
    LpTheorem(super::defs::LpTheorem),
    #[serde(rename = "dev.idiolect.defs#lpConformance")]
    LpConformance(super::defs::LpConformance),
    #[serde(rename = "dev.idiolect.defs#lpChecker")]
    LpChecker(super::defs::LpChecker),
    #[serde(rename = "dev.idiolect.defs#lpConvergence")]
    LpConvergence(super::defs::LpConvergence),
}