Hledger.Utils

Standard imports and utilities which are useful everywhere, or needed low in the module hierarchy. This is the bottom of hledger's module graph.

Documentation

lowercase :: [Char] -> [Char]

uppercase :: [Char] -> [Char]

strip :: [Char] -> String

lstrip :: String -> String

rstrip :: [Char] -> [Char]

stripbrackets :: String -> String

elideLeft :: Int -> [Char] -> [Char]

elideRight :: Int -> [Char] -> [Char]

underline :: String -> String

quoteIfSpaced :: String -> String

Wrap a string in double quotes, and -prefix any embedded single quotes, if it contains whitespace and is not already single- or double-quoted.

quoteIfNeeded :: [Char] -> [Char]

Double-quote this string if it contains whitespace, single quotes or double-quotes, escaping the quotes as needed.

singleQuoteIfNeeded :: [Char] -> [Char]

Single-quote this string if it contains whitespace or double-quotes. No good for strings containing single quotes.

quotechars :: [Char]

whitespacechars :: [Char]

escapeDoubleQuotes :: String -> String

escapeSingleQuotes :: String -> String

escapeQuotes :: String -> String

words' :: String -> [String]

Quote-aware version of words - don't split on spaces which are inside quotes. NB correctly handles "a'b" but not "''a''". Can raise an error if parsing fails.

unwords' :: [String] -> String

Quote-aware version of unwords - single-quote strings which contain whitespace

stripquotes :: String -> String

Strip one matching pair of single or double quotes on the ends of a string.

isSingleQuoted :: [Char] -> Bool

isDoubleQuoted :: [Char] -> Bool

unbracket :: String -> String

concatTopPadded :: [String] -> String

Join multi-line strings as side-by-side rectangular strings of the same height, top-padded.

concatBottomPadded :: [String] -> String

Join multi-line strings as side-by-side rectangular strings of the same height, bottom-padded.

vConcatRightAligned :: [String] -> String

Compose strings vertically and right-aligned.

padtop :: Int -> String -> String

Convert a multi-line string to a rectangular string top-padded to the specified height.

padbottom :: Int -> String -> String

Convert a multi-line string to a rectangular string bottom-padded to the specified height.

padleft :: Int -> String -> String

Convert a multi-line string to a rectangular string left-padded to the specified width.

padright :: Int -> String -> String

Convert a multi-line string to a rectangular string right-padded to the specified width.

cliptopleft :: Int -> Int -> String -> String

Clip a multi-line string to the specified width and height from the top left.

fitto :: Int -> Int -> String -> String

Clip and pad a multi-line string to fill the specified width and height.

first3 :: (t, t1, t2) -> t

second3 :: (t, t1, t2) -> t1

third3 :: (t, t1, t2) -> t2

first4 :: (t, t1, t2, t3) -> t

second4 :: (t, t1, t2, t3) -> t1

third4 :: (t, t1, t2, t3) -> t2

fourth4 :: (t, t1, t2, t3) -> t3

first5 :: (t, t1, t2, t3, t4) -> t

second5 :: (t, t1, t2, t3, t4) -> t1

third5 :: (t, t1, t2, t3, t4) -> t2

fourth5 :: (t, t1, t2, t3, t4) -> t3

fifth5 :: (t, t1, t2, t3, t4) -> t4

difforzero :: (Num a, Ord a) => a -> a -> a

regexMatch :: String -> String -> Maybe (RegexResult, MatchList)

regexMatchCI :: String -> String -> Maybe (RegexResult, MatchList)

regexMatches :: String -> String -> Bool

regexMatchesCI :: String -> String -> Bool

containsRegex :: String -> String -> Bool

regexReplace :: String -> String -> String -> String

regexReplaceCI :: String -> String -> String -> String

regexReplaceBy :: String -> (String -> String) -> String -> String

regexToCaseInsensitive :: String -> String

regexSplit :: String -> String -> [String]

regexMatchesRegexCompat :: String -> String -> Bool

regexMatchesCIRegexCompat :: String -> String -> Bool

splitAtElement :: Eq a => a -> [a] -> [[a]]

root :: Tree a -> a

subs :: Tree a -> Forest a

branches :: Tree a -> Forest a

leaves :: Tree a -> [a]

List just the leaf nodes of a tree

subtreeat :: Eq a => a -> Tree a -> Maybe (Tree a)

get the sub-tree rooted at the first (left-most, depth-first) occurrence of the specified node value

subtreeinforest :: Eq a => a -> [Tree a] -> Maybe (Tree a)

get the sub-tree for the specified node value in the first tree in forest in which it occurs.

treeprune :: Int -> Tree a -> Tree a

remove all nodes past a certain depth

treemap :: (a -> b) -> Tree a -> Tree b

apply f to all tree nodes

treefilter :: (a -> Bool) -> Tree a -> Tree a

remove all subtrees whose nodes do not fulfill predicate

treeany :: (a -> Bool) -> Tree a -> Bool

is predicate true in any node of tree ?

showtree :: Show a => Tree a -> String

show a compact ascii representation of a tree

showforest :: Show a => Forest a -> String

show a compact ascii representation of a forest

newtype FastTree a

An efficient-to-build tree suggested by Cale Gibbard, probably better than accountNameTreeFrom.

Constructors

T (Map a (FastTree a))

Instances

Eq a => Eq (FastTree a)

Ord a => Ord (FastTree a)

Show a => Show (FastTree a)

emptyTree :: FastTree a

mergeTrees :: Ord a => FastTree a -> FastTree a -> FastTree a

treeFromPath :: [a] -> FastTree a

