conversations
listlengths 2
3
| source
stringclasses 1
value | stack
stringclasses 1
value |
|---|---|---|
[
{
"from": "system",
"value": "chore(cli): Add option for other subcommands and ENV fallbacks\n"
},
{
"from": "human",
"value": "use structopt::StructOpt;\n\n/// The CaSILE command line interface, publishing automation level wizard.\n#[derive(StructOpt)]\nstruct Cli {\n // #[structopt(short, long)]\n // version: [ version = env!(\"VERGEN_SEMVER\") ],\n\n /// Activate debug mode\n #[structopt(short, long)]\n debug: bool,\n\n /// Outputs verbose feedback where possible\n #[structopt(short, long)]\n verbose: bool,\n\n #[structopt(subcommand)]\n command: Command,\n}\n\n#[derive(StructOpt)]\nenum Command {\n /// Executes a make target\n Make {\n target: String\n }\n}\n\nfn main() {\n let args = Cli::from_args();\n println!(\"Insert magic potion!\");\n println!(\"Build SHA: {}\", env!(\"VERGEN_SHA_SHORT\"));\n}\n"
},
{
"from": "gpt",
"value": "use structopt::StructOpt;\n\n/// The CaSILE command line interface, publishing automation level wizard.\n#[derive(StructOpt)]\nstruct Cli {\n // #[structopt(short, long)]\n // version: [ version = env!(\"VERGEN_SEMVER\") ],\n\n /// Activate debug mode\n #[structopt(short, long, env = \"DEBUG\")]\n debug: bool,\n\n /// Outputs verbose feedback where possible\n #[structopt(short, long)]\n verbose: bool,\n\n #[structopt(subcommand)]\n command: Command,\n}\n\n#[derive(StructOpt)]\nenum Command {\n /// Executes a make target\n Make {\n target: String\n },\n\n /// Pass through other commands to shell\n #[structopt(external_subcommand)]\n Other(Vec<String>),\n}\n\nfn main() {\n let args = Cli::from_args();\n println!(\"Insert magic potion!\");\n println!(\"Build SHA: {}\", env!(\"VERGEN_SHA_SHORT\"));\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Fix hostname, some IRC servers doesn't accept @ in hostnames\n"
},
{
"from": "human",
"value": "extern crate tiny;\n\nuse tiny::Tiny;\n\nfn main() {\n Tiny::run(\"tiny_test\".to_owned(), \"tiny@tiny\".to_owned(), \"yada yada\".to_owned());\n}\n"
},
{
"from": "gpt",
"value": "extern crate tiny;\n\nuse tiny::Tiny;\n\nfn main() {\n Tiny::run(\"tiny_test\".to_owned(), \"tiny\".to_owned(), \"yada yada\".to_owned());\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Fix Handling of Segment History Element Missing\n"
},
{
"from": "human",
"value": "use {Segment, Attempt, TimingMethod, TimeSpan};\nuse super::ComparisonGenerator;\n\n#[derive(Copy, Clone, Debug)]\npub struct LastFinishedRun;\n\npub const NAME: &'static str = \"Last Finished Run\";\n\nfn generate(segments: &mut [Segment], attempts: &[Attempt], method: TimingMethod) {\n let attempt = attempts\n .iter()\n .rev()\n .find(|a| a.time()[method].is_some());\n\n if let Some(attempt) = attempt {\n let id = attempt.index();\n let mut total_time = TimeSpan::zero();\n for segment in segments {\n let segment_time = segment\n .segment_history()\n .get(id)\n .and_then(|t| t[method]);\n\n let split_time = if let Some(segment_time) = segment_time {\n total_time += segment_time;\n Some(total_time)\n } else {\n None\n };\n\n segment.comparison_mut(NAME)[method] = split_time;\n }\n } else {\n for segment in segments {\n segment.comparison_mut(NAME)[method] = None;\n }\n }\n}\n\nimpl ComparisonGenerator for LastFinishedRun {\n fn name(&self) -> &str {\n NAME\n }\n\n fn generate(&mut self, segments: &mut [Segment], attempts: &[Attempt]) {\n generate(segments, attempts, TimingMethod::RealTime);\n generate(segments, attempts, TimingMethod::GameTime);\n }\n}\n"
},
{
"from": "gpt",
"value": "use {Segment, Attempt, TimingMethod, TimeSpan};\nuse super::ComparisonGenerator;\n\n#[derive(Copy, Clone, Debug)]\npub struct LastFinishedRun;\n\npub const NAME: &'static str = \"Last Finished Run\";\n\nfn generate(segments: &mut [Segment], attempts: &[Attempt], method: TimingMethod) {\n let attempt = attempts\n .iter()\n .rev()\n .find(|a| a.time()[method].is_some());\n\n let mut remaining_segments = segments.iter_mut();\n\n if let Some(attempt) = attempt {\n let id = attempt.index();\n let mut total_time = TimeSpan::zero();\n while let Some(segment) = remaining_segments.next() {\n let segment_time = segment.segment_history().get(id).map(|t| t[method]);\n\n let split_time = match segment_time {\n Some(Some(segment_time)) => {\n total_time += segment_time;\n Some(total_time)\n }\n Some(None) => None,\n None => {\n segment.comparison_mut(NAME)[method] = None;\n break;\n }\n };\n\n segment.comparison_mut(NAME)[method] = split_time;\n }\n }\n\n for segment in remaining_segments {\n segment.comparison_mut(NAME)[method] = None;\n }\n}\n\nimpl ComparisonGenerator for LastFinishedRun {\n fn name(&self) -> &str {\n NAME\n }\n\n fn generate(&mut self, segments: &mut [Segment], attempts: &[Attempt]) {\n generate(segments, attempts, TimingMethod::RealTime);\n generate(segments, attempts, TimingMethod::GameTime);\n }\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Remove debug statements in MapFromString\n"
},
{
"from": "human",
"value": "use engine::{Map, Tile};\nuse engine::builders::{MapBuilder, MapBuildError, MapBuildResult};\n\nuse std::iter::{IteratorExt};\n\npub struct MapFromString {\n s: String,\n}\n\nimpl MapFromString {\n\n pub fn new(s: &str) -> MapFromString {\n MapFromString { s: s.to_string() }\n }\n\n fn build_line(&self, line: &str) -> Vec<Tile> {\n line.chars().map(|char| self.build_cell(char)).collect()\n }\n\n fn build_cell(&self, cell: char) -> Tile {\n match cell {\n ' ' => Tile::Empty,\n '.' => Tile::Floor,\n '#' => Tile::Wall,\n _ => { panic!(\"Invalid character in level string: {}\", cell); }\n }\n }\n}\n\nimpl MapBuilder for MapFromString {\n fn build(&self) -> MapBuildResult {\n let lines : Vec<_> = self.s.split('\\n').collect();\n\n if !lines.iter().all(|x| x.len() == lines[0].len()) { return Err(MapBuildError::new(\"Different length lines\")) };\n\n println!(\"{}\", lines);\n\n let tiles: Vec<Vec<Tile>> = lines.iter().map(|&line| self.build_line(line)).collect();\n\n println!(\"{}\", tiles);\n\n Ok(Map::new(tiles))\n }\n}\n"
},
{
"from": "gpt",
"value": "use engine::{Map, Tile};\nuse engine::builders::{MapBuilder, MapBuildError, MapBuildResult};\n\nuse std::iter::{IteratorExt};\n\npub struct MapFromString {\n s: String,\n}\n\nimpl MapFromString {\n\n pub fn new(s: &str) -> MapFromString {\n MapFromString { s: s.to_string() }\n }\n\n fn build_line(&self, line: &str) -> Vec<Tile> {\n line.chars().map(|char| self.build_cell(char)).collect()\n }\n\n fn build_cell(&self, cell: char) -> Tile {\n match cell {\n ' ' => Tile::Empty,\n '.' => Tile::Floor,\n '#' => Tile::Wall,\n _ => { panic!(\"Invalid character in level string: {}\", cell); }\n }\n }\n}\n\nimpl MapBuilder for MapFromString {\n fn build(&self) -> MapBuildResult {\n let lines : Vec<_> = self.s.split('\\n').collect();\n\n if !lines.iter().all(|x| x.len() == lines[0].len()) { return Err(MapBuildError::new(\"Different length lines\")) };\n\n let tiles: Vec<Vec<Tile>> = lines.iter().map(|&line| self.build_line(line)).collect();\n\n Ok(Map::new(tiles))\n }\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Make discriminant test values huge to make mistakes more apparent\n"
},
{
"from": "human",
"value": "#![no_std]\n\n#[macro_use]\nextern crate enum_map;\n\nuse enum_map::EnumMap;\n\n#[derive(Debug, EnumMap, PartialEq)]\nenum Discriminants {\n A = 2,\n B = 0,\n C = 1,\n}\n\n#[test]\nfn discriminants() {\n let mut map = EnumMap::new();\n map[Discriminants::A] = 3;\n map[Discriminants::B] = 2;\n map[Discriminants::C] = 1;\n let mut pairs = map.into_iter();\n assert_eq!(pairs.next(), Some((Discriminants::A, &3)));\n assert_eq!(pairs.next(), Some((Discriminants::B, &2)));\n assert_eq!(pairs.next(), Some((Discriminants::C, &1)));\n assert_eq!(pairs.next(), None);\n}\n"
},
{
"from": "gpt",
"value": "#![no_std]\n\n#[macro_use]\nextern crate enum_map;\n\nuse enum_map::EnumMap;\n\n#[derive(Debug, EnumMap, PartialEq)]\nenum Discriminants {\n A = 2000,\n B = 3000,\n C = 1000,\n}\n\n#[test]\nfn discriminants() {\n let mut map = EnumMap::new();\n map[Discriminants::A] = 3;\n map[Discriminants::B] = 2;\n map[Discriminants::C] = 1;\n let mut pairs = map.into_iter();\n assert_eq!(pairs.next(), Some((Discriminants::A, &3)));\n assert_eq!(pairs.next(), Some((Discriminants::B, &2)));\n assert_eq!(pairs.next(), Some((Discriminants::C, &1)));\n assert_eq!(pairs.next(), None);\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Tweak number of clusters per line\n"
},
{
"from": "human",
"value": "use std::error;\n\nuse fat;\n\npub fn detail_file(args: &[String])\n -> Result<(), Box<error::Error>>\n{\n if args.len() < 2 {\n return Err(From::from(\"expected <file> <image> filename\"));\n }\n\n let image_fn = args[0].clone();\n let image = fat::Image::from(image_fn)?;\n\n let file_metadata = image.get_file_entry(args[1].clone())?;\n println!(\"{:#?}\", file_metadata);\n\n let mut cluster_num = file_metadata.first_logical_cluster;\n 'outer: loop {\n for _ in 0 .. 4 {\n let next_cluster = image.get_fat_entry(cluster_num);\n print!(\"{:#x}\\t\", cluster_num);\n\n if !fat::cluster_num_is_valid(next_cluster) {\n println!(\"\\n{:#x}\", next_cluster);\n break 'outer;\n }\n\n cluster_num = next_cluster;\n }\n println!(\"\");\n }\n\n Ok(())\n}\n"
},
{
"from": "gpt",
"value": "use std::error;\n\nuse fat;\n\npub fn detail_file(args: &[String])\n -> Result<(), Box<error::Error>>\n{\n if args.len() < 2 {\n return Err(From::from(\"expected <file> <image> filename\"));\n }\n\n let image_fn = args[0].clone();\n let image = fat::Image::from(image_fn)?;\n\n let file_metadata = image.get_file_entry(args[1].clone())?;\n println!(\"{:#?}\", file_metadata);\n\n let mut cluster_num = file_metadata.first_logical_cluster;\n const CLUSTER_NUMS_PER_LINE: usize = 8;\n 'outer: loop {\n for _ in 0 .. CLUSTER_NUMS_PER_LINE {\n let next_cluster = image.get_fat_entry(cluster_num);\n print!(\"{:#x}\\t\", cluster_num);\n\n if !fat::cluster_num_is_valid(next_cluster) {\n println!(\"\\n{:#x}\", next_cluster);\n break 'outer;\n }\n\n cluster_num = next_cluster;\n }\n println!(\"\");\n }\n\n Ok(())\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Revert \"Locking turtles in export even though they aren't used (guarantees that mutation is impossible)\"\n\nThis reverts commit 61682a533a2de6e92d0e85bb75b95d14bdc0721b.\n"
},
{
"from": "human",
"value": "use std::path::Path;\n\nuse tokio::sync::Mutex;\n\nuse crate::ipc_protocol::{\n ServerConnection,\n ServerResponse,\n ExportFormat,\n};\nuse crate::renderer_client::ClientId;\n\nuse super::HandlerError;\nuse super::super::{\n access_control::{AccessControl, RequiredData, RequiredTurtles},\n renderer::{export, display_list::DisplayList},\n};\n\npub(crate) async fn export_drawings(\n conn: &ServerConnection,\n client_id: ClientId,\n app_control: &AccessControl,\n display_list: &Mutex<DisplayList>,\n path: &Path,\n format: ExportFormat,\n) -> Result<(), HandlerError> {\n // We need to lock everything to ensure that the export takes place in a sequentially\n // consistent way. We wouldn't want this to run while any lines are still being drawn.\n let mut data = app_control.get(RequiredData {\n drawing: true,\n turtles: Some(RequiredTurtles::All),\n }).await;\n // Lock the turtles even though they aren't used\n let mut _turtles = data.turtles_mut().await;\n\n // Wait to lock the display list until we actually have the data from the access controller\n let display_list = display_list.lock().await;\n\n use ExportFormat::*;\n let res = match format {\n Svg => export::save_svg(&display_list, data.drawing_mut(), path),\n };\n\n conn.send(client_id, ServerResponse::ExportComplete(res)).await?;\n\n Ok(())\n}\n"
},
{
"from": "gpt",
"value": "use std::path::Path;\n\nuse tokio::sync::Mutex;\n\nuse crate::ipc_protocol::{\n ServerConnection,\n ServerResponse,\n ExportFormat,\n};\nuse crate::renderer_client::ClientId;\n\nuse super::HandlerError;\nuse super::super::{\n access_control::{AccessControl, RequiredData, RequiredTurtles},\n renderer::{export, display_list::DisplayList},\n};\n\npub(crate) async fn export_drawings(\n conn: &ServerConnection,\n client_id: ClientId,\n app_control: &AccessControl,\n display_list: &Mutex<DisplayList>,\n path: &Path,\n format: ExportFormat,\n) -> Result<(), HandlerError> {\n // We need to lock everything to ensure that the export takes place in a sequentially\n // consistent way. We wouldn't want this to run while any lines are still being drawn.\n let mut data = app_control.get(RequiredData {\n drawing: true,\n turtles: Some(RequiredTurtles::All),\n }).await;\n\n // Wait to lock the display list until we actually have the data from the access controller\n let display_list = display_list.lock().await;\n\n use ExportFormat::*;\n let res = match format {\n Svg => export::save_svg(&display_list, data.drawing_mut(), path),\n };\n\n conn.send(client_id, ServerResponse::ExportComplete(res)).await?;\n\n Ok(())\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Add converter from for Date\n"
},
{
"from": "human",
"value": "use std::error::Error;\n\nuse serde::Serialize;\nuse serde::Serializer;\nuse serde::Deserialize;\nuse serde::Deserializer;\nuse serde::de::Visitor;\nuse serde::de::Error as SerdeError;\nuse chrono::naive::datetime::NaiveDateTime;\n\n#[derive(Clone, Debug, Hash)]\npub struct Date(NaiveDateTime);\n\npub static TASKWARRIOR_DATETIME_TEMPLATE : &'static str = \"%Y%m%dT%H%M%SZ\";\n\nimpl Serialize for Date {\n\n fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>\n where S: Serializer\n {\n serializer.serialize_str(&format!(\"{}\", self.0))\n }\n\n}\n\nimpl Deserialize for Date {\n\n fn deserialize<D>(deserializer: &mut D) -> Result<Date, D::Error>\n where D: Deserializer\n {\n struct DateVisitor;\n\n impl Visitor for DateVisitor {\n type Value = Date;\n\n fn visit_str<E>(&mut self, value: &str) -> Result<Date, E>\n where E: SerdeError\n {\n NaiveDateTime::parse_from_str(value, TASKWARRIOR_DATETIME_TEMPLATE)\n .map(|d| Date(d))\n .map_err(|e| SerdeError::custom(e.description()))\n }\n }\n\n deserializer.deserialize(DateVisitor)\n }\n\n}\n"
},
{
"from": "gpt",
"value": "use std::error::Error;\n\nuse serde::Serialize;\nuse serde::Serializer;\nuse serde::Deserialize;\nuse serde::Deserializer;\nuse serde::de::Visitor;\nuse serde::de::Error as SerdeError;\nuse chrono::naive::datetime::NaiveDateTime;\n\n#[derive(Clone, Debug, Hash, Eq, PartialEq)]\npub struct Date(NaiveDateTime);\n\nimpl From<NaiveDateTime> for Date {\n\n fn from(ndt: NaiveDateTime) -> Date {\n Date(ndt)\n }\n\n}\n\npub static TASKWARRIOR_DATETIME_TEMPLATE : &'static str = \"%Y%m%dT%H%M%SZ\";\n\nimpl Serialize for Date {\n\n fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>\n where S: Serializer\n {\n serializer.serialize_str(&format!(\"{}\", self.0))\n }\n\n}\n\nimpl Deserialize for Date {\n\n fn deserialize<D>(deserializer: &mut D) -> Result<Date, D::Error>\n where D: Deserializer\n {\n struct DateVisitor;\n\n impl Visitor for DateVisitor {\n type Value = Date;\n\n fn visit_str<E>(&mut self, value: &str) -> Result<Date, E>\n where E: SerdeError\n {\n NaiveDateTime::parse_from_str(value, TASKWARRIOR_DATETIME_TEMPLATE)\n .map(|d| Date(d))\n .map_err(|e| SerdeError::custom(e.description()))\n }\n }\n\n deserializer.deserialize(DateVisitor)\n }\n\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Remove `icompr!` macro from day 7.\n"
},
{
"from": "human",
"value": "#[macro_use]\nextern crate itertools;\n\nuse itertools::Itertools;\n\nfn main() {\n println!(\"24 days of Rust - itertools (day 7)\");\n let mut words = \"hello supercalifragilisticexpialidocious programmer\".split(|c| c == ' ');\n words.foreach(|word| println!(\"{} is {} characters long\", word, word.len()));\n let even = (1..10).map(|x| x * 2);\n let odd = (1..5).map(|x| x * 2 + 1);\n println!(\"{:?}\", even.interleave(odd).collect::<Vec<_>>());\n println!(\"{:?}\", (1..10).intersperse(15).collect::<Vec<_>>());\n let numbers = 1..4;\n let chars = vec!['a', 'b', 'c'];\n for (i, c) in iproduct!(numbers, chars.iter()) {\n println!(\"{}: {}\", i, c);\n }\n let log = \"GET / 4096\\nGET /home/ 16301\\nPOST /home/ 49\\nGET / 4096\\n\";\n let lines = log.lines();\n let rows = icompr!(line.split(|c| c == ' ').collect::<Vec<_>>(), line, lines);\n let bytes = icompr!(row[2], row, rows, row[0] != \"POST\");\n let total = icompr!(b.parse::<u32>().unwrap(), b, bytes).fold(0, |acc, x| acc + x);\n println!(\"Total GET throughput: {} bytes\", total);\n}\n"
},
{
"from": "gpt",
"value": "#[macro_use]\nextern crate itertools;\n\nuse itertools::Itertools;\n\nfn main() {\n println!(\"24 days of Rust - itertools (day 7)\");\n let mut words = \"hello supercalifragilisticexpialidocious programmer\".split(|c| c == ' ');\n words.foreach(|word| println!(\"{} is {} characters long\", word, word.len()));\n let even = (1..10).map(|x| x * 2);\n let odd = (1..5).map(|x| x * 2 + 1);\n println!(\"{:?}\", even.interleave(odd).collect::<Vec<_>>());\n println!(\"{:?}\", (1..10).intersperse(15).collect::<Vec<_>>());\n let numbers = 1..4;\n let chars = vec!['a', 'b', 'c'];\n for (i, c) in iproduct!(numbers, chars.iter()) {\n println!(\"{}: {}\", i, c);\n }\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Print fortune using fortune command\n"
},
{
"from": "human",
"value": "fn main() {\n println!(\"Hello, world!\");\n}\n"
},
{
"from": "gpt",
"value": "use std::io::Write;\nuse std::process::Command;\n\nconst FORTUNE: &str = \"fortune\";\n\nfn main() {\n println!(\"[FORTUNE COOKIE]\");\n println!(\"{}\", fortune());\n}\n\n/// Get a fortune cookie.\nfn fortune() -> String {\n let output = Command::new(FORTUNE)\n .arg(\"-s\") // Short fortunes only\n .output()\n .expect(\"Failed to get fortune\");\n\n String::from_utf8(output.stdout).expect(\"Failed to decode output\")\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Move write_to to trait implementation\n"
},
{
"from": "human",
"value": "use std::io;\nuse byteorder::WriteBytesExt;\nuse super::{MessageType, WriteTo};\nuse super::messages::{AddEntry, EntryExpired, Entry, RemoveEntry};\n\npub enum Message {\n Ping,\n AddEntry(AddEntry),\n RemoveEntry(RemoveEntry),\n EntryExpired(EntryExpired),\n #[doc(hidden)]\n __NonExhaustive,\n}\n\nimpl Message {\n pub fn message_type(&self) -> MessageType {\n match self {\n &Message::Ping => MessageType::Ping,\n &Message::AddEntry(_) => MessageType::AddEntry,\n &Message::RemoveEntry(_) => MessageType::RemoveEntry,\n _ => panic!(\"invalid Message\")\n }\n }\n\n pub fn is_command(&self) -> bool {\n self.message_type().is_command()\n }\n\n pub fn write_to<W: io::Write>(&self, target: &mut W) -> io::Result<()> {\n target.write_u8(self.message_type().into())?;\n\n match self {\n &Message::Ping => Ok(()),\n &Message::RemoveEntry(ref cmd) => cmd.write_to(target),\n &Message::AddEntry(ref cmd) => cmd.write_to(target),\n _ => panic!(\"invalid Message\")\n }\n }\n}\n\n#[cfg(test)]\nmod test {\n use super::*;\n\n #[test]\n fn test_ping() {\n let cmd = Message::Ping;\n let mut vec = Vec::new();\n\n assert!(cmd.write_to(&mut vec).is_ok());\n assert_eq!(vec![0], vec);\n }\n}"
},
{
"from": "gpt",
"value": "use std::io;\nuse byteorder::WriteBytesExt;\nuse super::{MessageType, WriteTo};\nuse super::messages::{AddEntry, EntryExpired, RemoveEntry};\n\npub enum Message {\n Ping,\n AddEntry(AddEntry),\n RemoveEntry(RemoveEntry),\n EntryExpired(EntryExpired),\n #[doc(hidden)]\n __NonExhaustive,\n}\n\nimpl Message {\n pub fn message_type(&self) -> MessageType {\n match self {\n &Message::Ping => MessageType::Ping,\n &Message::AddEntry(_) => MessageType::AddEntry,\n &Message::RemoveEntry(_) => MessageType::RemoveEntry,\n &Message::EntryExpired(_) => MessageType::EntryExpired,\n _ => panic!(\"invalid Message\")\n }\n }\n\n pub fn is_command(&self) -> bool {\n self.message_type().is_command()\n }\n}\n\nimpl WriteTo for Message {\n fn write_to<W: io::Write>(&self, target: &mut W) -> io::Result<()> {\n target.write_u8(self.message_type().into())?;\n\n match self {\n &Message::Ping => Ok(()),\n &Message::RemoveEntry(ref msg) => msg.write_to(target),\n &Message::AddEntry(ref msg) => msg.write_to(target),\n &Message::EntryExpired(ref msg) => msg.write_to(target),\n _ => panic!(\"invalid Message\")\n }\n }\n}\n\n#[cfg(test)]\nmod test {\n use super::*;\n\n #[test]\n fn test_ping() {\n let cmd = Message::Ping;\n let mut vec = Vec::new();\n\n assert!(cmd.write_to(&mut vec).is_ok());\n assert_eq!(vec![0], vec);\n }\n}"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Include the \"machine\" module so the tests run.\n"
},
{
"from": "human",
"value": "use std::io::{self, Write};\n\nfn main() {\n println!(\"Welcome to Chifir!\");\n println!(\"\");\n println!(\"Type 'help' to get started.\");\n\n loop {\n print!(\"> \");\n io::stdout().flush().unwrap();\n\n let mut command = String::new();\n\n io::stdin().read_line(&mut command).expect(\"Failed to read command\");\n\n match command.trim() {\n \"help\" => println!(\"help, quit\"),\n \"quit\" => break,\n _ => continue\n }\n }\n}\n"
},
{
"from": "gpt",
"value": "mod machine;\n\nuse std::io::{self, Write};\n\nfn main() {\n println!(\"Welcome to Chifir!\");\n println!(\"\");\n println!(\"Type 'help' to get started.\");\n\n loop {\n print!(\"> \");\n io::stdout().flush().unwrap();\n\n let mut command = String::new();\n\n io::stdin().read_line(&mut command).expect(\"Failed to read command\");\n\n match command.trim() {\n \"help\" => println!(\"help, quit\"),\n \"quit\" => break,\n _ => continue\n }\n }\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "fix: Handle missing overrides file gracefully\n"
},
{
"from": "human",
"value": "use std::env;\nuse std::io::prelude::*;\nuse std::io::BufReader;\nuse std::collections::HashMap;\nuse std::path::PathBuf;\nuse std::fs::File;\n\nstatic OVERRIDES_PATH : &'static str = \".multirust/overrides\";\n\nfn main() {\n let home = env::home_dir().expect(\"Impossible to get your home dir!\");\n let mut overrides_path = home.clone();\n overrides_path.push(OVERRIDES_PATH);\n\n let overrides = File::open(&overrides_path).unwrap();\n let overrides = BufReader::new(overrides);\n\n let mut overrides_map = HashMap::<PathBuf, String>::new();\n\n for line in overrides.lines() {\n let line = line.expect(\"No valid line found\");\n let mut s = line.split(';');\n let path = s.next().expect(\"No path in line\");\n let toolchain = s.next().expect(\"No toolchain in line\");\n\n let path = PathBuf::from(path);\n\n overrides_map.insert(path, toolchain.into());\n }\n\n let cwd = env::current_dir().expect(\"No valid working directory\");\n\n match overrides_map.get(&cwd) {\n Some(toolchain) => println!(\"{}\", toolchain),\n None => println!(\"default\"),\n }\n}\n"
},
{
"from": "gpt",
"value": "use std::{env, process};\nuse std::io::prelude::*;\nuse std::io::BufReader;\nuse std::collections::HashMap;\nuse std::path::PathBuf;\nuse std::fs::File;\n\nstatic OVERRIDES_PATH : &'static str = \".multirust/overrides\";\n\nfn main() {\n let home = env::home_dir().expect(\"Impossible to get your home dir!\");\n let mut overrides_path = home.clone();\n overrides_path.push(OVERRIDES_PATH);\n\n let overrides = match File::open(&overrides_path) {\n Ok(f) => f,\n Err(_) => {\n println!(\"default\");\n process::exit(0);\n }\n };\n let overrides = BufReader::new(overrides);\n\n let mut overrides_map = HashMap::<PathBuf, String>::new();\n\n for line in overrides.lines() {\n let line = line.expect(\"No valid line found\");\n let mut s = line.split(';');\n let path = s.next().expect(\"No path in line\");\n let toolchain = s.next().expect(\"No toolchain in line\");\n\n let path = PathBuf::from(path);\n\n overrides_map.insert(path, toolchain.into());\n }\n\n let cwd = env::current_dir().expect(\"No valid working directory\");\n\n match overrides_map.get(&cwd) {\n Some(toolchain) => println!(\"{}\", toolchain),\n None => println!(\"default\"),\n }\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Remove unnecessary 'static in consts\n"
},
{
"from": "human",
"value": "// Copyright 2017 Serde Developers\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\nextern crate serde_json;\n\nuse serde_json::{from_str, Value};\n\n#[test]\nfn test_map_order() {\n // Sorted order\n #[cfg(not(feature = \"preserve_order\"))]\n const EXPECTED: &'static [&'static str] = &[\"a\", \"b\", \"c\"];\n\n // Insertion order\n #[cfg(feature = \"preserve_order\")]\n const EXPECTED: &'static [&'static str] = &[\"b\", \"a\", \"c\"];\n\n let v: Value = from_str(r#\"{\"b\":null,\"a\":null,\"c\":null}\"#).unwrap();\n let keys: Vec<_> = v.as_object().unwrap().keys().collect();\n assert_eq!(keys, EXPECTED);\n}\n"
},
{
"from": "gpt",
"value": "// Copyright 2017 Serde Developers\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\nextern crate serde_json;\n\nuse serde_json::{from_str, Value};\n\n#[test]\nfn test_map_order() {\n // Sorted order\n #[cfg(not(feature = \"preserve_order\"))]\n const EXPECTED: &[&str] = &[\"a\", \"b\", \"c\"];\n\n // Insertion order\n #[cfg(feature = \"preserve_order\")]\n const EXPECTED: &[&str] = &[\"b\", \"a\", \"c\"];\n\n let v: Value = from_str(r#\"{\"b\":null,\"a\":null,\"c\":null}\"#).unwrap();\n let keys: Vec<_> = v.as_object().unwrap().keys().collect();\n assert_eq!(keys, EXPECTED);\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Store GapBuffer data as a byte vector.\n"
},
{
"from": "human",
"value": "use super::Position;\nuse super::Range;\n\npub struct GapBuffer {\n data: String,\n}\n\npub fn new(mut data: String) -> GapBuffer {\n // Ensure that the data has enough room to grow without reallocating.\n let data_length = data.len();\n data.reserve(data_length * 2);\n\n GapBuffer{ data: data }\n}\n\nimpl GapBuffer {\n pub fn to_string(&self) -> String {\n self.data.clone()\n }\n}\n"
},
{
"from": "gpt",
"value": "use super::Position;\nuse super::Range;\n\npub struct GapBuffer {\n data: Vec<u8>,\n}\n\npub fn new(mut data: String) -> GapBuffer {\n // Ensure that the data has enough room to grow without reallocating.\n let data_length = data.len();\n data.reserve(data_length * 2);\n\n GapBuffer{ data: data.into_bytes() }\n}\n\nimpl GapBuffer {\n pub fn to_string(&self) -> String {\n String::from_utf8(self.data.clone()).unwrap()\n }\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Add tests for must_use statements\n"
},
{
"from": "human",
"value": "#![deny(unused_must_use)]\n\n#[macro_use]\nextern crate diesel;\n\nuse diesel::*;\n\ntable! {\n stuff (b) {\n b -> Bool,\n }\n}\n\n\nfn main() {\n use stuff::table as st;\n use stuff::b;\n\n st.select(b); //~ ERROR unused `diesel::query_builder::SelectStatement`\n st.select(b).distinct(); //~ ERROR unused `diesel::query_builder::SelectStatement`\n st.count(); //~ ERROR unused `diesel::query_builder::SelectStatement`\n st.order(b); //~ ERROR unused `diesel::query_builder::SelectStatement`\n st.limit(1); //~ ERROR unused `diesel::query_builder::SelectStatement`\n st.offset(1); //~ ERROR unused `diesel::query_builder::SelectStatement`\n\n st.filter(b.eq(true)); //~ ERROR unused `diesel::query_builder::SelectStatement`\n st.filter(b.eq(true)).limit(1); //~ ERROR unused `diesel::query_builder::SelectStatement`\n\n let _thingies = st.filter(b.eq(true)); // No ERROR\n}\n"
},
{
"from": "gpt",
"value": "#![deny(unused_must_use)]\n\n#[macro_use]\nextern crate diesel;\n\nuse diesel::*;\n\ntable! {\n stuff (b) {\n b -> Bool,\n }\n}\n\n\nfn main() {\n use stuff::table as st;\n use stuff::b;\n\n st.select(b); //~ ERROR unused `diesel::query_builder::SelectStatement`\n st.select(b).distinct(); //~ ERROR unused `diesel::query_builder::SelectStatement`\n st.count(); //~ ERROR unused `diesel::query_builder::SelectStatement`\n st.order(b); //~ ERROR unused `diesel::query_builder::SelectStatement`\n st.limit(1); //~ ERROR unused `diesel::query_builder::SelectStatement`\n st.offset(1); //~ ERROR unused `diesel::query_builder::SelectStatement`\n\n st.filter(b.eq(true)); //~ ERROR unused `diesel::query_builder::SelectStatement`\n st.filter(b.eq(true)).limit(1); //~ ERROR unused `diesel::query_builder::SelectStatement`\n\n insert_into(stuff)\n .values(b.eq(true)); //- ERROR unused `diesel::query_builder::InsertStatement`\n insert_into(stuff)\n .values(&vec![b.eq(true), b.eq(false)]); //~ ERROR unused `diesel::query_builder::InsertStatement`\n\n update(stuff).set(b.eq(true)); //~ ERROR unused `diesel::query_builder::UpdateStatement`\n\n delete(stuff); //~ ERROR unused `diesel::query_builder::DeleteStatement`\n\n let _thingies = st.filter(b.eq(true)); // No ERROR\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Test now ignored because of deadlock\n"
},
{
"from": "human",
"value": "extern crate httpd = \"tiny-http\";\n\nuse std::io::net::tcp::TcpStream;\n\n#[test]\nfn basic_handling() {\n let (server, port) = httpd::Server::new_with_random_port().unwrap();\n\n let mut stream = std::io::net::tcp::TcpStream::connect(\"127.0.0.1\", port);\n write!(stream, \"GET / HTTP/1.1\\r\\nHost: localhost\\r\\nConnection: close\\r\\n\\r\\n\");\n\n let request = server.recv().unwrap();\n assert!(request.get_method().equiv(&\"get\"));\n //assert!(request.get_url() == \"/\");\n request.respond(httpd::Response::from_string(format!(\"hello world\")));\n\n server.try_recv().unwrap();\n\n let content = stream.read_to_string().unwrap();\n assert!(content.as_slice().ends_with(\"hello world\"));\n}\n"
},
{
"from": "gpt",
"value": "extern crate httpd = \"tiny-http\";\n\nuse std::io::net::tcp::TcpStream;\n\n#[test]\n#[ignore]\nfn basic_handling() {\n let (server, port) = httpd::Server::new_with_random_port().unwrap();\n\n let mut stream = std::io::net::tcp::TcpStream::connect(\"127.0.0.1\", port).unwrap();\n write!(stream, \"GET / HTTP/1.1\\r\\nHost: localhost\\r\\nConnection: close\\r\\n\\r\\n\");\n\n let request = server.recv().unwrap();\n assert!(request.get_method().equiv(&\"get\"));\n //assert!(request.get_url() == \"/\");\n request.respond(httpd::Response::from_string(format!(\"hello world\")));\n\n server.try_recv().unwrap();\n\n let content = stream.read_to_string().unwrap();\n assert!(content.as_slice().ends_with(\"hello world\"));\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Include newline in example log output\n\nThe example output was previously unreadable, since the log format\ndidn't include a newline. Perhaps related to the env_logger bump.\n"
},
{
"from": "human",
"value": "extern crate chrono;\nextern crate env_logger;\nextern crate log;\n\nuse self::chrono::prelude::*;\n\nuse self::env_logger::fmt::Formatter;\nuse self::env_logger::Builder;\nuse self::log::{LevelFilter, Record};\nuse std::io::Write;\nuse std::thread;\n\npub fn setup_logger(log_thread: bool, rust_log: Option<&str>) {\n let output_format = move |formatter: &mut Formatter, record: &Record| {\n let thread_name = if log_thread {\n format!(\"(t: {}) \", thread::current().name().unwrap_or(\"unknown\"))\n } else {\n \"\".to_string()\n };\n\n let local_time: DateTime<Local> = Local::now();\n let time_str = local_time.format(\"%H:%M:%S%.3f\").to_string();\n write!(\n formatter,\n \"{} {}{} - {} - {}\",\n time_str,\n thread_name,\n record.level(),\n record.target(),\n record.args()\n )\n };\n\n let mut builder = Builder::new();\n builder\n .format(output_format)\n .filter(None, LevelFilter::Info);\n\n rust_log.map(|conf| builder.parse_filters(conf));\n\n builder.init();\n}\n\n#[allow(dead_code)]\nfn main() {\n println!(\"This is not an example\");\n}\n"
},
{
"from": "gpt",
"value": "extern crate chrono;\nextern crate env_logger;\nextern crate log;\n\nuse self::chrono::prelude::*;\n\nuse self::env_logger::fmt::Formatter;\nuse self::env_logger::Builder;\nuse self::log::{LevelFilter, Record};\nuse std::io::Write;\nuse std::thread;\n\npub fn setup_logger(log_thread: bool, rust_log: Option<&str>) {\n let output_format = move |formatter: &mut Formatter, record: &Record| {\n let thread_name = if log_thread {\n format!(\"(t: {}) \", thread::current().name().unwrap_or(\"unknown\"))\n } else {\n \"\".to_string()\n };\n\n let local_time: DateTime<Local> = Local::now();\n let time_str = local_time.format(\"%H:%M:%S%.3f\").to_string();\n write!(\n formatter,\n \"{} {}{} - {} - {}\\n\",\n time_str,\n thread_name,\n record.level(),\n record.target(),\n record.args()\n )\n };\n\n let mut builder = Builder::new();\n builder\n .format(output_format)\n .filter(None, LevelFilter::Info);\n\n rust_log.map(|conf| builder.parse_filters(conf));\n\n builder.init();\n}\n\n#[allow(dead_code)]\nfn main() {\n println!(\"This is not an example\");\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Revert \"Remove is_whitespace function as no longer used\" since actually STILL used\n\nThis reverts commit 21d02a285521f2dcf3ce2983898fb663c62366c5.\n"
},
{
"from": "human",
"value": "// This Source Code Form is subject to the terms of the Mozilla Public\n// License, v. 2.0. If a copy of the MPL was not distributed with\n// this file, You can obtain one at https://mozilla.org/MPL/2.0/.\n\npub const NB_CHAR: char = ' '; // non breaking space\npub const NB_CHAR_NARROW: char = '\\u{202F}'; // narrow non breaking space\npub const NB_CHAR_EM: char = '\\u{2002}'; // demi em space\n"
},
{
"from": "gpt",
"value": "// This Source Code Form is subject to the terms of the Mozilla Public\n// License, v. 2.0. If a copy of the MPL was not distributed with\n// this file, You can obtain one at https://mozilla.org/MPL/2.0/.\n\npub const NB_CHAR: char = ' '; // non breaking space\npub const NB_CHAR_NARROW: char = '\\u{202F}'; // narrow non breaking space\npub const NB_CHAR_EM: char = '\\u{2002}'; // demi em space\n\n\n/// Custom function because we don't really want to touch \\t or \\n\n///\n/// This function detects spaces and non breking spaces\npub fn is_whitespace(c: char) -> bool {\n c == ' ' || c == ' ' || c == ' '\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Change how One trait is implemented\n"
},
{
"from": "human",
"value": "use std::ops::Add;\n\npub mod point;\npub mod rect;\n\npub type Point<T> = point::Point<T>;\npub type Rect<T> = rect::Rect<T>;\n\ntrait One<T>\n where T: Add<i32, Output=T> +\n Default\n{\n fn one() -> T {\n T::default() + 1\n }\n}\n\nimpl<T> One<T> for T\n where T: Default + Add<i32, Output=T>\n{ /* derived implementor */ }\n"
},
{
"from": "gpt",
"value": "use std::ops::Add;\n\npub mod point;\npub mod rect;\n\npub type Point<T> = point::Point<T>;\npub type Rect<T> = rect::Rect<T>;\n\ntrait One<T> {\n fn one() -> T;\n}\n\nimpl<T> One<T> for T\n where T: Add<i32, Output=T> + Default\n{\n fn one() -> T {\n T::default() + 1\n }\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Add code from Gist. Slight modifications to naming, visibility, and use of $crate\n"
},
{
"from": "human",
"value": "#[test]\nfn it_works() {\n}\n"
},
{
"from": "gpt",
"value": "pub struct HNil;\n \npub struct HCons<H, T> {\n pub head: H,\n pub tail: T\n}\n\npub trait Contains<A> {\n fn get(&self) -> &A;\n fn get_mut(&mut self) -> &mut A;\n}\n\nmacro_rules! hlist_type_internal {\n ($hlist_name:ident, $hlist_current:ty, $th:ty, $($tr:ty,)*) => {\n hlist_type_internal!($hlist_name, HCons<$th, $hlist_current>, $($tr,)*);\n };\n ($hlist_name:ident, $hlist_current:ty,) => {\n type $hlist_name = $hlist_current;\n }\n}\n\n#[macro_export]\nmacro_rules! hlist_type {\n ($hlist:ident) => {hlist_type_internal!($hlist, HNil,)};\n ($hlist:ident, $($types:ty),* ) => {hlist_type_internal!($hlist, $crate::HNil, $($types,)*);}\n}\n\nmacro_rules! generate_hlist_contains {\n \n ($hlist:ty) => {{}};\n ($hlist:ty,) => {{}};\n \n ($hlist:ty, $last:ty, $($init:ty,)*) => {{\n \n impl $crate::Contains<$last> for $hlist {\n \n #[allow(unused_variables)]\n fn get(&self) -> &$last {\n let cur_cell = self;\n $(\n let head: &$init = &cur_cell.head; // Only used to refer to $init \n let cur_cell = &cur_cell.tail;\n )*\n &cur_cell.head\n }\n \n #[allow(unused_variables)]\n fn get_mut(&mut self) -> &mut $last {\n let cur_cell = self;\n $(\n let head: &$init = &cur_cell.head;\n let cur_cell = &mut cur_cell.tail;\n )*\n &mut cur_cell.head\n }\n }\n \n generate_hlist_contains!($hlist, $($init,)*);\n }}\n}\n\n/// Test comment\n#[macro_export]\nmacro_rules! generate_contains_impls {\n ($($types:ty),*) => {{\n hlist_type!(TheHList, $($types),*); \n generate_hlist_contains!(TheHList, $($types,)*);\n }}\n}\n\npub trait HList: Sized {\n fn insert<A: Sized>(self, a: A) -> HCons<A, Self> {\n HCons { head: a, tail: self }\n }\n}\n\n\n \nimpl HList for HNil {}\nimpl<H, T: HList> HList for HCons<H, T> {}\n\n#[test]\nfn it_works() {\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Select last translation inserted for each key/locale pair\n\nNaive approach with ids for now.\n"
},
{
"from": "human",
"value": "extern crate iron;\nextern crate rustc_serialize;\n\nuse iron::headers::ContentType;\nuse iron::prelude::*;\nuse iron::status;\nuse diesel::prelude::*;\nuse rustc_serialize::json;\nuse database;\n\npub fn index(_: &mut Request) -> IronResult<Response> {\n Ok(Response::with((status::Ok, \"Welcome to Lugh API!\")))\n}\n\npub fn translations(_: &mut Request) -> IronResult<Response> {\n use schema::translations::dsl::*;\n use models::*;\n\n let connection = database::establish_connection();\n let results = translations.load::<Translation>(&connection)\n .expect(\"Error loading translations\");\n\n println!(\"Returns {} translations\", results.len());\n\n let payload = json::encode(&results).unwrap();\n\n Ok(Response::with((ContentType::json().0, status::Ok, payload)))\n}\n"
},
{
"from": "gpt",
"value": "extern crate iron;\nextern crate rustc_serialize;\n\nuse iron::headers::ContentType;\nuse iron::prelude::*;\nuse iron::status;\nuse diesel::prelude::*;\nuse rustc_serialize::json;\nuse database;\n\npub fn index(_: &mut Request) -> IronResult<Response> {\n Ok(Response::with((status::Ok, \"Welcome to Lugh API!\")))\n}\n\npub fn translations(_: &mut Request) -> IronResult<Response> {\n use diesel::expression::dsl::sql;\n use models::*;\n use schema::translations::dsl::*;\n\n let connection = database::establish_connection();\n let results = translations.filter(sql(\"id IN (SELECT MAX(id) FROM translations GROUP BY key, locale)\"))\n .load::<Translation>(&connection)\n .expect(\"Error loading translations\");\n\n println!(\"Returns {} translations\", results.len());\n\n let payload = json::encode(&results).unwrap();\n\n Ok(Response::with((ContentType::json().0, status::Ok, payload)))\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Implement Default::default & new for PerCoreVariable\n"
},
{
"from": "human",
"value": "use vmx;\nuse collections::vec::Vec;\nuse core::sync::atomic::{ATOMIC_U16_INIT, AtomicU16, Ordering};\nuse spin;\n\n\nstatic CPU_COUNT: spin::Once<u16> = spin::Once::new();\nstatic CPU_ASSIGNMENT: AtomicU16 = ATOMIC_U16_INIT;\n\n\npub fn init(count: u16) {\n CPU_COUNT.call_once(||{ count });\n}\n\n\npub fn bring_core_online() {\n let cpu_num = CPU_ASSIGNMENT.fetch_add(1, Ordering::Relaxed);\n set_number(cpu_num);\n}\n\n\nfn set_number(num: u16) {\n vmx::write_es(num);\n}\n\n\npub fn get_number() -> u16 {\n vmx::read_es()\n}\n\n\n#[derive(Default)]\npub struct PerCoreVariable<T> {\n vars: Vec<T>,\n}\n\n\nimpl<T> PerCoreVariable<T> {\n pub fn get(&self) -> &T {\n &self.vars[get_number() as usize]\n }\n}\n"
},
{
"from": "gpt",
"value": "use vmx;\nuse collections::vec::Vec;\nuse core::sync::atomic::{ATOMIC_U16_INIT, AtomicU16, Ordering};\nuse spin;\n\n\nstatic CPU_COUNT: spin::Once<u16> = spin::Once::new();\nstatic CPU_ASSIGNMENT: AtomicU16 = ATOMIC_U16_INIT;\n\n\npub fn init(count: u16) {\n CPU_COUNT.call_once(||{ count });\n}\n\nfn get_cpu_count() -> u16 {\n *CPU_COUNT.call_once(|| {\n panic!(\"Must initialize CPU count before requesting it\");\n })\n}\n\n\npub fn bring_core_online() {\n let cpu_num = CPU_ASSIGNMENT.fetch_add(1, Ordering::Relaxed);\n set_number(cpu_num);\n}\n\n\nfn set_number(num: u16) {\n vmx::write_es(num);\n}\n\n\npub fn get_number() -> u16 {\n vmx::read_es()\n}\n\n\npub struct PerCoreVariable<T> {\n vars: Vec<T>,\n}\n\n\nimpl<T: Default> Default for PerCoreVariable<T> {\n fn default() -> Self {\n let mut vars = vec![];\n for _ in 0..get_cpu_count() {\n vars.push(Default::default());\n }\n PerCoreVariable { vars: vars }\n }\n}\n\n\nimpl<T> PerCoreVariable<T> {\n pub fn get(&self) -> &T {\n &self.vars[get_number() as usize]\n }\n}\n\n\nimpl<T: Clone> PerCoreVariable<T> {\n pub fn new(item: T) -> Self {\n PerCoreVariable { vars: vec![item; get_cpu_count() as usize] }\n }\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Add test for empty password\n\nHandling empty passwords properly.\n\nI don't have an explicit check for empty passwords in the keyring\nlibrary (front-end or any of the backends). Instead, I rely on the\nsystem vaults (or as close as possible to that interface) to report back\nerrors. I don't want to up-front assume that blank passwords are\ninvalid (although I thought about doing it this way... and would have\nmissed a bug).\n\nIn the keyring library, the set_password fn for linux has a try! around\nevery single function call which returns a result (all of which are\nbasically wrappers around dbus secret-service calls).\n\nSo, I was a bit surprised to find that fuzzing the keyring library\ncaught a panic on empty string input! I expected a propagated error.\n\nTurns out it was an error in the secret-service library, in a non-IO\ncall formatting the secret. I assumed that because there was no IO it\ncould safely be unwrapped, but it turns out that the dbus library would\nreturn an empty array error when construting from an empty string! A\nvery unexpected error!\n\nAnyways, now that error is no longer unwrapped, and is instead\npropogated up.\n\nThis error was caught while fuzzing, although it would have been easy\nenough if I had more basic tests.\n"
},
{
"from": "human",
"value": "//! # Keyring library\n//!\n//! Allows for setting and getting passwords on Linux, OSX, and Windows\n\n// Configure for Linux\n#[cfg(target_os = \"linux\")]\nextern crate secret_service;\n#[cfg(target_os = \"linux\")]\nmod linux;\n#[cfg(target_os = \"linux\")]\npub use linux::Keyring;\n\n// Configure for Windows\n#[cfg(target_os = \"windows\")]\nextern crate winapi;\n#[cfg(target_os = \"windows\")]\nextern crate advapi32;\n#[cfg(target_os = \"windows\")]\nmod windows;\n#[cfg(target_os = \"windows\")]\npub use windows::Keyring;\n\n// Configure for OSX\n#[cfg(target_os = \"macos\")]\nextern crate rustc_serialize;\n#[cfg(target_os = \"macos\")]\nmod macos;\n#[cfg(target_os = \"macos\")]\npub use macos::Keyring;\n\nmod error;\npub use error::{KeyringError, Result};\n\n"
},
{
"from": "gpt",
"value": "//! # Keyring library\n//!\n//! Allows for setting and getting passwords on Linux, OSX, and Windows\n\n// Configure for Linux\n#[cfg(target_os = \"linux\")]\nextern crate secret_service;\n#[cfg(target_os = \"linux\")]\nmod linux;\n#[cfg(target_os = \"linux\")]\npub use linux::Keyring;\n\n// Configure for Windows\n#[cfg(target_os = \"windows\")]\nextern crate winapi;\n#[cfg(target_os = \"windows\")]\nextern crate advapi32;\n#[cfg(target_os = \"windows\")]\nmod windows;\n#[cfg(target_os = \"windows\")]\npub use windows::Keyring;\n\n// Configure for OSX\n#[cfg(target_os = \"macos\")]\nextern crate rustc_serialize;\n#[cfg(target_os = \"macos\")]\nmod macos;\n#[cfg(target_os = \"macos\")]\npub use macos::Keyring;\n\nmod error;\npub use error::{KeyringError, Result};\n\n#[cfg(test)]\nmod tests {\n use super::*;\n\n #[test]\n #[should_panic]\n fn test_empty_password_input() {\n let pass = \"\";\n let keyring = Keyring::new(\"test\", \"test\");\n match keyring.set_password(pass) {\n Ok(_) => (),\n Err(_) => {\n keyring.get_password().unwrap();\n },\n }\n }\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Make PHI nodes more type safe.\n"
},
{
"from": "human",
"value": "use value::Value;\nuse block::BasicBlock;\nuse ffi::core;\n\n/// A PHI node represents a value which is selected based on the predecessor of the current block.\npub type PhiNode = Value;\n\nimpl PhiNode {\n /// Adds an incoming value to the end of this PHI node.\n pub fn add_incoming(&self, val: &Value, block: &BasicBlock) {\n let mut values = vec![val.into()];\n let mut blocks = vec![block.into()];\n unsafe { core::LLVMAddIncoming(self.into(), values.as_mut_ptr(), blocks.as_mut_ptr(), 1) }.into()\n }\n\n /// Counts the number of incoming values attached to this PHI node.\n pub fn count_incoming(&self) -> u32 {\n unsafe { core::LLVMCountIncoming(self.into()) }\n }\n\n /// Gets an incoming value from this PHI node from a specific index.\n pub fn get_incoming_value(&self, index: u32) -> &Value {\n unsafe { core::LLVMGetIncomingValue(self.into(), index) }.into()\n }\n\n /// Gets an incoming basic block from this PHI node from a specific index.\n pub fn get_incoming_block(&self, index: u32) -> &BasicBlock {\n unsafe { core::LLVMGetIncomingBlock(self.into(), index) }.into()\n }\n}\n"
},
{
"from": "gpt",
"value": "use value::Value;\nuse block::BasicBlock;\nuse ffi::prelude::LLVMValueRef;\nuse ffi::core;\nuse util::CastFrom;\nuse std::ops::Deref;\nuse std::{mem, ptr};\n\n/// A PHI node represents a value which is selected based on the predecessor of the current block.\npub struct PhiNode;\n\nnative_ref!(&PhiNode = LLVMValueRef);\nimpl PhiNode {\n /// Adds an incoming value to the end of this PHI node.\n pub fn add_incoming(&self, val: &Value, block: &BasicBlock) {\n let mut values = vec![val.into()];\n let mut blocks = vec![block.into()];\n unsafe { core::LLVMAddIncoming(self.into(), values.as_mut_ptr(), blocks.as_mut_ptr(), 1) }.into()\n }\n\n /// Counts the number of incoming values attached to this PHI node.\n pub fn count_incoming(&self) -> u32 {\n unsafe { core::LLVMCountIncoming(self.into()) }\n }\n\n /// Gets an incoming value from this PHI node from a specific index.\n pub fn get_incoming_value(&self, index: u32) -> &Value {\n unsafe { core::LLVMGetIncomingValue(self.into(), index) }.into()\n }\n\n /// Gets an incoming basic block from this PHI node from a specific index.\n pub fn get_incoming_block(&self, index: u32) -> &BasicBlock {\n unsafe { core::LLVMGetIncomingBlock(self.into(), index) }.into()\n }\n}\nimpl CastFrom for PhiNode {\n type From = Value;\n fn cast(value: &Value) -> Option<&PhiNode> {\n unsafe {\n let node = core::LLVMIsAPHINode(value.into());\n if node == ptr::null_mut() {\n None\n } else {\n Some(node.into())\n }\n }\n }\n}\nderef!(PhiNode, Value);\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Add fn join_group to RadioToolButton\n"
},
{
"from": "human",
"value": "use std::ptr;\n\nuse RadioToolButton;\nuse ToolItem;\nuse ffi;\nuse glib::object::Downcast;\nuse glib::translate::*;\n\nimpl RadioToolButton {\n pub fn new() -> RadioToolButton {\n assert_initialized_main_thread!();\n unsafe {\n ToolItem::from_glib_none(ffi::gtk_radio_tool_button_new(ptr::null_mut())).downcast_unchecked()\n }\n }\n\n pub fn new_from_stock(stock_id: &str) -> RadioToolButton {\n assert_initialized_main_thread!();\n unsafe {\n ToolItem::from_glib_none(ffi::gtk_radio_tool_button_new_from_stock(ptr::null_mut(), stock_id.to_glib_none().0)).downcast_unchecked()\n }\n }\n}\n"
},
{
"from": "gpt",
"value": "use std::ptr;\n\nuse RadioToolButton;\nuse ToolItem;\nuse ffi;\nuse glib::object::Downcast;\nuse glib::translate::*;\nuse glib::Value;\nuse gobject_ffi;\n\nimpl RadioToolButton {\n pub fn new() -> RadioToolButton {\n assert_initialized_main_thread!();\n unsafe {\n ToolItem::from_glib_none(ffi::gtk_radio_tool_button_new(ptr::null_mut())).downcast_unchecked()\n }\n }\n\n pub fn new_from_stock(stock_id: &str) -> RadioToolButton {\n assert_initialized_main_thread!();\n unsafe {\n ToolItem::from_glib_none(ffi::gtk_radio_tool_button_new_from_stock(ptr::null_mut(), stock_id.to_glib_none().0)).downcast_unchecked()\n }\n }\n\n pub fn join_group<'a, P: Into<Option<&'a RadioToolButton>>>(&self, group: P) {\n let group = group.into();\n unsafe {\n gobject_ffi::g_object_set_property(self.to_glib_none().0, \"group\".to_glib_none().0, Value::from(group).to_glib_none().0);\n }\n }\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "net/eth: Add definition of type EtherTypeExtractor\n"
},
{
"from": "human",
"value": "//! Implementation of Ethernet related Extractors\n"
},
{
"from": "gpt",
"value": "//! Implementation of Ethernet related Extractors\n\nuse net::Packet;\n\nuse net::defs::{Rule, EtherType};\n\nuse net::conn::filter::Extractor;\n\nuse super::defs::Header;\n\n/// Type responsible for ether type extraction\npub struct EtherTypeExtractor;\n\nimpl Extractor<EtherType> for EtherTypeExtractor {\n /// Extract the ether type from a rule\n fn from_rule(rule: &Rule) -> Option<EtherType> {\n rule.eth_rule.as_ref().map(|eth_rule| eth_rule.ether_type)\n }\n\n /// Extract the ether type from a packet\n fn from_packet(pkt: &Packet) -> Option<EtherType> {\n pkt.link_header::<Header>().map(|hdr| hdr.ether_type.as_host())\n }\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Update code sample for chapter 9.\n"
},
{
"from": "human",
"value": "fn main() {\n let a_vector = ~[1,2,3];\n let mut mut_vector = a_vector;\n mut_vector[0] = 5;\n\n println!(\"The first number is {:d}.\", mut_vector[0])\n}\n\n"
},
{
"from": "gpt",
"value": "fn main() {\n let a_vector = vec![1i, 2i, 3i];\n let mut mut_vector = a_vector;\n *mut_vector.get_mut(0) = 5;\n\n println!(\"The first number is {:d}.\", mut_vector[0])\n}\n\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Build sys crate with opt-level 2\n\nIt looks like by default optimization level for C code was the same as\nfor Rust, which caused LMDB to be built with -O3 in release mode and\nthat is not supported officially => sometimes it crashed.\n\nFixes #40\n"
},
{
"from": "human",
"value": "extern crate gcc;\n\nfn main() {\n let target = std::env::var(\"TARGET\").unwrap();\n\n let mut config = gcc::Config::new();\n config.file(\"mdb/libraries/liblmdb/mdb.c\")\n .file(\"mdb/libraries/liblmdb/midl.c\");\n\n if target.contains(\"dragonfly\") {\n config.flag(\"-DMDB_DSYNC=O_SYNC\");\n config.flag(\"-DMDB_FDATASYNC=fsync\");\n }\n\n config.compile(\"liblmdb.a\");\n}\n"
},
{
"from": "gpt",
"value": "extern crate gcc;\n\nfn main() {\n let target = std::env::var(\"TARGET\").unwrap();\n\n let mut config = gcc::Config::new();\n config.file(\"mdb/libraries/liblmdb/mdb.c\")\n .file(\"mdb/libraries/liblmdb/midl.c\");\n config.opt_level(2);\n\n if target.contains(\"dragonfly\") {\n config.flag(\"-DMDB_DSYNC=O_SYNC\");\n config.flag(\"-DMDB_FDATASYNC=fsync\");\n }\n\n config.compile(\"liblmdb.a\");\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Update link libraries to ensure that check-servo-net can link skia\n"
},
{
"from": "human",
"value": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/. */\n\n// Some crumminess to make sure we link correctly\n\n#[cfg(target_os = \"linux\")]\n#[link(name = \"azure\")]\n#[link(name = \"stdc++\")]\n#[link(name = \"skia\")]\n// fontconfig must come before expat for linking to succeed\n#[link(name = \"fontconfig\")]\n#[link(name = \"expat\")]\n#[link(name = \"X11\")]\nextern { }\n\n#[cfg(target_os = \"android\")]\n#[link(name = \"azure\")]\n#[link(name = \"stdc++\")]\n#[link(name = \"skia\")]\n#[link(name = \"expat\")]\n#[link(name = \"fontconfig\")]\n#[link(name = \"EGL\")]\nextern { }\n\n#[cfg(target_os = \"macos\")]\n#[link(name = \"azure\")]\n#[link(name = \"stdc++\")]\n#[link(name = \"skia\")]\n#[link(name = \"objc\")]\n#[link(name = \"IOSurface\", kind = \"framework\")]\n#[link(name = \"OpenGL\", kind = \"framework\")]\n#[link(name = \"Foundation\", kind = \"framework\")]\n#[link(name = \"QuartzCore\", kind = \"framework\")]\n#[link(name = \"ApplicationServices\", kind = \"framework\")]\nextern { }\n"
},
{
"from": "gpt",
"value": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/. */\n\n// Some crumminess to make sure we link correctly\n\n#[cfg(target_os = \"linux\")]\n#[link(name = \"azure\")]\n#[link(name = \"stdc++\")]\n#[link(name = \"skia\")]\n// skia must come before freetype for linking to succeed\n#[link(name = \"freetype\")]\n// fontconfig must come before expat for linking to succeed\n#[link(name = \"fontconfig\")]\n#[link(name = \"expat\")]\n#[link(name = \"X11\")]\nextern { }\n\n#[cfg(target_os = \"android\")]\n#[link(name = \"azure\")]\n#[link(name = \"stdc++\")]\n#[link(name = \"skia\")]\n#[link(name = \"expat\")]\n#[link(name = \"fontconfig\")]\n#[link(name = \"EGL\")]\nextern { }\n\n#[cfg(target_os = \"macos\")]\n#[link(name = \"azure\")]\n#[link(name = \"stdc++\")]\n#[link(name = \"skia\")]\n#[link(name = \"objc\")]\n#[link(name = \"IOSurface\", kind = \"framework\")]\n#[link(name = \"OpenGL\", kind = \"framework\")]\n#[link(name = \"Foundation\", kind = \"framework\")]\n#[link(name = \"QuartzCore\", kind = \"framework\")]\n#[link(name = \"ApplicationServices\", kind = \"framework\")]\nextern { }\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Adjust test to new API"
},
{
"from": "human",
"value": "extern crate pandoc;\n\nuse std::path::PathBuf;\n\n#[test]\nfn creation() {\n use pandoc::PandocOption::*;\n use pandoc::OutputKind;\n let mut pandoc = pandoc::new();\n\n pandoc.add_input(\"cake\");\n pandoc.set_output(OutputKind::File(String::from(\"lie\")));\n pandoc.set_chapters();\n pandoc.set_number_sections();\n pandoc.set_latex_template(\"template.tex\");\n pandoc.set_output_format(pandoc::OutputFormat::Beamer);\n pandoc.add_latex_path_hint(\"D:\\\\texlive\\\\2015\\\\bin\\\\win32\");\n pandoc.set_slide_level(3);\n pandoc.set_toc();\n pandoc.add_option(Strict);\n pandoc.add_option(IndentedCodeClasses(\"cake\".to_string()));\n let path = PathBuf::new();\n pandoc.add_option(Filter(path));\n}\n"
},
{
"from": "gpt",
"value": "extern crate pandoc;\n\nuse std::path::PathBuf;\n\n#[test]\nfn creation() {\n use pandoc::PandocOption::*;\n use pandoc::OutputKind;\n let mut pandoc = pandoc::new();\n\n pandoc.add_input(\"cake\");\n pandoc.set_output(OutputKind::File(String::from(\"lie\")));\n pandoc.set_chapters();\n pandoc.set_number_sections();\n pandoc.set_latex_template(\"template.tex\");\n pandoc.set_output_format(pandoc::OutputFormat::Beamer, Vec::new());\n pandoc.add_latex_path_hint(\"D:\\\\texlive\\\\2015\\\\bin\\\\win32\");\n pandoc.set_slide_level(3);\n pandoc.set_toc();\n pandoc.add_option(Strict);\n pandoc.add_option(IndentedCodeClasses(\"cake\".to_string()));\n let path = PathBuf::new();\n pandoc.add_option(Filter(path));\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Add buffer binder fields to `Context`\n"
},
{
"from": "human",
"value": "use std::mem;\nuse super::gl;\nuse super::gl_lib::types::*;\nuse super::Buffer;\n\npub struct Context;\n\nimpl Context {\n pub unsafe fn current_context() -> Self {\n Context\n }\n\n pub fn clear_color(&mut self, color: super::Color) {\n unsafe {\n gl::ClearColor(color.r, color.g, color.b, color.a);\n }\n }\n\n pub fn clear(&mut self, buffers: super::BufferBits) {\n unsafe {\n gl::Clear(buffers.bits())\n }\n }\n\n pub fn gen_buffer(&self) -> Buffer {\n unsafe {\n let mut id : GLuint = mem::uninitialized();\n gl::GenBuffers(1, &mut id as *mut GLuint);\n Buffer::from_id(id)\n }\n }\n}\n"
},
{
"from": "gpt",
"value": "use std::mem;\nuse super::gl;\nuse super::gl_lib::types::*;\nuse super::{Buffer, ArrayBufferBinder, ElementArrayBufferBinder};\n\npub struct Context {\n array_buffer: ArrayBufferBinder,\n element_array_buffer: ElementArrayBufferBinder\n}\n\nimpl Context {\n pub unsafe fn current_context() -> Self {\n Context {\n array_buffer: ArrayBufferBinder,\n element_array_buffer: ElementArrayBufferBinder\n }\n }\n\n pub fn clear_color(&mut self, color: super::Color) {\n unsafe {\n gl::ClearColor(color.r, color.g, color.b, color.a);\n }\n }\n\n pub fn clear(&mut self, buffers: super::BufferBits) {\n unsafe {\n gl::Clear(buffers.bits())\n }\n }\n\n pub fn gen_buffer(&self) -> Buffer {\n unsafe {\n let mut id : GLuint = mem::uninitialized();\n gl::GenBuffers(1, &mut id as *mut GLuint);\n Buffer::from_id(id)\n }\n }\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Fix erronous error with call to write\n"
},
{
"from": "human",
"value": "#![allow(deprecated)]\n\nuse std::fs::File;\nuse std::hash::{Hash, Hasher, SipHasher};\nuse std::io::Read;\n\npub fn to_hex(num: u64) -> String {\n hex::encode(&[\n (num >> 0) as u8,\n (num >> 8) as u8,\n (num >> 16) as u8,\n (num >> 24) as u8,\n (num >> 32) as u8,\n (num >> 40) as u8,\n (num >> 48) as u8,\n (num >> 56) as u8,\n ])\n}\n\npub fn hash_u64<H: Hash>(hashable: H) -> u64 {\n let mut hasher = SipHasher::new_with_keys(0, 0);\n hashable.hash(&mut hasher);\n hasher.finish()\n}\n\npub fn hash_u64_file(mut file: &File) -> u64 {\n let mut hasher = SipHasher::new_with_keys(0, 0);\n let mut buf = [0; 64 * 1024];\n loop {\n let n = file.read(&mut buf).unwrap();\n if n == 0 {\n break;\n }\n hasher.write(&buf);\n }\n hasher.finish()\n}\n\npub fn short_hash<H: Hash>(hashable: &H) -> String {\n to_hex(hash_u64(hashable))\n}\n"
},
{
"from": "gpt",
"value": "#![allow(deprecated)]\n\nuse std::fs::File;\nuse std::hash::{Hash, Hasher, SipHasher};\nuse std::io::Read;\n\npub fn to_hex(num: u64) -> String {\n hex::encode(&[\n (num >> 0) as u8,\n (num >> 8) as u8,\n (num >> 16) as u8,\n (num >> 24) as u8,\n (num >> 32) as u8,\n (num >> 40) as u8,\n (num >> 48) as u8,\n (num >> 56) as u8,\n ])\n}\n\npub fn hash_u64<H: Hash>(hashable: H) -> u64 {\n let mut hasher = SipHasher::new_with_keys(0, 0);\n hashable.hash(&mut hasher);\n hasher.finish()\n}\n\npub fn hash_u64_file(mut file: &File) -> u64 {\n let mut hasher = SipHasher::new_with_keys(0, 0);\n let mut buf = [0; 64 * 1024];\n loop {\n let n = file.read(&mut buf).unwrap();\n if n == 0 {\n break;\n }\n hasher.write(&buf[..n]);\n }\n hasher.finish()\n}\n\npub fn short_hash<H: Hash>(hashable: &H) -> String {\n to_hex(hash_u64(hashable))\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Fix bug in `HistoryHinter` when `ctx.history_index()` is 0\n\nRunning the example without a `history.txt` file on the current master lead to the following error: \r\n```\r\nthread 'main' panicked at 'attempt to subtract with overflow', src\\hint.rs:26:13 note: Run with `RUST_BACKTRACE=1` environment variable to display a backtrace. error: process didn't exit successfully: `target\\debug\\examples\\example.exe` (exit code: 101)\r\n```"
},
{
"from": "human",
"value": "//! Hints (suggestions at the right of the prompt as you type).\n\nuse crate::history::Direction;\nuse crate::Context;\n\n/// Hints provider\npub trait Hinter {\n /// Takes the currently edited `line` with the cursor `pos`ition and\n /// returns the string that should be displayed or `None`\n /// if no hint is available for the text the user currently typed.\n // TODO Validate: called while editing line but not while moving cursor.\n fn hint(&self, line: &str, pos: usize, ctx: &Context) -> Option<String>;\n}\n\nimpl Hinter for () {\n fn hint(&self, _line: &str, _pos: usize, _ctx: &Context) -> Option<String> {\n None\n }\n}\n\npub struct HistoryHinter {}\n\nimpl Hinter for HistoryHinter {\n fn hint(&self, line: &str, pos: usize, ctx: &Context) -> Option<String> {\n let start = if ctx.history_index() == ctx.history().len() {\n ctx.history_index() - 1\n } else {\n ctx.history_index()\n };\n if let Some(history_index) =\n ctx.history\n .starts_with(&line[..pos], start, Direction::Reverse)\n {\n let entry = ctx.history.get(history_index);\n if let Some(entry) = entry {\n if entry == line || entry == &line[..pos] {\n return None;\n }\n }\n return entry.map(|s| s[pos..].to_owned());\n }\n None\n }\n}\n"
},
{
"from": "gpt",
"value": "//! Hints (suggestions at the right of the prompt as you type).\n\nuse crate::history::Direction;\nuse crate::Context;\n\n/// Hints provider\npub trait Hinter {\n /// Takes the currently edited `line` with the cursor `pos`ition and\n /// returns the string that should be displayed or `None`\n /// if no hint is available for the text the user currently typed.\n // TODO Validate: called while editing line but not while moving cursor.\n fn hint(&self, line: &str, pos: usize, ctx: &Context) -> Option<String>;\n}\n\nimpl Hinter for () {\n fn hint(&self, _line: &str, _pos: usize, _ctx: &Context) -> Option<String> {\n None\n }\n}\n\npub struct HistoryHinter {}\n\nimpl Hinter for HistoryHinter {\n fn hint(&self, line: &str, pos: usize, ctx: &Context) -> Option<String> {\n let start = if ctx.history_index() == ctx.history().len() {\n ctx.history_index().saturating_sub(1)\n } else {\n ctx.history_index()\n };\n if let Some(history_index) =\n ctx.history\n .starts_with(&line[..pos], start, Direction::Reverse)\n {\n let entry = ctx.history.get(history_index);\n if let Some(entry) = entry {\n if entry == line || entry == &line[..pos] {\n return None;\n }\n }\n return entry.map(|s| s[pos..].to_owned());\n }\n None\n }\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Add method to retrieve content from Post\n"
},
{
"from": "human",
"value": "use std::collections::HashMap;\n\n#[deriving(PartialEq, Show)]\npub struct Post {\n header: HashMap<String, String>,\n content: String\n}\n\nimpl Post {\n pub fn new(header: HashMap<String, String>, content: &str) -> Post {\n Post { header: header, content: content.to_string() }\n }\n}\n"
},
{
"from": "gpt",
"value": "use std::collections::HashMap;\n\n#[deriving(PartialEq, Show)]\npub struct Post {\n header: HashMap<String, String>,\n content: String\n}\n\nimpl Post {\n pub fn new(header: HashMap<String, String>, content: &str) -> Post {\n Post { header: header, content: content.to_string() }\n }\n\n pub fn content(&self) -> &str {\n self.content.as_slice()\n }\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Remove unnecessary Path::new, and use AsPath overloading instead\n"
},
{
"from": "human",
"value": "use engine::{Actor, Map};\nuse util::units::{Direction, Point};\n\nuse std::path::Path;\n\npub struct World {\n pub player: Actor,\n pub actors: Vec<Actor>,\n pub map: Map,\n}\n\nimpl World {\n\n pub fn new() -> World {\n World {\n player: Actor::new(\"Player\", Point::new(10, 10), 100, '@'),\n actors: Vec::new(),\n map: Map::from_file(Path::new(\"assets/maps/test.map\")),\n }\n }\n\n pub fn walk(&mut self, direction: Direction) {\n if !self.map.is_walkable(self.player.pos.move_dir(direction)) { return; }\n\n self.player.walk(direction);\n }\n\n}\n"
},
{
"from": "gpt",
"value": "use engine::{Actor, Map};\nuse util::units::{Direction, Point};\n\npub struct World {\n pub player: Actor,\n pub actors: Vec<Actor>,\n pub map: Map,\n}\n\nimpl World {\n\n pub fn new() -> World {\n World {\n player: Actor::new(\"Player\", Point::new(10, 10), 100, '@'),\n actors: Vec::new(),\n map: Map::from_file(\"assets/maps/test.map\"),\n }\n }\n\n pub fn walk(&mut self, direction: Direction) {\n if !self.map.is_walkable(self.player.pos.move_dir(direction)) { return; }\n\n self.player.walk(direction);\n }\n\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Change prompt for REPL to say \"tf\" instead of \"bf\"\n"
},
{
"from": "human",
"value": "mod vm;\nmod command;\nmod parse;\nmod program;\n\nuse std::io::{Write, Read};\nuse std::env;\nuse std::path::Path;\nuse std::fs::File;\n\nuse vm::VM;\nuse program::Program;\nuse parse::parse;\n\n\nfn main() {\n let vm = VM::new();\n let program = Program::new();\n match env::args().nth(1) {\n None => repl(vm, program),\n Some(arg) => interpreter(arg, vm, program),\n }\n}\n\n\nfn repl (mut vm: VM, mut program: Program) -> () {\n loop {\n print!(\"{}\", if program.is_seeking {\"... \"} else {\"bf> \"});\n std::io::stdout().flush().unwrap();\n\n let mut line = String::new();\n let commands = match std::io::stdin().read_line(&mut line) {\n Ok(0) => break,\n Ok(_) => parse(&line),\n Err(error) => panic!(error),\n };\n program.append(&commands);\n program.execute(&mut vm);\n }\n}\n\n\nfn interpreter(arg: String, mut vm: VM, mut program: Program) -> () {\n let path = Path::new(&arg);\n let mut contents = String::new();\n File::open(&path)\n .unwrap()\n .read_to_string(&mut contents)\n .unwrap();\n\n program.append(&parse(&contents));\n program.execute(&mut vm);\n}\n"
},
{
"from": "gpt",
"value": "mod vm;\nmod command;\nmod parse;\nmod program;\n\nuse std::io::{Write, Read};\nuse std::env;\nuse std::path::Path;\nuse std::fs::File;\n\nuse vm::VM;\nuse program::Program;\nuse parse::parse;\n\n\nfn main() {\n let vm = VM::new();\n let program = Program::new();\n match env::args().nth(1) {\n None => repl(vm, program),\n Some(arg) => interpreter(arg, vm, program),\n }\n}\n\n\nfn repl (mut vm: VM, mut program: Program) -> () {\n loop {\n print!(\"{}\", if program.is_seeking {\"... \"} else {\"tf> \"});\n std::io::stdout().flush().unwrap();\n\n let mut line = String::new();\n let commands = match std::io::stdin().read_line(&mut line) {\n Ok(0) => break,\n Ok(_) => parse(&line),\n Err(error) => panic!(error),\n };\n program.append(&commands);\n program.execute(&mut vm);\n }\n}\n\n\nfn interpreter(arg: String, mut vm: VM, mut program: Program) -> () {\n let path = Path::new(&arg);\n let mut contents = String::new();\n File::open(&path)\n .unwrap()\n .read_to_string(&mut contents)\n .unwrap();\n\n program.append(&parse(&contents));\n program.execute(&mut vm);\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": ":sparkles: Make possible to recevie commands\n\n"
},
{
"from": "human",
"value": "fn main() {\n println!(\"Hello, world!\");\n}\n"
},
{
"from": "gpt",
"value": "extern crate clap;\n#[macro_use]\nextern crate serde_derive;\nextern crate serde_json;\nextern crate toml;\n\nmod config;\nmod workflow;\n\nuse clap::{App, SubCommand};\n\nfn main() {\n let _ = workflow::new();\n let matches = App::new(\"jira\")\n .version(env!(\"CARGO_PKG_VERSION\"))\n .about(\"Alfred JIRA Workflow.\")\n .subcommand(SubCommand::with_name(\"Search\")\n .about(\"Search JIRA issues\"))\n .get_matches();\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Add MetricHolder::new() and use LinkedList\n"
},
{
"from": "human",
"value": "extern crate rand;\n\nconst N: usize = 3;\n\nstruct MetricHolder {\n // TODO: make N a part of the metric holder and use a vector\n // also improve by persisting the sum instead of doing avg every time\n history: [u32; N],\n counter: usize\n}\n\nimpl MetricHolder {\n fn moving_average(&mut self, new_val: u32) -> f64 {\n self.history[self.counter] = new_val;\n self.counter = (self.counter + 1) % N;\n let mut sum: u32 = 0;\n let mut count: u32 = 0;\n for &el in self.history.iter() {\n sum += el;\n if el != 0 {\n count += 1;\n }\n }\n sum as f64 / count as f64\n }\n}\n\nfn main() {\n\n // TODO: implement default\n let mut metric_holder = MetricHolder {\n history: [0; N],\n counter: 0\n };\n\n println!(\"{}\", metric_holder.moving_average(1));\n println!(\"{}\", metric_holder.moving_average(1));\n println!(\"{}\", metric_holder.moving_average(1));\n println!(\"{}\", metric_holder.moving_average(2));\n println!(\"{}\", metric_holder.moving_average(3));\n}\n"
},
{
"from": "gpt",
"value": "use std::collections::LinkedList;\n\nstruct MetricHolder {\n n: usize,\n sum: u32,\n history: LinkedList<u32>\n}\n\nimpl MetricHolder {\n fn moving_average(&mut self, new_val: u32) -> f64 {\n self.history.push_back(new_val);\n self.sum += new_val;\n if self.history.len() > self.n {\n let old_val = match self.history.pop_front() {\n Some(val) => val,\n None => 0,\n };\n self.sum -= old_val;\n }\n\n self.sum as f64 / self.history.len() as f64\n }\n\n fn new(n: usize) -> MetricHolder {\n MetricHolder {\n n: n,\n sum: 0,\n history: LinkedList::new()\n }\n }\n}\n\nfn main() {\n let mut metric_holder = MetricHolder::new(2);\n println!(\"{}\", metric_holder.moving_average(1));\n println!(\"{}\", metric_holder.moving_average(1));\n println!(\"{}\", metric_holder.moving_average(1));\n println!(\"{}\", metric_holder.moving_average(2));\n println!(\"{}\", metric_holder.moving_average(3));\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Use vec of subcommands for future.\n"
},
{
"from": "human",
"value": "\nextern crate mprovision;\nextern crate clap;\n\nuse std::fs;\nuse clap::{Arg, App, AppSettings, SubCommand};\n\nfn main() {\n let count_subcommand = SubCommand::with_name(\"count\")\n .about(\"Counts provisioning profiles in a directory.\")\n .arg(Arg::with_name(\"DIRECTORY\")\n .help(\"Directory where to count provisioning profiles.\")\n .required(false));\n\n let matches = App::new(\"mprovision\")\n .setting(AppSettings::SubcommandRequired)\n .version(\"0.1.0\")\n .about(\"A tool that helps iOS developers to manage mobileprovision files.\")\n .subcommand(count_subcommand)\n .get_matches();\n\n if let Some(matches) = matches.subcommand_matches(\"count\") {\n handle_count_subcommand(matches)\n }\n}\n\nfn handle_count_subcommand(matches: &clap::ArgMatches) {\n\n fn show(result: mprovision::Result<Box<Iterator<Item = fs::DirEntry>>>) {\n match result {\n Ok(files) => println!(\"Found {} files.\", files.count()),\n Err(err) => println!(\"Error: {}\", err),\n }\n }\n\n if let Some(directory) = matches.value_of(\"DIRECTORY\") {\n show(mprovision::files(directory));\n } else {\n match mprovision::directory() {\n Ok(directory) => show(mprovision::files(directory)),\n Err(err) => println!(\"Error: {}\", err),\n }\n }\n}\n"
},
{
"from": "gpt",
"value": "\nextern crate mprovision;\nextern crate clap;\n\nuse std::fs;\nuse clap::{Arg, App, AppSettings, SubCommand};\n\nfn main() {\n let subcommands = vec![\n SubCommand::with_name(\"count\")\n .about(\"Counts provisioning profiles in a directory.\")\n .arg(Arg::with_name(\"DIRECTORY\")\n .help(\"Directory where to count provisioning profiles.\")\n .required(false)),\n ];\n\n let matches = App::new(\"mprovision\")\n .setting(AppSettings::SubcommandRequired)\n .version(\"0.1.0\")\n .about(\"A tool that helps iOS developers to manage mobileprovision files.\")\n .subcommands(subcommands)\n .get_matches();\n\n if let Some(matches) = matches.subcommand_matches(\"count\") {\n handle_count_subcommand(matches)\n }\n}\n\nfn handle_count_subcommand(matches: &clap::ArgMatches) {\n\n fn show(result: mprovision::Result<Box<Iterator<Item = fs::DirEntry>>>) {\n match result {\n Ok(files) => println!(\"Found {} files.\", files.count()),\n Err(err) => println!(\"Error: {}\", err),\n }\n }\n\n if let Some(directory) = matches.value_of(\"DIRECTORY\") {\n show(mprovision::files(directory));\n } else {\n match mprovision::directory() {\n Ok(directory) => show(mprovision::files(directory)),\n Err(err) => println!(\"Error: {}\", err),\n }\n }\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Use traits and type specifiable\n"
},
{
"from": "human",
"value": "pub struct Gauge<T> {\n pub value: T\n}\n\n\nimpl<T> Gauge<T> {\n pub fn update(&mut self, value: T) {\n self.value = value\n }\n\n pub fn snapshot(self) -> Gauge<T> {\n Gauge { value: self.value }\n }\n}\n\n\n#[cfg(test)]\nmod test {\n use gauge::Gauge;\n\n #[test]\n fn create_and_snapshot() {\n let g: Gauge<f64> = Gauge {value: 0f64 };\n let mut g_snapshot = g.snapshot();\n\n g_snapshot.update(10f64);\n\n assert!(g.value == 0f64);\n assert!(g_snapshot.value == 10f64);\n }\n}"
},
{
"from": "gpt",
"value": "pub struct StdGauge<T> {\n pub value: T\n}\n\n\npub trait Gauge<T> {\n fn update(&mut self, value: T);\n fn snapshot(self) -> Self;\n}\n\n\nimpl<T> Gauge<T> for StdGauge<T> {\n fn update(&mut self, value: T) {\n self.value = value\n }\n\n fn snapshot(self) -> StdGauge<T> {\n StdGauge { value: self.value }\n }\n}\n\n\n#[cfg(test)]\nmod test {\n use gauge::{Gauge,StdGauge};\n\n #[test]\n fn create_and_snapshot() {\n let g: StdGauge<f64> = StdGauge {value: 0f64 };\n let mut g_snapshot = g.snapshot();\n\n g_snapshot.update(10f64);\n\n assert!(g.value == 0f64);\n assert!(g_snapshot.value == 10f64);\n }\n}"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Set twitter poll back to railinfo\n"
},
{
"from": "human",
"value": "extern crate iron;\n#[macro_use]\nextern crate router;\nextern crate dotenv;\nextern crate sbb_telegram_bot;\n\nuse dotenv::dotenv;\nuse iron::prelude::*;\nuse sbb_telegram_bot::route;\nuse sbb_telegram_bot::util::{telegram, twitter};\nuse std::thread;\nuse std::time::Duration;\n\nfn main() {\n dotenv().ok();\n thread::spawn(broadcast_loop);\n let router = router!(telegram: post \"/sbb/telegram\" => route::telegram);\n Iron::new(router).http(\"localhost:3001\").unwrap();\n}\n\nfn broadcast_loop() {\n loop {\n thread::sleep(Duration::from_secs(10));\n let tweets = twitter::user_timeline(\"SBB_Delay_Bot\", 1).unwrap();\n let tweet = &tweets[0];\n if tweet.id != twitter::read_last_tweet_id() {\n twitter::write_last_tweet_id(tweet.id);\n let mut txt = tweet.text.clone();\n if let Some(pos) = txt.find(\"http\") {\n txt = txt[..pos].to_owned();\n }\n telegram::broadcast(&txt).unwrap();\n }\n }\n}\n"
},
{
"from": "gpt",
"value": "extern crate iron;\n#[macro_use]\nextern crate router;\nextern crate dotenv;\nextern crate sbb_telegram_bot;\n\nuse dotenv::dotenv;\nuse iron::prelude::*;\nuse sbb_telegram_bot::route;\nuse sbb_telegram_bot::util::{telegram, twitter};\nuse std::thread;\nuse std::time::Duration;\n\nfn main() {\n dotenv().ok();\n thread::spawn(broadcast_loop);\n let router = router!(telegram: post \"/sbb/telegram\" => route::telegram);\n Iron::new(router).http(\"localhost:3001\").unwrap();\n}\n\nfn broadcast_loop() {\n loop {\n thread::sleep(Duration::from_secs(10));\n let tweets = twitter::user_timeline(\"railinfo_sbb\", 1).unwrap();\n let tweet = &tweets[0];\n if tweet.id != twitter::read_last_tweet_id() {\n twitter::write_last_tweet_id(tweet.id);\n let mut txt = tweet.text.clone();\n if let Some(pos) = txt.find(\"http\") {\n txt = txt[..pos].to_owned();\n }\n telegram::broadcast(&txt).unwrap();\n }\n }\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Implement tournament selection to obtain some convergence\n"
},
{
"from": "human",
"value": "extern crate rand;\n\nuse rand::thread_rng;\nuse rand::distributions::Range;\nuse individual::Individual;\n\nmod individual;\n\nfn main() {\n let mut rng = thread_rng();\n let range = Range::new(-512.03_f64, 511.97); // range for Schwefel problem\n\n // initialize population\n let mut population: Vec<_> = (0..128).map(|_| {\n Individual::new(&range, &mut rng)\n }).collect();\n\n for i in 0..10000 {\n // generate mutated offspring\n population = population.iter().map(|x| {\n x.mutate(&range, &mut rng)\n }).collect();\n\n let best = population.iter().min().unwrap();\n if i % 100 == 0 {\n println!(\"{}th fitness: {}\", i, best.fitness);\n }\n\n if best.fitness < 1000_f64 {\n println!(\"Solution: {:?}\", best.solution);\n return;\n }\n }\n println!(\"Failed to converge.\");\n}\n"
},
{
"from": "gpt",
"value": "extern crate rand;\n\nuse rand::{Rng, thread_rng};\nuse rand::distributions::Range;\nuse individual::Individual;\n\nmod individual;\n\nfn select<'a, R: Rng>(population: &'a Vec<Individual>, rng: &mut R)\n -> &'a Individual {\n let population: Vec<_> = (0..4).map(|_| rng.choose(population)).collect();\n if let Some(selected) = population.iter().min() {\n return selected.unwrap();\n }\n unimplemented!();\n}\n\nfn main() {\n let mut rng = thread_rng();\n let range = Range::new(-512.03_f64, 511.97); // range for Schwefel problem\n\n // initialize population\n let mut population: Vec<_> = (0..128).map(|_| {\n Individual::new(&range, &mut rng)\n }).collect();\n\n for i in 0..10000 {\n // select and mutate individuals for next population\n population = (0..128).map(|_| {\n select(&population, &mut rng).mutate(&range, &mut rng)\n }).collect();\n\n let best = population.iter().min().unwrap();\n if i % 100 == 0 {\n println!(\"{}th fitness: {}\", i, best.fitness);\n }\n\n if best.fitness < 1000_f64 {\n println!(\"{}th solution converged at {}: {:?}\",\n i, best.fitness, best.solution);\n return;\n }\n }\n println!(\"Failed to converge.\");\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Fix warning about unstable library features"
},
{
"from": "human",
"value": "// This code is editable and runnable!\nfn main() {\n // A simple integer calculator:\n // `+` or `-` means add or subtract by 1\n // `*` or `/` means multiply or divide by 2\n\n let program = \"+ + * - /\";\n let mut accumulator = 0;\n\n for token in program.chars() {\n match token {\n '+' => accumulator += 1,\n '-' => accumulator -= 1,\n '*' => accumulator *= 2,\n '/' => accumulator /= 2,\n _ => { /* ignore everything else */ }\n }\n }\n\n println!(\"The program \\\"{}\\\" calculates the value {}\",\n program, accumulator);\n}\n"
},
{
"from": "gpt",
"value": "#![feature(core)]\n\n// This code is editable and runnable!\nfn main() {\n // A simple integer calculator:\n // `+` or `-` means add or subtract by 1\n // `*` or `/` means multiply or divide by 2\n\n let program = \"+ + * - /\";\n let mut accumulator = 0;\n\n for token in program.chars() {\n match token {\n '+' => accumulator += 1,\n '-' => accumulator -= 1,\n '*' => accumulator *= 2,\n '/' => accumulator /= 2,\n _ => { /* ignore everything else */ }\n }\n }\n\n println!(\"The program \\\"{}\\\" calculates the value {}\",\n program, accumulator);\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Remove a now-extraneous `use std`\n"
},
{
"from": "human",
"value": "// Copyright (c) 2015-2016 William (B.J.) Snow Orvis\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npub mod fractaldata;\npub mod pistonrendering;\npub mod work_multiplexer;\n\nfn main() {\n // Command line arguments specification\n let mut app = clap::App::new(\"fractal\")\n .version(env!(\"CARGO_PKG_VERSION\"))\n .author(env!(\"CARGO_PKG_AUTHORS\"))\n .about(\"Renders fractals in another window.\");\n app = fractaldata::add_subcommands(app);\n\n let matches = app.get_matches();\n let result = fractaldata::run_subcommand(&matches);\n\n match result {\n Ok(_) => {}\n Err(e) => {\n use std;\n use std::io::{stderr, Write};\n writeln!(&mut stderr(), \"{}\", e).unwrap();\n std::process::exit(1);\n }\n }\n}\n"
},
{
"from": "gpt",
"value": "// Copyright (c) 2015-2016 William (B.J.) Snow Orvis\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npub mod fractaldata;\npub mod pistonrendering;\npub mod work_multiplexer;\n\nfn main() {\n // Command line arguments specification\n let mut app = clap::App::new(\"fractal\")\n .version(env!(\"CARGO_PKG_VERSION\"))\n .author(env!(\"CARGO_PKG_AUTHORS\"))\n .about(\"Renders fractals in another window.\");\n app = fractaldata::add_subcommands(app);\n\n let matches = app.get_matches();\n let result = fractaldata::run_subcommand(&matches);\n\n match result {\n Ok(_) => {}\n Err(e) => {\n use std::io::{stderr, Write};\n writeln!(&mut stderr(), \"{}\", e).unwrap();\n std::process::exit(1);\n }\n }\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Update wav mirror to new api\n"
},
{
"from": "human",
"value": "//! Reads input from a microphone and mirrors it to a speaker ad nauseum.\n\nextern crate oxcable;\n\n#[cfg(not(test))]\nfn main() {\n use oxcable::types::Device;\n use oxcable::io::wav;\n println!(\"Mirroring wav/song.wav input to wav/test_wav.wav...\");\n\n let mut inwav = wav::WavReader::new(\"wav/song.wav\");\n let mut outwav = wav::WavWriter::new(\"wav/test_wav.wav\", 2);\n outwav.inputs.set_channel(0, inwav.outputs.get_channel(0));\n outwav.inputs.set_channel(1, inwav.outputs.get_channel(1));\n\n let mut t = 0;\n while !inwav.is_done() {\n inwav.tick(t);\n outwav.tick(t);\n t += 1;\n }\n}\n"
},
{
"from": "gpt",
"value": "//! Reads input from a microphone and mirrors it to a speaker ad nauseum.\n\nextern crate oxcable;\n\n#[cfg(not(test))]\nfn main() {\n use oxcable::chain::DeviceChain;\n use oxcable::io::wav;\n\n println!(\"Initializing signal chain...\");\n let inwav = wav::WavReader::new(\"wav/song.wav\");\n let samples = inwav.get_num_samples();\n let outwav = wav::WavWriter::new(\"wav/test_wav.wav\", 2);\n let mut chain = DeviceChain::from(inwav).into(outwav);\n\n println!(\"Mirroring wav/song.wav input to wav/test_wav.wav...\");\n for _ in 0..samples {\n chain.tick();\n }\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Fix some unused warnings with the latest rustc compiler\n"
},
{
"from": "human",
"value": "// vim: tw=80\n//! bare functions can use non-public types, as long as the object's visibility is compatible.\n\n// mocking modules requires the proc_macro_hygiene feature in the _consumer_\n// code\n#![cfg_attr(feature = \"nightly\", feature(proc_macro_hygiene))]\n\n#[allow(unused)]\ncfg_if::cfg_if! {\n if #[cfg(feature = \"nightly\")] {\n mod outer {\n struct SuperT();\n\n mod inner {\n use mockall::automock;\n\n pub(crate) struct PubCrateT();\n struct PrivT();\n\n #[automock]\n mod m {\n use super::*;\n\n fn foo(x: PubCrateT) -> PubCrateT { unimplemented!() }\n fn bar(x: PrivT) -> PrivT { unimplemented!() }\n fn baz(x: super::super::SuperT) -> super::super::SuperT {\n unimplemented!()\n }\n fn bang(x: crate::outer::SuperT) -> crate::outer::SuperT {\n unimplemented!()\n }\n }\n }\n }\n }\n}\n"
},
{
"from": "gpt",
"value": "// vim: tw=80\n//! bare functions can use non-public types, as long as the object's visibility is compatible.\n\n// mocking modules requires the proc_macro_hygiene feature in the _consumer_\n// code\n#![cfg_attr(feature = \"nightly\", feature(proc_macro_hygiene))]\n\n#[allow(unused)]\ncfg_if::cfg_if! {\n if #[cfg(feature = \"nightly\")] {\n mod outer {\n struct SuperT();\n\n mod inner {\n use mockall::automock;\n\n pub(crate) struct PubCrateT();\n struct PrivT();\n\n #[automock]\n #[allow(unused)]\n mod m {\n use super::*;\n\n fn foo(x: PubCrateT) -> PubCrateT { unimplemented!() }\n fn bar(x: PrivT) -> PrivT { unimplemented!() }\n fn baz(x: super::super::SuperT) -> super::super::SuperT {\n unimplemented!()\n }\n fn bang(x: crate::outer::SuperT) -> crate::outer::SuperT {\n unimplemented!()\n }\n }\n }\n }\n }\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Disable HPET use on x86\n"
},
{
"from": "human",
"value": "pub mod cpu;\npub mod ioapic;\npub mod local_apic;\npub mod pic;\npub mod pit;\npub mod rtc;\npub mod serial;\n#[cfg(feature = \"acpi\")]\npub mod hpet;\n#[cfg(feature = \"system76_ec_debug\")]\npub mod system76_ec;\n\nuse crate::paging::KernelMapper;\n\npub unsafe fn init() {\n pic::init();\n local_apic::init(&mut KernelMapper::lock());\n}\npub unsafe fn init_after_acpi() {\n // this will disable the IOAPIC if needed.\n //ioapic::init(mapper);\n}\n\n#[cfg(feature = \"acpi\")]\nunsafe fn init_hpet() -> bool {\n use crate::acpi::ACPI_TABLE;\n if let Some(ref mut hpet) = *ACPI_TABLE.hpet.write() {\n hpet::init(hpet)\n } else {\n false\n }\n}\n\n#[cfg(not(feature = \"acpi\"))]\nunsafe fn init_hpet() -> bool {\n false\n}\n\npub unsafe fn init_noncore() {\n if init_hpet() {\n log::info!(\"HPET used as system timer\");\n } else {\n pit::init();\n log::info!(\"PIT used as system timer\");\n }\n\n rtc::init();\n serial::init();\n}\n\npub unsafe fn init_ap() {\n local_apic::init_ap();\n}\n"
},
{
"from": "gpt",
"value": "pub mod cpu;\npub mod ioapic;\npub mod local_apic;\npub mod pic;\npub mod pit;\npub mod rtc;\npub mod serial;\n#[cfg(feature = \"acpi\")]\npub mod hpet;\n#[cfg(feature = \"system76_ec_debug\")]\npub mod system76_ec;\n\nuse crate::paging::KernelMapper;\n\npub unsafe fn init() {\n pic::init();\n local_apic::init(&mut KernelMapper::lock());\n}\npub unsafe fn init_after_acpi() {\n // this will disable the IOAPIC if needed.\n //ioapic::init(mapper);\n}\n\n#[cfg(feature = \"acpi\")]\nunsafe fn init_hpet() -> bool {\n use crate::acpi::ACPI_TABLE;\n if let Some(ref mut hpet) = *ACPI_TABLE.hpet.write() {\n hpet::init(hpet)\n } else {\n false\n }\n}\n\n#[cfg(not(feature = \"acpi\"))]\nunsafe fn init_hpet() -> bool {\n false\n}\n\npub unsafe fn init_noncore() {\n if false /*TODO: init_hpet()*/ {\n log::info!(\"HPET used as system timer\");\n } else {\n pit::init();\n log::info!(\"PIT used as system timer\");\n }\n\n rtc::init();\n serial::init();\n}\n\npub unsafe fn init_ap() {\n local_apic::init_ap();\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Make read_file and write_file take generic paths\n"
},
{
"from": "human",
"value": "use std::io;\nuse std::io::{Read, Write};\nuse std::fs::File;\n\n\npub fn write_file(filename: &str, contents: &Vec<u8>) -> io::Result<()> {\n let mut file = try!(File::create(filename));\n Ok(try!(file.write_all(contents)))\n}\n\n\npub fn read_file_to_string(filename: &str, buf: &mut String) -> io::Result<usize> {\n let mut file = try!(File::open(filename));\n let bytes = try!(file.read_to_string(buf));\n Ok(bytes)\n}\n"
},
{
"from": "gpt",
"value": "use std::io;\nuse std::io::{Read, Write};\nuse std::fs::File;\nuse std::path::Path;\n\n\npub fn write_file<P: AsRef<Path>>(path: P, contents: &Vec<u8>) -> io::Result<()> {\n let mut file = try!(File::create(path));\n Ok(try!(file.write_all(contents)))\n}\n\n\npub fn read_file_to_string<P: AsRef<Path>>(path: P, buf: &mut String) -> io::Result<usize> {\n let mut file = try!(File::open(path));\n let bytes = try!(file.read_to_string(buf));\n Ok(bytes)\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "chore: Fix the path in the fmt_repl test\n"
},
{
"from": "human",
"value": "#[macro_use]\nextern crate pretty_assertions;\n\nuse std::fs::File;\nuse std::io::Read;\nuse std::process::Command;\n\n#[test]\nfn fmt_repl() {\n let source = \"src/repl.glu\";\n\n let mut before = String::new();\n File::open(source)\n .unwrap()\n .read_to_string(&mut before)\n .unwrap();\n\n let status = Command::new(\"gluon\")\n .args(&[\"fmt\", source])\n .spawn()\n .unwrap()\n .wait()\n .unwrap();\n assert!(status.success());\n\n let mut after = String::new();\n File::open(source)\n .unwrap()\n .read_to_string(&mut after)\n .unwrap();\n\n assert_eq!(before, after);\n}\n"
},
{
"from": "gpt",
"value": "#[macro_use]\nextern crate pretty_assertions;\n\nuse std::fs::File;\nuse std::io::Read;\nuse std::process::Command;\n\n#[test]\nfn fmt_repl() {\n let source = \"src/repl.glu\";\n\n let mut before = String::new();\n File::open(source)\n .unwrap()\n .read_to_string(&mut before)\n .unwrap();\n\n let status = Command::new(\"target/debug/gluon\")\n .args(&[\"fmt\", source])\n .spawn()\n .expect(\"Could not find gluon executable\")\n .wait()\n .unwrap();\n assert!(status.success());\n\n let mut after = String::new();\n File::open(source)\n .unwrap()\n .read_to_string(&mut after)\n .unwrap();\n\n assert_eq!(before, after);\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Fix deprecation warnings with 1.39.0\n\nSigned-off-by: Josh Black <2831680e59d3b8be5b278b69b4e783c575edf378@gmail.com>\n"
},
{
"from": "human",
"value": "use std::{ffi::CStr,\n mem};\n\nuse libc;\n\nuse crate::{error::{Error,\n Result},\n os::system::Uname};\nuse errno::errno;\n\npub fn uname() -> Result<Uname> { unsafe { uname_libc() } }\n\nunsafe fn uname_libc() -> Result<Uname> {\n let mut utsname: libc::utsname = mem::uninitialized();\n let rv = libc::uname(&mut utsname);\n if rv < 0 {\n let errno = errno();\n let code = errno.0 as i32;\n return Err(Error::UnameFailed(format!(\"Error {} when calling uname: \\\n {}\",\n code, errno)));\n }\n Ok(Uname { sys_name: CStr::from_ptr(utsname.sysname.as_ptr()).to_string_lossy()\n .into_owned(),\n node_name: CStr::from_ptr(utsname.nodename.as_ptr()).to_string_lossy()\n .into_owned(),\n release: CStr::from_ptr(utsname.release.as_ptr()).to_string_lossy()\n .into_owned(),\n version: CStr::from_ptr(utsname.version.as_ptr()).to_string_lossy()\n .into_owned(),\n machine: CStr::from_ptr(utsname.machine.as_ptr()).to_string_lossy()\n .into_owned(), })\n}\n"
},
{
"from": "gpt",
"value": "use crate::{error::{Error,\n Result},\n os::system::Uname};\nuse errno::errno;\nuse libc;\nuse std::{ffi::CStr,\n mem};\n\npub fn uname() -> Result<Uname> { unsafe { uname_libc() } }\n\nunsafe fn uname_libc() -> Result<Uname> {\n let mut utsname: libc::utsname = mem::MaybeUninit::uninit().assume_init();\n let rv = libc::uname(&mut utsname);\n if rv < 0 {\n let errno = errno();\n let code = errno.0 as i32;\n return Err(Error::UnameFailed(format!(\"Error {} when calling uname: \\\n {}\",\n code, errno)));\n }\n Ok(Uname { sys_name: CStr::from_ptr(utsname.sysname.as_ptr()).to_string_lossy()\n .into_owned(),\n node_name: CStr::from_ptr(utsname.nodename.as_ptr()).to_string_lossy()\n .into_owned(),\n release: CStr::from_ptr(utsname.release.as_ptr()).to_string_lossy()\n .into_owned(),\n version: CStr::from_ptr(utsname.version.as_ptr()).to_string_lossy()\n .into_owned(),\n machine: CStr::from_ptr(utsname.machine.as_ptr()).to_string_lossy()\n .into_owned(), })\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "bitstream: Add tagl and tagb macros\n\nThey are yet another building block useful to write demuxers.\n"
},
{
"from": "human",
"value": "pub mod bitread;\npub mod byteread;\npub mod bytewrite;\n\n"
},
{
"from": "gpt",
"value": "pub mod bitread;\npub mod byteread;\npub mod bytewrite;\n\n#[macro_export]\nmacro_rules! tagl {\n ($a:expr, $b:expr, $c:expr, $d:expr) => {\n ($a as u32) |\n ($b as u32) << 8 |\n ($c as u32) << 16 |\n ($d as u32) << 24\n }\n}\n\n#[macro_export]\nmacro_rules! tagb {\n ($a:expr, $b:expr, $c:expr, $d:expr) => {\n tagl!($d, $c, $b, $a)\n }\n}\n\n\n// TODO: write meaningful tests.\n#[cfg(test)]\nmod test {\n #[test]\n fn tags() {\n assert_eq!(tagl!('a', 'b', 'c', 'd'), 1684234849u32);\n assert_eq!(tagb!('a', 'b', 'c', 'd'), 1633837924u32);\n }\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Improve scrabble by removing unnecessary String::from()\n"
},
{
"from": "human",
"value": "fn value(c: char) -> u32 {\n match c {\n 'a' | 'e' | 'i' | 'o' | 'u' | 'l' | 'n' | 'r' | 's' | 't' => 1,\n 'd' | 'g' => 2,\n 'b' | 'c' | 'm' | 'p' => 3,\n 'f' | 'h' | 'v' | 'w' | 'y' => 4,\n 'k' => 5,\n 'j' | 'x' => 8,\n 'q' | 'z' => 10,\n _ => 0,\n }\n}\n\npub fn score(word: &str) -> u32 {\n let owned_word = String::from(word).to_lowercase();\n\n owned_word.chars().fold(0, |acc, x| acc + value(x))\n}\n"
},
{
"from": "gpt",
"value": "fn value(c: char) -> u32 {\n match c {\n 'a' | 'e' | 'i' | 'o' | 'u' | 'l' | 'n' | 'r' | 's' | 't' => 1,\n 'd' | 'g' => 2,\n 'b' | 'c' | 'm' | 'p' => 3,\n 'f' | 'h' | 'v' | 'w' | 'y' => 4,\n 'k' => 5,\n 'j' | 'x' => 8,\n 'q' | 'z' => 10,\n _ => 0,\n }\n}\n\npub fn score(word: &str) -> u32 {\n word.to_lowercase().chars().fold(0, |acc, x| acc + value(x))\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Add an example of using newline\n"
},
{
"from": "human",
"value": "use rustyline::validate::MatchingBracketValidator;\nuse rustyline::{Editor, Result};\nuse rustyline_derive::{Completer, Helper, Highlighter, Hinter, Validator};\n\n#[derive(Completer, Helper, Highlighter, Hinter, Validator)]\nstruct InputValidator {\n #[rustyline(Validator)]\n brackets: MatchingBracketValidator,\n}\n\nfn main() -> Result<()> {\n let h = InputValidator {\n brackets: MatchingBracketValidator::new(),\n };\n let mut rl = Editor::new()?;\n rl.set_helper(Some(h));\n\n let input = rl.readline(\"> \")?;\n println!(\"Input: {}\", input);\n\n Ok(())\n}\n"
},
{
"from": "gpt",
"value": "use rustyline::validate::MatchingBracketValidator;\nuse rustyline::{Cmd, Editor, EventHandler, KeyCode, KeyEvent, Modifiers, Result};\nuse rustyline_derive::{Completer, Helper, Highlighter, Hinter, Validator};\n\n#[derive(Completer, Helper, Highlighter, Hinter, Validator)]\nstruct InputValidator {\n #[rustyline(Validator)]\n brackets: MatchingBracketValidator,\n}\n\nfn main() -> Result<()> {\n let h = InputValidator {\n brackets: MatchingBracketValidator::new(),\n };\n let mut rl = Editor::new()?;\n rl.set_helper(Some(h));\n rl.bind_sequence(\n KeyEvent(KeyCode::Char('s'), Modifiers::CTRL),\n EventHandler::Simple(Cmd::Newline),\n );\n\n let input = rl.readline(\"> \")?;\n println!(\"Input: {}\", input);\n\n Ok(())\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Fix Bug in PNG Encoding\n"
},
{
"from": "human",
"value": "use std::marker::PhantomData;\n\n#[derive(Copy, Clone)]\npub enum ColorType {\n RGBA(u8),\n}\npub struct ImageBuffer<T, U = ()>(U, PhantomData<T>);\npub struct Rgba<T>(PhantomData<T>);\n\npub mod png {\n use super::ColorType;\n use super::super::png::Encoder;\n use std::io::Write;\n\n pub struct PNGEncoder<W>(W);\n\n impl<W: Write> PNGEncoder<W> {\n pub fn new(w: W) -> Self {\n PNGEncoder(w)\n }\n\n pub fn encode(&mut self, d: &[u8], w: u32, h: u32, _: ColorType) -> Result<(), ()> {\n Encoder::new(&mut self.0, w, h)\n .write_header()\n .map_err(|_| ())?\n .write_image_data(d)\n .map_err(|_| ())\n }\n }\n}\n\nimpl<T, U> ImageBuffer<T, U> {\n pub fn from_raw(_: u32, _: u32, d: U) -> Option<ImageBuffer<Rgba<u8>, U>> {\n Some(ImageBuffer(d, PhantomData))\n }\n\n pub fn as_ref(&self) -> &[u8]\n where\n U: AsRef<[u8]>,\n {\n self.0.as_ref()\n }\n}\n"
},
{
"from": "gpt",
"value": "use std::marker::PhantomData;\n\n#[derive(Copy, Clone)]\npub enum ColorType {\n RGBA(u8),\n}\npub struct ImageBuffer<T, U = ()>(U, PhantomData<T>);\npub struct Rgba<T>(PhantomData<T>);\n\npub mod png {\n use super::ColorType;\n use super::super::png::{self as pnglib, HasParameters};\n use std::io::Write;\n\n pub struct PNGEncoder<W>(W);\n\n impl<W: Write> PNGEncoder<W> {\n pub fn new(w: W) -> Self {\n PNGEncoder(w)\n }\n\n pub fn encode(&mut self, d: &[u8], w: u32, h: u32, _: ColorType) -> Result<(), ()> {\n let mut encoder = pnglib::Encoder::new(&mut self.0, w, h);\n encoder\n .set(pnglib::ColorType::RGBA)\n .set(pnglib::BitDepth::Eight);\n encoder\n .write_header()\n .map_err(|_| ())?\n .write_image_data(d)\n .map_err(|_| ())\n }\n }\n}\n\nimpl<T, U> ImageBuffer<T, U> {\n pub fn from_raw(_: u32, _: u32, d: U) -> Option<ImageBuffer<Rgba<u8>, U>> {\n Some(ImageBuffer(d, PhantomData))\n }\n\n pub fn as_ref(&self) -> &[u8]\n where\n U: AsRef<[u8]>,\n {\n self.0.as_ref()\n }\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Print out connection rates in the server\n"
},
{
"from": "human",
"value": "use std::env;\nuse std::io::*;\nuse std::net::*;\n\nfn main() {\n let addr = env::args().nth(1).unwrap_or(\"127.0.0.1:12345\".to_string());\n let addr = addr.parse::<SocketAddr>().unwrap();\n let l = TcpListener::bind(&addr).unwrap();\n println!(\"listening...\");\n let b = [0; 64 * 1024];\n loop {\n let mut c = l.accept().unwrap().0;\n println!(\"got a connection, writing some data to it\");\n while c.write(&b).is_ok() {}\n println!(\"connection is gone, listening for another\");\n }\n}\n"
},
{
"from": "gpt",
"value": "use std::env;\nuse std::io::*;\nuse std::net::*;\nuse std::sync::atomic::*;\nuse std::thread;\nuse std::time::Duration;\n\nstatic AMT: AtomicUsize = ATOMIC_USIZE_INIT;\n\nfn main() {\n let addr = env::args().nth(1).unwrap_or(\"127.0.0.1:12345\".to_string());\n let addr = addr.parse::<SocketAddr>().unwrap();\n let l = TcpListener::bind(&addr).unwrap();\n println!(\"listening...\");\n let b = [0; 64 * 1024];\n thread::spawn(|| {\n loop {\n thread::sleep(Duration::new(1, 0));\n println!(\"{}\", AMT.swap(0, Ordering::SeqCst));\n }\n });\n loop {\n let mut c = l.accept().unwrap().0;\n println!(\"got a connection, writing some data to it\");\n while let Ok(n) = c.write(&b) {\n AMT.fetch_add(n, Ordering::SeqCst);\n }\n println!(\"connection is gone, listening for another\");\n }\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Add three basic execute cases\n"
},
{
"from": "human",
"value": "use command::Command;\nuse vm::VM;\n\n\npub struct Program {\n instructions: Vec<Command>,\n instruction_pointer: Option<usize>,\n current_depth: u64,\n pub status: ProgramStatus,\n}\n\n#[derive(Clone, Copy, PartialEq, Debug)]\npub enum ProgramStatus {\n Normal,\n Seeking(u64),\n}\n\n\nimpl Program {\n pub fn new() -> Program {\n Program {\n instructions: Vec::new(),\n instruction_pointer: None,\n current_depth: 0,\n status: ProgramStatus::Normal,\n }\n }\n\n\n pub fn append(&mut self, instructions: &[Command]) {\n self.instructions.extend(instructions.iter().cloned());\n if self.instruction_pointer.is_none() {\n self.instruction_pointer = Some(0);\n }\n }\n\n\n pub fn execute(&mut self, vm: &mut VM) {\n }\n}\n"
},
{
"from": "gpt",
"value": "use command::Command;\nuse vm::VM;\n\n\npub struct Program {\n instructions: Vec<Command>,\n instruction_pointer: Option<usize>,\n current_depth: u64,\n pub status: ProgramStatus,\n}\n\n#[derive(Clone, Copy, PartialEq, Debug)]\npub enum ProgramStatus {\n Normal,\n Seeking(u64),\n}\n\n\nimpl Program {\n pub fn new() -> Program {\n Program {\n instructions: Vec::new(),\n instruction_pointer: None,\n current_depth: 0,\n status: ProgramStatus::Normal,\n }\n }\n\n\n pub fn append(&mut self, instructions: &[Command]) {\n self.instructions.extend(instructions.iter().cloned());\n if self.instruction_pointer.is_none() {\n self.instruction_pointer = Some(0);\n }\n }\n\n\n pub fn execute(&mut self, vm: &mut VM) {\n match (self.instruction_pointer, self.status) {\n (Some(index), ProgramStatus::Seeking(goal)) => {}\n\n (Some(index), ProgramStatus::Normal) => {}\n\n _ => {}\n }\n }\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Remove deleted pass from rustdoc test suite\n\n`src/test/rustdoc-ui/deprecated-attrs.rs`\ntells rustdoc to run the `collapse-docs` pass, which no longer exists\n(it was removed in https://github.com/rust-lang/rust/pull/80261).\nRustdoc doesn't actually give a proper diagnostic here; instead it\nprints an `error!` log. Now that tracing is compiled unconditionally,\nthe log is now being emitted by default, because it's at the error\nlevel.\n\nrustdoc shouldn't be using `error!` logging for diagnostics in the first\nplace, but in the meantime this change gets the testsuite to pass.\n"
},
{
"from": "human",
"value": "// check-pass\n\n#![doc(no_default_passes, passes = \"collapse-docs unindent-comments\")]\n\nstruct SomeStruct;\n\npub struct OtherStruct;\n"
},
{
"from": "gpt",
"value": "// check-pass\n\n#![doc(no_default_passes, passes = \"unindent-comments\")]\n\nstruct SomeStruct;\n\npub struct OtherStruct;\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Use issue = \"none\" instead of \"0\"\n"
},
{
"from": "human",
"value": "#![feature(staged_api)]\n#![feature(test)]\n#![unstable(feature = \"test\", issue = \"0\")]\n\nextern crate test;\n\npub use test::*;\n\npub fn custom_api() {\n}\n"
},
{
"from": "gpt",
"value": "#![feature(staged_api)]\n#![feature(test)]\n#![unstable(feature = \"test\", issue = \"none\")]\n\nextern crate test;\n\npub use test::*;\n\npub fn custom_api() {\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Remove unused `fs` feature gate\n"
},
{
"from": "human",
"value": "#![feature(collections, fs, io, path)]\n\nextern crate tcod;\n\npub mod engine;\npub mod gui;\npub mod util;\n"
},
{
"from": "gpt",
"value": "#![feature(collections, io, path)]\n\nextern crate tcod;\n\npub mod engine;\npub mod gui;\npub mod util;\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Remove unused macro_rules feature attribute\n"
},
{
"from": "human",
"value": "#![feature(macro_rules)]\n#![feature(unboxed_closures)]\n\nuse std::fmt;\n\npub use api::IntoLogger;\npub use api::Logger;\npub use config::Logger as LoggerConfig;\npub use config::Output as LoggerOutput;\n\nmod config;\nmod api;\nmod loggers;\n\npub enum Level {\n Debug,\n Info,\n Warning,\n Error,\n Critical,\n}\n\nimpl Copy for Level {}\n\nimpl Level {\n pub fn as_int(&self) -> u8 {\n match self {\n &Level::Debug => 0u8,\n &Level::Info => 1u8,\n &Level::Warning => 2u8,\n &Level::Error => 3u8,\n &Level::Critical => 4u8,\n }\n }\n}\n\nimpl fmt::Show for Level {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n return write!(f, \"{}\", match self {\n &Level::Debug => \"DEBUG\",\n &Level::Info => \"INFO\",\n &Level::Warning => \"WARNING\",\n &Level::Error => \"ERROR\",\n &Level::Critical => \"CRITICAL\",\n });\n }\n}\n"
},
{
"from": "gpt",
"value": "#![feature(unboxed_closures)]\n\nuse std::fmt;\n\npub use api::IntoLogger;\npub use api::Logger;\npub use config::Logger as LoggerConfig;\npub use config::Output as LoggerOutput;\n\nmod config;\nmod api;\nmod loggers;\n\npub enum Level {\n Debug,\n Info,\n Warning,\n Error,\n Critical,\n}\n\nimpl Copy for Level {}\n\nimpl Level {\n pub fn as_int(&self) -> u8 {\n match self {\n &Level::Debug => 0u8,\n &Level::Info => 1u8,\n &Level::Warning => 2u8,\n &Level::Error => 3u8,\n &Level::Critical => 4u8,\n }\n }\n}\n\nimpl fmt::Show for Level {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n return write!(f, \"{}\", match self {\n &Level::Debug => \"DEBUG\",\n &Level::Info => \"INFO\",\n &Level::Warning => \"WARNING\",\n &Level::Error => \"ERROR\",\n &Level::Critical => \"CRITICAL\",\n });\n }\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Use the `$crate` inside `skip_bytes`\n\nThis will allow anyone to use the macro without needing to import\n`IResult`, `Err`, or `ErrorCode`.\n"
},
{
"from": "human",
"value": "macro_rules! skip_bytes (\n ($input: expr, $length: expr, $offset: expr) => (\n {\n match take!($input, $length) {\n IResult::Done(i, bytes) => {\n let head = bytes[0] << $offset;\n let tail = &bytes[1..];\n let is_all_zero = tail.iter().all(|byte| *byte == 0);\n\n if head == 0 && is_all_zero {\n IResult::Done(i, bytes)\n } else {\n IResult::Error(Err::Position(ErrorCode::Digit as u32, $input))\n }\n }\n IResult::Error(error) => IResult::Error(error),\n IResult::Incomplete(need) => IResult::Incomplete(need),\n }\n }\n );\n);\n"
},
{
"from": "gpt",
"value": "macro_rules! skip_bytes (\n ($input: expr, $length: expr, $offset: expr) => (\n {\n match take!($input, $length) {\n $crate::nom::IResult::Done(i, bytes) => {\n let head = bytes[0] << $offset;\n let tail = &bytes[1..];\n let is_all_zero = tail.iter().all(|byte| *byte == 0);\n\n if head == 0 && is_all_zero {\n $crate::nom::IResult::Done(i, bytes)\n } else {\n $crate::nom::IResult::Error($crate::nom::Err::Position(\n $crate::nom::ErrorCode::Digit as u32, $input))\n }\n }\n $crate::nom::IResult::Error(error) =>\n $crate::nom::IResult::Error(error),\n $crate::nom::IResult::Incomplete(need) =>\n $crate::nom::IResult::Incomplete(need),\n }\n }\n );\n);\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Move IP protocols to associated constants\n"
},
{
"from": "human",
"value": "/// Represents the eight bit header field in IPv4/IPv6 that defines what protocol the payload has.\n/// See [this list] for the full definition.\n///\n/// [this list]: https://en.wikipedia.org/wiki/List_of_IP_protocol_numbers\n#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]\npub struct Protocol(pub u8);\n\nimpl Protocol {\n /// Returns the numeric representation of this protocol.\n #[inline]\n pub fn value(&self) -> u8 {\n self.0\n }\n\n pub fn is_unassigned(&self) -> bool {\n self.0 >= 143 && self.0 <= 252\n }\n\n pub fn is_experimental(&self) -> bool {\n self.0 >= 253 && self.0 <= 254\n }\n}\n\npub mod protocols {\n use super::Protocol;\n\n pub const ICMP: Protocol = Protocol(1);\n pub const TCP: Protocol = Protocol(6);\n pub const UDP: Protocol = Protocol(17);\n pub const RESERVED: Protocol = Protocol(255);\n}\n"
},
{
"from": "gpt",
"value": "/// Represents the eight bit header field in IPv4/IPv6 that defines what protocol the payload has.\n/// See [this list] for the full definition.\n///\n/// [this list]: https://en.wikipedia.org/wiki/List_of_IP_protocol_numbers\n#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]\npub struct Protocol(pub u8);\n\nimpl Protocol {\n pub const ICMP: Protocol = Protocol(1);\n pub const TCP: Protocol = Protocol(6);\n pub const UDP: Protocol = Protocol(17);\n pub const RESERVED: Protocol = Protocol(255);\n\n /// Returns the numeric representation of this protocol.\n #[inline]\n pub fn value(&self) -> u8 {\n self.0\n }\n\n pub fn is_unassigned(&self) -> bool {\n self.0 >= 143 && self.0 <= 252\n }\n\n pub fn is_experimental(&self) -> bool {\n self.0 >= 253 && self.0 <= 254\n }\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Add rustdoc for staged columns\n"
},
{
"from": "human",
"value": "//! Provides drilldown related procedures.\n//! This module will be used with `SelectCommand` type by `+` operation\n//! to concatinate `select` and `drilldown` queries.\n//!\n//! Also this module support `pseudo_table` and `staged_columns` manupilation.\n\npub mod drilldown_type;\npub mod drilldown;\npub mod labeled_drilldown;\npub mod drilldownable;\npub mod labeled_drilldownable;\npub mod labeled_drilldown_sequencable;\npub mod drilldown_builder;\npub mod labeled_drilldown_builder;\npub mod labeled_drilldown_sequence_builder;\n/// `fragmentable` module provides making query fragment operation.\n/// It is useful to make composable query elements.\n/// It makes `select` query to be composable against drilldown related query\n/// and `staged_columns` query.\npub mod fragmentable;\n/// `pseudo_table` is a trait to be used for tablable state which is appeared in\n/// \"drilldown in drilldown\".\npub mod pseudo_table;\npub mod staged_columns;\npub mod staged_columns_builder;\npub mod staged_columnable;\n"
},
{
"from": "gpt",
"value": "//! Provides drilldown related procedures.\n//! This module will be used with `SelectCommand` type by `+` operation\n//! to concatinate `select` and `drilldown` queries.\n//!\n//! Also this module support `pseudo_table` and `staged_columns` manupilation.\n\npub mod drilldown_type;\npub mod drilldown;\npub mod labeled_drilldown;\npub mod drilldownable;\npub mod labeled_drilldownable;\npub mod labeled_drilldown_sequencable;\npub mod drilldown_builder;\npub mod labeled_drilldown_builder;\npub mod labeled_drilldown_sequence_builder;\n/// `fragmentable` module provides making query fragment operation.\n/// It is useful to make composable query elements.\n/// It makes `select` query to be composable against drilldown related query\n/// and `staged_columns` query.\npub mod fragmentable;\n/// `pseudo_table` is a trait to be used for tablable state which is appeared in\n/// \"drilldown in drilldown\".\npub mod pseudo_table;\n/// `staged_columns` provides making query which supports window function syntax.\npub mod staged_columns;\npub mod staged_columns_builder;\npub mod staged_columnable;\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Use the `issue-1567` dependency in the test\n"
},
{
"from": "human",
"value": "/// Doc-test test\n/// ```rust\n/// assert!(cargo_miri_test::make_true());\n/// ```\npub fn make_true() -> bool {\n issue_1705::use_the_dependency();\n issue_1691::use_me()\n}\n"
},
{
"from": "gpt",
"value": "/// Doc-test test\n/// ```rust\n/// assert!(cargo_miri_test::make_true());\n/// ```\npub fn make_true() -> bool {\n issue_1567::use_the_dependency();\n issue_1705::use_the_dependency();\n issue_1691::use_me()\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Add current time in RequestLogger\n"
},
{
"from": "human",
"value": "extern crate iron;\nextern crate time;\n\nuse iron::prelude::*;\nuse iron::{BeforeMiddleware, AfterMiddleware, typemap};\nuse time::precise_time_ns;\n\npub struct RequestLogger;\n\nimpl typemap::Key for RequestLogger { type Value = u64; }\n\nimpl BeforeMiddleware for RequestLogger {\n fn before(&self, request: &mut Request) -> IronResult<()> {\n request.extensions.insert::<RequestLogger>(precise_time_ns());\n println!(\n \"Started {} \\\"{}\\\" for {}\",\n request.method,\n format!(\"/{}\", request.url.path().join(\"/\")),\n request.remote_addr\n );\n\n Ok(())\n }\n}\n\nimpl AfterMiddleware for RequestLogger {\n fn after(&self, request: &mut Request, response: Response) -> IronResult<Response> {\n let delta = precise_time_ns() - *request.extensions.get::<RequestLogger>().unwrap();\n println!(\"Request took {} ms\", (delta as f64) / 1000000.0);\n\n Ok(response)\n }\n}\n"
},
{
"from": "gpt",
"value": "extern crate iron;\nextern crate time;\n\nuse iron::prelude::*;\nuse iron::{BeforeMiddleware, AfterMiddleware, typemap};\nuse time::precise_time_ns;\n\npub struct RequestLogger;\n\nimpl typemap::Key for RequestLogger { type Value = u64; }\n\nimpl BeforeMiddleware for RequestLogger {\n fn before(&self, request: &mut Request) -> IronResult<()> {\n request.extensions.insert::<RequestLogger>(precise_time_ns());\n println!(\n \"Started {} \\\"{}\\\" for {} at {}\",\n request.method,\n format!(\"/{}\", request.url.path().join(\"/\")),\n request.remote_addr,\n time::now().strftime(\"%+\").unwrap()\n );\n\n Ok(())\n }\n}\n\nimpl AfterMiddleware for RequestLogger {\n fn after(&self, request: &mut Request, response: Response) -> IronResult<Response> {\n let delta = precise_time_ns() - *request.extensions.get::<RequestLogger>().unwrap();\n println!(\"Request took {} ms\", (delta as f64) / 1000000.0);\n\n Ok(response)\n }\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Remove mut warning for empty macro\n"
},
{
"from": "human",
"value": "#[macro_export]\nmacro_rules! bson {\n ([$($val:tt),*]) => {{\n let mut array = Vec::new();\n\n $(\n array.push(bson!($val));\n )*\n\n $crate::Bson::Array(array)\n }};\n\n ([$val:expr]) => {{\n $crate::Bson::Array(vec!(::std::convert::From::from($val)))\n }};\n\n ({ $($k:expr => $v:tt),* }) => {{\n $crate::Bson::Document(doc! {\n $(\n $k => $v\n ),*\n })\n }};\n\n ($val:expr) => {{\n ::std::convert::From::from($val)\n }};\n}\n\n#[macro_export]\nmacro_rules! doc {\n ( $($key:expr => $val:tt),* ) => {{\n let mut document = $crate::Document::new();\n\n $(\n document.insert($key.to_owned(), bson!($val));\n )*\n\n document\n }};\n}\n"
},
{
"from": "gpt",
"value": "#[macro_export]\nmacro_rules! bson {\n ([$($val:tt),*]) => {{\n let mut array = Vec::new();\n\n $(\n array.push(bson!($val));\n )*\n\n $crate::Bson::Array(array)\n }};\n\n ([$val:expr]) => {{\n $crate::Bson::Array(vec!(::std::convert::From::from($val)))\n }};\n\n ({ $($k:expr => $v:tt),* }) => {{\n $crate::Bson::Document(doc! {\n $(\n $k => $v\n ),*\n })\n }};\n\n ($val:expr) => {{\n ::std::convert::From::from($val)\n }};\n}\n\n#[macro_export]\nmacro_rules! doc {\n () => {{ $crate::Document::new() }};\n\n ( $($key:expr => $val:tt),* ) => {{\n let mut document = $crate::Document::new();\n\n $(\n document.insert($key.to_owned(), bson!($val));\n )*\n\n document\n }};\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Fix SOAP request mime type\n"
},
{
"from": "human",
"value": "use hyper::header::{CONTENT_LENGTH, CONTENT_TYPE};\nuse hyper::{Request, Body, client::Client};\n\nuse crate::errors::RequestError;\n\n#[derive(Clone, Debug)]\npub struct Action(String);\n\nimpl Action {\n pub fn new(action: &str) -> Action {\n Action(action.into())\n }\n}\n\nconst HEADER_NAME: &str = \"SOAPAction\";\n\npub async fn send_async(\n url: &str,\n action: Action,\n body: &str,\n) -> Result<String, RequestError> {\n\n let client = Client::new();\n\n let req = Request::builder()\n .uri(url)\n .method(\"POST\")\n .header(HEADER_NAME, action.0)\n .header(CONTENT_TYPE, \"xml\")\n .header(CONTENT_LENGTH, body.len() as u64)\n .body(Body::from(body.to_string()))?;\n\n let resp = client.request(req).await?;\n let body = hyper::body::to_bytes(resp.into_body()).await?;\n let string = String::from_utf8(body.to_vec())?;\n Ok(string)\n}\n"
},
{
"from": "gpt",
"value": "use hyper::header::{CONTENT_LENGTH, CONTENT_TYPE};\nuse hyper::{Request, Body, client::Client};\n\nuse crate::errors::RequestError;\n\n#[derive(Clone, Debug)]\npub struct Action(String);\n\nimpl Action {\n pub fn new(action: &str) -> Action {\n Action(action.into())\n }\n}\n\nconst HEADER_NAME: &str = \"SOAPAction\";\n\npub async fn send_async(\n url: &str,\n action: Action,\n body: &str,\n) -> Result<String, RequestError> {\n\n let client = Client::new();\n\n let req = Request::builder()\n .uri(url)\n .method(\"POST\")\n .header(HEADER_NAME, action.0)\n .header(CONTENT_TYPE, \"text/xml\")\n .header(CONTENT_LENGTH, body.len() as u64)\n .body(Body::from(body.to_string()))?;\n\n let resp = client.request(req).await?;\n let body = hyper::body::to_bytes(resp.into_body()).await?;\n let string = String::from_utf8(body.to_vec())?;\n Ok(string)\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Write tests for the flag collection utility.\n"
},
{
"from": "human",
"value": "// Copyright 2020 Google LLC\n//\n// Use of this source code is governed by an MIT-style license that can be found\n// in the LICENSE file or at https://opensource.org/licenses/MIT.\n\nuse std::path::Path;\n\npub fn flags<P>(path: P) -> std::io::Result<u32> where\n P: AsRef<Path>\n{\n let file = std::fs::File::open(path)?;\n\n let mut flags = 0;\n let code = unsafe {\n use std::os::unix::io::AsRawFd as _;\n ioctls::fs_ioc_getflags(file.as_raw_fd(), &mut flags)\n };\n\n if code == 0 {\n Ok(flags as u32)\n } else {\n Err(std::io::Error::from_raw_os_error(code))\n }\n}\n"
},
{
"from": "gpt",
"value": "// Copyright 2020 Google LLC\n//\n// Use of this source code is governed by an MIT-style license that can be found\n// in the LICENSE file or at https://opensource.org/licenses/MIT.\n\nuse std::path::Path;\n\npub fn flags<P>(path: P) -> std::io::Result<u32> where\n P: AsRef<Path>\n{\n let file = std::fs::File::open(path)?;\n\n let mut flags = 0;\n let code = unsafe {\n use std::os::unix::io::AsRawFd as _;\n ioctls::fs_ioc_getflags(file.as_raw_fd(), &mut flags)\n };\n\n if code == 0 {\n Ok(flags as u32)\n } else {\n Err(std::io::Error::from_raw_os_error(code))\n }\n}\n\n#[cfg(test)]\nmod tests {\n\n use std::fs::File;\n\n use super::*;\n\n #[test]\n fn test_flags_non_existing() {\n let tempdir = tempfile::tempdir().unwrap();\n\n assert!(flags(tempdir.path().join(\"foo\")).is_err());\n }\n\n #[test]\n fn test_flags_noatime() {\n // https://elixir.bootlin.com/linux/v5.8.14/source/include/uapi/linux/fs.h#L245\n const FS_NOATIME_FL: std::os::raw::c_long = 0x00000080;\n\n let tempdir = tempfile::tempdir().unwrap();\n let tempfile = File::create(tempdir.path().join(\"foo\")).unwrap();\n\n unsafe {\n use std::os::unix::io::AsRawFd as _;\n let fd = tempfile.as_raw_fd();\n\n assert_eq!(ioctls::fs_ioc_setflags(fd, &FS_NOATIME_FL), 0);\n }\n\n let flags = flags(tempdir.path().join(\"foo\")).unwrap();\n assert_eq!(flags & FS_NOATIME_FL as u32, FS_NOATIME_FL as u32);\n }\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": ":sparkles: Make possible to load config file\n\n"
},
{
"from": "human",
"value": "extern crate toml;\nuse config::Config;\n\npub struct Workflow {\n config: Config,\n}\n\npub fn new() -> Workflow {\n let config = load_config();\n Workflow {\n config: config,\n }\n}\n\nfn load_config() -> Result<Config, String> {\n let mut config_file: String = env::home_dir().unwrap();\n config_file.push(\".jiraconfig\");\n\n match toml::from_str(&config_file) {\n Ok(c) => c,\n Err(_) => Err(\"Failed load config file\")\n }\n}"
},
{
"from": "gpt",
"value": "extern crate toml;\nuse config::Config;\nuse std::env;\nuse std::fs::File;\nuse std::io::Read;\n\npub struct Workflow {\n config: Config,\n}\n\npub fn new() -> Workflow {\n let config = load_config().unwrap();\n Workflow {\n config: config,\n }\n}\n\nfn load_config() -> Result<Config, String> {\n let mut config_file = env::home_dir().unwrap();\n config_file.push(\".jiraconfig\");\n let mut file = File::open(&config_file).expect(\"open config file\");\n\n let mut toml_string = String::new();\n file.read_to_string(&mut toml_string).unwrap();\n\n match toml::from_str(&toml_string) {\n Ok(c) => c,\n Err(_) => Err(\"Failed load config file\".to_string())\n }\n}"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Make CachedStateFlags u8 to save space in jit_cache_array\n"
},
{
"from": "human",
"value": "#[derive(Copy, Clone, PartialEq, Eq)]\npub struct CachedStateFlags(u32);\n\nimpl CachedStateFlags {\n const MASK_IS_32: u32 = 1 << 0;\n const MASK_SS32: u32 = 1 << 1;\n const MASK_CPL3: u32 = 1 << 2;\n const MASK_FLAT_SEGS: u32 = 1 << 3;\n\n pub const EMPTY: CachedStateFlags = CachedStateFlags(0);\n\n pub fn of_u32(f: u32) -> CachedStateFlags { CachedStateFlags(f) }\n pub fn to_u32(&self) -> u32 { self.0 }\n\n pub fn cpl3(&self) -> bool { self.0 & CachedStateFlags::MASK_CPL3 != 0 }\n pub fn has_flat_segmentation(&self) -> bool { self.0 & CachedStateFlags::MASK_FLAT_SEGS != 0 }\n pub fn is_32(&self) -> bool { self.0 & CachedStateFlags::MASK_IS_32 != 0 }\n pub fn ssize_32(&self) -> bool { self.0 & CachedStateFlags::MASK_SS32 != 0 }\n}\n"
},
{
"from": "gpt",
"value": "#[derive(Copy, Clone, PartialEq, Eq)]\npub struct CachedStateFlags(u8);\n\nimpl CachedStateFlags {\n const MASK_IS_32: u8 = 1 << 0;\n const MASK_SS32: u8 = 1 << 1;\n const MASK_CPL3: u8 = 1 << 2;\n const MASK_FLAT_SEGS: u8 = 1 << 3;\n\n pub const EMPTY: CachedStateFlags = CachedStateFlags(0);\n\n pub fn of_u32(f: u32) -> CachedStateFlags { CachedStateFlags(f as u8) }\n pub fn to_u32(&self) -> u32 { self.0 as u32 }\n\n pub fn cpl3(&self) -> bool { self.0 & CachedStateFlags::MASK_CPL3 != 0 }\n pub fn has_flat_segmentation(&self) -> bool { self.0 & CachedStateFlags::MASK_FLAT_SEGS != 0 }\n pub fn is_32(&self) -> bool { self.0 & CachedStateFlags::MASK_IS_32 != 0 }\n pub fn ssize_32(&self) -> bool { self.0 & CachedStateFlags::MASK_SS32 != 0 }\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Implement reading one character (bump)\n"
},
{
"from": "human",
"value": "pub fn compile(sass: String, style: &str) -> String {\n let parsed = SassReader::new(sass).parse();\n match style {\n \"nested\" => nested(parsed),\n \"compressed\" => compressed(parsed),\n \"expanded\" => expanded(parsed),\n \"compact\" => compact(parsed),\n _ => panic!(\"Unknown style: {}. Please specify one of nested, compressed, expanded, or compact.\", style),\n }\n}\n\nfn nested(sass: String) -> String {\n sass\n}\n\nfn compressed(sass: String) -> String {\n sass.replace(\" \", \"\").replace(\"\\n\", \"\")\n}\n\nfn expanded(sass: String) -> String {\n sass\n}\n\nfn compact(sass: String) -> String {\n sass\n}\n\nstruct SassReader {\n pub pos: u32,\n pub last_pos: u32,\n pub curr: Option<char>,\n sass: String,\n}\n\nimpl SassReader {\n pub fn new(str: String) -> SassReader {\n SassReader {\n pos: 0,\n last_pos: 0,\n curr: Some('\\n'),\n sass: str,\n }\n }\n\n pub fn parse(self) -> String {\n self.sass\n }\n}"
},
{
"from": "gpt",
"value": "pub fn compile(sass: String, style: &str) -> String {\n let sr = SassReader::new(sass);\n println!(\"{:?}\", sr);\n let parsed = sr.parse();\n match style {\n \"nested\" => nested(parsed),\n \"compressed\" => compressed(parsed),\n \"expanded\" => expanded(parsed),\n \"compact\" => compact(parsed),\n _ => panic!(\"Unknown style: {}. Please specify one of nested, compressed, expanded, or compact.\", style),\n }\n}\n\nfn nested(sass: String) -> String {\n sass\n}\n\nfn compressed(sass: String) -> String {\n sass.replace(\" \", \"\").replace(\"\\n\", \"\")\n}\n\nfn expanded(sass: String) -> String {\n sass\n}\n\nfn compact(sass: String) -> String {\n sass\n}\n\n#[derive(Debug)]\nstruct SassReader {\n pub pos: u32,\n pub last_pos: u32,\n pub curr: Option<char>,\n sass: String,\n}\n\nimpl SassReader {\n pub fn new(str: String) -> SassReader {\n let mut sr = SassReader {\n pos: 0,\n last_pos: 0,\n curr: Some('\\n'),\n sass: str,\n };\n sr.bump();\n sr\n }\n\n pub fn bump(&mut self) {\n self.last_pos = self.pos;\n let current_pos = self.pos as usize;\n if current_pos < self.sass.len() {\n let ch = char_at(&self.sass, current_pos);\n\n self.pos = self.pos + (ch.len_utf8() as u32);\n self.curr = Some(ch);\n } else {\n self.curr = None;\n }\n }\n\n pub fn parse(self) -> String {\n self.sass\n }\n}\n\npub fn char_at(s: &str, byte: usize) -> char {\n s[byte..].chars().next().unwrap()\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Add documentation for type information of iter\n"
},
{
"from": "human",
"value": "//! An implementation of [FLAC](https://xiph.org/flac), free lossless audio\n//! codec, written in Rust.\n//!\n//! The code is available on [GitHub](https://github.com/sourrust/flac).\n//!\n//! # Examples\n//!\n//! Basic decoding from a file.\n//!\n//! ```\n//! use flac::StreamReader;\n//! use std::fs::File;\n//!\n//! match StreamReader::<File>::from_file(\"path/to/file.flac\") {\n//! Ok(mut stream) => {\n//! // Copy of `StreamInfo` to help convert to a different audio format.\n//! let info = stream.info();\n//!\n//! for sample in stream.iter::<i16>() {\n//! // Iterate over each decoded sample\n//! }\n//! }\n//! Err(error) => println!(\"{:?}\", error),\n//! }\n//! ```\n\n#[macro_use]\nextern crate nom;\n\n#[macro_use]\nmod utility;\nmod frame;\nmod subframe;\npub mod metadata;\npub mod stream;\n\npub use metadata::Metadata;\npub use stream::{Stream, StreamBuffer, StreamReader};\npub use utility::{\n Sample, SampleSize,\n StreamProducer, ReadStream, ByteStream,\n ErrorKind\n};\n"
},
{
"from": "gpt",
"value": "//! An implementation of [FLAC](https://xiph.org/flac), free lossless audio\n//! codec, written in Rust.\n//!\n//! The code is available on [GitHub](https://github.com/sourrust/flac).\n//!\n//! # Examples\n//!\n//! Basic decoding from a file.\n//!\n//! ```\n//! use flac::StreamReader;\n//! use std::fs::File;\n//!\n//! match StreamReader::<File>::from_file(\"path/to/file.flac\") {\n//! Ok(mut stream) => {\n//! // Copy of `StreamInfo` to help convert to a different audio format.\n//! let info = stream.info();\n//!\n//! // The explicit size for `Stream::iter` is the resulting decoded\n//! // sample. You can usually find out the desired size of the\n//! // samples with `info.bits_per_sample`.\n//! for sample in stream.iter::<i16>() {\n//! // Iterate over each decoded sample\n//! }\n//! }\n//! Err(error) => println!(\"{:?}\", error),\n//! }\n//! ```\n\n#[macro_use]\nextern crate nom;\n\n#[macro_use]\nmod utility;\nmod frame;\nmod subframe;\npub mod metadata;\npub mod stream;\n\npub use metadata::Metadata;\npub use stream::{Stream, StreamBuffer, StreamReader};\npub use utility::{\n Sample, SampleSize,\n StreamProducer, ReadStream, ByteStream,\n ErrorKind\n};\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Make Rsp a unit struct\n"
},
{
"from": "human",
"value": "#[derive(Default)]\npub struct Rsp {\n _dummy: i32\n}\n\nimpl Rsp {\n // TODO: Read general regs\n pub fn read_status_reg(&self) -> u32 {\n 0 // TODO: Properly implement this\n }\n}\n"
},
{
"from": "gpt",
"value": "#[derive(Default)]\npub struct Rsp;\n\nimpl Rsp {\n // TODO: Read general regs\n pub fn read_status_reg(&self) -> u32 {\n 0 // TODO: Properly implement this\n }\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Add note about using different hashers\n"
},
{
"from": "human",
"value": "use std::collections::HashMap;\n\nfn main() {\n let mut scores = HashMap::new();\n scores.insert(String::from(\"Blue\"), 10);\n scores.insert(String::from(\"Yellow\"), 50);\n\n let teams = vec![String::from(\"Blue\"), String::from(\"Yellow\")];\n let initial_scores = vec![10, 50];\n\n let different_scores: HashMap<_, _> = teams.iter().zip(initial_scores.iter()).collect();\n\n // Hash map becomes the owner of values used during inserting\n\n let team_name = String::from(\"Blue\");\n let score = different_scores.get(&team_name);\n\n for (key, value) in &different_scores {\n println!(\"{}: {}\", key, value);\n }\n\n // Insert overwrites things by default\n\n scores.entry(String::from(\"Blue\")).or_insert(100);\n scores.entry(String::from(\"Red\")).or_insert(200);\n\n println!(\"{:?}\", scores);\n\n let text = \"hello wonderful world world\";\n\n let mut map = HashMap::new();\n\n for word in text.split_whitespace() {\n let count = map.entry(word).or_insert(0)\n *count += 1;\n }\n\n println!(\"{:?}\", map);\n}\n"
},
{
"from": "gpt",
"value": "use std::collections::HashMap;\n\nfn main() {\n let mut scores = HashMap::new();\n scores.insert(String::from(\"Blue\"), 10);\n scores.insert(String::from(\"Yellow\"), 50);\n\n let teams = vec![String::from(\"Blue\"), String::from(\"Yellow\")];\n let initial_scores = vec![10, 50];\n\n let different_scores: HashMap<_, _> = teams.iter().zip(initial_scores.iter()).collect();\n\n // Hash map becomes the owner of values used during inserting\n\n let team_name = String::from(\"Blue\");\n let score = different_scores.get(&team_name);\n\n for (key, value) in &different_scores {\n println!(\"{}: {}\", key, value);\n }\n\n // Insert overwrites things by default\n\n scores.entry(String::from(\"Blue\")).or_insert(100);\n scores.entry(String::from(\"Red\")).or_insert(200);\n\n println!(\"{:?}\", scores);\n\n let text = \"hello wonderful world world\";\n\n let mut map = HashMap::new();\n\n for word in text.split_whitespace() {\n let count = map.entry(word).or_insert(0)\n *count += 1;\n }\n\n println!(\"{:?}\", map);\n\n // It's possible to use different hasher than default one\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Remove unnecessary type hint from RNA Transcription\n"
},
{
"from": "human",
"value": "use std::iter::FromIterator;\n\n#[derive(PartialEq, Debug)]\npub struct RibonucleicAcid(String);\n\nimpl RibonucleicAcid {\n pub fn new(rna: &str) -> RibonucleicAcid {\n RibonucleicAcid(rna.into())\n }\n}\n\nimpl FromIterator<char> for RibonucleicAcid {\n fn from_iter<I: IntoIterator<Item=char>>(iter: I) -> Self {\n RibonucleicAcid(iter.into_iter().collect())\n }\n}\n\n#[derive(PartialEq, Debug)]\npub struct DeoxyribonucleicAcid(String);\n\nimpl DeoxyribonucleicAcid {\n pub fn new(dna: &str) -> DeoxyribonucleicAcid {\n DeoxyribonucleicAcid(dna.into())\n }\n\n pub fn to_rna(&self) -> Result<RibonucleicAcid, &'static str> {\n self.0.chars().map(|c| match c {\n 'G' => Ok('C'),\n 'C' => Ok('G'),\n 'T' => Ok('A'),\n 'A' => Ok('U'),\n _ => Err(\"Invalid DNA strand\")\n }).collect::<Result<_, _>>()\n }\n}\n"
},
{
"from": "gpt",
"value": "use std::iter::FromIterator;\n\n#[derive(PartialEq, Debug)]\npub struct RibonucleicAcid(String);\n\nimpl RibonucleicAcid {\n pub fn new(rna: &str) -> RibonucleicAcid {\n RibonucleicAcid(rna.into())\n }\n}\n\nimpl FromIterator<char> for RibonucleicAcid {\n fn from_iter<I: IntoIterator<Item=char>>(iter: I) -> Self {\n RibonucleicAcid(iter.into_iter().collect())\n }\n}\n\n#[derive(PartialEq, Debug)]\npub struct DeoxyribonucleicAcid(String);\n\nimpl DeoxyribonucleicAcid {\n pub fn new(dna: &str) -> DeoxyribonucleicAcid {\n DeoxyribonucleicAcid(dna.into())\n }\n\n pub fn to_rna(&self) -> Result<RibonucleicAcid, &'static str> {\n self.0.chars().map(|c| match c {\n 'G' => Ok('C'),\n 'C' => Ok('G'),\n 'T' => Ok('A'),\n 'A' => Ok('U'),\n _ => Err(\"Invalid DNA strand\")\n }).collect()\n }\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Add `black_box` calls to avoid f64 generation disappearing.\n\nThe final steps of generating an `f64` are fairly pure, and LLVM can see\nthis, so it just removes it, since the result is unused. The `black_box`\nfunction is designed to manually overcome this, making the benchmarks\nmore representative.\n\nBefore:\n\n test bench_isaac64_1_000_000_rands ... bench: 6028930 ns/iter (+/- 133191)\n test bench_mt19937_1_000_000_rands ... bench: 1538384 ns/iter (+/- 43405)\n test bench_xor_1_000_000_rands ... bench: 2368067 ns/iter (+/- 68618)\n\nAfter:\n\n test bench_isaac64_1_000_000_rands ... bench: 6580334 ns/iter (+/- 199685)\n test bench_mt19937_1_000_000_rands ... bench: 3216404 ns/iter (+/- 84669)\n test bench_xor_1_000_000_rands ... bench: 4135769 ns/iter (+/- 175282)\n"
},
{
"from": "human",
"value": "extern crate dsfmt;\nextern crate test;\n\nuse test::Bencher;\n\nuse std::rand::{Rng, SeedableRng, Isaac64Rng, XorShiftRng};\nuse dsfmt::DSFMTRng;\n\n#[bench]\nfn bench_mt19937_1_000_000_rands(b: &mut Bencher){\n let mut rng: DSFMTRng = SeedableRng::from_seed(1);\n\n b.iter(||{\n for _ in range(1u, 1_000_000){\n rng.next_f64();\n }\n });\n}\n\n#[bench]\nfn bench_isaac64_1_000_000_rands(b: &mut Bencher){\n let mut rng: Isaac64Rng = SeedableRng::from_seed([1u64].as_slice());\n\n b.iter(||{\n for _ in range(1u, 1_000_000){\n rng.next_f64();\n }\n });\n}\n\n#[bench]\nfn bench_xor_1_000_000_rands(b: &mut Bencher){\n let mut rng: XorShiftRng = SeedableRng::from_seed([1u32, 1u32, 1u32, 1u32]);\n\n b.iter(||{\n for _ in range(1u, 1_000_000){\n rng.next_f64();\n }\n });\n}\n"
},
{
"from": "gpt",
"value": "extern crate dsfmt;\nextern crate test;\n\nuse test::Bencher;\n\nuse std::rand::{Rng, SeedableRng, Isaac64Rng, XorShiftRng};\nuse dsfmt::DSFMTRng;\n\n#[bench]\nfn bench_mt19937_1_000_000_rands(b: &mut Bencher){\n let mut rng: DSFMTRng = SeedableRng::from_seed(1);\n\n b.iter(||{\n for _ in range(1u, 1_000_000){\n test::black_box(rng.next_f64());\n }\n });\n}\n\n#[bench]\nfn bench_isaac64_1_000_000_rands(b: &mut Bencher){\n let mut rng: Isaac64Rng = SeedableRng::from_seed([1u64].as_slice());\n\n b.iter(||{\n for _ in range(1u, 1_000_000){\n test::black_box(rng.next_f64());\n }\n });\n}\n\n#[bench]\nfn bench_xor_1_000_000_rands(b: &mut Bencher){\n let mut rng: XorShiftRng = SeedableRng::from_seed([1u32, 1u32, 1u32, 1u32]);\n\n b.iter(||{\n for _ in range(1u, 1_000_000){\n test::black_box(rng.next_f64());\n }\n });\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Add Bpchar type aliased to VarChar\n"
},
{
"from": "human",
"value": "mod array;\npub mod date_and_time;\npub mod floats;\nmod integers;\nmod primitives;\n#[cfg(feature = \"uuid\")]\nmod uuid;\n\n#[doc(hidden)]\npub mod sql_types {\n #[derive(Debug, Clone, Copy, Default)] pub struct Oid;\n #[derive(Debug, Clone, Copy, Default)] pub struct Array<T>(T);\n pub type SmallSerial = ::types::SmallInt;\n pub type Serial = ::types::Integer;\n pub type BigSerial = ::types::BigInt;\n #[cfg(feature = \"uuid\")]\n #[derive(Debug, Clone, Copy, Default)] pub struct Uuid;\n pub type Bytea = ::types::Binary;\n}\n"
},
{
"from": "gpt",
"value": "mod array;\npub mod date_and_time;\npub mod floats;\nmod integers;\nmod primitives;\n#[cfg(feature = \"uuid\")]\nmod uuid;\n\n#[doc(hidden)]\npub mod sql_types {\n #[derive(Debug, Clone, Copy, Default)] pub struct Oid;\n #[derive(Debug, Clone, Copy, Default)] pub struct Array<T>(T);\n pub type SmallSerial = ::types::SmallInt;\n pub type Serial = ::types::Integer;\n pub type BigSerial = ::types::BigInt;\n #[cfg(feature = \"uuid\")]\n #[derive(Debug, Clone, Copy, Default)] pub struct Uuid;\n pub type Bytea = ::types::Binary;\n pub type Bpchar = ::types::VarChar;\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Fix comment referring to formerly-above code\n"
},
{
"from": "human",
"value": "use crate::rc::Rc;\nuse crate::sync::Arc;\nuse core::panic::{RefUnwindSafe, UnwindSafe};\n\n// not covered via the Shared impl above b/c the inner contents use\n// Cell/AtomicUsize, but the usage here is unwind safe so we can lift the\n// impl up one level to Arc/Rc itself\n#[stable(feature = \"catch_unwind\", since = \"1.9.0\")]\nimpl<T: RefUnwindSafe + ?Sized> UnwindSafe for Rc<T> {}\n#[stable(feature = \"catch_unwind\", since = \"1.9.0\")]\nimpl<T: RefUnwindSafe + ?Sized> UnwindSafe for Arc<T> {}\n"
},
{
"from": "gpt",
"value": "use crate::rc::Rc;\nuse crate::sync::Arc;\nuse core::panic::{RefUnwindSafe, UnwindSafe};\n\n// not covered via the Shared impl in libcore b/c the inner contents use\n// Cell/AtomicUsize, but the usage here is unwind safe so we can lift the\n// impl up one level to Arc/Rc itself\n#[stable(feature = \"catch_unwind\", since = \"1.9.0\")]\nimpl<T: RefUnwindSafe + ?Sized> UnwindSafe for Rc<T> {}\n#[stable(feature = \"catch_unwind\", since = \"1.9.0\")]\nimpl<T: RefUnwindSafe + ?Sized> UnwindSafe for Arc<T> {}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Add a log (MessageList) to the Game\n"
},
{
"from": "human",
"value": "use engine::World;\n\npub struct Game {\n pub world: World,\n}\n\nimpl Game {\n\n pub fn new() -> Game {\n Game {\n world: World::new(),\n }\n }\n\n pub fn step(&mut self) {\n\n }\n\n}\n"
},
{
"from": "gpt",
"value": "use engine::{MessageList, World};\n\npub struct Game {\n pub world: World,\n pub log: MessageList,\n}\n\nimpl Game {\n\n pub fn new() -> Game {\n Game {\n world: World::new(),\n log: MessageList::new(),\n }\n }\n\n pub fn step(&mut self) {\n\n }\n\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Implement IntoSV for Option<T: IntoSV>\n"
},
{
"from": "human",
"value": "//! Traits for converting to and from Perl scalars.\n\nuse std::fmt::Display;\nuse raw;\nuse SV;\n\n/// Fast unsafe conversion from raw SV pointer.\npub trait FromSV {\n /// Perform the conversion.\n unsafe fn from_sv(pthx: raw::Interpreter, raw: *mut raw::SV) -> Self;\n}\n\n/// Construct new `SV` from `self`.\npub trait IntoSV {\n /// Perform the conversion.\n fn into_sv(self, pthx: raw::Interpreter) -> SV;\n}\n\n/// Attempt unsafe conversion from a raw SV pointer.\npub trait TryFromSV: Sized {\n /// The type returned in the event of a conversion error.\n type Error: Display;\n /// Perform the conversion.\n unsafe fn try_from_sv(pthx: raw::Interpreter, raw: *mut raw::SV) -> Result<Self, Self::Error>;\n}\n\nimpl<T> TryFromSV for T where T: FromSV {\n type Error = &'static str;\n unsafe fn try_from_sv(pthx: raw::Interpreter, raw: *mut raw::SV) -> Result<T, Self::Error>\n {\n Ok(T::from_sv(pthx, raw))\n }\n}\n"
},
{
"from": "gpt",
"value": "//! Traits for converting to and from Perl scalars.\n\nuse std::fmt::Display;\nuse raw;\nuse SV;\n\n/// Fast unsafe conversion from raw SV pointer.\npub trait FromSV {\n /// Perform the conversion.\n unsafe fn from_sv(pthx: raw::Interpreter, raw: *mut raw::SV) -> Self;\n}\n\n/// Construct new `SV` from `self`.\npub trait IntoSV {\n /// Perform the conversion.\n fn into_sv(self, pthx: raw::Interpreter) -> SV;\n}\n\nimpl<T> IntoSV for Option<T> where T: IntoSV {\n fn into_sv(self, pthx: raw::Interpreter) -> SV {\n match self {\n Some(inner) => inner.into_sv(pthx),\n None => unsafe { SV::from_raw_owned(pthx, pthx.sv_undef()) },\n }\n }\n}\n\n/// Attempt unsafe conversion from a raw SV pointer.\npub trait TryFromSV: Sized {\n /// The type returned in the event of a conversion error.\n type Error: Display;\n /// Perform the conversion.\n unsafe fn try_from_sv(pthx: raw::Interpreter, raw: *mut raw::SV) -> Result<Self, Self::Error>;\n}\n\nimpl<T> TryFromSV for T where T: FromSV {\n type Error = &'static str;\n unsafe fn try_from_sv(pthx: raw::Interpreter, raw: *mut raw::SV) -> Result<T, Self::Error>\n {\n Ok(T::from_sv(pthx, raw))\n }\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Make the QT location more dynamic\n\n"
},
{
"from": "human",
"value": "fn main() {\n println!(\"cargo:rustc-link-search=framework=/usr/local/opt/qt5/Frameworks\");\n println!(\"cargo:rustc-link-lib=c++\");\n}\n"
},
{
"from": "gpt",
"value": "use std::env;\nuse std::env::consts;\n\n\nfn main() {\n\n // We use the QTDIR or QTDIR64 env variables to find the location of\n // Qt5. If these are not set, we use the default homebrew install\n // location.\n let qtdir_variable = match consts::ARCH {\n \"x86_64\" => \"QTDIR64\",\n _ => \"QTDIR\",\n };\n let qt5_location = env::var(qtdir_variable).unwrap_or(String::from(\"/usr/local/opt/qt5\"));\n\n println!(\"cargo:rustc-link-search=framework={}/Frameworks\", qt5_location);\n println!(\"cargo:rustc-link-lib=c++\");\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Fix wrong inner comment in evallib\n"
},
{
"from": "human",
"value": "/// Modules to help creating a problem.\n///\n/// TODO\n\npub mod autoio;\npub mod batch;\npub mod bios;\npub mod dce;\npub mod diff;\npub mod make;\n"
},
{
"from": "gpt",
"value": "//! Modules to help creating a problem.\n//!\n//! TODO\n\npub mod autoio;\npub mod batch;\npub mod bios;\npub mod dce;\npub mod diff;\npub mod make;\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Print the usage if the command is bad.\n"
},
{
"from": "human",
"value": "use getopts::{getopts};\nuse help;\n\nfn verify_command(command: &str) -> bool {\n match command {\n \"new\" => true,\n \"open\" => true,\n _ => false\n }\n}\n\nfn run_command(command: &str) {\n println!(\"{}\", command);\n}\n\npub fn init(args: Vec<String>) {\n let program = args[0].clone();\n let opts = help::opts();\n\n let matches = match getopts(args.tail(), opts) {\n Ok(m) => { m }\n Err(f) => { fail!(f.to_string()) }\n };\n\n if matches.opt_present(\"h\") {\n help::print_usage(program.as_slice(), opts);\n return;\n }\n\n let input = if !matches.free.is_empty() {\n matches.free[0].clone()\n } else {\n help::print_usage(program.as_slice(), opts);\n return;\n };\n\n if !verify_command(input.as_slice()) {\n return;\n }\n\n run_command(input.as_slice());\n}\n\n#[test]\nfn verify_command_new_returns_true() {\n assert_eq!(verify_command(\"new\"), true);\n}\n\n#[test]\nfn verify_command_open_returns_true() {\n assert_eq!(verify_command(\"open\"), true);\n}\n\n#[test]\nfn verify_command_value_returns_false() {\n assert_eq!(verify_command(\"value\"), false);\n}\n\n"
},
{
"from": "gpt",
"value": "use getopts::{getopts};\nuse help;\n\nfn verify_command(command: &str) -> bool {\n match command {\n \"new\" => true,\n \"open\" => true,\n _ => false\n }\n}\n\nfn run_command(command: &str) {\n println!(\"{}\", command);\n}\n\npub fn init(args: Vec<String>) {\n let program = args[0].clone();\n let opts = help::opts();\n\n let matches = match getopts(args.tail(), opts) {\n Ok(m) => { m }\n Err(f) => { fail!(f.to_string()) }\n };\n\n if matches.opt_present(\"h\") {\n help::print_usage(program.as_slice(), opts);\n return;\n }\n\n let input = if !matches.free.is_empty() {\n matches.free[0].clone()\n } else {\n help::print_usage(program.as_slice(), opts);\n return;\n };\n\n if !verify_command(input.as_slice()) {\n help::print_usage(program.as_slice(), opts);\n return;\n }\n\n run_command(input.as_slice());\n}\n\n#[test]\nfn verify_command_new_returns_true() {\n assert_eq!(verify_command(\"new\"), true);\n}\n\n#[test]\nfn verify_command_open_returns_true() {\n assert_eq!(verify_command(\"open\"), true);\n}\n\n#[test]\nfn verify_command_value_returns_false() {\n assert_eq!(verify_command(\"value\"), false);\n}\n\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Use slices for input and output\n"
},
{
"from": "human",
"value": "\n// use std::fmt::Debug;\n\n// pub fn insertion_sort<T: Debug>(array: &mut Vec<T>) {\npub fn insertion_sort(array: &mut Vec<f64>) {\n let n = array.len();\n\n if n > 1 {\n println!(\" simplesorts::insertion_sort(): N = {:?}\", n);\n for (i,elem) in array.iter().enumerate() {\n println!(\" simplesorts::insertion_sort(): i={} {:?}\", i, elem);\n }\n }\n}\n"
},
{
"from": "gpt",
"value": "\nuse std::fmt::Debug;\n\npub fn insertion_sort<T: Clone + Debug>(input: &[T]) -> &[T] {\n let n = input.len();\n\n let output = input.clone();\n\n println!(\" simplesorts::insertion_sort(): n = {:?}\", n);\n println!(\" simplesorts::insertion_sort(): input: {:?}\", input);\n println!(\" simplesorts::insertion_sort(): output: {:?}\", output);\n\n for (i,elem) in input.iter().enumerate() {\n println!(\" simplesorts::insertion_sort(): i={} {:?}\", i, elem);\n }\n\n return output;\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Use Cryptographically Secure PRNG instead of Rng\n\nAs stated in the Rust documentation:\n\n> An application that requires an entropy source for cryptographic purposes\n> must use OsRng, which reads randomness from the source that the operating\n> system provides (e.g. /dev/urandom on Unixes or CryptGenRandom() on Windows).\n> The other random number generators provided by this module are not suitable\n> for such purposes.\n"
},
{
"from": "human",
"value": "extern crate rand;\nuse rand::Rng;\nuse std::env;\n\nconst CYPHERBYTES: usize = 32;\n\nfn main() {\n let args: Vec<_> = env::args().collect();\n if args.len() != 2 {\n println!(\"usage: {} file-to-encrypt\", args[0]);\n return\n }\n\n let mut rng = rand::thread_rng();\n\n let mut cyphertext = [0u8; CYPHERBYTES];\n rng.fill_bytes(&mut cyphertext);\n for x in &cyphertext { print!(\"{:02x}\", *x); }\n println!(\"\")\n}\n"
},
{
"from": "gpt",
"value": "extern crate rand;\nuse rand::Rng;\nuse std::env;\n\nconst CYPHERBYTES: usize = 32;\n\nfn main() {\n let args: Vec<_> = env::args().collect();\n if args.len() != 2 {\n println!(\"usage: {} file-to-encrypt\", args[0]);\n return\n }\n\n let mut csprng = match rand::OsRng::new() {\n Ok(g) => g,\n Err(e) => panic!(\"Could not find a cryptographically-secure PRNG on the system. Details: {}\", e)\n };\n\n let mut cyphertext = [0u8; CYPHERBYTES];\n csprng.fill_bytes(&mut cyphertext);\n for x in &cyphertext { print!(\"{:02x}\", *x); }\n println!(\"\")\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Remove unused arguments for the time being.\n"
},
{
"from": "human",
"value": "// STD Dependencies -----------------------------------------------------------\nuse std::fs::File;\n\n\n// Internal Dependencies ------------------------------------------------------\nuse super::{Chunk, Track};\n\n\n// Audio Writer Trait ---------------------------------------------------------\npub trait AudioWriter: Send {\n fn write_header(&mut self, &mut File, &Track);\n fn write_chunk(&mut self, &mut File, Chunk);\n}\n\n\n// Ogg Writer Implementation --------------------------------------------------\npub struct OggWriter;\n\nimpl AudioWriter for OggWriter {\n\n fn write_header(&mut self, file: &mut File, track: &Track) {\n\n }\n\n fn write_chunk(&mut self, file: &mut File, chunk: Chunk) {\n\n }\n\n}\n\n"
},
{
"from": "gpt",
"value": "// STD Dependencies -----------------------------------------------------------\nuse std::fs::File;\n\n\n// Internal Dependencies ------------------------------------------------------\nuse super::{Chunk, Track};\n\n\n// Audio Writer Trait ---------------------------------------------------------\npub trait AudioWriter: Send {\n fn write_header(&mut self, &mut File, &Track);\n fn write_chunk(&mut self, &mut File, Chunk);\n}\n\n\n// Ogg Writer Implementation --------------------------------------------------\npub struct OggWriter;\n\nimpl AudioWriter for OggWriter {\n\n fn write_header(&mut self, _: &mut File, _: &Track) {\n\n }\n\n fn write_chunk(&mut self, _: &mut File, _: Chunk) {\n\n }\n\n}\n\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Add note on why integration test is ignored, check token and expiration for instance profile integration test.\n"
},
{
"from": "human",
"value": "extern crate tokio_core;\n\nuse rusoto_credential::{InstanceMetadataProvider, ProvideAwsCredentials};\nuse std::time::Duration;\nuse tokio_core::reactor::Core;\n\n#[test]\n#[ignore]\nfn it_fetches_basic_role() {\n // set env vars to point to local provider\n let mut provider = InstanceMetadataProvider::new();\n provider.set_timeout(Duration::from_secs(5));\n provider.set_to_localhost(\"8080\");\n\n let creds_future = provider.credentials();\n let mut core = Core::new().unwrap();\n let creds = match core.run(creds_future) {\n Ok(creds) => creds,\n Err(e) => panic!(\"Got error: {:?}\", e),\n };\n\n assert_eq!(creds.aws_access_key_id(), \"Access_key_id_value\");\n assert_eq!(creds.aws_secret_access_key(), \"Secret_access_key_value\");\n}\n"
},
{
"from": "gpt",
"value": "extern crate tokio_core;\n\nuse rusoto_credential::{InstanceMetadataProvider, ProvideAwsCredentials};\nuse std::time::Duration;\nuse tokio_core::reactor::Core;\n\n// This test is marked ignored because it requires special setup.\n// It's run with the `credential_integration_test` Makefile target.\n#[test]\n#[ignore]\nfn it_fetches_basic_role() {\n // set env vars to point to local provider\n let mut provider = InstanceMetadataProvider::new();\n provider.set_timeout(Duration::from_secs(5));\n provider.set_to_localhost(\"8080\");\n\n let creds_future = provider.credentials();\n let mut core = Core::new().unwrap();\n let creds = match core.run(creds_future) {\n Ok(creds) => creds,\n Err(e) => panic!(\"Got error: {:?}\", e),\n };\n\n assert_eq!(creds.aws_access_key_id(), \"Access_key_id_value\");\n assert_eq!(creds.aws_secret_access_key(), \"Secret_access_key_value\");\n assert_eq!(creds.token().as_ref(), Some(&\"AAAAA\".to_string()));\n let dt = match creds.expires_at().as_ref() {\n Some(d) => d.to_string(),\n None => panic!(\"Expiration should be present\"),\n };\n assert_eq!(dt, \"2015-08-04 06:32:37 UTC\");\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Rename the Scene constructor to Scene::new\n"
},
{
"from": "human",
"value": "// Copyright 2013 The Servo Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\nuse color::Color;\nuse geom::size::Size2D;\nuse geom::matrix::Matrix4;\nuse layers::Layer;\nuse std::rc::Rc;\n\npub struct Scene<T> {\n pub root: Option<Rc<Layer<T>>>,\n pub size: Size2D<f32>,\n pub transform: Matrix4<f32>,\n pub background_color: Color\n}\n\npub fn Scene<T>(size: Size2D<f32>, transform: Matrix4<f32>) -> Scene<T> {\n Scene {\n root: None,\n size: size,\n transform: transform,\n background_color: Color {\n r: 0.38f32,\n g: 0.36f32,\n b: 0.36f32,\n a: 1.0f32\n }\n }\n}\n\n"
},
{
"from": "gpt",
"value": "// Copyright 2013 The Servo Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\nuse color::Color;\nuse geom::size::Size2D;\nuse geom::matrix::Matrix4;\nuse layers::Layer;\nuse std::rc::Rc;\n\npub struct Scene<T> {\n pub root: Option<Rc<Layer<T>>>,\n pub size: Size2D<f32>,\n pub transform: Matrix4<f32>,\n pub background_color: Color\n}\n\nimpl<T> Scene<T> {\n pub fn new(size: Size2D<f32>, transform: Matrix4<f32>) -> Scene<T> {\n Scene {\n root: None,\n size: size,\n transform: transform,\n background_color: Color {\n r: 0.38f32,\n g: 0.36f32,\n b: 0.36f32,\n a: 1.0f32\n }\n }\n }\n}\n\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Update rustdoc test to make it work with newly added rustc passes\n"
},
{
"from": "human",
"value": "#![crate_name = \"foo\"]\n\n#![feature(staged_api)]\n\n#[stable(feature = \"bar\", since = \"OLD 1.0\")]\npub trait Bar {}\n\n#[stable(feature = \"baz\", since = \"OLD 1.0\")]\npub trait Baz {}\n\npub struct Foo;\n\n// @has foo/trait.Bar.html '//div[@id=\"implementors-list\"]//span[@class=\"since\"]' 'NEW 2.0'\n#[stable(feature = \"foobar\", since = \"NEW 2.0\")]\nimpl Bar for Foo {}\n\n// @!has foo/trait.Baz.html '//div[@id=\"implementors-list\"]//span[@class=\"since\"]' 'OLD 1.0'\n#[stable(feature = \"foobaz\", since = \"OLD 1.0\")]\nimpl Baz for Foo {}\n"
},
{
"from": "gpt",
"value": "#![stable(feature = \"bar\", since = \"OLD 1.0\")]\n#![crate_name = \"foo\"]\n\n#![feature(staged_api)]\n\n#[stable(feature = \"bar\", since = \"OLD 1.0\")]\npub trait Bar {}\n\n#[stable(feature = \"baz\", since = \"OLD 1.0\")]\npub trait Baz {}\n\n#[stable(feature = \"baz\", since = \"OLD 1.0\")]\npub struct Foo;\n\n// @has foo/trait.Bar.html '//div[@id=\"implementors-list\"]//span[@class=\"since\"]' 'NEW 2.0'\n#[stable(feature = \"foobar\", since = \"NEW 2.0\")]\nimpl Bar for Foo {}\n\n// @!has foo/trait.Baz.html '//div[@id=\"implementors-list\"]//span[@class=\"since\"]' 'OLD 1.0'\n#[stable(feature = \"foobaz\", since = \"OLD 1.0\")]\nimpl Baz for Foo {}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Test allowing individual struct field\n"
},
{
"from": "human",
"value": " // aux-build:priv_dep.rs\n // aux-build:pub_dep.rs\n // compile-flags: --extern-private priv_dep\n#![deny(exported_private_dependencies)]\n\n// This crate is a private dependency\nextern crate priv_dep;\n// This crate is a public dependenct\nextern crate pub_dep;\n\nuse priv_dep::{OtherType, OtherTrait};\nuse pub_dep::PubType;\n\n// Type from private dependency used in private\n// type - this is fine\nstruct PrivateType {\n field: OtherType\n}\n\npub struct PublicType {\n pub field: OtherType,\n //~^ ERROR type `priv_dep::OtherType` from private dependency 'priv_dep' in public interface\n //~| WARNING this was previously accepted\n priv_field: OtherType, // Private field - this is fine\n pub other_field: PubType // Type from public dependency - this is fine\n}\n\nimpl PublicType {\n pub fn pub_fn(param: OtherType) {}\n //~^ ERROR type `priv_dep::OtherType` from private dependency 'priv_dep' in public interface\n //~| WARNING this was previously accepted\n\n fn priv_fn(param: OtherType) {}\n}\n\npub trait MyPubTrait {\n type Foo: OtherTrait;\n}\n//~^^^ ERROR trait `priv_dep::OtherTrait` from private dependency 'priv_dep' in public interface\n//~| WARNING this was previously accepted\n\n\nfn main() {}\n"
},
{
"from": "gpt",
"value": " // aux-build:priv_dep.rs\n // aux-build:pub_dep.rs\n // compile-flags: --extern-private priv_dep\n#![deny(exported_private_dependencies)]\n\n// This crate is a private dependency\nextern crate priv_dep;\n// This crate is a public dependenct\nextern crate pub_dep;\n\nuse priv_dep::{OtherType, OtherTrait};\nuse pub_dep::PubType;\n\n// Type from private dependency used in private\n// type - this is fine\nstruct PrivateType {\n field: OtherType\n}\n\npub struct PublicType {\n pub field: OtherType,\n //~^ ERROR type `priv_dep::OtherType` from private dependency 'priv_dep' in public interface\n //~| WARNING this was previously accepted\n priv_field: OtherType, // Private field - this is fine\n pub other_field: PubType // Type from public dependency - this is fine\n}\n\nimpl PublicType {\n pub fn pub_fn(param: OtherType) {}\n //~^ ERROR type `priv_dep::OtherType` from private dependency 'priv_dep' in public interface\n //~| WARNING this was previously accepted\n\n fn priv_fn(param: OtherType) {}\n}\n\npub trait MyPubTrait {\n type Foo: OtherTrait;\n}\n//~^^^ ERROR trait `priv_dep::OtherTrait` from private dependency 'priv_dep' in public interface\n//~| WARNING this was previously accepted\n\npub struct AllowedPrivType {\n #[allow(exported_private_dependencies)]\n pub allowed: OtherType\n}\n\n\n\nfn main() {}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Add some more doc on fault handling issues and lack of work stealing\n"
},
{
"from": "human",
"value": "//! The distrib module provides methods for executing the rendering in a\n//! distributed environment across multiple nodes. The worker module provides\n//! the Worker which does the actual job of rendering a subsection of the image.\n//! The master module provides the Master which instructs the Workers and collects\n//! their results.\n//!\n//! **Note:** At this time I do nothing for distributed fault handling.\n\nuse bincode::rustc_serialize::encoded_size;\n\npub use self::worker::Worker;\npub use self::master::Master;\n\npub mod worker;\npub mod master;\n\n#[derive(Debug, Clone, RustcEncodable, RustcDecodable)]\nstruct Instructions {\n pub encoded_size: u64,\n pub scene: String,\n pub frames: (usize, usize),\n pub block_start: usize,\n pub block_count: usize,\n}\n\nimpl Instructions {\n pub fn new(scene: &String, frames: (usize, usize), block_start: usize,\n block_count: usize) -> Instructions {\n let mut instr = Instructions { encoded_size: 0, scene: scene.clone(), frames: frames,\n block_start: block_start, block_count: block_count };\n instr.encoded_size = encoded_size(&instr);\n instr\n }\n}\n\n"
},
{
"from": "gpt",
"value": "//! The distrib module provides methods for executing the rendering in a\n//! distributed environment across multiple nodes. The worker module provides\n//! the Worker which does the actual job of rendering a subsection of the image.\n//! The master module provides the Master which instructs the Workers and collects\n//! their results.\n//!\n//! **Note:** At this time I do nothing for distributed fault handling or work\n//! stealing. If a node crashes during rendering it's results will be lost and the\n//! master will hang forever waiting to hear back from the crashed node.\n\nuse bincode::rustc_serialize::encoded_size;\n\npub use self::worker::Worker;\npub use self::master::Master;\n\npub mod worker;\npub mod master;\n\n#[derive(Debug, Clone, RustcEncodable, RustcDecodable)]\nstruct Instructions {\n pub encoded_size: u64,\n pub scene: String,\n pub frames: (usize, usize),\n pub block_start: usize,\n pub block_count: usize,\n}\n\nimpl Instructions {\n pub fn new(scene: &String, frames: (usize, usize), block_start: usize,\n block_count: usize) -> Instructions {\n let mut instr = Instructions { encoded_size: 0, scene: scene.clone(), frames: frames,\n block_start: block_start, block_count: block_count };\n instr.encoded_size = encoded_size(&instr);\n instr\n }\n}\n\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Test dynamic and native regexps at stage2.\n"
},
{
"from": "human",
"value": "// Copyright 2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n#[cfg(not(stage1))]\n#[phase(syntax)]\nextern crate regex_macros;\n\n// Dirty hack: During stage1, test dynamic regexs. For stage2, we test\n// native regexs.\n#[cfg(stage1)]\nmacro_rules! regex(\n ($re:expr) => (\n match ::regex::Regex::new($re) {\n Ok(re) => re,\n Err(err) => fail!(\"{}\", err),\n }\n );\n)\n\nmod bench;\nmod tests;\n\n"
},
{
"from": "gpt",
"value": "// Copyright 2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n#[cfg(not(stage1))]\n#[phase(syntax)]\nextern crate regex_macros;\n\n#[cfg(not(stage1))]\n#[path = \"bench.rs\"]\nmod native_bench;\n\n#[cfg(not(stage1))]\n#[path = \"tests.rs\"]\nmod native_tests;\n\n// Due to macro scoping rules, this definition only applies for the modules\n// defined below. Effectively, it allows us to use the same tests for both\n// native and dynamic regexes.\nmacro_rules! regex(\n ($re:expr) => (\n match ::regex::Regex::new($re) {\n Ok(re) => re,\n Err(err) => fail!(\"{}\", err),\n }\n );\n)\n\n#[path = \"bench.rs\"]\nmod dynamic_bench;\n#[path = \"tests.rs\"]\nmod dynamic_tests;\n\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Fix module name for path parameter\n"
},
{
"from": "human",
"value": "#![feature(associated_consts)]\n#![feature(type_ascription)]\n#![feature(use_extern_macros)]\n#![allow(plugin_as_library)]\n\n#[macro_use]\nextern crate tapioca;\n\ninfer_api!(httpbin, \"https://raw.githubusercontent.com/OJFord/tapioca/master/tests/schemata/httpbin.yml\");\n\nuse httpbin::status;\n\n#[test]\nfn ok_err_matching() {\n match status::get(200) {\n Ok(_) => assert!(true),\n Err(_) => assert!(false),\n }\n match status::get(400) {\n Ok(_) => assert!(false),\n Err(_) => assert!(true),\n }\n}\n\n#[test]\nfn status_body_matching() {\n match status::get(200) {\n Ok(response) => match response.body() {\n status::get::OkBody::Status200(_) => assert!(true),\n _ => assert!(false),\n },\n Err(_) => assert!(false),\n }\n}\n"
},
{
"from": "gpt",
"value": "#![feature(associated_consts)]\n#![feature(type_ascription)]\n#![feature(use_extern_macros)]\n#![allow(plugin_as_library)]\n\n#[macro_use]\nextern crate tapioca;\n\ninfer_api!(httpbin, \"https://raw.githubusercontent.com/OJFord/tapioca/master/tests/schemata/httpbin.yml\");\n\nuse httpbin::status_resource;\n\n#[test]\nfn ok_err_matching() {\n match status_resource::get(200) {\n Ok(_) => assert!(true),\n Err(_) => assert!(false),\n }\n match status_resource::get(400) {\n Ok(_) => assert!(false),\n Err(_) => assert!(true),\n }\n}\n\n#[test]\nfn status_body_matching() {\n match status_resource::get(200) {\n Ok(response) => match response.body() {\n status_resource::get::OkBody::Status200(_) => assert!(true),\n _ => assert!(false),\n },\n Err(_) => assert!(false),\n }\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Add history and env to repl.\n"
},
{
"from": "human",
"value": "// Copyright (c) 2016, Matthew O'Connor\nextern crate system_zero_core;\n\nuse std::io;\nuse std::io::{BufRead, Write};\nuse system_zero_core::*;\nuse system_zero_core::ast::*;\n\nconst PROMPT: &'static str = \"> \";\n\nfn prompt() -> () {\n print!(\"{}\", PROMPT);\n io::stdout().flush().unwrap()\n}\n\nfn repl() -> io::Result<()> {\n prompt();\n let stdin = io::stdin();\n for line in stdin.lock().lines() {\n let line = line.unwrap();\n if line.len() > 0 {\n match parse_one(&line[..]) {\n Ok(one) => print!(\"{:?}\", one.normalize()),\n Err(error) => println!(\"Couldn't parse: {:?}\", error),\n }\n }\n prompt();\n }\n Ok(())\n}\n\nfn main() {\n println!(\"szi - system zero interpreter\");\n println!(\"Copyright (c) 2016, Matthew O'Connor <thegreendragon@gmail.com>\");\n std::process::exit(repl().is_ok() as i32)\n}\n"
},
{
"from": "gpt",
"value": "// Copyright (c) 2016, Matthew O'Connor\nextern crate system_zero_core;\n\nuse std::io;\nuse std::io::{BufRead, Write};\nuse system_zero_core::*;\nuse system_zero_core::ast::*;\n\nconst PROMPT: &'static str = \"> \";\n\nfn prompt() -> () {\n print!(\"{}\", PROMPT);\n io::stdout().flush().unwrap()\n}\n\ntype Env = Vec<Def>;\n\nfn repl() -> io::Result<()> {\n let mut history: Vec<String> = vec![];\n let mut env = Env::new();\n prompt();\n let stdin = io::stdin();\n for line in stdin.lock().lines() {\n let line = line.unwrap();\n if line.len() > 0 {\n history.push(line.clone());\n match parse_one(&line[..]) {\n Ok(one) => {\n match one {\n One::Def(ref def) => {\n print!(\"{:?}\", one);\n env.push(def.clone());\n }\n One::Expr(_) => print!(\"{:?}\", one.normalize()),\n }\n }\n Err(error) => println!(\"Couldn't parse: {:?}\", error),\n }\n }\n prompt();\n }\n Ok(())\n}\n\nfn main() {\n println!(\"szi - system zero interpreter\");\n println!(\"Copyright (c) 2016, Matthew O'Connor <thegreendragon@gmail.com>\");\n std::process::exit(repl().is_ok() as i32)\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Remove printing the secret number\n"
},
{
"from": "human",
"value": "extern crate rand;\n\nuse std::io;\nuse std::cmp::Ordering;\nuse rand::Rng;\n\nfn main() {\n println!(\"Hello in my guessing game!\");\n\n let secret_number = rand::thread_rng().gen_range(1, 101);\n\n println!(\"The secret number is: {}\", secret_number);\n loop {\n println!(\"Input your guess, please:\");\n\n let mut guess = String::new();\n\n io::stdin().read_line(&mut guess)\n .expect(\"Failed to read line!\");\n\n let guess: u32 = match guess.trim().parse() {\n Ok(num) => num,\n Err(_) => continue\n };\n\n println!(\"Your guess is: {}\", guess);\n\n match guess.cmp(&secret_number) {\n Ordering::Less => println!(\"Too low!\"),\n Ordering::Greater => println!(\"Too big!\"),\n Ordering::Equal => {\n println!(\"Great guess! You win!\");\n break;\n }\n }\n }\n}\n"
},
{
"from": "gpt",
"value": "extern crate rand;\n\nuse std::io;\nuse std::cmp::Ordering;\nuse rand::Rng;\n\nfn main() {\n println!(\"Hello in my guessing game!\");\n\n let secret_number = rand::thread_rng().gen_range(1, 101);\n\n loop {\n println!(\"Input your guess, please:\");\n\n let mut guess = String::new();\n\n io::stdin().read_line(&mut guess)\n .expect(\"Failed to read line!\");\n\n let guess: u32 = match guess.trim().parse() {\n Ok(num) => num,\n Err(_) => continue\n };\n\n println!(\"Your guess is: {}\", guess);\n\n match guess.cmp(&secret_number) {\n Ordering::Less => println!(\"Too low!\"),\n Ordering::Greater => println!(\"Too big!\"),\n Ordering::Equal => {\n println!(\"Great guess! You win!\");\n break;\n }\n }\n }\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Add some more common String/&str idioms\n"
},
{
"from": "human",
"value": "// Ok, here are a bunch of values-- some are `Strings`, some are `&strs`. Your\n// task is to call one of these two functions on each value depending on what\n// you think each value is. That is, add either `string_slice` or `string`\n// before the parentheses on each line. If you're right, it will compile!\n\nfn string_slice(arg: &str) { println!(\"{}\", arg); }\nfn string(arg: String) { println!(\"{}\", arg); }\n\nfn main() {\n (\"blue\");\n (\"red\".to_string());\n (String::from(\"hi\"));\n (format!(\"Interpolation {}\", \"Station\"));\n (&String::from(\"abc\")[0..1]);\n (\" hello there \".trim());\n (\"Happy Monday!\".to_string().replace(\"Mon\", \"Tues\"));\n (\"mY sHiFt KeY iS sTiCkY\".to_lowercase());\n}\n"
},
{
"from": "gpt",
"value": "// Ok, here are a bunch of values-- some are `Strings`, some are `&strs`. Your\n// task is to call one of these two functions on each value depending on what\n// you think each value is. That is, add either `string_slice` or `string`\n// before the parentheses on each line. If you're right, it will compile!\n\nfn string_slice(arg: &str) { println!(\"{}\", arg); }\nfn string(arg: String) { println!(\"{}\", arg); }\n\nfn main() {\n (\"blue\");\n (\"red\".to_string());\n (String::from(\"hi\"));\n (\"rust is fun!\".to_owned());\n (\"nice weather\".into());\n (format!(\"Interpolation {}\", \"Station\"));\n (&String::from(\"abc\")[0..1]);\n (\" hello there \".trim());\n (\"Happy Monday!\".to_string().replace(\"Mon\", \"Tues\"));\n (\"mY sHiFt KeY iS sTiCkY\".to_lowercase());\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Test function has been renamed\n"
},
{
"from": "human",
"value": "#[macro_use] extern crate match_any;\n\nuse std::any::Any;\n\nfn make_any<T: Any>(value: T) -> Box<Any> {\n Box::new(value)\n}\n\n#[test]\nfn empty() {\n match_any!(make_any(10) => \n x: i32 => { \n assert_eq!(*x, 10);\n }\n );\n}\n\n// TODO: Add.\n// #[bench]\n"
},
{
"from": "gpt",
"value": "#[macro_use] extern crate match_any;\n\nuse std::any::Any;\n\nfn make_any<T: Any>(value: T) -> Box<Any> {\n Box::new(value)\n}\n\n#[test]\nfn match_i32() {\n match_any!(make_any(10) => \n x: i32 => { \n assert_eq!(*x, 10);\n }\n );\n}\n\n// TODO: Add.\n// #[bench]\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Use the s-expression printing in the REPL\n"
},
{
"from": "human",
"value": "use cell_gc;\nuse parser::parse;\nuse std::io::{self, Write};\nuse vm;\n\npub fn repl() -> io::Result<()> {\n cell_gc::with_heap(|hs| {\n let env = vm::Value::default_env(hs);\n\n loop {\n {\n let stdout = io::stdout();\n let mut stdout = stdout.lock();\n write!(&mut stdout, \"lisp> \")?;\n stdout.flush()?;\n }\n\n // Read\n let mut source = String::new();\n io::stdin().read_line(&mut source)?;\n let expr = parse(hs, &source)\n .map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?;\n\n // Eval\n let result = vm::eval(hs, expr, &env);\n\n // Print\n println!(\"{:?}\", result);\n\n // Loop...\n }\n\n // Unreachable...\n })\n}\n"
},
{
"from": "gpt",
"value": "use cell_gc;\nuse parser::parse;\nuse print::print;\nuse std::io::{self, Write};\nuse vm;\n\npub fn repl() -> io::Result<()> {\n cell_gc::with_heap(|hs| {\n let env = vm::Value::default_env(hs);\n\n loop {\n {\n let stdout = io::stdout();\n let mut stdout = stdout.lock();\n write!(&mut stdout, \"lisp> \")?;\n stdout.flush()?;\n }\n\n // Read\n let mut source = String::new();\n io::stdin().read_line(&mut source)?;\n let expr = parse(hs, &source)\n .map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?;\n\n // Eval\n let result = vm::eval(hs, expr, &env);\n\n // Print\n print(val);\n println!();\n\n // Loop...\n }\n\n // Unreachable...\n })\n}\n"
}
] |
rust
|
chosen
|
[
{
"from": "system",
"value": "Remove print on game exit\n"
},
{
"from": "human",
"value": "extern crate json;\nextern crate tiled;\n\nextern crate cgmath;\n#[macro_use]\nextern crate gfx;\nextern crate specs;\nextern crate genmesh;\nextern crate gfx_device_gl;\nextern crate gfx_window_glutin;\nextern crate glutin;\nextern crate image;\nextern crate rodio;\n\nmod gfx_app;\nmod game;\nmod data;\nmod critter;\nmod graphics;\nmod terrain;\nmod character;\nmod shaders;\nmod zombie;\n\nfn main() {\n let mut window = gfx_app::GlutinWindow::new();\n loop {\n match gfx_app::init::run(&mut window) {\n gfx_app::GameStatus::Quit => {\n println!(\"Game was quit\");\n break;\n }\n gfx_app::GameStatus::Render => (),\n }\n }\n}\n"
},
{
"from": "gpt",
"value": "extern crate json;\nextern crate tiled;\n\nextern crate cgmath;\n#[macro_use]\nextern crate gfx;\nextern crate specs;\nextern crate genmesh;\nextern crate gfx_device_gl;\nextern crate gfx_window_glutin;\nextern crate glutin;\nextern crate image;\nextern crate rodio;\n\nmod gfx_app;\nmod game;\nmod data;\nmod critter;\nmod graphics;\nmod terrain;\nmod character;\nmod shaders;\nmod zombie;\n\nfn main() {\n let mut window = gfx_app::GlutinWindow::new();\n loop {\n match gfx_app::init::run(&mut window) {\n gfx_app::GameStatus::Quit => break,\n gfx_app::GameStatus::Render => (),\n }\n }\n}\n"
}
] |
rust
|
chosen
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.