Safe HaskellSafe-Infered




Utility functions.


Debug functions

debug :: Show a => a -> aSource

To be used only for debugging, breaks referential integrity.

debugFn :: Show b => (a -> b) -> a -> aSource

Displays a modified form of the second parameter before returning it.

debugXy :: Show a => a -> b -> bSource

Show the first parameter before returning the second one.


applyIf :: Bool -> (a -> a) -> a -> aSource

Apply the function if condition holds, otherwise use default value.

commaJoin :: [String] -> StringSource

Comma-join a string list.

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

Split a list on a separator and return a list of lists.

plural :: Int -> String -> String -> StringSource

Simple pluralize helper

ensureQuoted :: String -> StringSource

Ensure a value is quoted if needed.

Mathematical functions

stdDev :: [Double] -> DoubleSource

Standard deviation function.

data Statistics Source

Abstract type of statistical accumulations. They behave as if the given statistics were computed on the list of values, but they allow a potentially more efficient update of a given value.


SumStatistics Double 
StdDevStatistics Double Double Double 


Show Statistics 

getSumStatistics :: [Double] -> StatisticsSource

Get a statistics that sums up the values.

getStdDevStatistics :: [Double] -> StatisticsSource

Get a statistics for the standard deviation.

getStatisticValue :: Statistics -> DoubleSource

Obtain the value of a statistics.

updateStatistics :: Statistics -> (Double, Double) -> StatisticsSource

In a given statistics replace on value by another. This will only give meaningful results, if the original value was actually part of the statistics.

Logical functions



:: Bool


-> a

"then" result

-> a

"else" result

-> a

"then" or else result depending on the condition

"if" as a function, rather than as syntactic sugar.

Parsing utility functions

parseChoices :: Monad m => String -> String -> [(a, String)] -> m aSource

tryRead :: (Monad m, Read a) => String -> String -> m aSource

Safe read function returning data encapsulated in a Result.

formatTable :: [[String]] -> [Bool] -> [[String]]Source

Format a table of strings to maintain consistent length.

printTable :: String -> [String] -> [[String]] -> [Bool] -> StringSource

Constructs a printable table from given header and rows

parseUnitValue :: Monad m => Bool -> String -> m RationalSource

parseUnitEx :: (Monad m, Integral a, Read a) => Bool -> String -> m aSource

parseUnit :: (Monad m, Integral a, Read a) => String -> m aSource

Tries to extract number and scale from the given string.

Input must be in the format NUMBER+ SPACE* [UNIT]. If no unit is specified, it defaults to MiB. Return value is always an integral value in MiB.

parseUnitAssumeBinary :: (Monad m, Integral a, Read a) => String -> m aSource

Tries to extract a number and scale from a given string, taking all kilos to be binary.

exitIfBad :: String -> Result a -> IO aSource

Unwraps a Result, exiting the program if it is a Bad value, otherwise returning the actual contained value.

exitErr :: String -> IO aSource

Exits immediately with an error message.

exitWhen :: Bool -> String -> IO ()Source

Exits with an error message if the given boolean condition if true.

exitUnless :: Bool -> String -> IO ()Source

Exits with an error message unless the given boolean condition if true, the opposite of exitWhen.

logWarningIfBad :: String -> a -> Result a -> IO aSource

Unwraps a Result, logging a warning message and then returning a default value if it is a Bad value, otherwise returning the actual contained value.

tryAndLogIOError :: IO a -> String -> (a -> Result b) -> IO (Result b)Source

Try an IO interaction, log errors and unfold as a Result.

warn :: String -> IO ()Source

Print a warning, but do not exit.

extractKey :: [Either Integer String] -> String -> ([Either Integer String], String)Source

niceSort :: [String] -> [String]Source

Sort a list of strings based on digit and non-digit groupings.

Given a list of names [a1, a10, a11, a2] this function will sort the list in the logical order [a1, a2, a10, a11].

The sort algorithm breaks each name in groups of either only-digits or no-digits, and sorts based on each group.

Internally, this is not implemented via regexes (like the Python version), but via actual splitting of the string in sequences of either digits or everything else, and converting the digit sequences in Left Integer and the non-digit ones in Right String, at which point sorting becomes trivial due to the built-in Either ordering; we only need one extra step of dropping the key at the end.

niceSortKey :: (a -> String) -> [a] -> [a]Source

Key-version of niceSort. We use sortBy and compare on fst since we don't want to add an ordering constraint on the a type, hence the need to only compare the first element of the (key, a) tuple.

rStripSpace :: String -> StringSource

Strip space characthers (including newline). As this is expensive, should only be run on small strings.

newUUID :: IO StringSource

Returns a random UUID. This is a Linux-specific method as it uses the /proc filesystem.

getCurrentTime :: IO IntegerSource

