src/Tools/cache_io.ML

 type result = {
   output: string list,
   redirected_output: string list,
   return_code: int}
 
+val read_lines = Bytes.read #> Bytes.trim_split_lines
+
 fun raw_run make_cmd str in_path out_path =
   let
     val _ = File.write in_path str
     val (out2, rc) = Isabelle_System.bash_output (make_cmd in_path out_path)
-    val out1 = the_default [] (try (rev o File.fold_lines cons out_path) [])
+    val out1 = the_default [] (try read_lines out_path)
   in {output = split_lines out2, redirected_output = out1, return_code = rc} end
 
 fun run make_cmd str =
   Isabelle_System.with_tmp_file cache_io_prefix "" (fn in_path =>
     Isabelle_System.with_tmp_file cache_io_prefix "" (fn out_path =>

             if i = l
             then
               let val (key, l1, l2) = split line
               in ((i+1, l+l1+l2+1), Symtab.update (key, (i+1, l1, l2)) tab) end
             else ((i+1, l), tab)
-        in apfst fst (File.fold_lines parse cache_path ((1, 1), Symtab.empty)) end
+        in apfst fst (fold parse (read_lines cache_path) ((1, 1), Symtab.empty)) end
       else (1, Symtab.empty)
   in Cache {path = cache_path, table = Synchronized.var "Cache_IO" table} end
 
 fun lookup (Cache {path = cache_path, table}) str =
   let val key = SHA1.rep (SHA1.digest str)

               if i < p then (i+1, xsp)
               else if i < p + len1 then (i+1, apfst (cons line) xsp)
               else if i < p + len2 then (i+1, apsnd (cons line) xsp)
               else (i, xsp)
             val (out, err) =
-              apply2 rev (snd (File.fold_lines load cache_path (1, ([], []))))
+              apply2 rev (snd (fold load (read_lines cache_path) (1, ([], []))))
           in ((SOME {output = err, redirected_output = out, return_code = 0}, key), tab) end))
   end
 
 fun run_and_cache (Cache {path = cache_path, table}) key make_cmd str =
   let