GF.Support

Supporting infrastructure and system utilities

Source locations

class HasSourcePath a where

Methods

sourcePath :: a -> FilePath

Instances

HasSourcePath ModuleInfo

data Location

Constructors

NoLoc

Local Int Int

External FilePath Location

Instances

Eq Location

Ord Location

Show Location

Pretty Location

data L a

Attaching location information

Constructors

L Location a

Instances

Functor L

Show a => Show (L a)

Pretty a => Pretty (L a)

unLoc :: L a -> a

noLoc :: a -> L a

ppLocation :: FilePath -> Location -> Doc

ppL :: (Pretty a1, Pretty a2) => L a2 -> a1 -> Doc

Command line options

Option types

data Options

Instances

Show Options

data Flags

Constructors

Flags

Fields

optMode :: Mode

optStopAfterPhase :: Phase

optVerbosity :: Verbosity

optShowCPUTime :: Bool

optOutputFormats :: [OutputFormat]

optSISR :: Maybe SISRFormat

optHaskellOptions :: Set HaskellOption

optLexicalCats :: Set String

optLiteralCats :: Set Ident

optGFODir :: Maybe FilePath

optOutputDir :: Maybe FilePath

optGFLibPath :: Maybe FilePath

optDocumentRoot :: Maybe FilePath

optRecomp :: Recomp

optProbsFile :: Maybe FilePath

optRetainResource :: Bool

optName :: Maybe String

optPreprocessors :: [String]

optEncoding :: Maybe String

optPMCFG :: Bool

optOptimizations :: Set Optimization

optOptimizePGF :: Bool

optSplitPGF :: Bool

optCFGTransforms :: Set CFGTransform

optLibraryPath :: [FilePath]

optStartCat :: Maybe String

optSpeechLanguage :: Maybe String

optLexer :: Maybe String

optUnlexer :: Maybe String

optWarnings :: [Warning]

optDump :: [Dump]

optTagsOnly :: Bool

optHeuristicFactor :: Maybe Double

optCaseSensitive :: Bool

optPlusAsBind :: Bool

optJobs :: Maybe (Maybe Int)

optTrace :: Bool

Instances

Show Flags

data Mode

Constructors

ModeVersion

ModeHelp

ModeInteractive

ModeRun

ModeInteractive2

ModeRun2

ModeCompiler

ModeServer Int

Instances

Eq Mode

Ord Mode

Show Mode

data Phase

Constructors

Preproc

Convert

Compile

Link

Instances

Eq Phase

Ord Phase

Show Phase

data Verbosity

Constructors

Quiet

Normal

Verbose

Debug

Instances

Bounded Verbosity

Enum Verbosity

Eq Verbosity

Ord Verbosity

Show Verbosity

data OutputFormat

Constructors

FmtPGFPretty

FmtJavaScript

FmtPython

FmtHaskell

FmtProlog

FmtLambdaProlog

FmtByteCode

FmtBNF

FmtEBNF

FmtRegular

FmtNoLR

FmtSRGS_XML

FmtSRGS_XML_NonRec

FmtSRGS_ABNF

FmtSRGS_ABNF_NonRec

FmtJSGF

FmtGSL

FmtVoiceXML

FmtSLF

FmtRegExp

FmtFA

Instances

Eq OutputFormat

Ord OutputFormat

Read OutputFormat

Show OutputFormat

data SISRFormat

Constructors

SISR_WD20030401

SISR Working draft 1 April 2003 http://www.w3.org/TR/2003/WD-semantic-interpretation-20030401/

SISR_1_0

Instances

Eq SISRFormat

Ord SISRFormat

Show SISRFormat

data Optimization

Constructors

OptStem

OptCSE

OptExpand

OptParametrize

Instances

Eq Optimization

Ord Optimization

Show Optimization

data CFGTransform

Constructors

CFGNoLR

CFGRegular

CFGTopDownFilter

CFGBottomUpFilter

CFGStartCatOnly

CFGMergeIdentical

CFGRemoveCycles

Instances

Eq CFGTransform

Ord CFGTransform

Show CFGTransform

data HaskellOption

Constructors

HaskellNoPrefix

HaskellGADT

HaskellLexical

HaskellConcrete

HaskellVariants

Instances

Eq HaskellOption

Ord HaskellOption

Show HaskellOption

newtype Dump

Constructors

Dump Pass

Instances

Eq Dump

Ord Dump

Show Dump

data Pass

Constructors

Source

Rebuild

Extend

Rename

TypeCheck

Refresh

Optimize

Canon

