1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124
//! `use std_prelude::*` so you can be ready to code! //! //! # Traits //! Not having common traits imported is one of the most annoying gotchas in rust when coming from //! other languages. When you are used to the language, you expect the methods you are used to to //! always work... not so. Using `Vec::from_iter` is extremely common, but you must first import //! the `FromIterator` trait. //! //! The following are the traits that are exported and why: //! //! - `std::ascii::AsciiExt`: adds the `to_ascii_uppercase` onto `&str` types. //! - `std::fmt::Debug`: allows you to define Debug manually. //! - `std::fmt::Write as FmtWrite`: adds `write_str` onto byte buffers (such as `String`). Renamed //! `FmtWrite` to avoid conflict with `std::io::Write` //! - `std::io::BufRead`: the `BufRead` trait allows you to use the methods associated with //! the `BufReader` struct. //! - `std::io::Read`: allows you to use `file.read()` //! - `std::io::Seek`: allows you to use `file.seek()` //! - `std::io::Write as IoWrite`: allows you to use `file.write()` and `file.write_all()`. Renamed //! `IoWrite` to avoid conflict with `std::fmt::Write` //! - `std::ops::{Deref, DerefMut}`: allows deref through `*v` and also enables Deref coercions //! - `std::str::FromStr`: allows you to use `type::from_str` constructor for several types. This //! is what is implicitly called with `str::parse<_>()` //! //! # structs //! These are extremely commonly used types and it is annoying to have to reimport them all the //! time. //! //! - `std::collections::{BTreeMap, HashMap, HashSet}`: ordered-dict, dict and set //! - `std::ffi::OsString`: os agnostic (non unicode) string type `std::path::PathBuf` uses this. //! - `std::fs::File`: for opening files. //! - `File::open` to open a file for reading //! - `File::write` to open a file for writing //! - `std::fs::OpenOptions` for more file opening options //! - `std::fs::ReadDir`: to iterate over the entries in a directory. //! - `std::io::BufReader`: the BufRead struct wraps `io::Read` using a buffer reducing the number //! of OS calls and giving helpful methods //! - `read_line()`: read a single line //! - `lines()`: return an iterator over all lines. //! - `split(byte: u8)`: return an iterator which splits at the chosen byte. //! - `std::io::BufWriter`: similar to `BufReader`, buffers writes to reduce the number of calls to //! the OS. Provides no new methods. //! - `std::path::{Path, PathBuf}`: specifies an os path. //! - `std::rc::Rc`: reference counted pointer //! - `std::sync::Arc`: atomically reference counted pointer //! - `std::sync::Mutex`: mutual exclusion primitive for threading. //! - `std::sync::atomic::{AtomicBool, AtomicIsize, AtomicUsize}`: basic atomic types. Good for //! unique ids and lots of other use cases. //! - `std::sync::atomic::Ordering`: necessary for performing operations on atomic types. For //! incrementing a counter use `val.fetch_add(1, Ordering::SeqCst)`. //! - `std::sync::atomic::ATOMIC_USIZE_INIT`: initialized `AtomicUsize` of 0. Use with `static //! COUNTER: AtomicUsize = ATOMIC_USIZE_INIT;` //! - `std::time::Duration`: an amount of time, used for `std::thread::sleep`. //! //! # functions //! These are mostly just "nice to have" functions and it is *really* unlikely that they would ever //! be overriden. //! //! - `std::mem::{size_of, size_of_val}`: get the size of a type. This is safe and common enough //! that it should be always available. //! - `std::thread::sleep`: put the thread to sleep for a `Duration`. //! - `std::thread::spawn`: spawn a function in a new thread. In rust this is memory safe, so it is //! nice to have it always available. //! //! # modules //! The following modules are imported so that it is easy to access their constants and methods, //! i.e. `str::from_utf8` and `u64::from_str`, `u64::MAX`. //! - `u8 u16 u64 usize`: unsigned integer modules //! - `i8 i16 i64 isize`: signed integer modules //! - `f32 f64`: floating point modules //! - `str`: core string type // traits pub use std::ascii::AsciiExt; pub use std::fmt::{Debug, Write as FmtWrite}; pub use std::io::{ BufRead, Read, Seek, SeekFrom, Write as IoWrite, }; pub use std::iter::FromIterator; pub use std::ops::{Deref, DerefMut}; pub use std::str::FromStr; // structs pub use std::collections::{BTreeMap, HashMap, HashSet}; pub use std::ffi::OsString; pub use std::fs::{ File, OpenOptions, ReadDir, }; pub use std::io::{ BufReader, BufWriter, }; pub use std::path::{Path, PathBuf}; pub use std::rc::Rc; pub use std::sync::{Arc, Mutex}; pub use std::sync::atomic::{ AtomicBool, AtomicIsize, AtomicUsize, Ordering, ATOMIC_USIZE_INIT, }; pub use std::time::Duration; // functions pub use std::mem::{size_of, size_of_val}; pub use std::thread::{sleep, spawn}; // modules pub use std::u8; pub use std::u16; pub use std::u64; pub use std::usize; pub use std::i8; pub use std::i16; pub use std::i64; pub use std::isize; pub use std::f32; pub use std::f64; pub use std::str;