pysof 0.1.45__tar.gz → 0.1.47__tar.gz

{pysof-0.1.45 → pysof-0.1.47}/Cargo.toml

@@ -17,8 +17,8 @@ crate-type = ["cdylib"]
 
 [dependencies]
 pyo3 = { version = ">=0.27", features = ["extension-module", "generate-import-lib"] }
-helios-sof = { path = "../sof", version = "0.1.45" }
-helios-fhir = { path = "../fhir", version = "0.1.45" }
+helios-sof = { path = "../sof", version = "0.1.47" }
+helios-fhir = { path = "../fhir", version = "0.1.47" }
 serde = { workspace = true }
 serde_json = { workspace = true }
 chrono = { version = "0.4", features = ["serde"] }

{pysof-0.1.45 → pysof-0.1.47}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pysof
-Version: 0.1.45
+Version: 0.1.47
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11

{pysof-0.1.45 → pysof-0.1.47}/crates/fhir/Cargo.toml

@@ -24,9 +24,9 @@ xml = ["helios-serde-support/xml"]
 serde = { workspace = true }
 serde_json = { workspace = true, features = ["raw_value"] }
 clap = { version = "4.0", features = ["derive"] }
-helios-fhir-macro = { path = "../fhir-macro", version = "0.1.45" }
-helios-serde-support = { path = "../serde-support", version = "0.1.45" }
-helios-fhirpath-support = { path = "../fhirpath-support", version = "0.1.45" }
+helios-fhir-macro = { path = "../fhir-macro", version = "0.1.47" }
+helios-serde-support = { path = "../serde-support", version = "0.1.47" }
+helios-fhirpath-support = { path = "../fhirpath-support", version = "0.1.47" }
 time = "0.3"
 chrono = { workspace = true }
 # Re-add serde-with-arbitrary-precision, keep macros

{pysof-0.1.45 → pysof-0.1.47}/crates/fhir-macro/Cargo.toml

@@ -20,4 +20,4 @@ proc-macro2 = "1.0"
 serde = { workspace = true }
 serde_json = { workspace = true }
 heck = "0.5" # For case conversion
-helios-fhirpath-support = { path = "../fhirpath-support", version = "0.1.45" }
+helios-fhirpath-support = { path = "../fhirpath-support", version = "0.1.47" }

{pysof-0.1.45 → pysof-0.1.47}/crates/fhirpath/Cargo.toml

@@ -18,8 +18,8 @@ R5 = ["helios-fhir/R5"]
 R6 = ["helios-fhir/R6"]
 
 [dependencies]
-helios-fhir = { path = "../fhir", version = "0.1.45" }
-helios-fhirpath-support = { path = "../fhirpath-support", version = "0.1.45" }
+helios-fhir = { path = "../fhir", version = "0.1.47" }
+helios-fhirpath-support = { path = "../fhirpath-support", version = "0.1.47" }
 chumsky = "0.10"
 roxmltree = "0.20"
 chrono = { workspace = true } # For date/time parsing and functions

{pysof-0.1.45 → pysof-0.1.47}/crates/fhirpath/README.md

