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

//! `import 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 implemented 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::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::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
//! - `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.

// traits
pub use std::ascii::AsciiExt;
pub use std::fmt::{Debug, Write as FmtWrite};
pub use std::io::{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::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};