refactor(types): arrange asap-types modules by #511 section (#572 B1)

Cargo.toml

@@ -2,6 +2,7 @@
 members = [
     "crates/asap-physical-operators",
     "crates/types",
+    "crates/frontend-common",
     "crates/sql-function-catalog",
     "crates/asap-aware-mapping",
     "crates/frontend-promql",

crates/asap-aware-mapping/src/accuracy/composition.rs

@@ -448,9 +448,7 @@ fn composed_provenance(
 }
 
 pub(super) fn exact_operation_rule(operation: &ExactOperation) -> Option<CompositionOperator> {
-    let ExactOperation::Aggregate { measures, .. } = operation else {
-        return None;
-    };
+    let ExactOperation::Aggregate { measures, .. } = operation;
     match measures.as_slice() {
         [intent] => crate::function_rules::function_rules(intent).map(|rules| rules.accuracy),
         // The remaining functions are exact over exact samples, but have
@@ -707,7 +705,7 @@ pub(super) fn propagate(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use asap_types::pre_asap::AggIntent;
+    use asap_types::ir::operator::AggIntent;
     fn abs(bound: f64, delta: f64) -> ResultGuarantee {
         ResultGuarantee {
             metric: ErrorMetric::AbsoluteValue,
@@ -1032,11 +1030,11 @@ mod tests {
     #[test]
     fn counter_functions_have_distinct_definition_rules() {
         let operation = |intent| ExactOperation::Aggregate {
-            reduction: asap_types::pre_asap::Reduction::PerEntity,
+            reduction: asap_types::ir::operator::Reduction::PerEntity,
             measures: vec![intent],
             output_names: vec![],
-            having: None,
             filters: vec![],
+            having: None,
         };
         assert_eq!(
             DefaultAccuracyModel.exact_operation_rule(&operation(AggIntent::Rate)),

crates/asap-aware-mapping/src/accuracy/estimators/cms.rs

@@ -42,8 +42,8 @@ mod tests {
     #[test]
     fn local_guarantee_inverts_frequency_sizing() {
         use crate::replacement::default_size_params;
-        use asap_types::post_asap::{GroupingStrategy, SketchKind};
-        let c = asap_types::pre_asap::agg_intent::default_cardinality();
+        use asap_types::ir::schema::{GroupingStrategy, SketchKind};
+        let c = asap_types::ir::operator::agg_intent::default_cardinality();
         let params = default_size_params(SketchAlgorithm::Cms, &c, 0.01, 0.001);
         let g = DefaultAccuracyModel
             .local_guarantee(
@@ -65,8 +65,8 @@ mod tests {
     }
 
     #[test]
-    fn heap_readout_retains_frequency_metric() {
-        use asap_types::post_asap::{GroupingStrategy, SketchKind};
+    fn heap_evaluation_retains_frequency_metric() {
+        use asap_types::ir::schema::{GroupingStrategy, SketchKind};
         let cms_heap = SketchParams::CmsWithHeap {
             width: 272,
             depth: 5,

crates/asap-aware-mapping/src/accuracy/estimators/count_sketch.rs

@@ -56,8 +56,8 @@ mod tests {
     #[test]
     fn count_sketch_uses_an_l2_guarantee() {
         use crate::replacement::default_size_params;
-        use asap_types::post_asap::{GroupingStrategy, SketchKind};
-        use asap_types::pre_asap::agg_intent::default_cardinality;
+        use asap_types::ir::operator::agg_intent::default_cardinality;
+        use asap_types::ir::schema::{GroupingStrategy, SketchKind};
         let intent = default_cardinality();
         let count_sketch = default_size_params(SketchAlgorithm::CountSketch, &intent, 0.01, 0.01);
         let guarantee = DefaultAccuracyModel
@@ -67,7 +67,7 @@ mod tests {
                     GroupingStrategy::default(),
                 ),
                 &SketchStatistic::PointCount {
-                    key: asap_types::pre_asap::expr_ir::ColumnRef::SampleValue,
+                    key: asap_types::ir::scalar::ColumnRef::SampleValue,
                     value: None,
                 },
             )

crates/asap-aware-mapping/src/accuracy/estimators/hll.rs

@@ -1,7 +1,7 @@
 //! Estimator-specific confidence for classic HLL's linear-counting branch.
 //!
 //! This is conditional on independent uniform bucket hashes and an enforced
-//! upper bound on distinct items in the complete readout population (including
+//! upper bound on distinct items in the complete evaluation population (including
 //! all merged panes). It is not an RSE-to-normal conversion or an ERP fit.
 
 use super::*;
@@ -56,13 +56,13 @@ impl ClassicHllConfidence {
                 value: self.relative_error,
             },
             failure_probability: ProbabilityExpr::Constant { value: delta },
-            provenance: vec![GuaranteeSource::SketchReadout {
+            provenance: vec![GuaranteeSource::SketchEvaluation {
                 algorithm: "Hll".into(),
                 contract: "classic_hll_linear_counting_collision_bound_v1".into(),
                 params: serde_json::json!({"precision": precision,
                     "max_distinct": self.max_distinct, "relative_error": self.relative_error,
                     "hash_assumption": "independent_uniform_buckets",
-                    "population_scope": "complete_readout_including_merged_panes"}),
+                    "population_scope": "complete_evaluation_including_merged_panes"}),
                 query: "Cardinality".into(),
             }],
         })
@@ -187,7 +187,7 @@ mod tests {
             }
         }
     }
-    /// The model's readout formula matches the actual classic estimator after merge.
+    /// The model's evaluation formula matches the actual classic estimator after merge.
     #[test]
     fn native_classic_estimator_and_merged_registers_use_the_same_contract() {
         use asap_sketchlib::sketches::hll::{Classic, HyperLogLogP16};
@@ -231,8 +231,8 @@ mod tests {
     #[test]
     fn generic_rse_sizing_does_not_certify_confidence() {
         use crate::replacement::default_size_params;
-        use asap_types::post_asap::{GroupingStrategy, SketchKind};
-        use asap_types::pre_asap::agg_intent::default_cardinality;
+        use asap_types::ir::operator::agg_intent::default_cardinality;
+        use asap_types::ir::schema::{GroupingStrategy, SketchKind};
         let c = default_cardinality();
         let params = default_size_params(SketchAlgorithm::Hll, &c, 0.01, 0.01);
         let g = DefaultAccuracyModel

crates/asap-aware-mapping/src/accuracy/estimators/kll.rs

@@ -43,8 +43,8 @@ mod tests {
     #[test]
     fn local_guarantee_inverts_rank_sizing() {
         use crate::replacement::default_size_params;
-        use asap_types::post_asap::{GroupingStrategy, SketchKind};
-        use asap_types::pre_asap::agg_intent::default_quantile;
+        use asap_types::ir::operator::agg_intent::default_quantile;
+        use asap_types::ir::schema::{GroupingStrategy, SketchKind};
         let q = default_quantile(0.99);
         let params = default_size_params(SketchAlgorithm::Kll, &q, 0.01, 0.01);
         let g = DefaultAccuracyModel
@@ -69,7 +69,7 @@ mod tests {
         assert_eq!(g.approximate_layer_count(), 1);
         assert!(g.provenance.iter().any(|source| matches!(
             source,
-            GuaranteeSource::SketchReadout { contract, .. }
+            GuaranteeSource::SketchEvaluation { contract, .. }
                 if contract == "apache_datasketches_kll_empirical_99_a9b42755072b"
         )));
     }

crates/asap-aware-mapping/src/accuracy/estimators/mod.rs

@@ -1,7 +1,7 @@
 //! Dispatch committed estimator parameters to their accuracy models.
 use super::*;
-use asap_types::post_asap::GroupingStrategy;
-use asap_types::pre_asap::AggIntent;
+use asap_types::ir::operator::AggIntent;
+use asap_types::ir::schema::GroupingStrategy;
 
 pub mod cardinality;
 pub mod cms;
@@ -46,7 +46,7 @@ fn bounded_guarantee(
         metric,
         bound: BoundExpr::Constant { value: bound },
         failure_probability: delta,
-        provenance: vec![GuaranteeSource::SketchReadout {
+        provenance: vec![GuaranteeSource::SketchEvaluation {
             algorithm: format!("{algorithm:?}"),
             contract: contract.into(),
             params: serde_json::to_value(params).unwrap_or(serde_json::Value::Null),
@@ -169,9 +169,9 @@ impl<'a> EstimatorAccuracy<'a> {
 
     fn hll(&self) -> Option<hll::ClassicHllConfidence> {
         let EstimatorContract::ClassicHll {
-            max_distinct_per_readout,
+            max_distinct_per_evaluation,
         } = self.contract?;
-        hll::ClassicHllConfidence::new(max_distinct_per_readout, self.epsilon)
+        hll::ClassicHllConfidence::new(max_distinct_per_evaluation, self.epsilon)
     }
 
     pub(crate) fn size_params(&self, algorithm: &SketchAlgorithm) -> Option<SketchParams> {

crates/asap-aware-mapping/src/accuracy/estimators/univmon.rs

@@ -1,4 +1,4 @@
-//! UnivMon currently certifies only its exact unit-update total readout.
+//! UnivMon currently certifies only its exact unit-update total evaluation.
 use super::*;
 
 pub(super) fn guarantee(query: &SketchStatistic) -> Option<ResultGuarantee> {

crates/asap-aware-mapping/src/accuracy/evidence.rs

@@ -2,12 +2,12 @@
 use super::*;
 
 /// A trusted source assertion scoped by `AccuracyEvidenceProvider` to one
-/// complete readout. Choosing this variant asserts the estimator and hash
+/// complete evaluation. Choosing this variant asserts the estimator and hash
 /// assumptions; it must not be inferred from sampled population statistics.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum EstimatorContract {
     /// Classic HLL with independent uniform bucket hashing, including merged panes.
-    ClassicHll { max_distinct_per_readout: u32 },
+    ClassicHll { max_distinct_per_evaluation: u32 },
 }
 
 /// An enforced domain for every sample of a direct quantile operand, in every
@@ -18,7 +18,7 @@ pub enum EstimatorContract {
 pub struct QuantileInputDomain {
     pub lower: f64,
     pub upper: f64,
-    /// Upper bound on samples per evaluation, matching the pinned readout's
+    /// Upper bound on samples per evaluation, matching the pinned evaluation's
     /// exact Float64 rank limit. The population must also be nonempty.
     pub max_samples: u64,
     pub contract: String,
@@ -87,31 +87,22 @@ pub struct PropagationStats {
 /// Supplies typed planning-time evidence required by propagation rules.
 pub trait AccuracyEvidenceProvider {
     /// Trusted estimator contract for this complete aggregate expression,
-    /// including source, filters, grouping and all panes in each readout.
+    /// including source, filters, grouping and all panes in each evaluation.
     /// An observed cardinality is not an enforced population bound.
-    fn estimator_contract(
-        &self,
-        _expression: &asap_types::pre_asap::QueryExpr,
-    ) -> Option<EstimatorContract> {
+    fn estimator_contract(&self, _expression: &OperatorNode) -> Option<EstimatorContract> {
         None
     }
 
     /// Enforced upper bound on distinct (partition, item) identities across a
-    /// complete TopK readout. Used to union-bound score errors for adaptively
+    /// complete TopK evaluation. Used to union-bound score errors for adaptively
     /// selected candidates. Observed cardinality is not sufficient evidence.
-    fn topk_max_distinct_items(
-        &self,
-        _expression: &asap_types::pre_asap::QueryExpr,
-    ) -> Option<u64> {
+    fn topk_max_distinct_items(&self, _expression: &OperatorNode) -> Option<u64> {
         None
     }
 
     /// Proof scoped to this complete quantile expression, including its source,
     /// filters, grouping and window. `None` means unknown, including emptiness.
-    fn quantile_input_domain(
-        &self,
-        _operand: &asap_types::pre_asap::query_expr::QueryExpr,
-    ) -> Option<QuantileInputDomain> {
+    fn quantile_input_domain(&self, _operand: &OperatorNode) -> Option<QuantileInputDomain> {
         None
     }
 
@@ -181,8 +172,8 @@ mod tests {
         let fresh = provider.propagation_stats(
             &CompositionOperator::ExactSum,
             &FieldDataType::ExactAggregate(
-                asap_types::post_asap::ExactKind::Sum,
-                asap_types::post_asap::ExactParams::Sum,
+                asap_types::ir::schema::ExactKind::Sum,
+                asap_types::ir::schema::ExactParams::Sum,
             ),
             None,
         );
@@ -196,8 +187,8 @@ mod tests {
         .propagation_stats(
             &CompositionOperator::ExactSum,
             &FieldDataType::ExactAggregate(
-                asap_types::post_asap::ExactKind::Sum,
-                asap_types::post_asap::ExactParams::Sum,
+                asap_types::ir::schema::ExactKind::Sum,
+                asap_types::ir::schema::ExactParams::Sum,
             ),
             None,
         );

crates/asap-aware-mapping/src/accuracy/mod.rs

@@ -20,18 +20,21 @@ pub use evidence::{
     QuantileInputDomain, WorkloadAccuracyEvidence,
 };
 
-use asap_types::post_asap::{
-    AccuracyError, BoundExpr, CompositionOperator, ErrorMetric, ExactOperation, FieldDataType,
-    GuaranteeSource, ProbabilityExpr, ResultGuarantee, SketchAlgorithm, SketchParams,
-    SketchStatistic,
+use asap_types::ir::properties::{
+    AccuracyError, BoundExpr, CompositionOperator, ErrorMetric, GuaranteeSource, ProbabilityExpr,
+    ResultGuarantee,
 };
+use asap_types::ir::schema::{FieldDataType, SketchAlgorithm, SketchParams, SketchStatistic};
+use asap_types::ir::OperatorNode;
 use asap_types::types::AccuracyTarget;
 
+use crate::exact_composition::ExactOperation;
+
 /// The deployment-extensible accuracy algebra. `asap-aware-mapping` ships
 /// [`DefaultAccuracyModel`]; a deployment with a proof for a composition the
 /// default rejects (a registered cross-metric conversion, say) implements
 /// this trait and passes it to
-/// [`crate::replacement::SketchAlgorithmStrategy::new_with_planning_inputs`].
+/// [`crate::replacement::ASAPStrategies::new_with_planning_inputs`].
 pub trait AccuracyModel {
     /// The definition-registered rule for applying `operation` to an
     /// approximate input. `None` means the function is exact only over exact
@@ -78,7 +81,7 @@ pub struct DefaultAccuracyModel;
 const SATISFACTION_TOLERANCE: f64 = 1e-9;
 
 impl DefaultAccuracyModel {
-    /// Derive the guarantee for the committed estimator parameters and readout.
+    /// Derive the guarantee for the committed estimator parameters and evaluation.
     pub fn sketch_guarantee(
         algorithm: &SketchAlgorithm,
         params: &SketchParams,