feat(fzn-rs): Implement support for i32 as an integer type

Author: maartenflippo

fzn-rs/src/ast.rs

@@ -4,6 +4,7 @@
 //! It is a modified version of the `FlatZinc` type from [`flatzinc-serde`](https://docs.rs/flatzinc-serde).
 use std::collections::BTreeMap;
 use std::fmt::Display;
+use std::iter::FusedIterator;
 use std::ops::RangeInclusive;
 use std::rc::Rc;
 
@@ -153,15 +154,26 @@ impl<E: PartialOrd> RangeList<E> {
     }
 }
 
-impl RangeList<i64> {
-    /// Obtain an iterator over the values in this set.
-    ///
-    /// Currently only implemented for `i64` elements, as that is what is used in the AST.
-    pub fn iter(&self) -> impl Iterator<Item = i64> + '_ {
-        self.intervals.iter().flat_map(|&(start, end)| start..=end)
-    }
+macro_rules! impl_iter_fn {
+    ($int_type:ty) => {
+        impl<'a> IntoIterator for &'a RangeList<$int_type> {
+            type Item = $int_type;
+
+            type IntoIter = RangeListIter<'a, $int_type>;
+
+            fn into_iter(self) -> Self::IntoIter {
+                RangeListIter {
+                    current_interval: self.intervals.first().copied().unwrap_or((1, 0)),
+                    tail: &self.intervals[1..],
+                }
+            }
+        }
+    };
 }
 
