ALT Sleepy blank and white cat curled up on the top edge of the couch. His eyes are closed and his legs are crossed

ALT struct Person { name: String, age: u32 } impl std::fmt::Display for Person { fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { write!(f, "{} ({} years old)", self.name, self.age) } } fn main() { let person = Person { name: "Alice".to_string(), age: 30 }; println!("{}", person); // Output: Alice (30 years old) }

ALT println!("Size of i32: {}", std::mem::size_of::<i32>()); //output: Size of i32: 4 println!("Size of i64: {}", std::mem::size_of::<i64>()); //output: Size of i64: 8 println!("Size of String: {}", std::mem::size_of::<String>()); //output: Size of String: 24

ALT let mut vec = Vec::with_capacity(10); for i in 0..10 { vec.push(i); }

ALT #[cfg(test)] mod tests { use std::thread; use std::time::Duration; #[test] fn quick_test() { assert_eq!(2 2, 4); } #[test] #[ignore] fn slow_test() { // Simulate a long-running test thread::sleep(Duration::from_secs(5)); assert!(true); } }

ALT "rust-analyzer.check.command": "clippy"

ALT macro_rules! create_function { ($func_name:ident) => { fn $func_name() { println!("You called {:?}()", stringify!($func_name)); } }; } create_function!(foo); create_function!(bar); fn main() { foo(); bar(); }

ALT // notice how all the imports are revealed! #![feature(prelude_import)] #[prelude_import] use std::prelude::rust_2021::*; #[macro_use] extern crate std; // notice how the function bodies are shown! fn foo() { { ::std::io::_print(format_args!("You called {0:?}()\n", "foo")); }; } fn bar() { { ::std::io::_print(format_args!("You called {0:?}()\n", "bar")); }; } fn main() { foo(); bar(); }

ALT "[rust]": { "editor.defaultFormatter": "rust-lang.rust-analyzer", "editor.formatOnSave": true }

ALT struct Person { name: String, age: u32, } fn main() { let person = Person { name: "rust biggest fan".to_string(), ..Default::default() }; println!("{:?}", person); // Output: Person { name: "rust biggest fan", age: 0 } }

ALT #[derive(Default, Debug)] struct Person { name: String, age: u32, } #[derive(Debug)] struct PersonWithCustomDefault { name: String, age: u32, } impl Default for PersonWithCustomDefault { fn default() -> Self { PersonWithCustomDefault { name: "Unknown".to_string(), age: 10 } } } fn main() { let person = Person::default(); println!("{:?}", person); // Output: Person { name: "", age: 0 } let person_with_custom_default = PersonWithCustomDefault::default(); println!("{:?}", person_with_custom_default); // Output: PersonWithCustomDefault { name: "Unknown", age: 10 } }

ALT struct Animal { name: String, age: u32, fav_treat: Option<String> } fn print_treat(animal: Animal) { // println!("{} loves {}", animal.name, animal.fav_treat) // This line ^^ wouldn't compile because fav_treat is an Option<String> // and can't be printed directly. Instead lets use a match statement! match &animal.fav_treat { Some(treat) => println!("{} loves {}", animal.name, treat), None => println!("{} doesn't have a favorite treat", animal.name), } }

ALT enum TrafficLight { Red, Yellow, Green, } fn get_light_action(light: TrafficLight) -> &'static str { // This match does NOT compile, the compiler says the following: //error[E0004]: non-exhaustive patterns: `TrafficLight::Yellow` not covered match light { TrafficLight::Red => "Stop", TrafficLight::Green => "Go", } }

ALT #[derive(Debug, Clone)] struct Person { name: String, age: u32, } fn main() { let alice = Person { name: "Alice".into(), age: 30 }; let mut bob = alice.clone(); bob.name = "Bob".to_string(); dbg!(alice); dbg!(bob); // Outputs: // alice = Person { name: "Alice", age: 30 } // bob = Person { name: "Bob", age: 30 } }

ALT Screenshot of requests to a new domain for lots of random prefixes, likely by automated bots scanning the certificate transparency logs. Some of the paths include `.DS_Store` `.env` `.git/config` and `/_all_dbs`