--1 Constructors: the Resource Syntax API incomplete resource Constructors = open Grammar in { flags optimize=noexpand ; -- This module gives access to the syntactic constructions of the -- GF Resource Grammar library. Its main principle is simple: -- to construct an object of type $C$, use the function $mkC$. -- -- For example, an object of type $S$ corresponding to the string -- -- $John loves Mary$ -- -- is written -- -- $mkS (mkCl (mkNP (mkPN "John")) (mkV2 "love") (mkNP (mkPN "Mary")))$ -- -- This module defines the syntactic constructors, which take trees as arguments. -- Lexical constructors, which take strings as arguments, are defined in the -- $Paradigms$ modules separately for each language. -- -- The recommended usage of this module is via the wrapper module $Syntax$, -- which also contains the $Structural$ (structural words). -- Together with $Paradigms$, $Syntax$ gives everything that is needed -- to implement the concrete syntax for a langauge. --2 Principles of organization -- To make the library easier to grasp and navigate, we have followed -- a set of principles when organizing it: -- + Each category $C$ has an overloaded constructor $mkC$, with value type $C$. -- + With $mkC$, it is possible to construct any tree of type $C$, except -- atomic ones, i.e. those that take no arguments, and -- those whose argument types are exactly the same as in some other instance -- + To achieve completeness, the library therefore also has -- for each atomic tree of type $C$, a constant suffixed $C$, and, -- for other missing constructions, some operation suffixed $C$. -- These constructors are listed immediately after the $mkC$ group. -- + Those atomic constructors that are given in $Structural$ are not repeated here. -- + In addition to the minimally complete set of constructions, many $mkC$ groups -- include some frequently needed special cases, with two possible logics: -- default value (to decrease the number of arguments), and -- direct arguments of an intervening constructor (to flatten the terms). -- + If such a special case is applied to some category in some rule, it is -- also applied to all other rules in which the category appears. -- + The constructors in a group are listed, roughly, -- *from the most common to the most general*. This does not of course specify -- a total order. -- + Optional argument types are marked in parentheses. Although parentheses make no -- difference in the way the GF compiler treats the types, their presence indicates -- to the reader that the corresponding arguments can be left out; internally, the -- library has an overload case for each such combination. -- + Each constructor case is equipped with an example that is built by that -- case but could not be built with any other one. -- -- --2 Texts, phrases, and utterances --3 Text: texts -- A text is a list of phrases separated by punctuation marks. -- The default punctuation mark is the full stop, and the default -- continuation of a text is empty. oper mkText : overload { mkText : Phr -> Text ; -- 1. But John walks. mkText : Phr -> (Punct) -> (Text) -> Text ; -- 2. John walks? Yes. -- A text can also be directly built from utterances, which in turn can -- be directly built from sentences, present-tense clauses, questions, or -- positive imperatives. mkText : Utt -> Text ; -- 3. John. mkText : S -> Text ; -- 4. John walked. mkText : Cl -> Text ; -- 5. John walks. mkText : QS -> Text ; -- 6. Did John walk? mkText : Imp -> Text ; -- 7. Walk! -- Finally, two texts can be combined into a text. mkText : Text -> Text -> Text ; -- 8. Where? When? Here. Now! } ; -- A text can also be empty. emptyText : Text ; -- 8. (empty text) --3 Punct: punctuation marks -- There are three punctuation marks that can separate phrases in a text. fullStopPunct : Punct ; -- . questMarkPunct : Punct ; -- ? exclMarkPunct : Punct ; -- ! --3 Phr: phrases in a text -- Phrases are built from utterances by adding a phrasal conjunction -- and a vocative, both of which are by default empty. mkPhr : overload { mkPhr : Utt -> Phr ; -- 1. why mkPhr : (PConj) -> Utt -> (Voc) -> Phr ; -- 2. but why John -- A phrase can also be directly built by a sentence, a present-tense -- clause, a question, or a positive singular imperative. mkPhr : S -> Phr ; -- 3. John walked mkPhr : Cl -> Phr ; -- 4. John walks mkPhr : QS -> Phr ; -- 5. did John walk mkPhr : Imp -> Phr -- 6. walk } ; --3 PConj, phrasal conjunctions -- Any conjunction can be used as a phrasal conjunction. -- More phrasal conjunctions are defined in $Structural$. mkPConj : Conj -> PConj ; -- 1. and --3 Voc, vocatives -- Any noun phrase can be turned into a vocative. -- More vocatives are defined in $Structural$. mkVoc : NP -> Voc ; -- 1. John --3 Utt, utterances -- Utterances are formed from sentences, clauses, questions, and positive singular imperatives. mkUtt : overload { mkUtt : S -> Utt ; -- 1. John walked mkUtt : Cl -> Utt ; -- 2. John walks mkUtt : QS -> Utt ; -- 3. did John walk mkUtt : Imp -> Utt ; -- 4. love yourself -- Imperatives can also vary in $ImpForm$ (number/politeness) and -- polarity. mkUtt : (ImpForm) -> (Pol) -> Imp -> Utt ; -- 5. don't love yourselves -- Utterances can also be formed from interrogative phrases and -- interrogative adverbials, noun phrases, adverbs, and verb phrases. mkUtt : IP -> Utt ; -- 6. who mkUtt : IAdv -> Utt ; -- 7. why mkUtt : NP -> Utt ; -- 8. John mkUtt : Adv -> Utt ; -- 9. here mkUtt : VP -> Utt -- 10. to walk } ; -- The plural first-person imperative is a special construction. lets_Utt : VP -> Utt ; -- 11. let's walk --2 Auxiliary parameters for phrases and sentences --3 Pol, polarity -- Polarity is a parameter that sets a clause to positive or negative -- form. Since positive is the default, it need never be given explicitly. positivePol : Pol ; -- (John walks) [default] negativePol : Pol ; -- (John doesn't walk) --3 Ant, anteriority -- Anteriority is a parameter that presents an event as simultaneous or -- anterior to some other reference time. -- Since simultaneous is the default, it need never be given explicitly. simultaneousAnt : Ant ; -- (John walks) [default] anteriorAnt : Ant ; -- (John has walked) --# notpresent --3 Tense, tense -- Tense is a parameter that relates the time of an event -- to the time of speaking about it. -- Since present is the default, it need never be given explicitly. presentTense : Tense ; -- (John walks) [default] pastTense : Tense ; -- (John walked) --# notpresent futureTense : Tense ; -- (John will walk) --# notpresent conditionalTense : Tense ; -- (John would walk) --# notpresent --3 ImpForm, imperative form -- Imperative form is a parameter that sets the form of imperative -- by reference to the person or persons addressed. -- Since singular is the default, it need never be given explicitly. singularImpForm : ImpForm ; -- (help yourself) [default] pluralImpForm : ImpForm ; -- (help yourselves) politeImpForm : ImpForm ; -- (help yourself) (polite singular) --2 Sentences and clauses --3 S, sentences -- A sentence has a fixed tense, anteriority and polarity. mkS : overload { mkS : Cl -> S ; -- 1. John walks mkS : (Tense) -> (Ant) -> (Pol) -> Cl -> S ; -- 2. John wouldn't have walked -- Sentences can be combined with conjunctions. This can apply to a pair -- of sentences, but also to a list of more than two. mkS : Conj -> S -> S -> S ; -- 3. John walks and I run mkS : Conj -> ListS -> S ; -- 4. John walks, I run and you sleep mkS : DConj -> S -> S -> S ; -- 5. either John walk or I run mkS : DConj -> ListS -> S ; -- 6. either John walks, I run or you sleep -- A sentence can be prefixed by an adverb. mkS : Adv -> S -> S -- 7. today, John walks } ; --3 Cl, clauses -- A clause has a variable tense, anteriority and polarity. -- A clause can be built from a subject noun phrase -- with a verb and appropriate arguments. mkCl : overload { mkCl : NP -> V -> Cl ; -- 1. John walks mkCl : NP -> V2 -> NP -> Cl ; -- 2. John loves her mkCl : NP -> V3 -> NP -> NP -> Cl ; -- 3. John sends it to her mkCl : NP -> VV -> VP -> Cl ; -- 4. John wants to walk mkCl : NP -> VS -> S -> Cl ; -- 5. John says that it is good mkCl : NP -> VQ -> QS -> Cl ; -- 6. John wonders if it is good mkCl : NP -> VA -> AP -> Cl ; -- 7. John becomes old mkCl : NP -> V2A -> NP -> AP -> Cl ; -- 8. John paints it red mkCl : NP -> A -> Cl ; -- 9. John is old mkCl : NP -> A -> NP -> Cl ; -- 10. John is older than her mkCl : NP -> A2 -> NP -> Cl ; -- 11. John is married to her mkCl : NP -> AP -> Cl ; -- 12. John is very old mkCl : NP -> N -> Cl ; -- 13. John is a man mkCl : NP -> CN -> Cl ; -- 14. John is an old man mkCl : NP -> NP -> Cl ; -- 15. John is the man mkCl : NP -> Adv -> Cl ; -- 16. John is here -- As the general rule, a clause can be built from a subject noun phrase and -- a verb phrase. mkCl : NP -> VP -> Cl ; -- 17. John walks here -- Subjectless verb phrases are used for impersonal actions. mkCl : V -> Cl ; -- 18. it rains mkCl : VP -> Cl ; -- 19. it is raining -- Existentials are a special form of clauses. mkCl : N -> Cl ; -- 20. there is a house mkCl : CN -> Cl ; -- 21. there is an old houses mkCl : NP -> Cl ; -- 22. there are five houses -- There are also special forms in which a noun phrase or an adverb is -- emphasized. mkCl : NP -> RS -> Cl ; -- 23. it is John that walks mkCl : Adv -> S -> Cl -- 24. it is here John walks } ; -- Generic clauses are one with an impersonal subject. genericCl : VP -> Cl ; -- 25. one walks --2 Verb phrases and imperatives --3 VP, verb phrases -- A verb phrase is formed from a verb with appropriate arguments. mkVP : overload { mkVP : V -> VP ; -- 1. walk mkVP : V2 -> NP -> VP ; -- 2. love her mkVP : V3 -> NP -> NP -> VP ; -- 3. send it to her mkVP : VV -> VP -> VP ; -- 4. want to walk mkVP : VS -> S -> VP ; -- 5. know that she walks mkVP : VQ -> QS -> VP ; -- 6. ask if she walks mkVP : VA -> AP -> VP ; -- 7. become old mkVP : V2A -> NP -> AP -> VP ; -- 8. paint it red -- The verb can also be a copula ("be"), and the relevant argument is -- then the complement adjective or noun phrase. mkVP : A -> VP ; -- 9. be warm mkVP : AP -> VP ; -- 12. be very warm mkVP : A -> NP -> VP ; -- 10. be older than her mkVP : A2 -> NP -> VP ; -- 11. be married to her mkVP : N -> VP ; -- 13. be a man mkVP : CN -> VP ; -- 14. be an old man mkVP : NP -> VP ; -- 15. be the man mkVP : Adv -> VP ; -- 16. be here -- A verb phrase can be modified with a postverbal or a preverbal adverb. mkVP : VP -> Adv -> VP ; -- 17. sleep here mkVP : AdV -> VP -> VP -- 18. always sleep } ; -- Two-place verbs can be used reflexively. reflexiveVP : V2 -> VP ; -- 19. love itself -- Two-place verbs can also be used in the passive, with or without an agent. passiveVP : overload { passiveVP : V2 -> VP ; -- 20. be loved passiveVP : V2 -> NP -> VP ; -- 21. be loved by her } ; -- A verb phrase can be turned into the progressive form. progressiveVP : VP -> VP ; -- 22. be sleeping --3 Imp, imperatives -- Imperatives are formed from verbs and their arguments; as the general -- rule, from verb phrases. mkImp : overload { mkImp : V -> Imp ; -- go mkImp : V2 -> NP -> Imp ; -- take it mkImp : VP -> Imp -- go there now } ; --2 Noun phrases and determiners --3 NP, noun phrases -- A noun phrases can be built from a determiner and a common noun ($CN$) . -- For determiners, the special cases of quantifiers, numerals, integers, -- and possessive pronouns are provided. For common nouns, the -- special case of a simple common noun ($N$) is always provided. mkNP : overload { mkNP : Det -> N -> NP ; -- 1. the first man mkNP : Det -> CN -> NP ; -- 2. the first old man mkNP : QuantSg -> N -> NP ; -- 3. this man mkNP : QuantSg -> CN -> NP ; -- 4. this old man mkNP : QuantPl -> N -> NP ; -- 5. these men mkNP : QuantPl -> CN -> NP ; -- 6. these old men mkNP : Numeral -> N -> NP ; -- 7. twenty men mkNP : Numeral -> CN -> NP ; -- 8. twenty old men mkNP : Digits -> N -> NP ; -- 9. 45 men mkNP : Digits -> CN -> NP ; -- 10. 45 old men mkNP : Num -> N -> NP ; -- 11. almost twenty men mkNP : Num -> CN -> NP ; -- 12. almost twenty old men mkNP : Pron -> N -> NP ; -- 13. my man mkNP : Pron -> CN -> NP ; -- 14. my old man -- Proper names and pronouns can be used as noun phrases. mkNP : PN -> NP ; -- 15. John mkNP : Pron -> NP ; -- 16. he -- A noun phrase once formed can be prefixed by a predeterminer and -- suffixed by a past participle or an adverb. mkNP : Predet -> NP -> NP ; -- 17. only John mkNP : NP -> V2 -> NP ; -- 18. John killed mkNP : NP -> Adv -> NP ; -- 19. John in Paris -- A conjunction can be formed both from two noun phrases and a longer -- list of them. mkNP : Conj -> NP -> NP -> NP ; -- 20. John and I mkNP : Conj -> ListNP -> NP ; -- 21. John, I, and that mkNP : DConj -> NP -> NP -> NP ; -- 22. either John or I mkNP : DConj -> ListNP -> NP -- 23. either John, I, or that } ; --3 Det, determiners -- A determiner is either a singular or a plural one. -- Both have a quantifier and an optional ordinal; the plural -- determiner also has an optional numeral. mkDet : overload { mkDet : QuantSg -> Det ; -- 1. this mkDet : QuantSg -> (Ord) -> Det ; -- 2. this first mkDet : QuantPl -> Det ; -- 3. these mkDet : QuantPl -> (Num) -> (Ord) -> Det ; -- 4. these five best -- Quantifiers that have both singular and plural forms are by default used as -- singular determiners. If a numeral is added, the plural form is chosen. mkDet : Quant -> Det ; -- 5. this mkDet : Quant -> Num -> Det ; -- 6. these five -- Numerals, their special cases integers and digits, and possessive pronouns can be -- used as determiners. mkDet : Num -> Det ; -- 7. almost twenty mkDet : Numeral -> Det ; -- 8. five mkDet : Digits -> Det ; -- 9. 51 mkDet : Pron -> Det -- 10. my } ; -- The definite and indefinite articles are commonly used determiners. defSgDet : Det ; -- 11. the (house) defPlDet : Det ; -- 12. the (houses) indefSgDet : Det ; -- 13. a (house) indefPlDet : Det ; -- 14. (houses) --3 Quant, quantifiers with both sincular and plural forms -- Definite and indefinite articles have both singular and plural -- forms (even though the -- plural indefinite is empty in most languages). defQuant : Quant ; -- 1. the indefQuant : Quant ; -- 2. a -- More quantifiers are available in the $Structural$ module. --3 QuantSg, singular quantifiers -- From quantifiers that can have both forms, this constructor -- builds the singular form. mkQuantSg : Quant -> QuantSg ; -- 1. this -- The mass noun phrase constructor is treated as a singular quantifier. massQuant : QuantSg ; -- 2. (mass terms) -- More singular quantifiers are available in the $Structural$ module. -- The following singular cases of quantifiers are often used. the_QuantSg : QuantSg ; -- 3. the a_QuantSg : QuantSg ; -- 4. a this_QuantSg : QuantSg ; -- 5. this that_QuantSg : QuantSg ; -- 6. that --3 QuantPl, plural quantifiers -- From quantifiers that can have both forms, this constructor -- builds the plural form. mkQuantPl : Quant -> QuantPl ; -- 1. these -- More plural quantifiers are available in the $Structural$ module. -- The following plural cases of quantifiers are often used. the_QuantPl : QuantPl ; -- 2. the a_QuantPl : QuantPl ; -- 3. (indefinite plural) these_QuantPl : QuantPl ; -- 4. these those_QuantPl : QuantPl ; -- 5. those --3 Num, cardinal numerals -- Numerals can be formed from number words ($Numeral$), their special case digits, -- and from symbolic integers. mkNum : overload { mkNum : Numeral -> Num ; -- 1. twenty mkNum : Digits -> Num ; -- 2. 51 -- A numeral can be modified by an adnumeral. mkNum : AdN -> Num -> Num -- 3. almost ten } ; --3 Ord, ordinal numerals -- Just like cardinals, ordinals can be formed from number words ($Numeral$) -- and from symbolic integers. mkOrd : overload { mkOrd : Numeral -> Ord ; -- 1. twentieth mkOrd : Digits -> Ord ; -- 2. 51st -- Also adjectives in the superlative form can appear on ordinal positions. mkOrd : A -> Ord -- 3. best } ; --3 AdN, adnumerals -- Comparison adverbs can be used as adnumerals. mkAdN : CAdv -> AdN ; -- 1. more than --3 Numeral, number words -- Digits and some "round" numbers are here given as shorthands. n1_Numeral : Numeral ; -- 1. one n2_Numeral : Numeral ; -- 2. two n3_Numeral : Numeral ; -- 3. three n4_Numeral : Numeral ; -- 4. four n5_Numeral : Numeral ; -- 5. five n6_Numeral : Numeral ; -- 6. six n7_Numeral : Numeral ; -- 7. seven n8_Numeral : Numeral ; -- 8. eight n9_Numeral : Numeral ; -- 9. nine n10_Numeral : Numeral ; -- 10. ten n20_Numeral : Numeral ; -- 11. twenty n100_Numeral : Numeral ; -- 12. hundred n1000_Numeral : Numeral ; -- 13. thousand -- See $Numeral$ for the full set of constructors, and use the category -- $Digits$ for other numbers from one million. n1_Digits : Digits ; -- 1. 1 n2_Digits : Digits ; -- 2. 2 n3_Digits : Digits ; -- 3. 3 n4_Digits : Digits ; -- 4. 4 n5_Digits : Digits ; -- 5. 5 n6_Digits : Digits ; -- 6. 6 n7_Digits : Digits ; -- 7. 7 n8_Digits : Digits ; -- 8. 8 n9_Digits : Digits ; -- 9. 9 n10_Digits : Digits ; -- 10. 10 n20_Digits : Digits ; -- 11. 20 n100_Digits : Digits ; -- 12. 100 n1000_Digits : Digits ; -- 13. 1,000 --2 Nouns --3 CN, common noun phrases mkCN : overload { -- The most frequent way of forming common noun phrases is from atomic nouns $N$. mkCN : N -> CN ; -- 1. house -- Common noun phrases can be formed from relational nouns by providing arguments. mkCN : N2 -> NP -> CN ; -- 2. mother of John mkCN : N3 -> NP -> NP -> CN ; -- 3. distance from this city to Paris -- Relational nouns can also be used without their arguments. mkCN : N2 -> CN ; -- 4. son mkCN : N3 -> CN ; -- 5. flight -- A common noun phrase can be modified by adjectival phrase. We give special -- cases of this, where one or both of the arguments are atomic. mkCN : A -> N -> CN ; -- 6. big house mkCN : A -> CN -> CN ; -- 7. big blue house mkCN : AP -> N -> CN ; -- 8. very big house mkCN : AP -> CN -> CN ; -- 9. very big blue house -- A common noun phrase can be modified by a relative clause or an adverb. mkCN : N -> RS -> CN ; -- 10. house that John loves mkCN : CN -> RS -> CN ; -- 11. big house that John loves mkCN : N -> Adv -> CN ; -- 12. house in the city mkCN : CN -> Adv -> CN ; -- 13. big house in the city -- For some nouns it makes sense to modify them by sentences, -- questions, or infinitives. But syntactically this is possible for -- all nouns. mkCN : CN -> S -> CN ; -- 14. rule that John walks mkCN : CN -> QS -> CN ; -- 15. question if John walks mkCN : CN -> VP -> CN ; -- 16. reason to walk -- A noun can be used in apposition to a noun phrase, especially a proper name. mkCN : N -> NP -> CN ; -- 17. king John mkCN : CN -> NP -> CN -- 18. old king John } ; --2 Adjectives and adverbs --3 AP, adjectival phrases mkAP : overload { -- Adjectival phrases can be formed from atomic adjectives by using the positive form or -- the comparative with a complement mkAP : A -> AP ; -- 1. old mkAP : A -> NP -> AP ; -- 2. older than John -- Relational adjectives can be used with a complement or a reflexive mkAP : A2 -> NP -> AP ; -- 3. married to her mkAP : A2 -> AP ; -- 4. married to myself -- Some adjectival phrases can take as complements sentences, -- questions, or infinitives. Syntactically this is possible for -- all adjectives. mkAP : AP -> S -> AP ; -- 5. probable that John walks mkAP : AP -> QS -> AP ; -- 6. uncertain if John walks mkAP : AP -> VP -> AP ; -- 7. ready to go -- An adjectival phrase can be modified by an adadjective. mkAP : AdA -> A -> AP ; -- 8. very old mkAP : AdA -> AP -> AP ; -- 9. very very old -- Conjunction can be formed from two or more adjectival phrases. mkAP : Conj -> AP -> AP -> AP ; -- 10. old and big mkAP : Conj -> ListAP -> AP ; -- 11. old, big, and warm mkAP : DConj -> AP -> AP -> AP ; -- 12. either old or big mkAP : DConj -> ListAP -> AP -- 13. either old, big, or warm } ; --3 Adv, adverbial phrases mkAdv : overload { -- Adverbs can be formed from adjectives. mkAdv : A -> Adv ; -- 1. warmly -- Prepositional phrases are treated as adverbs. mkAdv : Prep -> NP -> Adv ; -- 2. with John -- Subordinate sentences are treated as adverbs. mkAdv : Subj -> S -> Adv ; -- 3. when John walks -- An adjectival adverb can be compared to a noun phrase or a sentence. mkAdv : CAdv -> A -> NP -> Adv ; -- 4. more warmly than John mkAdv : CAdv -> A -> S -> Adv ; -- 5. more warmly than John walks -- Adverbs can be modified by adadjectives. mkAdv : AdA -> Adv -> Adv ; -- 6. very warmly -- Conjunction can be formed from two or more adverbial phrases. mkAdv : Conj -> Adv -> Adv -> Adv ; -- 7. here and now mkAdv : Conj -> ListAdv -> Adv ; -- 8. with John, here and now mkAdv : DConj -> Adv -> Adv -> Adv ; -- 9. either here or now mkAdv : DConj -> ListAdv -> Adv -- 10. either here, now, or with John } ; --2 Questions and relatives --3 QS, question sentences mkQS : overload { -- Just like a sentence $S$ is built from a clause $Cl$, -- a question sentence $QS$ is built from -- a question clause $QCl$ by fixing tense, anteriority and polarity. -- Any of these arguments can be omitted, which results in the -- default (present, simultaneous, and positive, respectively). mkQS : QCl -> QS ; -- 1. who walks mkQS : (Tense) -> (Ant) -> (Pol) -> QCl -> QS ; -- 2. who wouldn't have walked -- Since 'yes-no' question clauses can be built from clauses (see below), -- we give a shortcut -- for building a question sentence directly from a clause, using the defaults -- present, simultaneous, and positive. mkQS : Cl -> QS -- 3. does John walk } ; --3 QCl, question clauses mkQCl : overload { -- 'Yes-no' question clauses are built from 'declarative' clauses. mkQCl : Cl -> QCl ; -- 1. does John walk -- 'Wh' questions are built from interrogative pronouns in subject -- or object position. The former uses a verb phrase; we don't give -- shortcuts for verb-argument sequences as we do for clauses. -- The latter uses the 'slash' category of objectless clauses -- (see below); we give the common special case with a two-place verb. mkQCl : IP -> VP -> QCl ; -- 2. who walks mkQCl : IP -> NP -> V2 -> QCl ; -- 3. whom does John love mkQCl : IP -> Slash -> QCl ; -- 4. whom does John love today -- Adverbial 'wh' questions are built with interrogative adverbials, with the -- special case of prepositional phrases with interrogative pronouns. mkQCl : IAdv -> Cl -> QCl ; -- 5. why does John walk mkQCl : Prep -> IP -> Cl -> QCl ; -- 6. with who does John walk -- An interrogative adverbial can serve as the complement of a copula. mkQCl : IAdv -> NP -> QCl ; -- 7. where is John -- Existentials are a special construction. mkQCl : IP -> QCl -- 8. what is there } ; --3 IP, interrogative pronouns mkIP : overload { -- Interrogative pronouns -- can be formed much like noun phrases, by using interrogative determiners. mkIP : IDet -> N -> IP ; -- 1. which city mkIP : IDet -> (Num) -> (Ord) -> CN -> IP ; -- 2. which five best cities -- An interrogative pronoun can be modified by an adverb. mkIP : IP -> Adv -> IP -- 3. who in Paris } ; -- More interrogative pronouns and determiners can be found in $Structural$. --3 IAdv, interrogative adverbs. -- In addition to the interrogative adverbs defined in the $Structural$ lexicon, they -- can be formed as prepositional phrases from interrogative pronouns. mkIAdv : Prep -> IP -> IAdv ; -- 1. in which city -- More interrogative adverbs are given in $Structural$. --3 RS, relative sentences -- Just like a sentence $S$ is built from a clause $Cl$, -- a relative sentence $RS$ is built from -- a relative clause $RCl$ by fixing the tense, anteriority and polarity. -- Any of these arguments -- can be omitted, which results in the default (present, simultaneous, -- and positive, respectively). mkRS : overload { mkRS : RCl -> RS ; -- 1. that walk mkRS : (Tense) -> (Ant) -> (Pol) -> RCl -> RS -- 2. that wouldn't have walked } ; --3 RCl, relative clauses mkRCl : overload { -- Relative clauses are built from relative pronouns in subject or object position. -- The former uses a verb phrase; we don't give -- shortcuts for verb-argument sequences as we do for clauses. -- The latter uses the 'slash' category of objectless clauses (see below); -- we give the common special case with a two-place verb. mkRCl : RP -> VP -> RCl ; -- 1. that walk mkRCl : RP -> NP -> V2 -> RCl ; -- 2. which John loves mkRCl : RP -> Slash -> RCl ; -- 3. which John loves today -- There is a simple 'such that' construction for forming relative -- clauses from clauses. mkRCl : Cl -> RCl -- 4. such that John loves her } ; --3 RP, relative pronouns -- There is an atomic relative pronoun which_RP : RP ; -- 1. which -- A relative pronoun can be made into a kind of a prepositional phrase. mkRP : Prep -> NP -> RP -> RP ; -- 2. all the houses in which --3 Slash, objectless sentences mkSlash : overload { -- Objectless sentences are used in questions and relative clauses. -- The most common way of constructing them is by using a two-place verb -- with a subject but without an object. mkSlash : NP -> V2 -> Slash ; -- 1. (whom) John loves -- The two-place verb can be separated from the subject by a verb-complement verb. mkSlash : NP -> VV -> V2 -> Slash ; -- 2. (whom) John wants to see -- The missing object can also be the noun phrase in a prepositional phrase. mkSlash : Cl -> Prep -> Slash ; -- 3. (with whom) John walks -- An objectless sentence can be modified by an adverb. mkSlash : Slash -> Adv -> Slash -- 4. (whom) John loves today } ; --2 Lists for coordination -- The rules in this section are very uniform: a list can be built from two or more -- expressions of the same category. --3 ListS, sentence lists mkListS : overload { mkListS : S -> S -> ListS ; -- 1. he walks, I run mkListS : S -> ListS -> ListS -- 2. John walks, I run, you sleep } ; --3 ListAdv, adverb lists mkListAdv : overload { mkListAdv : Adv -> Adv -> ListAdv ; -- 1. here, now mkListAdv : Adv -> ListAdv -> ListAdv -- 2. to me, here, now } ; --3 ListAP, adjectival phrase lists mkListAP : overload { mkListAP : AP -> AP -> ListAP ; -- 1. old, big mkListAP : AP -> ListAP -> ListAP -- 2. old, big, warm } ; --3 ListNP, noun phrase lists mkListNP : overload { mkListNP : NP -> NP -> ListNP ; -- 1. John, I mkListNP : NP -> ListNP -> ListNP -- 2. John, I, that } ; --. -- Definitions QuantSg : Type = Quant ** {isSg : {}} ; QuantPl : Type = Quant ** {isPl : {}} ; SgQuant : Quant -> QuantSg = \q -> q ** {isSg = <>} ; PlQuant : Quant -> QuantPl = \q -> q ** {isPl = <>} ; mkAP = overload { mkAP : A -> AP -- warm = PositA ; mkAP : A -> NP -> AP -- warmer than Spain = ComparA ; mkAP : A2 -> NP -> AP -- divisible by 2 = ComplA2 ; mkAP : A2 -> AP -- divisible by itself = ReflA2 ; mkAP : AP -> S -> AP -- great that she won = \ap,s -> SentAP ap (EmbedS s) ; mkAP : AP -> QS -> AP -- great that she won = \ap,s -> SentAP ap (EmbedQS s) ; mkAP : AP -> VP -> AP -- great that she won = \ap,s -> SentAP ap (EmbedVP s) ; mkAP : AdA -> A -> AP -- very uncertain = \x,y -> AdAP x (PositA y) ; mkAP : AdA -> AP -> AP -- very uncertain = AdAP ; mkAP : Conj -> AP -> AP -> AP = \c,x,y -> ConjAP c (BaseAP x y) ; mkAP : DConj -> AP -> AP -> AP = \c,x,y -> DConjAP c (BaseAP x y) ; mkAP : Conj -> ListAP -> AP = \c,xy -> ConjAP c xy ; mkAP : DConj -> ListAP -> AP = \c,xy -> DConjAP c xy } ; mkAdv = overload { mkAdv : A -> Adv -- quickly = PositAdvAdj ; mkAdv : Prep -> NP -> Adv -- in the house = PrepNP ; mkAdv : CAdv -> A -> NP -> Adv -- more quickly than John = ComparAdvAdj ; mkAdv : CAdv -> A -> S -> Adv -- more quickly than he runs = ComparAdvAdjS ; mkAdv : AdA -> Adv -> Adv -- very quickly = AdAdv ; mkAdv : Subj -> S -> Adv -- when he arrives = SubjS ; mkAdv : Conj -> Adv -> Adv -> Adv = \c,x,y -> ConjAdv c (BaseAdv x y) ; mkAdv : DConj -> Adv -> Adv -> Adv = \c,x,y -> DConjAdv c (BaseAdv x y) ; mkAdv : Conj -> ListAdv -> Adv = \c,xy -> ConjAdv c xy ; mkAdv : DConj -> ListAdv -> Adv = \c,xy -> DConjAdv c xy } ; mkCl = overload { mkCl : NP -> VP -> Cl -- John wants to walk walks = PredVP ; mkCl : NP -> V -> Cl -- John walks = \s,v -> PredVP s (UseV v); mkCl : NP -> V2 -> NP -> Cl -- John uses it = \s,v,o -> PredVP s (ComplV2 v o); mkCl : NP -> V3 -> NP -> NP -> Cl = \s,v,o,i -> PredVP s (ComplV3 v o i); mkCl : NP -> VV -> VP -> Cl = \s,v,vp -> PredVP s (ComplVV v vp) ; mkCl : NP -> VS -> S -> Cl = \s,v,p -> PredVP s (ComplVS v p) ; mkCl : NP -> VQ -> QS -> Cl = \s,v,q -> PredVP s (ComplVQ v q) ; mkCl : NP -> VA -> AP -> Cl = \s,v,q -> PredVP s (ComplVA v q) ; mkCl : NP -> V2A ->NP -> AP -> Cl = \s,v,n,q -> PredVP s (ComplV2A v n q) ; mkCl : VP -> Cl -- it rains = ImpersCl ; mkCl : NP -> RS -> Cl -- it is you who did it = CleftNP ; mkCl : Adv -> S -> Cl -- it is yesterday she arrived = CleftAdv ; mkCl : N -> Cl -- there is a house = \y -> ExistNP (DetCN (DetSg (SgQuant IndefArt) NoOrd) (UseN y)) ; mkCl : CN -> Cl -- there is a house = \y -> ExistNP (DetCN (DetSg (SgQuant IndefArt) NoOrd) y) ; mkCl : NP -> Cl -- there is a house = ExistNP ; mkCl : NP -> AP -> Cl -- John is nice and warm = \x,y -> PredVP x (UseComp (CompAP y)) ; mkCl : NP -> A -> Cl -- John is warm = \x,y -> PredVP x (UseComp (CompAP (PositA y))) ; mkCl : NP -> A -> NP -> Cl -- John is warmer than Mary = \x,y,z -> PredVP x (UseComp (CompAP (ComparA y z))) ; mkCl : NP -> A2 -> NP -> Cl -- John is married to Mary = \x,y,z -> PredVP x (UseComp (CompAP (ComplA2 y z))) ; mkCl : NP -> NP -> Cl -- John is the man = \x,y -> PredVP x (UseComp (CompNP y)) ; mkCl : NP -> CN -> Cl -- John is a man = \x,y -> PredVP x (UseComp (CompNP (DetCN (DetSg (SgQuant IndefArt) NoOrd) y))) ; mkCl : NP -> N -> Cl -- John is a man = \x,y -> PredVP x (UseComp (CompNP (DetCN (DetSg (SgQuant IndefArt) NoOrd) (UseN y)))) ; mkCl : NP -> Adv -> Cl -- John is here = \x,y -> PredVP x (UseComp (CompAdv y)) ; mkCl : V -> Cl -- it rains = \v -> ImpersCl (UseV v) } ; genericCl : VP -> Cl = GenericCl ; mkNP = overload { mkNP : Det -> CN -> NP -- the old man = DetCN ; mkNP : Det -> N -> NP -- the man = \d,n -> DetCN d (UseN n) ; mkNP : Num -> CN -> NP -- forty-five old men = \d,n -> DetCN (DetPl (PlQuant IndefArt) d NoOrd) n ; mkNP : Num -> N -> NP -- forty-five men = \d,n -> DetCN (DetPl (PlQuant IndefArt) d NoOrd) (UseN n) ; mkNP : QuantSg -> CN -> NP = \q,n -> DetCN (DetSg q NoOrd) n ; mkNP : QuantSg -> N -> NP = \q,n -> DetCN (DetSg q NoOrd) (UseN n) ; mkNP : QuantPl -> CN -> NP = \q,n -> DetCN (DetPl q NoNum NoOrd) n ; mkNP : QuantPl -> N -> NP = \q,n -> DetCN (DetPl q NoNum NoOrd) (UseN n) ; mkNP : Pron -> CN -> NP = \p,n -> DetCN (DetSg (SgQuant (PossPron p)) NoOrd) n ; mkNP : Pron -> N -> NP = \p,n -> DetCN (DetSg (SgQuant (PossPron p)) NoOrd) (UseN n) ; mkNP : Numeral -> CN -> NP -- 51 old men = \d,n -> DetCN (DetPl (PlQuant IndefArt) (NumNumeral d) NoOrd) n ; mkNP : Numeral -> N -> NP -- 51 men = \d,n -> DetCN (DetPl (PlQuant IndefArt) (NumNumeral d) NoOrd) (UseN n) ; mkNP : Digits -> CN -> NP -- 51 old men = \d,n -> DetCN (DetPl (PlQuant IndefArt) (NumDigits d) NoOrd) n ; mkNP : Digits -> N -> NP -- 51 men = \d,n -> DetCN (DetPl (PlQuant IndefArt) (NumDigits d) NoOrd) (UseN n) ; mkNP : Int -> CN -> NP -- 51 old men = \d,n -> DetCN (DetPl (PlQuant IndefArt) (NumInt d) NoOrd) n ; mkNP : Int -> N -> NP -- 51 men = \d,n -> DetCN (DetPl (PlQuant IndefArt) (NumInt d) NoOrd) (UseN n) ; mkNP : Digit -> CN -> NP ---- obsol = \d,n -> DetCN (DetPl (PlQuant IndefArt) (NumNumeral (num (pot2as3 (pot1as2 (pot0as1 (pot0 d)))))) NoOrd) n ; mkNP : Digit -> N -> NP ---- obsol = \d,n -> DetCN (DetPl (PlQuant IndefArt) (NumNumeral (num (pot2as3 (pot1as2 (pot0as1 (pot0 d)))))) NoOrd) (UseN n) ; mkNP : PN -> NP -- John = UsePN ; mkNP : Pron -> NP -- he = UsePron ; mkNP : Predet -> NP -> NP -- only the man = PredetNP ; mkNP : NP -> V2 -> NP -- the number squared = PPartNP ; mkNP : NP -> Adv -> NP -- Paris at midnight = AdvNP ; mkNP : Conj -> NP -> NP -> NP = \c,x,y -> ConjNP c (BaseNP x y) ; mkNP : DConj -> NP -> NP -> NP = \c,x,y -> DConjNP c (BaseNP x y) ; mkNP : Conj -> ListNP -> NP = \c,xy -> ConjNP c xy ; mkNP : DConj -> ListNP -> NP = \c,xy -> DConjNP c xy } ; mkDet = overload { mkDet : QuantSg -> Ord -> Det -- this best man = DetSg ; mkDet : QuantSg -> Det -- this man = \q -> DetSg q NoOrd ; mkDet : QuantPl -> Num -> Ord -> Det -- these five best men = DetPl ; mkDet : QuantPl -> Det -- these men = \q -> DetPl q NoNum NoOrd ; mkDet : Quant -> Det -- this man = \q -> DetSg (SgQuant q) NoOrd ; mkDet : Quant -> Num -> Det -- these five man = \q,nu -> DetPl (PlQuant q) nu NoOrd ; mkDet : Num -> Det -- forty-five men = \n -> DetPl (PlQuant IndefArt) n NoOrd ; mkDet : Digits -> Det -- 51 (men) = \n -> DetPl (PlQuant IndefArt) (NumDigits n) NoOrd ; mkDet : Int -> Det -- 51 (men) = \n -> DetPl (PlQuant IndefArt) (NumInt n) NoOrd ; mkDet : Digit -> Det ---- obsol = \d -> DetPl (PlQuant IndefArt) (NumNumeral (num (pot2as3 (pot1as2 (pot0as1 (pot0 d)))))) NoOrd ; mkDet : Numeral -> Det -- = \d -> DetPl (PlQuant IndefArt) (NumNumeral d) NoOrd ; mkDet : Pron -> Det -- my (house) = \p -> DetSg (SgQuant (PossPron p)) NoOrd } ; defSgDet : Det = DetSg (SgQuant DefArt) NoOrd ; -- the (man) defPlDet : Det = DetPl (PlQuant DefArt) NoNum NoOrd ; -- the (man) indefSgDet : Det = DetSg (SgQuant IndefArt) NoOrd ; -- the (man) indefPlDet : Det = DetPl (PlQuant IndefArt) NoNum NoOrd ; -- the (man) ---- obsol def_Det : Det = DetSg (SgQuant DefArt) NoOrd ; -- the (man) indef_Det : Det = DetSg (SgQuant IndefArt) NoOrd ; -- a (man) mass_Det : Det = DetSg (SgQuant MassDet) NoOrd; -- (water) mkQuantSg : Quant -> QuantSg = SgQuant ; mkQuantPl : Quant -> QuantPl = PlQuant ; defQuant = DefArt ; indefQuant = IndefArt ; massQuant : QuantSg = SgQuant MassDet ; the_QuantSg : QuantSg = SgQuant DefArt ; a_QuantSg : QuantSg = mkQuantSg indefQuant ; this_QuantSg : QuantSg = mkQuantSg this_Quant ; that_QuantSg : QuantSg = mkQuantSg that_Quant ; the_QuantPl : QuantPl = mkQuantPl defQuant ; a_QuantPl : QuantPl = mkQuantPl indefQuant ; these_QuantPl : QuantPl = mkQuantPl this_Quant ; those_QuantPl : QuantPl = mkQuantPl that_Quant ; mkNum = overload { mkNum : Numeral -> Num = NumNumeral ; mkNum : Digits -> Num -- 51 = NumDigits ; mkNum : Int -> Num -- 51 = NumInt ; mkNum : Digit -> Num = \d -> NumNumeral (num (pot2as3 (pot1as2 (pot0as1 (pot0 d))))) ; mkNum : AdN -> Num -> Num = AdNum } ; noNum : Num -- [no num] = NoNum ; n1_Numeral = num (pot2as3 (pot1as2 (pot0as1 pot01))) ; n2_Numeral = num (pot2as3 (pot1as2 (pot0as1 (pot0 n2)))) ; n3_Numeral = num (pot2as3 (pot1as2 (pot0as1 (pot0 n3)))) ; n4_Numeral = num (pot2as3 (pot1as2 (pot0as1 (pot0 n4)))) ; n5_Numeral = num (pot2as3 (pot1as2 (pot0as1 (pot0 n5)))) ; n6_Numeral = num (pot2as3 (pot1as2 (pot0as1 (pot0 n6)))) ; n7_Numeral = num (pot2as3 (pot1as2 (pot0as1 (pot0 n7)))) ; n8_Numeral = num (pot2as3 (pot1as2 (pot0as1 (pot0 n8)))) ; n9_Numeral = num (pot2as3 (pot1as2 (pot0as1 (pot0 n9)))) ; n10_Numeral = num (pot2as3 (pot1as2 pot110)) ; n20_Numeral = num (pot2as3 (pot1as2 (pot1 n2))) ; n100_Numeral = num (pot2as3 (pot2 pot01)) ; n1000_Numeral = num (pot3 (pot1as2 (pot0as1 pot01))) ; n1_Digits = IDig D_1 ; n2_Digits = IDig D_2 ; n3_Digits = IDig D_3 ; n4_Digits = IDig D_4 ; n5_Digits = IDig D_5 ; n6_Digits = IDig D_6 ; n7_Digits = IDig D_7 ; n8_Digits = IDig D_8 ; n9_Digits = IDig D_9 ; n10_Digits = IIDig D_1 (IDig D_0) ; n20_Digits = IIDig D_2 (IDig D_0) ; n100_Digits = IIDig D_1 (IIDig D_0 (IDig D_0)) ; n1000_Digits = IIDig D_1 (IIDig D_0 (IIDig D_0 (IDig D_0))) ; mkAdN : CAdv -> AdN = AdnCAdv ; -- more (than five) mkOrd = overload { mkOrd : Numeral -> Ord = OrdNumeral ; mkOrd : Digits -> Ord -- 51st = OrdDigits ; mkOrd : Int -> Ord -- 51st = OrdInt ; mkOrd : Digit -> Ord -- fifth = \d -> OrdNumeral (num (pot2as3 (pot1as2 (pot0as1 (pot0 d))))) ; mkOrd : A -> Ord -- largest = OrdSuperl } ; noOrd : Ord -- [no ord] = NoOrd ; mkCN = overload { mkCN : N -> CN -- house = UseN ; mkCN : N2 -> NP -> CN -- son of the king = ComplN2 ; mkCN : N3 -> NP -> NP -> CN -- flight from Moscow (to Paris) = \f,x -> ComplN2 (ComplN3 f x) ; mkCN : N2 -> CN -- son = UseN2 ; mkCN : N3 -> CN -- flight = UseN3 ; mkCN : AP -> CN -> CN -- nice and big blue house = AdjCN ; mkCN : AP -> N -> CN -- nice and big house = \x,y -> AdjCN x (UseN y) ; mkCN : CN -> AP -> CN -- nice and big blue house = \x,y -> AdjCN y x ; mkCN : N -> AP -> CN -- nice and big house = \x,y -> AdjCN y (UseN x) ; mkCN : A -> CN -> CN -- big blue house = \x,y -> AdjCN (PositA x) y; mkCN : A -> N -> CN -- big house = \x,y -> AdjCN (PositA x) (UseN y); mkCN : CN -> RS -> CN -- house that John owns = RelCN ; mkCN : N -> RS -> CN -- house that John owns = \x,y -> RelCN (UseN x) y ; mkCN : CN -> Adv -> CN -- house on the hill = AdvCN ; mkCN : N -> Adv -> CN -- house on the hill = \x,y -> AdvCN (UseN x) y ; mkCN : CN -> S -> CN -- fact that John smokes = \cn,s -> SentCN cn (EmbedS s) ; mkCN : CN -> QS -> CN -- question if John smokes = \cn,s -> SentCN cn (EmbedQS s) ; mkCN : CN -> VP -> CN -- reason to smoke = \cn,s -> SentCN cn (EmbedVP s) ; mkCN : CN -> NP -> CN -- number x, numbers x and y = ApposCN ; mkCN : N -> NP -> CN -- number x, numbers x and y = \x,y -> ApposCN (UseN x) y } ; mkPhr = overload { mkPhr : PConj -> Utt -> Voc -> Phr -- But go home my friend = PhrUtt ; mkPhr : Utt -> Voc -> Phr = \u,v -> PhrUtt NoPConj u v ; mkPhr : PConj -> Utt -> Phr = \u,v -> PhrUtt u v NoVoc ; mkPhr : Utt -> Phr -- Go home = \u -> PhrUtt NoPConj u NoVoc ; mkPhr : S -> Phr -- I go home = \s -> PhrUtt NoPConj (UttS s) NoVoc ; mkPhr : Cl -> Phr -- I go home = \s -> PhrUtt NoPConj (UttS (UseCl TPres ASimul PPos s)) NoVoc ; mkPhr : QS -> Phr -- I go home = \s -> PhrUtt NoPConj (UttQS s) NoVoc ; mkPhr : Imp -> Phr -- I go home = \s -> PhrUtt NoPConj (UttImpSg PPos s) NoVoc } ; mkPConj : Conj -> PConj = PConjConj ; noPConj : PConj = NoPConj ; mkVoc : NP -> Voc = VocNP ; noVoc : Voc = NoVoc ; positivePol : Pol = PPos ; negativePol : Pol = PNeg ; simultaneousAnt : Ant = ASimul ; anteriorAnt : Ant = AAnter ; --# notpresent presentTense : Tense = TPres ; pastTense : Tense = TPast ; --# notpresent futureTense : Tense = TFut ; --# notpresent conditionalTense : Tense = TCond ; --# notpresent param ImpForm = IFSg | IFPl | IFPol ; oper singularImpForm : ImpForm = IFSg ; pluralImpForm : ImpForm = IFPl ; politeImpForm : ImpForm = IFPol ; mkUttImp : ImpForm -> Pol -> Imp -> Utt = \f,p,i -> case f of { IFSg => UttImpSg p i ; IFPl => UttImpPl p i ; IFPol => UttImpPol p i } ; mkUtt = overload { mkUtt : S -> Utt -- John walked = UttS ; mkUtt : Cl -> Utt -- John walks = \c -> UttS (UseCl TPres ASimul PPos c); mkUtt : QS -> Utt -- is it good = UttQS ; mkUtt : ImpForm -> Pol -> Imp -> Utt -- don't help yourselves = mkUttImp ; mkUtt : ImpForm -> Imp -> Utt -- help yourselves = \f -> mkUttImp f PPos ; mkUtt : Pol -> Imp -> Utt -- (don't) help yourself = UttImpSg ; mkUtt : Imp -> Utt -- help yourself = UttImpSg PPos ; mkUtt : IP -> Utt -- who = UttIP ; mkUtt : IAdv -> Utt -- why = UttIAdv ; mkUtt : NP -> Utt -- this man = UttNP ; mkUtt : Adv -> Utt -- here = UttAdv ; mkUtt : VP -> Utt -- to sleep = UttVP } ; lets_Utt : VP -> Utt = ImpPl1 ; mkQCl = overload { mkQCl : Cl -> QCl -- does John walk = QuestCl ; mkQCl : IP -> VP -> QCl -- who walks = QuestVP ; mkQCl : IP -> Slash -> QCl -- who does John love = QuestSlash ; mkQCl : IP -> NP -> V2 -> QCl -- who does John love = \ip,np,v -> QuestSlash ip (SlashV2 np v) ; mkQCl : IAdv -> Cl -> QCl -- why does John walk = QuestIAdv ; mkQCl : Prep -> IP -> Cl -> QCl -- with whom does John walk = \p,ip -> QuestIAdv (PrepIP p ip) ; mkQCl : IAdv -> NP -> QCl -- where is John = \a -> QuestIComp (CompIAdv a) ; mkQCl : IP -> QCl -- which houses are there = ExistIP } ; mkIP = overload { mkIP : IDet -> Num -> Ord -> CN -> IP -- which five best songs = IDetCN ; mkIP : IDet -> Ord -> CN -> IP -- which five best songs = \i -> IDetCN i NoNum ; mkIP : IDet -> Num -> CN -> IP -- which five best songs = \i,n -> IDetCN i n NoOrd ; mkIP : IDet -> CN -> IP -- which best songs = \i -> IDetCN i NoNum NoOrd ; mkIP : IDet -> N -> IP -- which song = \i,n -> IDetCN i NoNum NoOrd (UseN n) ; mkIP : IP -> Adv -> IP -- who in Europe = AdvIP } ; mkIAdv : Prep -> IP -> IAdv = PrepIP ; mkRCl = overload { mkRCl : Cl -> RCl -- such that John loves her = RelCl ; mkRCl : RP -> VP -> RCl -- who loves John = RelVP ; mkRCl : RP -> Slash -> RCl -- whom John loves = RelSlash ; mkRCl : RP -> NP -> V2 -> RCl -- whom John loves = \rp,np,v2 -> RelSlash rp (SlashV2 np v2) } ; which_RP : RP -- which = IdRP ; mkRP : Prep -> NP -> RP -> RP -- all the roots of which = FunRP ; mkSlash = overload { mkSlash : NP -> V2 -> Slash -- (whom) he sees = SlashV2 ; mkSlash : NP -> VV -> V2 -> Slash -- (whom) he wants to see = SlashVVV2 ; mkSlash : Slash -> Adv -> Slash -- (whom) he sees tomorrow = AdvSlash ; mkSlash : Cl -> Prep -> Slash -- (with whom) he walks = SlashPrep } ; mkImp = overload { mkImp : VP -> Imp -- go = ImpVP ; mkImp : V -> Imp = \v -> ImpVP (UseV v) ; mkImp : V2 -> NP -> Imp = \v,np -> ImpVP (ComplV2 v np) } ; mkS = overload { mkS : Cl -> S = UseCl TPres ASimul PPos ; mkS : Tense -> Cl -> S = \t -> UseCl t ASimul PPos ; mkS : Ant -> Cl -> S = \a -> UseCl TPres a PPos ; mkS : Pol -> Cl -> S = \p -> UseCl TPres ASimul p ; mkS : Tense -> Ant -> Cl -> S = \t,a -> UseCl t a PPos ; mkS : Tense -> Pol -> Cl -> S = \t,p -> UseCl t ASimul p ; mkS : Ant -> Pol -> Cl -> S = \a,p -> UseCl TPres a p ; mkS : Tense -> Ant -> Pol -> Cl -> S = UseCl ; mkS : Conj -> S -> S -> S = \c,x,y -> ConjS c (BaseS x y) ; mkS : DConj -> S -> S -> S = \c,x,y -> DConjS c (BaseS x y) ; mkS : Conj -> ListS -> S = \c,xy -> ConjS c xy ; mkS : DConj -> ListS -> S = \c,xy -> DConjS c xy ; mkS : Adv -> S -> S = AdvS } ; mkQS = overload { mkQS : QCl -> QS = UseQCl TPres ASimul PPos ; mkQS : Tense -> QCl -> QS = \t -> UseQCl t ASimul PPos ; mkQS : Ant -> QCl -> QS = \a -> UseQCl TPres a PPos ; mkQS : Pol -> QCl -> QS = \p -> UseQCl TPres ASimul p ; mkQS : Tense -> Ant -> QCl -> QS = \t,a -> UseQCl t a PPos ; mkQS : Tense -> Pol -> QCl -> QS = \t,p -> UseQCl t ASimul p ; mkQS : Ant -> Pol -> QCl -> QS = \a,p -> UseQCl TPres a p ; mkQS : Tense -> Ant -> Pol -> QCl -> QS = UseQCl ; mkQS : Cl -> QS = \x -> UseQCl TPres ASimul PPos (QuestCl x) } ; mkRS = overload { mkRS : RCl -> RS = UseRCl TPres ASimul PPos ; mkRS : Tense -> RCl -> RS = \t -> UseRCl t ASimul PPos ; mkRS : Ant -> RCl -> RS = \a -> UseRCl TPres a PPos ; mkRS : Pol -> RCl -> RS = \p -> UseRCl TPres ASimul p ; mkRS : Tense -> Ant -> RCl -> RS = \t,a -> UseRCl t a PPos ; mkRS : Tense -> Pol -> RCl -> RS = \t,p -> UseRCl t ASimul p ; mkRS : Ant -> Pol -> RCl -> RS = \a,p -> UseRCl TPres a p ; mkRS : Tense -> Ant -> Pol -> RCl -> RS = UseRCl } ; param Punct = PFullStop | PExclMark | PQuestMark ; oper emptyText : Text = TEmpty ; -- [empty text] fullStopPunct : Punct = PFullStop ; -- . questMarkPunct : Punct = PQuestMark ; -- ? exclMarkPunct : Punct = PExclMark ; -- ! mkText = overload { mkText : Phr -> Punct -> Text -> Text = \phr,punct,text -> case punct of { PFullStop => TFullStop phr text ; PExclMark => TExclMark phr text ; PQuestMark => TQuestMark phr text } ; mkText : Phr -> Punct -> Text = \phr,punct -> case punct of { PFullStop => TFullStop phr TEmpty ; PExclMark => TExclMark phr TEmpty ; PQuestMark => TQuestMark phr TEmpty } ; mkText : Phr -> Text -- John walks. = \x -> TFullStop x TEmpty ; mkText : Utt -> Text = \u -> TFullStop (PhrUtt NoPConj u NoVoc) TEmpty ; mkText : S -> Text = \s -> TFullStop (PhrUtt NoPConj (UttS s) NoVoc) TEmpty; mkText : Cl -> Text = \c -> TFullStop (PhrUtt NoPConj (UttS (UseCl TPres ASimul PPos c)) NoVoc) TEmpty; mkText : QS -> Text = \q -> TQuestMark (PhrUtt NoPConj (UttQS q) NoVoc) TEmpty ; mkText : Imp -> Text = \i -> TExclMark (PhrUtt NoPConj (UttImpSg PPos i) NoVoc) TEmpty; mkText : Pol -> Imp -> Text = \p,i -> TExclMark (PhrUtt NoPConj (UttImpSg p i) NoVoc) TEmpty; mkText : Phr -> Text -> Text -- John walks. ... = TFullStop ; mkText : Text -> Text -> Text = \t,u -> {s = t.s ++ u.s ; lock_Text = <>} ; } ; mkVP = overload { mkVP : V -> VP -- sleep = UseV ; mkVP : V2 -> NP -> VP -- use it = ComplV2 ; mkVP : V3 -> NP -> NP -> VP -- send a message to her = ComplV3 ; mkVP : VV -> VP -> VP -- want to run = ComplVV ; mkVP : VS -> S -> VP -- know that she runs = ComplVS ; mkVP : VQ -> QS -> VP -- ask if she runs = ComplVQ ; --- mkVP : VS -> NP -> VP = \v -> ComplV2 (UseVS v) ; --- mkVP : VQ -> NP -> VP = \v -> ComplV2 (UseVQ v) ; mkVP : VA -> AP -> VP -- look red = ComplVA ; mkVP : V2A -> NP -> AP -> VP -- paint the house red = ComplV2A ; mkVP : A -> VP -- be warm = \a -> UseComp (CompAP (PositA a)) ; mkVP : A -> NP -> VP -- John is warmer than Mary = \y,z -> (UseComp (CompAP (ComparA y z))) ; mkVP : A2 -> NP -> VP -- John is married to Mary = \y,z -> (UseComp (CompAP (ComplA2 y z))) ; mkVP : AP -> VP -- be warm = \a -> UseComp (CompAP a) ; mkVP : NP -> VP -- be a man = \a -> UseComp (CompNP a) ; mkVP : CN -> VP -- be a man = \y -> (UseComp (CompNP (DetCN (DetSg (SgQuant IndefArt) NoOrd) y))) ; mkVP : N -> VP -- be a man = \y -> (UseComp (CompNP (DetCN (DetSg (SgQuant IndefArt) NoOrd) (UseN y)))) ; mkVP : Adv -> VP -- be here = \a -> UseComp (CompAdv a) ; mkVP : VP -> Adv -> VP -- sleep here = AdvVP ; mkVP : AdV -> VP -> VP -- always sleep = AdVVP } ; reflexiveVP : V2 -> VP = ReflV2 ; passiveVP = overload { passiveVP : V2 -> VP = PassV2 ; passiveVP : V2 -> NP -> VP = \v,np -> (AdvVP (PassV2 v) (PrepNP by8agent_Prep np)) } ; progressiveVP : VP -> VP = ProgrVP ; mkListS = overload { mkListS : S -> S -> ListS = BaseS ; mkListS : S -> ListS -> ListS = ConsS } ; mkListAP = overload { mkListAP : AP -> AP -> ListAP = BaseAP ; mkListAP : AP -> ListAP -> ListAP = ConsAP } ; mkListAdv = overload { mkListAdv : Adv -> Adv -> ListAdv = BaseAdv ; mkListAdv : Adv -> ListAdv -> ListAdv = ConsAdv } ; mkListNP = overload { mkListNP : NP -> NP -> ListNP = BaseNP ; mkListNP : NP -> ListNP -> ListNP = ConsNP } ; ---- what is this? AR 18/12/2007 mkInt : Str -> {s : Str ; size : Predef.Ints 1 ; last : Predef.Ints 9 ; lock_Int : {}} = \s -> { s = s ; last = case s of { _ + "0" => 0 ; _ + "1" => 1 ; _ + "2" => 2 ; _ => 3 ---- } ; size = case s of { "1" => 0 ; _ => 1 } ; lock_Int = <> } ; }