+impl_iter_fn!(i32);
+impl_iter_fn!(i64);
+
 impl<E: Copy + Ord> From<RangeInclusive<E>> for RangeList<E> {
     fn from(value: RangeInclusive<E>) -> Self {
         RangeList {
@@ -170,15 +182,81 @@ impl<E: Copy + Ord> From<RangeInclusive<E>> for RangeList<E> {
     }
 }
 
-impl<E: Copy + Ord> FromIterator<E> for RangeList<E> {
-    fn from_iter<T: IntoIterator<Item = E>>(iter: T) -> Self {
-        let mut intervals: Vec<_> = iter.into_iter().map(|e| (e, e)).collect();
-        intervals.sort();
+macro_rules! range_list_from_iter {
+    ($int_type:ty) => {
+        impl FromIterator<$int_type> for RangeList<$int_type> {
+            fn from_iter<T: IntoIterator<Item = $int_type>>(iter: T) -> Self {
+                let mut intervals: Vec<_> = iter.into_iter().map(|e| (e, e)).collect();
+                intervals.sort();
+                intervals.dedup();
+
+                let mut idx = 0;
+
+                while idx < intervals.len() - 1 {
+                    let current = intervals[idx];
+                    let next = intervals[idx + 1];
+
+                    if current.1 >= next.0 - 1 {
+                        intervals[idx] = (current.0, next.1);
+                        let _ = intervals.remove(idx + 1);
+                    } else {
+                        idx += 1;
+                    }
+                }
+
+                RangeList { intervals }
+            }
+        }
+    };
+}
+
+range_list_from_iter!(i32);
+range_list_from_iter!(i64);
 
-        RangeList { intervals }
-    }
+/// An [`Iterator`] over a [`RangeList`].
+#[derive(Debug)]
+pub struct RangeListIter<'a, E> {
+    current_interval: (E, E),
+    tail: &'a [(E, E)],
+}
+
+macro_rules! impl_range_list_iter {
+    ($int_type:ty) => {
+        impl<'a> RangeListIter<'a, $int_type> {
+            fn new(intervals: &'a [($int_type, $int_type)]) -> Self {
+                RangeListIter {
+                    current_interval: intervals.first().copied().unwrap_or((1, 0)),
+                    tail: &intervals[1..],
+                }
+            }
+        }
+
+        impl Iterator for RangeListIter<'_, $int_type> {
+            type Item = $int_type;
+
+            fn next(&mut self) -> Option<Self::Item> {
+                let (current_lb, current_ub) = self.current_interval;
+
+                if current_lb > current_ub {
+                    let (next_interval, new_tail) = self.tail.split_first()?;
+                    self.current_interval = *next_interval;
+                    self.tail = new_tail;
+                }
+
+                let current_lb = self.current_interval.0;
+                self.current_interval.0 += 1;
+
+                Some(current_lb)
+            }
+        }
+
+        impl FusedIterator for RangeListIter<'_, $int_type> {}
+    };
 }
 
+impl_range_list_iter!(i32);
+impl_range_list_iter!(i64);
+
 /// A literal in the instance.
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum Literal {
@@ -265,3 +343,33 @@ pub enum AnnotationLiteral {
     /// `Annotation::Atom(ident)` or an `Literal::Identifier`.
     Annotation(AnnotationCall),
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn rangelist_from_iter_identifies_continuous_ranges() {
+        let set = RangeList::from_iter([1, 2, 3, 4]);
+
+        assert!(set.is_continuous());
+    }
+
+    #[test]
+    fn rangelist_from_iter_identifiers_non_continuous_ranges() {
+        let set = RangeList::from_iter([1, 3, 4, 6]);
+
+        assert!(!set.is_continuous());
+    }
+
+    #[test]
+    fn rangelist_iter_produces_elements_in_set() {
+        let set: RangeList<i32> = RangeList::from_iter([1, 3, 5]);
+
+        let mut iter = set.into_iter();
+        assert_eq!(Some(1), iter.next());
+        assert_eq!(Some(3), iter.next());
+        assert_eq!(Some(5), iter.next());
+        assert_eq!(None, iter.next());
+    }
+}

fzn-rs/src/error.rs

@@ -22,6 +22,9 @@ pub enum InstanceError {
 
     #[error("expected {expected} arguments, got {actual}")]
     IncorrectNumberOfArguments { expected: usize, actual: usize },
+
+    #[error("value {0} does not fit in the required integer type")]
+    IntegerOverflow(i64),
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]

fzn-rs/src/from_ast.rs

@@ -64,6 +64,17 @@ pub trait FromLiteral: Sized {
     fn from_literal(node: &ast::Node<ast::Literal>) -> Result<Self, InstanceError>;
 }
 
+impl FromLiteral for i32 {
+    fn expected() -> Token {
+        Token::IntLiteral
+    }
+
+    fn from_literal(node: &ast::Node<ast::Literal>) -> Result<Self, InstanceError> {
+        let integer = <i64 as FromLiteral>::from_literal(node)?;
+        i32::try_from(integer).map_err(|_| InstanceError::IntegerOverflow(integer))
+    }
+}
+
 impl FromLiteral for i64 {
     fn expected() -> Token {
         Token::IntLiteral
@@ -138,6 +149,20 @@ impl FromLiteral for bool {
     }
 }
 
+impl FromLiteral for RangeList<i32> {
+    fn expected() -> Token {
+        Token::IntSetLiteral
+    }
+
+    fn from_literal(argument: &ast::Node<ast::Literal>) -> Result<Self, InstanceError> {
+        let set = <RangeList<i64> as FromLiteral>::from_literal(argument)?;
+
+        set.into_iter()
+            .map(|elem| i32::try_from(elem).map_err(|_| InstanceError::IntegerOverflow(elem)))
+            .collect::<Result<_, _>>()
+    }
+}
+
 impl FromLiteral for RangeList<i64> {
     fn expected() -> Token {
         Token::IntSetLiteral

fzn-rs/src/fzn/mod.rs

@@ -502,6 +502,7 @@ fn set_of<'tokens, 'src: 'tokens, I, T: Copy + Ord>(
 ) -> impl Parser<'tokens, I, ast::RangeList<T>, FznExtra<'tokens, 'src>> + Clone
 where
     I: ValueInput<'tokens, Span = ast::Span, Token = Token<'src>>,
+    ast::RangeList<T>: FromIterator<T>,
 {
     let sparse_set = value_parser
         .clone()