hledger-lib-0.19.3: Core data types, parsers and utilities for the hledger accounting tool.

Safe HaskellNone

Hledger.Utils

Description

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

Synopsis

Documentation

quoteIfSpaced :: String -> StringSource

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

words' :: String -> [String]Source

Quote-aware version of words - don't split on spaces which are inside quotes. NB correctly handles a'b but not ''a''.

unwords' :: [String] -> StringSource

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

singleQuoteIfNeeded :: [Char] -> [Char]Source

Single-quote this string if it contains whitespace or double-quotes

stripquotes :: String -> StringSource

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

concatTopPadded :: [String] -> StringSource

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

concatBottomPadded :: [String] -> StringSource

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

vConcatRightAligned :: [String] -> StringSource

Compose strings vertically and right-aligned.

padtop :: Int -> String -> StringSource

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

padbottom :: Int -> String -> StringSource

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

padleft :: Int -> String -> StringSource

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

padright :: Int -> String -> StringSource

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

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

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

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

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

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

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

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

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

root :: Tree a -> aSource

leaves :: Tree a -> [a]Source

List just the leaf nodes of a tree

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

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)Source

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

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

remove all nodes past a certain depth

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

apply f to all tree nodes

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

remove all subtrees whose nodes do not fulfill predicate

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

is predicate true in any node of tree ?

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

show a compact ascii representation of a tree

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

show a compact ascii representation of a forest

newtype FastTree a Source

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) 
(Eq (FastTree a), Ord a) => Ord (FastTree a) 
Show a => Show (FastTree a) 

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

strace :: Show a => a -> aSource

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

lstrace :: Show a => String -> a -> aSource

labelled trace showable - like strace, with a label prepended

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

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

tracewith :: (a -> String) -> a -> aSource

trace an expression using a custom show function

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

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

testName :: Test -> StringSource

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

flattenTests :: Test -> [Test]Source

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

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

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

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

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

assertParse :: Either ParseError a -> AssertionSource

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

assertParseFailure :: Either ParseError a -> AssertionSource

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

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

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

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

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

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

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

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 aSource

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 = StringSource

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 -> StringSource

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 -> SystemStringSource

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 -> aSource

A SystemString-aware version of error.

userError' :: String -> IOErrorSource

A SystemString-aware version of userError.