mirror of
https://github.com/GrammaticalFramework/gf-core.git
synced 2026-04-09 04:59:31 -06:00
1902 lines
84 KiB
Plaintext
1902 lines
84 KiB
Plaintext
--1 Constructors: the Resource Syntax API --# notminimal
|
|
|
|
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 language.
|
|
|
|
--2 Principles of organization --# notminimal
|
|
|
|
-- 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 --# notminimal
|
|
|
|
--3 Text: texts --# notminimal
|
|
|
|
-- 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 { --# notminimal
|
|
mkText : Phr -> Text ; -- 1. But John walks. --# notminimal
|
|
mkText : Phr -> (Punct) -> (Text) -> Text ; -- 2. John walks? Yes. --# notminimal
|
|
|
|
-- 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. --# notminimal
|
|
mkText : S -> Text ; -- 4. John walked. --# notminimal
|
|
mkText : Cl -> Text ; -- 5. John walks. --# notminimal
|
|
mkText : QS -> Text ; -- 6. Did John walk? --# notminimal
|
|
mkText : Imp -> Text ; -- 7. Walk! --# notminimal
|
|
|
|
-- Finally, two texts can be combined into a text.
|
|
|
|
mkText : Text -> Text -> Text ; -- 8. Where? When? Here. Now! --# notminimal
|
|
|
|
} ; --# notminimal
|
|
|
|
-- A text can also be empty.
|
|
|
|
emptyText : Text ; -- 8. (empty text) --# notminimal
|
|
|
|
|
|
--3 Punct: punctuation marks --# notminimal
|
|
|
|
-- There are three punctuation marks that can separate phrases in a text.
|
|
|
|
fullStopPunct : Punct ; -- . --# notminimal
|
|
questMarkPunct : Punct ; -- ? --# notminimal
|
|
exclMarkPunct : Punct ; -- ! --# notminimal
|
|
|
|
--3 Phr: phrases in a text --# notminimal
|
|
|
|
-- Phrases are built from utterances by adding a phrasal conjunction
|
|
-- and a vocative, both of which are by default empty.
|
|
|
|
mkPhr : overload { --# notminimal
|
|
mkPhr : Utt -> Phr ; -- 1. why --# notminimal
|
|
mkPhr : (PConj) -> Utt -> (Voc) -> Phr ; -- 2. but why John --# notminimal
|
|
|
|
|
|
-- 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 --# notminimal
|
|
mkPhr : Cl -> Phr ; -- 4. John walks --# notminimal
|
|
mkPhr : QS -> Phr ; -- 5. did John walk --# notminimal
|
|
mkPhr : Imp -> Phr -- 6. walk --# notminimal
|
|
} ; --# notminimal
|
|
|
|
--3 PConj, phrasal conjunctions --# notminimal
|
|
|
|
-- Any conjunction can be used as a phrasal conjunction.
|
|
-- More phrasal conjunctions are defined in $Structural$.
|
|
|
|
mkPConj : Conj -> PConj ; -- 1. and --# notminimal
|
|
|
|
--3 Voc, vocatives --# notminimal
|
|
|
|
-- Any noun phrase can be turned into a vocative.
|
|
-- More vocatives are defined in $Structural$.
|
|
|
|
mkVoc : NP -> Voc ; -- 1. John --# notminimal
|
|
|
|
--3 Utt, utterances --# notminimal
|
|
|
|
-- Utterances are formed from sentences, clauses, questions, and positive singular imperatives.
|
|
|
|
mkUtt : overload { --# notminimal
|
|
mkUtt : S -> Utt ; -- 1. John walked --# notminimal
|
|
mkUtt : Cl -> Utt ; -- 2. John walks --# notminimal
|
|
mkUtt : QS -> Utt ; -- 3. did John walk --# notminimal
|
|
mkUtt : QCl -> Utt ; -- 4. does John walk --# notminimal
|
|
mkUtt : Imp -> Utt ; -- 5. love yourself --# notminimal
|
|
|
|
-- Imperatives can also vary in $ImpForm$ (number/politeness) and
|
|
-- polarity.
|
|
|
|
mkUtt : (ImpForm) -> (Pol) -> Imp -> Utt ; -- 5. don't love yourselves --# notminimal
|
|
|
|
-- Utterances can also be formed from interrogative phrases and
|
|
-- interrogative adverbials, noun phrases, adverbs, and verb phrases.
|
|
|
|
mkUtt : IP -> Utt ; -- 6. who --# notminimal
|
|
mkUtt : IAdv -> Utt ; -- 7. why --# notminimal
|
|
mkUtt : NP -> Utt ; -- 8. John --# notminimal
|
|
mkUtt : Adv -> Utt ; -- 9. here --# notminimal
|
|
mkUtt : VP -> Utt ; -- 10. to walk --# notminimal
|
|
mkUtt : CN -> Utt ; -- 11. beer --# notminimal
|
|
mkUtt : AP -> Utt ; -- 12. fine --# notminimal
|
|
mkUtt : Card -> Utt ; -- 13. five --# notminimal
|
|
} ; --# notminimal
|
|
|
|
-- The plural first-person imperative is a special construction.
|
|
|
|
lets_Utt : VP -> Utt ; -- 11. let's walk --# notminimal
|
|
|
|
|
|
--2 Auxiliary parameters for phrases and sentences --# notminimal
|
|
|
|
--3 Pol, polarity --# notminimal
|
|
|
|
-- 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] --# notminimal
|
|
negativePol : Pol ; -- (John doesn't walk) --# notminimal
|
|
|
|
--3 Ant, anteriority --# notminimal
|
|
|
|
-- 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] --# notminimal
|
|
anteriorAnt : Ant ; -- (John has walked) --# notpresent --# notminimal
|
|
|
|
--3 Tense, tense --# notminimal
|
|
|
|
-- 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] --# notminimal
|
|
pastTense : Tense ; -- (John walked) --# notpresent --# notminimal
|
|
futureTense : Tense ; -- (John will walk) --# notpresent --# notminimal
|
|
conditionalTense : Tense ; -- (John would walk) --# notpresent --# notminimal
|
|
|
|
--3 ImpForm, imperative form --# notminimal
|
|
|
|
-- 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] --# notminimal
|
|
pluralImpForm : ImpForm ; -- (help yourselves) --# notminimal
|
|
politeImpForm : ImpForm ; -- (help yourself) (polite singular) --# notminimal
|
|
|
|
|
|
--2 Sentences and clauses --# notminimal
|
|
|
|
--3 S, sentences --# notminimal
|
|
|
|
-- A sentence has a fixed tense, anteriority and polarity.
|
|
|
|
mkS : overload { --# notminimal
|
|
mkS : Cl -> S ; -- 1. John walks --# notminimal
|
|
mkS : (Tense) -> (Ant) -> (Pol) -> Cl -> S ; -- 2. John wouldn't have walked --# notminimal
|
|
|
|
-- 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 --# notminimal
|
|
mkS : Conj -> ListS -> S ; -- 4. John walks, I run and you sleep --# notminimal
|
|
|
|
-- A sentence can be prefixed by an adverb.
|
|
|
|
mkS : Adv -> S -> S -- 5. today, John walks --# notminimal
|
|
} ; --# notminimal
|
|
|
|
--3 Cl, clauses --# notminimal
|
|
|
|
-- 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 { --# notminimal
|
|
mkCl : NP -> V -> Cl ; -- 1. John walks --# notminimal
|
|
mkCl : NP -> V2 -> NP -> Cl ; -- 2. John loves her --# notminimal
|
|
mkCl : NP -> V3 -> NP -> NP -> Cl ; -- 3. John sends it to her --# notminimal
|
|
mkCl : NP -> VV -> VP -> Cl ; -- 4. John wants to walk --# notminimal
|
|
mkCl : NP -> VS -> S -> Cl ; -- 5. John says that it is good --# notminimal
|
|
mkCl : NP -> VQ -> QS -> Cl ; -- 6. John wonders if it is good --# notminimal
|
|
mkCl : NP -> VA -> AP -> Cl ; -- 7. John becomes old --# notminimal
|
|
mkCl : NP -> V2A -> NP -> AP -> Cl ; -- 8. John paints it red --# notminimal
|
|
mkCl : NP -> V2S -> NP -> S -> Cl ; -- 9. John tells her that we are here --# notminimal
|
|
mkCl : NP -> V2Q -> NP -> QS -> Cl ; -- 10. John asks her who is here --# notminimal
|
|
mkCl : NP -> V2V -> NP -> VP -> Cl ; -- 11. John forces us to sleep --# notminimal
|
|
mkCl : NP -> A -> Cl ; -- 12. John is old --# notminimal
|
|
mkCl : NP -> A -> NP -> Cl ; -- 13. John is older than her --# notminimal
|
|
mkCl : NP -> A2 -> NP -> Cl ; -- 14. John is married to her --# notminimal
|
|
mkCl : NP -> AP -> Cl ; -- 15. John is very old --# notminimal
|
|
mkCl : NP -> N -> Cl ; -- 16. John is a man --# notminimal
|
|
mkCl : NP -> CN -> Cl ; -- 17. John is an old man --# notminimal
|
|
mkCl : NP -> NP -> Cl ; -- 18. John is the man --# notminimal
|
|
mkCl : NP -> Adv -> Cl ; -- 19. John is here --# notminimal
|
|
|
|
-- As the general rule, a clause can be built from a subject noun phrase and
|
|
-- a verb phrase.
|
|
|
|
mkCl : NP -> VP -> Cl ; -- 20. John walks here --# notminimal
|
|
|
|
-- Subjectless verb phrases are used for impersonal actions.
|
|
|
|
mkCl : V -> Cl ; -- 21. it rains --# notminimal
|
|
mkCl : VP -> Cl ; -- 22. it is raining --# notminimal
|
|
|
|
-- Existentials are a special form of clauses.
|
|
|
|
mkCl : N -> Cl ; -- 23. there is a house --# notminimal
|
|
mkCl : CN -> Cl ; -- 24. there is an old houses --# notminimal
|
|
mkCl : NP -> Cl ; -- 25. there are five houses --# notminimal
|
|
|
|
-- There are also special forms in which a noun phrase or an adverb is
|
|
-- emphasized.
|
|
|
|
mkCl : NP -> RS -> Cl ; -- 26. it is John that walks --# notminimal
|
|
mkCl : Adv -> S -> Cl -- 27. it is here John walks --# notminimal
|
|
} ; --# notminimal
|
|
|
|
-- Generic clauses are one with an impersonal subject.
|
|
|
|
genericCl : VP -> Cl ; -- 28. one walks --# notminimal
|
|
|
|
|
|
--2 Verb phrases and imperatives --# notminimal
|
|
|
|
--3 VP, verb phrases --# notminimal
|
|
|
|
-- A verb phrase is formed from a verb with appropriate arguments.
|
|
|
|
mkVP : overload { --# notminimal
|
|
mkVP : V -> VP ; -- 1. walk --# notminimal
|
|
mkVP : V2 -> NP -> VP ; -- 2. love her --# notminimal
|
|
mkVP : V3 -> NP -> NP -> VP ; -- 3. send it to her --# notminimal
|
|
mkVP : VV -> VP -> VP ; -- 4. want to walk --# notminimal
|
|
mkVP : VS -> S -> VP ; -- 5. know that she walks --# notminimal
|
|
mkVP : VQ -> QS -> VP ; -- 6. ask if she walks --# notminimal
|
|
mkVP : VA -> AP -> VP ; -- 7. become old --# notminimal
|
|
mkVP : V2A -> NP -> AP -> VP ; -- 8. paint it red --# notminimal
|
|
|
|
-- 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 --# notminimal
|
|
mkVP : AP -> VP ; -- 12. be very warm --# notminimal
|
|
mkVP : A -> NP -> VP ; -- 10. be older than her --# notminimal
|
|
mkVP : A2 -> NP -> VP ; -- 11. be married to her --# notminimal
|
|
mkVP : N -> VP ; -- 13. be a man --# notminimal
|
|
mkVP : CN -> VP ; -- 14. be an old man --# notminimal
|
|
mkVP : NP -> VP ; -- 15. be the man --# notminimal
|
|
mkVP : Adv -> VP ; -- 16. be here --# notminimal
|
|
|
|
-- A verb phrase can be modified with a postverbal or a preverbal adverb.
|
|
|
|
mkVP : VP -> Adv -> VP ; -- 17. sleep here --# notminimal
|
|
mkVP : AdV -> VP -> VP ; -- 18. always sleep --# notminimal
|
|
|
|
-- Objectless verb phrases can be taken to verb phrases in two ways.
|
|
|
|
mkVP : VPSlash -> NP -> VP ; -- 19. paint it black --# notminimal
|
|
mkVP : VPSlash -> VP ; -- 20. paint itself black --# notminimal
|
|
|
|
} ; --# notminimal
|
|
|
|
-- Two-place verbs can be used reflexively.
|
|
|
|
reflexiveVP : V2 -> VP ; -- 19. love itself --# notminimal
|
|
|
|
-- Two-place verbs can also be used in the passive, with or without an agent.
|
|
|
|
passiveVP : overload { --# notminimal
|
|
passiveVP : V2 -> VP ; -- 20. be loved --# notminimal
|
|
passiveVP : V2 -> NP -> VP ; -- 21. be loved by her --# notminimal
|
|
} ; --# notminimal
|
|
|
|
-- A verb phrase can be turned into the progressive form.
|
|
|
|
progressiveVP : VP -> VP ; -- 22. be sleeping --# notminimal
|
|
|
|
--3 Imp, imperatives --# notminimal
|
|
|
|
-- Imperatives are formed from verbs and their arguments; as the general
|
|
-- rule, from verb phrases.
|
|
|
|
mkImp : overload { --# notminimal
|
|
mkImp : V -> Imp ; -- go --# notminimal
|
|
mkImp : V2 -> NP -> Imp ; -- take it --# notminimal
|
|
mkImp : VP -> Imp -- go there now --# notminimal
|
|
} ; --# notminimal
|
|
|
|
|
|
--2 Noun phrases and determiners --# notminimal
|
|
|
|
--3 NP, noun phrases --# notminimal
|
|
|
|
-- 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 { --# notminimal
|
|
mkNP : Quant -> N -> NP ; -- 3. this men --# notminimal
|
|
mkNP : Quant -> (Num) -> CN -> NP ; -- 4. these five old men --# notminimal
|
|
mkNP : Det -> N -> NP ; -- 5. the first man --# notminimal
|
|
mkNP : Det -> CN -> NP ; -- 6. the first old man --# notminimal
|
|
mkNP : Numeral -> N -> NP ; -- 7. twenty men --# notminimal
|
|
mkNP : Numeral -> CN -> NP ; -- 8. twenty old men --# notminimal
|
|
mkNP : Digits -> N -> NP ; -- 9. 45 men --# notminimal
|
|
mkNP : Digits -> CN -> NP ; -- 10. 45 old men --# notminimal
|
|
mkNP : Card -> N -> NP ; -- 11. almost twenty men --# notminimal
|
|
mkNP : Card -> CN -> NP ; -- 12. almost twenty old men --# notminimal
|
|
mkNP : Pron -> N -> NP ; -- 13. my man --# notminimal
|
|
mkNP : Pron -> CN -> NP ; -- 14. my old man --# notminimal
|
|
|
|
-- Proper names and pronouns can be used as noun phrases.
|
|
|
|
mkNP : PN -> NP ; -- 15. John --# notminimal
|
|
mkNP : Pron -> NP ; -- 16. he --# notminimal
|
|
|
|
-- Determiners alone can form noun phrases.
|
|
|
|
mkNP : Quant -> NP ; -- 17. this --# notminimal
|
|
mkNP : Det -> NP ; -- 18. these five --# notminimal
|
|
|
|
-- Determinesless mass noun phrases.
|
|
|
|
mkNP : N -> NP ; -- 19. beer --# notminimal
|
|
mkNP : CN -> NP ; -- 20. beer --# notminimal
|
|
|
|
-- A noun phrase once formed can be prefixed by a predeterminer and
|
|
-- suffixed by a past participle or an adverb.
|
|
|
|
mkNP : Predet -> NP -> NP ; -- 21. only John --# notminimal
|
|
mkNP : NP -> V2 -> NP ; -- 22. John killed --# notminimal
|
|
mkNP : NP -> Adv -> NP ; -- 23. John in Paris --# notminimal
|
|
mkNP : NP -> RS -> NP ; -- 24. John, who lives in Paris --# notminimal
|
|
|
|
-- A conjunction can be formed both from two noun phrases and a longer
|
|
-- list of them.
|
|
|
|
mkNP : Conj -> NP -> NP -> NP ; -- 25. John and I --# notminimal
|
|
mkNP : Conj -> ListNP -> NP ; -- 26. John, I, and that --# notminimal
|
|
|
|
} ; --# notminimal
|
|
|
|
|
|
--3 Det, determiners --# notminimal
|
|
|
|
-- 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 { --# notminimal
|
|
mkDet : Quant -> Det ; -- 1. this --# notminimal
|
|
mkDet : Quant -> (Ord) -> Det ; -- 2. this first --# notminimal
|
|
mkDet : Quant -> Num -> Det ; -- 3. these --# notminimal
|
|
mkDet : Quant -> Num -> (Ord) -> Det ; -- 4. these five best --# notminimal
|
|
|
|
-- 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 --# notminimal
|
|
mkDet : Quant -> Num -> Det ; -- 6. these five --# notminimal
|
|
|
|
-- Numerals, their special cases integers and digits, and possessive pronouns can be
|
|
-- used as determiners.
|
|
|
|
mkDet : Card -> Det ; -- 7. almost twenty --# notminimal
|
|
mkDet : Numeral -> Det ; -- 8. five --# notminimal
|
|
mkDet : Digits -> Det ; -- 9. 51 --# notminimal
|
|
mkDet : Pron -> Det ; -- 10. my (house) --# notminimal
|
|
mkDet : Pron -> Num -> Det -- 11. my (houses) --# notminimal
|
|
} ; --# notminimal
|
|
|
|
|
|
the_Det : Det ; -- the (house)
|
|
a_Det : Det ; -- a (house)
|
|
thePl_Det : Det ; -- the (houses)
|
|
aSg_Det : Det ; -- a (house)
|
|
aPl_Det : Det ; -- (houses)
|
|
|
|
--3 Quant, quantifiers --# notminimal
|
|
|
|
-- There are definite and indefinite articles.
|
|
|
|
mkQuant : overload { --# notminimal
|
|
mkQuant : Pron -> Quant ; -- 1. my --# notminimal
|
|
} ; --# notminimal
|
|
|
|
the_Quant : Quant ; -- the --# notminimal
|
|
a_Quant : Quant ; -- a --# notminimal
|
|
|
|
--3 Num, cardinal numerals --# notminimal
|
|
|
|
-- Numerals can be formed from number words ($Numeral$), their special case digits,
|
|
-- and from symbolic integers.
|
|
|
|
mkNum : overload { --# notminimal
|
|
mkNum : Str -> Num ; -- 0. thirty-five (given by "35") --# notminimal
|
|
mkNum : Numeral -> Num ; -- 1. twenty --# notminimal
|
|
mkNum : Digits -> Num ; -- 2. 51 --# notminimal
|
|
mkNum : Card -> Num ; -- 3. almost ten --# notminimal
|
|
|
|
-- Cardinals are the non-dummy numerals.
|
|
|
|
mkCard : overload {
|
|
mkCard : Str -> Card ; -- 0. thirty-five (given by "35")
|
|
mkCard : Numeral -> Card ; -- 0. thirty-five (given in any way)
|
|
mkCard : Digits -> Card ; -- 51 --# notminimal
|
|
mkCard : AdN -> Card -> Card --# notminimal
|
|
} ;
|
|
|
|
|
|
-- Such a numeral can be modified by an adnumeral.
|
|
|
|
mkNum : AdN -> Card -> Num -- 4. almost ten --# notminimal
|
|
} ; --# notminimal
|
|
|
|
-- Dummy numbers are sometimes to select the grammatical number of a determiner.
|
|
|
|
sgNum : Num ; -- singular --# notminimal
|
|
plNum : Num ; -- plural --# notminimal
|
|
|
|
--3 Ord, ordinal numerals --# notminimal
|
|
|
|
-- Just like cardinals, ordinals can be formed from number words ($Numeral$)
|
|
-- and from symbolic integers.
|
|
|
|
mkOrd : overload { --# notminimal
|
|
mkOrd : Numeral -> Ord ; -- 1. twentieth --# notminimal
|
|
mkOrd : Digits -> Ord ; -- 2. 51st --# notminimal
|
|
|
|
-- Also adjectives in the superlative form can appear on ordinal positions.
|
|
|
|
mkOrd : A -> Ord -- 3. best --# notminimal
|
|
} ; --# notminimal
|
|
|
|
--3 AdN, adnumerals --# notminimal
|
|
|
|
-- Comparison adverbs can be used as adnumerals.
|
|
|
|
mkAdN : CAdv -> AdN ; -- 1. more than --# notminimal
|
|
|
|
--3 Numeral, number words --# notminimal
|
|
|
|
-- Digits and some "round" numbers are here given as shorthands.
|
|
|
|
n1_Numeral : Numeral ; -- 1. one --# notminimal
|
|
n2_Numeral : Numeral ; -- 2. two --# notminimal
|
|
n3_Numeral : Numeral ; -- 3. three --# notminimal
|
|
n4_Numeral : Numeral ; -- 4. four --# notminimal
|
|
n5_Numeral : Numeral ; -- 5. five --# notminimal
|
|
n6_Numeral : Numeral ; -- 6. six --# notminimal
|
|
n7_Numeral : Numeral ; -- 7. seven --# notminimal
|
|
n8_Numeral : Numeral ; -- 8. eight --# notminimal
|
|
n9_Numeral : Numeral ; -- 9. nine --# notminimal
|
|
n10_Numeral : Numeral ; -- 10. ten --# notminimal
|
|
n20_Numeral : Numeral ; -- 11. twenty --# notminimal
|
|
n100_Numeral : Numeral ; -- 12. hundred --# notminimal
|
|
n1000_Numeral : Numeral ; -- 13. thousand --# notminimal
|
|
|
|
mkNumeral : overload { --# notminimal
|
|
mkNumeral : Str -> Numeral -- 0. thirty-five (given by "35") --# notminimal
|
|
} ; --# notminimal
|
|
|
|
-- See $Numeral$ for the full set of constructors, and use the category
|
|
-- $Digits$ for other numbers from one million.
|
|
|
|
mkDigits : overload { --# notminimal
|
|
mkDigits : Dig -> Digits ; -- 1. 8 --# notminimal
|
|
mkDigits : Dig -> Digits -> Digits ; -- 2. 876 --# notminimal
|
|
} ; --# notminimal
|
|
|
|
n1_Digits : Digits ; -- 1. 1 --# notminimal
|
|
n2_Digits : Digits ; -- 2. 2 --# notminimal
|
|
n3_Digits : Digits ; -- 3. 3 --# notminimal
|
|
n4_Digits : Digits ; -- 4. 4 --# notminimal
|
|
n5_Digits : Digits ; -- 5. 5 --# notminimal
|
|
n6_Digits : Digits ; -- 6. 6 --# notminimal
|
|
n7_Digits : Digits ; -- 7. 7 --# notminimal
|
|
n8_Digits : Digits ; -- 8. 8 --# notminimal
|
|
n9_Digits : Digits ; -- 9. 9 --# notminimal
|
|
n10_Digits : Digits ; -- 10. 10 --# notminimal
|
|
n20_Digits : Digits ; -- 11. 20 --# notminimal
|
|
n100_Digits : Digits ; -- 12. 100 --# notminimal
|
|
n1000_Digits : Digits ; -- 13. 1,000 --# notminimal
|
|
|
|
--3 Dig, single digits --# notminimal
|
|
|
|
n0_Dig : Dig ; -- 0. 0 --# notminimal
|
|
n1_Dig : Dig ; -- 1. 1 --# notminimal
|
|
n2_Dig : Dig ; -- 2. 2 --# notminimal
|
|
n3_Dig : Dig ; -- 3. 3 --# notminimal
|
|
n4_Dig : Dig ; -- 4. 4 --# notminimal
|
|
n5_Dig : Dig ; -- 5. 5 --# notminimal
|
|
n6_Dig : Dig ; -- 6. 6 --# notminimal
|
|
n7_Dig : Dig ; -- 7. 7 --# notminimal
|
|
n8_Dig : Dig ; -- 8. 8 --# notminimal
|
|
n9_Dig : Dig ; -- 9. 9 --# notminimal
|
|
|
|
|
|
--2 Nouns --# notminimal
|
|
|
|
--3 CN, common noun phrases --# notminimal
|
|
|
|
mkCN : overload { --# notminimal
|
|
|
|
-- The most frequent way of forming common noun phrases is from atomic nouns $N$.
|
|
|
|
mkCN : N -> CN ; -- 1. house --# notminimal
|
|
|
|
-- Common noun phrases can be formed from relational nouns by providing arguments.
|
|
|
|
mkCN : N2 -> NP -> CN ; -- 2. mother of John --# notminimal
|
|
mkCN : N3 -> NP -> NP -> CN ; -- 3. distance from this city to Paris --# notminimal
|
|
|
|
-- Relational nouns can also be used without their arguments.
|
|
|
|
mkCN : N2 -> CN ; -- 4. son --# notminimal
|
|
mkCN : N3 -> CN ; -- 5. flight --# notminimal
|
|
|
|
-- 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 --# notminimal
|
|
mkCN : A -> CN -> CN ; -- 7. big blue house --# notminimal
|
|
mkCN : AP -> N -> CN ; -- 8. very big house --# notminimal
|
|
mkCN : AP -> CN -> CN ; -- 9. very big blue house --# notminimal
|
|
|
|
-- A common noun phrase can be modified by a relative clause or an adverb.
|
|
|
|
mkCN : N -> RS -> CN ; -- 10. house that John loves --# notminimal
|
|
mkCN : CN -> RS -> CN ; -- 11. big house that John loves --# notminimal
|
|
mkCN : N -> Adv -> CN ; -- 12. house in the city --# notminimal
|
|
mkCN : CN -> Adv -> CN ; -- 13. big house in the city --# notminimal
|
|
|
|
-- 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 --# notminimal
|
|
mkCN : CN -> QS -> CN ; -- 15. question if John walks --# notminimal
|
|
mkCN : CN -> VP -> CN ; -- 16. reason to walk --# notminimal
|
|
|
|
-- A noun can be used in apposition to a noun phrase, especially a proper name.
|
|
|
|
mkCN : N -> NP -> CN ; -- 17. king John --# notminimal
|
|
mkCN : CN -> NP -> CN -- 18. old king John --# notminimal
|
|
} ; --# notminimal
|
|
|
|
|
|
--2 Adjectives and adverbs --# notminimal
|
|
|
|
--3 AP, adjectival phrases --# notminimal
|
|
|
|
mkAP : overload { --# notminimal
|
|
|
|
-- Adjectival phrases can be formed from atomic adjectives by using the positive form or
|
|
-- the comparative with a complement
|
|
|
|
mkAP : A -> AP ; -- 1. old --# notminimal
|
|
mkAP : A -> NP -> AP ; -- 2. older than John --# notminimal
|
|
|
|
-- Relational adjectives can be used with a complement or a reflexive
|
|
|
|
mkAP : A2 -> NP -> AP ; -- 3. married to her --# notminimal
|
|
mkAP : A2 -> AP ; -- 4. married --# notminimal
|
|
|
|
-- 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 --# notminimal
|
|
mkAP : AP -> QS -> AP ; -- 6. uncertain if John walks --# notminimal
|
|
mkAP : AP -> VP -> AP ; -- 7. ready to go --# notminimal
|
|
|
|
-- An adjectival phrase can be modified by an adadjective.
|
|
|
|
mkAP : AdA -> A -> AP ; -- 8. very old --# notminimal
|
|
mkAP : AdA -> AP -> AP ; -- 9. very very old --# notminimal
|
|
|
|
-- Conjunction can be formed from two or more adjectival phrases.
|
|
|
|
mkAP : Conj -> AP -> AP -> AP ; -- 10. old and big --# notminimal
|
|
mkAP : Conj -> ListAP -> AP ; -- 11. old, big and warm --# notminimal
|
|
|
|
mkAP : Ord -> AP ; -- 12. oldest --# notminimal
|
|
mkAP : CAdv -> AP -> NP -> AP ; -- 13. as old as John --# notminimal
|
|
} ; --# notminimal
|
|
|
|
reflAP : A2 -> AP ; -- married to himself --# notminimal
|
|
comparAP : A -> AP ; -- warmer --# notminimal
|
|
|
|
--3 Adv, adverbial phrases --# notminimal
|
|
|
|
mkAdv : overload { --# notminimal
|
|
|
|
-- Adverbs can be formed from adjectives.
|
|
|
|
mkAdv : A -> Adv ; -- 1. warmly --# notminimal
|
|
|
|
-- Prepositional phrases are treated as adverbs.
|
|
|
|
mkAdv : Prep -> NP -> Adv ; -- 2. with John --# notminimal
|
|
|
|
-- Subordinate sentences are treated as adverbs.
|
|
|
|
mkAdv : Subj -> S -> Adv ; -- 3. when John walks --# notminimal
|
|
|
|
-- An adjectival adverb can be compared to a noun phrase or a sentence.
|
|
|
|
mkAdv : CAdv -> A -> NP -> Adv ; -- 4. more warmly than John --# notminimal
|
|
mkAdv : CAdv -> A -> S -> Adv ; -- 5. more warmly than John walks --# notminimal
|
|
|
|
-- Adverbs can be modified by adadjectives.
|
|
|
|
mkAdv : AdA -> Adv -> Adv ; -- 6. very warmly --# notminimal
|
|
|
|
-- Conjunction can be formed from two or more adverbial phrases.
|
|
|
|
mkAdv : Conj -> Adv -> Adv -> Adv ; -- 7. here and now --# notminimal
|
|
mkAdv : Conj -> ListAdv -> Adv ; -- 8. with John, here and now --# notminimal
|
|
} ; --# notminimal
|
|
|
|
|
|
--2 Questions and relatives --# notminimal
|
|
|
|
--3 QS, question sentences --# notminimal
|
|
|
|
mkQS : overload { --# notminimal
|
|
|
|
-- 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 --# notminimal
|
|
mkQS : (Tense) -> (Ant) -> (Pol) -> QCl -> QS ; -- 2. who wouldn't have walked --# notminimal
|
|
|
|
-- 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 --# notminimal
|
|
} ; --# notminimal
|
|
|
|
|
|
--3 QCl, question clauses --# notminimal
|
|
|
|
mkQCl : overload { --# notminimal
|
|
|
|
-- 'Yes-no' question clauses are built from 'declarative' clauses.
|
|
|
|
mkQCl : Cl -> QCl ; -- 1. does John walk --# notminimal
|
|
|
|
-- '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 --# notminimal
|
|
mkQCl : IP -> NP -> V2 -> QCl ; -- 3. whom does John love --# notminimal
|
|
mkQCl : IP -> ClSlash -> QCl ; -- 4. whom does John love today --# notminimal
|
|
|
|
-- 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 --# notminimal
|
|
mkQCl : Prep -> IP -> Cl -> QCl ; -- 6. with who does John walk --# notminimal
|
|
|
|
-- An interrogative adverbial can serve as the complement of a copula.
|
|
|
|
mkQCl : IAdv -> NP -> QCl ; -- 7. where is John --# notminimal
|
|
|
|
-- Existentials are a special construction.
|
|
|
|
mkQCl : IP -> QCl ; -- 8. what is there --# notminimal
|
|
mkQCl : IComp -> NP -> QCl ; -- 9. who is John --# notminimal
|
|
|
|
} ; --# notminimal
|
|
|
|
|
|
--3 IP, interrogative pronouns --# notminimal
|
|
|
|
mkIP : overload { --# notminimal
|
|
|
|
-- Interrogative pronouns
|
|
-- can be formed much like noun phrases, by using interrogative quantifiers.
|
|
|
|
mkIP : IQuant -> N -> IP ; -- 1. which city --# notminimal
|
|
mkIP : IQuant -> (Num) -> CN -> IP ; -- 2. which five big cities --# notminimal
|
|
|
|
-- An interrogative pronoun can be modified by an adverb.
|
|
|
|
mkIP : IP -> Adv -> IP -- 3. who in Paris --# notminimal
|
|
} ; --# notminimal
|
|
|
|
-- More interrogative pronouns and determiners can be found in $Structural$.
|
|
|
|
|
|
|
|
--3 IAdv, interrogative adverbs. --# notminimal
|
|
|
|
-- 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 --# notminimal
|
|
|
|
-- More interrogative adverbs are given in $Structural$.
|
|
|
|
|
|
--3 RS, relative sentences --# notminimal
|
|
|
|
-- 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 { --# notminimal
|
|
mkRS : RCl -> RS ; -- 1. that walk --# notminimal
|
|
mkRS : (Tense) -> (Ant) -> (Pol) -> RCl -> RS ; -- 2. that wouldn't have walked --# notminimal
|
|
mkRS : Conj -> RS -> RS -> RS ; -- 3. who walks and whom I know --# notminimal
|
|
mkRS : Conj -> ListRS -> RS ; -- 4. who walks, whose son runs, and whom I know --# notminimal
|
|
} ; --# notminimal
|
|
|
|
--3 RCl, relative clauses --# notminimal
|
|
|
|
mkRCl : overload { --# notminimal
|
|
|
|
-- 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 --# notminimal
|
|
mkRCl : RP -> NP -> V2 -> RCl ; -- 2. which John loves --# notminimal
|
|
mkRCl : RP -> ClSlash -> RCl ; -- 3. which John loves today --# notminimal
|
|
|
|
-- There is a simple 'such that' construction for forming relative
|
|
-- clauses from clauses.
|
|
|
|
mkRCl : Cl -> RCl -- 4. such that John loves her --# notminimal
|
|
} ; --# notminimal
|
|
|
|
--3 RP, relative pronouns --# notminimal
|
|
|
|
-- There is an atomic relative pronoun
|
|
|
|
which_RP : RP ; -- 1. which --# notminimal
|
|
|
|
-- A relative pronoun can be made into a kind of a prepositional phrase.
|
|
|
|
mkRP : Prep -> NP -> RP -> RP ; -- 2. all the houses in which --# notminimal
|
|
|
|
|
|
--3 ClSlash, objectless sentences --# notminimal
|
|
|
|
mkClSlash : overload { --# notminimal
|
|
|
|
-- 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.
|
|
|
|
mkClSlash : NP -> V2 -> ClSlash ; -- 1. (whom) John loves --# notminimal
|
|
|
|
-- The two-place verb can be separated from the subject by a verb-complement verb.
|
|
|
|
mkClSlash : NP -> VV -> V2 -> ClSlash ; -- 2. (whom) John wants to see --# notminimal
|
|
|
|
-- The missing object can also be the noun phrase in a prepositional phrase.
|
|
|
|
mkClSlash : Cl -> Prep -> ClSlash ; -- 3. (with whom) John walks --# notminimal
|
|
|
|
-- An objectless sentence can be modified by an adverb.
|
|
|
|
mkClSlash : ClSlash -> Adv -> ClSlash -- 4. (whom) John loves today --# notminimal
|
|
} ; --# notminimal
|
|
|
|
|
|
--3 VPSlash, verb phrases missing an object --# notminimal
|
|
|
|
mkVPSlash : overload { --# notminimal
|
|
|
|
-- This is the deep level of many-argument predication, permitting extraction.
|
|
|
|
mkVPSlash : V2 -> VPSlash ; -- 1. (whom) (John) loves --# notminimal
|
|
mkVPSlash : V3 -> NP -> VPSlash ; -- 2. (whom) (John) gives an apple --# notminimal
|
|
mkVPSlash : V2A -> AP -> VPSlash ; -- 3. (whom) (John) paints red --# notminimal
|
|
mkVPSlash : V2Q -> QS -> VPSlash ; -- 4. (whom) (John) asks who sleeps --# notminimal
|
|
mkVPSlash : V2S -> S -> VPSlash ; -- 5. (whom) (John) tells that we sleep --# notminimal
|
|
mkVPSlash : V2V -> VP -> VPSlash ; -- 6. (whom) (John) forces to sleep --# notminimal
|
|
|
|
} ; --# notminimal
|
|
|
|
|
|
--2 Lists for coordination --# notminimal
|
|
|
|
-- 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 --# notminimal
|
|
|
|
mkListS : overload { --# notminimal
|
|
mkListS : S -> S -> ListS ; -- 1. he walks, I run --# notminimal
|
|
mkListS : S -> ListS -> ListS -- 2. John walks, I run, you sleep --# notminimal
|
|
} ; --# notminimal
|
|
|
|
--3 ListAdv, adverb lists --# notminimal
|
|
|
|
mkListAdv : overload { --# notminimal
|
|
mkListAdv : Adv -> Adv -> ListAdv ; -- 1. here, now --# notminimal
|
|
mkListAdv : Adv -> ListAdv -> ListAdv -- 2. to me, here, now --# notminimal
|
|
} ; --# notminimal
|
|
|
|
--3 ListAP, adjectival phrase lists --# notminimal
|
|
|
|
mkListAP : overload { --# notminimal
|
|
mkListAP : AP -> AP -> ListAP ; -- 1. old, big --# notminimal
|
|
mkListAP : AP -> ListAP -> ListAP -- 2. old, big, warm --# notminimal
|
|
} ; --# notminimal
|
|
|
|
|
|
--3 ListNP, noun phrase lists --# notminimal
|
|
|
|
mkListNP : overload { --# notminimal
|
|
mkListNP : NP -> NP -> ListNP ; -- 1. John, I --# notminimal
|
|
mkListNP : NP -> ListNP -> ListNP -- 2. John, I, that --# notminimal
|
|
} ; --# notminimal
|
|
|
|
--3 ListRS, relative clause lists --# notminimal
|
|
|
|
mkListRS : overload { --# notminimal
|
|
mkListRS : RS -> RS -> ListRS ; -- 1. who walks, who runs --# notminimal
|
|
mkListRS : RS -> ListRS -> ListRS -- 2. who walks, who runs, who sleeps --# notminimal
|
|
} ; --# notminimal
|
|
|
|
--. --# notminimal
|
|
-- Definitions
|
|
|
|
mkAP = overload {
|
|
mkAP : A -> AP -- warm
|
|
= PositA ;
|
|
mkAP : A -> NP -> AP -- warmer than Spain
|
|
= ComparA ;
|
|
mkAP : A2 -> NP -> AP -- divisible by 2 --# notminimal
|
|
= ComplA2 ; --# notminimal
|
|
mkAP : A2 -> AP -- divisible --# notminimal
|
|
= UseA2 ; --# notminimal
|
|
mkAP : AP -> S -> AP -- great that she won --# notminimal
|
|
= \ap,s -> SentAP ap (EmbedS s) ; --# notminimal
|
|
mkAP : AP -> QS -> AP -- great that she won --# notminimal
|
|
= \ap,s -> SentAP ap (EmbedQS s) ; --# notminimal
|
|
mkAP : AP -> VP -> AP -- great that she won --# notminimal
|
|
= \ap,s -> SentAP ap (EmbedVP s) ; --# notminimal
|
|
mkAP : AdA -> A -> AP -- very uncertain
|
|
= \x,y -> AdAP x (PositA y) ;
|
|
mkAP : AdA -> AP -> AP -- very uncertain
|
|
= AdAP ;
|
|
mkAP : Conj -> AP -> AP -> AP --# notminimal
|
|
= \c,x,y -> ConjAP c (BaseAP x y) ; --# notminimal
|
|
mkAP : Conj -> ListAP -> AP --# notminimal
|
|
= \c,xy -> ConjAP c xy ; --# notminimal
|
|
mkAP : Ord -> AP --# notminimal
|
|
= AdjOrd ; --# notminimal
|
|
mkAP : CAdv -> AP -> NP -> AP --# notminimal
|
|
= CAdvAP ; --# notminimal
|
|
} ;
|
|
|
|
reflAP = ReflA2 ; --# notminimal
|
|
comparAP = UseComparA ; --# notminimal
|
|
|
|
mkAdv = overload {
|
|
mkAdv : A -> Adv -- quickly
|
|
= PositAdvAdj ;
|
|
mkAdv : Prep -> NP -> Adv -- in the house
|
|
= PrepNP ;
|
|
mkAdv : CAdv -> A -> NP -> Adv -- more quickly than John --# notminimal
|
|
= ComparAdvAdj ; --# notminimal
|
|
mkAdv : CAdv -> A -> S -> Adv -- more quickly than he runs --# notminimal
|
|
= ComparAdvAdjS ; --# notminimal
|
|
mkAdv : AdA -> Adv -> Adv -- very quickly --# notminimal
|
|
= AdAdv ; --# notminimal
|
|
mkAdv : Subj -> S -> Adv -- when he arrives --# notminimal
|
|
= SubjS ; --# notminimal
|
|
mkAdv : Conj -> Adv -> Adv -> Adv --# notminimal
|
|
= \c,x,y -> ConjAdv c (BaseAdv x y) ; --# notminimal
|
|
mkAdv : Conj -> ListAdv -> Adv --# notminimal
|
|
= \c,xy -> ConjAdv c xy ; --# notminimal
|
|
} ;
|
|
|
|
mkCl = overload {
|
|
mkCl : NP -> VP -> Cl -- John wants to walk
|
|
= 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 --# notminimal
|
|
= \s,v,vp -> PredVP s (ComplVV v vp) ; --# notminimal
|
|
mkCl : NP -> VS -> S -> Cl --# notminimal
|
|
= \s,v,p -> PredVP s (ComplVS v p) ; --# notminimal
|
|
mkCl : NP -> VQ -> QS -> Cl --# notminimal
|
|
= \s,v,q -> PredVP s (ComplVQ v q) ; --# notminimal
|
|
mkCl : NP -> VA -> AP -> Cl --# notminimal
|
|
= \s,v,q -> PredVP s (ComplVA v q) ; --# notminimal
|
|
mkCl : NP -> V2A -> NP -> AP -> Cl --# notminimal
|
|
= \s,v,n,q -> PredVP s (ComplV2A v n q) ; --# notminimal
|
|
mkCl : NP -> V2S -> NP -> S -> Cl --n14 --# notminimal
|
|
= \s,v,n,q -> PredVP s (ComplSlash (SlashV2S v q) n) ; --# notminimal
|
|
mkCl : NP -> V2Q -> NP -> QS -> Cl --n14 --# notminimal
|
|
= \s,v,n,q -> PredVP s (ComplSlash (SlashV2Q v q) n) ; --# notminimal
|
|
mkCl : NP -> V2V -> NP -> VP -> Cl --n14 --# notminimal
|
|
= \s,v,n,q -> PredVP s (ComplSlash (SlashV2V v q) n) ; --# notminimal
|
|
|
|
mkCl : VP -> Cl -- it rains --# notminimal
|
|
= ImpersCl ; --# notminimal
|
|
mkCl : NP -> RS -> Cl -- it is you who did it --# notminimal
|
|
= CleftNP ; --# notminimal
|
|
mkCl : Adv -> S -> Cl -- it is yesterday she arrived --# notminimal
|
|
= CleftAdv ; --# notminimal
|
|
mkCl : N -> Cl -- there is a house --# notminimal
|
|
= \y -> ExistNP (DetArtSg IndefArt (UseN y)) ; --# notminimal
|
|
mkCl : CN -> Cl -- there is a house --# notminimal
|
|
= \y -> ExistNP (DetArtSg IndefArt y) ; --# notminimal
|
|
mkCl : NP -> Cl -- there is a house --# notminimal
|
|
= ExistNP ; --# notminimal
|
|
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 --# notminimal
|
|
= \x,y,z -> PredVP x (UseComp (CompAP (ComplA2 y z))) ; --# notminimal
|
|
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 (DetArtSg IndefArt y))) ;
|
|
mkCl : NP -> N -> Cl -- John is a man
|
|
= \x,y -> PredVP x (UseComp (CompNP (DetArtSg IndefArt (UseN y)))) ;
|
|
mkCl : NP -> Adv -> Cl -- John is here
|
|
= \x,y -> PredVP x (UseComp (CompAdv y)) ;
|
|
mkCl : V -> Cl -- it rains --# notminimal
|
|
= \v -> ImpersCl (UseV v) --# notminimal
|
|
} ;
|
|
|
|
genericCl : VP -> Cl = GenericCl ; --# notminimal
|
|
|
|
|
|
mkNP = overload {
|
|
mkNP : Art -> Num -> Ord -> CN -> NP -- the five best men --n14 --# notminimal
|
|
= \d,nu,ord,cn -> DetCN (DetArtOrd d nu ord) (cn) ; --# notminimal
|
|
mkNP : Art -> Ord -> CN -> NP -- the best men --n14 --# notminimal
|
|
= \d,ord,cn -> DetCN (DetArtOrd d sgNum ord) (cn) ; --# notminimal
|
|
mkNP : Art -> Card -> CN -> NP -- the five men --n14 --# notminimal
|
|
= \d,nu,cn -> DetCN (DetArtCard d nu) (cn) ; --# notminimal
|
|
|
|
mkNP : Art -> Num -> Ord -> N -> NP -- the five best men --n14 --# notminimal
|
|
= \d,nu,ord,cn -> DetCN (DetArtOrd d nu ord) (UseN cn) ; --# notminimal
|
|
mkNP : Art -> Ord -> N -> NP -- the best men --n14 --# notminimal
|
|
= \d,ord,cn -> DetCN (DetArtOrd d sgNum ord) (UseN cn) ; --# notminimal
|
|
mkNP : Art -> Card -> N -> NP -- the five men --n14 --# notminimal
|
|
= \d,nu,cn -> DetCN (DetArtCard d nu) (UseN cn) ; --# notminimal
|
|
|
|
mkNP : CN -> NP -- old beer --n14
|
|
= MassNP ;
|
|
mkNP : N -> NP -- beer --n14
|
|
= \n -> MassNP (UseN n) ;
|
|
|
|
mkNP : Det -> CN -> NP -- the old man
|
|
= DetCN ;
|
|
mkNP : Det -> N -> NP -- the man
|
|
= \d,n -> DetCN d (UseN n) ;
|
|
mkNP : Quant -> NP -- this --# notminimal
|
|
= \q -> DetNP (DetQuant q sgNum) ; --# notminimal
|
|
mkNP : Quant -> Num -> NP -- this --# notminimal
|
|
= \q,n -> DetNP (DetQuant q n) ; --# notminimal
|
|
mkNP : Det -> NP -- this --# notminimal
|
|
= DetNP ; --# notminimal
|
|
mkNP : Card -> CN -> NP -- forty-five old men
|
|
= \d,n -> DetCN (DetArtCard IndefArt d) n ;
|
|
mkNP : Card -> N -> NP -- forty-five men
|
|
= \d,n -> DetCN (DetArtCard IndefArt d) (UseN n) ;
|
|
mkNP : Quant -> CN -> NP
|
|
= \q,n -> DetCN (DetQuant q NumSg) n ;
|
|
mkNP : Quant -> N -> NP
|
|
= \q,n -> DetCN (DetQuant q NumSg) (UseN n) ;
|
|
mkNP : Quant -> Num -> CN -> NP
|
|
= \q,nu,n -> DetCN (DetQuant q nu) n ;
|
|
mkNP : Quant -> Num -> N -> NP
|
|
= \q,nu,n -> DetCN (DetQuant q nu) (UseN n) ;
|
|
|
|
mkNP : Pron -> CN -> NP --# notminimal
|
|
= \p,n -> DetCN (DetQuant (PossPron p) NumSg) n ; --# notminimal
|
|
mkNP : Pron -> N -> NP --# notminimal
|
|
= \p,n -> DetCN (DetQuant (PossPron p) NumSg) (UseN n) ; --# notminimal
|
|
|
|
mkNP : Numeral -> CN -> NP -- 51 old men
|
|
= \d,n -> DetCN (DetArtCard IndefArt (NumNumeral d)) n ;
|
|
|
|
mkNP : Numeral -> N -> NP -- 51 men
|
|
= \d,n -> DetCN (DetArtCard IndefArt (NumNumeral d)) (UseN n) ;
|
|
mkNP : Digits -> CN -> NP -- 51 old men --# notminimal
|
|
= \d,n -> DetCN (DetArtCard IndefArt (NumDigits d)) n ; --# notminimal
|
|
|
|
mkNP : Digits -> N -> NP -- 51 men --# notminimal
|
|
= \d,n -> DetCN (DetArtCard IndefArt (NumDigits d)) (UseN n) ; --# notminimal
|
|
|
|
mkNP : Digit -> CN -> NP ---- obsol --# notminimal
|
|
= \d,n -> DetCN (DetArtCard IndefArt (NumNumeral (num (pot2as3 (pot1as2 (pot0as1 (pot0 d))))))) n ; --# notminimal
|
|
mkNP : Digit -> N -> NP ---- obsol --# notminimal
|
|
= \d,n -> DetCN (DetArtCard IndefArt (NumNumeral (num (pot2as3 (pot1as2 (pot0as1 (pot0 d))))))) (UseN n) ; --# notminimal
|
|
|
|
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 --# notminimal
|
|
= PPartNP ; --# notminimal
|
|
mkNP : NP -> Adv -> NP -- Paris at midnight --# notminimal
|
|
= AdvNP ; --# notminimal
|
|
mkNP : NP -> RS -> NP --# notminimal
|
|
= RelNP ; --# notminimal
|
|
mkNP : Conj -> NP -> NP -> NP --# notminimal
|
|
= \c,x,y -> ConjNP c (BaseNP x y) ; --# notminimal
|
|
mkNP : Conj -> ListNP -> NP --# notminimal
|
|
= \c,xy -> ConjNP c xy ; --# notminimal
|
|
-- backward compat
|
|
mkNP : QuantSg -> CN -> NP --# notminimal
|
|
= \q,n -> DetCN (DetQuant q NumSg) n ; --# notminimal
|
|
mkNP : QuantPl -> CN -> NP --# notminimal
|
|
= \q,n -> DetCN (DetQuant q NumPl) n ; --# notminimal
|
|
|
|
} ;
|
|
|
|
mkDet = overload {
|
|
|
|
mkDet : Art -> Card -> Det -- the five men --n14 --# notminimal
|
|
= \d,nu -> (DetArtCard d nu) ; --# notminimal
|
|
|
|
|
|
|
|
mkDet : Quant -> Ord -> Det -- this best man --# notminimal
|
|
= \q,o -> DetQuantOrd q NumSg o ; --# notminimal
|
|
mkDet : Quant -> Det -- this man
|
|
= \q -> DetQuant q NumSg ;
|
|
mkDet : Quant -> Num -> Ord -> Det -- these five best men --# notminimal
|
|
= DetQuantOrd ; --# notminimal
|
|
mkDet : Quant -> Num -> Det -- these five man
|
|
= DetQuant ;
|
|
mkDet : Card -> Det -- forty-five men
|
|
= DetArtCard IndefArt ;
|
|
mkDet : Digits -> Det -- 51 (men) --# notminimal
|
|
= \d -> DetArtCard IndefArt (NumDigits d) ; --# notminimal
|
|
mkDet : Numeral -> Det --
|
|
= \d -> DetArtCard IndefArt (NumNumeral d) ;
|
|
mkDet : Pron -> Det -- my (house) --# notminimal
|
|
= \p -> DetQuant (PossPron p) NumSg ; --# notminimal
|
|
mkDet : Pron -> Num -> Det -- my (houses) --# notminimal
|
|
= \p -> DetQuant (PossPron p) ; --# notminimal
|
|
} ;
|
|
|
|
mkQuant = overload { --# notminimal
|
|
mkQuant : Pron -> Quant = PossPron ; -- 1. my --# notminimal
|
|
} ; --# notminimal
|
|
|
|
|
|
the_Art : Art = DefArt ; -- the
|
|
a_Art : Art = IndefArt ; -- a
|
|
|
|
---- obsol --# notminimal
|
|
|
|
mkQuantSg : Quant -> QuantSg = SgQuant ; --# notminimal
|
|
mkQuantPl : Quant -> QuantPl = PlQuant ; --# notminimal
|
|
|
|
this_QuantSg : QuantSg = mkQuantSg this_Quant ; --# notminimal
|
|
that_QuantSg : QuantSg = mkQuantSg that_Quant ; --# notminimal
|
|
|
|
-- the_QuantPl : QuantPl = mkQuantPl defQuant ;
|
|
-- a_QuantPl : QuantPl = mkQuantPl indefQuant ;
|
|
these_QuantPl : QuantPl = mkQuantPl this_Quant ; --# notminimal
|
|
those_QuantPl : QuantPl = mkQuantPl that_Quant ; --# notminimal
|
|
|
|
sgNum : Num = NumSg ;
|
|
plNum : Num = NumPl ;
|
|
|
|
|
|
mkCard = overload {
|
|
mkCard : Str -> Card
|
|
= str2card ;
|
|
mkCard : Numeral -> Card
|
|
= NumNumeral ;
|
|
mkCard : Digits -> Card -- 51 --# notminimal
|
|
= NumDigits ; --# notminimal
|
|
mkCard : AdN -> Card -> Card --# notminimal
|
|
= AdNum --# notminimal
|
|
} ;
|
|
|
|
mkNum = overload {
|
|
mkNum : Str -> Num
|
|
= \s -> NumCard (str2card s) ;
|
|
mkNum : Numeral -> Num
|
|
= \d -> NumCard (NumNumeral d) ;
|
|
mkNum : Digits -> Num -- 51 --# notminimal
|
|
= \d -> NumCard (NumDigits d) ; --# notminimal
|
|
mkNum : Digit -> Num --# notminimal
|
|
= \d -> NumCard (NumNumeral (num (pot2as3 (pot1as2 (pot0as1 (pot0 d)))))) ; --# notminimal
|
|
|
|
mkNum : Card -> Num = NumCard ;
|
|
mkNum : AdN -> Card -> Num = \a,c -> NumCard (AdNum a c) --# notminimal
|
|
} ;
|
|
|
|
singularNum : Num -- [no num] --# notminimal
|
|
= NumSg ; --# notminimal
|
|
pluralNum : Num -- [no num] --# notminimal
|
|
= NumPl ; --# notminimal
|
|
|
|
mkOrd = overload { --# notminimal
|
|
-- mkOrd : Str -> Ord = str2ord ; -- ambiguous in Try
|
|
mkOrd : Numeral -> Ord = OrdNumeral ; --# notminimal
|
|
mkOrd : Digits -> Ord -- 51st --# notminimal
|
|
= OrdDigits ; --# notminimal
|
|
mkOrd : Digit -> Ord -- fifth --# notminimal
|
|
= \d -> --# notminimal
|
|
OrdNumeral (num (pot2as3 (pot1as2 (pot0as1 (pot0 d))))) ; --# notminimal
|
|
mkOrd : A -> Ord -- largest --# notminimal
|
|
= OrdSuperl --# notminimal
|
|
} ; --# notminimal
|
|
|
|
mkNumeral = overload { --# notminimal
|
|
mkNumeral : Str -> Numeral --# notminimal
|
|
= str2numeral ; --# notminimal
|
|
} ; --# notminimal
|
|
|
|
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 ; --# notminimal
|
|
n2_Digits = IDig D_2 ; --# notminimal
|
|
n3_Digits = IDig D_3 ; --# notminimal
|
|
n4_Digits = IDig D_4 ; --# notminimal
|
|
n5_Digits = IDig D_5 ; --# notminimal
|
|
n6_Digits = IDig D_6 ; --# notminimal
|
|
n7_Digits = IDig D_7 ; --# notminimal
|
|
n8_Digits = IDig D_8 ; --# notminimal
|
|
n9_Digits = IDig D_9 ; --# notminimal
|
|
n10_Digits = IIDig D_1 (IDig D_0) ; --# notminimal
|
|
n20_Digits = IIDig D_2 (IDig D_0) ; --# notminimal
|
|
n100_Digits = IIDig D_1 (IIDig D_0 (IDig D_0)) ; --# notminimal
|
|
n1000_Digits = IIDig D_1 (IIDig D_0 (IIDig D_0 (IDig D_0))) ; --# notminimal
|
|
|
|
|
|
mkAdN : CAdv -> AdN = AdnCAdv ; -- more (than five) --# notminimal
|
|
|
|
mkDigits = overload { --# notminimal
|
|
mkDigits : Str -> Digits = str2digits ; --# notminimal
|
|
mkDigits : Dig -> Digits = IDig ; --# notminimal
|
|
mkDigits : Dig -> Digits -> Digits = IIDig ; --# notminimal
|
|
} ; --# notminimal
|
|
|
|
n0_Dig = D_0 ; --# notminimal
|
|
n1_Dig = D_1 ; --# notminimal
|
|
n2_Dig = D_2 ; --# notminimal
|
|
n3_Dig = D_3 ; --# notminimal
|
|
n4_Dig = D_4 ; --# notminimal
|
|
n5_Dig = D_5 ; --# notminimal
|
|
n6_Dig = D_6 ; --# notminimal
|
|
n7_Dig = D_7 ; --# notminimal
|
|
n8_Dig = D_8 ; --# notminimal
|
|
n9_Dig = D_9 ; --# notminimal
|
|
|
|
|
|
|
|
|
|
mkCN = overload {
|
|
mkCN : N -> CN -- house
|
|
= UseN ;
|
|
mkCN : N2 -> NP -> CN -- son of the king --# notminimal
|
|
= ComplN2 ; --# notminimal
|
|
mkCN : N3 -> NP -> NP -> CN -- flight from Moscow (to Paris) --# notminimal
|
|
= \f,x -> ComplN2 (ComplN3 f x) ; --# notminimal
|
|
mkCN : N2 -> CN -- son --# notminimal
|
|
= UseN2 ; --# notminimal
|
|
mkCN : N3 -> CN -- flight --# notminimal
|
|
= \n -> UseN2 (Use2N3 n) ; --# notminimal
|
|
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 --# notminimal
|
|
= \x,y -> AdjCN y x ; --# notminimal
|
|
mkCN : N -> AP -> CN -- nice and big house --# notminimal
|
|
= \x,y -> AdjCN y (UseN x) ; --# notminimal
|
|
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 --# notminimal
|
|
= RelCN ; --# notminimal
|
|
mkCN : N -> RS -> CN -- house that John owns --# notminimal
|
|
= \x,y -> RelCN (UseN x) y ; --# notminimal
|
|
mkCN : CN -> Adv -> CN -- house on the hill --# notminimal
|
|
= AdvCN ; --# notminimal
|
|
mkCN : N -> Adv -> CN -- house on the hill --# notminimal
|
|
= \x,y -> AdvCN (UseN x) y ; --# notminimal
|
|
mkCN : CN -> S -> CN -- fact that John smokes --# notminimal
|
|
= \cn,s -> SentCN cn (EmbedS s) ; --# notminimal
|
|
mkCN : CN -> QS -> CN -- question if John smokes --# notminimal
|
|
= \cn,s -> SentCN cn (EmbedQS s) ; --# notminimal
|
|
mkCN : CN -> VP -> CN -- reason to smoke --# notminimal
|
|
= \cn,s -> SentCN cn (EmbedVP s) ; --# notminimal
|
|
mkCN : CN -> NP -> CN -- number x, numbers x and y --# notminimal
|
|
= ApposCN ; --# notminimal
|
|
mkCN : N -> NP -> CN -- number x, numbers x and y --# notminimal
|
|
= \x,y -> ApposCN (UseN x) y --# notminimal
|
|
} ;
|
|
|
|
|
|
mkPhr = overload {
|
|
mkPhr : PConj -> Utt -> Voc -> Phr -- But go home my friend --# notminimal
|
|
= PhrUtt ; --# notminimal
|
|
mkPhr : Utt -> Voc -> Phr --# notminimal
|
|
= \u,v -> PhrUtt NoPConj u v ; --# notminimal
|
|
mkPhr : PConj -> Utt -> Phr --# notminimal
|
|
= \u,v -> PhrUtt u v NoVoc ; --# notminimal
|
|
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 (TUseCl 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 ; --# notminimal
|
|
noPConj : PConj = NoPConj ; --# notminimal
|
|
|
|
mkVoc : NP -> Voc = VocNP ; --# notminimal
|
|
noVoc : Voc = NoVoc ; --# notminimal
|
|
|
|
positivePol : Pol = PPos ;
|
|
negativePol : Pol = PNeg ;
|
|
|
|
simultaneousAnt : Ant = ASimul ; --# notminimal
|
|
anteriorAnt : Ant = AAnter ; --# notpresent --# notminimal
|
|
|
|
presentTense : Tense = TPres ; --# notminimal
|
|
pastTense : Tense = TPast ; --# notpresent --# notminimal
|
|
futureTense : Tense = TFut ; --# notpresent --# notminimal
|
|
conditionalTense : Tense = TCond ; --# notpresent --# notminimal
|
|
|
|
param ImpForm = IFSg | IFPl | IFPol ; --# notminimal
|
|
|
|
oper --# notminimal
|
|
singularImpForm : ImpForm = IFSg ; --# notminimal
|
|
pluralImpForm : ImpForm = IFPl ; --# notminimal
|
|
politeImpForm : ImpForm = IFPol ; --# notminimal
|
|
|
|
mkUttImp : ImpForm -> Pol -> Imp -> Utt = \f,p,i -> case f of { --# notminimal
|
|
IFSg => UttImpSg p i ; --# notminimal
|
|
IFPl => UttImpPl p i ; --# notminimal
|
|
IFPol => UttImpPol p i --# notminimal
|
|
} ; --# notminimal
|
|
|
|
mkUtt = overload {
|
|
mkUtt : S -> Utt -- John walked
|
|
= UttS ;
|
|
mkUtt : Cl -> Utt -- John walks
|
|
= \c -> UttS (TUseCl TPres ASimul PPos c);
|
|
mkUtt : QS -> Utt -- is it good
|
|
= UttQS ;
|
|
mkUtt : QCl -> Utt -- does John walk
|
|
= \c -> UttQS (TUseQCl TPres ASimul PPos c);
|
|
mkUtt : ImpForm -> Pol -> Imp -> Utt -- don't help yourselves --# notminimal
|
|
= mkUttImp ; --# notminimal
|
|
mkUtt : ImpForm -> Imp -> Utt -- help yourselves --# notminimal
|
|
= \f -> mkUttImp f PPos ; --# notminimal
|
|
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 --# notminimal
|
|
= UttVP ; --# notminimal
|
|
mkUtt : CN -> Utt = UttCN ; --# notminimal
|
|
mkUtt : AP -> Utt = UttAP ; --# notminimal
|
|
mkUtt : Card -> Utt = UttCard ; --# notminimal
|
|
} ;
|
|
|
|
lets_Utt : VP -> Utt = ImpPl1 ; --# notminimal
|
|
|
|
mkQCl = overload {
|
|
|
|
mkQCl : Cl -> QCl -- does John walk
|
|
= QuestCl ;
|
|
mkQCl : IP -> VP -> QCl -- who walks
|
|
= QuestVP ;
|
|
mkQCl : IP -> ClSlash -> QCl -- who does John love --# notminimal
|
|
= QuestSlash ; --# notminimal
|
|
mkQCl : IP -> NP -> V2 -> QCl -- who does John love --# notminimal
|
|
= \ip,np,v -> QuestSlash ip (SlashVP np (SlashV2a v)) ; --# notminimal
|
|
mkQCl : IAdv -> Cl -> QCl -- why does John walk
|
|
= QuestIAdv ;
|
|
mkQCl : Prep -> IP -> Cl -> QCl -- with whom does John walk --# notminimal
|
|
= \p,ip -> QuestIAdv (PrepIP p ip) ; --# notminimal
|
|
mkQCl : IAdv -> NP -> QCl -- where is John --# notminimal
|
|
= \a -> QuestIComp (CompIAdv a) ; --# notminimal
|
|
mkQCl : IP -> NP -> QCl -- who is John --# notminimal
|
|
= \a -> QuestIComp (CompIP a) ; --# notminimal
|
|
mkQCl : IP -> QCl -- which houses are there --# notminimal
|
|
= ExistIP ; --# notminimal
|
|
mkQCl : IComp -> NP -> QCl -- who is John --# notminimal
|
|
= \a -> QuestIComp a ; --# notminimal
|
|
} ;
|
|
|
|
mkIP = overload {
|
|
mkIP : IDet -> CN -> IP -- which songs --# notminimal
|
|
= IdetCN ; --# notminimal
|
|
mkIP : IDet -> N -> IP -- which song --# notminimal
|
|
= \i,n -> IdetCN i (UseN n) ; --# notminimal
|
|
mkIP : IQuant -> CN -> IP -- which songs
|
|
= \i,n -> IdetCN (IdetQuant i NumSg) n ;
|
|
mkIP : IQuant -> Num -> CN -> IP -- which songs --# notminimal
|
|
= \i,nu,n -> IdetCN (IdetQuant i nu) n ; --# notminimal
|
|
mkIP : IQuant -> N -> IP -- which song
|
|
= \i,n -> IdetCN (IdetQuant i NumSg) (UseN n) ;
|
|
mkIP : IP -> Adv -> IP -- who in Europe --# notminimal
|
|
= AdvIP --# notminimal
|
|
} ;
|
|
|
|
mkIDet = overload {
|
|
mkIDet : IQuant -> Num -> IDet -- which (songs) --# notminimal
|
|
= \i,nu -> IdetQuant i nu ; --# notminimal
|
|
mkIDet : IQuant -> IDet
|
|
= \i -> IdetQuant i NumSg ;
|
|
} ;
|
|
|
|
whichSg_IDet : IDet = IdetQuant which_IQuant NumSg ; --# notminimal
|
|
whichPl_IDet : IDet = IdetQuant which_IQuant NumPl ; --# notminimal
|
|
|
|
what_IP : IP = whatSg_IP ;
|
|
who_IP : IP = whoSg_IP ;
|
|
which_IDet : IDet = whichSg_IDet ; --# notminimal
|
|
|
|
mkIAdv : Prep -> IP -> IAdv = PrepIP ; --# notminimal
|
|
|
|
mkRCl = overload { --# notminimal
|
|
mkRCl : Cl -> RCl -- such that John loves her --# notminimal
|
|
= RelCl ; --# notminimal
|
|
mkRCl : RP -> VP -> RCl -- who loves John --# notminimal
|
|
= RelVP ; --# notminimal
|
|
mkRCl : RP -> ClSlash -> RCl -- whom John loves --# notminimal
|
|
= RelSlash ; --# notminimal
|
|
mkRCl : RP -> NP -> V2 -> RCl -- whom John loves --# notminimal
|
|
= \rp,np,v2 -> RelSlash rp (SlashVP np (SlashV2a v2)) ; --# notminimal
|
|
} ; --# notminimal
|
|
|
|
which_RP : RP -- which --# notminimal
|
|
= IdRP ; --# notminimal
|
|
mkRP : Prep -> NP -> RP -> RP -- all the roots of which --# notminimal
|
|
= FunRP --# notminimal
|
|
; --# notminimal
|
|
|
|
mkClSlash = overload { --# notminimal
|
|
mkClSlash : NP -> V2 -> ClSlash -- (whom) he sees --# notminimal
|
|
= \np,v2 -> SlashVP np (SlashV2a v2) ; --# notminimal
|
|
mkClSlash : NP -> VV -> V2 -> ClSlash -- (whom) he wants to see --# notminimal
|
|
= \np,vv,v2 -> SlashVP np (SlashVV vv (SlashV2a v2)) ; --# notminimal
|
|
mkClSlash : ClSlash -> Adv -> ClSlash -- (whom) he sees tomorrow --# notminimal
|
|
= AdvSlash ; --# notminimal
|
|
mkClSlash : Cl -> Prep -> ClSlash -- (with whom) he walks --# notminimal
|
|
= SlashPrep --# notminimal
|
|
} ; --# notminimal
|
|
|
|
mkImp = overload {
|
|
mkImp : VP -> Imp -- go --# notminimal
|
|
= ImpVP ; --# notminimal
|
|
mkImp : V -> Imp
|
|
= \v -> ImpVP (UseV v) ;
|
|
mkImp : V2 -> NP -> Imp
|
|
= \v,np -> ImpVP (ComplV2 v np)
|
|
} ;
|
|
|
|
mkS = overload {
|
|
mkS : Cl -> S
|
|
= TUseCl TPres ASimul PPos ;
|
|
mkS : Tense -> Cl -> S --# notminimal
|
|
= \t -> TUseCl t ASimul PPos ; --# notminimal
|
|
mkS : Ant -> Cl -> S --# notminimal
|
|
= \a -> TUseCl TPres a PPos ; --# notminimal
|
|
mkS : Pol -> Cl -> S
|
|
= \p -> TUseCl TPres ASimul p ;
|
|
mkS : Tense -> Ant -> Cl -> S --# notminimal
|
|
= \t,a -> TUseCl t a PPos ; --# notminimal
|
|
mkS : Tense -> Pol -> Cl -> S --# notminimal
|
|
= \t,p -> TUseCl t ASimul p ; --# notminimal
|
|
mkS : Ant -> Pol -> Cl -> S --# notminimal
|
|
= \a,p -> TUseCl TPres a p ; --# notminimal
|
|
mkS : Tense -> Ant -> Pol -> Cl -> S --# notminimal
|
|
= \t,a -> TUseCl t a ; --# notminimal
|
|
mkS : Conj -> S -> S -> S --# notminimal
|
|
= \c,x,y -> ConjS c (BaseS x y) ; --# notminimal
|
|
mkS : Conj -> ListS -> S --# notminimal
|
|
= \c,xy -> ConjS c xy ; --# notminimal
|
|
mkS : Adv -> S -> S --# notminimal
|
|
= AdvS --# notminimal
|
|
|
|
} ;
|
|
|
|
mkQS = overload {
|
|
|
|
mkQS : QCl -> QS
|
|
= TUseQCl TPres ASimul PPos ;
|
|
mkQS : Tense -> QCl -> QS --# notminimal
|
|
= \t -> TUseQCl t ASimul PPos ; --# notminimal
|
|
mkQS : Ant -> QCl -> QS --# notminimal
|
|
= \a -> TUseQCl TPres a PPos ; --# notminimal
|
|
mkQS : Pol -> QCl -> QS
|
|
= \p -> TUseQCl TPres ASimul p ;
|
|
mkQS : Tense -> Ant -> QCl -> QS --# notminimal
|
|
= \t,a -> TUseQCl t a PPos ; --# notminimal
|
|
mkQS : Tense -> Pol -> QCl -> QS --# notminimal
|
|
= \t,p -> TUseQCl t ASimul p ; --# notminimal
|
|
mkQS : Ant -> Pol -> QCl -> QS --# notminimal
|
|
= \a,p -> TUseQCl TPres a p ; --# notminimal
|
|
mkQS : Tense -> Ant -> Pol -> QCl -> QS --# notminimal
|
|
= TUseQCl ; --# notminimal
|
|
mkQS : Cl -> QS
|
|
= \x -> TUseQCl TPres ASimul PPos (QuestCl x)
|
|
} ;
|
|
|
|
|
|
mkRS = overload { --# notminimal
|
|
|
|
mkRS : RCl -> RS --# notminimal
|
|
= TUseRCl TPres ASimul PPos ; --# notminimal
|
|
mkRS : Tense -> RCl -> RS --# notminimal
|
|
= \t -> TUseRCl t ASimul PPos ; --# notminimal
|
|
mkRS : Ant -> RCl -> RS --# notminimal
|
|
= \a -> TUseRCl TPres a PPos ; --# notminimal
|
|
mkRS : Pol -> RCl -> RS --# notminimal
|
|
= \p -> TUseRCl TPres ASimul p ; --# notminimal
|
|
mkRS : Tense -> Ant -> RCl -> RS --# notminimal
|
|
= \t,a -> TUseRCl t a PPos ; --# notminimal
|
|
mkRS : Tense -> Pol -> RCl -> RS --# notminimal
|
|
= \t,p -> TUseRCl t ASimul p ; --# notminimal
|
|
mkRS : Ant -> Pol -> RCl -> RS --# notminimal
|
|
= \a,p -> TUseRCl TPres a p ; --# notminimal
|
|
mkRS : Tense -> Ant -> Pol -> RCl -> RS --# notminimal
|
|
= TUseRCl ; --# notminimal
|
|
mkRS : Conj -> RS -> RS -> RS --# notminimal
|
|
= \c,x,y -> ConjRS c (BaseRS x y) ; --# notminimal
|
|
mkRS : Conj -> ListRS -> RS --# notminimal
|
|
= \c,xy -> ConjRS c xy ; --# notminimal
|
|
|
|
} ; --# notminimal
|
|
|
|
param Punct = PFullStop | PExclMark | PQuestMark ;
|
|
|
|
oper
|
|
emptyText : Text = TEmpty ; -- [empty text] --# notminimal
|
|
|
|
fullStopPunct : Punct = PFullStop ; -- .
|
|
questMarkPunct : Punct = PQuestMark ; -- ?
|
|
exclMarkPunct : Punct = PExclMark ; -- !
|
|
|
|
|
|
mkText = overload {
|
|
mkText : Phr -> Punct -> Text -> Text = --# notminimal
|
|
\phr,punct,text -> case punct of { --# notminimal
|
|
PFullStop => TFullStop phr text ; --# notminimal
|
|
PExclMark => TExclMark phr text ; --# notminimal
|
|
PQuestMark => TQuestMark phr text --# notminimal
|
|
} ; --# notminimal
|
|
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. --# notminimal
|
|
= \x -> TFullStop x TEmpty ; --# notminimal
|
|
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 (TUseCl 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 --# notminimal
|
|
= \p,i -> TExclMark (PhrUtt NoPConj (UttImpSg p i) NoVoc) TEmpty; --# notminimal
|
|
mkText : Phr -> Text -> Text -- John walks. ... --# notminimal
|
|
= TFullStop ; --# notminimal
|
|
mkText : Text -> Text -> Text --# notminimal
|
|
= \t,u -> {s = t.s ++ u.s ; lock_Text = <>} ; --# notminimal
|
|
} ;
|
|
|
|
mkVP = overload {
|
|
mkVP : V -> VP -- sleep
|
|
= UseV ;
|
|
mkVP : V2 -> NP -> VP -- use it
|
|
= ComplV2 ;
|
|
mkVP : V3 -> NP -> NP -> VP -- send a message to her --# notminimal
|
|
= ComplV3 ; --# notminimal
|
|
mkVP : VV -> VP -> VP -- want to run --# notminimal
|
|
= ComplVV ; --# notminimal
|
|
mkVP : VS -> S -> VP -- know that she runs --# notminimal
|
|
= ComplVS ; --# notminimal
|
|
mkVP : VQ -> QS -> VP -- ask if she runs --# notminimal
|
|
= ComplVQ ; --# notminimal
|
|
mkVP : VA -> AP -> VP -- look red --# notminimal
|
|
= ComplVA ; --# notminimal
|
|
mkVP : V2A -> NP -> AP -> VP -- paint the house red --# notminimal
|
|
= ComplV2A ; --# notminimal
|
|
|
|
mkVP : V2S -> NP -> S -> VP --n14 --# notminimal
|
|
= \v,n,q -> (ComplSlash (SlashV2S v q) n) ; --# notminimal
|
|
mkVP : V2Q -> NP -> QS -> VP --n14 --# notminimal
|
|
= \v,n,q -> (ComplSlash (SlashV2Q v q) n) ; --# notminimal
|
|
mkVP : V2V -> NP -> VP -> VP --n14 --# notminimal
|
|
= \v,n,q -> (ComplSlash (SlashV2V v q) n) ; --# notminimal
|
|
|
|
mkVP : A -> VP -- be warm --# notminimal
|
|
= \a -> UseComp (CompAP (PositA a)) ; --# notminimal
|
|
mkVP : A -> NP -> VP -- John is warmer than Mary --# notminimal
|
|
= \y,z -> (UseComp (CompAP (ComparA y z))) ; --# notminimal
|
|
mkVP : A2 -> NP -> VP -- John is married to Mary --# notminimal
|
|
= \y,z -> (UseComp (CompAP (ComplA2 y z))) ; --# notminimal
|
|
mkVP : AP -> VP -- be warm --# notminimal
|
|
= \a -> UseComp (CompAP a) ; --# notminimal
|
|
mkVP : NP -> VP -- be a man --# notminimal
|
|
= \a -> UseComp (CompNP a) ; --# notminimal
|
|
mkVP : CN -> VP -- be a man --# notminimal
|
|
= \y -> (UseComp (CompNP (DetArtSg IndefArt y))) ; --# notminimal
|
|
mkVP : N -> VP -- be a man --# notminimal
|
|
= \y -> (UseComp (CompNP (DetArtSg IndefArt (UseN y)))) ; --# notminimal
|
|
mkVP : Adv -> VP -- be here --# notminimal
|
|
= \a -> UseComp (CompAdv a) ; --# notminimal
|
|
mkVP : VP -> Adv -> VP -- sleep here
|
|
= AdvVP ;
|
|
mkVP : AdV -> VP -> VP -- always sleep --# notminimal
|
|
= AdVVP ; --# notminimal
|
|
mkVP : VPSlash -> NP -> VP -- always sleep --# notminimal
|
|
= ComplSlash ; --# notminimal
|
|
mkVP : VPSlash -> VP --# notminimal
|
|
= ReflVP --# notminimal
|
|
} ;
|
|
|
|
reflexiveVP : V2 -> VP = \v -> ReflVP (SlashV2a v) ; --# notminimal
|
|
|
|
mkVPSlash = overload { --# notminimal
|
|
|
|
mkVPSlash : V2 -> VPSlash -- 1. (whom) (John) loves --# notminimal
|
|
= SlashV2a ; --# notminimal
|
|
mkVPSlash : V3 -> NP -> VPSlash -- 2. (whom) (John) gives an apple --# notminimal
|
|
= Slash2V3 ; --# notminimal
|
|
mkVPSlash : V2A -> AP -> VPSlash -- 3. (whom) (John) paints red --# notminimal
|
|
= SlashV2A ; --# notminimal
|
|
mkVPSlash : V2Q -> QS -> VPSlash -- 4. (whom) (John) asks who sleeps --# notminimal
|
|
= SlashV2Q ; --# notminimal
|
|
mkVPSlash : V2S -> S -> VPSlash -- 5. (whom) (John) tells that we sleep --# notminimal
|
|
= SlashV2S ; --# notminimal
|
|
mkVPSlash : V2V -> VP -> VPSlash -- 6. (whom) (John) forces to sleep --# notminimal
|
|
= SlashV2V ; --# notminimal
|
|
} ; --# notminimal
|
|
|
|
|
|
|
|
passiveVP = overload { --# notminimal
|
|
passiveVP : V2 -> VP = PassV2 ; --# notminimal
|
|
passiveVP : V2 -> NP -> VP = \v,np -> --# notminimal
|
|
(AdvVP (PassV2 v) (PrepNP by8agent_Prep np)) --# notminimal
|
|
} ; --# notminimal
|
|
progressiveVP : VP -> VP = ProgrVP ; --# notminimal
|
|
|
|
|
|
mkListS = overload { --# notminimal
|
|
mkListS : S -> S -> ListS = BaseS ; --# notminimal
|
|
mkListS : S -> ListS -> ListS = ConsS --# notminimal
|
|
} ; --# notminimal
|
|
|
|
mkListAP = overload { --# notminimal
|
|
mkListAP : AP -> AP -> ListAP = BaseAP ; --# notminimal
|
|
mkListAP : AP -> ListAP -> ListAP = ConsAP --# notminimal
|
|
} ; --# notminimal
|
|
|
|
mkListAdv = overload { --# notminimal
|
|
mkListAdv : Adv -> Adv -> ListAdv = BaseAdv ; --# notminimal
|
|
mkListAdv : Adv -> ListAdv -> ListAdv = ConsAdv --# notminimal
|
|
} ; --# notminimal
|
|
|
|
mkListNP = overload { --# notminimal
|
|
mkListNP : NP -> NP -> ListNP = BaseNP ; --# notminimal
|
|
mkListNP : NP -> ListNP -> ListNP = ConsNP --# notminimal
|
|
} ; --# notminimal
|
|
|
|
mkListRS = overload { --# notminimal
|
|
mkListRS : RS -> RS -> ListRS = BaseRS ; --# notminimal
|
|
mkListRS : RS -> ListRS -> ListRS = ConsRS --# notminimal
|
|
} ; --# notminimal
|
|
|
|
|
|
------------ for backward compatibility --# notminimal
|
|
|
|
QuantSg : Type = Quant ** {isSg : {}} ; --# notminimal
|
|
QuantPl : Type = Quant ** {isPl : {}} ; --# notminimal
|
|
SgQuant : Quant -> QuantSg = \q -> q ** {isSg = <>} ; --# notminimal
|
|
PlQuant : Quant -> QuantPl = \q -> q ** {isPl = <>} ; --# notminimal
|
|
|
|
-- Pre-1.4 constants defined
|
|
|
|
DetSg : Quant -> Ord -> Det = \q -> DetQuantOrd q NumSg ; --# notminimal
|
|
DetPl : Quant -> Num -> Ord -> Det = DetQuantOrd ; --# notminimal
|
|
|
|
ComplV2 : V2 -> NP -> VP = \v,np -> ComplSlash (SlashV2a v) np ;
|
|
ComplV2A : V2A -> NP -> AP -> VP = \v,np,ap -> ComplSlash (SlashV2A v ap) np ; --# notminimal
|
|
ComplV3 : V3 -> NP -> NP -> VP = \v,o,d -> ComplSlash (Slash3V3 v o) d ;
|
|
|
|
that_NP : NP = DetNP (DetQuant that_Quant sgNum) ; --# notminimal
|
|
this_NP : NP = DetNP (DetQuant this_Quant sgNum) ; --# notminimal
|
|
those_NP : NP = DetNP (DetQuant that_Quant plNum) ; --# notminimal
|
|
these_NP : NP = DetNP (DetQuant this_Quant plNum) ; --# notminimal
|
|
|
|
that_Det : Det = (DetQuant that_Quant sgNum) ;
|
|
this_Det : Det = (DetQuant this_Quant sgNum) ;
|
|
those_Det : Det = (DetQuant that_Quant plNum) ;
|
|
these_Det : Det = (DetQuant this_Quant plNum) ;
|
|
|
|
|
|
{- --# notminimal
|
|
-- The definite and indefinite articles are commonly used determiners.
|
|
|
|
defSgDet : Det ; -- 11. the (house) --# notminimal
|
|
defPlDet : Det ; -- 12. the (houses) --# notminimal
|
|
indefSgDet : Det ; -- 13. a (house) --# notminimal
|
|
indefPlDet : Det ; -- 14. (houses) --# notminimal
|
|
|
|
|
|
--3 QuantSg, singular quantifiers --# notminimal
|
|
|
|
-- From quantifiers that can have both forms, this constructor
|
|
-- builds the singular form.
|
|
|
|
mkQuantSg : Quant -> QuantSg ; -- 1. this --# notminimal
|
|
|
|
-- The mass noun phrase constructor is treated as a singular quantifier.
|
|
|
|
massQuant : QuantSg ; -- 2. (mass terms) --# notminimal
|
|
|
|
-- More singular quantifiers are available in the $Structural$ module.
|
|
-- The following singular cases of quantifiers are often used.
|
|
|
|
the_QuantSg : QuantSg ; -- 3. the --# notminimal
|
|
a_QuantSg : QuantSg ; -- 4. a --# notminimal
|
|
this_QuantSg : QuantSg ; -- 5. this --# notminimal
|
|
that_QuantSg : QuantSg ; -- 6. that --# notminimal
|
|
|
|
|
|
--3 QuantPl, plural quantifiers --# notminimal
|
|
|
|
-- From quantifiers that can have both forms, this constructor
|
|
-- builds the plural form.
|
|
|
|
mkQuantPl : Quant -> QuantPl ; -- 1. these --# notminimal
|
|
|
|
-- More plural quantifiers are available in the $Structural$ module.
|
|
-- The following plural cases of quantifiers are often used.
|
|
|
|
the_QuantPl : QuantPl ; -- 2. the --# notminimal
|
|
a_QuantPl : QuantPl ; -- 3. (indefinite plural) --# notminimal
|
|
these_QuantPl : QuantPl ; -- 4. these --# notminimal
|
|
those_QuantPl : QuantPl ; -- 5. those --# notminimal
|
|
-} --# notminimal
|
|
|
|
-- new things
|
|
|
|
the_Det : Det = theSg_Det ; -- the (house)
|
|
a_Det : Det = aSg_Det ; -- a (house)
|
|
theSg_Det : Det = DetQuant DefArt NumSg ; -- the (houses)
|
|
thePl_Det : Det = DetQuant DefArt NumPl ; -- the (houses)
|
|
aSg_Det : Det = DetQuant IndefArt NumSg ; -- a (house)
|
|
aPl_Det : Det = DetQuant IndefArt NumPl ; -- (houses)
|
|
|
|
|
|
-- export needed, since not in Cat
|
|
|
|
ListAdv : Type = Grammar.ListAdv ; --# notminimal
|
|
ListAP : Type = Grammar.ListAP ; --# notminimal
|
|
ListNP : Type = Grammar.ListNP ; --# notminimal
|
|
ListS : Type = Grammar.ListS ; --# notminimal
|
|
|
|
-- bw to 1.4
|
|
|
|
Art : Type = Quant ;
|
|
the_Art : Art = DefArt ; -- the --# notminimal
|
|
a_Art : Art = IndefArt ; -- a --# notminimal
|
|
|
|
the_Quant : Quant = DefArt ; -- the --# notminimal
|
|
a_Quant : Quant = IndefArt ; -- a --# notminimal
|
|
|
|
DetArtSg : Art -> CN -> NP = \a -> DetCN (DetQuant a sgNum) ;
|
|
DetArtPl : Art -> CN -> NP = \a -> DetCN (DetQuant a plNum) ;
|
|
|
|
DetArtOrd : Quant -> Num -> Ord -> Det = DetQuantOrd ; --# notminimal
|
|
DetArtCard : Art -> Card -> Det = \a,c -> DetQuant a (NumCard c) ;
|
|
|
|
TUseCl : Tense -> Ant -> Pol -> Cl -> S = \t,a -> UseCl (TTAnt t a) ;
|
|
TUseQCl : Tense -> Ant -> Pol -> QCl -> QS = \t,a -> UseQCl (TTAnt t a) ;
|
|
TUseRCl : Tense -> Ant -> Pol -> RCl -> RS = \t,a -> UseRCl (TTAnt t a) ; --# notminimal
|
|
|
|
-- numerals from strings
|
|
|
|
oper --# notminimal
|
|
str2ord : Str -> Ord = \s -> case Predef.lessInt (Predef.length s) 7 of {
|
|
Predef.PTrue => OrdNumeral (str2numeral s) ;
|
|
Predef.PFalse => OrdDigits (str2digits s)
|
|
} ;
|
|
|
|
str2card : Str -> Card = \s -> case Predef.lessInt (Predef.length s) 7 of {
|
|
Predef.PTrue => NumNumeral (str2numeral s) ;
|
|
Predef.PFalse => NumDigits (str2digits s)
|
|
} ;
|
|
|
|
str2numeral : Str -> Numeral = (\s -> case s of {
|
|
m@(? + _) + "000" => num (pot3 (s2s1000 m)) ;
|
|
m@(? + _) + "00" + n@? => num (pot3plus (s2s1000 m) (s2s1000 n)) ; --# notminimal
|
|
m@(? + _) + "0" + n@(? + ?) => num (pot3plus (s2s1000 m) (s2s1000 n)) ; --# notminimal
|
|
m@(? + _) + n@(? + ? + ?) => num (pot3plus (s2s1000 m) (s2s1000 n)) ; --# notminimal
|
|
_ => num (pot2as3 (s2s1000 s))
|
|
})
|
|
where {
|
|
|
|
s2d : Str -> Digit = \s -> case s of {
|
|
"2" => n2 ;
|
|
"3" => n3 ;
|
|
"4" => n4 ;
|
|
"5" => n5 ;
|
|
"6" => n6 ;
|
|
"7" => n7 ;
|
|
"8" => n8 ;
|
|
"9" => n9 ;
|
|
_ => Predef.error ("not a valid digit" ++ s)
|
|
} ;
|
|
|
|
s2s10 : Str -> Sub10 = \s -> case s of {
|
|
"1" => pot01 ;
|
|
#idigit => pot0 (s2d s) ;
|
|
_ => Predef.error ("not a valid digit" ++ s)
|
|
} ;
|
|
|
|
s2s100 : Str -> Sub100 = \s -> case s of {
|
|
"10" => pot110 ;
|
|
"11" => pot111 ;
|
|
"1" + d@#digit => pot1to19 (s2d d) ;
|
|
d@#idigit + "0" => pot1 (s2d d) ;
|
|
d@#idigit + n@? => pot1plus (s2d d) (s2s10 n) ;
|
|
_ => pot0as1 (s2s10 s)
|
|
} ;
|
|
|
|
s2s1000 : Str -> Sub1000 = \s -> case s of {
|
|
d@? + "00" => pot2 (s2s10 d) ;
|
|
d@? + "0" + n@? => pot2plus (s2s10 d) (s2s100 n) ;
|
|
d@? + n@(? + ?) => pot2plus (s2s10 d) (s2s100 n) ;
|
|
_ => pot1as2 (s2s100 s)
|
|
} ;
|
|
} ;
|
|
idigit : pattern Str = #("1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9") ;
|
|
digit : pattern Str = #("0" | #idigit) ;
|
|
|
|
--- it would be nice to have foldr on strings...
|
|
str2digits : Str -> Digits = (\s -> case s of {
|
|
d0@? => IDig (s2d d0) ;
|
|
d1@? + d0@? => IIDig (s2d d1) (IDig (s2d d0)) ;
|
|
d2@? + d1@? + d0@? => IIDig (s2d d2) (IIDig (s2d d1) (IDig (s2d d0))) ;
|
|
d3@? + d2@? + d1@? + d0@? =>
|
|
IIDig (s2d d3) (IIDig (s2d d2) (IIDig (s2d d1) (IDig (s2d d0)))) ;
|
|
d4@? + d3@? + d2@? + d1@? + d0@? =>
|
|
IIDig (s2d d4) (IIDig (s2d d3) (IIDig (s2d d2) (IIDig (s2d d1) (IDig (s2d d0))))) ;
|
|
d5@? + d4@? + d3@? + d2@? + d1@? + d0@? =>
|
|
IIDig (s2d d5) (IIDig (s2d d4) (IIDig (s2d d3) (IIDig (s2d d2)
|
|
(IIDig (s2d d1) (IDig (s2d d0)))))) ;
|
|
d6@? + d5@? + d4@? + d3@? + d2@? + d1@? + d0@? =>
|
|
IIDig (s2d d6) (IIDig (s2d d5) (IIDig (s2d d4) (IIDig (s2d d3)
|
|
(IIDig (s2d d2) (IIDig (s2d d1) (IDig (s2d d0))))))) ;
|
|
d7@? + d6@? + d5@? + d4@? + d3@? + d2@? + d1@? + d0@? =>
|
|
IIDig (s2d d7) (IIDig (s2d d6) (IIDig (s2d d5) (IIDig (s2d d4) (IIDig (s2d d3)
|
|
(IIDig (s2d d2) (IIDig (s2d d1) (IDig (s2d d0)))))))) ;
|
|
_ => Predef.error ("cannot deal with so many digits:" ++ s)
|
|
}) where {
|
|
s2d : Str -> Dig = \s -> case s of {
|
|
"0" => D_0 ;
|
|
"1" => D_1 ;
|
|
"2" => D_2 ;
|
|
"3" => D_3 ;
|
|
"4" => D_4 ;
|
|
"5" => D_5 ;
|
|
"6" => D_6 ;
|
|
"7" => D_7 ;
|
|
"8" => D_8 ;
|
|
"9" => D_9 ;
|
|
_ => Predef.error ("not a valid digit" ++ s)
|
|
} ;
|
|
} ;
|
|
|
|
}
|