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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

//! `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 commonly used methods to
//! always work... not so in rust! 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](trait.AsciiExt.html)**: adds the `to_ascii_uppercase` onto `&str`
//!   types.
//! - **std::borrow::[Borrow](trait.Borrow.html)**: for manually defining the `Borrow` trait.
//! - **std::cmp::{[Ord](enum.Ord.html), [PartialOrd](enum.PartialOrd.html)}**: for manually
//!   defining the Ordering traits and using them in trait bounds.
//! - **std::fmt::[Debug](trait.Debug.html)**: allows you to define Debug manually and use in trait
//!   bounds.
//! - **std::hash::{[Hash](trait.Hash.html), [Hasher](trait.Hasher.html)}**: allows you to
//!   define Hash manually and use in trait bounds.
//! - **std::fmt::[Write as FmtWrite](trait.FmtWrite.html)**: adds `write_str` onto byte buffers
//!   (such as `String`). Renamed `FmtWrite` to avoid conflict with `std::io::Write`
//! - **std::io::[BufRead](trait.BufRead.html)**: the `BufRead` trait allows you to use the methods
//!   associated with the `BufReader` struct (also imported).
//! - **std::io::[Read](trait.Read.html)**: allows you to use `file.read()`
//! - **std::io::[Seek](trait.Seek.html)**: allows you to use `file.seek()`
//! - **std::io::[Write as IoWrite](trait.IoWrite.html)**: allows you to use `file.write()` and
//!   `file.write_all()`. Renamed `IoWrite` to avoid conflict with `std::fmt::Write`
//! - **std::ops::{[Deref](trait.Deref.html), [DerefMut](trait.DerefMut.html)}**: allows deref
//!   through `*v` and also enables Deref coercions
//! - **std::str::[FromStr](trait.FromStr.html)**: 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::borrow::[Cow](struct.Cow.html)**: A clone-on-write smart pointer (often called copy on
//!   write in other languages). This is used by many libraries to be as efficient as possible when
//!   returned data is identical to the data passed in, among other uses.
//! - **std::collections::{[BTreeMap](struct.BTreeMap.html), [HashMap](struct.HashMap.html),
//!   [HashSet](struct.HashSet.html)}**: ordered-dict, dict and set
//! - **std::cmp::[Ordering](enum.Ordering.html)**: the enum type used in the Ordering traits.
//! - **std::ffi::[OsString](struct.OsString.html)**: os agnostic (non unicode) string type.
//!   `std::path::PathBuf` uses this.
//! - **std::fs::[File](struct.File.html)**: for opening files.
//!     - `File::open` to open a file for reading
//!     - `File::write` to open a file for writing
//! - **std::fs::[OpenOptions](struct.OpenOptions.html)**: file opening options.
//! - **std::fs::[ReadDir](struct.ReadDir.html)**: to iterate over the entries in a directory.
//! - **std::io::[BufReader](struct.BufReader.html)**: 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](struct.BufWriter.html)**: similar to `BufReader`, buffers writes to
//!   reduce the number of calls to the OS. Provides no new methods.
//!
//! - **std::path::{[Path](struct.Path.html), [PathBuf](struct.PathBuf.html)}**: specifies an os
//!   path.
//! - **std::rc::[Rc](struct.Rc.html)**: reference counted pointer
//! - **std::sync::[Arc](struct.Arc.html)**: atomically reference counted pointer
//! - **std::sync::[Mutex](struct.Mutex.html)**: 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 as AtomicOrdering](struct.AtomicOrdering.html)**: necessary
//!   for performing operations on atomic types. For incrementing a counter use `val.fetch_add(1,
//!   AtomicOrdering::SeqCst)`. Renamed to not conflict with `std::cmp::Ordering`.
//! - **std::sync::atomic::ATOMIC_USIZE_INIT**: initialized `AtomicUsize` of 0. Use with `static
//!   COUNTER: AtomicUsize = ATOMIC_USIZE_INIT;`
//! - **std::time::[Duration](struct.Duration.html)**: 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::cmp::{[max](fn.max.html), [min](fn.min.html)}**: get the max or min of two comparable integers.
//! - **std::mem::{[size_of](fn.size_of.html), [size_of_val](fn.size_of_val.html)}**: get the size
//!   of a type. This is safe and common enough that it should be always available.
//! - **std::thread::[sleep](fn.sleep.html)**: put the thread to sleep for a `Duration`.
//! - **std::thread::[spawn](fn.spawn.html)**: spawn a function in a new thread. In rust this is
//!   memory safe, so it is nice to have it always available.
//!
//! # Modules (_primitive type_ only)
//! The following modules are imported so that it is easy to access their relevant constants and
//! constructors.
//!
//! - **u8 u16 u64 usize**: unsigned integer modules with `MAX` and `MIN`
//! - **i8 i16 i64 isize**: signed integer modules with `MAX` and `MIN`
//! - **f32 f64**: floating point modules with not just `MAX` and `MIN` but also `NAN`, `INFINITY`,
//!   etc as well as a [f32::consts](f32/consts/index.html) and [f64::consts](f64/consts/index.html)
//!   modules with basic mathematical constants like `PI` and `E`.
//! - [**str**](str/index.html): core string type with [`from_utf8`](str/fn.from_utf8.html)
//!   function.

// ------------------------------
// ----------- TRAITS -----------
pub use std::ascii::AsciiExt;
pub use std::borrow::Borrow;
pub use std::cmp::{
    Ord, PartialOrd, Ordering
};
pub use std::fmt::{Debug, Write as FmtWrite};
pub use std::hash::{Hash, Hasher};
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::borrow::Cow;
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 as AtomicOrdering,
    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;