mirror of
https://github.com/GrammaticalFramework/gf-rgl.git
synced 2026-06-15 18:10:12 -06:00
259 lines
6.7 KiB
Plaintext
259 lines
6.7 KiB
Plaintext
--# -path=.:../abstract:../../prelude:../common
|
|
|
|
--1 Interlingua Lexical Paradigms
|
|
--
|
|
-- Aarne Ranta 2003--2005
|
|
-- JP Bernardy 2007
|
|
--
|
|
-- 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 $MorphoIna.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 [``IrregIna`` ../../english/IrregIna.gf],
|
|
-- which covers irregular verbss.
|
|
|
|
resource ParadigmsIna = open
|
|
(Predef=Predef),
|
|
Prelude,
|
|
MorphoIna,
|
|
CatIna,
|
|
CommonX
|
|
in {
|
|
--2 Parameters
|
|
--
|
|
-- To abstract over gender names, we define the following identifiers.
|
|
oper
|
|
male : Sex = Male ;
|
|
female : Sex = Female ;
|
|
|
|
oper
|
|
-- To abstract over case names, we define the following.
|
|
|
|
nominative : Case ;
|
|
accusative : Case ;
|
|
genitive : Case ;
|
|
dative : Case ;
|
|
ablative : Case ;
|
|
|
|
|
|
-- Prepositions are used in many-argument functions for rection.
|
|
-- The resource category $Prep$ is used.
|
|
|
|
|
|
|
|
--2 Nouns
|
|
--
|
|
|
|
-- All nouns are regular, so one should use $mkN$ to construct them.
|
|
|
|
--3 Relational nouns
|
|
--
|
|
-- Relational nouns ("daughter of x") need a preposition.
|
|
|
|
-- The most common preposition is "of", and the following is a
|
|
-- shortcut for regular relational nouns with "of".
|
|
|
|
regN2 : Str -> N2 ;
|
|
|
|
--2 Adjectives
|
|
|
|
-- All adjectives are regular, so on should use $regA$ to construct them.
|
|
|
|
--3 Two-place adjectives
|
|
|
|
-- Two-place adjectives need a preposition for their second argument.
|
|
|
|
mkA2 : A -> Prep -> A2 ;
|
|
|
|
|
|
--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 ;
|
|
mkAdN : 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 and an expected case.
|
|
|
|
mkPrep : Str -> Case -> Prep ;
|
|
noPrep : Prep ;
|
|
|
|
--2 Verbs
|
|
--
|
|
-- Regular verbs should be constructed with $regV$. The 3 irregular verbs
|
|
-- esser, haber and vader are available separately.
|
|
|
|
|
|
---- Reflexive verbs.
|
|
---- By default, verbs are not reflexive; this function makes them that.
|
|
--
|
|
reflV : V -> V ;
|
|
reflV v = {s = v.s ; part = v.part ; lock_V = v.lock_V ; isRefl = True} ;
|
|
|
|
|
|
--3 2 and many-place verbs
|
|
|
|
|
|
-- I decided to provide the following combinators for forming verbs with
|
|
-- complex grammar rules:
|
|
|
|
mkV2 = overload {
|
|
mkV2 : V -> Prep -> V2 = prepV2 ;
|
|
mkV2 : V -> V2 = dirV2 ;
|
|
} ;
|
|
|
|
mkV3 : V -> Prep -> Prep -> V3 ;
|
|
|
|
mkV0 : V -> V0 ;
|
|
mkVS : V -> VS ;
|
|
mkV2S : V -> Prep -> V2S ;
|
|
mkVV : V -> VV ;
|
|
mkV2V : V -> Prep -> Prep -> V2V ;
|
|
mkVA : V -> VA ;
|
|
mkV2A : V -> Prep -> 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, 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 : Type ; --- V2S, V2V, 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.
|
|
nominative = Nom ;
|
|
accusative = Acc ;
|
|
genitive = Gen ;
|
|
dative = Dat ;
|
|
ablative = Abl ;
|
|
|
|
mkN s = nounReg s ** {lock_N = <>};
|
|
|
|
compN : N -> Str -> N;
|
|
compN n s = {s = \\x => n.s ! x ++ s; lock_N = <>} ;
|
|
|
|
|
|
prepN2 : Prep -> N -> N2;
|
|
prepN3 : Prep -> N2 -> N3;
|
|
prepN2 = \p,n -> n ** {lock_N2 = <> ; p2 = p.s; c2 = p.c} ;
|
|
prepN3 = \p,n -> n ** {lock_N3 = <> ; p3 = p.s; c3 = p.c} ;
|
|
regN2 n = prepN2 (mkPrep [] genitive) (mkN n) ** {lock_N2 = <>};
|
|
|
|
----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 ;
|
|
--
|
|
---- This is obsolete.
|
|
-- cnN2 = \n,p -> n ** {lock_N2 = <> ; c2 = p.s} ;
|
|
-- cnN3 = \n,p,q -> n ** {lock_N3 = <> ; c2 = p.s ; c3 = q.s} ;
|
|
--
|
|
mkPN : Str -> PN = regGenPN;
|
|
|
|
mkLN = overload {
|
|
mkLN : Str -> LN = \s -> lin LN {s=s; n=Sg; art=False};
|
|
mkLN : Str -> Number -> LN = \s,n -> lin LN {s=s; n=n; art=False};
|
|
} ;
|
|
|
|
mkGN : Str -> Sex -> GN = \s,g -> lin GN {s=s; g=g};
|
|
mkSN = overload {
|
|
mkSN : Str -> SN = \s -> lin SN {s=\\_ => s; pl=s};
|
|
mkSN : Str -> Str -> Str -> SN = \m,f,pl -> lin SN {s=table {Male=>m; Female=>f}; pl=pl};
|
|
} ;
|
|
|
|
regGenPN : Str -> PN ;
|
|
regGenPN s = {s = s; lock_PN = <>} ;
|
|
|
|
mkA : Str -> A ;
|
|
mkA a = regAdjective a ** {lock_A = <>} ;
|
|
|
|
mkA2 a p = a ** {c2 = casePrep p.s p.c ; lock_A2 = <>} ;
|
|
|
|
|
|
|
|
mkAdv x = ss x ** {lock_Adv = <>} ;
|
|
mkAdV x = ss x ** {lock_AdV = <>} ;
|
|
mkAdA x = ss x ** {lock_AdA = <>} ;
|
|
mkAdN x = ss x ** {lock_AdA = <>} ;
|
|
|
|
mkPrep p c = ss p ** {c = c; lock_Prep = <>} ;
|
|
noPrep = mkPrep [] accusative ;
|
|
|
|
-- Verb-formation combinators.
|
|
mkV : Str -> V;
|
|
mkV s = mkVerb s ** {lock_V = <>};
|
|
|
|
prepV2 : V -> Prep -> V2 ;
|
|
prepV2 v p = v ** {c2 = p.c; p2 = p.s ; lock_V2 = <>} ;
|
|
|
|
dirV2 : V -> V2 ;
|
|
dirV2 v = prepV2 v noPrep ;
|
|
|
|
mkV3 v p1 p2 = v ** {c2 = p1.c; p2 = p1.s ; c3 = p2.c; p3 = p2.s ; lock_V3 = <>} ;
|
|
|
|
mkVS v = v ** {lock_VS = <>} ;
|
|
mkVV v = v ** {lock_VV = <>} ;
|
|
mkVQ v = v ** {lock_VQ = <>} ;
|
|
|
|
V0 : Type = V ;
|
|
--- V2S, V2V, V2Q : Type = V2 ;
|
|
AS, A2S, AV : Type = A ;
|
|
A2V : Type = A2 ;
|
|
--
|
|
mkV0 v = v ** {lock_V = <>} ;
|
|
mkV2S v p = prepV2 v p ** {lock_V2S = <>} ;
|
|
mkV2V v p t = prepV2 v p ** {s4 = t ; lock_V2V = <>} ;
|
|
mkVA v = v ** {lock_VA = <>} ;
|
|
mkV2A v p2 p3 = mkV3 v p2 p3 ** {lock_V2A = <>} ;
|
|
mkV2Q p v = prepV2 p v ** {lock_V2Q = <>} ;
|
|
mkAS v = v ** {lock_A = <>} ;
|
|
mkAV v = v ** {lock_A = <>} ;
|
|
mkA2V v p = mkA2 v p ** {lock_A2 = <>} ;
|
|
|
|
|
|
-- pre-overload API and overload definitions
|
|
mkN : Str -> N ;
|
|
|
|
|
|
mkInterj : Str -> Interj = \s -> lin Interj {s=s};
|
|
mkVoc : Str -> Voc = variants {} ;
|
|
|
|
|
|
} ;
|