diff --git a/lib/src/Make.hs b/lib/src/Make.hs index b1a1a368f..08a80a72d 100644 --- a/lib/src/Make.hs +++ b/lib/src/Make.hs @@ -68,7 +68,7 @@ langsLangAll = langs langsLang = langs `except` langsIncomplete ---- [] -- languagues that have notpresent marked -langsPresent = langsLang `except` ["Nep","Pes"] +langsPresent = langsLang `except` ["Nep","Pes","Tha"] -- languages for which Lang can be compiled but which are incomplete langsIncomplete = ["Amh","Ara","Hin","Lat","Tha","Tur"] @@ -77,7 +77,7 @@ langsIncomplete = ["Amh","Ara","Hin","Lat","Tha","Tur"] langsAPI = langsLang `except` langsIncomplete -- languages for which to compile Symbolic -langsSymbolic = langsLang `except` (langsIncomplete ++ ["Afr","Ina","Nep","Pes","Pnb","Rus"]) +langsSymbolic = langsLang `except` (langsIncomplete ++ ["Afr","Ina","Nep","Pes","Pnb","Rus","Tha"]) -- languages for which to compile minimal Syntax langsMinimal = langs `only` ["Ara","Eng","Bul","Rus"] diff --git a/lib/src/api/ConstructorsTha.gf b/lib/src/api/ConstructorsTha.gf new file mode 100644 index 000000000..2e9679684 --- /dev/null +++ b/lib/src/api/ConstructorsTha.gf @@ -0,0 +1,3 @@ +--# -path=.:alltenses:prelude + +resource ConstructorsTha = Constructors with (Grammar = GrammarTha) ; diff --git a/lib/src/api/SyntaxTha.gf b/lib/src/api/SyntaxTha.gf new file mode 100644 index 000000000..daade19be --- /dev/null +++ b/lib/src/api/SyntaxTha.gf @@ -0,0 +1,5 @@ +--# -path=.:./alltenses:../prelude + +instance SyntaxTha of Syntax = + ConstructorsTha, CatTha, StructuralTha, CombinatorsTha ; + diff --git a/lib/src/api/TryTha.gf b/lib/src/api/TryTha.gf new file mode 100644 index 000000000..4dbf0d30b --- /dev/null +++ b/lib/src/api/TryTha.gf @@ -0,0 +1,12 @@ +--# -path=.:alltenses + +resource TryTha = SyntaxTha, LexiconTha, ParadigmsTha -[mkDet,mkQuant]** + open (P = ParadigmsTha) in { + +-- oper + +-- mkAdv = overload SyntaxTha { +-- mkAdv : Str -> Adv = P.mkAdv ; +-- } ; + +} diff --git a/lib/src/thai/LexiconTha.gf b/lib/src/thai/LexiconTha.gf index c1e047894..5270d94e1 100644 --- a/lib/src/thai/LexiconTha.gf +++ b/lib/src/thai/LexiconTha.gf @@ -1,7 +1,7 @@ --# -path=.:prelude concrete LexiconTha of Lexicon = CatTha ** - open StringsTha, ResTha, Prelude in { + open ParadigmsTha, ResTha, Prelude in { flags optimize=values ; diff --git a/lib/src/thai/ParadigmsTha.gf b/lib/src/thai/ParadigmsTha.gf index a0dc0d4d3..3b3572caf 100644 --- a/lib/src/thai/ParadigmsTha.gf +++ b/lib/src/thai/ParadigmsTha.gf @@ -1,496 +1,29 @@ -----# -path=.:../abstract:../../prelude:../common --- -----1 Thai Lexical Paradigms ----- ----- Aarne Ranta 2003--2005 ----- ----- This is an API for the user of the resource grammar ----- for adding lexical items. It gives functions for forming ----- expressions of open categories: nouns, adjectives, verbs. ----- ----- Closed categories (determiners, pronouns, conjunctions) are ----- accessed through the resource syntax API, $Structural.gf$. ----- ----- The main difference with $MorphoTha.gf$ is that the types ----- referred to are compiled resource grammar types. We have moreover ----- had the design principle of always having existing forms, rather ----- than stems, as string arguments of the paradigms. ----- ----- The structure of functions for each word class $C$ is the following: ----- first we give a handful of patterns that aim to cover all ----- regular cases. Then we give a worst-case function $mkC$, which serves as an ----- escape to construct the most irregular words of type $C$. ----- However, this function should only seldom be needed: we have a ----- separate module [``IrregTha`` ../../english/IrregTha.gf], ----- which covers irregular verbss. --- ---resource ParadigmsTha = open --- (Predef=Predef), --- Prelude, --- MorphoTha, --- CatTha --- in { -----2 Parameters ----- ----- To abstract over gender names, we define the following identifiers. --- ---oper --- Gender : Type ; --- --- human : Gender ; --- nonhuman : Gender ; --- masculine : Gender ; --- ----- To abstract over number names, we define the following. --- --- Number : Type ; --- --- singular : Number ; --- plural : Number ; --- ----- To abstract over case names, we define the following. --- --- Case : Type ; --- --- nominative : Case ; --- genitive : Case ; --- ----- Prepositions are used in many-argument functions for rection. ----- The resource category $Prep$ is used. --- --- --- -----2 Nouns --- ----- Nouns are constructed by the function $mkN$, which takes a varying ----- number of arguments. --- --- mkN : overload { --- ----- Worst case: give all four forms. --- --- mkN : (man,men,man's,men's : Str) -> N ; --- ----- The regular function captures the variants for nouns ending with ----- "s","sh","x","z" or "y": "kiss - kisses", "flash - flashes"; ----- "fly - flies" (but "toy - toys"), --- --- mkN : (flash : Str) -> N ; --- ----- In practice the worst case is just: give singular and plural nominative. --- --- mkN : (man,men : Str) -> N ; --- ----- All nouns created by the previous functions are marked as ----- $nonhuman$. If you want a $human$ noun, wrap it with the following ----- function: --- --- mkN : Gender -> N -> N ; --- -----3 Compound nouns ----- ----- A compound noun is an uninflected string attached to an inflected noun, ----- such as "baby boom", "chief executive officer". --- --- mkN : Str -> N -> N --- } ; --- --- -----3 Relational nouns ----- ----- Relational nouns ("daughter of x") need a preposition. --- --- mkN2 : N -> Prep -> N2 ; --- ----- The most common preposition is "of", and the following is a ----- shortcut for regular relational nouns with "of". --- --- regN2 : Str -> N2 ; --- ----- Use the function $mkPrep$ or see the section on prepositions below to ----- form other prepositions. ----- ----- Three-place relational nouns ("the connection from x to y") need two prepositions. --- --- mkN3 : N -> Prep -> Prep -> N3 ; --- --- -----3 Relational common noun phrases ----- ----- In some cases, you may want to make a complex $CN$ into a ----- relational noun (e.g. "the old town hall of"). --- --- cnN2 : CN -> Prep -> N2 ; --- cnN3 : CN -> Prep -> Prep -> N3 ; --- ----- -----3 Proper names and noun phrases ----- ----- Proper names, with a regular genitive, are formed as follows --- --- regPN : Str -> PN ; --- regGenPN : Str -> Gender -> PN ; -- John, John's --- ----- Sometimes you can reuse a common noun as a proper name, e.g. "Bank". --- --- nounPN : N -> PN ; --- ----- To form a noun phrase that can also be plural and have an irregular ----- genitive, you can use the worst-case function. --- --- mkNP : Str -> Str -> Number -> Gender -> NP ; --- -----2 Adjectives --- ----- Non-comparison one-place adjectives need two forms: one for ----- the adjectival and one for the adverbial form ("free - freely") --- --- mkA : (free,freely : Str) -> A ; --- ----- For regular adjectives, the adverbial form is derived. This holds ----- even for cases with the variation "happy - happily". --- --- regA : Str -> A ; --- -----3 Two-place adjectives ----- ----- Two-place adjectives need a preposition for their second argument. --- --- mkA2 : A -> Prep -> A2 ; --- ----- Comparison adjectives may two more forms. --- --- ADeg : Type ; --- --- mkADeg : (good,better,best,well : Str) -> ADeg ; --- ----- The regular pattern recognizes two common variations: ----- "-e" ("rude" - "ruder" - "rudest") and ----- "-y" ("happy - happier - happiest - happily") --- --- regADeg : Str -> ADeg ; -- long, longer, longest --- ----- However, the duplication of the final consonant is nor predicted, ----- but a separate pattern is used: --- --- duplADeg : Str -> ADeg ; -- fat, fatter, fattest --- ----- If comparison is formed by "more", "most", as in general for ----- long adjective, the following pattern is used: --- --- compoundADeg : A -> ADeg ; -- -/more/most ridiculous --- ----- From a given $ADeg$, it is possible to get back to $A$. --- --- adegA : ADeg -> A ; --- --- -----2 Adverbs --- ----- Adverbs are not inflected. Most lexical ones have position ----- after the verb. Some can be preverbal (e.g. "always"). --- --- mkAdv : Str -> Adv ; --- mkAdV : Str -> AdV ; --- ----- Adverbs modifying adjectives and sentences can also be formed. --- --- mkAdA : Str -> AdA ; --- -----2 Prepositions ----- ----- A preposition as used for rection in the lexicon, as well as to ----- build $PP$s in the resource API, just requires a string. --- --- mkPrep : Str -> Prep ; --- noPrep : Prep ; --- ----- (These two functions are synonyms.) --- -----2 Verbs ----- ----- Except for "be", the worst case needs five forms: the infinitive and ----- the third person singular present, the past indicative, and the ----- past and present participles. --- --- mkV : (go, goes, went, gone, going : Str) -> V ; --- ----- The regular verb function recognizes the special cases where the last ----- character is "y" ("cry - cries" but "buy - buys") or "s", "sh", "x", "z" ----- ("fix - fixes", etc). --- --- regV : Str -> V ; --- ----- The following variant duplicates the last letter in the forms like ----- "rip - ripped - ripping". --- --- regDuplV : Str -> V ; --- ----- There is an extensive list of irregular verbs in the module $IrregularTha$. ----- In practice, it is enough to give three forms, ----- e.g. "drink - drank - drunk", with a variant indicating consonant ----- duplication in the present participle. --- --- irregV : (drink, drank, drunk : Str) -> V ; --- irregDuplV : (get, got, gotten : Str) -> V ; --- --- -----3 Verbs with a particle. ----- ----- The particle, such as in "switch on", is given as a string. --- --- partV : V -> Str -> V ; --- -----3 Reflexive verbs ----- ----- By default, verbs are not reflexive; this function makes them that. --- --- reflV : V -> V ; --- -----3 Two-place verbs ----- ----- Two-place verbs need a preposition, except the special case with direct object. ----- (transitive verbs). Notice that a particle comes from the $V$. --- --- mkV2 : V -> Prep -> V2 ; --- --- dirV2 : V -> V2 ; --- -----3 Three-place verbs ----- ----- Three-place (ditransitive) verbs need two prepositions, of which ----- the first one or both can be absent. --- --- mkV3 : V -> Prep -> Prep -> V3 ; -- speak, with, about --- dirV3 : V -> Prep -> V3 ; -- give,_,to --- dirdirV3 : V -> V3 ; -- give,_,_ --- -----3 Other complement patterns ----- ----- Verbs and adjectives can take complements such as sentences, ----- questions, verb phrases, and adjectives. --- --- mkV0 : V -> V0 ; --- mkVS : V -> VS ; --- mkV2S : V -> Prep -> V2S ; --- mkVV : V -> VV ; --- mkV2V : V -> Prep -> Prep -> V2V ; --- mkVA : V -> VA ; --- mkV2A : V -> Prep -> V2A ; --- mkVQ : V -> VQ ; --- mkV2Q : V -> Prep -> V2Q ; --- --- mkAS : A -> AS ; --- mkA2S : A -> Prep -> A2S ; --- mkAV : A -> AV ; --- mkA2V : A -> Prep -> A2V ; --- ----- Notice: categories $V2S, V2V, V2A, V2Q$ are in v 1.0 treated ----- just as synonyms of $V2$, and the second argument is given ----- as an adverb. Likewise $AS, A2S, AV, A2V$ are just $A$. ----- $V0$ is just $V$. --- --- V0, V2S, V2V, V2A, V2Q : Type ; --- AS, A2S, AV, A2V : Type ; --- -----. -----2 Definitions of paradigms ----- ----- The definitions should not bother the user of the API. So they are ----- hidden from the document. --- --- Gender = MorphoTha.Gender ; --- Number = MorphoTha.Number ; --- Case = MorphoTha.Case ; --- human = Masc ; --- nonhuman = Neutr ; --- masculine = Masc ; --- feminine = Fem ; --- singular = Sg ; --- plural = Pl ; --- nominative = Nom ; --- genitive = Gen ; --- --- Preposition : Type = Str ; -- obsolete --- --- regN = \ray -> --- let --- ra = Predef.tk 1 ray ; --- y = Predef.dp 1 ray ; --- r = Predef.tk 2 ray ; --- ay = Predef.dp 2 ray ; --- rays = --- case y of { --- "y" => y2ie ray "s" ; --- "s" => ray + "es" ; --- "z" => ray + "es" ; --- "x" => ray + "es" ; --- _ => case ay of { --- "sh" => ray + "es" ; --- "ch" => ray + "es" ; --- _ => ray + "s" --- } --- } --- in --- mk2N ray rays ; --- --- mk2N = \man,men -> --- let mens = case last men of { --- "s" => men + "'" ; --- _ => men + "'s" --- } --- in --- mk4N man men (man + "'s") mens ; --- --- mk4N = \man,men,man's,men's -> --- mkNoun man man's men men's ** {g = Neutr ; lock_N = <>} ; --- --- genderN g man = {s = man.s ; g = g ; lock_N = <>} ; --- --- compoundN s n = {s = \\x,y => s ++ n.s ! x ! y ; g=n.g ; lock_N = <>} ; --- --- mkN2 = \n,p -> n ** {lock_N2 = <> ; c2 = p.s} ; --- regN2 n = mkN2 (regN n) (mkPrep "of") ; --- mkN3 = \n,p,q -> n ** {lock_N3 = <> ; c2 = p.s ; c3 = q.s} ; --- cnN2 = \n,p -> n ** {lock_N2 = <> ; c2 = p.s} ; --- cnN3 = \n,p,q -> n ** {lock_N3 = <> ; c2 = p.s ; c3 = q.s} ; --- --- regPN n = regGenPN n human ; --- regGenPN n g = nameReg n g ** {lock_PN = <>} ; --- nounPN n = {s = n.s ! singular ; g = n.g ; lock_PN = <>} ; --- mkNP x y n g = {s = table {Gen => x ; _ => y} ; a = agrP3 n ; --- lock_NP = <>} ; --- --- mkA a b = mkAdjective a a a b ** {lock_A = <>} ; --- regA a = regAdjective a ** {lock_A = <>} ; --- --- mkA2 a p = a ** {c2 = p.s ; lock_A2 = <>} ; --- --- ADeg = A ; ---- --- --- mkADeg a b c d = mkAdjective a b c d ** {lock_A = <>} ; --- --- regADeg happy = --- let --- happ = init happy ; --- y = last happy ; --- happie = case y of { --- "y" => happ + "ie" ; --- "e" => happy ; --- _ => happy + "e" --- } ; --- happily = case y of { --- "y" => happ + "ily" ; --- _ => happy + "ly" --- } ; --- in mkADeg happy (happie + "r") (happie + "st") happily ; --- --- duplADeg fat = --- mkADeg fat --- (fat + last fat + "er") (fat + last fat + "est") (fat + "ly") ; --- --- compoundADeg a = --- let ad = (a.s ! AAdj Posit) --- in mkADeg ad ("more" ++ ad) ("most" ++ ad) (a.s ! AAdv) ; --- --- adegA a = a ; --- --- mkAdv x = ss x ** {lock_Adv = <>} ; --- mkAdV x = ss x ** {lock_AdV = <>} ; --- mkAdA x = ss x ** {lock_AdA = <>} ; --- --- mkPrep p = ss p ** {lock_Prep = <>} ; --- noPrep = mkPrep [] ; --- --- mkV a b c d e = mkVerb a b c d e ** {s1 = [] ; lock_V = <>} ; --- --- regV cry = --- let --- cr = init cry ; --- y = last cry ; --- cries = (regN cry).s ! Pl ! Nom ; -- ! --- crie = init cries ; --- cried = case last crie of { --- "e" => crie + "d" ; --- _ => crie + "ed" --- } ; --- crying = case y of { --- "e" => case last cr of { --- "e" => cry + "ing" ; --- _ => cr + "ing" --- } ; --- _ => cry + "ing" --- } --- in mkV cry cries cried cried crying ; --- --- regDuplV fit = --- case last fit of { --- ("a" | "e" | "i" | "o" | "u" | "y") => --- Predef.error (["final duplication makes no sense for"] ++ fit) ; --- t => --- let fitt = fit + t in --- mkV fit (fit + "s") (fitt + "ed") (fitt + "ed") (fitt + "ing") --- } ; --- --- irregV x y z = let reg = (regV x).s in --- mkV x (reg ! VPres) y z (reg ! VPresPart) ** {s1 = [] ; lock_V = <>} ; --- --- irregDuplV fit y z = --- let --- fitting = (regDuplV fit).s ! VPresPart --- in --- mkV fit (fit + "s") y z fitting ; --- --- partV v p = verbPart v p ** {lock_V = <>} ; --- reflV v = {s = v.s ; part = v.part ; lock_V = v.lock_V ; isRefl = True} ; --- --- mkV2 v p = v ** {s = v.s ; s1 = v.s1 ; c2 = p.s ; lock_V2 = <>} ; --- dirV2 v = mkV2 v noPrep ; --- --- mkV3 v p q = v ** {s = v.s ; s1 = v.s1 ; c2 = p.s ; c3 = q.s ; lock_V3 = <>} ; --- dirV3 v p = mkV3 v noPrep p ; --- dirdirV3 v = dirV3 v noPrep ; --- --- mkVS v = v ** {lock_VS = <>} ; --- mkVV v = { --- s = table {VVF vf => v.s ! vf ; _ => variants {}} ; --- isAux = False ; lock_VV = <> --- } ; --- mkVQ v = v ** {lock_VQ = <>} ; --- --- V0 : Type = V ; --- V2S, V2V, V2Q, V2A : Type = V2 ; --- AS, A2S, AV : Type = A ; --- A2V : Type = A2 ; --- --- mkV0 v = v ** {lock_V = <>} ; --- mkV2S v p = mkV2 v p ** {lock_V2 = <>} ; --- mkV2V v p t = mkV2 v p ** {s4 = t ; lock_V2 = <>} ; --- mkVA v = v ** {lock_VA = <>} ; --- mkV2A v p = mkV2 v p ** {lock_V2A = <>} ; --- mkV2Q v p = mkV2 v p ** {lock_V2 = <>} ; --- --- mkAS v = v ** {lock_A = <>} ; --- mkA2S v p = mkA2 v p ** {lock_A = <>} ; --- mkAV v = v ** {lock_A = <>} ; --- mkA2V v p = mkA2 v p ** {lock_A2 = <>} ; --- --- ----- pre-overload API and overload definitions --- --- mk4N : (man,men,man's,men's : Str) -> N ; --- regN : Str -> N ; --- mk2N : (man,men : Str) -> N ; --- genderN : Gender -> N -> N ; --- compoundN : Str -> N -> N ; --- --- mkN = overload { --- mkN : (man,men,man's,men's : Str) -> N = mk4N ; --- mkN : Str -> N = regN ; --- mkN : (man,men : Str) -> N = mk2N ; --- mkN : Gender -> N -> N = genderN ; --- mkN : Str -> N -> N = compoundN --- } ; --- --- ---} ; +resource ParadigmsTha = open CatTha, ResTha, Prelude in { + +flags coding = utf8 ; + +oper + mkN = overload { + mkN : Str -> N + = \s -> lin N {s = s ; c = "กำ ลัง"} ; ---- for small objects, see LP PB p. 20 + mkN : Str -> Str -> N + = \s,c -> lin N {s = s ; c = c} ; + } ; + + mkA : Str -> A = \s -> lin A (mkAdj s) ; + + mkV = overload { + mkV : Str -> Verb + = \s -> {s1 = [] ; s2 = s ; isCompl = False} ; + mkV : Str -> Str -> Verb + = \s,c -> lin V {s1 = s ; s2 = c ; isCompl = True} ; + } ; + + mkV2 = overload { + mkV2 : Str -> V2 + = \s -> lin V2 (dirV2 (regV s)) ; + mkV2 : V -> V2 + = \s -> lin V2 (dirV2 s) ; + } ; + +} diff --git a/lib/src/thai/SymbolTha.gf b/lib/src/thai/SymbolTha.gf new file mode 100644 index 000000000..d1a05ea3b --- /dev/null +++ b/lib/src/thai/SymbolTha.gf @@ -0,0 +1,41 @@ +--# -path=.:../abstract:../common + +concrete SymbolTha of Symbol = CatTha ** open Prelude, ResTha in { + + flags coding = utf8; +{- + lin +-- SymbPN i = {s = \\_ => i.s ; g = Masc} ; + SymbPN i = {s = addGenitiveS i.s ; g = Masc} ; + IntPN i = {s = addGenitiveS i.s ; g = Masc} ; + FloatPN i = {s = addGenitiveS i.s ; g = Masc} ; + NumPN i = {s = \\_ =>i.s ; g = Masc} ; + CNIntNP cn i = { + s = \\c => cn.s ! Sg ! Dir ++ i.s ; + a = agrP3 cn.g Sg + } ; + CNSymbNP det cn xs = { + s = \\c => det.s!Sg!Masc ++ cn.s ! det.n ! Dir ++ xs.s ; + a = agrP3 cn.g det.n + } ; + CNNumNP cn i = { + s = \\c => cn.s ! Sg ! Dir ++ i.s ; + a = agrP3 cn.g Sg + } ; + + SymbS sy = sy ; + SymbNum sy = { s = sy.s ; n = Pl } ; + SymbOrd sy = { s = sy.s ++ "waN" ; n = Pl} ; +-} + +lincat + + Symb, [Symb] = SS ; + +lin + MkSymb s = s ; + + BaseSymb = infixSS "" ; + ConsSymb = infixSS "" ; + +}