feat: Use stack-allocated trait object

src/io.rs

@@ -8,12 +8,13 @@ use std::{
 pub fn get_buffer(path: &Path) -> BufReader<File> {
     return match File::open(&path) {
         Ok(file) => BufReader::new(file),
-        Err(e) => panic!("Cannot open file '{:?}': '{}'.", path, e),
+        Err(e) => panic!("Cannot open file '{path:?}': '{e}'."),
     };
 }
 
 // Parse RDF triples.
-pub fn parse_ntriples(reader: Box<dyn BufRead>) -> NTriplesParser<Box<dyn BufRead>> {
+// This function takes ownership of a generic type which implements `BufRead`.
+pub fn parse_ntriples(reader: impl BufRead) -> NTriplesParser<impl BufRead> {
     return NTriplesParser::new(reader);
 }
 

src/pass_second.rs

@@ -21,10 +21,15 @@ fn process_triple(triple: &Triple) -> Result<(), TurtleError> {
 
 pub fn encrypt(log: &Logger, input: &Path, output: &Path, type_map_file: &Path) {
     // Construct the buffer either from `stdio` or from an input file.
-    // This object is constructed on the heap: `Box` and is a `trait object` (a dynamic dispatch)
-    let buffer: Box<dyn BufRead> = match input.to_str().unwrap() {
-        "-" => Box::new(BufReader::new(std::io::stdin())),
-        _ => Box::new(io::get_buffer(input)),
+    //
+    // This object is constructed on the stack and is a `trait object`.
+    // The wide-pointer `buffer` will have a pointer to the vtable
+    // and pointer to data on the stack.
+    // Normally that would be done with `Box::new(std::io::stdin())` on the heap, but since the
+    // newest version in Rust that also works on the stack (life-time extensions).
+    let buffer: &mut dyn BufRead = match input.to_str().unwrap() {
+        "-" => &mut BufReader::new(std::io::stdin()),
+        _ => &mut io::get_buffer(input),
     };
 
     let mut triples = io::parse_ntriples(buffer);