Upload checkpoint-8000 evaluation samples
Browse files
checkpoint-8000/samples.jsonl
ADDED
|
@@ -0,0 +1,77 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
{"prompt": "Write only a single Rust source file (main.rs) with a `fn main() -> anyhow::Result<()>` that demonstrates basic anyhow error handling. Do not explain; output only Rust code wrapped in ```rust code blocks.", "gen": "use anyhow::Result;\n\nfn main() -> Result<()> {\n let val = std::fs::File::open(\"nonexistant\")?;\n println!(\"{}\", val.metadata().unwrap().modified().unwrap());\n Ok(())\n}"}
|
| 2 |
+
{"prompt": "Write only a single Rust source file (main.rs) with a `fn main() -> anyhow::Result<()>` that demonstrates basic anyhow error handling. Do not explain; output only Rust code wrapped in ```rust code blocks.", "gen": "use anyhow::Result;\nuse anyhow::Context;\n\nfn main() -> Result<()> {\n let foo = \"bar\";\n let baz = \"qux\";\n let err: Result<String, _> = Err(\"whoops\".into());\n match err {\n Ok(_) => Ok(()),\n Err(e) => Err(e.with_context(|| format!(\"my error message: {}\", foo))),\n }\n}"}
|
| 3 |
+
{"prompt": "Write only a single Rust source file (main.rs) with a `fn main() -> anyhow::Result<()>` that demonstrates basic anyhow error handling. Do not explain; output only Rust code wrapped in ```rust code blocks.", "gen": "use anyhow::Result;\nuse anyhow::anyhow;\n\nfn main() -> Result<()> {\n let x = 1;\n let y = 0;\n if x == y {\n return Err(anyhow!(\"x == y\"));\n }\n println!(\"x!= y\");\n Ok(())\n}"}
|
| 4 |
+
{"prompt": "Write only a single Rust source file (main.rs) with a `fn main() -> anyhow::Result<()>` that demonstrates basic anyhow error handling. Do not explain; output only Rust code wrapped in ```rust code blocks.", "gen": "use anyhow::{anyhow, bail, Context, Result};\n\nfn main() -> anyhow::Result<()> {\n let result = Ok::<_, anyhow::Error>(42);\n\n // Test a successful result\n assert_eq!(result, Ok(42));\n println!(\"Test a successful result: {}\", result);\n\n // Test a failing result\n let result = Err::<(), anyhow::Error>(anyhow!(\"test error\"));\n assert_eq!(result, Err(anyhow!(\"test error\")));\n println!(\"Test a failing result: {}\", result);\n\n // Test a failed conversion\n let result: Result<(), anyhow::Error> = Ok(()).context(\"test error\");\n assert_eq!(result, Ok(()));\n println!(\"Test a failed conversion: {}\", result);\n\n // Test a failed conversion with a custom error message\n let result: Result<(), anyhow::Error> = Ok(()).context(\"test error: {}\", \"test\");\n assert_eq!(result, Ok(()));\n println!(\"Test a failed conversion with a custom error message: {}\", result);\n\n // Test a failed conversion with a custom error message and a custom error type\n let result: Result<(), anyhow::Error> = Ok(()).context(anyhow!(\"test error\"));\n assert_eq!(result, Ok(()));\n println!(\"Test a failed conversion with a custom error message and a custom error type: {}\", result);\n\n // Test a failing result with a custom error\n let result = Err::<(), anyhow::Error>(anyhow!(\"test error\"));\n assert_eq!(result, Err(anyhow!(\"test error\")));\n println!(\"Test a failing result with a custom error: {}\", result);\n\n // Test a failing result with a custom error and a custom error type\n let result = Err::<(), anyhow::Error>(anyhow!(\"test error\"));\n assert_eq!(result, Err(anyhow!(\"test error\")));\n println!(\"Test a failing result with a custom error and a custom error type: {}\", result);\n\n Ok(())\n}"}
|
| 5 |
+
{"prompt": "Write only a single Rust source file (main.rs) with a `fn main() -> anyhow::Result<()>` that demonstrates basic anyhow error handling. Do not explain; output only Rust code wrapped in ```rust code blocks.", "gen": "use anyhow::Result;\n\nfn main() -> Result<()> {\n let s = \"test\";\n let b = \"test\".to_string();\n let x = Some(\"test\");\n\n Ok(())\n}"}
|
| 6 |
+
{"prompt": "Write only a single Rust source file (main.rs) with a `fn main() -> anyhow::Result<()>` that demonstrates basic anyhow error handling. Do not explain; output only Rust code wrapped in ```rust code blocks.", "gen": "use anyhow::{anyhow, bail, Context, Result};\n\nfn main() -> anyhow::Result<()> {\n let x = 3 + 5;\n let y = 3 * 5;\n\n if x < y {\n Ok(())\n } else {\n Err(anyhow!(\"x is not less than y\"))\n }\n}"}
|
| 7 |
+
{"prompt": "Write only a single Rust source file (main.rs) with a `fn main() -> anyhow::Result<()>` that demonstrates basic anyhow error handling. Do not explain; output only Rust code wrapped in ```rust code blocks.", "gen": "use anyhow::anyhow;\nuse anyhow::Context;\n\nfn main() -> anyhow::Result<()> {\n let result = \"not a number\".parse::<i32>();\n let result = result.with_context(|| \"Failed to parse value\");\n match result {\n Ok(_) => Ok(()),\n Err(e) => Err(e),\n }\n}"}
|
| 8 |
+
{"prompt": "Write only Rust code for a program that uses iterators with map/filter to compute a sum. Include `fn main()` and necessary imports. No explanations. Wrap code in ```rust code blocks.", "gen": "fn main() {\n let mut numbers: Vec<u32> = vec![2, 4, 6, 8, 10];\n let total = numbers.iter().filter(|x| *x % 2 == 0).map(|x| x * x).sum();\n println!(\"The sum of the even squares is: {}\", total);\n}"}
|
| 9 |
+
{"prompt": "Write only Rust code for a program that uses iterators with map/filter to compute a sum. Include `fn main()` and necessary imports. No explanations. Wrap code in ```rust code blocks.", "gen": "use std::collections::HashMap;\n\nfn main() {\n let mut map = HashMap::new();\n map.insert(1, 1);\n map.insert(2, 2);\n map.insert(3, 3);\n map.insert(4, 4);\n\n let sum: u32 = map.iter().filter(|&(_, v)| v % 2 == 0).map(|&(_, v)| v).sum();\n\n println!(\"{}\", sum);\n}"}
|
| 10 |
+
{"prompt": "Write only Rust code for a program that uses iterators with map/filter to compute a sum. Include `fn main()` and necessary imports. No explanations. Wrap code in ```rust code blocks.", "gen": "use std::fs::File;\nuse std::io::{self, BufRead};\n\nfn main() -> io::Result<()> {\n let file = File::open(\"file.txt\")?;\n let lines = io::BufReader::new(file).lines();\n\n let numbers: Vec<i32> = lines\n .filter_map(|x| x.ok().and_then(|line| line.parse().ok()))\n .map(|x| x * 2)\n .collect();\n\n println!(\"{}\", numbers.iter().sum::<i32>());\n\n Ok(())\n}"}
|
| 11 |
+
{"prompt": "Write only Rust code for a program that uses iterators with map/filter to compute a sum. Include `fn main()` and necessary imports. No explanations. Wrap code in ```rust code blocks.", "gen": "use std::iter;\nuse std::ops::Mul;\n\nfn main() {\n let mut sum = 0;\n for i in 0..100 {\n if i % 3 == 0 || i % 5 == 0 {\n sum += i;\n }\n }\n\n println!(\"{}\", sum);\n\n let sum = iter::range(0, 100).filter(|&x| x % 3 == 0 || x % 5 == 0).sum::<i32>();\n println!(\"{}\", sum);\n}"}
|
| 12 |
+
{"prompt": "Write only Rust code for a program that uses iterators with map/filter to compute a sum. Include `fn main()` and necessary imports. No explanations. Wrap code in ```rust code blocks.", "gen": "use std::collections::HashMap;\nuse std::collections::BTreeMap;\nuse std::collections::HashSet;\nuse std::collections::VecDeque;\nuse std::fs;\nuse std::path::Path;\nuse std::process::Command;\nuse std::thread;\nuse std::time::Duration;"}
|
| 13 |
+
{"prompt": "Write only Rust code for a program that uses iterators with map/filter to compute a sum. Include `fn main()` and necessary imports. No explanations. Wrap code in ```rust code blocks.", "gen": "use std::iter;\nuse std::collections::HashMap;\n\nfn main() {\n let map = vec![1, 2, 3, 4, 5];\n let result: u32 = iter::once(0).chain(map.into_iter())\n .map(|x| x * x)\n .filter(|x| x % 2 == 0)\n .sum();\n println!(\"Sum: {}\", result);\n}"}
|
| 14 |
+
{"prompt": "Write only Rust code for a program that uses iterators with map/filter to compute a sum. Include `fn main()` and necessary imports. No explanations. Wrap code in ```rust code blocks.", "gen": "use std::fs;\n\nfn main() {\n let file = \"numbers.txt\";\n let file = fs::read_to_string(file)\n .expect(\"Could not read file\");\n let numbers: Vec<i32> = file.lines()\n .map(|line| line.trim())\n .filter(|line|!line.is_empty())\n .map(|line| line.parse().unwrap())\n .collect();\n let sum: i32 = numbers.iter().sum();\n println!(\"Sum: {}\", sum);\n}"}
|
| 15 |
+
{"prompt": "Define a newtype wrapper for [u8; 32] and implement FromStr and Display. Provide a small `fn main()` that parses and prints it. Output only Rust code in ```rust code blocks.", "gen": "struct U32Array([u8; 32]);\n\nimpl FromStr for U32Array {\n type Err = std::num::ParseIntError;\n fn from_str(s: &str) -> Result<Self, Self::Err> {\n if s.len()!= 64 {\n return Err(std::num::ParseIntError::new(\"invalid length\", s));\n }\n let mut arr = [0u8; 32];\n for (i, c) in s.chars().enumerate() {\n let d = c.to_digit(16).ok_or_else(|| std::num::ParseIntError::new(\"invalid char\", s))?;\n arr[i / 2] = d as u8;\n if i % 2 == 1 {\n arr[i / 2] <<= 4;\n }\n }\n Ok(U32Array(arr))\n }\n}\n\nimpl std::fmt::Display for U32Array {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n let mut s = String::with_capacity(64);\n for (i, byte) in self.0.iter().enumerate() {\n s.push_str(&format!(\"{:02x}\", byte));\n if i % 2 == 1 {\n s.push(' ');\n }\n }\n write!(f, \"{}\", s)\n }\n}\n\nfn main() {\n let u = U32Array::from_str(\"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00\").unwrap();\n println!(\"{}\", u);\n}"}
|
| 16 |
+
{"prompt": "Define a newtype wrapper for [u8; 32] and implement FromStr and Display. Provide a small `fn main()` that parses and prints it. Output only Rust code in ```rust code blocks.", "gen": "pub struct Uint32(pub [u8; 32]);\n\nimpl FromStr for Uint32 {\n type Err = std::num::ParseIntError;\n\n fn from_str(s: &str) -> Result<Self, Self::Err> {\n let mut out = [0u8; 32];\n let bytes = s.as_bytes();\n if bytes.len()!= 32 {\n return Err(std::num::ParseIntError);\n }\n for i in 0..32 {\n out[31 - i] = bytes[i];\n }\n Ok(Self(out))\n }\n}\n\nimpl std::fmt::Display for Uint32 {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n for i in 0..32 {\n write!(f, \"{}\", self.0[i])\n }\n }\n}\n\nfn main() {\n let a: Uint32 = \"1234567890abcdef\".parse().unwrap();\n println!(\"{}\", a);\n}"}
|
| 17 |
+
{"prompt": "Define a newtype wrapper for [u8; 32] and implement FromStr and Display. Provide a small `fn main()` that parses and prints it. Output only Rust code in ```rust code blocks.", "gen": "#[derive(Debug, PartialEq, Eq, Clone, Copy)]\nstruct Color([u8; 32]);\n\nimpl FromStr for Color {\n type Err = &'static str;\n\n fn from_str(s: &str) -> Result<Self, Self::Err> {\n if s.len()!= 32 {\n return Err(\"invalid length\");\n }\n let mut color = [0; 32];\n for (i, c) in s.bytes().enumerate() {\n color[i] = c as u8;\n }\n Ok(Color(color))\n }\n}\n\nimpl std::fmt::Display for Color {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n for byte in &self.0 {\n write!(f, \"{:02x}\", byte)?;\n }\n Ok(())\n }\n}\n\nfn main() {\n let color = Color::from_str(\"deadbeef\").unwrap();\n println!(\"{:?}\", color);\n println!(\"{}\", color);\n}"}
|
| 18 |
+
{"prompt": "Define a newtype wrapper for [u8; 32] and implement FromStr and Display. Provide a small `fn main()` that parses and prints it. Output only Rust code in ```rust code blocks.", "gen": "#[derive(Debug)]\nstruct U32Array([u8; 32]);\n\nimpl FromStr for U32Array {\n type Err = String;\n\n fn from_str(s: &str) -> Result<Self, Self::Err> {\n let bytes = hex::decode(s)?;\n if bytes.len()!= 32 {\n return Err(\"Length of string must be 32 characters long\".to_string());\n }\n let mut arr = [0; 32];\n for (i, byte) in arr.iter_mut().enumerate() {\n *byte = bytes[i];\n }\n Ok(U32Array(arr))\n }\n}\n\nimpl Display for U32Array {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n let bytes = hex::encode(&self.0);\n f.write_str(&bytes)\n }\n}\n\nfn main() {\n let arr = U32Array::from_str(\"00000000000000000000000000000000\").unwrap();\n println!(\"{:?}\", arr);\n}"}
|
| 19 |
+
{"prompt": "Define a newtype wrapper for [u8; 32] and implement FromStr and Display. Provide a small `fn main()` that parses and prints it. Output only Rust code in ```rust code blocks.", "gen": "struct Hash32([u8; 32]);\n\nimpl std::str::FromStr for Hash32 {\n type Err = std::num::ParseIntError;\n\n fn from_str(s: &str) -> Result<Self, Self::Err> {\n let mut bytes = [0; 32];\n let len = s.len();\n if len < 32 {\n return Err(std::num::ParseIntError::from(std::num::TryFromIntError::new(len.into(), \"u8\")));\n }\n for (i, c) in s.bytes().enumerate() {\n bytes[i] = c - b'0';\n }\n Ok(Self(bytes))\n }\n}\n\nimpl std::fmt::Display for Hash32 {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n for byte in self.0.iter() {\n write!(f, \"{:02x}\", byte)?;\n }\n Ok(())\n }\n}\n\nfn main() {\n let hash = Hash32::from_str(\"00000000000000000000000000000000\").unwrap();\n println!(\"{}\", hash);\n}"}
|
| 20 |
+
{"prompt": "Define a newtype wrapper for [u8; 32] and implement FromStr and Display. Provide a small `fn main()` that parses and prints it. Output only Rust code in ```rust code blocks.", "gen": "use std::str::FromStr;\n\n#[derive(Debug)]\npub struct U32Array(pub [u8; 32]);\n\nimpl FromStr for U32Array {\n type Err = String;\n\n fn from_str(s: &str) -> Result<Self, Self::Err> {\n if s.len()!= 32 {\n return Err(\"Expected 32 bytes\".to_string());\n }\n\n let mut bytes = [0u8; 32];\n bytes.copy_from_slice(&s.as_bytes()[0..32]);\n\n Ok(U32Array(bytes))\n }\n}\n\nimpl std::fmt::Display for U32Array {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n for (i, b) in self.0.iter().enumerate() {\n write!(f, \"{:02x}\", b)?;\n if i % 8 == 7 {\n write!(f, \" \")?;\n }\n }\n\n Ok(())\n }\n}\n\nfn main() {\n let array = U32Array::from_str(\"c0ffee\").unwrap();\n println!(\"{:?}\", array);\n println!(\"{}\", array);\n}"}
|
| 21 |
+
{"prompt": "Define a newtype wrapper for [u8; 32] and implement FromStr and Display. Provide a small `fn main()` that parses and prints it. Output only Rust code in ```rust code blocks.", "gen": "use std::fmt;\nuse std::str::FromStr;\n\n#[derive(Debug)]\nstruct U32Array([u8; 32]);\n\nimpl FromStr for U32Array {\n type Err = &'static str;\n \n fn from_str(s: &str) -> Result<Self, Self::Err> {\n if s.len()!= 32 {\n return Err(\"Invalid length\");\n }\n let mut bytes = [0u8; 32];\n for (i, c) in s.bytes().enumerate() {\n bytes[i] = c;\n }\n Ok(U32Array(bytes))\n }\n}\n\nimpl fmt::Display for U32Array {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n for byte in &self.0 {\n write!(f, \"{}\", byte as char)?;\n }\n Ok(())\n }\n}\n\nfn main() {\n let bytes = \"01010101\".parse::<U32Array>().unwrap();\n println!(\"{:?}\", bytes);\n println!(\"{}\", bytes);\n}"}
|
| 22 |
+
{"prompt": "Create a small example showing a thiserror enum, Display, a source cause, and a function using the ? operator. Include `fn main()` to drive it. Output only Rust code wrapped in ```rust code blocks.", "gen": "use std::fmt;\nuse std::error::Error;\n\n#[derive(thiserror::Error, Debug)]\nenum Error {\n #[error(\"Something went wrong: {0}\")]\n Something(String),\n #[error(\"Something else went wrong: {0}\")]\n SomethingElse(String),\n}\n\nimpl fmt::Display for Error {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n write!(f, \"{:?}\", self)\n }\n}\n\nimpl Error {\n fn source(&self) -> Option<&(dyn Error +'static)> {\n match self {\n Error::Something(_) => None,\n Error::SomethingElse(_) => None,\n }\n }\n}\n\nfn something(s: &str) -> Result<(), Error> {\n if s.is_empty() {\n return Err(Error::Something(\"s is empty\".to_string()));\n }\n Ok(())\n}\n\nfn something_else(s: &str) -> Result<(), Error> {\n if s.is_empty() {\n return Err(Error::SomethingElse(\"s is empty\".to_string()));\n }\n Ok(())\n}\n\nfn main() {\n match something(\"hello\") {\n Ok(()) => println!(\"OK\"),\n Err(e) => println!(\"Something went wrong: {}\", e),\n }\n match something(\"\") {\n Ok(()) => println!(\"OK\"),\n Err(e) => println!(\"Something went wrong: {}\", e),\n }\n match something_else(\"hello\") {\n Ok(()) => println!(\"OK\"),\n Err(e) => println!(\"Something else went wrong: {}\", e),\n }\n match something_else(\"\") {\n Ok(()) => println!(\"OK\"),\n Err(e) => println!(\"Something else went wrong: {}\", e),\n }\n}"}
|
| 23 |
+
{"prompt": "Create a small example showing a thiserror enum, Display, a source cause, and a function using the ? operator. Include `fn main()` to drive it. Output only Rust code wrapped in ```rust code blocks.", "gen": "use thiserror::Error;\nuse std::fmt;\nuse std::fmt::Display;\n\n#[derive(Debug, Error)]\npub enum MyError {\n #[error(\"The given name is too long: {0}\")]\n NameTooLong(String),\n #[error(\"A generic error\")]\n Generic,\n #[error(transparent)]\n Inner(#[from] std::io::Error),\n}\n\nimpl Display for MyError {\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n match self {\n Self::NameTooLong(s) => write!(f, \"Name is too long: {}\", s),\n Self::Generic => write!(f, \"A generic error\"),\n Self::Inner(e) => write!(f, \"An error occurred: {}\", e),\n }\n }\n}\n\nfn read_username() -> Result<String, MyError> {\n let mut name = String::new();\n\n std::io::stdin()\n .read_line(&mut name)\n .map_err(MyError::Inner)?;\n\n if name.len() > 3 {\n Err(MyError::NameTooLong(name))\n } else {\n Ok(name)\n }\n}\n\nfn main() {\n match read_username() {\n Ok(name) => println!(\"Hello, {}!\", name),\n Err(e) => println!(\"Error: {}\", e),\n }\n}"}
|
| 24 |
+
{"prompt": "Create a small example showing a thiserror enum, Display, a source cause, and a function using the ? operator. Include `fn main()` to drive it. Output only Rust code wrapped in ```rust code blocks.", "gen": "use thiserror::Error;\n\n#[derive(Error, Debug)]\npub enum MyError {\n #[error(\"out of bounds\")]\n OutOfBounds,\n #[error(\"div by zero\")]\n DivByZero,\n}\n\nimpl std::fmt::Display for MyError {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n match self {\n MyError::OutOfBounds => write!(f, \"out of bounds\"),\n MyError::DivByZero => write!(f, \"div by zero\"),\n }\n }\n}\n\nfn divide(a: i32, b: i32) -> Result<i32, MyError> {\n if b == 0 {\n return Err(MyError::DivByZero);\n }\n Ok(a / b)\n}\n\nfn main() {\n match divide(3, 0) {\n Ok(res) => println!(\"Result is: {}\", res),\n Err(err) => println!(\"Error: {}\", err),\n }\n}"}
|
| 25 |
+
{"prompt": "Create a small example showing a thiserror enum, Display, a source cause, and a function using the ? operator. Include `fn main()` to drive it. Output only Rust code wrapped in ```rust code blocks.", "gen": "#[derive(thiserror::Error, Debug, Display)]\nenum MyError {\n #[error(\"Could not read {0}\")]\n Read(#[from] std::io::Error),\n #[error(\"Could not write {0}\")]\n Write(#[from] std::io::Error),\n}\n\n#[derive(thiserror::Error, Debug)]\n#[error(\"Could not read {0}\")]\nstruct ReadError(#[source] std::io::Error);\n\nfn do_read() -> Result<u8, MyError> {\n let mut file = std::fs::File::open(\"test.txt\")?;\n let mut buffer = [0u8; 1];\n let read = file.read(&mut buffer)?;\n Ok(read)\n}\n\nfn main() {\n let result = do_read();\n match result {\n Ok(v) => println!(\"Read: {}\", v),\n Err(e) => println!(\"Error: {}\", e),\n }\n}"}
|
| 26 |
+
{"prompt": "Create a small example showing a thiserror enum, Display, a source cause, and a function using the ? operator. Include `fn main()` to drive it. Output only Rust code wrapped in ```rust code blocks.", "gen": "use thiserror::Error;\n\n#[derive(Debug, Error, Eq, PartialEq)]\npub enum Error {\n #[error(\"MyError\")]\n MyError,\n #[error(\"MyOtherError\")]\n MyOtherError,\n #[error(\"MyOtherOtherError\")]\n MyOtherOtherError,\n}\n\nimpl std::fmt::Display for Error {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n write!(f, \"{:?}\", self)\n }\n}\n\nimpl From<Error> for String {\n fn from(e: Error) -> Self {\n format!(\"{}\", e)\n }\n}\n\nfn my_function() -> Result<(), Error> {\n Err(Error::MyOtherOtherError)\n}\n\nfn main() {\n let result = my_function();\n\n if let Err(e) = result {\n println!(\"Error: {}\", e);\n } else {\n println!(\"Success!\");\n }\n}"}
|
| 27 |
+
{"prompt": "Create a small example showing a thiserror enum, Display, a source cause, and a function using the ? operator. Include `fn main()` to drive it. Output only Rust code wrapped in ```rust code blocks.", "gen": "use thiserror::Error;\n\n#[derive(Error, Debug)]\nenum ParseError {\n #[error(\"Not enough arguments\")]\n NotEnoughArguments,\n #[error(\"Invalid argument\")]\n InvalidArgument,\n #[error(\"Invalid value\")]\n InvalidValue,\n #[error(\"Invalid operation\")]\n InvalidOperation,\n}\n\nstruct Parser;\n\nimpl Parser {\n fn parse<T: std::str::FromStr>(&self, value: &str) -> Result<T, ParseError> {\n if value.is_empty() {\n return Err(ParseError::NotEnoughArguments);\n }\n\n match value.parse::<T>() {\n Ok(v) => Ok(v),\n Err(_) => Err(ParseError::InvalidArgument),\n }\n }\n}\n\nfn main() {\n let args: Vec<String> = std::env::args().collect();\n\n let arg1: i32 = Parser::parse(&args[1]).unwrap();\n\n if arg1 > 10 {\n println!(\"Too high\");\n } else if arg1 < 10 {\n println!(\"Too low\");\n } else {\n println!(\"Just right\");\n }\n}"}
|
| 28 |
+
{"prompt": "Create a small example showing a thiserror enum, Display, a source cause, and a function using the ? operator. Include `fn main()` to drive it. Output only Rust code wrapped in ```rust code blocks.", "gen": "use thiserror::Error;\n\n#[derive(Debug, Error)]\npub enum Error {\n #[error(\"Input not valid\")]\n InvalidInput,\n #[error(\"Cannot convert\")]\n CannotConvert,\n #[error(\"Io\")]\n Io(#[from] std::io::Error),\n}\n\n#[derive(Debug)]\nstruct InvalidInput;\n\nimpl std::fmt::Display for InvalidInput {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n f.write_str(\"Invalid input\")\n }\n}\n\nfn main() -> Result<(), Error> {\n let input = InvalidInput;\n let result = do_something(input)?;\n println!(\"result: {:#?}\", result);\n Ok(())\n}\n\nfn do_something(input: InvalidInput) -> Result<(), Error> {\n if input!= InvalidInput {\n return Err(Error::InvalidInput);\n }\n Ok(())\n}"}
|
| 29 |
+
{"prompt": "Write a complete Rust program with `fn main()` that demonstrates pattern matching with `match` and `if let`. Include necessary imports. Output only code in ```rust code blocks.", "gen": "use std::collections::HashMap;\n\nfn main() {\n let mut map = HashMap::new();\n map.insert(\"a\", 1);\n map.insert(\"b\", 2);\n map.insert(\"c\", 3);\n\n // Pattern matching with `match`\n match map.get(&\"a\") {\n Some(&x) => println!(\"The value is {}\", x),\n None => println!(\"Key not found\"),\n }\n\n // Pattern matching with `if let`\n if let Some(&x) = map.get(&\"a\") {\n println!(\"The value is {}\", x);\n } else {\n println!(\"Key not found\");\n }\n\n // Pattern matching with `match` and `if let` on multiple items\n match map.get(&\"b\") {\n Some(&x) if x == 2 => println!(\"The value is {}\", x),\n Some(&x) => println!(\"The value is {}\", x),\n None => println!(\"Key not found\"),\n }\n\n if let Some(&x) = map.get(&\"b\") {\n if x == 2 {\n println!(\"The value is {}\", x);\n } else {\n println!(\"The value is {}\", x);\n }\n } else {\n println!(\"Key not found\");\n }\n}"}
|
| 30 |
+
{"prompt": "Write a complete Rust program with `fn main()` that demonstrates pattern matching with `match` and `if let`. Include necessary imports. Output only code in ```rust code blocks.", "gen": "use std::collections::HashMap;\n\nfn main() {\n let x = Some(2);\n let y = Some(3);\n let z = None;\n\n // Match statement\n match x {\n Some(1) => println!(\"one\"),\n Some(2) => println!(\"two\"),\n Some(3) => println!(\"three\"),\n Some(4) => println!(\"four\"),\n _ => println!(\"anything\"),\n }\n\n // if let statement\n if let Some(1) = x {\n println!(\"one\");\n } else if let Some(2) = x {\n println!(\"two\");\n } else if let Some(3) = x {\n println!(\"three\");\n } else {\n println!(\"anything\");\n }\n\n // if let statement with multiple patterns\n let mut map = HashMap::new();\n map.insert(\"one\", 1);\n map.insert(\"two\", 2);\n if let Some(x) = map.get(\"one\") {\n println!(\"one is {}\", x);\n }\n if let Some(x) = map.get(\"two\") {\n println!(\"two is {}\", x);\n }\n}"}
|
| 31 |
+
{"prompt": "Write a complete Rust program with `fn main()` that demonstrates pattern matching with `match` and `if let`. Include necessary imports. Output only code in ```rust code blocks.", "gen": "use std::cmp::Ordering;\n\nfn main() {\n let numbers = vec![2, 4, 6, 8, 10];\n\n // Match\n match numbers[2] {\n 4 => println!(\"The number is 4\"),\n 6 => println!(\"The number is 6\"),\n 8 => println!(\"The number is 8\"),\n 10 => println!(\"The number is 10\"),\n _ => println!(\"Not a 4, 6, 8 or 10\"),\n }\n\n // If let\n let mut total = 0;\n for &n in numbers.iter() {\n if let 4 = n {\n println!(\"Found a 4\");\n } else if let 6 = n {\n println!(\"Found a 6\");\n } else if let 8 = n {\n println!(\"Found an 8\");\n } else if let 10 = n {\n println!(\"Found a 10\");\n } else {\n total += n;\n }\n }\n println!(\"Total: {}\", total);\n\n // Match with enum\n let order = Ordering::Less;\n match order {\n Ordering::Less => println!(\"Less\"),\n Ordering::Equal => println!(\"Equal\"),\n Ordering::Greater => println!(\"Greater\"),\n }\n\n // If let with enum\n let order = Ordering::Less;\n let mut total = 0;\n if let Ordering::Less = order {\n println!(\"Less\");\n } else if let Ordering::Equal = order {\n println!(\"Equal\");\n } else if let Ordering::Greater = order {\n println!(\"Greater\");\n } else {\n total += 1;\n }\n println!(\"Total: {}\", total);\n}"}
|
| 32 |
+
{"prompt": "Write a complete Rust program with `fn main()` that demonstrates pattern matching with `match` and `if let`. Include necessary imports. Output only code in ```rust code blocks.", "gen": "use std::collections::HashMap;\nuse std::collections::HashSet;\n\nfn main() {\n let mut map = HashMap::new();\n let mut set = HashSet::new();\n let mut list = Vec::new();\n let mut option = None;\n\n // match with a variable binding\n let mut num = 0;\n match num {\n 1 => println!(\"One\"),\n 2 => println!(\"Two\"),\n 3 => println!(\"Three\"),\n _ => println!(\"Something else\"),\n }\n\n // match with a pattern binding\n let x = 5;\n match x {\n 1 => println!(\"One\"),\n 2 => println!(\"Two\"),\n 3 => println!(\"Three\"),\n _ => println!(\"Something else\"),\n }\n\n // match with a tuple binding\n let t = (1, 2, 3);\n match t {\n (1, 2, 3) => println!(\"One, Two, Three\"),\n _ => println!(\"Something else\"),\n }\n\n // match with a tuple binding\n let t = (1, 2, 3);\n match t {\n (1, 2, 3) => println!(\"One, Two, Three\"),\n (1, 2, y) => println!(\"One, Two, {}\", y),\n _ => println!(\"Something else\"),\n }\n\n // match with a tuple binding\n let t = (1, 2, 3);\n match t {\n (1, 2, 3) => println!(\"One, Two, Three\"),\n (1, 2, y) => println!(\"One, Two, {}\", y),\n (1, x, 3) => println!(\"One, {}, Three\", x),\n _ => println!(\"Something else\"),\n }\n\n // match with a range binding\n let t = 2;\n match t {\n 1..=3 => println!(\"One, Two, Three\"),\n _ => println!(\"Something else\"),\n }\n\n // match with a range binding\n let t = 2;\n match t {\n 1..=3 => println!(\"One, Two, Three\"),\n 1...3 => println!(\"One, Two, Three\"),\n _ => println!(\"Something else\"),\n }\n\n // match with a pattern binding\n let x = 5;\n match x {\n 1 => println!(\"One\"),\n 2 => println!(\"Two\"),\n 3 => println!(\"Three\"),\n _ => println!(\"Something else\"),\n }\n\n // match with a pattern binding\n let x = 5;\n match x {\n 1 | 2 | 3 => println!(\"One, Two, Three\"),\n _ => println!(\"Something else\"),\n }\n\n // match with a pattern binding\n let x = 5;\n match x {\n 1 | 2 | 3 => println!(\"One, Two, Three\"),\n 1 => println!(\"One\"),\n 2 => println!(\"Two\"),\n 3 => println!(\"Three\"),\n _ => println!(\"Something else\"),\n }\n\n // match with a pattern binding\n let x = 5;\n match x {\n 1 | 2 | 3 => println!(\"One, Two, Three\"),\n 1 => println!(\"One\"),\n 2 => println!(\"Two\"),\n 3 => println!(\"Three\"),\n _ => println!(\"Something else\"),\n }\n\n // match with a pattern binding\n let x = 5;\n match x {\n 1 | 2 | 3 => println!(\"One, Two, Three\"),\n 1 => println!(\"One\"),\n 2 => println!(\"Two\"),\n 3 => println!(\"Three\"),\n _ => println!(\"Something else\"),\n }\n\n // match with a pattern binding\n let x = 5;\n match x {\n 1..=3 => println!(\"One, Two, Three\"),\n 1...3 => println!(\"One, Two, Three\"),\n _ => println!(\"Something else\"),\n }\n\n // match with a pattern binding\n let x = 5;\n match x {\n 1..=3 => println!(\"One, Two, Three\"),\n 1...3 => println!(\"One, Two, Three\"),\n _ => println!(\"Something else\"),\n }\n\n // if let binding\n let x = Some(5);\n if let Some(5) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }\n\n // if let binding\n let x = Some(5);\n if let Some(y) = x {\n println!(\"Five\");\n } else {\n println!(\"Not five\");\n }"}
|
| 33 |
+
{"prompt": "Write a complete Rust program with `fn main()` that demonstrates pattern matching with `match` and `if let`. Include necessary imports. Output only code in ```rust code blocks.", "gen": "use std::fs;\n\nfn main() {\n let contents = fs::read_to_string(\"Cargo.toml\").expect(\"Can't read Cargo.toml\");\n let lines: Vec<&str> = contents.lines().collect();\n\n for line in lines {\n if let Some(s) = line.strip_prefix(\"[\") {\n if let Some(s) = s.strip_suffix(\"]\") {\n println!(\" {}:\", s);\n }\n }\n }"}
|
| 34 |
+
{"prompt": "Write a complete Rust program with `fn main()` that demonstrates pattern matching with `match` and `if let`. Include necessary imports. Output only code in ```rust code blocks.", "gen": "use std::collections::HashMap;\n\nfn main() {\n let mut map = HashMap::new();\n\n map.insert(\"foo\", 1);\n map.insert(\"bar\", 2);\n map.insert(\"baz\", 3);\n\n let mut found = None;\n\n if let Some(val) = map.get(\"foo\") {\n println!(\"Found foo: {}\", val);\n found = Some(*val);\n }\n\n let found2 = map.get(\"foo\").copied();\n\n println!(\"Found foo2: {:?}\", found2);\n\n let mut found3 = None;\n\n if let Some(val) = map.get(\"foo\") {\n found3 = Some(*val);\n }\n\n let found4 = map.get(\"foo\").copied();\n\n println!(\"Found foo3: {:?}\", found3);\n println!(\"Found foo4: {:?}\", found4);\n}"}
|
| 35 |
+
{"prompt": "Write a complete Rust program with `fn main()` that demonstrates pattern matching with `match` and `if let`. Include necessary imports. Output only code in ```rust code blocks.", "gen": "fn main() {\n let x = 5;\n\n // Using if let\n if let Some(value) = Some(3) {\n println!(\"The value is {}\", value);\n }\n\n // Using match\n match Some(4) {\n Some(value) => println!(\"The value is {}\", value),\n None => println!(\"No value provided\"),\n }\n\n // Using if let\n if let Some(value) = Some(6) {\n println!(\"The value is {}\", value);\n }\n\n // Using match\n match Some(7) {\n Some(value) => println!(\"The value is {}\", value),\n None => println!(\"No value provided\"),\n }\n\n // Using if let\n if let Some(value) = Some(8) {\n println!(\"The value is {}\", value);\n }\n\n // Using match\n match Some(9) {\n Some(value) => println!(\"The value is {}\", value),\n None => println!(\"No value provided\"),\n }\n}"}
|
| 36 |
+
{"prompt": "Create a Rust program with a struct, an impl block, and a trait implementation. Include `fn main()` to demonstrate usage. Output only code in ```rust code blocks.", "gen": "use std::fmt::Display;\n\ntrait Print {\n fn print(&self);\n}\n\nstruct Person {\n name: String,\n age: i32,\n}\n\nimpl Print for Person {\n fn print(&self) {\n println!(\"{} is {} years old\", self.name, self.age);\n }\n}\n\nfn main() {\n let p = Person {\n name: \"Alice\".to_string(),\n age: 25,\n };\n p.print();\n}"}
|
| 37 |
+
{"prompt": "Create a Rust program with a struct, an impl block, and a trait implementation. Include `fn main()` to demonstrate usage. Output only code in ```rust code blocks.", "gen": "#[derive(Debug)]\nstruct Rectangle {\n width: u32,\n height: u32,\n}\n\nimpl Rectangle {\n fn area(&self) -> u32 {\n self.width * self.height\n }\n\n fn can_hold(&self, other: &Rectangle) -> bool {\n self.width < other.width && self.height < other.height\n }\n\n fn square(size: u32) -> Rectangle {\n Rectangle {\n width: size,\n height: size,\n }\n }\n}\n\ntrait SquareRoot {\n fn square_root(&self) -> f64;\n}\n\nimpl SquareRoot for f64 {\n fn square_root(&self) -> f64 {\n self.sqrt()\n }\n}\n\nfn main() {\n let rect = Rectangle {\n width: 30,\n height: 50,\n };\n\n let rect2 = Rectangle {\n width: 10,\n height: 40,\n };\n\n println!(\"The area of the rectangle is {} square pixels.\", rect.area());\n\n println!(\"Can rect hold rect2? {}\", rect.can_hold(&rect2));\n\n let square = Rectangle::square(10);\n\n println!(\"The area of the square is {} square pixels.\", square.area());\n\n let f = 3.0;\n println!(\"The square root of {} is {}\", f, f.square_root());\n}"}
|
| 38 |
+
{"prompt": "Create a Rust program with a struct, an impl block, and a trait implementation. Include `fn main()` to demonstrate usage. Output only code in ```rust code blocks.", "gen": "struct Point {\n x: i32,\n y: i32,\n}\n\nimpl Point {\n fn new(x: i32, y: i32) -> Point {\n Point { x, y }\n }\n\n fn distance(&self, other: &Point) -> f64 {\n let dx = (self.x - other.x) as f64;\n let dy = (self.y - other.y) as f64;\n dx * dx + dy * dy\n }\n\n fn print(&self) {\n println!(\"Point ({}, {})\", self.x, self.y);\n }\n}\n\ntrait Transform {\n fn transform(&mut self, x: i32, y: i32);\n}\n\nimpl Transform for Point {\n fn transform(&mut self, x: i32, y: i32) {\n self.x = x;\n self.y = y;\n }\n}\n\nfn main() {\n let mut p = Point::new(1, 2);\n println!(\"Initial point: \");\n p.print();\n println!(\"Distance from origin: {}\", p.distance(&Point::new(0, 0)));\n p.transform(3, 4);\n println!(\"After transformation: \");\n p.print();\n println!(\"Distance from origin: {}\", p.distance(&Point::new(0, 0)));\n}"}
|
| 39 |
+
{"prompt": "Create a Rust program with a struct, an impl block, and a trait implementation. Include `fn main()` to demonstrate usage. Output only code in ```rust code blocks.", "gen": "struct Person {\n name: String,\n age: u8,\n gender: String,\n}\n\nimpl Person {\n fn print_name(&self) {\n println!(\"My name is {}\", self.name);\n }\n}\n\ntrait Talk {\n fn speak(&self) {\n println!(\"Hello, world!\");\n }\n}\n\nimpl Talk for Person {\n fn speak(&self) {\n println!(\"Hi, my name is {}!\", self.name);\n }\n}\n\nfn main() {\n let person = Person {\n name: \"John\".to_string(),\n age: 30,\n gender: \"male\".to_string(),\n };\n person.print_name();\n person.speak();\n}"}
|
| 40 |
+
{"prompt": "Create a Rust program with a struct, an impl block, and a trait implementation. Include `fn main()` to demonstrate usage. Output only code in ```rust code blocks.", "gen": "use std::fmt::Display;\n\ntrait Summable {\n fn sum(&self, other: &Self) -> Self;\n}\n\n#[derive(Debug)]\nstruct Vector<T> {\n elements: Vec<T>,\n}\n\nimpl<T: Summable + Clone> Summable for Vector<T> {\n fn sum(&self, other: &Self) -> Self {\n Vector {\n elements: self.elements.iter().zip(other.elements.iter()).map(|(x, y)| x.sum(y)).collect(),\n }\n }\n}\n\nfn main() {\n let v1 = Vector { elements: vec![1, 2, 3] };\n let v2 = Vector { elements: vec![3, 4, 5] };\n\n println!(\"{:?}\", v1.sum(&v2));\n}"}
|
| 41 |
+
{"prompt": "Create a Rust program with a struct, an impl block, and a trait implementation. Include `fn main()` to demonstrate usage. Output only code in ```rust code blocks.", "gen": "// Create a trait for something that can be drawn.\ntrait Draw {\n fn draw(&self) -> String;\n}\n\n// Define a Rectangle struct.\nstruct Rectangle {\n width: i32,\n height: i32,\n}\n\n// Implement the Draw trait for Rectangle.\nimpl Draw for Rectangle {\n fn draw(&self) -> String {\n format!(\"Drawing a Rectangle of size {}x{}\", self.width, self.height)\n }\n}\n\nfn main() {\n let rect = Rectangle { width: 10, height: 20 };\n println!(\"{}\", rect.draw());\n}"}
|
| 42 |
+
{"prompt": "Create a Rust program with a struct, an impl block, and a trait implementation. Include `fn main()` to demonstrate usage. Output only code in ```rust code blocks.", "gen": "struct Person {\n name: String,\n age: u8,\n}\n\nimpl Person {\n fn greet(&self) {\n println!(\"Hello, my name is {} and I'm {} years old.\", self.name, self.age);\n }\n}\n\ntrait Talk {\n fn talk(&self);\n}\n\nimpl Talk for Person {\n fn talk(&self) {\n self.greet();\n }\n}\n\nfn main() {\n let john = Person {\n name: \"John\".to_string(),\n age: 25,\n };\n\n john.talk();\n}"}
|
| 43 |
+
{"prompt": "Write a Rust program that uses serde to serialize and deserialize a struct to JSON. Include `fn main()` and use serde_json. Output only Rust code in ```rust code blocks.", "gen": "use serde::{Deserialize, Serialize};\n\n#[derive(Serialize, Deserialize)]\nstruct User {\n id: i32,\n name: String,\n email: String,\n}\n\nfn main() {\n let user = User {\n id: 1,\n name: \"John\".to_string(),\n email: \"[email protected]\".to_string(),\n };\n\n let serialized = serde_json::to_string(&user).unwrap();\n println!(\"Serialized user: {}\", serialized);\n\n let deserialized: User = serde_json::from_str(&serialized).unwrap();\n println!(\"Deserialized user: {:?}\", deserialized);\n}"}
|
| 44 |
+
{"prompt": "Write a Rust program that uses serde to serialize and deserialize a struct to JSON. Include `fn main()` and use serde_json. Output only Rust code in ```rust code blocks.", "gen": "use serde::{Deserialize, Serialize};\n\n#[derive(Serialize, Deserialize)]\nstruct Book {\n title: String,\n author: String,\n price: f32,\n pages: u32,\n pub released: bool,\n}\n\nfn main() {\n let book = Book {\n title: \"1984\".to_string(),\n author: \"George Orwell\".to_string(),\n price: 9.99,\n pages: 328,\n released: true,\n };\n\n let serialized = serde_json::to_string(&book).unwrap();\n println!(\"Serialized: {}\", serialized);\n\n let deserialized: Book = serde_json::from_str(&serialized).unwrap();\n println!(\"Deserialized: {:?}\", deserialized);\n}"}
|
| 45 |
+
{"prompt": "Write a Rust program that uses serde to serialize and deserialize a struct to JSON. Include `fn main()` and use serde_json. Output only Rust code in ```rust code blocks.", "gen": "use serde::{Deserialize, Serialize};\n\n#[derive(Serialize, Deserialize)]\nstruct Point {\n x: f64,\n y: f64,\n}\n\nfn main() {\n let point = Point { x: 1.5, y: 2.5 };\n let json = serde_json::to_string(&point).unwrap();\n println!(\"{}\", json);\n let point2: Point = serde_json::from_str(&json).unwrap();\n println!(\"x: {}, y: {}\", point2.x, point2.y);\n}"}
|
| 46 |
+
{"prompt": "Write a Rust program that uses serde to serialize and deserialize a struct to JSON. Include `fn main()` and use serde_json. Output only Rust code in ```rust code blocks.", "gen": "use serde::{Deserialize, Serialize};\n\n#[derive(Debug, Serialize, Deserialize)]\nstruct Person {\n name: String,\n age: u8,\n hobbies: Vec<String>,\n}\n\nfn main() {\n let person = Person {\n name: \"John Doe\".to_string(),\n age: 30,\n hobbies: vec![\"reading\".to_string(), \"hiking\".to_string(), \"gaming\".to_string()],\n };\n\n let serialized = serde_json::to_string(&person).unwrap();\n println!(\"serialized Person: {}\", serialized);\n\n let deserialized_person: Person = serde_json::from_str(&serialized).unwrap();\n println!(\"deserialized Person: {:?}\", deserialized_person);\n}"}
|
| 47 |
+
{"prompt": "Write a Rust program that uses serde to serialize and deserialize a struct to JSON. Include `fn main()` and use serde_json. Output only Rust code in ```rust code blocks.", "gen": "use serde::{Deserialize, Serialize};\n\n#[derive(Debug, Serialize, Deserialize)]\nstruct User {\n username: String,\n email: String,\n age: u8,\n active: bool,\n}\n\nfn main() {\n let user = User {\n username: String::from(\"John Doe\"),\n email: String::from(\"[email protected]\"),\n age: 32,\n active: true,\n };\n\n let user_str = serde_json::to_string(&user).unwrap();\n let user_deserialized: User = serde_json::from_str(&user_str).unwrap();\n\n println!(\"{:?}\", user);\n println!(\"{}\", user_str);\n println!(\"{:?}\", user_deserialized);\n}"}
|
| 48 |
+
{"prompt": "Write a Rust program that uses serde to serialize and deserialize a struct to JSON. Include `fn main()` and use serde_json. Output only Rust code in ```rust code blocks.", "gen": "use serde::{Deserialize, Serialize};\n\n#[derive(Serialize, Deserialize)]\nstruct Address {\n street: String,\n city: String,\n state: String,\n zip: String,\n}\n\n#[derive(Serialize, Deserialize)]\nstruct Person {\n first_name: String,\n last_name: String,\n age: u8,\n address: Address,\n}\n\nfn main() {\n let person = Person {\n first_name: \"John\".to_string(),\n last_name: \"Doe\".to_string(),\n age: 30,\n address: Address {\n street: \"123 Main St\".to_string(),\n city: \"New York\".to_string(),\n state: \"NY\".to_string(),\n zip: \"10001\".to_string(),\n },\n };\n\n let json = serde_json::to_string(&person).unwrap();\n println!(\"{}\", json);\n\n let deserialized_person: Person = serde_json::from_str(&json).unwrap();\n println!(\"{:?}\", deserialized_person);\n}"}
|
| 49 |
+
{"prompt": "Write a Rust program that uses serde to serialize and deserialize a struct to JSON. Include `fn main()` and use serde_json. Output only Rust code in ```rust code blocks.", "gen": "#[macro_use]\nextern crate serde_derive;\n\n#[macro_use]\nextern crate serde_json;\n\nuse serde_json::Value;\n\n#[derive(Debug, Serialize, Deserialize)]\nstruct Person {\n first_name: String,\n last_name: String,\n age: u8,\n}\n\nfn main() {\n let mut person = Person {\n first_name: \"John\".to_string(),\n last_name: \"Doe\".to_string(),\n age: 30,\n };\n\n let json = serde_json::to_string(&person).unwrap();\n println!(\"JSON: {}\", json);\n\n person.age = 31;\n\n let new_person: Person = serde_json::from_str(&json).unwrap();\n println!(\"Deserialized: {:?}\", new_person);\n}"}
|
| 50 |
+
{"prompt": "Create a Rust program that uses the regex crate to find and replace patterns in a string. Include `fn main()` with example text. Output only Rust code in ```rust code blocks.", "gen": "use regex::Regex;\n\nfn main() {\n let text = \"Hello, world! I am a rust developer. Rust is awesome.\";\n let regex = Regex::new(r\"\\b\\w+\\b\").unwrap();\n let replaced = regex.replace_all(text, \"hello\");\n println!(\"{}\", replaced);\n}"}
|
| 51 |
+
{"prompt": "Create a Rust program that uses the regex crate to find and replace patterns in a string. Include `fn main()` with example text. Output only Rust code in ```rust code blocks.", "gen": "use regex::Regex;\n\nfn main() {\n let text = \"I'm a web developer from San Francisco, USA\";\n let re = Regex::new(r\"San Francisco\").unwrap();\n let result = re.replace(&text, \"New York\");\n println!(\"{}\", result);\n}"}
|
| 52 |
+
{"prompt": "Create a Rust program that uses the regex crate to find and replace patterns in a string. Include `fn main()` with example text. Output only Rust code in ```rust code blocks.", "gen": "use regex::Regex;\n\nfn main() {\n let re = Regex::new(r\"foo\").unwrap();\n let text = \"foo bar foo bar\";\n let new_text = re.replace_all(&text, \"baz\");\n println!(\"{}\", new_text);\n}"}
|
| 53 |
+
{"prompt": "Create a Rust program that uses the regex crate to find and replace patterns in a string. Include `fn main()` with example text. Output only Rust code in ```rust code blocks.", "gen": "use regex::Regex;\n\nfn main() {\n let text = \"My email address is [email protected] and my phone number is 123-1234.\";\n let re = Regex::new(r\"(\\d{3}-\\d{4})\").unwrap();\n let replaced = re.replace_all(&text, \"XXX-XXX4\");\n println!(\"{}\", replaced);\n}"}
|
| 54 |
+
{"prompt": "Create a Rust program that uses the regex crate to find and replace patterns in a string. Include `fn main()` with example text. Output only Rust code in ```rust code blocks.", "gen": "use regex::{Regex, RegexBuilder};\nuse std::env;\nuse std::fs::File;\nuse std::io::{BufReader, Write};\nuse std::path::Path;\n\nfn main() {\n let path = env::args().nth(1).expect(\"Please pass the path to a file to search in\");\n\n let file_path = Path::new(&path);\n let file = File::open(file_path).expect(\"file not found\");\n let reader = BufReader::new(file);\n\n let text = reader.lines().next().expect(\"no lines in file\").unwrap();\n\n let regex = RegexBuilder::new(r\"(\\d+)\").unwrap();\n let result = regex.replace_all(&text, |caps: ®ex::Captures| {\n &format!(\"REDACTED\")\n });\n\n let mut file = File::create(&file_path).expect(\"file could not be opened\");\n file.write_all(result.as_bytes()).expect(\"failed to write to file\");\n}"}
|
| 55 |
+
{"prompt": "Create a Rust program that uses the regex crate to find and replace patterns in a string. Include `fn main()` with example text. Output only Rust code in ```rust code blocks.", "gen": "use regex::Regex;\n\nfn main() {\n let mut text = \"I'm going to the store to buy some eggs, milk, and bread.\";\n let re = Regex::new(r\"\\b\\w+\\b\").unwrap();\n let new_text = re.replace_all(&text, \"<word>\");\n println!(\"{}\", new_text);\n}"}
|
| 56 |
+
{"prompt": "Create a Rust program that uses the regex crate to find and replace patterns in a string. Include `fn main()` with example text. Output only Rust code in ```rust code blocks.", "gen": "use regex::Regex;\n\nfn main() {\n let mut text = \"This is a sentence with many words, including some that contain punctuation: foo-bar and baz-quux.\";\n let re = Regex::new(r\"\\b(\\w+)\\b\").unwrap();\n let text = re.replace_all(&text, |caps: ®ex::Captures| {\n format!(\"**{}\", caps[1])\n });\n println!(\"{}\", text);\n}"}
|
| 57 |
+
{"prompt": "Write a Rust program that uses chrono to parse a date string and format it differently. Include `fn main()` with example dates. Output only Rust code in ```rust code blocks.", "gen": "use chrono::{DateTime, Datelike, LocalResult, NaiveDate, NaiveDateTime, NaiveTime, Timelike, Utc};\nuse chrono::format::Parsable;\nuse chrono::format::{Numeric, ParseError, ParseResult, ParseWeekday, ParseYear};"}
|
| 58 |
+
{"prompt": "Write a Rust program that uses chrono to parse a date string and format it differently. Include `fn main()` with example dates. Output only Rust code in ```rust code blocks.", "gen": "use chrono::{DateTime, DateTime, TimeZone, Utc};\n\nfn main() {\n let date_str = \"2022-07-26 12:00:00\";\n let date = DateTime::<Utc>::parse_from_str(date_str, \"%Y-%m-%d %H:%M:%S\").unwrap();\n println!(\"Date: {}\", date.format(\"%B %e, %Y\").to_string());\n\n let date_str = \"2022-07-26 12:00:00\";\n let date = DateTime::<Utc>::parse_from_str(date_str, \"%Y-%m-%d %H:%M:%S\").unwrap();\n println!(\"Date: {}\", date.format(\"%Y-%m-%d %H:%M:%S\").to_string());\n\n let date_str = \"2022-07-26 12:00:00\";\n let date = DateTime::<Utc>::parse_from_str(date_str, \"%Y-%m-%d %H:%M:%S\").unwrap();\n println!(\"Date: {}\", date.format(\"%a %b %d %Y %H:%M:%S\").to_string());\n\n let date_str = \"2022-07-26 12:00:00\";\n let date = DateTime::<Utc>::parse_from_str(date_str, \"%Y-%m-%d %H:%M:%S\").unwrap();\n println!(\"Date: {}\", date.format(\"%A, %B %e, %Y %H:%M:%S\").to_string());\n}"}
|
| 59 |
+
{"prompt": "Write a Rust program that uses chrono to parse a date string and format it differently. Include `fn main()` with example dates. Output only Rust code in ```rust code blocks.", "gen": "use chrono::prelude::*;\n\nfn main() {\n let date_str = \"2021-01-01\";\n let date_str_2 = \"2021-01-02T15:30:00\";\n let date_str_3 = \"2021-01-03 15:30:00\";\n let date_str_4 = \"2021-01-03T15:30:00-08:00\";\n let date_str_5 = \"2021-01-03T15:30:00-08:00[UTC]\";\n\n let date1: DateTime<Utc> = DateTime::parse_from_str(date_str, \"%Y-%m-%d\").unwrap();\n let date2: DateTime<Utc> = DateTime::parse_from_str(date_str_2, \"%Y-%m-%dT%H:%M:%S\").unwrap();\n let date3: DateTime<Utc> = DateTime::parse_from_str(date_str_3, \"%Y-%m-%d %H:%M:%S\").unwrap();\n let date4: DateTime<Utc> = DateTime::parse_from_str(date_str_4, \"%Y-%m-%dT%H:%M:%S%z\").unwrap();\n let date5: DateTime<Utc> = DateTime::parse_from_str(date_str_5, \"%Y-%m-%dT%H:%M:%S%z%Z\").unwrap();\n\n let formatted_date_1 = date1.format(\"%Y-%m-%d\").to_string();\n let formatted_date_2 = date2.format(\"%Y-%m-%d\").to_string();\n let formatted_date_3 = date3.format(\"%Y-%m-%d\").to_string();\n let formatted_date_4 = date4.format(\"%Y-%m-%d\").to_string();\n let formatted_date_5 = date5.format(\"%Y-%m-%d\").to_string();\n\n println!(\"{} -> {}\", date_str, formatted_date_1);\n println!(\"{} -> {}\", date_str_2, formatted_date_2);\n println!(\"{} -> {}\", date_str_3, formatted_date_3);\n println!(\"{} -> {}\", date_str_4, formatted_date_4);\n println!(\"{} -> {}\", date_str_5, formatted_date_5);\n}"}
|
| 60 |
+
{"prompt": "Write a Rust program that uses chrono to parse a date string and format it differently. Include `fn main()` with example dates. Output only Rust code in ```rust code blocks.", "gen": "use chrono::{DateTime, Utc};\n\nfn main() {\n let date_str = \"2001-02-27 10:30:59\";\n let date = DateTime::parse_from_rfc3339(date_str).unwrap();\n let formatted = date.format(\"%Y-%m-%d %H:%M:%S\").to_string();\n println!(\"{}\", formatted);\n \n let date_str = \"2021-12-25 12:00:00\";\n let date = DateTime::parse_from_rfc3339(date_str).unwrap();\n let formatted = date.format(\"%a %b %e %Y\").to_string();\n println!(\"{}\", formatted);\n \n let date_str = \"2022-06-12 15:00:00\";\n let date = DateTime::parse_from_rfc3339(date_str).unwrap();\n let formatted = date.format(\"%H:%M\").to_string();\n println!(\"{}\", formatted);\n}"}
|
| 61 |
+
{"prompt": "Write a Rust program that uses chrono to parse a date string and format it differently. Include `fn main()` with example dates. Output only Rust code in ```rust code blocks.", "gen": "use chrono::{DateTime, Local, NaiveDateTime, NaiveTime, Utc};\nuse chrono::format::{Item, ParseResult, Parsed, StrftimeItem};\n\nfn main() {\n // Date and Time Parsing\n let date = \"2020-10-22T16:30:00+08:00\";\n let naive = NaiveDateTime::parse_from_str(date, \"%Y-%m-%dT%H:%M:%S%z\").unwrap();\n let local = DateTime::<Local>::from_utc(naive, Utc);\n let utc = DateTime::<Utc>::from_utc(naive, Utc);\n let offset = local.offset();\n println!(\"Local Time: {}\", local);\n println!(\"UTC Time: {}\", utc);\n println!(\"UTC Offset: {:?}\", offset);\n println!(\"UTC Offset Seconds: {}\", offset.seconds());\n println!(\"UTC Offset Nanos: {}\", offset.nanos());\n\n // Date and Time Formatting\n let now = Local::now();\n println!(\"Now: {}\", now);\n println!(\"Now (Unix Epoch): {}\", now.timestamp());\n println!(\"Now (Unix Epoch in Seconds): {}\", now.timestamp());\n println!(\"Now (Unix Epoch in Nanoseconds): {}\", now.timestamp_nanos());\n\n let format = \"%Y-%m-%d %H:%M:%S %Z\";\n let formatted = now.format(format).to_string();\n println!(\"Now in format: {}\", formatted);\n}"}
|
| 62 |
+
{"prompt": "Write a Rust program that uses chrono to parse a date string and format it differently. Include `fn main()` with example dates. Output only Rust code in ```rust code blocks.", "gen": "use chrono::{DateTime, Datelike, Timelike, Local, NaiveDate, NaiveDateTime};\n\nfn main() {\n let date = NaiveDate::from_ymd(2022, 9, 25);\n println!(\"Date: {}\", date);\n\n let time = NaiveDateTime::from_timestamp(1661727600, 0);\n println!(\"Time: {}\", time);\n\n let datetime = Local::now();\n println!(\"Local Date & Time: {}\", datetime);\n\n let datetime = DateTime::from_utc(NaiveDateTime::from_timestamp(1661727600, 0), Local);\n println!(\"UTC Date & Time: {}\", datetime);\n\n let datetime = Local::now() + chrono::Duration::minutes(3);\n println!(\"In 3 minutes: {}\", datetime);\n\n let datetime = datetime.checked_add_signed(chrono::Duration::days(1)).unwrap();\n println!(\"In a day: {}\", datetime);\n\n let datetime = datetime.checked_sub_signed(chrono::Duration::days(1)).unwrap();\n println!(\"In a day ago: {}\", datetime);\n\n let datetime = Local::now() - chrono::Duration::hours(2);\n println!(\"2 hours ago: {}\", datetime);\n\n let datetime = datetime + chrono::Duration::hours(2);\n println!(\"2 hours from now: {}\", datetime);\n}"}
|
| 63 |
+
{"prompt": "Write a Rust program that uses chrono to parse a date string and format it differently. Include `fn main()` with example dates. Output only Rust code in ```rust code blocks.", "gen": "use chrono::{DateTime, NaiveDate, NaiveDateTime, Utc};\n\nfn main() {\n // Parse a date string\n let date = NaiveDate::parse_from_str(\"2020-01-01\", \"%Y-%m-%d\").unwrap();\n println!(\"date: {}\", date);\n\n // Parse a date and time string\n let dt = NaiveDateTime::parse_from_str(\"2020-01-01 10:10:10\", \"%Y-%m-%d %H:%M:%S\").unwrap();\n println!(\"date time: {}\", dt);\n\n // Parse a date and time string in UTC\n let dt = DateTime::<Utc>::parse_from_rfc3339(\"2020-01-01T10:10:10Z\").unwrap();\n println!(\"date time (utc): {}\", dt);\n}"}
|
| 64 |
+
{"prompt": "Create a Rust program that generates UUIDs using the uuid crate. Include `fn main()` that generates and prints multiple UUIDs. Output only Rust code in ```rust code blocks.", "gen": "use uuid::Uuid;\n\nfn main() {\n let random_uuid = Uuid::new_v4();\n let random_uuid_str = random_uuid.to_string();\n let random_uuid_array = random_uuid.as_bytes();\n\n let random_uuid1 = Uuid::new_v1();\n let random_uuid1_str = random_uuid1.to_string();\n let random_uuid1_array = random_uuid1.as_bytes();\n\n let random_uuid2 = Uuid::new_v5(\"00000000-0000-0000-0000-000000000000\");\n let random_uuid2_str = random_uuid2.to_string();\n let random_uuid2_array = random_uuid2.as_bytes();\n\n println!(\"Random UUID v4: {} \", random_uuid_str);\n println!(\"Random UUID v4 as array: {:?} \", random_uuid_array);\n println!(\"Random UUID v1: {} \", random_uuid1_str);\n println!(\"Random UUID v1 as array: {:?} \", random_uuid1_array);\n println!(\"Random UUID v5: {} \", random_uuid2_str);\n println!(\"Random UUID v5 as array: {:?} \", random_uuid2_array);\n}"}
|
| 65 |
+
{"prompt": "Create a Rust program that generates UUIDs using the uuid crate. Include `fn main()` that generates and prints multiple UUIDs. Output only Rust code in ```rust code blocks.", "gen": "use uuid::Uuid;\n\nfn main() {\n let uuid = Uuid::new_v4();\n println!(\"{}\", uuid);\n let uuid = Uuid::new_v5(\"5f8d1f0a-9c2b-4b7e-9a8f-7f1c6c2b4d2b\");\n println!(\"{}\", uuid);\n}"}
|
| 66 |
+
{"prompt": "Create a Rust program that generates UUIDs using the uuid crate. Include `fn main()` that generates and prints multiple UUIDs. Output only Rust code in ```rust code blocks.", "gen": "use uuid::Uuid;\n\nfn main() {\n let random_uuid = Uuid::new_v4();\n println!(\"{:?}\", random_uuid);\n\n let random_uuids: Vec<Uuid> = (0..10).map(|_| Uuid::new_v4()).collect();\n for uuid in random_uuids {\n println!(\"{:?}\", uuid);\n }\n}"}
|
| 67 |
+
{"prompt": "Create a Rust program that generates UUIDs using the uuid crate. Include `fn main()` that generates and prints multiple UUIDs. Output only Rust code in ```rust code blocks.", "gen": "use uuid::Uuid;\n\nfn main() {\n let id1 = Uuid::new_v4();\n println!(\"UUID v4: {}\", id1);\n\n let id2 = Uuid::new_v5(&Uuid::NAMESPACE_DNS, \"rust-lang.org\");\n println!(\"UUID v5: {}\", id2);\n\n let id3 = Uuid::new_v5(&Uuid::NAMESPACE_DNS, \"rust-lang.org\");\n println!(\"UUID v5: {}\", id3);\n\n let id4 = Uuid::new_v5(&Uuid::NAMESPACE_DNS, \"rust-lang.org\");\n println!(\"UUID v5: {}\", id4);\n}"}
|
| 68 |
+
{"prompt": "Create a Rust program that generates UUIDs using the uuid crate. Include `fn main()` that generates and prints multiple UUIDs. Output only Rust code in ```rust code blocks.", "gen": "use uuid::Uuid;\n\nfn main() {\n let uuid = Uuid::new_v4();\n println!(\"{}\", uuid);\n \n let uuid = Uuid::new_v5(\"3EB4B8A4-8B8B-4E8C-A2B9-1F3B3E3BBB3B\", &uuid);\n println!(\"{}\", uuid);\n \n let uuid = Uuid::new_v5(\"3EB4B8A4-8B8B-4E8C-A2B9-1F3B3E3BBB3B\", &Uuid::parse_str(\"d7e0c4b3-1b7b-4d8e-bc6c-5f1d0d1b3e3b\").unwrap());\n println!(\"{}\", uuid);\n}"}
|
| 69 |
+
{"prompt": "Create a Rust program that generates UUIDs using the uuid crate. Include `fn main()` that generates and prints multiple UUIDs. Output only Rust code in ```rust code blocks.", "gen": "use uuid::Uuid;\n\nfn main() {\n let uuid = Uuid::new_v4();\n println!(\"Generated UUID: {}\", uuid);\n\n let random_uuid = Uuid::new_v5(&Uuid::nil(), b\"rust\");\n println!(\"Generated UUID: {}\", random_uuid);\n}"}
|
| 70 |
+
{"prompt": "Create a Rust program that generates UUIDs using the uuid crate. Include `fn main()` that generates and prints multiple UUIDs. Output only Rust code in ```rust code blocks.", "gen": "use uuid::Uuid;\n\nfn main() {\n let uuid1 = Uuid::new_v4();\n println!(\"{:?}\", uuid1);\n\n let uuid2 = Uuid::parse_str(\"d4f7a1e1-7c7f-4f7a-a1e1-d4f7a1e17c7f\");\n println!(\"{:?}\", uuid2);\n\n let uuid3 = Uuid::parse_str(\"00000000-0000-0000-0000-000000000000\");\n println!(\"{:?}\", uuid3);\n\n let uuid4 = Uuid::parse_str(\"00000000-0000-0000-0000-000000000000\");\n println!(\"{:?}\", uuid4);\n\n let uuid5 = Uuid::parse_str(\"00000000-0000-0000-0000-000000000000\");\n println!(\"{:?}\", uuid5);\n}"}
|
| 71 |
+
{"prompt": "Write a Rust program that uses the rand crate to generate random numbers and select random items from a vector. Include `fn main()`. Output only Rust code in ```rust code blocks.", "gen": "use rand::Rng;\n\nfn main() {\n let mut rng = rand::thread_rng();\n let numbers: Vec<i32> = (0..10).map(|x| x).collect();\n let random_index: usize = rng.gen_range(0..numbers.len());\n let random_number = numbers[random_index];\n\n println!(\"Random index: {}\", random_index);\n println!(\"Random number: {}\", random_number);\n}"}
|
| 72 |
+
{"prompt": "Write a Rust program that uses the rand crate to generate random numbers and select random items from a vector. Include `fn main()`. Output only Rust code in ```rust code blocks.", "gen": "use rand::Rng;\nuse std::collections::HashMap;\n\nfn main() {\n let mut rng = rand::thread_rng();\n\n let names: Vec<&str> = vec![\"Alice\", \"Bob\", \"Charlie\", \"David\", \"Eve\", \"Frank\", \"Grace\", \"Henry\", \"Ivan\", \"Julia\"];\n let numbers: Vec<i32> = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];\n let people: Vec<&str> = vec![\"Ann\", \"Ben\", \"Cathy\", \"Dan\", \"Eddie\", \"Frankie\", \"George\", \"Helen\", \"Ivan\", \"Jenny\"];\n let numbers_and_people: Vec<(&str, i32)> = vec![(\"Ann\", 1), (\"Ben\", 2), (\"Cathy\", 3), (\"Dan\", 4), (\"Eddie\", 5), (\"Frankie\", 6), (\"George\", 7), (\"Helen\", 8), (\"Ivan\", 9), (\"Jenny\", 10)];\n\n // Select one random person from the list of names\n println!(\"Random name: {}\", rng.gen_range(0, names.len()).unwrap());\n println!(\"Random number: {}\", rng.gen_range(0, numbers.len()).unwrap());\n println!(\"Random person: {}\", rng.gen_range(0, people.len()).unwrap());\n\n // Select one random number from the list of numbers\n println!(\"Random number: {}\", rng.gen_range(0, numbers.len()).unwrap());\n\n // Select one random person from the list of people\n println!(\"Random person: {}\", rng.gen_range(0, people.len()).unwrap());\n\n // Select one random item from the list of tuples\n println!(\"Random number and person: {:?}\", rng.gen_range(0, numbers_and_people.len()).unwrap());\n\n // Select one random person from the list of people using HashMap\n let mut map: HashMap<&str, i32> = HashMap::new();\n for i in 0..people.len() {\n map.insert(&people[i], i as i32);\n }\n println!(\"Random person: {}\", map.get(&rng.gen_range(0, people.len()).unwrap()).unwrap());\n\n // Select one random item from the list of tuples using HashMap\n let mut map: HashMap<(&str, i32), i32> = HashMap::new();\n for i in 0..numbers_and_people.len() {\n map.insert(&numbers_and_people[i].0, &numbers_and_people[i].1);\n }\n println!(\"Random number and person: {:?}\", map.get(&rng.gen_range(0, numbers_and_people.len()).unwrap()).unwrap());\n}"}
|
| 73 |
+
{"prompt": "Write a Rust program that uses the rand crate to generate random numbers and select random items from a vector. Include `fn main()`. Output only Rust code in ```rust code blocks.", "gen": "extern crate rand;\nuse rand::Rng;\nuse rand::distributions::IndependentSample;\nuse rand::distributions::Sample;\n\nfn main() {\n let mut rng = rand::thread_rng();\n\n let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];\n let word = vec![\"apple\", \"banana\", \"cherry\", \"date\", \"elderberry\", \"fig\", \"grape\", \"honeydew\", \"ice cream\", \"jackfruit\", \"kiwi\", \"lemon\", \"mango\", \"nectarine\", \"orange\", \"peach\", \"papaya\", \"quince\", \"raspberry\", \"strawberry\", \"tangerine\", \"ugli fruit\", \"victoria plum\", \"watermelon\", \"xigua\", \"yellow passionfruit\", \"zucchini\"];\n\n let number = rng.gen_range(1, 11);\n let fruit = rng.gen::<usize>() % word.len();\n\n println!(\"Random number: {}\", number);\n println!(\"Random fruit: {}\", word[fruit]);\n}"}
|
| 74 |
+
{"prompt": "Write a Rust program that uses the rand crate to generate random numbers and select random items from a vector. Include `fn main()`. Output only Rust code in ```rust code blocks.", "gen": "use rand::Rng;\nuse rand::distributions::Distribution;\n\nfn main() {\n let mut rng = rand::thread_rng();\n let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];\n let mut result = Vec::new();\n for _ in 0..5 {\n let item = numbers.choose(&mut rng).unwrap();\n result.push(item.clone());\n }\n println!(\"{:?}\", result);\n}"}
|
| 75 |
+
{"prompt": "Write a Rust program that uses the rand crate to generate random numbers and select random items from a vector. Include `fn main()`. Output only Rust code in ```rust code blocks.", "gen": "use rand::prelude::*;\nuse rand::Rng;\nuse std::collections::HashSet;\n\nfn main() {\n let numbers: Vec<u8> = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20];\n let mut rng = thread_rng();\n let mut random_numbers: HashSet<u8> = HashSet::new();\n\n while random_numbers.len() < 5 {\n let random_number = rng.gen_range(1, 21);\n if!random_numbers.contains(&random_number) {\n random_numbers.insert(random_number);\n }\n }\n\n println!(\"Random numbers: {:?}\", random_numbers);\n}"}
|
| 76 |
+
{"prompt": "Write a Rust program that uses the rand crate to generate random numbers and select random items from a vector. Include `fn main()`. Output only Rust code in ```rust code blocks.", "gen": "use rand::prelude::*;\nuse rand::distributions::Distribution;\n\nfn main() {\n let mut rng = thread_rng();\n\n let vector: Vec<i32> = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];\n\n for i in 0..10 {\n let random_number = rng.gen_range(0..10);\n let random_item = vector[random_number as usize];\n println!(\"Random number: {}, Random item: {}\", random_number, random_item);\n }\n}"}
|
| 77 |
+
{"prompt": "Write a Rust program that uses the rand crate to generate random numbers and select random items from a vector. Include `fn main()`. Output only Rust code in ```rust code blocks.", "gen": "use rand::prelude::*;\nuse rand::rngs::OsRng;\nuse std::collections::HashSet;\n\nfn main() {\n let mut rng = OsRng::new().expect(\"Can't access the OS's random number generator\");\n\n let mut numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];\n let mut selected = HashSet::new();\n\n loop {\n let random_number = rng.gen_range(0..10);\n let number = numbers.get(random_number).unwrap();\n if!selected.contains(number) {\n selected.insert(*number);\n println!(\"{} is the winner\", number);\n }\n }\n}"}
|