get the api closer to what it was befor

benches/huge-car.rs

···
     let reader = tokio::fs::File::open(filename).await.unwrap();
     let reader = tokio::io::BufReader::new(reader);
 
-    let mut driver = match Driver::load_car(reader, ser, 1024).await.unwrap().unwrap() {
-        Driver::Memory(_, mem_driver) => mem_driver,
+    let mut driver = match Driver::load_car(reader, ser, 1024).await.unwrap() {
+        Driver::Memory(_, Some(mem_driver)) => mem_driver,
+        Driver::Memory(_, None) => panic!("car was empty"),
         Driver::Disk(_) => panic!("not doing disk for benchmark"),
     };
 

benches/non-huge-cars.rs

···
 
 async fn drive_car(bytes: &[u8]) -> usize {
     let mut driver = match Driver::load_car(bytes, ser, 32).await.unwrap() {
-        None => return 0,
-        Some(Driver::Memory(_, mem_driver)) => mem_driver,
-        Some(Driver::Disk(_)) => panic!("not benching big cars here"),
+        Driver::Memory(_, Some(mem_driver)) => mem_driver,
+        Driver::Memory(_, None) => return 0,
+        Driver::Disk(_) => panic!("not benching big cars here"),
     };
 
     let mut n = 0;

examples/disk-read-file/main.rs

···
         .load_car(reader)
         .await?
     {
-        None => panic!("empty mst! try a bigger car"),
-        Some(Driver::Memory(_, _)) => panic!("try this on a bigger car"),
-        Some(Driver::Disk(big_stuff)) => {
+        Driver::Memory(_, _) => panic!("try this on a bigger car"),
+        Driver::Disk(big_stuff) => {
             // we reach here if the repo was too big and needs to be spilled to
             // disk to continue
 

examples/read-file/main.rs

···
     let reader = tokio::fs::File::open(file).await?;
     let reader = tokio::io::BufReader::new(reader);
 
-    let (commit, mut driver) = match DriverBuilder::new()
+    let (commit, driver) = match DriverBuilder::new()
         .with_block_processor(|block| block.len().to_ne_bytes().to_vec())
         .load_car(reader)
         .await?
     {
-        None => todo!(),
-        Some(Driver::Memory(commit, mem_driver)) => (commit, mem_driver),
-        Some(Driver::Disk(_)) => panic!("this example doesn't handle big CARs"),
+        Driver::Memory(commit, mem_driver) => (commit, mem_driver),
+        Driver::Disk(_) => panic!("this example doesn't handle big CARs"),
     };
 
     log::info!("got commit: {commit:?}");
 
     let mut n = 0;
-    while let Some(pairs) = driver.next_chunk(256).await? {
-        n += pairs.len();
-        // log::info!("got {rkey:?}");
+    if let Some(mut driver) = driver {
+        while let Some(pairs) = driver.next_chunk(256).await? {
+            n += pairs.len();
+            // log::info!("got {rkey:?}");
+        }
     }
     log::info!("bye! total records={n}");
 

src/drive.rs

···
     ///
     /// You probably want to check the commit's signature. You can go ahead and
     /// walk the MST right away.
-    Memory(Commit, MemDriver),
+    Memory(Commit, Option<MemDriver>),
     /// Blocks exceed the memory limit
     ///
     /// You'll need to provide a disk storage to continue. The commit will be
···
         }
     }
     /// Begin processing an atproto MST from a CAR file
-    pub async fn load_car<R: AsyncRead + Unpin>(
-        &self,
-        reader: R,
-    ) -> Result<Option<Driver<R>>, DriveError> {
+    pub async fn load_car<R: AsyncRead + Unpin>(&self, reader: R) -> Result<Driver<R>, DriveError> {
         Driver::load_car(reader, noop, self.mem_limit_mb).await
     }
 }
···
         self
     }
     /// Begin processing an atproto MST from a CAR file
-    pub async fn load_car<R: AsyncRead + Unpin>(
-        &self,
-        reader: R,
-    ) -> Result<Option<Driver<R>>, DriveError> {
+    pub async fn load_car<R: AsyncRead + Unpin>(&self, reader: R) -> Result<Driver<R>, DriveError> {
         Driver::load_car(reader, self.block_processor, self.mem_limit_mb).await
     }
 }
···
         reader: R,
         process: fn(Bytes) -> Bytes,
         mem_limit_mb: usize,
-    ) -> Result<Option<Driver<R>>, DriveError> {
+    ) -> Result<Driver<R>, DriveError> {
         let max_size = mem_limit_mb * 2_usize.pow(20);
         let mut mem_blocks = HashMap::new();
 
···
             mem_size += maybe_processed.len();
             mem_blocks.insert(cid, maybe_processed);
             if mem_size >= max_size {
-                return Ok(Some(Driver::Disk(NeedDisk {
+                return Ok(Driver::Disk(NeedDisk {
                     car,
                     root,
                     process,
                     max_size,
                     mem_blocks,
                     commit,
-                })));
+                }));
             }
         }
 
···
         };
         let Some(walker) = Walker::new(root_node) else {
             // TODO: actually we still want the commit in this case
-            return Ok(None);
+            return Ok(Driver::Memory(commit, None));
         };
 
-        Ok(Some(Driver::Memory(
+        Ok(Driver::Memory(
             commit,
-            MemDriver {
+            Some(MemDriver {
                 blocks: mem_blocks,
                 walker,
                 process,
-            },
-        )))
+            }),
+        ))
     }
 }