Instances

Eq Pass

Ord Pass

Show Pass

data Recomp

Constructors

AlwaysRecomp

RecompIfNewer

NeverRecomp

Instances

Eq Recomp

Ord Recomp

Show Recomp

outputFormatsExpl :: [((String, OutputFormat), String)]

Option parsing

parseOptions

Arguments

:: ErrorMonad err

=> [String]

list of string arguments

-> err (Options, [FilePath])

parseModuleOptions

Arguments

:: ErrorMonad err

=> [String]

list of string arguments

-> err Options

fixRelativeLibPaths :: FilePath -> FilePath -> Options -> Options

Option pretty-printing

optionsGFO :: Options -> [(String, Literal)]

Pretty-print the options that are preserved in .gfo files.

optionsPGF :: Options -> [(String, Literal)]

Pretty-print the options that are preserved in .pgf files.

Option manipulation

addOptions :: Options -> Options -> Options

concatOptions :: [Options] -> Options

noOptions :: Options

modifyFlags :: (Flags -> Flags) -> Options

helpMessage :: String

Checking specific options

flag :: (Flags -> a) -> Options -> a

cfgTransform :: Options -> CFGTransform -> Bool

haskellOption :: Options -> HaskellOption -> Bool

readOutputFormat :: Monad m => String -> m OutputFormat

isLexicalCat :: Options -> String -> Bool

isLiteralCat :: Options -> Ident -> Bool

renameEncoding :: String -> String

This is for bacward compatibility. Since GHC 6.12 we started using the native Unicode support in GHC but it uses different names for the code pages.

getEncoding :: Options -> String

defaultEncoding :: [Char]

Setting specific options

setOptimization :: Optimization -> Bool -> Options

setCFGTransform :: CFGTransform -> Bool -> Options

Convenience methods for checking options

verbAtLeast :: Options -> Verbosity -> Bool

dump :: Options -> Dump -> Bool

The Error monad

data Err a

Like Maybe type with error msgs

Constructors

Ok a

Bad String

Instances

Monad Err

Functor Err

added 2/10/2003 by PEB

Applicative Err

Alternative Err

MonadPlus Err

added by KJ

ErrorMonad Err

Eq a => Eq (Err a)

Read a => Read (Err a)

Show a => Show (Err a)

err :: (String -> b) -> (a -> b) -> Err a -> b

Analogue of maybe

maybeErr :: ErrorMonad m => String -> Maybe a -> m a

Add msg s to Maybe failures

testErr :: ErrorMonad m => Bool -> String -> m ()

fromErr :: a -> Err a -> a

Analogue of fromMaybe

errIn :: ErrorMonad m => String -> m a -> m a

lookupErr :: (ErrorMonad m, Eq a, Show a) => a -> [(a, b)] -> m b

Error monad class

class (Functor m, Monad m) => ErrorMonad m where

Minimal complete definition

raise, handle

Methods

raise :: String -> m a

handle :: m a -> (String -> m a) -> m a

handle_ :: m a -> m a -> m a

Instances

ErrorMonad Err

checks :: ErrorMonad m => [m a] -> m a

liftErr :: ErrorMonad m => Err a -> m a

Checking

checkUnique :: (Show a, Eq a) => [a] -> [String]

unifyMaybeBy :: (Eq b, Monad m) => (a -> b) -> Maybe a -> Maybe a -> m (Maybe a)

unifyMaybe :: (Eq a, Monad m) => Maybe a -> Maybe a -> m (Maybe a)

this is what happens when matching two values in the same module

Monadic operations on lists and pairs

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

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

pairM :: Monad m => (b -> m c) -> (b, b) -> m (c, c)

Binary search trees; now with FiniteMap

type BinTree a b = Map a b

emptyBinTree :: BinTree a b

isInBinTree :: Ord a => a -> BinTree a b -> Bool

lookupTree :: (ErrorMonad m, Ord a) => (a -> String) -> a -> BinTree a b -> m b

lookupTreeManyAll :: Ord a => (a -> String) -> [BinTree a b] -> a -> [b]

updateTree :: Ord a => (a, b) -> BinTree a b -> BinTree a b

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

filterBinTree :: Ord a => (a -> b -> Bool) -> BinTree a b -> BinTree a b

mapTree :: ((a, b) -> c) -> BinTree a b -> BinTree a c

tree2list :: BinTree a b -> [(a, b)]

Printing

indent :: Int -> String -> String

(+++) :: String -> String -> String infixr 5

(++-) :: String -> String -> String infixr 5