@@ -288,9 +288,9 @@ The SQL on FHIR specification leverages FHIRPath to define flattened tabular vie
     *   [select()](https://hl7.org/fhirpath/2025Jan/#selectprojection-expression--collection): ✅
     *   [sort()](https://hl7.org/fhirpath/2025Jan/#sortkeyselector-expression-asc--desc----collection) (STU): ✅ (Sort with optional key selector)
     *   [repeat()](https://hl7.org/fhirpath/2025Jan/#repeatprojection-expression--collection): ✅ (With cycle detection)
-    *   [repeatAll()](https://hl7.org/fhirpath/2025Jan/#repeatallprojection-expression--collection) (STU): ❌ Not Implemented
+    *   [repeatAll()](https://hl7.org/fhirpath/2025Jan/#repeatallprojection-expression--collection) (STU): ✅
     *   [ofType()](https://hl7.org/fhirpath/2025Jan/#oftypetype--type-specifier--collection): ✅ (Full namespace qualification support)
-    *   [coalesce()](https://hl7.org/fhirpath/2025Jan/#coalescevalue--collection----collection) (STU): ❌ Not Implemented
+    *   [coalesce()](https://hl7.org/fhirpath/2025Jan/#coalescevalue--collection----collection) (STU): ✅
 *   [Subsetting](https://hl7.org/fhirpath/2025Jan/#subsetting)
     *   [Indexer `[]`](https://hl7.org/fhirpath/2025Jan/#-index--integer---collection): ✅
     *   [single()](https://hl7.org/fhirpath/2025Jan/#single--collection): ✅
@@ -303,7 +303,7 @@ The SQL on FHIR specification leverages FHIRPath to define flattened tabular vie
     *   [exclude()](https://hl7.org/fhirpath/2025Jan/#excludeother-collection--collection): ✅
 *   [Combining](https://hl7.org/fhirpath/2025Jan/#combining)
     *   [union()](https://hl7.org/fhirpath/2025Jan/#unionother--collection): ✅
-    *   [combine()](https://hl7.org/fhirpath/2025Jan/#combineother--collection--collection): 🟡 (Basic implementation; `preserveOrder` parameter not yet supported)
+    *   [combine()](https://hl7.org/fhirpath/2025Jan/#combineother--collection--collection): ✅ (Including optional `preserveOrder` parameter)
 *   [Conversion](https://hl7.org/fhirpath/2025Jan/#conversion)
     *   [Implicit Conversions](https://hl7.org/fhirpath/2025Jan/#conversion): ✅ (Integer/Decimal)
     *   [iif()](https://hl7.org/fhirpath/2025Jan/#iifcriterion-expression-true-result-collection--otherwise-result-collection--collection): ✅
@@ -313,18 +313,20 @@ The SQL on FHIR specification leverages FHIRPath to define flattened tabular vie
     *   [convertsToInteger()](https://hl7.org/fhirpath/2025Jan/#convertstointeger--boolean): ✅
     *   [toLong()](https://hl7.org/fhirpath/2025Jan/#tolong--long) (STU): ✅
     *   [convertsToLong()](https://hl7.org/fhirpath/2025Jan/#convertstolong--boolean) (STU): ✅
-    *   [toDate()](https://hl7.org/fhirpath/2025Jan/#todate--date): ✅
+    *   [toDate()](https://hl7.org/fhirpath/2025Jan/#todate--date): ✅ (Including optional `format` parameter)
     *   [convertsToDate()](https://hl7.org/fhirpath/2025Jan/#convertstodate--boolean): ✅
-    *   [toDateTime()](https://hl7.org/fhirpath/2025Jan/#todatetime--datetime): ✅
+    *   [toDateTime()](https://hl7.org/fhirpath/2025Jan/#todatetime--datetime): ✅ (Including optional `format` parameter)
     *   [convertsToDateTime()](https://hl7.org/fhirpath/2025Jan/#convertstodatetime--boolean): ✅
     *   [toDecimal()](https://hl7.org/fhirpath/2025Jan/#todecimal--decimal): ✅
     *   [convertsToDecimal()](https://hl7.org/fhirpath/2025Jan/#convertstodecimal--boolean): ✅
     *   [toQuantity()](https://hl7.org/fhirpath/2025Jan/#toquantityunit--string--quantity): 🟡 (Basic types, no unit conversion)
     *   [convertsToQuantity()](https://hl7.org/fhirpath/2025Jan/#convertstoquantityunit--string--boolean): 🟡 (Basic types, no unit conversion)
-    *   [toString()](https://hl7.org/fhirpath/2025Jan/#tostring--string): ✅
+    *   [toString()](https://hl7.org/fhirpath/2025Jan/#tostring--string): ✅ (Including optional `format` parameter)
     *   [convertsToString()](https://hl7.org/fhirpath/2025Jan/#convertstostring--string): ✅
     *   [toTime()](https://hl7.org/fhirpath/2025Jan/#totime--time): ✅
     *   [convertsToTime()](https://hl7.org/fhirpath/2025Jan/#convertstotime--boolean): ✅
+*   [Date Conversion Functions](https://hl7.org/fhirpath/2025Jan/#date-conversion-functions) (STU)
+    *   Date/DateTime/Time string format codes (`yyyy`, `MM`, `dd`, etc.): ✅
 *   [String Manipulation](https://hl7.org/fhirpath/2025Jan/#string-manipulation)
     *   [indexOf()](https://hl7.org/fhirpath/2025Jan/#indexofsubstring--string--integer): ✅
     *   [lastIndexOf()](https://hl7.org/fhirpath/2025Jan/#lastindexofsubstring--string--integer) (STU): ✅
@@ -335,9 +337,9 @@ The SQL on FHIR specification leverages FHIRPath to define flattened tabular vie
     *   [upper()](https://hl7.org/fhirpath/2025Jan/#upper--string): ✅
     *   [lower()](https://hl7.org/fhirpath/2025Jan/#lower--string): ✅
     *   [replace()](https://hl7.org/fhirpath/2025Jan/#replacepattern--string-substitution--string--string): ✅
-    *   [matches()](https://hl7.org/fhirpath/2025Jan/#matchesregex--string--boolean): 🟡 (Basic implementation; optional `flags` parameter not yet supported)
-    *   [matchesFull()](https://hl7.org/fhirpath/2025Jan/#matchesfullregex--string--boolean) (STU): 🟡 (Basic implementation; optional `flags` parameter not yet supported)
-    *   [replaceMatches()](https://hl7.org/fhirpath/2025Jan/#replacematchesregex--string-substitution-string--string): 🟡 (Basic implementation; optional `flags` parameter not yet supported)
+    *   [matches()](https://hl7.org/fhirpath/2025Jan/#matchesregex--string--boolean): ✅ (Including optional `flags` parameter: `s`, `m`, `i`, `x`)
+    *   [matchesFull()](https://hl7.org/fhirpath/2025Jan/#matchesfullregex--string--boolean) (STU): ✅ (Including optional `flags` parameter)
+    *   [replaceMatches()](https://hl7.org/fhirpath/2025Jan/#replacematchesregex--string-substitution-string--string): ✅ (Including optional `flags` parameter)
     *   [length()](https://hl7.org/fhirpath/2025Jan/#length--integer): ✅
     *   [toChars()](https://hl7.org/fhirpath/2025Jan/#tochars--collection): ✅
     *   [encode()](https://hl7.org/fhirpath/2025Jan/#encodeformat--string--string): ✅
@@ -373,7 +375,10 @@ The SQL on FHIR specification leverages FHIRPath to define flattened tabular vie
     *   [highBoundary()](https://hl7.org/fhirpath/2025Jan/#highboundaryprecision-integer-decimal--date--datetime--time) (STU): ✅ (Full support for Decimal, Date, DateTime, and Time)
     *   [precision()](https://hl7.org/fhirpath/2025Jan/#precision--integer) (STU): ✅ (See [limitation for decimal trailing zeros](PRECISION_LIMITATION.md))
 *   [Date/DateTime/Time Component Extraction](https://hl7.org/fhirpath/2025Jan/#extract-datedatetimetime-components) (STU): ✅ (All component functions implemented: yearOf, monthOf, dayOf, hourOf, minuteOf, secondOf, millisecondOf)
-    
+*   [Date and Time Interval Functions](https://hl7.org/fhirpath/2025Jan/#date-and-time-interval-functions) (STU)
+    *   [duration()](https://hl7.org/fhirpath/2025Jan/#durationvalue-date--datetime--time-precision-identifier-integer): ✅
+    *   [difference()](https://hl7.org/fhirpath/2025Jan/#differencevalue-date--datetime--time-precision-identifier-integer): ✅
+
 ### [Operations](https://hl7.org/fhirpath/2025Jan/#operations)
     
 *   [Equality](https://hl7.org/fhirpath/2025Jan/#equality)
@@ -409,15 +414,20 @@ The SQL on FHIR specification leverages FHIRPath to define flattened tabular vie
     *   [`mod` (Modulo)](https://hl7.org/fhirpath/2025Jan/#mod): ✅ (Numeric)
     *   [`&` (String Concatenation)](https://hl7.org/fhirpath/2025Jan/#-string-concatenation): ✅
 *   [Date/Time Arithmetic](https://hl7.org/fhirpath/2025Jan/#datetime-arithmetic): ✅ (Full arithmetic support with timezone and precision handling)
+*   [Unary Operators (`+` and `-`)](https://hl7.org/fhirpath/2025Jan/#unary-operators--and--): ✅
 *   [Operator Precedence](https://hl7.org/fhirpath/2025Jan/#operator-precedence): ✅
     
+### [Instance Selector](https://hl7.org/fhirpath/2025Jan/#instance-selector) (STU)
+
+*   Object creation syntax (`typename { element : value, ... }`): ✅
+
 ### [Aggregates](https://hl7.org/fhirpath/2025Jan/#aggregates)
 
 *   [aggregate()](https://hl7.org/fhirpath/2025Jan/#aggregateaggregator--expression--init--value--value) (STU): ✅ (Full accumulator support)
-*   [sum()](https://hl7.org/fhirpath/2025Jan/#sum--integer--long--decimal--quantity) (STU): ❌ Not Implemented (can be done via `aggregate($this + $total, 0)`)
-*   [min()](https://hl7.org/fhirpath/2025Jan/#min--integer--long--decimal--quantity--date--datetime--time--string) (STU): ❌ Not Implemented
-*   [max()](https://hl7.org/fhirpath/2025Jan/#max--integer--long--decimal--quantity--date--datetime--time--string) (STU): ❌ Not Implemented
-*   [avg()](https://hl7.org/fhirpath/2025Jan/#avg--decimal--quantity) (STU): ❌ Not Implemented
+*   [sum()](https://hl7.org/fhirpath/2025Jan/#sum--integer--long--decimal--quantity) (STU): ✅
+*   [min()](https://hl7.org/fhirpath/2025Jan/#min--integer--long--decimal--quantity--date--datetime--time--string) (STU): ✅
+*   [max()](https://hl7.org/fhirpath/2025Jan/#max--integer--long--decimal--quantity--date--datetime--time--string) (STU): ✅
+*   [avg()](https://hl7.org/fhirpath/2025Jan/#avg--decimal--quantity) (STU): ✅
 
 ### [Lexical Elements](https://hl7.org/fhirpath/2025Jan/#lexical-elements)
 

pysof-0.1.47/crates/fhirpath/src/aggregate_math_functions.rs

@@ -0,0 +1,458 @@
+//! # FHIRPath Aggregate Math Functions
+//!
+//! Implements the aggregate math functions: `sum()`, `min()`, `max()`, `avg()`.
+
+use helios_fhirpath_support::{EvaluationError, EvaluationResult};
+use rust_decimal::Decimal;
+use std::cmp::Ordering;
+
+/// Extracts items from an EvaluationResult into a Vec.
+fn extract_items(input: &EvaluationResult) -> Vec<&EvaluationResult> {
+    match input {
+        EvaluationResult::Collection { items, .. } => items.iter().collect(),
+        EvaluationResult::Empty => vec![],
+        single_item => vec![single_item],
+    }
+}
+
+/// Compares two EvaluationResults of compatible types.
+/// Returns None if the types are incomparable.
+fn compare_values(a: &EvaluationResult, b: &EvaluationResult) -> Option<Ordering> {
+    match (a, b) {
+        (EvaluationResult::Integer(a, _), EvaluationResult::Integer(b, _)) => Some(a.cmp(b)),
+        (EvaluationResult::Integer64(a, _), EvaluationResult::Integer64(b, _)) => Some(a.cmp(b)),
+        (EvaluationResult::Decimal(a, _), EvaluationResult::Decimal(b, _)) => Some(a.cmp(b)),
+        // Mixed numeric: promote to Decimal
+        (EvaluationResult::Integer(a, _), EvaluationResult::Decimal(b, _)) => {
+            Some(Decimal::from(*a).cmp(b))
+        }
+        (EvaluationResult::Decimal(a, _), EvaluationResult::Integer(b, _)) => {
+            Some(a.cmp(&Decimal::from(*b)))
+        }
+        (EvaluationResult::Integer(a, _), EvaluationResult::Integer64(b, _)) => Some(a.cmp(b)),
+        (EvaluationResult::Integer64(a, _), EvaluationResult::Integer(b, _)) => Some(a.cmp(b)),
+        // Quantity comparison (same unit only)
+        (
+            EvaluationResult::Quantity(val_a, unit_a, _),
+            EvaluationResult::Quantity(val_b, unit_b, _),
+        ) => {
+            if unit_a == unit_b {
+                Some(val_a.cmp(val_b))
+            } else {
+                None
+            }
+        }
+        // String comparison
+        (EvaluationResult::String(a, _), EvaluationResult::String(b, _)) => Some(a.cmp(b)),
+        // Date/Time comparisons
+        (EvaluationResult::Date(a, _), EvaluationResult::Date(b, _)) => Some(a.cmp(b)),
+        (EvaluationResult::DateTime(a, _), EvaluationResult::DateTime(b, _)) => Some(a.cmp(b)),
+        (EvaluationResult::Time(a, _), EvaluationResult::Time(b, _)) => Some(a.cmp(b)),
+        _ => None,
+    }
+}
+
+/// Implements the FHIRPath `sum()` function.
+///
+/// Returns the sum of all items in the collection.
+/// If the collection is empty, returns 0 (Integer).
+/// Items must be Integer, Decimal, or Quantity (same unit).
+pub fn sum_function(
+    invocation_base: &EvaluationResult,
+) -> Result<EvaluationResult, EvaluationError> {
+    let items = extract_items(invocation_base);
+
+    if items.is_empty() {
+        return Ok(EvaluationResult::integer(0));
+    }
+
+    let mut acc = items[0].clone();
+
+    for item in &items[1..] {
+        acc = add_values(&acc, item)?;
+    }
+
+    Ok(acc)
+}
+
+/// Implements the FHIRPath `min()` function.
+///
+/// Returns the minimum value in the collection.
+/// If the collection is empty, returns Empty.
+pub fn min_function(
+    invocation_base: &EvaluationResult,
+) -> Result<EvaluationResult, EvaluationError> {
+    let items = extract_items(invocation_base);
+
+    if items.is_empty() {
+        return Ok(EvaluationResult::Empty);
+    }
+
+    let mut min_val = items[0];
+
+    for item in &items[1..] {
+        match compare_values(min_val, item) {
+            Some(Ordering::Greater) => min_val = item,
+            Some(_) => {}
+            None => {
+                return Err(EvaluationError::TypeError(format!(
+                    "min() cannot compare {} and {}",
+                    min_val.type_name(),
+                    item.type_name()
+                )));
+            }
+        }
+    }
+
+    Ok(min_val.clone())
+}
+
+/// Implements the FHIRPath `max()` function.
+///
+/// Returns the maximum value in the collection.
+/// If the collection is empty, returns Empty.
+pub fn max_function(
+    invocation_base: &EvaluationResult,
+) -> Result<EvaluationResult, EvaluationError> {
+    let items = extract_items(invocation_base);
+
+    if items.is_empty() {
+        return Ok(EvaluationResult::Empty);
+    }
+
+    let mut max_val = items[0];
+
+    for item in &items[1..] {
+        match compare_values(max_val, item) {
+            Some(Ordering::Less) => max_val = item,
+            Some(_) => {}
+            None => {
+                return Err(EvaluationError::TypeError(format!(
+                    "max() cannot compare {} and {}",
+                    max_val.type_name(),
+                    item.type_name()
+                )));
+            }
+        }
+    }
+
+    Ok(max_val.clone())
+}
+
+/// Implements the FHIRPath `avg()` function.
+///
+/// Returns the average of all items in the collection.
+/// If the collection is empty, returns Empty.
+/// Always returns Decimal (or Quantity).
+pub fn avg_function(
+    invocation_base: &EvaluationResult,
+) -> Result<EvaluationResult, EvaluationError> {
+    let items = extract_items(invocation_base);
+
+    if items.is_empty() {
+        return Ok(EvaluationResult::Empty);
+    }
+
+    let count = Decimal::from(items.len() as i64);
+    let sum = sum_function(invocation_base)?;
+
+    match sum {
+        EvaluationResult::Integer(v, _) => Ok(EvaluationResult::decimal(Decimal::from(v) / count)),
+        EvaluationResult::Integer64(v, _) => {
+            Ok(EvaluationResult::decimal(Decimal::from(v) / count))
+        }
+        EvaluationResult::Decimal(v, _) => Ok(EvaluationResult::decimal(v / count)),
+        EvaluationResult::Quantity(v, unit, _) => Ok(EvaluationResult::quantity(v / count, unit)),
+        _ => Err(EvaluationError::TypeError(
+            "avg() requires numeric or quantity items".to_string(),
+        )),
+    }
+}
+
+/// Adds two numeric or quantity values together.
+fn add_values(
+    a: &EvaluationResult,
+    b: &EvaluationResult,
+) -> Result<EvaluationResult, EvaluationError> {
+    match (a, b) {
+        (EvaluationResult::Integer(a, _), EvaluationResult::Integer(b, _)) => {
+            Ok(EvaluationResult::integer(a + b))
+        }
+        (EvaluationResult::Integer64(a, _), EvaluationResult::Integer64(b, _)) => {
+            Ok(EvaluationResult::integer64(*a + *b))
+        }
+        (EvaluationResult::Decimal(a, _), EvaluationResult::Decimal(b, _)) => {
+            Ok(EvaluationResult::decimal(*a + *b))
+        }
+        // Mixed numeric: promote to Decimal
+        (EvaluationResult::Integer(a, _), EvaluationResult::Decimal(b, _)) => {
+            Ok(EvaluationResult::decimal(Decimal::from(*a) + *b))
+        }
+        (EvaluationResult::Decimal(a, _), EvaluationResult::Integer(b, _)) => {
+            Ok(EvaluationResult::decimal(*a + Decimal::from(*b)))
+        }
+        (EvaluationResult::Integer(a, _), EvaluationResult::Integer64(b, _)) => {
+            Ok(EvaluationResult::integer64(*a + *b))
+        }
+        (EvaluationResult::Integer64(a, _), EvaluationResult::Integer(b, _)) => {
+            Ok(EvaluationResult::integer64(*a + *b))
+        }
+        // Quantity addition (same unit)
+        (
+            EvaluationResult::Quantity(val_a, unit_a, _),
+            EvaluationResult::Quantity(val_b, unit_b, _),
+        ) => {
+            if unit_a == unit_b {
+                Ok(EvaluationResult::quantity(*val_a + *val_b, unit_a.clone()))
+            } else {
+                Err(EvaluationError::TypeError(format!(
+                    "sum() cannot add quantities with different units: '{}' and '{}'",
+                    unit_a, unit_b
+                )))
+            }
+        }
+        _ => Err(EvaluationError::TypeError(format!(
+            "sum() requires numeric or quantity items, found {} and {}",
+            a.type_name(),
+            b.type_name()
+        ))),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use rust_decimal_macros::dec;
+
+    #[test]
+    fn test_sum_integers() {
+        let input = EvaluationResult::Collection {
+            items: vec![
+                EvaluationResult::integer(1),
+                EvaluationResult::integer(2),
+                EvaluationResult::integer(3),
+            ],
+            has_undefined_order: false,
+            type_info: None,
+        };
+        let result = sum_function(&input).unwrap();
+        assert_eq!(result, EvaluationResult::integer(6));
+    }
+
+    #[test]
+    fn test_sum_decimals() {
+        let input = EvaluationResult::Collection {
+            items: vec![
+                EvaluationResult::decimal(dec!(1.5)),
+                EvaluationResult::decimal(dec!(2.5)),
+            ],
+            has_undefined_order: false,
+            type_info: None,
+        };
+        let result = sum_function(&input).unwrap();
+        assert_eq!(result, EvaluationResult::decimal(dec!(4.0)));
+    }
+
+    #[test]
+    fn test_sum_mixed_int_decimal() {
+        let input = EvaluationResult::Collection {
+            items: vec![
+                EvaluationResult::integer(1),
+                EvaluationResult::decimal(dec!(2.5)),
+            ],
+            has_undefined_order: false,
+            type_info: None,
+        };
+        let result = sum_function(&input).unwrap();
+        assert_eq!(result, EvaluationResult::decimal(dec!(3.5)));
+    }
+
+    #[test]
+    fn test_sum_empty() {
+        let result = sum_function(&EvaluationResult::Empty).unwrap();
+        assert_eq!(result, EvaluationResult::integer(0));
+    }
+
+    #[test]
+    fn test_sum_quantities() {
+        let input = EvaluationResult::Collection {
+            items: vec![
+                EvaluationResult::quantity(dec!(5), "mg".to_string()),
+                EvaluationResult::quantity(dec!(3), "mg".to_string()),
+            ],
+            has_undefined_order: false,
+            type_info: None,
+        };
+        let result = sum_function(&input).unwrap();
+        assert_eq!(
+            result,
+            EvaluationResult::quantity(dec!(8), "mg".to_string())
+        );
+    }
+
+    #[test]
+    fn test_sum_quantities_different_units() {
+        let input = EvaluationResult::Collection {
+            items: vec![
+                EvaluationResult::quantity(dec!(5), "mg".to_string()),
+                EvaluationResult::quantity(dec!(3), "kg".to_string()),
+            ],
+            has_undefined_order: false,
+            type_info: None,
+        };
+        assert!(sum_function(&input).is_err());
+    }
+
+    #[test]
+    fn test_min_integers() {
+        let input = EvaluationResult::Collection {
+            items: vec![
+                EvaluationResult::integer(3),
+                EvaluationResult::integer(1),
+                EvaluationResult::integer(2),
+            ],
+            has_undefined_order: false,
+            type_info: None,
+        };
+        let result = min_function(&input).unwrap();
+        assert_eq!(result, EvaluationResult::integer(1));
+    }
+
+    #[test]
+    fn test_min_empty() {
+        let result = min_function(&EvaluationResult::Empty).unwrap();
+        assert_eq!(result, EvaluationResult::Empty);
+    }
+
+    #[test]
+    fn test_max_integers() {
+        let input = EvaluationResult::Collection {
+            items: vec![
+                EvaluationResult::integer(1),
+                EvaluationResult::integer(3),
+                EvaluationResult::integer(2),
+            ],
+            has_undefined_order: false,
+            type_info: None,
+        };
+        let result = max_function(&input).unwrap();
+        assert_eq!(result, EvaluationResult::integer(3));
+    }
+
+    #[test]
+    fn test_max_empty() {
+        let result = max_function(&EvaluationResult::Empty).unwrap();
+        assert_eq!(result, EvaluationResult::Empty);
+    }
+
+    #[test]
+    fn test_avg_integers() {
+        let input = EvaluationResult::Collection {
+            items: vec![
+                EvaluationResult::integer(1),
+                EvaluationResult::integer(2),
+                EvaluationResult::integer(3),
+            ],
+            has_undefined_order: false,
+            type_info: None,
+        };
+        let result = avg_function(&input).unwrap();
+        assert_eq!(result, EvaluationResult::decimal(dec!(2)));
+    }
+
+    #[test]
+    fn test_avg_decimals() {
+        let input = EvaluationResult::Collection {
+            items: vec![
+                EvaluationResult::decimal(dec!(1.5)),
+                EvaluationResult::decimal(dec!(2.5)),
+            ],
+            has_undefined_order: false,
+            type_info: None,
+        };
+        let result = avg_function(&input).unwrap();
+        assert_eq!(result, EvaluationResult::decimal(dec!(2.0)));
+    }
+
+    #[test]
+    fn test_avg_empty() {
+        let result = avg_function(&EvaluationResult::Empty).unwrap();
+        assert_eq!(result, EvaluationResult::Empty);
+    }
+
+    #[test]
+    fn test_avg_quantities() {
+        let input = EvaluationResult::Collection {
+            items: vec![
+                EvaluationResult::quantity(dec!(4), "mg".to_string()),
+                EvaluationResult::quantity(dec!(6), "mg".to_string()),
+            ],
+            has_undefined_order: false,
+            type_info: None,
+        };
+        let result = avg_function(&input).unwrap();
+        assert_eq!(
+            result,
+            EvaluationResult::quantity(dec!(5), "mg".to_string())
+        );
+    }
+
+    #[test]
+    fn test_min_strings() {
+        let input = EvaluationResult::Collection {
+            items: vec![
+                EvaluationResult::string("banana".to_string()),
+                EvaluationResult::string("apple".to_string()),
+                EvaluationResult::string("cherry".to_string()),
+            ],
+            has_undefined_order: false,
+            type_info: None,
+        };
+        let result = min_function(&input).unwrap();
+        assert_eq!(result, EvaluationResult::string("apple".to_string()));
+    }
+
+    #[test]
+    fn test_max_strings() {
+        let input = EvaluationResult::Collection {
+            items: vec![
+                EvaluationResult::string("banana".to_string()),
+                EvaluationResult::string("apple".to_string()),
+                EvaluationResult::string("cherry".to_string()),
+            ],
+            has_undefined_order: false,
+            type_info: None,
+        };
+        let result = max_function(&input).unwrap();
+        assert_eq!(result, EvaluationResult::string("cherry".to_string()));
+    }
+
+    #[test]
+    fn test_min_dates() {
+        let input = EvaluationResult::Collection {
+            items: vec![
+                EvaluationResult::date("2025-03-01".to_string()),
+                EvaluationResult::date("2025-01-01".to_string()),
+                EvaluationResult::date("2025-02-01".to_string()),
+            ],
+            has_undefined_order: false,
+            type_info: None,
+        };
+        let result = min_function(&input).unwrap();
+        assert_eq!(result, EvaluationResult::date("2025-01-01".to_string()));
+    }
+
+    #[test]
+    fn test_sum_single_item() {
+        let input = EvaluationResult::integer(42);
+        let result = sum_function(&input).unwrap();
+        assert_eq!(result, EvaluationResult::integer(42));
+    }
+
+    #[test]
+    fn test_min_single_item() {
+        let input = EvaluationResult::integer(42);
+        let result = min_function(&input).unwrap();
+        assert_eq!(result, EvaluationResult::integer(42));
+    }
+}

{pysof-0.1.45 → pysof-0.1.47}/crates/fhirpath/src/debug_trace.rs

@@ -171,5 +171,6 @@ fn expression_debug_name(expr: &Expression) -> String {
         Expression::Or(_, op, _) => op.clone(),
         Expression::Implies(_, _) => "implies".to_string(),
         Expression::Lambda(_, _) => "=>".to_string(),
+        Expression::InstanceSelector(type_name, _) => format!("{} {{...}}", type_name),
     }
 }