unyt-org · janiejestemja · Dec 17, 2025 · Dec 17, 2025 · Dec 17, 2025 · Dec 17, 2025
diff --git a/src/ast/structs/expression.rs b/src/ast/structs/expression.rs
@@ -16,6 +16,7 @@ use crate::values::core_values::decimal::typed_decimal::TypedDecimal;
 use crate::values::core_values::endpoint::Endpoint;
 use crate::values::core_values::integer::Integer;
 use crate::values::core_values::integer::typed_integer::TypedInteger;
+use crate::values::core_values::range;
 use crate::values::core_values::r#type::Type;
 use crate::values::pointer::PointerAddress;
 use crate::values::value::Value;
@@ -88,6 +89,8 @@ pub enum DatexExpressionData {
     /// Integer, e.g 123456789123456789
     Integer(Integer),
 
+    Range(range::Range),
+
     /// Typed Integer, e.g. 123i8
     TypedInteger(TypedInteger),
 
@@ -251,6 +254,12 @@ impl TryFrom<&DatexExpressionData> for ValueContainer {
                     crate::values::core_values::map::Map::from(entries),
                 )
             }
+            DatexExpressionData::Range(range) => ValueContainer::from(
+                crate::values::core_values::range::Range::new(
+                    range.start.clone(),
+                    range.end.clone(),
+                ),
+            ),
             _ => Err(())?,
         })
     }

diff --git a/src/core_compiler/value_compiler.rs b/src/core_compiler/value_compiler.rs
@@ -96,6 +96,13 @@ pub fn append_value(buffer: &mut Vec<u8>, value: &Value) {
             }
             append_instruction_code(buffer, InstructionCode::SCOPE_END);
         }
+        CoreValue::Range(range) => {
+            append_instruction_code(buffer, InstructionCode::RANGE);
+            let start = range.start.to_smallest_fitting();
+            let end = range.end.to_smallest_fitting();
+            append_encoded_integer(buffer, &start);
+            append_encoded_integer(buffer, &end);
+        }
     }
 }
 

diff --git a/src/decompiler/ast_from_value_container.rs b/src/decompiler/ast_from_value_container.rs
@@ -44,6 +44,7 @@ fn value_to_datex_expression(value: &Value) -> DatexExpressionData {
         }
         CoreValue::Boolean(boolean) => DatexExpressionData::Boolean(boolean.0),
         CoreValue::Text(text) => DatexExpressionData::Text(text.0.clone()),
+        CoreValue::Range(range) => DatexExpressionData::Range(range.clone()),
         CoreValue::Endpoint(endpoint) => {
             DatexExpressionData::Endpoint(endpoint.clone())
         }