Returns the current time as an Integer representing the number of seconds from the Unix epoch.

getCurrentTimeUSec :: IO IntegerSource

Returns the current time as an Integer representing the number of microseconds from the Unix epoch (hence the need for Integer).

clockTimeToString :: ClockTime -> StringSource

Convert a ClockTime into a (seconds-only) timestamp.

chompPrefix :: String -> String -> Maybe StringSource

Strip a prefix from a string, allowing the last character of the prefix (which is assumed to be a separator) to be absent from the string if the string terminates there.

>>> chompPrefix "foo:bar:" "a:b:c" Nothing

>>> chompPrefix "foo:bar:" "foo:bar:baz" Just "baz"

>>> chompPrefix "foo:bar:" "foo:bar:" Just ""

>>> chompPrefix "foo:bar:" "foo:bar" Just ""

>>> chompPrefix "foo:bar:" "foo:barbaz" Nothing



:: Int


-> String

string that needs wrapping

-> [String]

string "broken" in lines

Breaks a string in lines with length <= maxWidth.

NOTE: The split is OK if:

  • It doesn't break a word, i.e. the next line begins with space (isSpace . head $ rest) or the current line ends with space (null revExtra);
  • It breaks a very big word that doesn't fit anyway (null revLine).

trim :: String -> StringSource

Removes surrounding whitespace. Should only be used in small strings.

defaultHead :: a -> [a] -> aSource

A safer head version, with a default value.

exitIfEmpty :: String -> [a] -> IO aSource

A head version in the I/O monad, for validating parameters without which we cannot continue.

monadicThe :: (Eq a, Monad m) => String -> [a] -> m aSource

Obtain the unique element of a list in an arbitrary monad.

splitEithers :: [Either a b] -> ([a], [b], [Bool])Source

Split an Either list into two separate lists (containing the Left and Right elements, plus a "trail" list that allows recombination later.

This is splitter; for recombination, look at recombineEithers. The sum of "left" and "right" lists should be equal to the original list length, and the trail list should be the same length as well. The entries in the resulting lists are reversed in comparison with the original list.

recombineEithers :: (Show a, Show b) => [a] -> [b] -> [Bool] -> Result [Either a b]Source

Recombines two "left" and "right" lists using a "trail" list into a single Either list.

This is the counterpart to splitEithers. It does the opposite transformation, and the output list will be the reverse of the input lists. Since splitEithers also reverses the lists, calling these together will result in the original list.

Mismatches in the structure of the lists (e.g. inconsistent lengths) are represented via Bad; normally this function should not fail, if lists are passed as generated by splitEithers.

resolveAddrHints :: Maybe AddrInfoSource

resolveAddr :: Int -> String -> IO (Result (Family, SockAddr))Source

Resolves a numeric address.

setOwnerAndGroupFromNames :: FilePath -> GanetiDaemon -> GanetiGroup -> IO ()Source

Set the owner and the group of a file (given as names, not numeric id).

formatOrdinal :: (Integral a, Show a) => a -> StringSource

Formats an integral number, appending a suffix.

atomicWriteFile :: FilePath -> String -> IO ()Source

Atomically write a file, by first writing the contents into a temporary file and then renaming it to the old position.

lockFile :: FilePath -> IO (Result ())Source

Attempt, in a non-blocking way, to obtain a lock on a given file; report back success.

type FStat = (EpochTime, FileID, FileOffset)Source

File stat identifier.

nullFStat :: FStatSource

Null FStat value.

buildFileStatus :: FileStatus -> FStatSource

getFStat :: FilePath -> IO FStatSource

Wrapper over buildFileStatus. This reads the data from the filesystem and then builds our cache structure.

getFStatSafe :: FilePath -> IO FStatSource

Safe version of getFStat, that ignores IOErrors.

needsReload :: FStat -> FilePath -> IO (Maybe FStat)Source

Check if the file needs reloading

watchFileEx :: (Eq a, Eq b) => Integer -> b -> IORef b -> a -> IO a -> IO aSource

watchFile :: Eq a => FilePath -> Int -> a -> IO a -> IO aSource

Within the given timeout (in seconds), wait for for the output of the given method to change and return the new value; make use of the promise that the method will only change its value, if the given file changes on disk. If the file does not exist on disk, return immediately.

data FilePermissions Source

Type describing ownership and permissions of newly generated directories and files. All parameters are optional, with nothing meaning that the default value should be left untouched.




fpOwner :: Maybe String
fpGroup :: Maybe String
fpPermissions :: FileMode

ensurePermissions :: FilePath -> FilePermissions -> IO (Result ())Source

Ensure that a given file or directory has the permissions, and possibly ownerships, as required.

safeRenameFile :: FilePermissions -> FilePath -> FilePath -> IO (Result ())Source

Safely rename a file, creating the target directory, if needed.