| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
NLP.GenI
Description
This is the interface between the front and backends of the generator. The GUI and the console interface both talk to this module, and in turn, this module talks to the input file parsers and the surface realisation engine.
- data ProgState = ProgState {
- pa :: Params
- gr :: Macros
- le :: Lexicon
- morphinf :: MorphInputFn
- traces :: [Text]
- customMorph :: Maybe MorphRealiser
- type ProgStateRef = IORef ProgState
- emptyProgState :: Params -> ProgState
- type LexicalSelector sem = Macros -> Lexicon -> sem -> IO LexicalSelection
- runGeni :: ProgState -> CustomSem sem -> Builder st it -> TestCase sem -> ExceptT String IO (GeniResults, st)
- simplifyResults :: Either String (GeniResults, st) -> GeniResults
- defaultCustomSem :: ProgState -> IO (CustomSem SemInput)
- data GeniResults = GeniResults {
- grResults :: [GeniResult]
- grGlobalWarnings :: [Text]
- grStatistics :: Statistics
- data GeniResult
- isSuccess :: GeniResult -> Bool
- data GeniError = GeniError [Text]
- data GeniSuccess = GeniSuccess {}
- data GeniLexSel = GeniLexSel {}
- data ResultType
- initGeni :: ProgState -> CustomSem sem -> sem -> ExceptT String IO (Input, GeniWarnings)
- extractResults :: ProgState -> Maybe Params -> Builder st it -> st -> IO [GeniResult]
- lemmaSentenceString :: GeniSuccess -> Text
- prettyResult :: ProgState -> GeniSuccess -> Text
- showRealisations :: [String] -> String
- histogram :: Ord a => [a] -> Map a Int
- getTraces :: ProgState -> Text -> [Text]
- loadEverything :: ProgStateRef -> CustomSem sem -> IO ()
- class Loadable x where
- loadLexicon :: ProgStateRef -> IO Lexicon
- loadGeniMacros :: ProgStateRef -> IO Macros
- loadTestSuite :: ProgState -> CustomSem sem -> IO [TestCase sem]
- parseSemInput :: Text -> Either ParseError SemInput
- loadRanking :: ProgStateRef -> IO ()
- data BadInputException = BadInputException String Text
- loadFromString :: Loadable a => ProgStateRef -> String -> Text -> IO a
Main interface
Program state and configuration
The program state consists of its configuration options and abstract, cleaned up representations of all the data it's had to load into memory (tree schemata files, lexicon files, etc). The intention is for the state to stay static until the next time something triggers some file loading.
Constructors
| ProgState | |
Fields
| |
type ProgStateRef = IORef ProgState Source #
emptyProgState :: Params -> ProgState Source #
The program state when you start GenI for the very first time
type LexicalSelector sem = Macros -> Lexicon -> sem -> IO LexicalSelection Source #
See Configuration if you want to use GenI with a custom
lexical selection function.
Running GenI
runGeni :: ProgState -> CustomSem sem -> Builder st it -> TestCase sem -> ExceptT String IO (GeniResults, st) Source #
Entry point! (the most useful function to know here)
- Initialises the realiser (lexical selection, among other things),
- Runs the builder (the surface realisation engine proper)
- Unpacks the builder results
- Finalises the results (morphological generation)
In addition to the results, this returns a generator state. The latter is is mostly useful for debugging via the graphical interface. Note that we assumes that you have already loaded in your grammar and parsed your input semantics.
simplifyResults :: Either String (GeniResults, st) -> GeniResults Source #
simplifyResults $ runGenI...' for an easier time if you don't need the
surface realiser state
defaultCustomSem :: ProgState -> IO (CustomSem SemInput) Source #
Standard GenI semantics and lexical selection algorithm (with optional "preanchored" mode)
data GeniResults Source #
GeniResults is the outcome of running GenI on a single input semantics.
Each distinct result is returned as a single GeniResult (NB: a single
result may expand into multiple strings through morphological
post-processing),
Constructors
| GeniResults | |
Fields
| |
Instances
isSuccess :: GeniResult -> Bool Source #
data GeniSuccess Source #
Constructors
| GeniSuccess | |
Fields
| |
Instances
Helpers
initGeni :: ProgState -> CustomSem sem -> sem -> ExceptT String IO (Input, GeniWarnings) Source #
initGeni performs lexical selection and strips the input semantics of
any morpohological literals
See defaultCustomSem
Arguments
| :: ProgState | |
| -> Maybe Params | test-case-specific parameters |
| -> Builder st it | |
| -> st | |
| -> IO [GeniResult] |
This is a helper to runGenI. It's mainly useful if you are building
interactive GenI debugging tools.
Given a builder state,
- Unpacks the builder results
- Finalises the results (morphological generation)
lemmaSentenceString :: GeniSuccess -> Text Source #
No morphology! Pretend the lemma string is a sentence
prettyResult :: ProgState -> GeniSuccess -> Text Source #
showRealisations :: [String] -> String Source #
Show the sentences produced by the generator, in a relatively compact form
getTraces :: ProgState -> Text -> [Text] Source #
getTraces is most likely useful for grammars produced by a
metagrammar system. Given a tree name, we retrieve the `trace'
information from the grammar for all trees that have this name. We
assume the tree name was constructed by GenI; see the source code for
details.
Loading things
loadEverything :: ProgStateRef -> CustomSem sem -> IO () Source #
We have one master function that loads all the files GenI is expected to use. This just calls the sub-loaders below, some of which are exported for use by the graphical interface. The master function also makes sure to complain intelligently if some of the required files are missing.
class Loadable x where Source #
The file loading functions all work the same way: we load the file, and try to parse it. If this doesn't work, we just fail in IO, and GenI dies. If we succeed, we update the program state passed in as an IORef.
Minimal complete definition
loadLexicon :: ProgStateRef -> IO Lexicon Source #
loadGeniMacros :: ProgStateRef -> IO Macros Source #
The macros are stored as a hashing function in the monad.
parseSemInput :: Text -> Either ParseError SemInput Source #
loadRanking :: ProgStateRef -> IO () Source #
Arguments
| :: Loadable a | |
| => ProgStateRef | |
| -> String | description |
| -> Text | string to load |
| -> IO a |
Load something from a string rather than a file