|
|
|
|
|
Description |
This module provides some very generic, non-GenI specific functions on strings,
trees and other miscellaneous odds and ends. Whenever possible, one should try
to replace these functions with versions that are available in the standard
libraries, or the Haskell platform ones, or on hackage.
|
|
Synopsis |
|
ePutStr :: String -> IO () | | ePutStrLn :: String -> IO () | | eFlush :: IO () | | readFile' :: FilePath -> IO String | | lazySlurp :: ForeignPtr Word8 -> Int -> Int -> IO String | | withTimeout :: Integer -> IO a -> IO a -> IO a | | exitTimeout :: IO () | | dropTillIncluding :: Char -> String -> String | | trim :: String -> String | | toUpperHead :: String -> String | | toLowerHead :: String -> String | | toAlphaNum :: String -> [AlphaNum] | | fst3 :: (a, b, c) -> a | | snd3 :: (a, b, c) -> b | | thd3 :: (a, b, c) -> c | | map' :: (a -> b) -> [a] -> [b] | | boundsCheck :: Int -> [a] -> Bool | | isEmptyIntersect :: Eq a => [a] -> [a] -> Bool | | groupByFM :: Ord b => (a -> b) -> [a] -> Map b [a] | | multiGroupByFM :: Ord b => (a -> [b]) -> [a] -> Map b [a] | | insertToListMap :: Ord b => b -> a -> Map b [a] -> Map b [a] | | groupAndCount :: (Eq a, Ord a) => [a] -> [(a, Int)] | | combinations :: [[a]] -> [[a]] | | mapMaybeM :: Monad m => (a -> m (Maybe b)) -> [a] -> m [b] | | repList :: (a -> Bool) -> (a -> a) -> [a] -> [a] | | mapTree' :: (a -> b) -> Tree a -> Tree b | | filterTree :: (a -> Bool) -> Tree a -> [a] | | treeLeaves :: Tree a -> [a] | | preTerminals :: Tree a -> [(a, a)] | | repNode :: (Tree a -> Tree a) -> (Tree a -> Bool) -> Tree a -> Maybe (Tree a) | | repAllNode :: (Tree a -> Tree a) -> (Tree a -> Bool) -> Tree a -> Tree a | | listRepNode :: (Tree a -> Tree a) -> (Tree a -> Bool) -> [Tree a] -> ([Tree a], Bool) | | repNodeByNode :: (a -> Bool) -> a -> Tree a -> Tree a | | type Interval = (Int, Int) | | (!+!) :: Interval -> Interval -> Interval | | ival :: Int -> Interval | | showInterval :: Interval -> String | | type BitVector = Integer | | showBitVector :: Int -> BitVector -> String | | geniBug :: String -> a |
|
|
|
IO
|
|
|
putStr on stderr
|
|
|
|
|
|
Strict readFile
|
|
|
Using readFile' can be a good idea if you're dealing with not-so-huge
files (i.e. where you don't want lazy evaluation), because it ensures
that the handles are closed. No more ``too many open files''
|
|
|
|
Timeouts
|
|
|
:: | | => Integer | action to run upon timing out
| -> IO a | main action to run
| -> IO a | | -> IO a | |
|
|
|
Like exitFailure, except that we return with a code that we reserve for timing out
|
|
Strings
|
|
|
Drop all characters up to and including the one in question
|
|
|
|
|
Make the first character of a string upper case
|
|
|
Make the first character of a string lower case
|
|
|
An alphanumeric sort is one where you treat the numbers in the string
as actual numbers. An alphanumeric sort would put x2 before x100,
because 2 < 10, wheraeas a naive sort would put it the other way
around because the characters 1 < 2. To sort alphanumerically, just
'sortBy (comparing toAlphaNum)'
|
|
Triples
|
|
|
|
|
|
|
|
Lists
|
|
map' :: (a -> b) -> [a] -> [b] | Source |
|
A strict version of map
|
|
|
Makes sure that index s is in the bounds of list l.
Surely there must be some more intelligent way to deal with this.
|
|
|
True if the intersection of two lists is empty.
|
|
|
Serves the same function as groupBy. It groups together
items by some property they have in common. The difference is that the
property is used as a key to a Map that you can lookup.
|
|
multiGroupByFM :: Ord b => (a -> [b]) -> [a] -> Map b [a] | Source |
|
Same as groupByFM, except that we let an item appear in
multiple groups. The fn extracts the property from the item,
and returns multiple results in the form of a list
|
|
|
|
|
Convert a list of items into a list of tuples (a,b) where
a is an item in the list and b is the number of times a
in occurs in the list.
|
|
combinations :: [[a]] -> [[a]] | Source |
|
|
|
|
repList :: (a -> Bool) -> (a -> a) -> [a] -> [a] | Source |
|
Return the list, modifying only the first matching item.
|
|
Trees
|
|
|
Strict version of mapTree (for non-strict, just use fmap)
|
|
|
Like filter, except on Trees. Filter might not be a good name, though,
because we return a list of nodes, not a tree.
|
|
|
The leaf nodes of a Tree
|
|
|
Return pairs of (parent, terminal)
|
|
|
:: | | => Tree a -> Tree a | filtering function
| -> Tree a -> Bool | | -> Tree a | | -> Maybe (Tree a) | | repNode fn filt t returns a version of t in which the first
node which filt matches is transformed using fn.
|
|
|
|
Like repNode except that it performs the operations on
all nodes that match and doesn't care if any nodes match
or not
|
|
|
|
|
|
:: | | => a -> Bool | | -> a | | -> Tree a | | -> Tree a | | Replace a node in the tree in-place with another node; keep the
children the same. If the node is not found in the tree, or if
there are multiple instances of the node, this is treated as an
error.
|
|
|
Intervals
|
|
|
|
|
Add two intervals
|
|
|
ival x builds a trivial interval from x to x
|
|
|
|
Bit vectors
|
|
|
|
|
displays a bit vector, using a minimum number of bits
|
|
Bugs
|
|
|
errors specifically in GenI, which is very likely NOT the user's fault.
|
|
Produced by Haddock version 2.6.0 |