treeFromPaths :: Ord a => [[a]] -> FastTree a

strace :: Show a => a -> a

Trace (print on stdout at runtime) a showable value. (for easily tracing in the middle of a complex expression)

ltrace :: Show a => String -> a -> a

Labelled trace - like strace, with a label prepended.

mtrace :: (Monad m, Show a) => a -> m a

Monadic trace - like strace, but works as a standalone line in a monad.

traceWith :: (a -> String) -> a -> a

Custom trace - like strace, with a custom show function.

ptrace :: String -> GenParser Char st ()

Parsec trace - show the current parsec position and next input, and the provided label if it's non-null.

debugLevel :: Int

Global debug level, which controls the verbosity of debug output on the console. The default is 0 meaning no debug output. The --debug command line flag sets it to 1, or --debug=N sets it to a higher value (note: not --debug N for some reason). This uses unsafePerformIO and can be accessed from anywhere and before normal command-line processing. After command-line processing, it is also available as the debug_ field of CliOpts.

dbg :: Show a => String -> a -> a

Print a message and a showable value to the console if the global debug level is non-zero. Uses unsafePerformIO.

dbg0 :: Show a => String -> a -> a

dbg1 :: Show a => String -> a -> a

dbg2 :: Show a => String -> a -> a

dbgAt :: Show a => Int -> String -> a -> a

Print a message and a showable value to the console if the global debug level is at or above the specified level. Uses unsafePerformIO.

dbgAtM :: Show a => Int -> String -> a -> IO ()

dbgshow :: Show a => Int -> String -> a -> a

Print a showable value to the console, with a message, if the debug level is at or above the specified level (uses unsafePerformIO). Values are displayed with show, all on one line, which is hard to read.

dbgppshow :: Show a => Int -> String -> a -> a

Print a showable value to the console, with a message, if the debug level is at or above the specified level (uses unsafePerformIO). Values are displayed with ppShow, each field/constructor on its own line.

dbgExit :: Show a => String -> a -> a

Like dbg, then exit the program. Uses unsafePerformIO.

pdbg :: Int -> String -> ParsecT [Char] st Identity ()

Print a message and parsec debug info (parse position and next input) to the console when the debug level is at or above this level. Uses unsafePerformIO. pdbgAt :: GenParser m => Float -> String -> m ()

choice' :: [GenParser tok st a] -> GenParser tok st a

Backtracking choice, use this when alternatives share a prefix. Consumes no input if all choices fail.

parsewith :: Parser a -> String -> Either ParseError a

parseWithCtx :: b -> GenParser Char b a -> String -> Either ParseError a

fromparse :: Either ParseError a -> a

parseerror :: ParseError -> a

showParseError :: ParseError -> String

showDateParseError :: ParseError -> String

nonspace :: GenParser Char st Char

spacenonewline :: GenParser Char st Char

restofline :: GenParser Char st String

eolof :: GenParser Char st ()

getCurrentLocalTime :: IO LocalTime

testName :: Test -> String

Get a Test's label, or the empty string.

flattenTests :: Test -> [Test]

Flatten a Test containing TestLists into a list of single tests.

filterTests :: (Test -> Bool) -> Test -> Test

Filter TestLists in a Test, recursively, preserving the structure.

is :: (Eq a, Show a) => a -> a -> Assertion

Simple way to assert something is some expected value, with no label.

assertParse :: Either ParseError a -> Assertion

Assert a parse result is successful, printing the parse error on failure.

assertParseFailure :: Either ParseError a -> Assertion

Assert a parse result is successful, printing the parse error on failure.

assertParseEqual :: (Show a, Eq a) => Either ParseError a -> a -> Assertion

Assert a parse result is some expected value, printing the parse error on failure.

printParseError :: Show a => a -> IO ()

isLeft :: Either a b -> Bool

isRight :: Either a b -> Bool

applyN :: Int -> (a -> a) -> a -> a

Apply a function the specified number of times. Possibly uses O(n) stack ?

expandPath :: MonadIO m => FilePath -> FilePath -> m FilePath

Convert a possibly relative, possibly tilde-containing file path to an absolute one, given the current directory. ~username is not supported. Leave "-" unchanged.

firstJust :: Eq a => [Maybe a] -> Maybe a

readFile' :: FilePath -> IO String

Read a file in universal newline mode, handling whatever newline convention it may contain.

trace :: String -> a -> a

The trace function outputs the trace message given as its first argument, before returning the second argument as its result.

For example, this returns the value of f x but first outputs the message.

trace ("calling f with x = " ++ show x) (f x)

The trace function should only be used for debugging, or for monitoring execution. The function is not referentially transparent: its type indicates that it is a pure function but it has the side effect of outputting the trace message.

type SystemString = String

A string received from or being passed to the operating system, such as a file path, command-line argument, or environment variable name or value. With GHC versions before 7.2 on some platforms (posix) these are typically encoded. When converting, we assume the encoding is UTF-8 (cf http://www.dwheeler.com/essays/fixing-unix-linux-filenames.html#UTF8).

fromSystemString :: SystemString -> String

Convert a system string to an ordinary string, decoding from UTF-8 if it appears to be UTF8-encoded and GHC version is less than 7.2.

toSystemString :: String -> SystemString

Convert a unicode string to a system string, encoding with UTF-8 if we are on a posix platform with GHC < 7.2.

error' :: String -> a

A SystemString-aware version of error.

userError' :: String -> IOError

A SystemString-aware version of userError.

ppShow :: Show a => a -> String

Convert a generic value into a pretty String, if possible.