(++++) :: String -> String -> String infixr 5

(+++-) :: String -> String -> String

(+++++) :: String -> String -> String infixr 5

prUpper :: String -> String

prReplicate :: Int -> String -> String

prTList :: String -> [String] -> String

prQuotedString :: String -> String

prParenth :: String -> String

prCurly :: String -> String

prBracket :: String -> String

prArgList :: [String] -> String

prSemicList :: [String] -> String

prCurlyList :: [String] -> String

restoreEscapes :: String -> String

numberedParagraphs :: [[String]] -> [String]

prConjList :: String -> [String] -> String

prIfEmpty :: String -> String -> String -> String -> String

wrapLines :: Int -> String -> String

Thomas Hallgren's wrap lines

Topological sorting

topoTest :: Ord a => [(a, [a])] -> Either [a] [[a]]

Topological sorting with test of cyclicity

topoTest2 :: Ord a => [(a, [a])] -> Either [[a]] [[a]]

Topological sorting with test of cyclicity, new version /TH 2012-06-26

Misc

ifNull :: b -> ([a] -> b) -> [a] -> b

combinations :: [[a]] -> [[a]]

combinations is the same as sequence!!! peb 30/5-04

done :: Monad m => m ()

return ()

readIntArg :: String -> Int

iterFix :: Eq a => ([a] -> [a]) -> [a] -> [a]

Fix point iterator (for computing e.g. transitive closures or reachability)

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

chop into separator-separated parts

Files and IO

putIfVerb :: Output f => Options -> String -> f ()

GF files path and library path manipulation

type FileName = String

type InitPath

Arguments

 = String

the directory portion of a pathname

type FullPath = String

gfLibraryPath :: [Char]

gfGrammarPathVar :: [Char]

getLibraryDirectory :: MonadIO io => Options -> io FilePath

getGrammarPath :: MonadIO io => FilePath -> io [FilePath]

extendPathEnv :: MonadIO io => Options -> io [FilePath]

extends the search path with the gfLibraryPath and gfGrammarPathVar environment variables. Returns only existing paths.

getSubdirs :: FilePath -> IO [FilePath]

justModuleName :: FilePath -> String

isGF :: FilePath -> Bool

isGFO :: FilePath -> Bool

gfFile :: FilePath -> FilePath

gfoFile :: FilePath -> FilePath

gf2gfo :: Options -> FilePath -> FilePath

gf2gfo' :: Maybe FilePath -> FilePath -> FilePath

splitInModuleSearchPath :: String -> [FilePath]

Error handling in the IO monad

type IOE a = IO a

Was: newtype IOE a = IOE { appIOE :: IO (Err a) }

tryIOE :: IOE a -> IO (Err a)

Catch exceptions caused by calls to raise or fail in the IO monad. To catch all IO exceptions, use try instead.

useIOE :: a -> IOE a -> IO a

Print the error message and return a default value if the IO operation fails

maybeIO :: MonadIO f => IO a -> f (Maybe a)

die :: String -> IO a

Diagnostic output

class Monad m => Output m where

Methods

ePutStr, ePutStrLn, putStrE, putStrLnE :: String -> m ()

Instances

Output IO

Output m => Output (StateT s m)

putPointE :: (MonadIO m, Output m) => Verbosity -> Options -> String -> m b -> m b

ioErrorText :: IOError -> String

Because GHC adds the confusing text "user error" for failures caused by calls to fail.

Timing

timeIt :: MonadIO m => m t -> m (Integer, t)

File IO

writeUTF8File :: FilePath -> String -> IO ()

readBinaryFile :: FilePath -> IO String

writeBinaryFile :: FilePath -> String -> IO ()

Reused

class Monad m => MonadIO m where

Monads in which IO computations may be embedded. Any monad built by applying a sequence of monad transformers to the IO monad will be an instance of this class.

Instances should satisfy the following laws, which state that liftIO is a transformer of monads:

• liftIO . return = return

• liftIO (m >>= f) = liftIO m >>= (liftIO . f)

Methods

liftIO :: IO a -> m a

Lift a computation from the IO monad.

Instances

MonadIO IO

MonadIO m => MonadIO (CGIT m)

MonadIO m => MonadIO (MaybeT m)

MonadIO m => MonadIO (InputT m)

MonadIO m => MonadIO (ListT m)

MonadIO m => MonadIO (IdentityT m)

MonadIO m => MonadIO (ReaderT r m)

MonadIO m => MonadIO (ContT r m)

MonadIO m => MonadIO (StateT s m)

