style: clippy (the old version used on pipeline)

src/prototype/smart_system_update_fn.rs

@@ -61,7 +61,7 @@ impl<D: SymbolicDomain<u8>> SmartSystemUpdateFn<D, u8> {
                     ),
                 );
 
-                let primed_name = format!("{}'", name.clone());
+                let primed_name = format!("{}'", name);
                 let primed = (
                     primed_name.clone(),
                     D::new(
@@ -2247,7 +2247,6 @@ mod tests {
         // the orderings might be fcked up -> pair the corresponding bdds of the two
         let smart_triple_sorted = {
             let mut smart_triple_sorted = smart_triple
-                .clone()
                 .into_iter()
                 .map(|(name, val, bdd)| (format!("{}-{}", name, val), bdd))
                 .collect::<Vec<_>>();
@@ -2258,7 +2257,6 @@ mod tests {
 
         let force_triple_sorted = {
             let mut force_triple_sorted = force_triple
-                .clone()
                 .into_iter()
                 .map(|(name, val, bdd)| (format!("{}-{}", name, val), bdd))
                 .collect::<Vec<_>>();

src/prototype/symbolic_domain.rs

@@ -450,11 +450,7 @@ impl SymbolicDomain<u8> for BinaryIntegerDomain<u8> {
             .iter()
             .enumerate()
             .fold(0, |acc, (idx, var)| {
-                let bit = if bdd_valuation.get_value(*var).unwrap() {
-                    1
-                } else {
-                    0
-                };
+                let bit = u8::from(bdd_valuation.get_value(*var).unwrap());
 
                 acc | (bit << idx)
             });
@@ -561,11 +557,7 @@ impl SymbolicDomain<u8> for GrayCodeIntegerDomain<u8> {
             .iter()
             .enumerate()
             .fold(0, |acc, (idx, var)| {
-                let bit = if bdd_valuation.get_value(*var).unwrap() {
-                    1
-                } else {
-                    0
-                };
+                let bit = u8::from(bdd_valuation.get_value(*var).unwrap());
 
                 acc | (bit << idx)
             });

src/prototype/system_update_fn.rs

@@ -187,7 +187,7 @@ impl<D: SymbolicDomain<u8>> SystemUpdateFn<D, u8> {
         let unnormalized_res = domain
             .get_all_possible_values(&self.bdd_variable_set)
             .into_iter()
-            .fold(const_false.clone(), |acc, possible_var_val| {
+            .fold(const_false, |acc, possible_var_val| {
                 let bits_of_the_encoded_value = domain.encode_bits_into_vec(possible_var_val);
 
                 // println!("{:?}", bits_of_the_encoded_value);
@@ -430,13 +430,11 @@ impl<D: SymbolicDomain<u8>> SystemUpdateFn<D, u8> {
                         .collect::<Vec<_>>();
 
                     // must order the bit-answering bdds the way the variables are ordered in the domain
-                    let correctly_ordered_bit_answered_bdds = vars_and_their_bits
-                        .iter()
-                        .map(|(bdd_variable, _)| {
+                    let correctly_ordered_bit_answered_bdds =
+                        vars_and_their_bits.iter().map(|(bdd_variable, _)| {
                             vars_and_their_updating_bdds.get(bdd_variable).unwrap()
                             // todo here
-                        })
-                        .collect::<Vec<_>>();
+                        });
 
                     // todo abstract the function `set_of_those_states_that_transition_to_specific_value_of_specific_variable`
                     // let those_transitioning_to_target =
@@ -517,7 +515,6 @@ impl<D: SymbolicDomain<u8>> SystemUpdateFn<D, u8> {
             sym_dom.get_all_possible_values(&self.bdd_variable_set);
 
         let all_possible_values_and_their_bits = all_possible_values_of_target_var
-            .clone()
             .into_iter()
             .map(|val| (val, sym_dom.encode_bits_into_vec(val)))
             .collect::<Vec<_>>();
@@ -628,7 +625,7 @@ impl<D: SymbolicDomain<u8>> SystemUpdateFn<D, u8> {
         sym_dom
             .get_all_possible_values(&self.bdd_variable_set)
             .into_iter()
-            .fold(const_false.clone(), |_acc, one_of_possible_values| {
+            .fold(const_false, |_acc, one_of_possible_values| {
                 let bits = sym_dom.encode_bits_into_vec(one_of_possible_values);
                 let target_set_of_states_with_known_value_of_target_var = target_set_of_states
                     .select(

src/prototype/utils.rs

@@ -358,12 +358,12 @@ impl<BR: BufRead> XmlReader<BR> for DebuggingReader<BR> {
 
                         if self.expecting_variable_value {
                             self.expecting_variable_value = false;
-                            let actual_value = content.clone().trim().parse::<u8>().unwrap_or_else(
-                                |_| panic!(
-                                            "currently only allowing DebugReader parse u8 values; got {}",
-                                            content
+                            let actual_value = content.trim().parse::<u8>().unwrap_or_else(|_| {
+                                panic!(
+                                    "currently only allowing DebugReader parse u8 values; got {}",
+                                    content
                                 )
-                            );
+                            });
 
                             let associated_max_value = self.vars_and_their_max_values.get(
                                 &self
@@ -427,7 +427,7 @@ impl<BR: BufRead> XmlReader<BR> for CountingReader<BR> {
     fn next(&mut self) -> Result<XmlEvent, String> {
         match self.xml.next() {
             Ok(e) => {
-                match e.clone() {
+                match e {
                     XmlEvent::StartElement { .. } => {
                         self.curr_line += 1;
                     }

src/symbolic_domains/symbolic_domain.rs

@@ -411,14 +411,11 @@ impl SymbolicDomain<u8> for BinaryIntegerDomain<u8> {
             .iter()
             .enumerate()
             .fold(0, |acc, (idx, var)| {
-                let bit = if bdd_valuation
-                    .get_value(*var)
-                    .expect("bits of the value should be in the valuation")
-                {
-                    1
-                } else {
-                    0
-                };
+                let bit = u8::from(
+                    bdd_valuation
+                        .get_value(*var)
+                        .expect("bits of the value should be in the valuation"),
+                );
 
                 acc | (bit << idx)
             });
@@ -536,14 +533,11 @@ impl SymbolicDomain<u8> for GrayCodeIntegerDomain<u8> {
             .iter()
             .enumerate()
             .fold(0, |acc, (idx, var)| {
-                let bit = if bdd_valuation
-                    .get_value(*var)
-                    .expect("bits of the value should be in the valuation")
-                {
-                    1
-                } else {
-                    0
-                };
+                let bit = u8::from(
+                    bdd_valuation
+                        .get_value(*var)
+                        .expect("bits of the value should be in the valuation"),
+                );
 
                 acc | (bit << idx)
             });

src/xml_parsing/utils.rs

@@ -121,11 +121,7 @@ where
                 namespace,
             } => {
                 return if name.local_name == expected {
-                    Ok(StartElementWrapper::new(
-                        name,
-                        attributes,
-                        namespace.clone(),
-                    ))
+                    Ok(StartElementWrapper::new(name, attributes, namespace))
                 } else {
                     Err(XmlReadingError::UnexpectedEvent {
                         expected: ExpectedXmlEvent::Start(expected.to_string()),

src/xml_parsing/variable_update_fn_parser.rs

@@ -98,9 +98,7 @@ fn process_input_var_name_item<XR: XmlReader<BR>, BR: BufRead>(
 
     let item = qualitative_species
         .next()
-        .ok_or(XmlReadingError::NoSuchAttribute(
-            "qualitativeSpecies".to_string(),
-        ))?; // todo
+        .ok_or_else(|| XmlReadingError::NoSuchAttribute("qualitativeSpecies".to_string()))?; // todo
 
     expect_closure_of(xml, "input")?;
 
@@ -176,7 +174,7 @@ fn result_level_from_attributes<T: FromStr>(
         .attributes
         .iter()
         .find(|attr_name| attr_name.name.local_name == "resultLevel")
-        .ok_or(XmlReadingError::NoSuchAttribute("resultLevel".to_string()))?;
+        .ok_or_else(|| XmlReadingError::NoSuchAttribute("resultLevel".to_string()))?;
 
     attribute_with_result_lvl
         .value