Run cargo fmt after automated changes

Author: erickpintor

evaluator/src/builtins.rs

@@ -698,12 +698,7 @@ pub fn compile_eager_op(op: &str) -> CompiledExprWithArgs {
             Ok(Value::map(set.iter().map(|v| v.as_tuple2()).collect()))
         },
         // A set of all possible maps with keys and values from the given sets.
-        "setOfMaps" => |_env, args| {
-            Ok(Value::map_set(
-                args[0].clone(),
-                args[1].clone(),
-            ))
-        },
+        "setOfMaps" => |_env, args| Ok(Value::map_set(args[0].clone(), args[1].clone())),
         // Expect a value to be false
         "fail" => |_env, args| Ok(Value::bool(!args[0].as_bool())),
         // Expect a value to be true, returning a runtime error if it is not

evaluator/src/itf.rs

@@ -89,7 +89,9 @@ impl Value {
             | ValueInner::MapSet(_, _) => {
                 itf::Value::Set(self.as_set().iter().map(|v| v.to_itf()).collect())
             }
-            ValueInner::Tuple(elems) => itf::Value::Tuple(elems.iter().map(|v| v.to_itf()).collect()),
+            ValueInner::Tuple(elems) => {
+                itf::Value::Tuple(elems.iter().map(|v| v.to_itf()).collect())
+            }
             ValueInner::Record(fields) => itf::Value::Record(
                 fields
                     .iter()

evaluator/src/normalizer.rs

@@ -20,7 +20,9 @@ impl Value {
                     .map(|v| v.normalize())
                     .collect(),
             ),
-            ValueInner::Tuple(elems) => Value::tuple(elems.iter().cloned().map(|v| v.normalize()).collect()),
+            ValueInner::Tuple(elems) => {
+                Value::tuple(elems.iter().cloned().map(|v| v.normalize()).collect())
+            }
             ValueInner::Record(fields) => Value::record(
                 fields
                     .iter()
@@ -32,7 +34,9 @@ impl Value {
                     .map(|(k, v)| (k.clone().normalize(), v.clone().normalize()))
                     .collect(),
             ),
-            ValueInner::List(elems) => Value::list(elems.iter().cloned().map(|v| v.normalize()).collect()),
+            ValueInner::List(elems) => {
+                Value::list(elems.iter().cloned().map(|v| v.normalize()).collect())
+            }
             ValueInner::Variant(label, value) => {
                 Value::variant(label.clone(), value.clone().normalize())
             }

evaluator/src/value.rs

@@ -25,8 +25,8 @@ use std::borrow::Cow;
 use std::cell::RefCell;
 use std::fmt;
 use std::hash::{Hash, Hasher};
-use std::rc::Rc;
 use std::ops::Deref;
+use std::rc::Rc;
 
 /// Quint values that hold sets are immutable, use `GenericHashSet` immutable
 /// structure to hold them
@@ -187,7 +187,7 @@ impl Eq for ValueInner {}
 
 impl Deref for Value {
     type Target = ValueInner;
-    
+
     fn deref(&self) -> &Self::Target {
         &self.0
     }
@@ -198,55 +198,55 @@ impl Value {
     pub fn int(n: i64) -> Self {
         Value(Rc::new(ValueInner::Int(n)))
     }
-    
+
     pub fn bool(b: bool) -> Self {
         Value(Rc::new(ValueInner::Bool(b)))
     }
-    
+
     pub fn str(s: Str) -> Self {
         Value(Rc::new(ValueInner::Str(s)))
     }
-    
+
     pub fn set(s: ImmutableSet<Value>) -> Self {
         Value(Rc::new(ValueInner::Set(s)))
     }
-    
+
     pub fn tuple(t: ImmutableVec<Value>) -> Self {
         Value(Rc::new(ValueInner::Tuple(t)))
     }
-    
+
     pub fn record(r: ImmutableMap<QuintName, Value>) -> Self {
         Value(Rc::new(ValueInner::Record(r)))
     }
-    
+
     pub fn map(m: ImmutableMap<Value, Value>) -> Self {
         Value(Rc::new(ValueInner::Map(m)))
     }
-    
+
     pub fn list(l: ImmutableVec<Value>) -> Self {
         Value(Rc::new(ValueInner::List(l)))
     }
-    
+
     pub fn lambda(registers: Vec<Rc<RefCell<EvalResult>>>, body: CompiledExpr) -> Self {
         Value(Rc::new(ValueInner::Lambda(registers, body)))
     }
-    
+
     pub fn variant(name: QuintName, value: Value) -> Self {
         Value(Rc::new(ValueInner::Variant(name, value)))
     }
-    
+
     pub fn interval(start: i64, end: i64) -> Self {
         Value(Rc::new(ValueInner::Interval(start, end)))
     }
-    
+
     pub fn cross_product(values: Vec<Value>) -> Self {
         Value(Rc::new(ValueInner::CrossProduct(values)))
     }
-    
+
     pub fn power_set(value: Value) -> Self {
         Value(Rc::new(ValueInner::PowerSet(value)))
     }
-    
+
     pub fn map_set(a: Value, b: Value) -> Self {
         Value(Rc::new(ValueInner::MapSet(a, b)))
     }
@@ -260,7 +260,9 @@ impl Value {
             ValueInner::Map(map) => map.len(),
             ValueInner::List(elems) => elems.len(),
             ValueInner::Interval(start, end) => (end - start + 1).try_into().unwrap(),
-            ValueInner::CrossProduct(sets) => sets.iter().fold(1, |acc, set| acc * set.cardinality()),
+            ValueInner::CrossProduct(sets) => {
+                sets.iter().fold(1, |acc, set| acc * set.cardinality())
+            }
             ValueInner::PowerSet(value) => {
                 // 2^(cardinality of value)
                 2_usize.pow(value.cardinality().try_into().unwrap())
@@ -314,7 +316,9 @@ impl Value {
                         .zip(supersets)
                         .all(|(subset, superset)| subset.subseteq(superset))
             }
-            (ValueInner::PowerSet(subset), ValueInner::PowerSet(superset)) => subset.subseteq(superset),
+            (ValueInner::PowerSet(subset), ValueInner::PowerSet(superset)) => {
+                subset.subseteq(superset)
+            }
             (
                 ValueInner::MapSet(subset_domain, subset_range),
                 ValueInner::MapSet(superset_domain, superset_range),
@@ -374,7 +378,9 @@ impl Value {
     pub fn as_set(&self) -> Cow<'_, ImmutableSet<Value>> {
         match self.0.as_ref() {
             ValueInner::Set(set) => Cow::Borrowed(set),
-            ValueInner::Interval(start, end) => Cow::Owned((*start..=*end).map(Value::int).collect()),
+            ValueInner::Interval(start, end) => {
+                Cow::Owned((*start..=*end).map(Value::int).collect())
+            }
             ValueInner::CrossProduct(sets) => {
                 let size = self.cardinality();
                 if size == 0 {