GenUtil

This is a collection of random useful utility functions written in pure Haskell 98. In general, it trys to conform to the naming scheme put forth the haskell prelude and fill in the obvious omissions, as well as provide useful routines in general. To ensure maximum portability, no instances are exported so it may be added to any project without conflicts.

Functions

Error reporting

putErr :: String -> IO ()

Flushes stdout and writes string to standard error

putErrLn :: String -> IO ()

Flush stdout and write string and newline to standard error

putErrDie :: String -> IO a

Flush stdout, write string and newline to standard error, then exit program with failure.

Simple deconstruction

fromLeft :: Either a b -> a

fromRight :: Either a b -> b

fsts :: [(a, b)] -> [a]

take the fst of every element of a list

snds :: [(a, b)] -> [b]

take the snd of every element of a list

splitEither :: [Either a b] -> ([a], [b])

partition a list of eithers.

rights :: [Either a b] -> [b]

take just the rights

lefts :: [Either a b] -> [a]

take just the lefts

isLeft :: Either t t1 -> Bool

isRight :: Either t t1 -> Bool

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

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

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

System routines

exitSuccess :: IO a

The computation exitSuccess is equivalent to exitWith ExitSuccess, It terminates the program successfully.

exitFailure :: IO a

The computation exitFailure is equivalent to exitWith (ExitFailure exitfail), where exitfail is implementation-dependent.

epoch :: ClockTime

the standard unix epoch

lookupEnv :: Monad m => String -> IO (m String)

looks up an enviornment variable and returns it in an arbitrary Monad rather than raising an exception if the variable is not set.

endOfTime :: ClockTime

an arbitrary time in the future

Random routines

repMaybe :: (a -> Maybe a) -> a -> a

recursivly apply function to value until it returns Nothing

liftT2 :: (a -> b, c -> d) -> (a, c) -> (b, d)

apply functions to values inside a tupele. liftT3 and liftT4 also exist.

liftT3 :: (t -> t3, t1 -> t4, t2 -> t5) -> (t, t1, t2) -> (t3, t4, t5)

liftT4 :: (t -> t4, t1 -> t5, t2 -> t6, t3 -> t7) -> (t, t1, t2, t3) -> (t4, t5, t6, t7)

snub :: Ord a => [a] -> [a]

sorted nub of list, much more efficient than nub, but doesnt preserve ordering.

snubFst :: Ord a => [(a, b)] -> [(a, b)]

sorted nub of list of tuples, based solely on the first element of each tuple.

snubUnder :: Ord b => (a -> b) -> [a] -> [a]

sorted nub of list based on function of values

smerge :: Ord a => [a] -> [a] -> [a]

merge sorted lists in linear time

sortFst :: Ord a => [(a, b)] -> [(a, b)]

sort list of tuples, based on first element of each tuple.

groupFst :: Eq a => [(a, b)] -> [[(a, b)]]

group list of tuples, based only on equality of the first element of each tuple.

foldl' :: (a -> b -> a) -> a -> [b] -> a

A strict version of foldl.

fmapLeft :: Functor f => (a -> c) -> f (Either a b) -> f (Either c b)

fmapRight :: Functor f => (b -> c) -> f (Either a b) -> f (Either a c)

isDisjoint :: Eq a => [a] -> [a] -> Bool

set operations on lists. (slow!)

isConjoint :: Eq a => [a] -> [a] -> Bool

set operations on lists. (slow!)

groupUnder :: Eq b => (a -> b) -> [a] -> [[a]]

group a list based on a function of the values.

sortUnder :: Ord b => (a -> b) -> [a] -> [a]

sort a list based on a function of the values.

minimumUnder :: Ord b => (a -> b) -> [a] -> a

maximumUnder :: Ord b => (a -> b) -> [a] -> a

sortGroupUnder :: Ord a => (b -> a) -> [b] -> [[b]]

sortGroupUnderF :: Ord a => (b -> a) -> [b] -> [(a, [b])]

sortGroupUnderFG :: Ord b => (a -> b) -> (a -> c) -> [a] -> [(b, [c])]

sameLength :: [t] -> [t1] -> Bool

naturals :: [Int]

Monad routines

perhapsM :: Monad m => Bool -> a -> m a

repeatM :: Monad m => m a -> m [a]

repeatM_ :: Monad m => m a -> m ()

replicateM :: Monad m => Int -> m a -> m [a]

replicateM_ :: Monad m => Int -> m a -> m ()

maybeToMonad :: Monad m => Maybe a -> m a

convert a maybe to an arbitrary failable monad

toMonadM :: Monad m => m (Maybe a) -> m a

ioM :: Monad m => IO a -> IO (m a)

Trasform IO errors into the failing of an arbitrary monad.

ioMp :: MonadPlus m => IO a -> IO (m a)

Trasform IO errors into the mzero of an arbitrary member of MonadPlus.

foldlM :: Monad m => (a -> b -> m a) -> a -> [b] -> m a

foldlM_ :: Monad m => (a -> b -> m a) -> a -> [b] -> m ()

foldl1M :: Monad m => (a -> a -> m a) -> [a] -> m a

