SYMBOL INDEX (738 symbols across 52 files)

FILE: build.rs
  function main (line 22) | fn main() -> io::Result<()> {
  function strip_codes (line 51) | fn strip_codes(input: &str) -> String {
  function git_hash (line 58) | fn git_hash() -> String {
  function is_development_version (line 72) | fn is_development_version() -> bool {
  function is_debug_build (line 77) | fn is_debug_build() -> bool {
  function cargo_version (line 82) | fn cargo_version() -> String {
  function version_string (line 87) | fn version_string() -> String {
  function feature_enabled (line 99) | fn feature_enabled(name: &str) -> bool {
  function nonstandard_features_string (line 106) | fn nonstandard_features_string() -> String {
  function build_date (line 120) | fn build_date() -> String {

FILE: src/fs/dir.rs
  type Dir (line 19) | pub struct Dir {
    method read_dir (line 38) | pub fn read_dir(path: PathBuf) -> io::Result<Self> {
    method files (line 50) | pub fn files<'dir, 'ig>(&'dir self, dots: DotFilter, git: Option<&'ig ...
    method contains (line 62) | pub fn contains(&self, path: &Path) -> bool {
    method join (line 67) | pub fn join(&self, child: &Path) -> PathBuf {
  type Files (line 74) | pub struct Files<'dir, 'ig> {
  function parent (line 95) | fn parent(&self) -> PathBuf {
  function next_visible_file (line 106) | fn next_visible_file(&mut self) -> Option<Result<File<'dir>, (PathBuf, i...
  type DotsNext (line 139) | enum DotsNext {
  type Item (line 152) | type Item = Result<File<'dir>, (PathBuf, io::Error)>;
  method next (line 154) | fn next(&mut self) -> Option<Self::Item> {
  type DotFilter (line 180) | pub enum DotFilter {
    method shows_dotfiles (line 201) | fn shows_dotfiles(self) -> bool {
    method dots (line 210) | fn dots(self) -> DotsNext {
  method default (line 193) | fn default() -> Self {

FILE: src/fs/dir_action.rs
  type DirAction (line 23) | pub enum DirAction {
    method recurse_options (line 42) | pub fn recurse_options(self) -> Option<RecurseOptions> {
    method treat_dirs_as_files (line 50) | pub fn treat_dirs_as_files(self) -> bool {
  type RecurseOptions (line 62) | pub struct RecurseOptions {
    method is_too_deep (line 76) | pub fn is_too_deep(self, depth: usize) -> bool {

FILE: src/fs/feature/git.rs
  type GitCache (line 18) | pub struct GitCache {
    method has_anything_for (line 28) | pub fn has_anything_for(&self, index: &Path) -> bool {
    method get (line 32) | pub fn get(&self, index: &Path, prefix_lookup: bool) -> f::Git {
    method from_iter (line 42) | fn from_iter<I>(iter: I) -> Self
  type GitRepo (line 83) | pub struct GitRepo {
    method search (line 134) | fn search(&self, index: &Path, prefix_lookup: bool) -> f::Git {
    method has_workdir (line 152) | fn has_workdir(&self, path: &Path) -> bool {
    method has_path (line 157) | fn has_path(&self, path: &Path) -> bool {
    method discover (line 163) | fn discover(path: PathBuf) -> Result<Self, PathBuf> {
  type GitContents (line 104) | enum GitContents {
    method inner_repo (line 190) | fn inner_repo(self) -> git2::Repository {
  function repo_to_statuses (line 204) | fn repo_to_statuses(repo: &git2::Repository, workdir: &Path) -> Git {
  type Git (line 239) | struct Git {
    method status (line 248) | fn status(&self, index: &Path, prefix_lookup: bool) -> f::Git {
    method file_status (line 256) | fn file_status(&self, file: &Path) -> f::Git {
    method dir_status (line 277) | fn dir_status(&self, dir: &Path) -> f::Git {
  function reorient (line 300) | fn reorient(path: &Path) -> PathBuf {
  function reorient (line 313) | fn reorient(path: &Path) -> PathBuf {
  function working_tree_status (line 321) | fn working_tree_status(status: git2::Status) -> f::GitStatus {
  function index_status (line 336) | fn index_status(status: git2::Status) -> f::GitStatus {

FILE: src/fs/feature/mod.rs
  type GitCache (line 14) | pub struct GitCache;
    method from_iter (line 17) | fn from_iter<I>(_iter: I) -> Self
    method has_anything_for (line 25) | pub fn has_anything_for(&self, _index: &Path) -> bool {
    method get (line 29) | pub fn get(&self, _index: &Path, _prefix_lookup: bool) -> f::Git {

FILE: src/fs/feature/xattr.rs
  constant ENABLED (line 10) | pub const ENABLED: bool = cfg!(any(target_os = "macos", target_os = "lin...
  type FileAttributes (line 13) | pub trait FileAttributes {
    method attributes (line 14) | fn attributes(&self) -> io::Result<Vec<Attribute>>;
    method symlink_attributes (line 15) | fn symlink_attributes(&self) -> io::Result<Vec<Attribute>>;
    method attributes (line 20) | fn attributes(&self) -> io::Result<Vec<Attribute>> {
    method symlink_attributes (line 24) | fn symlink_attributes(&self) -> io::Result<Vec<Attribute>> {
    method attributes (line 31) | fn attributes(&self) -> io::Result<Vec<Attribute>> {
    method symlink_attributes (line 35) | fn symlink_attributes(&self) -> io::Result<Vec<Attribute>> {
  type FollowSymlinks (line 44) | pub enum FollowSymlinks {
  type Attribute (line 51) | pub struct Attribute {
  function list_attrs (line 58) | pub fn list_attrs(lister: &lister::Lister, path: &Path) -> io::Result<Ve...
  function listxattr (line 120) | fn listxattr(
  function getxattr (line 127) | fn getxattr(
  type Lister (line 137) | pub struct Lister {
    method new (line 142) | pub fn new(do_follow: FollowSymlinks) -> Self {
    method translate_attribute_name (line 151) | pub fn translate_attribute_name(&self, input: &[u8]) -> String {
    method listxattr_first (line 155) | pub fn listxattr_first(&self, c_path: &CString) -> ssize_t {
    method listxattr_second (line 166) | pub fn listxattr_second(&self, c_path: &CString, buf: &mut Vec<u8>, bu...
    method getxattr (line 177) | pub fn getxattr(&self, c_path: &CString, buf: &[u8]) -> ssize_t {
    method new (line 233) | pub fn new(follow_symlinks: FollowSymlinks) -> Lister {
    method translate_attribute_name (line 237) | pub fn translate_attribute_name(&self, input: &[u8]) -> String {
    method listxattr_first (line 241) | pub fn listxattr_first(&self, c_path: &CString) -> ssize_t {
    method listxattr_second (line 256) | pub fn listxattr_second(&self, c_path: &CString, buf: &mut Vec<u8>, bu...
    method getxattr (line 271) | pub fn getxattr(&self, c_path: &CString, buf: &[u8]) -> ssize_t {
  function listxattr (line 201) | fn listxattr(
  function llistxattr (line 207) | fn llistxattr(
  function getxattr (line 213) | fn getxattr(
  function lgetxattr (line 220) | fn lgetxattr(
  type Lister (line 228) | pub struct Lister {
    method new (line 142) | pub fn new(do_follow: FollowSymlinks) -> Self {
    method translate_attribute_name (line 151) | pub fn translate_attribute_name(&self, input: &[u8]) -> String {
    method listxattr_first (line 155) | pub fn listxattr_first(&self, c_path: &CString) -> ssize_t {
    method listxattr_second (line 166) | pub fn listxattr_second(&self, c_path: &CString, buf: &mut Vec<u8>, bu...
    method getxattr (line 177) | pub fn getxattr(&self, c_path: &CString, buf: &[u8]) -> ssize_t {
    method new (line 233) | pub fn new(follow_symlinks: FollowSymlinks) -> Lister {
    method translate_attribute_name (line 237) | pub fn translate_attribute_name(&self, input: &[u8]) -> String {
    method listxattr_first (line 241) | pub fn listxattr_first(&self, c_path: &CString) -> ssize_t {
    method listxattr_second (line 256) | pub fn listxattr_second(&self, c_path: &CString, buf: &mut Vec<u8>, bu...
    method getxattr (line 271) | pub fn getxattr(&self, c_path: &CString, buf: &[u8]) -> ssize_t {

FILE: src/fs/fields.rs
  type blkcnt_t (line 20) | pub type blkcnt_t = u64;
  type gid_t (line 23) | pub type gid_t = u32;
  type ino_t (line 26) | pub type ino_t = u64;
  type nlink_t (line 29) | pub type nlink_t = u64;
  type time_t (line 32) | pub type time_t = i64;
  type uid_t (line 35) | pub type uid_t = u32;
  type Type (line 47) | pub enum Type {
    method is_regular_file (line 59) | pub fn is_regular_file(self) -> bool {
  type Permissions (line 67) | pub struct Permissions {
  type Attributes (line 87) | pub struct Attributes {
  type PermissionsPlus (line 100) | pub struct PermissionsPlus {
  type OctalPermissions (line 112) | pub struct OctalPermissions {
  type Links (line 123) | pub struct Links {
  type Inode (line 137) | pub struct Inode(pub ino_t);
  type Blocks (line 142) | pub enum Blocks {
  type User (line 155) | pub struct User(pub uid_t);
  type Group (line 159) | pub struct Group(pub gid_t);
  type Size (line 165) | pub enum Size {
  type DeviceIDs (line 196) | pub struct DeviceIDs {
  type Time (line 204) | pub struct Time {
  type GitStatus (line 214) | pub enum GitStatus {
  type Git (line 247) | pub struct Git {
  method default (line 255) | fn default() -> Self {

FILE: src/fs/file.rs
  type File (line 24) | pub struct File<'dir> {
  function from_args (line 72) | pub fn from_args<PD, FN>(path: PathBuf, parent_dir: PD, filename: FN) ->...
  function new_aa_current (line 87) | pub fn new_aa_current(parent_dir: &'dir Dir) -> io::Result<File<'dir>> {
  function new_aa_parent (line 99) | pub fn new_aa_parent(path: PathBuf, parent_dir: &'dir Dir) -> io::Result...
  function filename (line 113) | pub fn filename(path: &Path) -> String {
  function ext (line 132) | fn ext(path: &Path) -> Option<String> {
  function is_directory (line 141) | pub fn is_directory(&self) -> bool {
  function points_to_directory (line 146) | pub fn points_to_directory(&self) -> bool {
  function to_dir (line 167) | pub fn to_dir(&self) -> io::Result<Dir> {
  function is_file (line 173) | pub fn is_file(&self) -> bool {
  function is_executable_file (line 181) | pub fn is_executable_file(&self) -> bool {
  function is_link (line 187) | pub fn is_link(&self) -> bool {
  function is_pipe (line 193) | pub fn is_pipe(&self) -> bool {
  function is_char_device (line 199) | pub fn is_char_device(&self) -> bool {
  function is_block_device (line 205) | pub fn is_block_device(&self) -> bool {
  function is_socket (line 211) | pub fn is_socket(&self) -> bool {
  function reorient_target_path (line 219) | fn reorient_target_path(&self, path: &Path) -> PathBuf {
  function link_target (line 244) | pub fn link_target(&self) -> FileTarget<'dir> {
  function links (line 282) | pub fn links(&self) -> f::Links {
  function inode (line 293) | pub fn inode(&self) -> f::Inode {
  function blocks (line 301) | pub fn blocks(&self) -> f::Blocks {
  function user (line 312) | pub fn user(&self) -> f::User {
  function group (line 318) | pub fn group(&self) -> f::Group {
  function size (line 331) | pub fn size(&self) -> f::Size {
  function size (line 353) | pub fn size(&self) -> f::Size {
  function modified_time (line 363) | pub fn modified_time(&self) -> Option<SystemTime> {
  function changed_time (line 369) | pub fn changed_time(&self) -> Option<SystemTime> {
  function changed_time (line 388) | pub fn changed_time(&self) -> Option<SystemTime> {
  function accessed_time (line 393) | pub fn accessed_time(&self) -> Option<SystemTime> {
  function created_time (line 398) | pub fn created_time(&self) -> Option<SystemTime> {
  function type_char (line 408) | pub fn type_char(&self) -> f::Type {
  function type_char (line 436) | pub fn type_char(&self) -> f::Type {
  function permissions (line 450) | pub fn permissions(&self) -> f::Permissions {
  function attributes (line 474) | pub fn attributes(&self) -> f::Attributes {
  function extension_is_one_of (line 492) | pub fn extension_is_one_of(&self, choices: &[&str]) -> bool {
  function name_is_one_of (line 501) | pub fn name_is_one_of(&self, choices: &[&str]) -> bool {
  function as_ref (line 508) | fn as_ref(&self) -> &File<'a> {
  type FileTarget (line 515) | pub enum FileTarget<'dir> {
  function is_broken (line 538) | pub fn is_broken(&self) -> bool {
  type Mode (line 551) | pub type Mode = u32;
  constant USER_READ (line 553) | pub const USER_READ: Mode     = libc::S_IRUSR as Mode;
  constant USER_WRITE (line 554) | pub const USER_WRITE: Mode    = libc::S_IWUSR as Mode;
  constant USER_EXECUTE (line 555) | pub const USER_EXECUTE: Mode  = libc::S_IXUSR as Mode;
  constant GROUP_READ (line 557) | pub const GROUP_READ: Mode    = libc::S_IRGRP as Mode;
  constant GROUP_WRITE (line 558) | pub const GROUP_WRITE: Mode   = libc::S_IWGRP as Mode;
  constant GROUP_EXECUTE (line 559) | pub const GROUP_EXECUTE: Mode = libc::S_IXGRP as Mode;
  constant OTHER_READ (line 561) | pub const OTHER_READ: Mode    = libc::S_IROTH as Mode;
  constant OTHER_WRITE (line 562) | pub const OTHER_WRITE: Mode   = libc::S_IWOTH as Mode;
  constant OTHER_EXECUTE (line 563) | pub const OTHER_EXECUTE: Mode = libc::S_IXOTH as Mode;
  constant STICKY (line 565) | pub const STICKY: Mode        = libc::S_ISVTX as Mode;
  constant SETGID (line 566) | pub const SETGID: Mode        = libc::S_ISGID as Mode;
  constant SETUID (line 567) | pub const SETUID: Mode        = libc::S_ISUID as Mode;
  function extension (line 577) | fn extension() {
  function dotfile (line 582) | fn dotfile() {
  function no_extension (line 587) | fn no_extension() {
  function file (line 599) | fn file() {
  function no_path (line 604) | fn no_path() {
  function here (line 609) | fn here() {
  function there (line 614) | fn there() {
  function everywhere (line 619) | fn everywhere() {
  function topmost (line 625) | fn topmost() {

FILE: src/fs/filter.rs
  type FileFilter (line 27) | pub struct FileFilter {
    method filter_child_files (line 68) | pub fn filter_child_files(&self, files: &mut Vec<File<'_>>) {
    method filter_argument_files (line 85) | pub fn filter_argument_files(&self, files: &mut Vec<File<'_>>) {
    method sort_files (line 92) | pub fn sort_files<'a, F>(&self, files: &mut [F])
  type SortField (line 117) | pub enum SortField {
    method compare_files (line 218) | pub fn compare_files(self, a: &File<'_>, b: &File<'_>) -> Ordering {
    method strip_dot (line 262) | fn strip_dot(n: &str) -> &str {
  type SortCase (line 198) | pub enum SortCase {
  type IgnorePatterns (line 275) | pub struct IgnorePatterns {
    method from_iter (line 281) | fn from_iter<I>(iter: I) -> Self
    method parse_from_iter (line 294) | pub fn parse_from_iter<'a, I: IntoIterator<Item = &'a str>>(iter: I) -...
    method empty (line 318) | pub fn empty() -> Self {
    method is_ignored (line 323) | fn is_ignored(&self, file: &str) -> bool {
  type GitIgnore (line 331) | pub enum GitIgnore {
  function empty_matches_nothing (line 347) | fn empty_matches_nothing() {
  function ignores_a_glob (line 354) | fn ignores_a_glob() {
  function ignores_an_exact_filename (line 362) | fn ignores_an_exact_filename() {
  function ignores_both (line 370) | fn ignores_both() {

FILE: src/info/filetype.rs
  type FileExtensions (line 15) | pub struct FileExtensions;
    method is_immediate (line 23) | fn is_immediate(&self, file: &File<'_>) -> bool {
    method is_image (line 36) | fn is_image(&self, file: &File<'_>) -> bool {
    method is_video (line 46) | fn is_video(&self, file: &File<'_>) -> bool {
    method is_music (line 53) | fn is_music(&self, file: &File<'_>) -> bool {
    method is_lossless (line 60) | fn is_lossless(&self, file: &File<'_>) -> bool {
    method is_crypto (line 66) | fn is_crypto(&self, file: &File<'_>) -> bool {
    method is_document (line 72) | fn is_document(&self, file: &File<'_>) -> bool {
    method is_compressed (line 80) | fn is_compressed(&self, file: &File<'_>) -> bool {
    method is_temp (line 88) | fn is_temp(&self, file: &File<'_>) -> bool {
    method is_compiled (line 94) | fn is_compiled(&self, file: &File<'_>) -> bool {
  method colour_file (line 108) | fn colour_file(&self, file: &File<'_>) -> Option<Style> {
  method icon_file (line 128) | fn icon_file(&self, file: &File<'_>) -> Option<char> {

FILE: src/info/sources.rs
  function get_source_files (line 16) | pub fn get_source_files(&self) -> Vec<PathBuf> {

FILE: src/logger.rs
  function configure (line 10) | pub fn configure<T: AsRef<OsStr>>(ev: Option<T>) {
  type Logger (line 36) | struct Logger;
    method enabled (line 41) | fn enabled(&self, _: &log::Metadata<'_>) -> bool {
    method log (line 45) | fn log(&self, record: &log::Record<'_>) {
    method flush (line 53) | fn flush(&self) {
  constant GLOBAL_LOGGER (line 38) | const GLOBAL_LOGGER: &Logger = &Logger;
  function level (line 58) | fn level(level: log::Level) -> ANSIString<'static> {

FILE: src/main.rs
  function main (line 49) | fn main() {
  type Exa (line 120) | pub struct Exa<'args> {
  type LiveVars (line 150) | struct LiveVars;
  method get (line 152) | fn get(&self, name: &'static str) -> Option<OsString> {
  function git_options (line 159) | fn git_options(options: &Options, args: &[&OsStr]) -> Option<GitCache> {
  function run (line 172) | pub fn run(mut self) -> io::Result<i32> {
  function print_dirs (line 213) | fn print_dirs(&mut self, dir_files: Vec<Dir>, mut first: bool, is_only_d...
  function print_files (line 271) | fn print_files(&mut self, dir: Option<&Dir>, files: Vec<File<'_>>) -> io...
  constant SUCCESS (line 334) | pub const SUCCESS: i32 = 0;
  constant RUNTIME_ERROR (line 337) | pub const RUNTIME_ERROR: i32 = 1;
  constant OPTIONS_ERROR (line 340) | pub const OPTIONS_ERROR: i32 = 3;

FILE: src/options/dir_action.rs
  method deduce (line 15) | pub fn deduce(matches: &MatchedFlags<'_>, can_tree: bool) -> Result<Self...
  method deduce (line 57) | pub fn deduce(matches: &MatchedFlags<'_>, tree: bool) -> Result<Self, Op...

FILE: src/options/error.rs
  type OptionsError (line 11) | pub enum OptionsError {
    method from (line 58) | fn from(error: glob::PatternError) -> Self {
    method fmt (line 73) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method suggestion (line 104) | pub fn suggestion(&self) -> Option<&'static str> {
  type NumberSource (line 48) | pub enum NumberSource {
    method fmt (line 64) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Choices (line 123) | pub struct Choices(pub &'static [&'static str]);
    method fmt (line 126) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: src/options/file_name.rs
  method deduce (line 9) | pub fn deduce<V: Vars>(matches: &MatchedFlags<'_>, vars: &V) -> Result<S...
  method deduce (line 18) | fn deduce(matches: &MatchedFlags<'_>) -> Result<Self, OptionsError> {
  method deduce (line 27) | pub fn deduce<V: Vars>(matches: &MatchedFlags<'_>, vars: &V) -> Result<S...

FILE: src/options/filter.rs
  method deduce (line 13) | pub fn deduce(matches: &MatchedFlags<'_>) -> Result<Self, OptionsError> {
  method deduce (line 32) | fn deduce(matches: &MatchedFlags<'_>) -> Result<Self, OptionsError> {
  method default (line 143) | fn default() -> Self {
  method deduce (line 157) | pub fn deduce(matches: &MatchedFlags<'_>) -> Result<Self, OptionsError> {
  method deduce (line 184) | pub fn deduce(matches: &MatchedFlags<'_>) -> Result<Self, OptionsError> {
  method deduce (line 208) | pub fn deduce(matches: &MatchedFlags<'_>) -> Result<Self, OptionsError> {
  function pat (line 299) | fn pat(string: &'static str) -> glob::Pattern {

FILE: src/options/flags.rs
  constant COLOURS (line 19) | const COLOURS: &[&str] = &["always", "auto", "never"];
  constant SORTS (line 34) | const SORTS: Values = &[ "name", "Name", "size", "extension",
  constant TIMES (line 54) | const TIMES: Values = &["modified", "changed", "accessed", "created"];
  constant TIME_STYLES (line 55) | const TIME_STYLES: Values = &["default", "long-iso", "full-iso", "iso"];

FILE: src/options/help.rs
  type HelpString (line 73) | pub struct HelpString;
    method deduce (line 84) | pub fn deduce(matches: &MatchedFlags<'_>) -> Option<Self> {
    method fmt (line 98) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
  function help (line 126) | fn help() {
  function help_with_file (line 133) | fn help_with_file() {
  function unhelpful (line 140) | fn unhelpful() {

FILE: src/options/mod.rs
  type Options (line 105) | pub struct Options {
    method parse (line 130) | pub fn parse<'args, I, V>(args: I, vars: &V) -> OptionsResult<'args>
    method should_scan_for_git (line 164) | pub fn should_scan_for_git(&self) -> bool {
    method deduce (line 178) | fn deduce<V: Vars>(matches: &MatchedFlags<'_>, vars: &V) -> Result<Sel...
  type OptionsResult (line 198) | pub enum OptionsResult<'args> {
  type Strictnesses (line 220) | pub enum Strictnesses {
  function parse_for_test (line 232) | pub fn parse_for_test<T, F>(inputs: &[&str], args: &'static [&'static Ar...

FILE: src/options/parser.rs
  type ShortArg (line 38) | pub type ShortArg = u8;
  type LongArg (line 44) | pub type LongArg = &'static str;
  type Values (line 51) | pub type Values = &'static [&'static str];
  type Flag (line 56) | pub enum Flag {
    method matches (line 62) | pub fn matches(&self, arg: &Arg) -> bool {
    method fmt (line 71) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
  type Strictness (line 81) | pub enum Strictness {
  type TakesValue (line 95) | pub enum TakesValue {
  type Arg (line 112) | pub struct Arg {
    method fmt (line 126) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
  type Args (line 140) | pub struct Args(pub &'static [&'static Arg]);
    method parse (line 146) | pub fn parse<'args, I>(&self, inputs: I, strictness: Strictness) -> Re...
    method lookup_short (line 326) | fn lookup_short(&self, short: ShortArg) -> Result<&Arg, ParseError> {
    method lookup_long (line 333) | fn lookup_long<'b>(&self, long: &'b OsStr) -> Result<&Arg, ParseError> {
  type Matches (line 344) | pub struct Matches<'args> {
  type MatchedFlags (line 355) | pub struct MatchedFlags<'args> {
  function has (line 374) | pub fn has(&self, arg: &'static Arg) -> Result<bool, OptionsError> {
  function has_where (line 384) | pub fn has_where<P>(&self, predicate: P) -> Result<Option<&Flag>, Option...
  function has_where_any (line 403) | pub fn has_where_any<P>(&self, predicate: P) -> Option<&Flag>
  function get (line 417) | pub fn get(&self, arg: &'static Arg) -> Result<Option<&OsStr>, OptionsEr...
  function get_where (line 426) | pub fn get_where<P>(&self, predicate: P) -> Result<Option<&OsStr>, Optio...
  function count (line 449) | pub fn count(&self, arg: &Arg) -> usize {
  function is_strict (line 457) | pub fn is_strict(&self) -> bool {
  type ParseError (line 466) | pub enum ParseError {
    method fmt (line 485) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function os_str_to_bytes (line 497) | fn os_str_to_bytes<'b>(s: &'b OsStr) ->  &'b [u8]{
  function bytes_to_os_str (line 504) | fn bytes_to_os_str<'b>(b:  &'b [u8]) ->  &'b OsStr{
  function os_str_to_bytes (line 511) | fn os_str_to_bytes<'b>(s: &'b OsStr) ->  &'b [u8]{
  function bytes_to_os_str (line 516) | fn bytes_to_os_str<'b>(b:  &'b [u8]) ->  &'b OsStr{
  function split_on_equals (line 524) | fn split_on_equals(input: &OsStr) -> Option<(&OsStr, &OsStr)> {
  constant SUGGESTIONS (line 615) | const SUGGESTIONS: Values = &[ "example" ];
  function only_count (line 717) | fn only_count() {
  function rightmost_count (line 729) | fn rightmost_count() {
  function no_count (line 743) | fn no_count() {

FILE: src/options/theme.rs
  method deduce (line 7) | pub fn deduce<V: Vars>(matches: &MatchedFlags<'_>, vars: &V) -> Result<S...
  method deduce (line 24) | fn deduce<V: Vars>(matches: &MatchedFlags<'_>, vars: &V) -> Result<Self,...
  method deduce (line 52) | fn deduce(matches: &MatchedFlags<'_>) -> Result<Self, OptionsError> {
  method deduce (line 64) | fn deduce<V: Vars>(vars: &V) -> Self {
  type MockVars (line 125) | struct MockVars {
    method empty (line 132) | fn empty() -> MockVars {
    method with_no_color (line 139) | fn with_no_color() -> MockVars {
  method get (line 150) | fn get(&self, name: &'static str) -> Option<OsString> {

FILE: src/options/vars.rs
  type Vars (line 53) | pub trait Vars {
    method get (line 54) | fn get(&self, name: &'static str) -> Option<OsString>;
    method get (line 61) | fn get(&self, _name: &'static str) -> Option<OsString> {

FILE: src/options/version.rs
  type VersionString (line 12) | pub struct VersionString;
    method deduce (line 22) | pub fn deduce(matches: &MatchedFlags<'_>) -> Option<Self> {
    method fmt (line 33) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
  function version (line 45) | fn version() {
  function version_with_file (line 52) | fn version_with_file() {

FILE: src/options/view.rs
  method deduce (line 12) | pub fn deduce<V: Vars>(matches: &MatchedFlags<'_>, vars: &V) -> Result<S...
  method deduce (line 31) | pub fn deduce<V: Vars>(matches: &MatchedFlags<'_>, vars: &V) -> Result<S...
  method strict_check_long_flags (line 79) | fn strict_check_long_flags(matches: &MatchedFlags<'_>) -> Result<(), Opt...
  function deduce (line 104) | fn deduce(matches: &MatchedFlags<'_>) -> Result<Self, OptionsError> {
  function deduce_tree (line 115) | fn deduce_tree(matches: &MatchedFlags<'_>) -> Result<Self, OptionsError> {
  function deduce_long (line 125) | fn deduce_long<V: Vars>(matches: &MatchedFlags<'_>, vars: &V) -> Result<...
  method deduce (line 145) | fn deduce<V: Vars>(vars: &V) -> Result<Self, OptionsError> {
  method deduce (line 167) | fn deduce<V: Vars>(vars: &V) -> Result<Self, OptionsError> {
  method deduce (line 189) | fn deduce<V: Vars>(matches: &MatchedFlags<'_>, vars: &V) -> Result<Self,...
  method deduce (line 200) | fn deduce(matches: &MatchedFlags<'_>) -> Result<Self, OptionsError> {
  method deduce (line 229) | fn deduce(matches: &MatchedFlags<'_>) -> Result<Self, OptionsError> {
  method deduce (line 244) | fn deduce<V: Vars>(matches: &MatchedFlags<'_>, vars: &V) -> Result<Self,...
  method deduce (line 277) | fn deduce(matches: &MatchedFlags<'_>) -> Result<Self, OptionsError> {
  method deduce (line 296) | fn deduce(matches: &MatchedFlags<'_>) -> Result<Self, OptionsError> {

FILE: src/output/cell.rs
  type TextCell (line 21) | pub struct TextCell {
    method paint (line 42) | pub fn paint(style: Style, text: String) -> Self {
    method paint_str (line 54) | pub fn paint_str(style: Style, text: &'static str) -> Self {
    method blank (line 69) | pub fn blank(style: Style) -> Self {
    method add_spaces (line 79) | pub fn add_spaces(&mut self, count: usize) {
    method push (line 87) | pub fn push(&mut self, string: ANSIString<'static>, extra_width: usize) {
    method append (line 93) | pub fn append(&mut self, other: Self) {
  type Target (line 31) | type Target = TextCellContents;
  method deref (line 33) | fn deref(&self) -> &Self::Target {
  type TextCellContents (line 134) | pub struct TextCellContents(Vec<ANSIString<'static>>);
    method from (line 137) | fn from(strings: Vec<ANSIString<'static>>) -> Self {
    method strings (line 158) | pub fn strings(&self) -> ANSIStrings<'_> {
    method width (line 164) | pub fn width(&self) -> DisplayWidth {
    method promote (line 172) | pub fn promote(self) -> TextCell {
  type Target (line 143) | type Target = [ANSIString<'static>];
  method deref (line 145) | fn deref(&self) -> &Self::Target {
  type DisplayWidth (line 195) | pub struct DisplayWidth(usize);
    method from (line 198) | fn from(input: &'a str) -> Self {
    method from (line 204) | fn from(width: usize) -> Self {
    type Output (line 232) | type Output = Self;
    method add (line 234) | fn add(self, rhs: usize) -> Self::Output {
  type Target (line 210) | type Target = usize;
  method deref (line 212) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 218) | fn deref_mut(&mut self) -> &mut Self::Target {
  type Output (line 224) | type Output = Self;
  method add (line 226) | fn add(self, rhs: Self) -> Self::Output {
  method sum (line 240) | fn sum<I>(iter: I) -> Self
  function empty_string (line 253) | fn empty_string() {
  function test_string (line 259) | fn test_string() {
  function addition (line 265) | fn addition() {
  function addition_usize (line 272) | fn addition_usize() {

FILE: src/output/details.rs
  type Options (line 95) | pub struct Options {
  type Render (line 111) | pub struct Render<'a> {
  type Egg (line 133) | struct Egg<'a> {
  function as_ref (line 142) | fn as_ref(&self) -> &File<'a> {
  function render (line 149) | pub fn render<W: Write>(mut self, w: &mut W) -> io::Result<()> {
  function add_files_to_table (line 194) | fn add_files_to_table<'dir>(&self, pool: &mut Pool, table: &mut Option<T...
  function render_header (line 346) | pub fn render_header(&self, header: TableRow) -> Row {
  function render_error (line 354) | fn render_error(&self, error: &io::Error, tree: TreeParams, path: Option...
  function render_xattr (line 369) | fn render_xattr(&self, xattr: &Attribute, tree: TreeParams) -> Row {
  function render_file (line 374) | pub fn render_file(&self, cells: TableRow, name: TextCell, tree: TreePar...
  function iterate_with_table (line 378) | pub fn iterate_with_table(&'a self, table: Table<'a>, rows: Vec<Row>) ->...
  function iterate (line 388) | pub fn iterate(&'a self, rows: Vec<Row>) -> Iter {
  type Row (line 398) | pub struct Row {
  type TableIter (line 417) | pub struct TableIter<'a> {
  type Item (line 427) | type Item = TextCell;
  method next (line 429) | fn next(&mut self) -> Option<Self::Item> {
  type Iter (line 458) | pub struct Iter {
  type Item (line 465) | type Item = TextCell;
  method next (line 467) | fn next(&mut self) -> Option<Self::Item> {

FILE: src/output/escape.rs
  function escape (line 4) | pub fn escape(string: String, bits: &mut Vec<ANSIString<'_>>, good: Styl...

FILE: src/output/file_name.rs
  type Options (line 15) | pub struct Options {
    method for_file (line 28) | pub fn for_file<'a, 'dir, C>(self, file: &'a File<'dir>, colours: &'a ...
  type LinkStyle (line 43) | enum LinkStyle {
  type Classify (line 58) | pub enum Classify {
  method default (line 69) | fn default() -> Self {
  type ShowIcons (line 77) | pub enum ShowIcons {
  type FileName (line 90) | pub struct FileName<'a, 'dir, C> {
  function with_link_paths (line 111) | pub fn with_link_paths(mut self) -> Self {
  function paint (line 125) | pub fn paint(&self) -> TextCellContents {
  function add_parent_bits (line 225) | fn add_parent_bits(&self, bits: &mut Vec<ANSIString<'_>>, parent: &Path) {
  function classify_char (line 245) | fn classify_char(&self, file: &File<'_>) -> Option<&'static str> {
  function classify_char (line 267) | fn classify_char(&self, file: &File<'_>) -> Option<&'static str> {
  function coloured_file_name (line 289) | fn coloured_file_name<'unused>(&self) -> Vec<ANSIString<'unused>> {
  function style (line 307) | pub fn style(&self) -> Style {
  type Colours (line 337) | pub trait Colours: FiletypeColours {
    method symlink_path (line 341) | fn symlink_path(&self) -> Style;
    method normal_arrow (line 344) | fn normal_arrow(&self) -> Style;
    method broken_symlink (line 349) | fn broken_symlink(&self) -> Style;
    method broken_filename (line 352) | fn broken_filename(&self) -> Style;
    method control_char (line 355) | fn control_char(&self) -> Style;
    method broken_control_char (line 359) | fn broken_control_char(&self) -> Style;
    method executable_file (line 362) | fn executable_file(&self) -> Style;
    method colour_file (line 364) | fn colour_file(&self, file: &File<'_>) -> Style;
  function spaces (line 369) | fn spaces(width: u32) -> String {

FILE: src/output/grid.rs
  type Options (line 12) | pub struct Options {
    method direction (line 17) | pub fn direction(self) -> tg::Direction {
  type Render (line 24) | pub struct Render<'a> {
  function render (line 34) | pub fn render<W: Write>(mut self, w: &mut W) -> io::Result<()> {

FILE: src/output/grid_details.rs
  type Options (line 22) | pub struct Options {
    method to_details_options (line 29) | pub fn to_details_options(&self) -> &DetailsOptions {
  type RowThreshold (line 43) | pub enum RowThreshold {
  type Render (line 54) | pub struct Render<'a> {
  function details_for_column (line 101) | fn details_for_column(&self) -> DetailsRender<'a> {
  function give_up (line 119) | pub fn give_up(self) -> DetailsRender<'a> {
  function render (line 136) | pub fn render<W: Write>(mut self, w: &mut W) -> io::Result<()> {
  function find_fitting_grid (line 145) | pub fn find_fitting_grid(&mut self) -> Option<(grid::Grid, grid::Width)> {
  function make_table (line 198) | fn make_table(&mut self, options: &'a TableOptions, drender: &DetailsRen...
  function make_grid (line 217) | fn make_grid(&mut self, column_count: usize, options: &'a TableOptions, ...
  function divide_rounding_up (line 293) | fn divide_rounding_up(a: usize, b: usize) -> usize {
  function file_has_xattrs (line 304) | fn file_has_xattrs(file: &File<'_>) -> bool {

FILE: src/output/icons.rs
  type FileIcon (line 9) | pub trait FileIcon {
    method icon_file (line 10) | fn icon_file(&self, file: &File<'_>) -> Option<char>;
  type Icons (line 15) | pub enum Icons {
    method value (line 22) | pub fn value(self) -> char {
  function iconify_style (line 40) | pub fn iconify_style(style: Style) -> Style {
  function icon_for_file (line 96) | pub fn icon_for_file(file: &File<'_>) -> char {

FILE: src/output/lines.rs
  type Render (line 13) | pub struct Render<'a> {
  function render (line 21) | pub fn render<W: Write>(mut self, w: &mut W) -> io::Result<()> {
  function render_file (line 31) | fn render_file<'f>(&self, file: &'f File<'a>) -> TextCellContents {

FILE: src/output/mod.rs
  type View (line 21) | pub struct View {
  type Mode (line 31) | pub enum Mode {
  type TerminalWidth (line 41) | pub enum TerminalWidth {
    method actual_terminal_width (line 51) | pub fn actual_terminal_width(self) -> Option<usize> {

FILE: src/output/render/blocks.rs
  function render (line 8) | pub fn render<C: Colours>(&self, colours: &C) -> TextCell {
  type Colours (line 17) | pub trait Colours {
    method block_count (line 18) | fn block_count(&self) -> Style;
    method no_blocks (line 19) | fn no_blocks(&self) -> Style;
    method block_count (line 36) | fn block_count(&self) -> Style { Red.blink() }
    method no_blocks (line 37) | fn no_blocks(&self)   -> Style { Green.italic() }
  type TestColours (line 33) | struct TestColours;
  function blocklessness (line 42) | fn blocklessness() {
  function blockfulity (line 51) | fn blockfulity() {

FILE: src/output/render/filetype.rs
  function render (line 7) | pub fn render<C: Colours>(self, colours: &C) -> ANSIString<'static> {
  type Colours (line 22) | pub trait Colours {
    method normal (line 23) | fn normal(&self) -> Style;
    method directory (line 24) | fn directory(&self) -> Style;
    method pipe (line 25) | fn pipe(&self) -> Style;
    method symlink (line 26) | fn symlink(&self) -> Style;
    method block_device (line 27) | fn block_device(&self) -> Style;
    method char_device (line 28) | fn char_device(&self) -> Style;
    method socket (line 29) | fn socket(&self) -> Style;
    method special (line 30) | fn special(&self) -> Style;

FILE: src/output/render/git.rs
  function render (line 8) | pub fn render(self, colours: &dyn Colours) -> TextCell {
  function render (line 21) | fn render(self, colours: &dyn Colours) -> ANSIString<'static> {
  type Colours (line 36) | pub trait Colours {
    method not_modified (line 37) | fn not_modified(&self) -> Style;
    method new (line 39) | fn new(&self) -> Style;
    method modified (line 40) | fn modified(&self) -> Style;
    method deleted (line 41) | fn deleted(&self) -> Style;
    method renamed (line 42) | fn renamed(&self) -> Style;
    method type_change (line 43) | fn type_change(&self) -> Style;
    method ignored (line 44) | fn ignored(&self) -> Style;
    method conflicted (line 45) | fn conflicted(&self) -> Style;
    method not_modified (line 62) | fn not_modified(&self) -> Style { Fixed(90).normal() }
    method new (line 63) | fn new(&self)          -> Style { Fixed(91).normal() }
    method modified (line 64) | fn modified(&self)     -> Style { Fixed(92).normal() }
    method deleted (line 65) | fn deleted(&self)      -> Style { Fixed(93).normal() }
    method renamed (line 66) | fn renamed(&self)      -> Style { Fixed(94).normal() }
    method type_change (line 67) | fn type_change(&self)  -> Style { Fixed(95).normal() }
    method ignored (line 68) | fn ignored(&self)      -> Style { Fixed(96).normal() }
    method conflicted (line 69) | fn conflicted(&self)   -> Style { Fixed(97).normal() }
  type TestColours (line 59) | struct TestColours;
  function git_blank (line 74) | fn git_blank() {
  function git_new_changed (line 93) | fn git_new_changed() {

FILE: src/output/render/groups.rs
  function render (line 10) | pub fn render<C: Colours, U: Users+Groups>(self, colours: &C, users: &U,...
  type Colours (line 40) | pub trait Colours {
    method yours (line 41) | fn yours(&self) -> Style;
    method not_yours (line 42) | fn not_yours(&self) -> Style;
    method yours (line 64) | fn yours(&self)     -> Style { Fixed(80).normal() }
    method not_yours (line 65) | fn not_yours(&self) -> Style { Fixed(81).normal() }
  type TestColours (line 61) | struct TestColours;
  function named (line 70) | fn named() {
  function unnamed (line 84) | fn unnamed() {
  function primary (line 94) | fn primary() {
  function secondary (line 105) | fn secondary() {
  function overflow (line 118) | fn overflow() {

FILE: src/output/render/inode.rs
  function render (line 8) | pub fn render(self, style: Style) -> TextCell {
  function blocklessness (line 23) | fn blocklessness() {

FILE: src/output/render/links.rs
  function render (line 9) | pub fn render<C: Colours>(&self, colours: &C, numeric: &NumericLocale) -...
  type Colours (line 18) | pub trait Colours {
    method normal (line 19) | fn normal(&self) -> Style;
    method multi_link_file (line 20) | fn multi_link_file(&self) -> Style;
    method normal (line 38) | fn normal(&self)           -> Style { Blue.normal() }
    method multi_link_file (line 39) | fn multi_link_file(&self)  -> Style { Blue.on(Red) }
  type TestColours (line 35) | struct TestColours;
  function regular_file (line 44) | fn regular_file() {
  function regular_directory (line 59) | fn regular_directory() {
  function popular_file (line 74) | fn popular_file() {

FILE: src/output/render/octal.rs
  function bits_to_octal (line 8) | fn bits_to_octal(r: bool, w: bool, x: bool) -> u8 {
  function render (line 12) | pub fn render(&self, style: Style) -> TextCell {
  function normal_folder (line 33) | fn normal_folder() {
  function normal_file (line 47) | fn normal_file() {
  function secret_file (line 61) | fn secret_file() {
  function sticky1 (line 75) | fn sticky1() {
  function sticky2 (line 90) | fn sticky2() {
  function sticky3 (line 104) | fn sticky3() {

FILE: src/output/render/permissions.rs
  function render (line 10) | pub fn render<C: Colours+FiletypeColours>(&self, colours: &C) -> TextCell {
  function render (line 28) | pub fn render<C: Colours+FiletypeColours>(&self, colours: &C) -> TextCell {
  function render (line 41) | pub fn render<C: Colours>(&self, colours: &C, is_regular_file: bool) -> ...
  function user_execute_bit (line 61) | fn user_execute_bit<C: Colours>(&self, colours: &C, is_regular_file: boo...
  function group_execute_bit (line 72) | fn group_execute_bit<C: Colours>(&self, colours: &C) -> ANSIString<'stat...
  function other_execute_bit (line 81) | fn other_execute_bit<C: Colours>(&self, colours: &C) -> ANSIString<'stat...
  function render (line 92) | pub fn render<C: Colours+FiletypeColours>(&self, colours: &C) -> Vec<ANS...
  function render_type (line 106) | pub fn render_type<C: Colours+FiletypeColours>(&self, colours: &C) -> AN...
  type Colours (line 119) | pub trait Colours {
    method dash (line 120) | fn dash(&self) -> Style;
    method user_read (line 122) | fn user_read(&self) -> Style;
    method user_write (line 123) | fn user_write(&self) -> Style;
    method user_execute_file (line 124) | fn user_execute_file(&self) -> Style;
    method user_execute_other (line 125) | fn user_execute_other(&self) -> Style;
    method group_read (line 127) | fn group_read(&self) -> Style;
    method group_write (line 128) | fn group_write(&self) -> Style;
    method group_execute (line 129) | fn group_execute(&self) -> Style;
    method other_read (line 131) | fn other_read(&self) -> Style;
    method other_write (line 132) | fn other_write(&self) -> Style;
    method other_execute (line 133) | fn other_execute(&self) -> Style;
    method special_user_file (line 135) | fn special_user_file(&self) -> Style;
    method special_other (line 136) | fn special_other(&self) -> Style;
    method attribute (line 138) | fn attribute(&self) -> Style;
    method dash (line 156) | fn dash(&self)                -> Style { Fixed(11).normal() }
    method user_read (line 157) | fn user_read(&self)           -> Style { Fixed(101).normal() }
    method user_write (line 158) | fn user_write(&self)          -> Style { Fixed(102).normal() }
    method user_execute_file (line 159) | fn user_execute_file(&self)   -> Style { Fixed(103).normal() }
    method user_execute_other (line 160) | fn user_execute_other(&self)  -> Style { Fixed(113).normal() }
    method group_read (line 161) | fn group_read(&self)          -> Style { Fixed(104).normal() }
    method group_write (line 162) | fn group_write(&self)         -> Style { Fixed(105).normal() }
    method group_execute (line 163) | fn group_execute(&self)       -> Style { Fixed(106).normal() }
    method other_read (line 164) | fn other_read(&self)          -> Style { Fixed(107).normal() }
    method other_write (line 165) | fn other_write(&self)         -> Style { Fixed(108).normal() }
    method other_execute (line 166) | fn other_execute(&self)       -> Style { Fixed(109).normal() }
    method special_user_file (line 167) | fn special_user_file(&self)   -> Style { Fixed(110).normal() }
    method special_other (line 168) | fn special_other(&self)       -> Style { Fixed(111).normal() }
    method attribute (line 169) | fn attribute(&self)           -> Style { Fixed(112).normal() }
  type TestColours (line 153) | struct TestColours;
  function negate (line 174) | fn negate() {
  function affirm (line 192) | fn affirm() {
  function specials (line 210) | fn specials() {
  function extra_specials (line 228) | fn extra_specials() {

FILE: src/output/render/size.rs
  function render (line 11) | pub fn render<C: Colours>(self, colours: &C, size_format: SizeFormat, nu...
  function render (line 63) | fn render<C: Colours>(self, colours: &C) -> TextCell {
  type Colours (line 79) | pub trait Colours {
    method size (line 80) | fn size(&self, prefix: Option<Prefix>) -> Style;
    method unit (line 81) | fn unit(&self, prefix: Option<Prefix>) -> Style;
    method no_size (line 82) | fn no_size(&self) -> Style;
    method major (line 84) | fn major(&self) -> Style;
    method comma (line 85) | fn comma(&self) -> Style;
    method minor (line 86) | fn minor(&self) -> Style;
    method size (line 106) | fn size(&self, _prefix: Option<Prefix>) -> Style { Fixed(66).normal() }
    method unit (line 107) | fn unit(&self, _prefix: Option<Prefix>) -> Style { Fixed(77).bold() }
    method no_size (line 108) | fn no_size(&self)          -> Style { Black.italic() }
    method major (line 110) | fn major(&self) -> Style { Blue.on(Red) }
    method comma (line 111) | fn comma(&self) -> Style { Green.italic() }
    method minor (line 112) | fn minor(&self) -> Style { Cyan.on(Yellow) }
  type TestColours (line 103) | struct TestColours;
  function directory (line 117) | fn directory() {
  function file_decimal (line 125) | fn file_decimal() {
  function file_binary (line 140) | fn file_binary() {
  function file_bytes (line 155) | fn file_bytes() {
  function device_ids (line 169) | fn device_ids() {

FILE: src/output/render/times.rs
  type Render (line 10) | pub trait Render {
    method render (line 11) | fn render(self, style: Style, tz: &Option<TimeZone>, format: TimeForma...
    method render (line 15) | fn render(self, style: Style, tz: &Option<TimeZone>, format: TimeForma...

FILE: src/output/render/users.rs
  function render (line 10) | pub fn render<C: Colours, U: Users>(self, colours: &C, users: &U, format...
  type Colours (line 24) | pub trait Colours {
    method you (line 25) | fn you(&self) -> Style;
    method someone_else (line 26) | fn someone_else(&self) -> Style;
    method you (line 47) | fn you(&self)          -> Style { Red.bold() }
    method someone_else (line 48) | fn someone_else(&self) -> Style { Blue.underline() }
  type TestColours (line 44) | struct TestColours;
  function named (line 53) | fn named() {
  function unnamed (line 66) | fn unnamed() {
  function different_named (line 76) | fn different_named() {
  function different_unnamed (line 86) | fn different_unnamed() {
  function overflow (line 93) | fn overflow() {

FILE: src/output/table.rs
  type Options (line 25) | pub struct Options {
  type Columns (line 35) | pub struct Columns {
    method collect (line 55) | pub fn collect(&self, actually_enable_git: bool) -> Vec<Column> {
  type Column (line 123) | pub enum Column {
    method alignment (line 154) | pub fn alignment(self) -> Alignment {
    method alignment (line 166) | pub fn alignment(&self) -> Alignment {
    method header (line 176) | pub fn header(self) -> &'static str {
  type Alignment (line 145) | pub enum Alignment {
  type SizeFormat (line 205) | pub enum SizeFormat {
  type UserFormat (line 221) | pub enum UserFormat {
  method default (line 229) | fn default() -> Self {
  type TimeType (line 238) | pub enum TimeType {
    method header (line 256) | pub fn header(self) -> &'static str {
  type TimeTypes (line 274) | pub struct TimeTypes {
  method default (line 285) | fn default() -> Self {
  type Environment (line 300) | pub struct Environment {
    method lock_users (line 316) | pub fn lock_users(&self) -> MutexGuard<'_, UsersCache> {
    method load_all (line 320) | fn load_all() -> Self {
  function determine_time_zone (line 342) | fn determine_time_zone() -> TZResult<TimeZone> {
  function determine_time_zone (line 363) | fn determine_time_zone() -> TZResult<TimeZone> {
  type Table (line 392) | pub struct Table<'a> {
  type Row (line 404) | pub struct Row {
  function new (line 409) | pub fn new(options: &'a Options, git: Option<&'a GitCache>, theme: &'a T...
  function widths (line 426) | pub fn widths(&self) -> &TableWidths {
  function header_row (line 430) | pub fn header_row(&self) -> Row {
  function row_for_file (line 438) | pub fn row_for_file(&self, file: &File<'_>, xattrs: bool) -> Row {
  function add_widths (line 446) | pub fn add_widths(&mut self, row: &Row) {
  function permissions_plus (line 450) | fn permissions_plus(&self, file: &File<'_>, xattrs: bool) -> f::Permissi...
  function octal_permissions (line 462) | fn octal_permissions(&self, file: &File<'_>) -> f::OctalPermissions {
  function display (line 468) | fn display(&self, file: &File<'_>, column: Column, xattrs: bool) -> Text...
  function git_status (line 519) | fn git_status(&self, file: &File<'_>) -> f::Git {
  function render (line 527) | pub fn render(&self, row: Row) -> TextCell {
  type TableWidths (line 556) | pub struct TableWidths(Vec<usize>);
    method zero (line 567) | pub fn zero(count: usize) -> Self {
    method add_widths (line 571) | pub fn add_widths(&mut self, row: &Row) {
    method total (line 577) | pub fn total(&self) -> usize {
  type Target (line 559) | type Target = [usize];
  method deref (line 561) | fn deref(&self) -> &Self::Target {

FILE: src/output/time.rs
  type TimeFormat (line 29) | pub enum TimeFormat {
    method format_local (line 55) | pub fn format_local(self, time: SystemTime) -> String {
    method format_zoned (line 64) | pub fn format_zoned(self, time: SystemTime, zone: &TimeZone) -> String {
  function default_local (line 76) | fn default_local(time: SystemTime) -> String {
  function default_zoned (line 83) | fn default_zoned(time: SystemTime, zone: &TimeZone) -> String {
  function get_dateformat (line 89) | fn get_dateformat(date: &LocalDateTime) -> &'static DateFormat<'static> {
  function long_local (line 101) | fn long_local(time: SystemTime) -> String {
  function long_zoned (line 109) | fn long_zoned(time: SystemTime, zone: &TimeZone) -> String {
  function full_local (line 117) | fn full_local(time: SystemTime) -> String {
  function full_zoned (line 125) | fn full_zoned(time: SystemTime, zone: &TimeZone) -> String {
  function iso_local (line 138) | fn iso_local(time: SystemTime) -> String {
  function iso_zoned (line 153) | fn iso_zoned(time: SystemTime, zone: &TimeZone) -> String {
  function systemtime_epoch (line 168) | fn systemtime_epoch(time: SystemTime) -> i64 {
  function systemtime_nanos (line 181) | fn systemtime_nanos(time: SystemTime) -> u32 {
  function is_recent (line 194) | fn is_recent(date: &LocalDateTime) -> bool {

FILE: src/output/tree.rs
  type TreePart (line 43) | pub enum TreePart {
    method ascii_art (line 62) | pub fn ascii_art(self) -> &'static str {
  type TreeTrunk (line 75) | pub struct TreeTrunk {
    method new_row (line 109) | pub fn new_row(&mut self, params: TreeParams) -> &[TreePart] {
  type TreeParams (line 87) | pub struct TreeParams {
    method new (line 144) | pub fn new(depth: TreeDepth, last: bool) -> Self {
    method is_at_root (line 148) | pub fn is_at_root(&self) -> bool {
  type TreeDepth (line 98) | pub struct TreeDepth(pub usize);
    method root (line 154) | pub fn root() -> Self {
    method deeper (line 158) | pub fn deeper(self) -> Self {
    method iterate_over (line 164) | pub fn iterate_over<I, T>(self, inner: I) -> Iter<I>
  type Iter (line 172) | pub struct Iter<I> {
  type Item (line 180) | type Item = (TreeParams, T);
  method next (line 182) | fn next(&mut self) -> Option<Self::Item> {
  function params (line 196) | fn params(depth: usize, last: bool) -> TreeParams {
  function empty_at_first (line 201) | fn empty_at_first() {
  function one_child (line 207) | fn one_child() {
  function two_children (line 214) | fn two_children() {
  function two_times_two_children (line 222) | fn two_times_two_children() {
  function two_times_two_nested_children (line 234) | fn two_times_two_nested_children() {
  function test_iteration (line 254) | fn test_iteration() {
  function test_empty (line 274) | fn test_empty() {

FILE: src/theme/default_theme.rs
  method default_theme (line 9) | pub fn default_theme(scale: ColourScale) -> Self {
  method colourful (line 86) | pub fn colourful(scale: ColourScale) -> Self {
  method colourful_fixed (line 93) | fn colourful_fixed() -> Self {
  method colourful_gradient (line 112) | fn colourful_gradient() -> Self {

FILE: src/theme/lsc.rs
  type LSColors (line 25) | pub struct LSColors<'var>(pub &'var str);
  function each_pair (line 28) | pub fn each_pair<C>(&mut self, mut callback: C)
  function parse_into_high_colour (line 44) | fn parse_into_high_colour<'a, I>(iter: &mut Peekable<I>) -> Option<Colour>
  type Pair (line 88) | pub struct Pair<'var> {
  function to_style (line 94) | pub fn to_style(&self) -> Style {

FILE: src/theme/mod.rs
  type Options (line 18) | pub struct Options {
    method to_theme (line 68) | pub fn to_theme(&self, isatty: bool) -> Theme {
  type UseColours (line 35) | pub enum UseColours {
  type ColourScale (line 48) | pub enum ColourScale {
  type Definitions (line 54) | pub struct Definitions {
    method parse_color_vars (line 101) | fn parse_color_vars(&self, colours: &mut UiStyles) -> (ExtensionMappin...
  type Theme (line 60) | pub struct Theme {
    method block_count (line 205) | fn block_count(&self)  -> Style { self.ui.blocks }
    method no_blocks (line 206) | fn no_blocks(&self)    -> Style { self.ui.punctuation }
    method normal (line 210) | fn normal(&self)       -> Style { self.ui.filekinds.normal }
    method directory (line 211) | fn directory(&self)    -> Style { self.ui.filekinds.directory }
    method pipe (line 212) | fn pipe(&self)         -> Style { self.ui.filekinds.pipe }
    method symlink (line 213) | fn symlink(&self)      -> Style { self.ui.filekinds.symlink }
    method block_device (line 214) | fn block_device(&self) -> Style { self.ui.filekinds.block_device }
    method char_device (line 215) | fn char_device(&self)  -> Style { self.ui.filekinds.char_device }
    method socket (line 216) | fn socket(&self)       -> Style { self.ui.filekinds.socket }
    method special (line 217) | fn special(&self)      -> Style { self.ui.filekinds.special }
    method not_modified (line 221) | fn not_modified(&self)  -> Style { self.ui.punctuation }
    method new (line 223) | fn new(&self)           -> Style { self.ui.git.new }
    method modified (line 224) | fn modified(&self)      -> Style { self.ui.git.modified }
    method deleted (line 225) | fn deleted(&self)       -> Style { self.ui.git.deleted }
    method renamed (line 226) | fn renamed(&self)       -> Style { self.ui.git.renamed }
    method type_change (line 227) | fn type_change(&self)   -> Style { self.ui.git.typechange }
    method ignored (line 228) | fn ignored(&self)       -> Style { self.ui.git.ignored }
    method conflicted (line 229) | fn conflicted(&self)    -> Style { self.ui.git.conflicted }
    method yours (line 234) | fn yours(&self)      -> Style { self.ui.users.group_yours }
    method not_yours (line 235) | fn not_yours(&self)  -> Style { self.ui.users.group_not_yours }
    method normal (line 239) | fn normal(&self)           -> Style { self.ui.links.normal }
    method multi_link_file (line 240) | fn multi_link_file(&self)  -> Style { self.ui.links.multi_link_file }
    method dash (line 244) | fn dash(&self)               -> Style { self.ui.punctuation }
    method user_read (line 245) | fn user_read(&self)          -> Style { self.ui.perms.user_read }
    method user_write (line 246) | fn user_write(&self)         -> Style { self.ui.perms.user_write }
    method user_execute_file (line 247) | fn user_execute_file(&self)  -> Style { self.ui.perms.user_execute_file }
    method user_execute_other (line 248) | fn user_execute_other(&self) -> Style { self.ui.perms.user_execute_oth...
    method group_read (line 249) | fn group_read(&self)         -> Style { self.ui.perms.group_read }
    method group_write (line 250) | fn group_write(&self)        -> Style { self.ui.perms.group_write }
    method group_execute (line 251) | fn group_execute(&self)      -> Style { self.ui.perms.group_execute }
    method other_read (line 252) | fn other_read(&self)         -> Style { self.ui.perms.other_read }
    method other_write (line 253) | fn other_write(&self)        -> Style { self.ui.perms.other_write }
    method other_execute (line 254) | fn other_execute(&self)      -> Style { self.ui.perms.other_execute }
    method special_user_file (line 255) | fn special_user_file(&self)  -> Style { self.ui.perms.special_user_file }
    method special_other (line 256) | fn special_other(&self)      -> Style { self.ui.perms.special_other }
    method attribute (line 257) | fn attribute(&self)          -> Style { self.ui.perms.attribute }
    method size (line 261) | fn size(&self, prefix: Option<number_prefix::Prefix>) -> Style {
    method unit (line 273) | fn unit(&self, prefix: Option<number_prefix::Prefix>) -> Style {
    method no_size (line 285) | fn no_size(&self) -> Style { self.ui.punctuation }
    method major (line 286) | fn major(&self)   -> Style { self.ui.size.major }
    method comma (line 287) | fn comma(&self)   -> Style { self.ui.punctuation }
    method minor (line 288) | fn minor(&self)   -> Style { self.ui.size.minor }
    method you (line 293) | fn you(&self)           -> Style { self.ui.users.user_you }
    method someone_else (line 294) | fn someone_else(&self)  -> Style { self.ui.users.user_someone_else }
  type FileColours (line 148) | pub trait FileColours: std::marker::Sync {
    method colour_file (line 149) | fn colour_file(&self, file: &File<'_>) -> Option<Style>;
    method colour_file (line 155) | fn colour_file(&self, _file: &File<'_>) -> Option<Style> {
    method colour_file (line 168) | fn colour_file(&self, file: &File<'_>) -> Option<Style> {
    method colour_file (line 184) | fn colour_file(&self, file: &File<'_>) -> Option<Style> {
  type NoFileColours (line 153) | struct NoFileColours;
  type ExtensionMappings (line 176) | struct ExtensionMappings {
    method is_non_empty (line 192) | fn is_non_empty(&self) -> bool {
    method add (line 196) | fn add(&mut self, pattern: glob::Pattern, style: Style) {
  method normal_arrow (line 298) | fn normal_arrow(&self)        -> Style { self.ui.punctuation }
  method broken_symlink (line 299) | fn broken_symlink(&self)      -> Style { self.ui.broken_symlink }
  method broken_filename (line 300) | fn broken_filename(&self)     -> Style { apply_overlay(self.ui.broken_sy...
  method broken_control_char (line 301) | fn broken_control_char(&self) -> Style { apply_overlay(self.ui.control_c...
  method control_char (line 302) | fn control_char(&self)        -> Style { self.ui.control_char }
  method symlink_path (line 303) | fn symlink_path(&self)        -> Style { self.ui.symlink_path }
  method executable_file (line 304) | fn executable_file(&self)     -> Style { self.ui.filekinds.executable }
  method colour_file (line 306) | fn colour_file(&self, file: &File<'_>) -> Style {
  function apply_overlay (line 324) | fn apply_overlay(mut base: Style, overlay: Style) -> Style {

FILE: src/theme/ui_styles.rs
  type UiStyles (line 7) | pub struct UiStyles {
    method plain (line 108) | pub fn plain() -> Self {
    method set_ls (line 119) | pub fn set_ls(&mut self, pair: &Pair<'_>) -> bool {
    method set_exa (line 142) | pub fn set_exa(&mut self, pair: &Pair<'_>) -> bool {
    method set_number_style (line 202) | pub fn set_number_style(&mut self, style: Style) {
    method set_unit_style (line 210) | pub fn set_unit_style(&mut self, style: Style) {
  type FileKinds (line 31) | pub struct FileKinds {
  type Permissions (line 44) | pub struct Permissions {
  type Size (line 65) | pub struct Size {
  type Users (line 83) | pub struct Users {
  type Links (line 91) | pub struct Links {
  type Git (line 97) | pub struct Git {