main fn and complete

Author: AndyGauge

src/data_structures/bitfield/bitfield.md

@@ -12,26 +12,27 @@ use bitflags::bitflags;
 use std::fmt;
 
 bitflags! {
+    #[derive(PartialEq, Debug, Copy, Clone)]
     struct MyFlags: u32 {
         const FLAG_A       = 0b00000001;
         const FLAG_B       = 0b00000010;
         const FLAG_C       = 0b00000100;
-        const FLAG_ABC     = Self::FLAG_A.bits
-                           | Self::FLAG_B.bits
-                           | Self::FLAG_C.bits;
+        const FLAG_ABC     = Self::FLAG_A.bits()
+                           | Self::FLAG_B.bits()
+                           | Self::FLAG_C.bits();
     }
 }
 
 impl MyFlags {
     pub fn clear(&mut self) -> &mut MyFlags {
-        self.bits = 0;  
+        *self = MyFlags::empty();
         self
     }
 }
 
 impl fmt::Display for MyFlags {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{:032b}", self.bits)
+        write!(f, "{:032b}", self.bits())
     }
 }
 
@@ -46,10 +47,6 @@ fn main() {
     let mut flags = MyFlags::FLAG_ABC;
     assert_eq!(format!("{}", flags), "00000000000000000000000000000111");
     assert_eq!(format!("{}", flags.clear()), "00000000000000000000000000000000");
-    assert_eq!(format!("{:?}", MyFlags::FLAG_B), "FLAG_B");
-    assert_eq!(format!("{:?}", MyFlags::FLAG_A | MyFlags::FLAG_B), "FLAG_A | FLAG_B");
+    assert_eq!(format!("{:?}", MyFlags::FLAG_B), "MyFlags(FLAG_B)");
+    assert_eq!(format!("{:?}", MyFlags::FLAG_A | MyFlags::FLAG_B), "MyFlags(FLAG_A | FLAG_B)");
 }
-```
-
-[`bitflags!`]: https://docs.rs/bitflags/*/bitflags/macro.bitflags.html
-[`Display`]: https://doc.rust-lang.org/std/fmt/trait.Display.html

src/encoding/csv/transform.md

@@ -6,7 +6,7 @@ Transform a CSV file containing a color name and a hex color into one with a
 color name and an rgb color.  Utilizes the [csv] crate to read and write the
 csv file, and [serde] to deserialize and serialize the rows to and from bytes.
 
-See [`csv::Reader::deserialize`], [`serde::Deserialize`], and [`std::str::FromStr`]
+See [csv::Reader::deserialize], [serde::Deserialize], and [std::str::FromStr]
 
 ```rust,edition2018
 extern crate csv;
@@ -82,7 +82,7 @@ magenta,#ff00ff"
     Ok(())
 }
 
-[`csv::Reader::deserialize`]: https://docs.rs/csv/\*/csv/struct.Reader.html#method.deserialize
-[`csv::invalid_option`]: https://docs.rs/csv/*/csv/fn.invalid_option.html
-[`serde::Deserialize`]: https://docs.rs/serde/\*/serde/trait.Deserialize.html
-[`std::str::FromStr`]: https://doc.rust-lang.org/std/str/trait.FromStr.html
+[csv::Reader::deserialize]: https://docs.rs/csv/*/csv/struct.Reader.html#method.deserialize
+[csv::invalid_option]: https://docs.rs/csv/*/csv/fn.invalid_option.html
+[serde::Deserialize]: https://docs.rs/serde/*/serde/trait.Deserialize.html
+[std::str::FromStr]: https://doc.rust-lang.org/std/str/trait.FromStr.html

src/errors/handle/main.md

@@ -10,8 +10,14 @@ As recommended in Rust by Example, [`Box`ing errors] is seen as an easy
 strategy for getting started.
 
 ```rust,edition2018
-Box<dyn Error>
-````
+use std::error::Error;
+
+fn main() -> Result<(), Box<dyn Error>> {
+    // Example of boxing errors
+    let result: Result<(), Box<dyn Error>> = Ok(());
+    result
+}
+```
 
 To understand what kind of error handling may be required study [Designing 
 error types in Rust] and consider [`thiserror`] for libraries or [`anyhow`] as 
@@ -26,6 +32,11 @@ pub enum MultiError {
   #[error("🦀 got {0}")]
   ErrorClass(String),
 }
+
+fn main() -> Result<(), MultiError> {
+    // Example of using thiserror
+    Err(MultiError::ErrorClass("example error".to_string()))
+}
 ```
 
 Application authors can compose enums using `anyhow` can import the `Result`

src/file/dir/loops.md

@@ -10,7 +10,7 @@ ln -s /tmp/foo/  /tmp/foo/bar/baz/qux
 ```
 The following would assert that a loop exists.
 
-```rust,edition2018
+```rust,edition2018,no_run
 extern crate walkdir;
 extern crate same_file;
 use walkdir::WalkDir;

src/file/dir/recursive.md

@@ -1,3 +1,14 @@
 ```rust,edition2018
 extern crate walkdir;
-use walkdir::WalkDir; 
+use walkdir::WalkDir;
+
+fn main() {
+    // Example of using WalkDir to recursively traverse directories
+    for entry in WalkDir::new(".").max_depth(2) {
+        match entry {
+            Ok(entry) => println!("{}", entry.path().display()),
+            Err(e) => eprintln!("Error: {}", e),
+        }
+    }
+}
+``` 

src/file/read-write/same-file.md

@@ -6,7 +6,7 @@ Use [`same_file::Handle`] to a file that can be tested for equality with
 other handles. In this example, the handles of file to be read from and
 to be written to are tested for equality.
 
-```rust,edition2018
+```rust,edition2018,no_run
 extern crate same_file;
 use same_file::{is_same_file, Handle};
 use std::fs::File;

src/file/read/read_lines.md

@@ -3,4 +3,22 @@ extern crate tempfile;
 use std::fs::File;
 use std::io::{self, BufRead, BufReader, Write};
 use tempfile::NamedTempFile;
+
+fn main() -> io::Result<()> {
+    // Create a temporary file with some content
+    let mut temp_file = NamedTempFile::new()?;
+    writeln!(temp_file, "Line 1")?;
+    writeln!(temp_file, "Line 2")?;
+    writeln!(temp_file, "Line 3")?;
+    
+    // Read lines from the file
+    let file = File::open(temp_file.path())?;
+    let reader = BufReader::new(file);
+    
+    for (index, line) in reader.lines().enumerate() {
+        println!("Line {}: {}", index + 1, line?);
+    }
+    
+    Ok(())
+}
 ```