MonadIO m => MonadIO (StateT s m)

MonadIO m => MonadIO (ExceptT e m)

(Error e, MonadIO m) => MonadIO (ErrorT e m)

(Monoid w, MonadIO m) => MonadIO (WriterT w m)

(Monoid w, MonadIO m) => MonadIO (WriterT w m)

(Monoid w, MonadIO m) => MonadIO (RWST r w s m)

(Monoid w, MonadIO m) => MonadIO (RWST r w s m)

liftErr :: ErrorMonad m => Err a -> m a

Backwards compatible try and catch

catch :: IO a -> (IOError -> IO a) -> IO a

try :: IO a -> IO (Either IOError a)

Console IO

Changing which character encoding to use for console IO

setConsoleEncoding :: IO ()

Set the console encoding (for Windows, has no effect on Unix-like systems)

changeConsoleEncoding :: String -> IO ()

Console colors

data TermColors

Constructors

TermColors

Fields

redFg, blueFg, restore :: String

Instances

Show TermColors

getTermColors :: MonadIO m => m TermColors

Binary serialisation

class Binary t

The Binary class provides put and get, methods to encode and decode a Haskell value to a lazy ByteString. It mirrors the Read and Show classes for textual representation of Haskell types, and is suitable for serialising Haskell values to disk, over the network.

For parsing and generating simple external binary formats (e.g. C structures), Binary may be used, but in general is not suitable for complex protocols. Instead use the Put and Get primitives directly.

Instances of Binary should satisfy the following property:

decode . encode == id

That is, the get and put methods should be the inverse of each other. A range of instances are provided for basic Haskell types.

Minimal complete definition

put, get

Instances

Binary Bool

Binary Char

Binary Double

Binary Float

Binary Int

Binary Int8

Binary Int16

Binary Int32

Binary Int64

Binary Integer

Binary Ordering

Binary Word

Binary Word8

Binary Word16

Binary Word32

Binary Word64

Binary ()

Binary ByteString

Binary ByteString

Binary IntSet

Binary RawIdent

Binary a => Binary [a]

(Binary a, Integral a) => Binary (Ratio a)

Binary a => Binary (Maybe a)

Binary e => Binary (IntMap e)

(Ord a, Binary a) => Binary (Set a)

Binary e => Binary (Tree e)

Binary e => Binary (Seq e)

Binary a => Binary (VersionTagged a)

(Binary a, Binary b) => Binary (Either a b)

(Binary a, Binary b) => Binary (a, b)

(Binary i, Ix i, Binary e, IArray UArray e) => Binary (UArray i e)

(Binary i, Ix i, Binary e) => Binary (Array i e)

(Ord k, Binary k, Binary e) => Binary (Map k e)

(Binary a, Binary b, Binary c) => Binary (a, b, c)

(Binary a, Binary b, Binary c, Binary d) => Binary (a, b, c, d)

(Binary a, Binary b, Binary c, Binary d, Binary e) => Binary (a, b, c, d, e)

(Binary a, Binary b, Binary c, Binary d, Binary e, Binary f) => Binary (a, b, c, d, e, f)

(Binary a, Binary b, Binary c, Binary d, Binary e, Binary f, Binary g) => Binary (a, b, c, d, e, f, g)

(Binary a, Binary b, Binary c, Binary d, Binary e, Binary f, Binary g, Binary h) => Binary (a, b, c, d, e, f, g, h)

(Binary a, Binary b, Binary c, Binary d, Binary e, Binary f, Binary g, Binary h, Binary i) => Binary (a, b, c, d, e, f, g, h, i)

(Binary a, Binary b, Binary c, Binary d, Binary e, Binary f, Binary g, Binary h, Binary i, Binary j) => Binary (a, b, c, d, e, f, g, h, i, j)

encode :: Binary a => a -> ByteString

Encode a value using binary serialisation to a lazy ByteString.

decode :: Binary a => ByteString -> a

Decode a value from a lazy ByteString, reconstructing the original structure.

encodeFile :: Binary a => FilePath -> a -> IO ()

Lazily serialise a value to a file

This is just a convenience function, it's defined simply as:

encodeFile f = B.writeFile f . encode

So for example if you wanted to compress as well, you could use:

B.writeFile f . compress . encode

decodeFile :: Binary a => FilePath -> IO a

Lazily reconstruct a value previously written to a file.

This is just a convenience function, it's defined simply as:

decodeFile f = return . decode =<< B.readFile f

So for example if you wanted to decompress as well, you could use:

return . decode . decompress =<< B.readFile f