پ?      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                              !"#$%&'()*+,-./0123456789:;<=>?@ +Adds a metric at the beginning of the list B (note we reverse the order whene we want to print the metrics) A        8 is something you want to perform detect polarities on. RestrictedPolarityKey c att( is a polarity key in which we only pay - attention to nodes that have the category c. This makes it possible 9 to have polarities for a just a small subset of nodes     /BCD-Intermediary type used for alphanumeric sort EFputStr on stderr <Drop all characters up to and including the one in question 0Make the first character of a string upper case 0Make the first character of a string lower case FAn alphanumeric sort is one where you treat the numbers in the string F as actual numbers. An alphanumeric sort would put x2 before x100,  because 2 <6 10, wheraeas a naive sort would put it the other way # around because the characters 1 <$ 2. To sort alphanumerically, just  'sortBy (comparing toAlphaNum)' !"#$A strict version of G %6Makes sure that index s is in the bounds of list l. E Surely there must be some more intelligent way to deal with this. &0True if the intersection of two lists is empty. 'Serves the same function as H. It groups together J 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. (Same as '', except that we let an item appear in A multiple groups. The fn extracts the property from the item, 6 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. +,-9Return the list, modifying only the first matching item. .Strict version of mapTree! (for non-strict, just use fmap) /Like I=, except on Trees. Filter might not be a good name, though, 2 because we return a list of nodes, not a tree. 0The leaf nodes of a Tree 1#Return pairs of (parent, terminal) 22  fn filt t returns a version of t in which the first  node which filt matches is transformed using fn. replacement function filtering function 3Like 2+ except that it performs the operations on ! all nodes that match and doesn't care if any nodes match  or not 4Like 2 but on a list of tree nodes replacement function filtering function nodes 5@Replace a node in the tree in-place with another node; keep the C children the same. If the node is not found in the tree, or if C there are multiple instances of the node, this is treated as an  error.  which node? 6>errors specifically in GenI, which is very likely NOT the user' s fault. 7Add two intervals 88 x builds a trivial interval from x to x 9:6displays a bit vector, using a minimum number of bits ;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'' J<K=action to run upon timing out main action to run >Like  exitFailureC, except that we return with a code that we reserve for timing out ( !"#$%&'()*+,-./0123456789:;<=>(;<=> !"#$%&'()*+,-./012345789:6( !"#$%&'()*+,-./0123456789:;<=>#?@ABCDEFGHIJK anonymous L variable M(atomic disjunction - constant x | y | z NOPQ(assumes that it' s a GConst!) R(assumes that it' s a GVar!) SS& performs unification on two lists of J. If $ unification succeeds, it returns  Just (r,s) where v erb!r! is ! the result of unification and v'erb!s! is a list of substitutions that  this unification results in. T=Note that the first Subst is assumed to come chronologically % before the second one; so merging  { X -> Y } and  { Y -> 3 }  should give us { X -> 3; Y -> 3 }; See U for a warning! U!Add to variable replacement to a I that logical comes before 6 the other stuff in it. So for example, if we have Y -> foo  and we want to insert X -> Y, we notice that, in fact, Y has  already been replaced by foo , so we add X -> foo instead >Note that it is undefined if you try to append something like  Y -> foo to Y -> bar+, because that would mean that unification  is broken VSee source code for details WXYFHere it is safe to say (X -> Y; Y -> Z) because this would be crushed / down into a final value of (X -> Z; Y -> Z) Z[\5Unifying something with itself should always succeed ]KUnifying something with only anonymous variables should succeed and return  the same result. ^*Unification should be symmetrical. We can't guarantee these if there N are cases where there are variables in the same place on both sides, so we ) normalise the sides so that this doesn' t happen. _`a%?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[L\]^M_`a#JMLKNOPQRISTUEHGFVWXYZ[CD\]^AB?@_`a#?@@ABBCDDEHGFFGHIJMLKKLMNOPQRSTUVWXYZ[\]^_`ab7Note: you can define the final state either by setting e  to Just f where f( is some function or by putting them in  f cdei will use this if defined fcan be ignored if e is defined g=there can be more than one transition between any two states . and a transition could be the empty symbol h if you don'*t care about grouping states into columns 0 you can just dump everything in one big list ii. returns all the final states of an automaton jj  aut st1 ab returns the states that st1 transitions  to via a. k from state  transition  to state l9Returns all possible paths through an automaton from the  start state to any dead-end. .Each path is represented as a list of labels. 5We assume that the automaton does not have any loops  in it. m?The set of all bundled paths. A bundled path is a sequence of A states through the automaton from the start state to any dead < end. Any two neighbouring states can have more than one A possible transition between them, so the bundles can multiply - out to a lot of different possible paths. (The output is a list of lists of lists: ; Each item in the outer list is a bundled path through the ? automaton, i.e. without distinguishing between the possible 0 transitions from any two neighbouring states 7 Each item in the middle list is represents the set of 5 transitions between two given neighbouring states 5 Each item in the inner list represents a transition  between two given states nobcdefghijklmnobcdefghikjlmnobcdefghcdefghijklmnocpqrsfor gui tuexpected results (for testing) v8results we actually got, and their traces (for testing) wxyz{:An Idable is something that can be mapped to a unique id. < You might consider using this to implement Ord, but I won't. ? Note that the only use I have for this so far (20 dec 2005)  is in alpha-conversion. |}~A single node of a TAG tree. top feature structure bottom feature structure False for na nodes [] for na nodes +for TAG, this would be the elementary tree ' that this node originally came from 7A lexicon maps semantic predicates to lexical entries. IA null tree which you can use for various debugging or display purposes. A null > which you can use for various debugging or display purposes. Return the value of the cat attribute, if available 9Attributes recognised as lexemes, in order of preference Given a lexical item s' and a Tree GNode t, returns the tree t' 4 where l has been assigned to the anchor node in t' Given a lexical item l and a tree node n (actually a subtree D with no children), return the same node with the lexical item as I its unique child. The idea is that it converts terminal lexeme nodes I into preterminal nodes where the actual terminal is the given lexical  item @Plug the first tree into the second tree at the specified node. 9 Anything below the second node is silently discarded. @ We assume the trees are pluggable; it is treated as a bug if  they are not! Given two trees auxt and t, splice the tree auxt into  t via the TAG adjunction rule. foot node of the aux tree  aux tree place to adjoin in target tree  target tree NO,Sort an Flist according with its attributes :Given a Semantics, return the string with the proper keys + (propsymbol+arity) to access the agenda PQJSort semantics first according to its predicate, and then to its handles. 3 performs feature structure unification, under the & these assumptions about the input:  Features are ordered 9 The Flists do not share variables (renaming has already  been done. ?The features are allowed to have different sets of attributes,  beacuse we use R to realign them. RR@ is a pre-procesing step used to ensure that feature structures M have the same set of keys. If a key is missing in one, we copy it to the " other with an anonymous value. ;The two feature structures must be sorted for this to work SmCDIJKLMNOPQRSTWYpqrstuvwxyz{|}~mpqrstuvzJMLKyxwISTWCDY}~{|QRNOP]pqrstuvqrstuvwxyz{||}~~  .T is a generalisation of . An anchored grammar. P The grammar associates a set of semantic predicates to a list of trees each. addTags  tags key elem adds elem( to the the list of elements associated  to the key AGiven a tree(GNode) returns a list of substitution or adjunction H nodes, as well as remaining nodes with a null adjunction constraint. FAssigns a unique id to each element of this list, that is, an integer ' between 1 and the size of the list. UCSorts trees into a Map.Map organised by the first literal of their E semantics. This is useful in at least three places: the polarity M optimisation, the gui display code, and code for measuring the efficiency H of GenI. Note: trees with a null semantics are filed under an empty  predicate, if any.  cs ts' determines if the candidate semantics cs is ) subsumed by the proposition semantics ts. Notice how the proposition I semantics is only a single item where as the candidate semantics is a  list.  We assume  most importantly that cs' has already its semantics instatiated  (all variables assigned)  cs and ts are sorted 9 the list in each element of cs and ts is itself sorted V3Try in order: lexeme, lexeme attributes, node name W+~+~*   ;XYZ[\]>The original string representation of the semantics (for gui) ^_1Just the String representations of the semantics  in the test suite .This is only used by the script genimakesuite `abcde<The original string representation of a test case semantics  (for gui) fghi jklmn <This makes it possible to read anchored trees, which may be " useful for debugging purposes. EFIXME: note that this is very rudimentary; we do not set id numbers,  parse polarities. You'll have to call @ some of our helper functions if you want that functionality. opp: recognises a list of parameters optionally followed by a  bang (vBerb$!$) and a list of attribute-value pairs. This whole thing is  to wrapped in the parens. TODO: deprecate  q rr4 associates a numerical value to a polarity symbol,  that is, s or t. uvwxyz{|}~Like y# but allows for reserved words too *identifier, permitting reserved words too  i                ; is like Show but it's only used for debugging  TODO: is this true? 3position in the input semantics, extra semantics,  polarity interval Aintermediate auts, seed aut, final aut, potentially modified sem EConstructs a polarity automaton. For debugging purposes, it returns I all the intermediate automata produced by the construction algorithm. polarities to detect  root features to compensate for explicit extra polarities input semantics lexical selection KReturns a modified input semantics and lexical selection in which pronouns  are properly accounted for. KBuilds a fake semantic predicate that the index counting mechanism uses to  represent extra columns. 1Careful, this completely ignores any user errors polarity to assign attribute to look for feature structure to filter on $feature structure to get value from polarity to assign 5Given a list of paths (i.e. a list of list of trees) M return a list of trees such that each tree is annotated with the paths it  belongs to. 8Render the list of polarity automaton paths as a string Adds a new polarity item to a ". If there already is a polarity 5 for that item, it is summed with the new polarity. BEnsures that all states and transitions in the polarity automaton < are unique. This is a slight optimisation so that we don' t have to B repeatedly check the automaton for state uniqueness during its C construction, but it is essential that this check be done after  construction 'an initial state for polarity automata  )Display a PolMap in human-friendly text. < The advantage is that it displays fewer quotation marks. bghil  libgh !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_ `ablexical selection already done c#built into geni, no parsing needed dgeni's text format efghijkone phase only! lmnop q>Holds the specification for how Geni should be run, its input B files, etc. This is the stuff that would normally be found in  the configuration file. rstuvwxyz{|%The default parameters configuration }?Uses the GetOpt library to process the command line arguments. 9 Note that we divide them into basic and advanced usage. ~ flag ;string reader for flag (probably |id| if already a String)  description flag default value string reader (as in reqArg)  description HPrint out a GenI-style usage message with options divided into sections options  prog name    !"+Displays the usage text for optimisations. = It shows a table of optimisation codes and their meaning. #?If we do not recognise a code, we output an error message. We 9 also take the liberty of expanding thematic codes like pol - into the respective list of optimisations. $#Returns |Left| for any codes we don't recognise, or  |Right| if everything is ok. %&=Hint: compose with (map toLower) to make it case-insensitive '+Is case-insensitive, error if unknown type ()*;Update the internal instructions list, test suite and case 6 according to the contents of an instructions file. +,-./0123456789:;!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~tqrstuadcbehgf`_]^YZ[\WXUVSTQROPMNKLIJEFCDAB12?@=>;<9:785634/0-.+,)*'(GH%&#$!"z{ywxviponmlkj|~}s!""#$$%&&'(()**+,,-../001223445667889::;<<=>>?@@ABBCDDEFFGHHIJJKLLMNNOPPQRRSTTUVVWXXYZZ[\\]^^_`adcbbcdehgffghiponmlkjjklmnopqrsturstuvwxyz{|}~ AA sentence composed of  instead of plain old words (A lemma plus its morphological features for the debugger  tag tree Equivalent to <5 unless the input contains an empty or uninstatiated  semantics NPerforms surface realisation from an input semantics and a lexical selection. Statistics tracked L pol_used_bundles - number of bundled paths through the polarity automaton.  see m > pol_used_paths - number of paths through the final automaton X pol_seed_paths - number of paths through the seed automaton (i.e. with no polarities). X This is normally just 1, unless you have multi-literal semantics O pol_total_states - combined number of states in the all the polarity automata J pol_total_tras - combined number of transitions in all polarity automata R pol_max_states - number of states in the polarity automaton with the most states [ pol_total_tras - number of transitions in the polarity automata with the most transitions ;assign a bit vector value to each literal in the semantics > the resulting map can then be used to construct a bit vector ! representation of the semantics :Return the literals of the semantics (in bit vector form) 1 whose accesibility depends on the given index -Return the handle and arguments of a literal Like  fromGConstG but only for the non-disjoint ones: meant to be used as Maybe or List &Calculate the new set of accessibility/!inaccesible indices, returning a  a tuple of accesible / inaccesible indices JReturn, in bitvector form, the portion of a semantics that is inaccesible  from an item the input semantics the semantics of the item Default implementation for the  function in  Sequence two dispatch filters. /A filter that always fails (i.e. no filtering) BIf the item meets some condition, use the first filter, otherwise  use the second one. @Running the null builder allows you to track certain statistics = sem_literals - number of literals in the input semantics < lex_trees - total number of lexically selected trees AThe names of lexically selected chart items used in a derivation AAA DConverts information from a morphological information file into GenI's  internal format. GFilters away from an input semantics any literals whose realisation is K strictly morphological. The first argument tells us helps identify the N morphological literals -- it associates literals with morphological stuff;  if it returns =, then it is non-morphological  morphfn sem cands$ does the bulk of the morphological  input processing. We use morphfn to determine which literals in  semF contain morphological information and what information they contain. J Then we attach this morphological information to the relevant trees in  cand:. A tree is considered relevant w.r.t to a morphological L literal if its semantics contains at least one literal whose first index @ is the same as the first index of the morphological literal. >?Actually unify the morphological features into the anchor node  FIXME: we'3ll need to make sure this still works as promised ! when we implement co-anchors. HExtracts the lemmas from a list of uninflected sentences. This is used 9 when the morphological generator is unavailable, doesn' t work, etc. HConverts a list of uninflected sentences into inflected ones by calling ?  +@ABCDEempty for global FGSame as  with the sorting inverted H.these traces must not appear AT THE SAME TIME the trace must NOT appear the trace must appear IJ>A positive constraint is violated when a trace is NOT present K:A negative constraint is violated when a trace is present >Note that we will not notice if a constraint is violated more < than once. If you want to count multiple violations, you'll D either need to partition the input strings and map this function ) on each sublist or rewrite this code.  lex name traces L9Violations sorted so that the highest ranking constraint  (smallest number) goes first M6Sort the sentences so that the ones with the *lowest* 1 ranking violations (biggest number) go first. 7 Note that we return in groups for the sake of ties. NOPQRSTUVWXY0Results are grouped so that ties can be noticed Z[\u]^_7Things whose only use is within the graphical debugger nodes to highlight actually a set 1 if there are things wrong with this item, what? 2actually: a set of pre-terminals and their leaves `abcd efgh   i jklmnopq6True if the chart item has no open substitution nodes r,True if the chart item is an auxiliary tree s True if both q and r are True tu!Creates an initial SimpleStatus. v disable gui wxyz{|}~?Arbitrarily selects and removes an element from the agenda and  returns it. 8Note: returns ONE possible substitution (the head node) B of the first in the second. As all substitutions nodes should 2 be substituted we force substitution in order.  Ignore the next adjunction node  Ignore the next adjunction node  aux trees me ]Retrieves a list of trees from the chart which could be combined with the given agenda tree. 5 The current implementation searches for trees which 5 * do not have overlapping semantics with the given @ * are on the some of the same polarity automaton paths as the  current agenda item 3Helper function for when chart operations succeed. nodes to highlight .This is only used for the one-phase algorithm AIf the item (ostensibly a result) does not have the correct root 8 category, return Nothing; otherwise return Just item *     1     *     Y>Only used for instances of GenI where the grammar is compiled  directly into GenI. -(node, top, att) (node is Nothing if anchor)  !"#$*the current configuration being processed %&'()names of test case to run *%name, original string (for gui), sem +OT constraints (optional) ,simplified traces (optional) -,any warnings accumulated during realisation  (most recent first) .>The program state when you start GenI for the very first time 2Log another warning in our internal program state /01:The macros are stored as a hashing function in the monad. :The results are stored as a lookup function in the monad. 23verbose 42Stores the results in the tcase and tsuite fields 5&Updates program state the same way as 4 flag flag >Load the file if the relevant option is set, otherwise ignore HLoad the file if the relevant option is set, otherwise complain and die  file to load  description  parsing cmd 6KReturns a list of sentences, a set of Statistics, and the generator state. S The generator state is mostly useful for debugging via the graphical interface. I Note that we assumes that you have already loaded in your grammar and  parsed your input semantics. 788> performs lexical selection and strips the input semantics of  any morpohological literals : does any post-processing steps that we want to integrate O into mainline GenI. So far, this consists of morphological realisation and  OT ranking 9KShow the sentences produced by the generator, in a relatively compact form :6No morphology! Pretend the lemma string is a sentence ;<<2 is most likely useful for grammars produced by a ; metagrammar system. Given a tree name, we retrieve the `trace' G information from the grammar for all trees that have this name. We I assume the tree name was constructed by GenI; see the source code for  details. &We assume the name was constructed by  combineName =GSelect and returns the set of entries from the lexicon whose semantics ! subsumes the input semantics.  xs fn organises items (xs) by their semantic key  (retrieved by fn$). An item may have multiple keys. >>  macros lex creates the  repository combining lexical G entries and un-anchored trees from the grammar. It also unifies the M parameters used to specialize un-anchored trees and propagates additional  features given in the . DGiven a lexical item, looks up the tree families for that item, and ! anchor the item to the trees. any warnings, plus the results HCombine a single tree with its lexical item to form a bonafide TagElem. G This process can fail, however, because of filtering or enrichement lexeme (for debugging info) enrichment eq Split a lex entry'6s path equations into interface enrichement equations  or (co-)anchor modifiers 1Parse a path equation using the GenI conventions ( This always succeeds, but can return  Just warning " if anything anomalous comes up ,* !"#$%&'()*+,-./0123456789:;<=>,"#$%&'()*+,-!.867 :;9*</014523>=+  !" #$%&'()*+,-#$%&'()*+,-./0123456789:;<=> !"#$%&''()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRRSSTUVWXYZ[\]^_`abcdefghijklmnopqrsstuvwxyz{|}~                               ! " # $ % & ' ( ) * + ,--..//00112233445566778899::;;<<==>>??@@AABBCCDDEEFFGGHHIIJJKKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                              !"#$%&&'()*+,-./0123456789:;< = > > ? @ A B C D E F G H I J K L M N O P Q R S T U VWXWY Z [ \ ] ^ _ ` a  b  c d efghfgifgjfgkfglfgmfgnfgofgpfgqfgrfgsfgtfgufgvfgwfgxfgyfgzfg{fg|fg}fg~ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff                                         L      *!"# $ %&&'()*++,-./0123456789:;<=>?@ABCDEFGHIJTKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~: GenI-0.20.2NLP.GenI.ConfigurationNLP.GenI.StatisticsNLP.GenI.PolarityTypesNLP.GenI.GeneralNLP.GenI.GeniValNLP.GenI.AutomatonNLP.GenI.Btypes NLP.GenI.TagsNLP.GenI.GeniShowNLP.GenI.GeniParsersNLP.GenI.PolarityNLP.GenI.BuilderNLP.GenI.MorphologyNLP.GenI.OptimalityTheoryNLP.GenI.Simple.SimpleBuilder NLP.GenI.GeniNLP.GenI.BtypesBinarybase Data.TypeableTypeableMetric IntMetricStatisticsState Statistics updateMetrics queryMetrics emptyStatsinitialStatisticsStateFor addMetricshowFinalStats incrIntMetricqueryIntMetric PolarityAttrRestrictedPolarityAttr_rpkCatrpkAttSimplePolarityAttrspkAtt PolarityKeyfromPolarityKeyreadPolarityAttrs BitVectorIntervalePutStr ePutStrLneFlushtrimdropTillIncluding toUpperHead toLowerHead toAlphaNumfst3snd3thd3map' boundsCheckisEmptyIntersect groupByFMmultiGroupByFMinsertToListMap groupAndCount combinations mapMaybeMrepListmapTree' filterTree treeLeaves preTerminalsrepNode repAllNode listRepNode repNodeByNodegeniBug!+!ival showInterval showBitVector readFile' lazySlurp withTimeout exitTimeout GTestString2 GTestStringDescendGeniValdescendGeniValUnificationResultFailure SuccessRep SuccessSansSubstGeniValGAnonGVarGConstisConstisVarisAnon fromGConstfromGVarunify mergeSubstprependToSubstunifyOnereplace replaceOne replaceList replaceMapG replaceOneGprop_unify_selfprop_unify_anonprop_unify_symfromGTestStringfromGTestString2qc_not_empty_GConstNFAstartSt isFinalSt finalStList transitionsstatesfinalSt lookupTransaddTransautomatonPathsautomatonPathSets numStatesnumTransitionsTestCasetcName tcSemStringtcSem tcExpected tcOutputsSemInput LitConstrSemPredIdableidOf CollectablecollectAvPairavAttavValFlistNodeNameGTypeOtherLexFootSubsGNodeGNgnnamegupgdownganchorglexemegtypegaconstrgorigin MorphLexEntry ILexEntryILEiwordifamnameiparams iinterfaceifilters iequationsiptype isemanticsisempolsSemPolsLexiconPtype UnspecifiedAuxiliarInitialTtreeTTparamspfamilypidname pinterfaceptype psemanticsptracetreeMacrosMTtree emptyMacroemptyLE emptyGNodegnnameIs gCategorylexemeAttributes showLexemerootrootUpdfoot setAnchor setLexemeplugTree spliceTreealphaConvertById alphaConvert sortFlist showFlist showPairsshowAv emptyPredshowSemshowPredtoKeys subsumeSemsortSem unifyFeatTagItemtgIdNametgIdNum tgSemanticsDerivationStepdsOpdsChilddsParent dsParentSite TagDerivationTagElemTEidname ttreenametidnumttypettree tsemantics tpolarities tinterfacettracetsempolsTagSitetsNametsUptsDowntsOriginTags addToTagsemptyTE detectSites setTidnumsmapBySem subsumedBy tagLeaves showTagSitests_synIncompletets_tbUnificationFailurets_rootFeatureMismatchts_semIncompleteGeniShowgeniShowparenssquaresgeniShowKeywordgeniShowSemInputgeniLanguageDef geniValue geniFeats geniSemanticsgeniSemanticInputtoSemInputString geniTestSuitegeniTestSuiteStringgeniDerivations geniWordsgeniWord geniLexicon geniMacros geniTagElems geniMorphInfogeniPolaritiestillEof parseFromFileshowLitePolAutPolStatePolStAutDebug PolResultbuildAutomaton makePolAut fixPronounsdetectIdxConstraintsdeclareIdxConstraintsdetectPolFeatures detectSansIdx detectPolsdetectPolPaths showPolPaths showPolPaths' showLitePm ViewCmdFlg VersionFlgVerboseModeFlg TimeoutFlg TestSuiteFlgTestInstructionsFlg TestCaseFlg StatsFileFlgNoLoadTestSuiteFlgRunUnitTestFlgRootFeatureFlgRegressionTestModeFlgRankingConstraintsFlg PartialFlg OutputFileFlgOptimisationsFlg MorphInfoFlg MorphCmdFlg MetricsFlg TracesFlg MacrosFlg LexiconFlgInstructionsFileFlgHelpFlg FromStdinFlgExtraPolaritiesFlg EarlyDeathFlgDumpDerivationFlgDetectPolaritiesFlg DisableGuiFlg BatchDirFlgFlag Instruction GrammarType PreAnchored PreCompiledGeniHand BuilderTypeSimpleOnePhaseBuilder SimpleBuilder NullBuilder OptimisationEarlyNaIaf SemFiltered NoConstraints PolarisedAdjOptsPolOptsParamsPrms grammarType builderType geniFlagshasOpthasFlagP deleteFlagPsetFlagPgetFlagP getListFlagP emptyParamsoptionsForStandardGenI basicSectionsoptionsSections nubBySwitchesnoArgreqArgoptArgusage treatArgstreatArgsWithParams defineParamsoptionsForBasicStuffoptionsForInputFilesoptionsForOptimisationparseFlagWithParsecoptionsForBuildermainBuilderTypesoptionsForTestingoptionsForMorphologyprocessInstructionshasFlagsetFlaggetFlagLemmaPlusSentence LemmaPluslpLemmalpFeats NullStateDispatchFilterIafAbleiafAcciafInacc iafSetAcc iafSetInacc iafNewAccIafMap SemBitMap BuilderStateUninflectedDisjunction SentenceAutInput inSemInputinLexinCands DerivationOutputBuilderinitstepstepAllfinishedunpackpartialpreInitunlessEmptySemrundefineSemanticBitssemToBitVectorbitVectorToSem dependentSem literalArgs semToIafMap fromUniConstgetIdx ts_iafFailurerecalculateAccesibility iafBadSemdefaultStepAll>--> nullFilter condFilter modifyStats incrCounter queryCounter initStats namedMetricdefaultMetricNamesnum_iterations chart_sizenum_comparisons nullBuilderinitNullBuilderlexicalSelection parsecToJSONMorphFn readMorph stripMorphSem attachMorphsetMorphAnchor sansMorphinflectSentencesUsingCmdOtResult GetTraces OtViolation OtRankingRankedOtConstraint OtConstraint NegativeConjC NegativeC PositiveC otWarnings rankResultsprettyViolations prettyRank SimpleGuiItem siHighlightsiNodes siDiagnostic siFullSemsiIdname SimpleItemsiId siSubstnodes siAdjnodes siSemantics siPolpaths siAccesiblesiInaccessiblesiLeaves siDerivedsiRootsiFoot siPendingTb siDerivation siGuiStuff SimpleStatus theAgenda theHoldingPentheCharttheTrash theResults genconfig SimpleStateChart AuxAgendaAgendasimpleBuilder_2psimpleBuilder_1p simpleBuilder addToAgenda addToChartinitSimpleBuilder unpackResultSelector ResultType PartialResultCompleteResult GeniResultgrLemmaSentencegrRealisations grDerivationgrLexSelection grRanking grViolations grResultType ProgStateRef ProgStateSTpagrlemorphinftstcasetsuiterankingtraceswarningsemptyProgStateloadEverything loadLexiconloadGeniMacros loadRanking readRanking loadTestSuiteloadTargetSemStrrunGenirunGeniWithSelectorinitGenishowRealisationslemmaSentenceString prettyResult getTraces chooseLexCandcombineStatmetrics metricToJSONTimeOutAlphaNumNAGHC.Basemap Data.ListgroupByGHC.Listfilterbuf_size timeOutTc testSuitetestBackPropagationnmatch findSubTreesubsumeSemHelper subsumePred alignFeat alignFeatH setOrigin getLexeme firstMaybeTestCaseOutputSemInputString geniAttVal geniLiteralgeniSemanticInputStringgeniIdxConstraints squaresString geniTestCase geniOutput geniTraces withWhite geniSentencegeniTestCaseStringgeniLexicalEntrygeniLexSemanticsgeniLexLiteral geniPolValueinitTypeauxType geniTreeDefgeniTreegeniNode geniTagElem geniParams morphEntry geniPolarityGHC.Num+-keywordkeywordSemanticslexer whiteSpace identifierlooseIdentifier stringLiteralcolonbracesreservedsymbol identifierRparsec-2.1.0.1(Text.ParserCombinators.Parsec.Combinator lookAheadmanyTill notFollowedByeofanyTokenchainr1chainl1chainlchainrcountendByendBy1sepEndBy sepEndBy1sepBy1sepBymany1 skipMany1betweenoptional optionMaybeoptionchoice"Text.ParserCombinators.Parsec.CharstringsatisfyanyCharcharoctDigithexDigitdigitletteralphaNumloweruppertabnewlinespacespacesnoneOfoneOf CharParser"Text.ParserCombinators.Parsec.PrimtokensskipManymany unexpectedlabelslabel tokenPrimEx tokenPrimtokentrypzero runParserparse parseTestsetParserStategetParserStatesetInput setPositiongetInput getPosition updateStatesetStategetState<|>Parser GenParser stateUserstatePos stateInputState#Text.ParserCombinators.Parsec.ErrorerrorPos ParseError!Text.ParserCombinators.Parsec.PossetSourceColumn setSourceLine setSourceNameincSourceColumn incSourceLine sourceColumn sourceLine sourceName SourceNameLineColumn SourcePosShowLite PolTransFnPolTransPolMapSemMap PolPathMapPolarityDetectionResultPD_Just PD_Nothing PD_UserError SemWeightMapPredLite buildColumns buildSeedAut buildSeedAut'buildSeedAutHelper buildPolAut buildPolAut'buildPolAutHelperpruneprune' indexPred isExtraCol assignIndexidxConstraintKey detectPolsH__cat____idx__pdJustsdetectPolaritydetectPolarityForAttrtoZero prefixWith substNodes substTopsdetectPolPaths' sortSemByFreqaddPolnubAut fakestatepolstartWeirdFlgGrammarTypeFlg BuilderFlg OptSection getSwitches usageSectioninstructionsOption macrosOption lexiconOption tracesOption rankingOptionoptionsForOutput outputOptionoptionsForUserInterface noguiOption helpOption versionOption verboseOptiondefaultPolarityAttrsdefaultRootFeatcoreOptimisationCodesoptimisationCodespolOptsadjOpts lookupOpt showOptCode describeOptusageForOptimisationsreadOptimisationsparseOptimisationslookupOptimisationmReadBuilderTypereadBuilderTypefromStdinOptiontestSuiteOptionmorphInfoOptioninstructionsFileisFlag deleteFlag getAllFlagsSystem.Console.GetOptgetOpt'getOpt usageInfo RequireOrderPermute ReturnInOrderArgOrderOptionOptDescrNoArgReqArgOptArgArgDescrid Data.MaybeNothingattachMorphHelper singletonLexItemlLexnamelTraces otLexNameotConstraintViolatedRankedOtConstraint2 violations posViolations negViolationssortedViolations sortResults lexTraces toLexItemrankedOtConstraintToPairsprettyRankedConstraintprettyConstraint neverViolatednonExistentTracescTraces concatRanknoRankbucketssortAndGroupByDecorationindented splitAtBeforeTbEitherSimpleDispatchFilterChartIdS theIafMaptsem gencounter semBitMapGenerationPhaseAdjunctionPhaseSubstitutionPhaseTrashisAdjunctionPhase updateAgendaaddToAuxAgenda addToTrash addToResultsemptySimpleGuiItemmodifyGuiStuffclosedaux closedAuxadjdone siInitialinitSimpleIteminitSimpleGuiItemrenameNodesWithTidnumgenerateStep_1pgenerateStep_2pgenerateStep_2p_subgenerateStep_2p_adjtrashIt selectGiven switchToAux semfilterapplySubstitutionapplySubstitution1p iapplySubstapplyAdjunction2ppassiveAdjunction1pactiveAdjunction1pvalidAuxtryAdjsansAdjunction1psansAdjunction2p iapplyAdjNode canAdjoindetectNancopyisRootOf lookupChartfilterCompatiblecombineSimpleItemscombineSimpleGuiItems constrainAdjaddToDerivationsimpleDispatch_2psimpleDispatch_2p_adjphasesimpleDispatch_1psimpleDispatch dpToAgenda dpToResults dpToTrashdpAux dpTbFailuredpRootFeatFailure tbUnifyTree tbUnifyNode dpIafFailure unpackResultslistToSentenceAutpartialResultscoverage countBits PathEqPair PathEqLhsLexCombineError OtherError EnrichErroreeMacro eeLexEntry eeLocation BoringError GeniLexSelnlTreenlTracemyEMPTY addWarning loadMorphInfo loadTracesloadThingOrIgnoreloadThingOrDie loadThingparseFromFileOrFailparseFromFileMaybeBinaryinitGeniWithSelectorfinaliseResults readPidnamerunLexSelectioncompressLexCombineErrors chooseCandI mapBySemKeys mapEither combineList unzipEither combineOneenrichenrichBy pathEqNamemissingCoanchors lexEquations seekCoanchor matchNodeName parsePathEq setLemAnchors _lemanchordefaultSelectorreadPreAnchored