foldl1M_ :: Monad m => (a -> a -> m a) -> [a] -> m ()

maybeM :: Monad m => String -> Maybe a -> m a

convert a maybe to an arbitrary failable monad

Text Routines

Quoting

shellQuote :: [String] -> String

quote a set of strings as would be appropriate to pass them as arguments to a sh style shell

simpleQuote :: [String] -> String

quote strings rc style. single quotes protect any characters between them, to get an actual single quote double it up. Inverse of simpleUnquote

simpleUnquote :: String -> [String]

inverse of simpleQuote

Layout

indentLines :: Int -> String -> String

place spaces before each line in string.

buildTableLL :: [(String, String)] -> [String]

buildTableRL :: [(String, String)] -> [String]

buildTable :: [String] -> [(String, [String])] -> String

trimBlankLines :: String -> String

trim blank lines at beginning and end of string

paragraph :: Int -> String -> String

reformat a string to not be wider than a given width, breaking it up between words.

paragraphBreak :: Int -> String -> String

expandTabs :: String -> String

expand tabs into spaces in a string assuming tabs are every 8 spaces and we are starting at column 0.

chunkText :: Int -> String -> String

Scrambling

rot13 :: String -> String

Random

intercalate :: [a] -> [[a]] -> [a]

intercalate xs xss is equivalent to (concat (intersperse xs xss)). It inserts the list xs in between the lists in xss and concatenates the result.

powerSet :: [a] -> [[a]]

compute the power set of a list

randomPermute :: StdGen -> [a] -> [a]

randomly permute a list given a RNG

randomPermuteIO :: [a] -> IO [a]

randomly permute a list, using the standard random number generator.

chunk :: Int -> [a] -> [[a]]

rtup :: t1 -> t -> (t, t1)

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

fromEither :: Either a a -> a

mapFst :: (a -> b) -> (a, c) -> (b, c)

mapSnd :: (a -> b) -> (c, a) -> (c, b)

mapFsts :: (a -> b) -> [(a, c)] -> [(b, c)]

mapSnds :: (a -> b) -> [(c, a)] -> [(c, b)]

tr :: String -> String -> String -> String

Translate characters to other characters in a string, if the second argument is empty, delete the characters in the first argument, else map each character to the cooresponding one in the second argument, cycling the second argument if necessary.

readHex :: Monad m => String -> m Int

overlaps :: Ord a => (a, a) -> (a, a) -> Bool

determine if two closed intervals overlap at all.

showDuration :: (Show a, Integral a) => a -> String

translate a number of seconds to a string representing the duration expressed.

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

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

split :: (a -> Bool) -> [a] -> [[a]]

Splits a list into components delimited by separators, where the predicate returns True for a separator element. The resulting components do not contain the separators. Two adjacent separators result in an empty component in the output. eg.

 split (=='a') "aabbaca"
 ["", "", "bb", "c", ""]

tokens :: (a -> Bool) -> [a] -> [[a]]

Like split, except that sequences of adjacent separators are treated as a single separator. eg.

 tokens (=='a') "aabbaca"
 ["bb","c"]

count :: (a -> Bool) -> [a] -> Int

count elements of list that have a given property

hasRepeatUnder :: Ord a1 => (a -> a1) -> [a] -> Bool

Option handling

getArgContents :: IO String

behave like while() in perl, go through the argument list, reading the concation of each file name mentioned or stdin if - is on it. If no arguments are given, read stdin.

parseOpt

Arguments

:: Monad m

=> String

Argument string, list of valid options with : after ones which accept an argument

-> [String]

Arguments

-> m ([String], [Char], [(Char, String)])

(non-options,flags,options with arguments)

Process options with an option string like the standard C getopt function call.

getOptContents :: String -> IO (String, [Char], [(Char, String)])

Combination of parseOpt and getArgContents.

doTime :: String -> IO a -> IO a

time task

getPrefix :: Monad m => String -> String -> m String

rspan :: (a -> Bool) -> [a] -> ([a], [a])

rbreak :: (a -> Bool) -> [a] -> ([a], [a])

rdropWhile :: (a -> Bool) -> [a] -> [a]

rtakeWhile :: (a -> Bool) -> [a] -> [a]

rbdropWhile :: (a -> Bool) -> [a] -> [a]

concatMapM :: Monad m => (a -> m [b]) -> [a] -> m [b]

on :: (a -> a -> b) -> (c -> a) -> c -> c -> b

mapMsnd :: Monad m => (b -> m c) -> [(a, b)] -> m [(a, c)]

mapMfst :: Monad m => (b -> m c) -> [(b, a)] -> m [(c, a)]

iocatch :: IO a -> (IOException -> IO a) -> IO a

catch function only for IOException

Classes

class Monad m => UniqueProducer m where

class for monads which can generate unique values.

Methods

newUniq :: m Int

produce a new unique value

Instances

UniqueProducer IO

UniqueProducer Tc

(Monad m, Monad (t m), MonadTrans t, UniqueProducer m) => UniqueProducer (t m)

Monad m => UniqueProducer (UniqT m)