SYMBOL INDEX (395 symbols across 45 files)

FILE: src/cmd/cat.rs
  type Args (line 42) | struct Args {
    method configs (line 64) | fn configs(&self) -> CliResult<Vec<Config>> {
    method cat_rows (line 71) | fn cat_rows(&self) -> CliResult<()> {
    method cat_columns (line 86) | fn cat_columns(&self) -> CliResult<()> {
  function run (line 52) | pub fn run(argv: &[&str]) -> CliResult<()> {

FILE: src/cmd/count.rs
  type Args (line 25) | struct Args {
  function run (line 31) | pub fn run(argv: &[&str]) -> CliResult<()> {

FILE: src/cmd/fixlengths.rs
  type Args (line 37) | struct Args {
  function run (line 44) | pub fn run(argv: &[&str]) -> CliResult<()> {

FILE: src/cmd/flatten.rs
  type Args (line 42) | struct Args {
  function run (line 50) | pub fn run(argv: &[&str]) -> CliResult<()> {

FILE: src/cmd/fmt.rs
  type Args (line 37) | struct Args {
  function run (line 49) | pub fn run(argv: &[&str]) -> CliResult<()> {

FILE: src/cmd/frequency.rs
  type Args (line 64) | struct Args {
    method rconfig (line 108) | fn rconfig(&self) -> Config {
    method counts (line 115) | fn counts(&self, ftab: &FTable) -> Vec<(ByteString, u64)> {
    method sequential_ftables (line 133) | fn sequential_ftables(&self) -> CliResult<(Headers, FTables)> {
    method parallel_ftables (line 139) | fn parallel_ftables(&self, idx: &mut Indexed<fs::File, fs::File>)
    method ftables (line 166) | fn ftables<I>(&self, sel: &Selection, it: I) -> CliResult<FTables>
    method sel_headers (line 188) | fn sel_headers<R: io::Read>(&self, rdr: &mut csv::Reader<R>)
    method njobs (line 195) | fn njobs(&self) -> usize {
  function run (line 76) | pub fn run(argv: &[&str]) -> CliResult<()> {
  type ByteString (line 102) | type ByteString = Vec<u8>;
  type Headers (line 103) | type Headers = csv::ByteRecord;
  type FTable (line 104) | type FTable = Frequencies<Vec<u8>>;
  type FTables (line 105) | type FTables = Vec<Frequencies<Vec<u8>>>;
  function trim (line 200) | fn trim(bs: ByteString) -> ByteString {

FILE: src/cmd/headers.rs
  type Args (line 35) | struct Args {
  function run (line 42) | pub fn run(argv: &[&str]) -> CliResult<()> {

FILE: src/cmd/index.rs
  type Args (line 38) | struct Args {
  function run (line 44) | pub fn run(argv: &[&str]) -> CliResult<()> {

FILE: src/cmd/input.rs
  type Args (line 32) | struct Args {
  function run (line 41) | pub fn run(argv: &[&str]) -> CliResult<()> {

FILE: src/cmd/join.rs
  type ByteString (line 74) | type ByteString = Vec<u8>;
  type Args (line 77) | struct Args {
    method new_io_state (line 280) | fn new_io_state(&self)
    method get_selections (line 307) | fn get_selections<R: io::Read>(
  function run (line 93) | pub fn run(argv: &[&str]) -> CliResult<()> {
  type IoState (line 126) | struct IoState<R, W: io::Write> {
  function write_headers (line 138) | fn write_headers(&mut self) -> CliResult<()> {
  function inner_join (line 147) | fn inner_join(mut self) -> CliResult<()> {
  function outer_join (line 170) | fn outer_join(mut self, right: bool) -> CliResult<()> {
  function full_outer_join (line 208) | fn full_outer_join(mut self) -> CliResult<()> {
  function cross_join (line 248) | fn cross_join(mut self) -> CliResult<()> {
  function get_padding (line 267) | fn get_padding(
  type ValueIndex (line 326) | struct ValueIndex<R> {
  function new (line 334) | fn new(
  function fmt (line 399) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  function get_row_key (line 414) | fn get_row_key(
  function transform (line 422) | fn transform(bs: &[u8], casei: bool) -> ByteString {

FILE: src/cmd/partition.rs
  type Args (line 46) | struct Args {
    method rconfig (line 70) | fn rconfig(&self) -> Config {
    method key_column (line 78) | fn key_column(
    method sequential_partition (line 92) | fn sequential_partition(&self) -> CliResult<()> {
  function run (line 57) | pub fn run(argv: &[&str]) -> CliResult<()> {
  type BoxedWriter (line 138) | type BoxedWriter = csv::Writer<Box<io::Write+'static>>;
  type WriterGenerator (line 141) | struct WriterGenerator {
    method new (line 149) | fn new(template: FilenameTemplate) -> WriterGenerator {
    method writer (line 159) | fn writer<P>(&mut self, path: P, key: &[u8]) -> io::Result<BoxedWriter>
    method unique_value (line 169) | fn unique_value(&mut self, key: &[u8]) -> String {

FILE: src/cmd/reverse.rs
  type Args (line 28) | struct Args {
  function run (line 35) | pub fn run(argv: &[&str]) -> CliResult<()> {

FILE: src/cmd/sample.rs
  type Args (line 47) | struct Args {
  function run (line 56) | pub fn run(argv: &[&str]) -> CliResult<()> {
  function sample_random_access (line 87) | fn sample_random_access<R, I>(
  function sample_reservoir (line 105) | fn sample_reservoir<R: io::Read>(
  function do_random_access (line 140) | fn do_random_access(sample_size: u64, total: u64) -> bool {

FILE: src/cmd/search.rs
  type Args (line 39) | struct Args {
  function run (line 50) | pub fn run(argv: &[&str]) -> CliResult<()> {

FILE: src/cmd/select.rs
  type Args (line 51) | struct Args {
  function run (line 59) | pub fn run(argv: &[&str]) -> CliResult<()> {

FILE: src/cmd/slice.rs
  type Args (line 45) | struct Args {
    method no_index (line 65) | fn no_index(&self) -> CliResult<()> {
    method with_index (line 77) | fn with_index(
    method range (line 96) | fn range(&self) -> Result<(usize, usize), String> {
    method rconfig (line 101) | fn rconfig(&self) -> Config {
    method wconfig (line 107) | fn wconfig(&self) -> Config {
  function run (line 56) | pub fn run(argv: &[&str]) -> CliResult<()> {

FILE: src/cmd/sort.rs
  type Args (line 37) | struct Args {
  function run (line 47) | pub fn run(argv: &[&str]) -> CliResult<()> {
  function iter_cmp (line 98) | pub fn iter_cmp<A, L, R>(mut a: L, mut b: R) -> cmp::Ordering
  function iter_cmp_num (line 114) | pub fn iter_cmp_num<'a, L, R>(mut a: L, mut b: R) -> cmp::Ordering
  type Number (line 130) | enum Number {
  function compare_num (line 135) | fn compare_num(n1: Number, n2: Number) -> cmp::Ordering{
  function compare_float (line 144) | fn compare_float(f1: f64, f2: f64) -> cmp::Ordering {
  function next_num (line 150) | fn next_num<'a, X>(xs: &mut X) -> Option<Number>

FILE: src/cmd/split.rs
  type Args (line 50) | struct Args {
    method sequential_split (line 74) | fn sequential_split(&self) -> CliResult<()> {
    method parallel_split (line 94) | fn parallel_split(
    method new_writer (line 127) | fn new_writer(
    method rconfig (line 142) | fn rconfig(&self) -> Config {
    method njobs (line 148) | fn njobs(&self) -> usize {
  function run (line 60) | pub fn run(argv: &[&str]) -> CliResult<()> {

FILE: src/cmd/stats.rs
  type Args (line 71) | struct Args {
    method sequential_stats (line 118) | fn sequential_stats(&self) -> CliResult<(csv::ByteRecord, Vec<Stats>)> {
    method parallel_stats (line 125) | fn parallel_stats(
    method stats_to_records (line 156) | fn stats_to_records(&self, stats: Vec<Stats>) -> Vec<csv::StringRecord> {
    method compute (line 173) | fn compute<I>(&self, sel: &Selection, it: I) -> CliResult<Vec<Stats>>
    method sel_headers (line 185) | fn sel_headers<R: io::Read>(
    method rconfig (line 194) | fn rconfig(&self) -> Config {
    method njobs (line 201) | fn njobs(&self) -> usize {
    method new_stats (line 205) | fn new_stats(&self, record_len: usize) -> Vec<Stats> {
    method stat_headers (line 217) | fn stat_headers(&self) -> csv::StringRecord {
  function run (line 85) | pub fn run(argv: &[&str]) -> CliResult<()> {
  type WhichStats (line 231) | struct WhichStats {
  method merge (line 242) | fn merge(&mut self, other: WhichStats) {
  type Stats (line 248) | struct Stats {
    method new (line 259) | fn new(which: WhichStats) -> Stats {
    method add (line 278) | fn add(&mut self, sample: &[u8]) {
    method to_record (line 308) | fn to_record(&mut self) -> csv::StringRecord {
  method merge (line 373) | fn merge(&mut self, other: Stats) {
  type FieldType (line 385) | enum FieldType {
    method from_sample (line 394) | fn from_sample(sample: &[u8]) -> FieldType {
    method is_number (line 407) | fn is_number(&self) -> bool {
    method is_null (line 411) | fn is_null(&self) -> bool {
    method fmt (line 443) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method merge (line 417) | fn merge(&mut self, other: FieldType) {
  method default (line 439) | fn default() -> FieldType { TNull }
  type TypedSum (line 458) | struct TypedSum {
    method add (line 464) | fn add(&mut self, typ: FieldType, sample: &[u8]) {
    method show (line 491) | fn show(&self, typ: FieldType) -> Option<String> {
  method merge (line 501) | fn merge(&mut self, other: TypedSum) {
  type TypedMinMax (line 514) | struct TypedMinMax {
    method add (line 522) | fn add(&mut self, typ: FieldType, sample: &[u8]) {
    method len_range (line 549) | fn len_range(&self) -> Option<(String, String)> {
    method show (line 556) | fn show(&self, typ: FieldType) -> Option<(String, String)> {
  method default (line 590) | fn default() -> TypedMinMax {
  method merge (line 601) | fn merge(&mut self, other: TypedMinMax) {
  function from_bytes (line 609) | fn from_bytes<T: FromStr>(bytes: &[u8]) -> Option<T> {

FILE: src/cmd/table.rs
  type Args (line 40) | struct Args {
  function run (line 49) | pub fn run(argv: &[&str]) -> CliResult<()> {

FILE: src/config.rs
  type Delimiter (line 20) | pub struct Delimiter(pub u8);
    method as_byte (line 28) | pub fn as_byte(self) -> u8 {
    method deserialize (line 34) | fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Delimiter, D::Err...
  type Config (line 58) | pub struct Config {
    method new (line 74) | pub fn new(path: &Option<String>) -> Config {
    method delimiter (line 105) | pub fn delimiter(mut self, d: Option<Delimiter>) -> Config {
    method no_headers (line 112) | pub fn no_headers(mut self, mut yes: bool) -> Config {
    method flexible (line 120) | pub fn flexible(mut self, yes: bool) -> Config {
    method crlf (line 125) | pub fn crlf(mut self, yes: bool) -> Config {
    method terminator (line 134) | pub fn terminator(mut self, term: csv::Terminator) -> Config {
    method quote (line 139) | pub fn quote(mut self, quote: u8) -> Config {
    method quote_style (line 144) | pub fn quote_style(mut self, style: csv::QuoteStyle) -> Config {
    method double_quote (line 149) | pub fn double_quote(mut self, yes: bool) -> Config {
    method escape (line 154) | pub fn escape(mut self, escape: Option<u8>) -> Config {
    method quoting (line 159) | pub fn quoting(mut self, yes: bool) -> Config {
    method select (line 164) | pub fn select(mut self, sel_cols: SelectColumns) -> Config {
    method is_std (line 169) | pub fn is_std(&self) -> bool {
    method selection (line 173) | pub fn selection(
    method write_headers (line 184) | pub fn write_headers<R: io::Read, W: io::Write>
    method writer (line 196) | pub fn writer(&self)
    method reader (line 201) | pub fn reader(&self)
    method reader_file (line 206) | pub fn reader_file(&self) -> io::Result<csv::Reader<fs::File>> {
    method index_files (line 215) | pub fn index_files(&self)
    method indexed (line 255) | pub fn indexed(&self)
    method io_reader (line 263) | pub fn io_reader(&self) -> io::Result<Box<io::Read+'static>> {
    method from_reader (line 282) | pub fn from_reader<R: Read>(&self, rdr: R) -> csv::Reader<R> {
    method io_writer (line 293) | pub fn io_writer(&self) -> io::Result<Box<io::Write+'static>> {
    method from_writer (line 300) | pub fn from_writer<W: io::Write>(&self, wtr: W) -> csv::Writer<W> {

FILE: src/index.rs
  type Indexed (line 10) | pub struct Indexed<R, I> {
  type Target (line 16) | type Target = csv::Reader<R>;
  function deref (line 17) | fn deref(&self) -> &csv::Reader<R> { &self.csv_rdr }
  function deref_mut (line 21) | fn deref_mut(&mut self) -> &mut csv::Reader<R> { &mut self.csv_rdr }
  function open (line 26) | pub fn open(
  function count (line 38) | pub fn count(&self) -> u64 {
  function seek (line 47) | pub fn seek(&mut self, mut i: u64) -> CliResult<()> {

FILE: src/main.rs
  type Args (line 91) | struct Args {
  function main (line 96) | fn main() {
  type Command (line 142) | enum Command {
    method run (line 167) | fn run(self) -> CliResult<()> {
  type CliResult (line 203) | pub type CliResult<T> = Result<T, CliError>;
  type CliError (line 206) | pub enum CliError {
    method fmt (line 214) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    method from (line 225) | fn from(err: docopt::Error) -> CliError {
    method from (line 231) | fn from(err: csv::Error) -> CliError {
    method from (line 243) | fn from(err: io::Error) -> CliError {
    method from (line 249) | fn from(err: String) -> CliError {
    method from (line 255) | fn from(err: &'a str) -> CliError {
    method from (line 261) | fn from(err: regex::Error) -> CliError {

FILE: src/select.rs
  type SelectColumns (line 13) | pub struct SelectColumns {
    method parse (line 19) | fn parse(mut s: &str) -> Result<SelectColumns, String> {
    method selection (line 33) | pub fn selection(
    method fmt (line 67) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    method deserialize (line 80) | fn deserialize<D: Deserializer<'de>>(
  type SelectorParser (line 88) | struct SelectorParser {
    method new (line 94) | fn new(s: &str) -> SelectorParser {
    method parse (line 98) | fn parse(&mut self) -> Result<Vec<Selector>, String> {
    method parse_one (line 135) | fn parse_one(&mut self) -> Result<OneSelector, String> {
    method parse_name (line 154) | fn parse_name(&mut self) -> Result<String, String> {
    method parse_quoted_name (line 166) | fn parse_quoted_name(&mut self) -> Result<String, String> {
    method parse_index (line 189) | fn parse_index(&mut self) -> Result<usize, String> {
    method cur (line 209) | fn cur(&self) -> Option<char> {
    method is_end_of_field (line 213) | fn is_end_of_field(&self) -> bool {
    method is_end_of_selector (line 217) | fn is_end_of_selector(&self) -> bool {
    method bump (line 221) | fn bump(&mut self) {
  type Selector (line 227) | enum Selector {
    method indices (line 241) | fn indices(
    method fmt (line 325) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type OneSelector (line 233) | enum OneSelector {
    method index (line 272) | fn index(
    method fmt (line 335) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type Selection (line 347) | pub struct Selection(Vec<usize>);
    method select (line 353) | pub fn select<'a, 'b>(&'a self, row: &'b csv::ByteRecord)
    method normal (line 368) | pub fn normal(&self) -> NormalSelection {
    method len (line 385) | pub fn len(&self) -> usize {
    type Target (line 391) | type Target = [usize];
    method deref (line 393) | fn deref(&self) -> &[usize] {
  type _GetField (line 349) | pub type _GetField =
  type NormalSelection (line 399) | pub struct NormalSelection(Vec<bool>);
    method select (line 416) | pub fn select<'a, T, I>(&'a self, row: I) -> _NormalFilterMap<'a, T, I>
    method len (line 429) | pub fn len(&self) -> usize {
    type Target (line 435) | type Target = [bool];
    method deref (line 437) | fn deref(&self) -> &[bool] {
  type _NormalScan (line 401) | pub type _NormalScan<'a, T, I> = iter::Scan<
  type _NormalFilterMap (line 407) | pub type _NormalFilterMap<'a, T, I> = iter::FilterMap<
  type _NormalGetField (line 412) | pub type _NormalGetField<T> =

FILE: src/util.rs
  function num_cpus (line 17) | pub fn num_cpus() -> usize {
  function version (line 21) | pub fn version() -> String {
  function get_args (line 34) | pub fn get_args<T>(usage: &str, argv: &[&str]) -> CliResult<T>
  function many_configs (line 43) | pub fn many_configs(inps: &[String], delim: Option<Delimiter>,
  function errif_greater_one_stdin (line 58) | pub fn errif_greater_one_stdin(inps: &[Config]) -> Result<(), String> {
  function chunk_size (line 66) | pub fn chunk_size(nitems: usize, njobs: usize) -> usize {
  function num_of_chunks (line 74) | pub fn num_of_chunks(nitems: usize, chunk_size: usize) -> usize {
  function last_modified (line 85) | pub fn last_modified(md: &fs::Metadata) -> u64 {
  function condense (line 90) | pub fn condense<'a>(val: Cow<'a, [u8]>, n: Option<usize>) -> Cow<'a, [u8...
  function idx_path (line 116) | pub fn idx_path(csv_path: &Path) -> PathBuf {
  type Idx (line 122) | pub type Idx = Option<usize>;
  function range (line 124) | pub fn range(start: Idx, end: Idx, len: Idx, index: Idx)
  function create_dir_all_threadsafe (line 151) | fn create_dir_all_threadsafe(path: &Path) -> io::Result<()> {
  type FilenameTemplate (line 173) | pub struct FilenameTemplate {
    method filename (line 181) | pub fn filename(&self, unique_value: &str) -> String {
    method writer (line 189) | pub fn writer<P>(&self, path: P, unique_value: &str)
    method deserialize (line 207) | fn deserialize<D: Deserializer<'de>>(

FILE: tests/test_cat.rs
  function no_headers (line 6) | fn no_headers(cmd: &mut process::Command) {
  function pad (line 10) | fn pad(cmd: &mut process::Command) {
  function run_cat (line 14) | fn run_cat<X, Y, Z, F>(test_name: &str, which: &str, rows1: X, rows2: Y,
  function prop_cat_rows (line 27) | fn prop_cat_rows() {
  function cat_rows_space (line 45) | fn cat_rows_space() {
  function cat_rows_headers (line 61) | fn cat_rows_headers() {
  function prop_cat_cols (line 74) | fn prop_cat_cols() {
  function cat_cols_headers (line 92) | fn cat_cols_headers() {
  function cat_cols_no_pad (line 106) | fn cat_cols_no_pad() {
  function cat_cols_pad (line 119) | fn cat_cols_pad() {

FILE: tests/test_count.rs
  function prop_count_len (line 8) | fn prop_count_len(name: &str, rows: CsvData,
  function prop_count (line 33) | fn prop_count() {
  function prop_count_headers (line 41) | fn prop_count_headers() {
  function prop_count_indexed (line 49) | fn prop_count_indexed() {
  function prop_count_indexed_headers (line 57) | fn prop_count_indexed_headers() {

FILE: tests/test_fixlengths.rs
  function trim_trailing_empty (line 6) | fn trim_trailing_empty(it : &CsvRecord) -> Vec<String> {
  function prop_fixlengths_all_maxlen (line 15) | fn prop_fixlengths_all_maxlen() {
  function fixlengths_all_maxlen_trims (line 38) | fn fixlengths_all_maxlen_trims() {
  function fixlengths_all_maxlen_trims_at_least_1 (line 56) | fn fixlengths_all_maxlen_trims_at_least_1() {
  function prop_fixlengths_explicit_len (line 75) | fn prop_fixlengths_explicit_len() {

FILE: tests/test_flatten.rs
  function setup (line 5) | fn setup(name: &str) -> (Workdir, process::Command) {
  function flatten_basic (line 22) | fn flatten_basic() {
  function flatten_no_headers (line 36) | fn flatten_no_headers() {
  function flatten_separator (line 55) | fn flatten_separator() {
  function flatten_condense (line 71) | fn flatten_condense() {

FILE: tests/test_fmt.rs
  function setup (line 5) | fn setup(name: &str) -> (Workdir, process::Command) {
  function fmt_delimiter (line 22) | fn fmt_delimiter() {
  function fmt_weird_delimiter (line 35) | fn fmt_weird_delimiter() {
  function fmt_crlf (line 48) | fn fmt_crlf() {
  function fmt_quote_always (line 61) | fn fmt_quote_always() {

FILE: tests/test_frequency.rs
  function setup (line 11) | fn setup(name: &str) -> (Workdir, process::Command) {
  function frequency_no_headers (line 32) | fn frequency_no_headers() {
  function frequency_no_nulls (line 50) | fn frequency_no_nulls() {
  function frequency_nulls (line 66) | fn frequency_nulls() {
  function frequency_limit (line 83) | fn frequency_limit() {
  function frequency_asc (line 98) | fn frequency_asc() {
  function frequency_select (line 112) | fn frequency_select() {
  function prop_frequency (line 130) | fn prop_frequency() {
  function frequency_bom (line 150) | fn frequency_bom() {
  function prop_frequency_indexed (line 163) | fn prop_frequency_indexed() {
  function param_prop_frequency (line 172) | fn param_prop_frequency(name: &str, rows: CsvData, idx: bool) -> bool {
  type FTables (line 192) | type FTables = HashMap<String, Frequencies<String>>;
  type FRow (line 195) | struct FRow {
  function ftables_from_rows (line 201) | fn ftables_from_rows<T: Csv>(rows: T) -> FTables {
  function ftables_from_csv_string (line 224) | fn ftables_from_csv_string(data: String) -> FTables {
  function freq_data (line 247) | fn freq_data<T>(ftable: &Frequencies<T>) -> Vec<(&T, u64)>
  function assert_eq_ftables (line 254) | fn assert_eq_ftables(got: &FTables, expected: &FTables) -> bool {

FILE: tests/test_headers.rs
  function setup (line 5) | fn setup(name: &str) -> (Workdir, process::Command) {
  function headers_basic (line 20) | fn headers_basic() {
  function headers_just_names (line 31) | fn headers_just_names() {
  function headers_multiple (line 43) | fn headers_multiple() {
  function headers_intersect (line 57) | fn headers_intersect() {

FILE: tests/test_index.rs
  function index_outdated (line 8) | fn index_outdated() {
  function future_time (line 24) | fn future_time(ft: FileTime) -> FileTime {

FILE: tests/test_join.rs
  function setup (line 34) | fn setup(name: &str, headers: bool) -> Workdir {
  function make_rows (line 56) | fn make_rows(headers: bool, rows: Vec<Vec<String>>) -> Vec<Vec<String>> {
  function join_inner_issue11 (line 119) | fn join_inner_issue11() {
  function join_cross (line 148) | fn join_cross() {
  function join_cross_no_headers (line 170) | fn join_cross_no_headers() {

FILE: tests/test_partition.rs
  function data (line 12) | fn data(headers: bool) -> Vec<Vec<String>> {
  function partition (line 25) | fn partition() {
  function partition_drop (line 50) | fn partition_drop() {
  function partition_without_headers (line 75) | fn partition_without_headers() {
  function partition_drop_without_headers (line 97) | fn partition_drop_without_headers() {
  function partition_into_new_directory (line 119) | fn partition_into_new_directory() {
  function partition_custom_filename (line 131) | fn partition_custom_filename() {
  function partition_custom_filename_with_directory (line 146) | fn partition_custom_filename_with_directory() {
  function partition_invalid_filename (line 162) | fn partition_invalid_filename() {
  function tricky_data (line 181) | fn tricky_data() -> Vec<Vec<String>> {
  function partition_with_tricky_key_values (line 196) | fn partition_with_tricky_key_values() {
  function prefix_data (line 236) | fn prefix_data() -> Vec<Vec<String>> {
  function partition_with_prefix_length (line 248) | fn partition_with_prefix_length() {

FILE: tests/test_reverse.rs
  function prop_reverse (line 5) | fn prop_reverse(name: &str, rows: CsvData, headers: bool) -> bool {
  function prop_reverse_headers (line 26) | fn prop_reverse_headers() {
  function prop_reverse_no_headers (line 34) | fn prop_reverse_no_headers() {

FILE: tests/test_search.rs
  function data (line 3) | fn data(headers: bool) -> Vec<Vec<String>> {
  function search (line 14) | fn search() {
  function search_empty (line 30) | fn search_empty() {
  function search_empty_no_headers (line 44) | fn search_empty_no_headers() {
  function search_ignore_case (line 57) | fn search_ignore_case() {
  function search_no_headers (line 74) | fn search_no_headers() {
  function search_select (line 90) | fn search_select() {
  function search_select_no_headers (line 106) | fn search_select_no_headers() {
  function search_invert_match (line 122) | fn search_invert_match() {
  function search_invert_match_no_headers (line 138) | fn search_invert_match_no_headers() {

FILE: tests/test_select.rs
  function header_row (line 62) | fn header_row() -> Vec<String> { svec!["h1", "h2", "h[]3", "h4", "h1"] }
  function data (line 64) | fn data(headers: bool) -> Vec<Vec<String>> {

FILE: tests/test_slice.rs
  function setup (line 63) | fn setup(name: &str, headers: bool, use_index: bool)
  function test_slice (line 82) | fn test_slice(name: &str, start: Option<usize>, end: Option<usize>,
  function test_index (line 109) | fn test_index(name: &str, idx: usize, expected: &str,
  function slice_index (line 130) | fn slice_index() {
  function slice_index_no_headers (line 134) | fn slice_index_no_headers() {
  function slice_index_withindex (line 138) | fn slice_index_withindex() {
  function slice_index_no_headers_withindex (line 142) | fn slice_index_no_headers_withindex() {

FILE: tests/test_sort.rs
  function prop_sort (line 7) | fn prop_sort(name: &str, rows: CsvData, headers: bool) -> bool {
  function prop_sort_headers (line 28) | fn prop_sort_headers() {
  function prop_sort_no_headers (line 36) | fn prop_sort_no_headers() {
  function sort_select (line 44) | fn sort_select() {
  function sort_numeric (line 57) | fn sort_numeric() {
  function sort_numeric_non_natural (line 83) | fn sort_numeric_non_natural() {
  function sort_reverse (line 111) | fn sort_reverse() {
  function iter_cmp (line 132) | pub fn iter_cmp<A, L, R>(mut a: L, mut b: R) -> cmp::Ordering

FILE: tests/test_split.rs
  function data (line 14) | fn data(headers: bool) -> Vec<Vec<String>> {
  function split_zero (line 25) | fn split_zero() {
  function split (line 35) | fn split() {
  function split_idx (line 62) | fn split_idx() {
  function split_no_headers (line 89) | fn split_no_headers() {
  function split_no_headers_idx (line 114) | fn split_no_headers_idx() {
  function split_one (line 139) | fn split_one() {
  function split_one_idx (line 174) | fn split_one_idx() {
  function split_uneven (line 209) | fn split_uneven() {
  function split_uneven_idx (line 232) | fn split_uneven_idx() {
  function split_custom_filename (line 255) | fn split_custom_filename() {

FILE: tests/test_stats.rs
  function test_stats (line 59) | fn test_stats<S>(name: S, field: &str, rows: &[&str], expected: &str,
  function setup (line 70) | fn setup<S>(name: S, rows: &[&str], headers: bool,
  function get_field_value (line 91) | fn get_field_value(wrk: &Workdir, cmd: &mut process::Command, field: &str)

FILE: tests/test_table.rs
  function data (line 3) | fn data() -> Vec<Vec<String>> {
  function table (line 12) | fn table() {

FILE: tests/tests.rs
  function qcheck (line 55) | fn qcheck<T: Testable>(p: T) {
  function qcheck_sized (line 59) | fn qcheck_sized<T: Testable>(p: T, size: usize) {
  type CsvVecs (line 63) | pub type CsvVecs = Vec<Vec<String>>;
  type Csv (line 65) | pub trait Csv {
    method to_vecs (line 66) | fn to_vecs(self) -> CsvVecs;
    method from_vecs (line 67) | fn from_vecs(CsvVecs) -> Self;
    method to_vecs (line 71) | fn to_vecs(self) -> CsvVecs { self }
    method from_vecs (line 72) | fn from_vecs(vecs: CsvVecs) -> CsvVecs { vecs }
    method to_vecs (line 112) | fn to_vecs(self) -> CsvVecs {
    method from_vecs (line 115) | fn from_vecs(vecs: CsvVecs) -> Vec<CsvRecord> {
    method to_vecs (line 175) | fn to_vecs(self) -> CsvVecs { unsafe { transmute(self.data) } }
    method from_vecs (line 176) | fn from_vecs(vecs: CsvVecs) -> CsvData {
  type CsvRecord (line 76) | struct CsvRecord(Vec<String>);
    method unwrap (line 79) | fn unwrap(self) -> Vec<String> {
    type Target (line 86) | type Target = [String];
    method deref (line 87) | fn deref<'a>(&'a self) -> &'a [String] { &*self.0 }
    method fmt (line 91) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method arbitrary (line 100) | fn arbitrary<G: Gen>(g: &mut G) -> CsvRecord {
  method shrink (line 105) | fn shrink(&self) -> Box<Iterator<Item=CsvRecord>+'static> {
  type CsvData (line 121) | struct CsvData {
    method unwrap (line 126) | fn unwrap(self) -> Vec<CsvRecord> { self.data }
    method len (line 128) | fn len(&self) -> usize { (&**self).len() }
    method is_empty (line 130) | fn is_empty(&self) -> bool { self.len() == 0 }
    type Target (line 134) | type Target = [CsvRecord];
    method deref (line 135) | fn deref<'a>(&'a self) -> &'a [CsvRecord] { &*self.data }
  method arbitrary (line 139) | fn arbitrary<G: Gen>(g: &mut G) -> CsvData {
  method shrink (line 151) | fn shrink(&self) -> Box<Iterator<Item=CsvData>+'static> {
  method eq (line 184) | fn eq(&self, other: &CsvData) -> bool {

FILE: tests/workdir.rs
  type Workdir (line 19) | pub struct Workdir {
    method new (line 26) | pub fn new(name: &str) -> Workdir {
    method flexible (line 45) | pub fn flexible(mut self, yes: bool) -> Workdir {
    method create (line 50) | pub fn create<T: Csv>(&self, name: &str, rows: T) {
    method create_indexed (line 61) | pub fn create_indexed<T: Csv>(&self, name: &str, rows: T) {
    method read_stdout (line 69) | pub fn read_stdout<T: Csv>(&self, cmd: &mut process::Command) -> T {
    method command (line 85) | pub fn command(&self, sub_command: &str) -> process::Command {
    method output (line 91) | pub fn output(&self, cmd: &mut process::Command) -> process::Output {
    method run (line 109) | pub fn run(&self, cmd: &mut process::Command) {
    method stdout (line 113) | pub fn stdout<T: FromStr>(&self, cmd: &mut process::Command) -> T {
    method assert_err (line 120) | pub fn assert_err(&self, cmd: &mut process::Command) {
    method from_str (line 135) | pub fn from_str<T: FromStr>(&self, name: &Path) -> T {
    method path (line 141) | pub fn path(&self, name: &str) -> PathBuf {
    method xsv_bin (line 145) | pub fn xsv_bin(&self) -> PathBuf {
    method fmt (line 151) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  function create_dir_all (line 159) | fn create_dir_all<P: AsRef<Path>>(p: P) -> io::Result<()> {