Only cache some function results

Some functions evaluate more quickly without caching than with caching,
because they use data that is cached in a separate read-only cache
that's faster to check, and don't do anything complex with that data.

src/function/eval.rs

@@ -193,11 +193,13 @@ fn evaluate_version(
 
 impl Function {
     pub fn eval(&self, state: &State) -> Result<bool, Error> {
+        if self.is_slow() {
             if let Ok(reader) = state.condition_cache.read() {
                 if let Some(cached_result) = reader.get(self) {
                     return Ok(*cached_result);
                 }
             }
+        }
 
         let result = match *self {
             Function::FilePath(ref f) => evaluate_file_path(state, f),
@@ -210,14 +212,27 @@ impl Function {
             Function::Version(ref p, ref v, ref c) => evaluate_version(state, p, v, *c),
         };
 
+        if self.is_slow() {
             if let Ok(function_result) = result {
                 if let Ok(mut writer) = state.condition_cache.write() {
                     writer.insert(self.clone(), function_result);
                 }
             }
+        }
 
         result
     }
+
+    /// Some functions are faster to evaluate than to look their result up in
+    /// the cache, as the data they operate on are already cached separately and
+    /// the operation is simple.
+    fn is_slow(&self) -> bool {
+        use Function::*;
+        match self {
+            ActivePath(_) | ActiveRegex(_) | ManyActive(_) | Checksum(_, _) => false,
+            _ => true,
+        }
+    }
 }
 
 #[cfg(test)]