@@ -88,6 +89,7 @@ mod tests {
     use crate::values::core_values::decimal::typed_decimal::TypedDecimal;
     use crate::values::core_values::integer::Integer;
     use crate::values::core_values::integer::typed_integer::TypedInteger;
+    use crate::values::core_values::range::Range;
     use crate::values::value::Value;
     use crate::values::value_container::ValueContainer;
 
@@ -98,6 +100,22 @@ mod tests {
         assert_eq!(ast, DatexExpressionData::Integer(Integer::from(42)));
     }
 
+    #[test]
+    fn range_to_ast() {
+        let range = ValueContainer::from(Range::new(
+            Integer::from(11),
+            Integer::from(13),
+        ));
+        let ast = DatexExpressionData::from(&range);
+        assert_eq!(
+            ast,
+            DatexExpressionData::Range(Range::new(
+                Integer::from(11),
+                Integer::from(13)
+            ))
+        );
+    }
+
     #[test]
     fn test_typed_integer_to_ast() {
         let value = ValueContainer::from(TypedInteger::from(42i8));

diff --git a/src/decompiler/ast_to_source_code.rs b/src/decompiler/ast_to_source_code.rs
@@ -463,6 +463,7 @@ impl AstToSourceCodeFormatter {
             }
             DatexExpressionData::Noop => "".to_string(),
             DatexExpressionData::Integer(i) => i.to_string(),
+            DatexExpressionData::Range(range) => range.to_string(),
             DatexExpressionData::TypedInteger(ti) => {
                 if self.add_variant_suffix() {
                     ti.to_string_with_suffix()
@@ -844,6 +845,15 @@ mod tests {
 
         let null_ast = DatexExpressionData::Null;
         assert_eq!(compact().format(&null_ast.with_default_span()), "null");
+
+        let range_ast = DatexExpressionData::Range(
+            crate::values::core_values::range::Range::new(
+                crate::values::core_values::integer::Integer(11.into()),
+                crate::values::core_values::integer::Integer(13.into()),
+            ),
+        );
+
+        assert_eq!(compact().format(&range_ast.with_default_span()), "11..13");
     }
 
     #[test]

diff --git a/src/dif/value.rs b/src/dif/value.rs
@@ -185,6 +185,9 @@ impl DIFValue {
                     }
                 }
             }
+            CoreValue::Range(range) => {
+                DIFValueRepresentation::String(range.to_string())
+            }
             CoreValue::Decimal(decimal) => {
                 // TODO #384: optimize this and pass as decimal if in range
                 DIFValueRepresentation::String(decimal.to_string())

diff --git a/src/libs/core.rs b/src/libs/core.rs
@@ -55,6 +55,7 @@ pub enum CoreLibPointerId {
     Unit,                                // #core.Unit
     Never,                               // #core.never
     Unknown,                             // #core.unknown
+    Range,
 }
 
 impl CoreLibPointerId {
@@ -75,6 +76,7 @@ impl CoreLibPointerId {
             CoreLibPointerId::Map => 12,
             CoreLibPointerId::Never => 13,
             CoreLibPointerId::Unknown => 14,
+            CoreLibPointerId::Range => 15,
             CoreLibPointerId::Integer(None) => Self::INTEGER_BASE,
             CoreLibPointerId::Integer(Some(v)) => {
                 let v: u8 = (*v).into();
@@ -102,6 +104,7 @@ impl CoreLibPointerId {
             12 => Some(CoreLibPointerId::Map),
             13 => Some(CoreLibPointerId::Never),
             14 => Some(CoreLibPointerId::Unknown),
+            15 => Some(CoreLibPointerId::Range),
 
             Self::INTEGER_BASE => Some(CoreLibPointerId::Integer(None)),
             n if (Self::INTEGER_BASE + 1..Self::DECIMAL_BASE).contains(&n) => {
@@ -220,6 +223,7 @@ pub fn create_core_lib() -> HashMap<CoreLibPointerId, TypeContainer> {
         unknown(),
         map(),
         null(),
+        range(),
     ]
     .into_iter()
     .chain(once(integer.clone()))
@@ -269,6 +273,10 @@ pub fn decimal() -> CoreLibTypeDefinition {
     create_core_type("decimal", None, None, CoreLibPointerId::Decimal(None))
 }
 
+pub fn range() -> CoreLibTypeDefinition {
+    create_core_type("range", None, None, CoreLibPointerId::Range)
+}
+
 pub fn decimal_variant(
     base_type: TypeContainer,
     variant: DecimalTypeVariant,

diff --git a/src/types/type_container.rs b/src/types/type_container.rs
@@ -120,6 +120,9 @@ impl TypeContainer {
     pub fn integer() -> Self {
         get_core_lib_type(CoreLibPointerId::Integer(None))
     }
+    pub fn range_definition() -> Self {
+        get_core_lib_type(CoreLibPointerId::Range)
+    }
     pub fn typed_integer(variant: IntegerTypeVariant) -> Self {
         get_core_lib_type(CoreLibPointerId::Integer(Some(variant)))
     }

diff --git a/src/values/core_value.rs b/src/values/core_value.rs
@@ -21,6 +21,7 @@ use crate::values::core_values::integer::typed_integer::{
 };
 use crate::values::core_values::list::List;
 use crate::values::core_values::map::Map;
+use crate::values::core_values::range::Range;
 use crate::values::core_values::text::Text;
 use crate::values::core_values::r#type::Type;
 use crate::values::value_container::{ValueContainer, ValueError};
@@ -40,6 +41,7 @@ pub enum CoreValue {
     List(List),
     Map(Map),
     Type(Type),
+    Range(Range),
 }
 impl StructuralEq for CoreValue {
     fn structural_eq(&self, other: &Self) -> bool {
@@ -87,6 +89,10 @@ impl StructuralEq for CoreValue {
             }
             (CoreValue::List(a), CoreValue::List(b)) => a.structural_eq(b),
             (CoreValue::Map(a), CoreValue::Map(b)) => a.structural_eq(b),
+
+            (CoreValue::Range(a), CoreValue::Range(b)) => {
+                a.start.structural_eq(&b.start) && a.end.structural_eq(&b.end)
+            }
             _ => false,
         }
     }
@@ -219,6 +225,7 @@ impl From<&CoreValue> for CoreLibPointerId {
             CoreValue::Endpoint(_) => CoreLibPointerId::Endpoint,
             CoreValue::Null => CoreLibPointerId::Null,
             CoreValue::Type(_) => CoreLibPointerId::Type,
+            CoreValue::Range(_) => CoreLibPointerId::Range,
         }
     }
 }
@@ -752,6 +759,7 @@ impl Display for CoreValue {
             CoreValue::Integer(integer) => core::write!(f, "{integer}"),
             CoreValue::Decimal(decimal) => core::write!(f, "{decimal}"),
             CoreValue::List(list) => core::write!(f, "{list}"),
+            CoreValue::Range(range) => core::write!(f, "{range}"),
         }
     }
 }
@@ -775,6 +783,15 @@ mod tests {
         assert_eq!(a.default_type().base_type().to_string(), "integer");
     }
 
+    #[test]
+    pub fn range_from_core() {
+        assert_eq!(
+            CoreValue::from(Range::new(Integer::from(11), Integer::from(13),))
+                .to_string(),
+            "11..13"
+        );
+    }
+
     #[test]
     fn addition() {
         init_logger_debug();

diff --git a/src/values/core_values/integer/mod.rs b/src/values/core_values/integer/mod.rs
@@ -20,7 +20,7 @@ use num::{BigInt, Num};
 use num_traits::ToPrimitive;
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Clone, PartialEq, Hash, Eq)]
+#[derive(Debug, Clone, PartialEq, PartialOrd, Hash, Eq)]
 pub struct Integer(pub BigInt);
 
 impl Serialize for Integer {

diff --git a/src/values/core_values/mod.rs b/src/values/core_values/mod.rs
@@ -5,5 +5,6 @@ pub mod error;
 pub mod integer;
 pub mod list;
 pub mod map;
+pub mod range;
 pub mod text;
 pub mod r#type;
diff --git a/src/values/core_values/range.rs b/src/values/core_values/range.rs
@@ -0,0 +1,91 @@
+use crate::values::core_values::integer::Integer;
+use core::fmt;
+use core::ops;
+
+#[derive(Debug)]
+pub enum RangeError {
+    StepOverflow,
+    InvalidRange,
+}
+
+#[derive(Clone, Eq, PartialEq, Hash)]
+pub struct Range {
+    // lower bound (inclusive)
+    pub start: Integer,
+    // upper bound (exclusive)
+    pub end: Integer,
+}
+
+impl From<Range> for ops::Range<Integer> {
+    fn from(range: Range) -> Self {
+        range.start..range.end
+    }
+}
+
+impl From<ops::Range<Integer>> for Range {
+    fn from(range: ops::Range<Integer>) -> Self {
+        Range {
+            start: range.start,
+            end: range.end,
+        }
+    }
+}
+
+impl Range {
+    pub fn new(start: Integer, end: Integer) -> Self {
+        Range { start, end }
+    }
+    pub fn is_empty(&self) -> bool {
+        self.end <= self.start
+    }
+}
+
+impl fmt::Debug for Range {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        core::write!(f, "{:?}..{:?}", self.start, self.end)
+    }
+}
+
+impl fmt::Display for Range {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        core::write!(f, "{}..{}", self.start, self.end)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::values::core_values::integer::Integer;
+
+    fn test_helper() -> (Integer, Integer, Integer) {
+        (
+            Integer::from_string("11").unwrap(),
+            Integer::from_string("23").unwrap(),
+            Integer::from_string("3").unwrap(),
+        )
+    }
+
+    #[test]
+    pub fn range_from_into() {
+        let (begin, ending, _) = test_helper();
+        let dx_range = Range::new(begin, ending.clone());
+        let std_range: ops::Range<Integer> = dx_range.clone().into();
+        let other_dx_range: Range = std_range.clone().into();
+
+        let other_std_range = ops::Range::from(other_dx_range.clone());
+        let other_dx_range = Range::from(std_range.clone());
+        assert_eq!(dx_range, other_dx_range);
+        assert_eq!(std_range, other_std_range);
+    }
+
+    #[test]
+    pub fn range_formatting() {
+        let (begin, ending, _) = test_helper();
+        let range = Range::new(begin, ending.clone());
+
+        let displayed = format!("{}", range);
+        let debugged = format!("{:?}", range);
+        assert_eq!(displayed, "11..23");
+        assert_eq!(debugged, "Integer(11)..Integer(23)");
+    }
+}
diff --git a/src/visitor/expression/mod.rs b/src/visitor/expression/mod.rs
@@ -13,6 +13,7 @@ use crate::values::core_values::decimal::typed_decimal::TypedDecimal;
 use crate::values::core_values::endpoint::Endpoint;
 use crate::values::core_values::integer::Integer;
 use crate::values::core_values::integer::typed_integer::TypedInteger;
+use crate::values::core_values::range;
 use crate::values::pointer::PointerAddress;
 use crate::visitor::VisitAction;
 use crate::visitor::expression::visitable::{
@@ -74,6 +75,9 @@ pub trait ExpressionVisitor<E>: TypeExpressionVisitor<E> {
             DatexExpressionData::Integer(i) => {
                 self.visit_integer(i, &expr.span)
             }
+            DatexExpressionData::Range(range) => {
+                self.visit_range_definition(range, &expr.span)
+            }
             DatexExpressionData::TypedInteger(ti) => {
                 self.visit_typed_integer(ti, &expr.span)
             }
@@ -559,4 +563,14 @@ pub trait ExpressionVisitor<E>: TypeExpressionVisitor<E> {
         let _ = slot;
         Ok(VisitAction::SkipChildren)
     }
+
+    fn visit_range_definition(
+        &mut self,
+        range: &range::Range,
+        span: &Range<usize>,
+    ) -> ExpressionVisitResult<E> {
+        let _ = span;
+        let _ = range;
+        Ok(VisitAction::SkipChildren)
+    }
 }
diff --git a/src/visitor/expression/visitable.rs b/src/visitor/expression/visitable.rs
@@ -287,6 +287,7 @@ impl<E> VisitableExpression<E> for DatexExpression {
             | DatexExpressionData::Decimal(_)
             | DatexExpressionData::TypedDecimal(_)
             | DatexExpressionData::Integer(_)
+            | DatexExpressionData::Range(_)
             | DatexExpressionData::TypedInteger(_)
             | DatexExpressionData::Identifier(_)
             | DatexExpressionData::Endpoint(_) => Ok(()),