GitHub/gf-core
1
0
Fork 1
mirror of https://github.com/GrammaticalFramework/gf-core.git synced 2026-04-09 04:59:31 -06:00
Code Issues Packages Projects Releases Wiki Activity

preparing resource api for multilingual documentation

Browse Source
This commit is contained in:
aarne
2010-12-10 08:48:26 +00:00
parent 847561d2f6
commit 7b9e55650b
7 changed files with 562 additions and 114 deletions
Download Patch File Download Diff File Expand all files Collapse all files

71
lib/doc/MkExx.hs Normal file
View File

@@ -0,0 +1,71 @@
-- make a script for computing examples
-- usage: runghc MkExx.hs <koe.txt >koe.gfs
-- then: gf -retain -s ../alltenses/TryRon.gfo <koe.gfs
main = interact (unlines . concatMap mkScript . lines)
mkScript l = case l of
' ':_ ->
let ident = mkIdent $ unwords $ takeWhile (/="--") $ words l
in [add $ psq ident]
'-':_ -> []
_ -> [
add $ psq l,
add $ "cc -one " ++ l
]
add = ('\n':)
psq s = "ps \"" ++ s ++ "\""
-- makes mkUtt : QS -> Utt to mkUtt-QS-Utt
mkIdent :: String -> String
mkIdent = concatMap unspec where
unspec c = case c of
' ' -> ""
'>' -> ""
'(' -> ""
')' -> ""
':' -> "-"
_ -> [c]
langsCoding = [
(("amharic", "Amh"),""),
(("arabic", "Ara"),""),
(("bulgarian","Bul"),""),
(("catalan", "Cat"),"Romance"),
(("danish", "Dan"),"Scand"),
(("dutch", "Dut"),""),
(("english", "Eng"),""),
(("finnish", "Fin"),""),
(("french", "Fre"),"Romance"),
(("hindi", "Hin"),"Hindustani"),
(("german", "Ger"),""),
(("interlingua","Ina"),""),
(("italian", "Ita"),"Romance"),
(("latin", "Lat"),""),
(("norwegian","Nor"),"Scand"),
(("polish", "Pol"),""),
(("punjabi", "Pnb"),""),
(("romanian", "Ron"),""),
(("russian", "Rus"),""),
(("spanish", "Spa"),"Romance"),
(("swedish", "Swe"),"Scand"),
(("thai", "Tha"),""),
(("turkish", "Tur"),""),
(("urdu", "Urd"),"Hindustani")
]
langs = map fst langsCoding
-- languagues for which Try is normally compiled
langsLang = langs `except` langsIncomplete
-- languages for which Lang can be compiled but which are incomplete
langsIncomplete = ["Amh","Ara","Hin","Lat","Pnb","Rus","Tha","Tur","Urd"]
except ls es = filter (flip notElem es . snd) ls

4
lib/doc/MkSynopsis.hs
View File

@@ -46,7 +46,9 @@ main = do
--- putStrLn $ unlines ["p -cat=" ++ last (words t) ++
--- " \"" ++ e ++ "\"" | (_,t,e) <- rs, not (null e)] ----
rs2 <- getRules structuralAPI
delimit $ mkSplitTables True isLatex cs $ rs ++ rs2
let rss = rs ++ rs2
mapM_ putStrLn [f ++ " " ++ e | (f,_,e) <- rss]
delimit $ mkSplitTables True isLatex cs rss
space
-- title "Structural Words"
-- space

367
lib/doc/api-examples.txt Normal file
View File

@@ -0,0 +1,367 @@
mkText : Phr -> (Punct) -> (Text) -> Text -- Does she sleep? Yes.
mkText (mkPhr (mkQS (mkCl she_NP sleep_V))) questMarkPunct (mkText (mkPhr yes_Utt) fullStopPunct)
mkText : Utt -> Text -- Yes.
mkText yes_Utt
mkText : S -> Text -- She slept.
mkText (mkS pastTense (mkCl she_NP sleep_V))
mkText : Cl -> Text -- She sleeps.
mkText (mkCl she_NP sleep_V)
mkText : QS -> Text -- Did she sleep?
mkText (mkQS pastTense (mkQCl (mkCl she_NP sleep_V)))
mkText : (Pol) -> Imp -> Text -- Don't sleep!
mkText negativePol (mkImp sleep_V)
mkText : Text -> Text -> Text -- Where? Here. When? Now!
mkText (mkText (mkPhr (mkUtt where_IAdv)) questMarkPunct (mkText (mkPhr (mkUtt here_Adv)))) (mkText (mkPhr (mkUtt when_IAdv)) questMarkPunct (mkText (mkPhr (mkUtt now_Adv)) exclMarkPunct))
-- emptyText : Text -- (empty text)
--emptyText
-- fullStopPunct : Punct -- .
--fullStopPunct
-- questMarkPunct : Punct -- ?
--questMarkPunct
-- exclMarkPunct : Punct -- !
--exclMarkPunct
-- mkPhr : (PConj) -> Utt -> (Voc) -> Phr -- but sleep, my friend
mkPhr but_PConj (mkUtt (mkImp sleep_V)) (mkVoc (mkNP i_Pron friend_N))
mkPhr : S -> Phr -- she won't sleep
mkPhr (mkS futureTense negativePol (mkCl she_NP sleep_V))
mkPhr : Cl -> Phr -- she sleeps
mkPhr (mkCl she_NP sleep_V)
mkPhr : QS -> Phr -- would she sleep
mkPhr (mkQS conditionalTense (mkQCl (mkCl she_NP sleep_V)))
mkPhr : Imp -> Phr -- sleep
mkPhr (mkImp sleep_V)
mkPConj : Conj -> PConj -- and
mkPConj and_Conj
mkVoc : NP -> Voc -- my friend
mkVoc (mkNP i_Pron friend_N)
mkUtt : S -> Utt -- she slept
mkUtt (mkS pastTense (mkCl she_NP sleep_V))
mkUtt : Cl -> Utt -- she sleeps
mkUtt (mkCl she_NP sleep_V)
mkUtt : QS -> Utt -- who didn't sleep
mkUtt (mkQS pastTense negativePol (mkQCl who_IP sleep_V))
mkUtt : QCl -> Utt -- who sleeps
mkUtt (mkQCl who_IP sleep_V)
mkUtt : (ImpForm) -> (Pol) -> Imp -> Utt -- don't be men
mkUtt pluralImpForm negativePol (mkImp (mkVP man_N))
mkUtt : IP -> Utt -- who
mkUtt who_IP
mkUtt : IAdv -> Utt -- why
mkUtt why_IAdv
mkUtt : NP -> Utt -- this man
mkUtt (mkNP this_Det man_N)
mkUtt : Adv -> Utt -- here
mkUtt here_Adv
mkUtt : VP -> Utt -- to sleep
mkUtt (mkVP sleep_V)
mkUtt : CN -> Utt -- beer
mkUtt (mkCN beer_N)
mkUtt : AP -> Utt -- good
mkUtt (mkAP good_A)
mkUtt : Card -> Utt -- five
mkUtt (mkCard (mkNumeral "5"))
lets_Utt : VP -> Utt -- let's sleep
mkPhr (lets_Utt (mkVP sleep_V))
positivePol : Pol -- she sleeps [default]
mkS positivePol (mkCl she_NP sleep_V)
negativePol : Pol -- she doesn't sleep
mkS negativePol (mkCl she_NP sleep_V)
simultaneousAnt : Ant -- she sleeps [default]
mkS simultaneousAnt (mkCl she_NP sleep_V)
anteriorAnt : Ant -- she has slept --# notpresent
mkS anteriorAnt (mkCl she_NP sleep_V)
presentTense : Tense -- she sleeps [default]
mkS presentTense (mkCl she_NP sleep_V)
pastTense : Tense -- she slept --# notpresent
mkS pastTense (mkCl she_NP sleep_V)
futureTense : Tense -- she will sleep --# notpresent
mkS futureTense (mkCl she_NP sleep_V)
conditionalTense : Tense -- she would sleep --# notpresent
mkS conditionalTense (mkCl she_NP sleep_V)
singularImpForm : ImpForm -- be a man [default]
mkUtt singularImpForm (mkImp (mkVP man_N))
pluralImpForm : ImpForm -- be men
mkUtt pluralImpForm (mkImp (mkVP man_N))
politeImpForm : ImpForm -- be a man [polite singular]
mkUtt politeImpForm (mkImp (mkVP man_N))
mkS : (Tense) -> (Ant) -> (Pol) -> Cl -> S -- she wouldn't have slept
mkS conditionalTense anteriorAnt negativePol (mkCl she_NP sleep_V)
mkS : Conj -> S -> S -> S -- she sleeps and I run
mkS : Conj -> ListS -> S -- she sleeps, I run and you sleep
mkS : Adv -> S -> S -- today, she sleeps
mkCl : NP -> V -> Cl -- she sleeps
mkCl : NP -> V2 -> NP -> Cl -- she loves him
mkCl : NP -> V3 -> NP -> NP -> Cl -- she sends it to him
mkCl : NP -> VV -> VP -> Cl -- she wants to sleep
mkCl : NP -> VS -> S -> Cl -- she says that she sleeps
mkCl : NP -> VQ -> QS -> Cl -- she wonders who sleeps
mkCl : NP -> VA -> AP -> Cl -- she becomes old
mkCl : NP -> V2A -> NP -> AP -> Cl -- she paints it red
mkCl : NP -> V2S -> NP -> S -> Cl -- she tells him that we sleep
mkCl : NP -> V2Q -> NP -> QS -> Cl -- she asks him who sleeps
mkCl : NP -> V2V -> NP -> VP -> Cl -- she forces him to sleep
mkCl : NP -> A -> Cl -- she is old
mkCl : NP -> A -> NP -> Cl -- she is older than him
mkCl : NP -> A2 -> NP -> Cl -- she is married to him
mkCl : NP -> AP -> Cl -- she is very old
mkCl : NP -> NP -> Cl -- she is the man
mkCl : NP -> N -> Cl -- she is a man
mkCl : NP -> CN -> Cl -- she is an old man
mkCl : NP -> Adv -> Cl -- she is here
mkCl : NP -> VP -> Cl -- she always sleeps here
mkCl : N -> Cl -- there is a house
mkCl : CN -> Cl -- there is an old house
mkCl : NP -> Cl -- there are five houses
mkCl : NP -> RS -> Cl -- it is she who sleeps
mkCl : Adv -> S -> Cl -- it is here he sleeps
mkCl : V -> Cl -- it rains
mkCl : VP -> Cl -- it is raining
mkCl : SC -> VP -> Cl
genericCl : VP -> Cl -- one sleeps
mkVP : V -> VP -- sleep
mkVP : V2 -> NP -> VP -- love it
mkVP : V3 -> NP -> NP -> VP -- send a message to him
mkVP : VV -> VP -> VP -- want to run
mkVP : VS -> S -> VP -- know that she runs
mkVP : VQ -> QS -> VP -- wonder if she runs
mkVP : VA -> AP -> VP -- become red
mkVP : V2A -> NP -> AP -> VP -- paint it red
mkVP : V2S -> NP -> S -> VP -- tell him that we sleep
mkVP : V2Q -> NP -> QS -> VP -- ask him who sleeps
mkVP : V2V -> NP -> VP -> VP -- force him to sleep
mkVP : A -> VP -- be warm
mkVP : A -> NP -> VP -- be older than him
mkVP : A2 -> NP -> VP -- be married to him
mkVP : AP -> VP -- be warm
mkVP : N -> VP -- be a man
mkVP : CN -> VP -- be an old man
mkVP : NP -> VP -- be this man
mkVP : Adv -> VP -- be here
mkVP : VP -> Adv -> VP -- sleep here
mkVP : AdV -> VP -> VP -- always sleep
mkVP : VPSlash -> NP -> VP -- paint it black
mkVP : VPSlash -> VP -- paint itself black
mkVP : Comp -> VP -- be warm
reflexiveVP : V2 -> VP -- love itself
passiveVP : V2 -> VP -- be loved
passiveVP : V2 -> NP -> VP -- be loved by her
progressiveVP : VP -> VP -- be sleeping
mkComp : AP -> Comp -- very old
mkComp : NP -> Comp -- this man
mkComp : Adv -> Comp -- here
mkSC : S -> SC -- that he sleeps
mkSC : QS -> SC -- whether he sleeps
mkSC : VP -> SC -- to sleep
mkImp : VP -> Imp -- go
mkImp : V -> Imp -- take it
mkImp : V2 -> NP -> Imp -- come here now
mkNP : Quant -> N -> NP -- this man
mkNP : Quant -> CN -> NP -- this old man
mkNP : Quant -> Num -> CN -> NP -- these five old men
mkNP : Quant -> Num -> N -> NP -- these five men
mkNP : Det -> CN -> NP -- the first old man
mkNP : Det -> N -> NP -- the first man
mkNP : Numeral -> CN -> NP -- fifty old men
mkNP : Numeral -> N -> NP -- fifty men
mkNP : Digits -> CN -> NP -- 51 old men
mkNP : Digits -> N -> NP -- 51 men
mkNP : Card -> CN -> NP -- forty-five old men
mkNP : Card -> N -> NP -- forty-five men
mkNP : Pron -> CN -> NP -- my old man
mkNP : Pron -> N -> NP -- my man
mkNP : PN -> NP -- she
mkNP : Pron -> NP -- he
mkNP : Quant -> NP -- this
mkNP : Quant -> Num -> NP -- these five
mkNP : Det -> NP -- these five best
mkNP : CN -> NP -- old beer
mkNP : N -> NP -- beer
mkNP : Predet -> NP -> NP -- only the man
mkNP : NP -> V2 -> NP -- the man seen
mkNP : NP -> Adv -> NP -- Paris today
mkNP : NP -> RS -> NP -- John, who lives in Paris
mkNP : Conj -> NP -> NP -> NP
mkNP : Conj -> ListNP -> NP
mkDet : Quant -> Det -- this
mkDet : Quant -> Card -> Det -- these five
mkDet : Quant -> Ord -> Det -- the best
mkDet : Quant -> Num -> Ord -> Det -- these five best
mkDet : Quant -> Num -> Det -- these five
mkDet : Card -> Det -- forty
mkDet : Digits -> Det -- 51
mkDet : Numeral -> Det -- five
mkDet : Pron -> Det -- my
mkDet : Pron -> Num -> Det -- my five
the_Det : Det -- the (house)
a_Det : Det -- a (house)
theSg_Det : Det -- the (houses)
thePl_Det : Det -- the (houses)
aSg_Det : Det -- a (house)
aPl_Det : Det -- (houses)
mkQuant : Pron -> Quant -- my
the_Quant : Quant -- the
a_Quant : Quant -- a
mkNum : Str -> Num -- thirty-five (given by "35")
mkNum : Numeral -> Num -- twenty
mkNum : Digits -> Num -- 21
mkNum : Digit -> Num -- five
mkNum : Card -> Num -- almost ten
mkNum : AdN -> Card -> Num -- almost ten
singularNum : Num -- singular
pluralNum : Num -- plural
mkCard : Str -> Card -- thirty-five (given as "35")
mkCard : Numeral -> Card -- twenty
mkCard : Digits -> Card -- 51
mkCard : AdN -> Card -> Card -- almost fifty
mkOrd : Numeral -> Ord -- twentieth
mkOrd : Digits -> Ord -- 51st
mkOrd : Digit -> Ord -- fifth
mkOrd : A -> Ord -- largest
mkAdN : CAdv -> AdN -- more than
mkNumeral : Sub1000 -> Numeral -- coerce 1..999
mkNumeral : Sub1000 -> Sub1000 -> Numeral -- 1000m + n
mkNumeral : Str -> Numeral -- thirty-five (given by "35")
thousandfoldNumeral : Sub1000 -> Numeral -- 1000n
mkSub1000 : Sub100 -> Sub1000 -- coerce 1..99
mkSub1000 : Sub10 -> Sub1000 -- 100n
mkSub1000 : Sub10 -> Sub100 -> Sub1000 -- 100m + n
mkSub100 : Unit -> Sub100 -- coerce 1..9
mkSub100 : Unit -> Unit -> Sub100 -- 10m + n
tenfoldSub100 : Unit -> Sub100 -- 10n
n1_Unit : Unit -- one
n2_Unit : Unit -- two
n3_Unit : Unit -- three
n4_Unit : Unit -- four
n5_Unit : Unit -- five
n6_Unit : Unit -- six
n7_Unit : Unit -- seven
n8_Unit : Unit -- eight
n9_Unit : Unit -- nine
mkDigits : Str -> Digits -- 35 (from string "35")
mkDigits : Dig -> Digits -- 4
mkDigits : Dig -> Digits -> Digits -- 1,233,432
n0_Dig : Dig -- 0
n1_Dig : Dig -- 1
n2_Dig : Dig -- 2
n3_Dig : Dig -- 3
n4_Dig : Dig -- 4
n5_Dig : Dig -- 5
n6_Dig : Dig -- 6
n7_Dig : Dig -- 7
n8_Dig : Dig -- 8
n9_Dig : Dig -- 9
mkCN : N -> CN -- house
mkCN : N2 -> NP -> CN -- mother of John
mkCN : N3 -> NP -> NP -> CN -- distance from this city to Paris
mkCN : N2 -> CN -- mother
mkCN : N3 -> CN -- distance
mkCN : A -> N -> CN -- big house
mkCN : A -> CN -> CN -- big blue house
mkCN : AP -> N -> CN -- very big house
mkCN : AP -> CN -> CN -- very big blue house
mkCN : N -> RS -> CN -- house that she owns
mkCN : CN -> RS -> CN -- big house that she loves
mkCN : N -> Adv -> CN -- house on the hill
mkCN : CN -> Adv -> CN -- big house on the hill
mkCN : CN -> S -> CN -- rule that she sleeps
mkCN : CN -> QS -> CN -- question if she sleeps
mkCN : CN -> VP -> CN -- reason to sleep
mkCN : CN -> SC -> CN -- reason to sleep
mkCN : N -> NP -> CN -- king John
mkCN : CN -> NP -> CN -- old king John
mkAP : A -> AP -- warm
mkAP : A -> NP -> AP -- warmer than Paris
mkAP : A2 -> NP -> AP -- married to her
mkAP : A2 -> AP -- married
mkAP : AP -> S -> AP -- probable that she sleeps
mkAP : AP -> QS -> AP -- uncertain if she sleeps
mkAP : AP -> VP -> AP -- ready to go
mkAP : AP -> SC -> AP -- ready to go
mkAP : AdA -> A -> AP -- very old
mkAP : AdA -> AP -> AP -- very very old
mkAP : Conj -> AP -> AP -> AP -- old and big
mkAP : Conj -> ListAP -> AP -- old, big and warm
mkAP : Ord -> AP -- oldest
mkAP : CAdv -> AP -> NP -> AP -- as old as she
reflAP : A2 -> AP -- married to himself
comparAP : A -> AP -- warmer
mkAdv : A -> Adv -- warmly
mkAdv : Prep -> NP -> Adv -- in the house
mkAdv : Subj -> S -> Adv -- when she sleeps
mkAdv : CAdv -> A -> NP -> Adv -- more warmly than she
mkAdv : CAdv -> A -> S -> Adv -- more warmly than he runs
mkAdv : AdA -> Adv -> Adv -- very warmly
mkAdv : Conj -> Adv -> Adv -> Adv -- here and now
mkAdv : Conj -> ListAdv -> Adv -- with John, here and now
mkQS : (Tense) -> (Ant) -> (Pol) -> QCl -> QS -- who wouldn't have slept
mkQS : Cl -> QS
mkQCl : Cl -> QCl -- does she sleep
mkQCl : IP -> VP -> QCl -- who sleeps
mkQCl : IP -> V -> QCl -- who sleeps
mkQCl : IP -> V2 -> NP -> QCl -- who loves her
mkQCl : IP -> V3 -> NP -> NP -> QCl -- who sends it to her
mkQCl : IP -> VV -> VP -> QCl -- who wants to sleep
mkQCl : IP -> VS -> S -> QCl -- who says that she sleeps
mkQCl : IP -> VQ -> QS -> QCl -- who wonders who sleeps
mkQCl : IP -> VA -> AP -> QCl -- who becomes old
mkQCl : IP -> V2A -> NP -> AP -> QCl -- who paints it red
mkQCl : IP -> V2S -> NP -> S -> QCl -- who tells her that we sleep
mkQCl : IP -> V2Q -> NP -> QS -> QCl -- who asks her who sleeps
mkQCl : IP -> V2V -> NP -> VP -> QCl -- who forces her to sleep
mkQCl : IP -> A -> QCl -- who is old
mkQCl : IP -> A -> NP -> QCl -- who is older than her
mkQCl : IP -> A2 -> NP -> QCl -- who is married to her
mkQCl : IP -> AP -> QCl -- who is very old
mkQCl : IP -> NP -> QCl -- who is the man
mkQCl : IP -> N -> QCl -- who is a man
mkQCl : IP -> CN -> QCl -- who is an old man
mkQCl : IP -> Adv -> QCl -- who is here
mkQCl : IP -> NP -> V2 -> QCl -- who does she love
mkQCl : IP -> ClSlash -> QCl -- who does she today
mkQCl : IAdv -> Cl -> QCl -- why does she sleep
mkQCl : Prep -> IP -> Cl -> QCl -- with whom does she sleep
mkQCl : IAdv -> NP -> QCl -- where is she
mkQCl : IComp -> NP -> QCl -- who is this man
mkQCl : IP -> QCl -- which houses are there
mkIP : IDet -> CN -> IP -- which five big cities
mkIP : IDet -> N -> IP -- which five cities
mkIP : IDet -> IP -- which five
mkIP : IQuant -> CN -> IP -- which big cities
mkIP : IQuant -> Num -> CN -> IP -- which five cities
mkIP : IQuant -> N -> IP -- which city
mkIP : IP -> Adv -> IP -- who in Paris
what_IP : IP -- what (singular)
who_IP : IP -- who (singular)
mkIAdv : Prep -> IP -> IAdv -- in which city
mkIAdv : IAdv -> Adv -> IAdv -- where in Paris
mkIDet : IQuant -> Num -> IDet -- which (songs)
mkIDet : IQuant -> IDet
which_IDet : IDet
whichPl_IDet : IDet
mkRS : (Tense) -> (Ant) -> (Pol) -> RCl -> RS -- that wouldn't have slept
mkRS : Conj -> RS -> RS -> RS -- who sleeps and whose mother runsx
mkRS : Conj -> ListRS -> RS -- who sleeps, whom I see and who sleeps
mkRCl : RP -> VP -> RCl -- that loves she
mkRCl : RP -> ClSlash -> RCl -- whom she loves today
mkRCl : RP -> NP -> V2 -> RCl -- whom she loves
mkRCl : Cl -> RCl -- such that she loves him
which_RP : RP -- which
mkRP : Prep -> NP -> RP -> RP -- all the houses in which
mkSSlash : Temp -> Pol -> ClSlash -> SSlash
mkClSlash : NP -> VPSlash -> ClSlash -- (whom) he sees here
mkClSlash : NP -> V2 -> ClSlash -- (whom) he sees
mkClSlash : NP -> VV -> V2 -> ClSlash -- (whom) he wants to see
mkClSlash : Cl -> Prep -> ClSlash -- (with whom) he sleeps
mkClSlash : ClSlash -> Adv -> ClSlash -- (whom) he sees tomorrow
mkClSlash : NP -> VS -> SSlash -> ClSlash -- (whom) she says that he loves
mkVPSlash : V2 -> VPSlash -- (whom) (she) loves
mkVPSlash : V3 -> NP -> VPSlash -- (whom) (she) gives an apple
mkVPSlash : V2A -> AP -> VPSlash -- (whom) (she) paints red
mkVPSlash : V2Q -> QS -> VPSlash -- (whom) (she) asks who sleeps
mkVPSlash : V2S -> S -> VPSlash -- (whom) (she) tells that we sleep
mkVPSlash : V2V -> VP -> VPSlash -- (whom) (she) forces to sleep
mkVPSlash : VV -> VPSlash -> VPSlash -- want always to buy
mkVPSlash : V2V -> NP -> VPSlash -> VPSlash -- beg me always to buy

230
lib/src/api/Constructors.gf
View File

@@ -74,13 +74,13 @@ incomplete resource Constructors = open Grammar in { --%
oper
mkText = overload { --%
mkText : Phr -> (Punct) -> (Text) -> Text -- John walks? Yes. --:
mkText : Phr -> (Punct) -> (Text) -> Text -- Does she sleep? Yes. --:
= \phr,punct,text -> case punct of { --%
PFullStop => TFullStop phr text ; --%
PExclMark => TExclMark phr text ; --%
PQuestMark => TQuestMark phr text --%
} ; --%
mkText : Phr -> Text -> Text -- 1. But John walks. Yes! --%
mkText : Phr -> Text -> Text -- But she sleeps. Yes! --%
= \x,t -> TFullStop x t ; --%
mkText : Phr -> Punct -> Text --%
= \phr,punct -> case punct of { --%
@@ -88,7 +88,7 @@ incomplete resource Constructors = open Grammar in { --%
PExclMark => TExclMark phr TEmpty ; --%
PQuestMark => TQuestMark phr TEmpty --%
} ; --%
mkText : Phr -> Text -- 1. But John walks. --%
mkText : Phr -> Text -- But she sleeps. --%
= \x -> TFullStop x TEmpty ; --%
@@ -98,19 +98,20 @@ incomplete resource Constructors = open Grammar in { --%
mkText : Utt -> Text -- Yes.
= \u -> TFullStop (PhrUtt NoPConj u NoVoc) TEmpty ; --%
mkText : S -> Text -- John walked.
mkText : S -> Text -- She slept.
= \s -> TFullStop (PhrUtt NoPConj (UttS s) NoVoc) TEmpty ; --%
mkText : Cl -> Text -- John walks.
mkText : Cl -> Text -- She sleeps.
= \c -> TFullStop (PhrUtt NoPConj (UttS (TUseCl TPres ASimul PPos c)) NoVoc) TEmpty ; --%
mkText : QS -> Text -- Did John walk?
mkText : QS -> Text -- Did she sleep?
= \q -> TQuestMark (PhrUtt NoPConj (UttQS q) NoVoc) TEmpty ; --%
mkText : (Pol) -> Imp -> Text -- Walk!
mkText : (Pol) -> Imp -> Text -- Don't sleep!
= \p,i -> TExclMark (PhrUtt NoPConj (UttImpSg p i) NoVoc) TEmpty; --%
mkText : Imp -> Text -- Walk! --%
mkText : Imp -> Text -- Sleep! --%
= \i -> TExclMark (PhrUtt NoPConj (UttImpSg PPos i) NoVoc) TEmpty; --%
-- Finally, two texts can be combined into a text.
mkText : Text -> Text -> Text -- Where? When? Here. Now!
mkText : Text -> Text -> Text -- Where? Here. When? Here. Now!
= \t,u -> {s = t.s ++ u.s ; lock_Text = <>} ; --%
} ; --%
@@ -142,7 +143,7 @@ incomplete resource Constructors = open Grammar in { --%
-- and a vocative, both of which are by default empty.
mkPhr = overload { --%
mkPhr : (PConj) -> Utt -> (Voc) -> Phr -- but come here John --:
mkPhr : (PConj) -> Utt -> (Voc) -> Phr -- but sleep, my friend --:
= PhrUtt ; --%
mkPhr : Utt -> Voc -> Phr -- come here John --%
= \u,v -> PhrUtt NoPConj u v ; --%
@@ -154,13 +155,13 @@ incomplete resource Constructors = open Grammar in { --%
-- A phrase can also be directly built by a sentence, a present-tense
-- clause, a question, or a positive singular imperative.
mkPhr : S -> Phr -- I go home
mkPhr : S -> Phr -- she won't sleep
= \s -> PhrUtt NoPConj (UttS s) NoVoc ; --%
mkPhr : Cl -> Phr -- I go home
mkPhr : Cl -> Phr -- she sleeps
= \s -> PhrUtt NoPConj (UttS (TUseCl TPres ASimul PPos s)) NoVoc ; --%
mkPhr : QS -> Phr -- I go home
mkPhr : QS -> Phr -- would she sleep
= \s -> PhrUtt NoPConj (UttQS s) NoVoc ; --%
mkPhr : Imp -> Phr -- I go home
mkPhr : Imp -> Phr -- sleep
= \s -> PhrUtt NoPConj (UttImpSg PPos s) NoVoc --%
} ; --%
@@ -172,7 +173,7 @@ incomplete resource Constructors = open Grammar in { --%
mkPConj : Conj -> PConj -- and --:
= PConjConj ; --%
noPConj : PConj --%
noPConj : PConj --: --%
= NoPConj ; --%
@@ -181,7 +182,7 @@ incomplete resource Constructors = open Grammar in { --%
-- Any noun phrase can be turned into a vocative.
-- More vocatives are defined in $Structural$.
mkVoc : NP -> Voc -- John --:
mkVoc : NP -> Voc -- my friend --:
= VocNP ; --%
noVoc : Voc --%
= NoVoc ; --%
@@ -192,20 +193,19 @@ incomplete resource Constructors = open Grammar in { --%
-- Utterances are formed from sentences, clauses, questions, and imperatives.
mkUtt = overload {
mkUtt : S -> Utt -- John walked --:
mkUtt : S -> Utt -- she slept --:
= UttS ; --%
mkUtt : Cl -> Utt -- John walks
mkUtt : Cl -> Utt -- she sleeps
= \c -> UttS (TUseCl TPres ASimul PPos c) ; --%
mkUtt : QS -> Utt -- did John walk --:
mkUtt : QS -> Utt -- who didn't sleep --:
= UttQS ; --%
mkUtt : QCl -> Utt -- does John walk
mkUtt : QCl -> Utt -- who sleeps
= \c -> UttQS (TUseQCl TPres ASimul PPos c) ; --%
mkUtt : (ImpForm) -> (Pol) -> Imp -> Utt -- don't love yourselves --:
mkUtt : (ImpForm) -> (Pol) -> Imp -> Utt -- don't be men --:
= mkUttImp ; --%
mkUtt : ImpForm -> Imp -> Utt -- love yourselves --%
mkUtt : ImpForm -> Imp -> Utt -- be men --%
= \f -> mkUttImp f PPos ; --%
mkUtt : Pol -> Imp -> Utt -- don't love yourself --%
mkUtt : Pol -> Imp -> Utt -- don't be men --%
= UttImpSg ; --%
mkUtt : Imp -> Utt -- love yourself --%
= UttImpSg PPos ; --%
@@ -233,7 +233,7 @@ incomplete resource Constructors = open Grammar in { --%
-- The plural first-person imperative is a special construction.
lets_Utt : VP -> Utt -- let's walk --:
lets_Utt : VP -> Utt -- let's sleep --:
= ImpPl1 ; --%
@@ -244,9 +244,9 @@ incomplete resource Constructors = open Grammar in { --%
-- 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] --:
positivePol : Pol -- she sleeps [default] --:
= PPos ; --%
negativePol : Pol -- John doesn't walk --:
negativePol : Pol -- she doesn't sleep --:
= PNeg ; --%
--3 Ant, anteriority
@@ -255,9 +255,9 @@ incomplete resource Constructors = open Grammar in { --%
-- anterior to some other reference time.
-- Since simultaneous is the default, it need never be given explicitly.
simultaneousAnt : Ant -- John walks [default] --:
simultaneousAnt : Ant -- she sleeps [default] --:
= ASimul ; --%
anteriorAnt : Ant -- John has walked --# notpresent --:
anteriorAnt : Ant -- she has slept --# notpresent --:
= AAnter ; --# notpresent --%
--3 Tense, tense
@@ -266,13 +266,13 @@ incomplete resource Constructors = open Grammar in { --%
-- to the time of speaking about it.
-- Since present is the default, it need never be given explicitly.
presentTense : Tense -- John walks [default] --:
presentTense : Tense -- she sleeps [default] --:
= TPres ; --%
pastTense : Tense -- John walked --# notpresent --:
pastTense : Tense -- she slept --# notpresent --:
= TPast ; --# notpresent --%
futureTense : Tense -- John will walk --# notpresent --:
futureTense : Tense -- she will sleep --# notpresent --:
= TFut ; --# notpresent --%
conditionalTense : Tense -- John would walk --# notpresent --:
conditionalTense : Tense -- she would sleep --# notpresent --:
= TCond ; --# notpresent --%
--3 ImpForm, imperative form
@@ -281,11 +281,11 @@ incomplete resource Constructors = open Grammar in { --%
-- by reference to the person or persons addressed.
-- Since singular is the default, it need never be given explicitly.
singularImpForm : ImpForm -- help yourself [default] --:
singularImpForm : ImpForm -- be a man [default] --:
= IFSg ; --%
pluralImpForm : ImpForm -- help yourselves --:
pluralImpForm : ImpForm -- be men --:
= IFPl ; --%
politeImpForm : ImpForm -- help yourself [polite singular] --:
politeImpForm : ImpForm -- be a man [polite singular] --:
= IFPol ; --%
-- This is how imperatives are implemented internally. --%
@@ -322,20 +322,20 @@ incomplete resource Constructors = open Grammar in { --%
= \t,p -> TUseCl t ASimul p ; --%
mkS : Ant -> Pol -> Cl -> S --%
= \a,p -> TUseCl TPres a p ; --%
mkS : (Tense) -> (Ant) -> (Pol) -> Cl -> S -- John wouldn't have walked --:
mkS : (Tense) -> (Ant) -> (Pol) -> Cl -> S -- she wouldn't have slept --:
= \t,a -> TUseCl t a ; --%
-- 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 -- John walks and I run
mkS : Conj -> S -> S -> S -- she sleeps and I run
= \c,x,y -> ConjS c (BaseS x y) ; --%
mkS : Conj -> ListS -> S -- John walks, I run and you sleep --:
mkS : Conj -> ListS -> S -- she sleeps, I run and you sleep --:
= \c,xy -> ConjS c xy ; --%
-- A sentence can be prefixed by an adverb.
mkS : Adv -> S -> S -- today, John walks --:
mkS : Adv -> S -> S -- today, she sleeps --:
= AdvS ; --%
} ;
@@ -347,50 +347,50 @@ incomplete resource Constructors = open Grammar in { --%
mkCl = overload {
mkCl : NP -> V -> Cl -- John walks
mkCl : NP -> V -> Cl -- she sleeps
= \s,v -> PredVP s (UseV v); --%
mkCl : NP -> V2 -> NP -> Cl -- John loves her
mkCl : NP -> V2 -> NP -> Cl -- she loves him
= \s,v,o -> PredVP s (ComplV2 v o); --%
mkCl : NP -> V3 -> NP -> NP -> Cl -- John sends it to her
mkCl : NP -> V3 -> NP -> NP -> Cl -- she sends it to him
= \s,v,o,i -> PredVP s (ComplV3 v o i); --%
mkCl : NP -> VV -> VP -> Cl -- John wants to walk
mkCl : NP -> VV -> VP -> Cl -- she wants to sleep
= \s,v,vp -> PredVP s (ComplVV v vp) ; --%
mkCl : NP -> VS -> S -> Cl -- John says that she walks
mkCl : NP -> VS -> S -> Cl -- she says that she sleeps
= \s,v,p -> PredVP s (ComplVS v p) ; --%
mkCl : NP -> VQ -> QS -> Cl -- John wonders who walks
mkCl : NP -> VQ -> QS -> Cl -- she wonders who sleeps
= \s,v,q -> PredVP s (ComplVQ v q) ; --%
mkCl : NP -> VA -> AP -> Cl -- John becomes old
mkCl : NP -> VA -> AP -> Cl -- she becomes old
= \s,v,q -> PredVP s (ComplVA v q) ; --%
mkCl : NP -> V2A -> NP -> AP -> Cl -- John paints it red
mkCl : NP -> V2A -> NP -> AP -> Cl -- she paints it red
= \s,v,n,q -> PredVP s (ComplV2A v n q) ; --%
mkCl : NP -> V2S -> NP -> S -> Cl -- John tells her that we walk
mkCl : NP -> V2S -> NP -> S -> Cl -- she tells him that we sleep
= \s,v,n,q -> PredVP s (ComplSlash (SlashV2S v q) n) ; --%
mkCl : NP -> V2Q -> NP -> QS -> Cl -- John asks her who walks
mkCl : NP -> V2Q -> NP -> QS -> Cl -- she asks him who sleeps
= \s,v,n,q -> PredVP s (ComplSlash (SlashV2Q v q) n) ; --%
mkCl : NP -> V2V -> NP -> VP -> Cl -- John forces her to walk
mkCl : NP -> V2V -> NP -> VP -> Cl -- she forces him to sleep
= \s,v,n,q -> PredVP s (ComplSlash (SlashV2V v q) n) ; --%
mkCl : NP -> A -> Cl -- John is old
mkCl : NP -> A -> Cl -- she is old
= \x,y -> PredVP x (UseComp (CompAP (PositA y))) ; --%
mkCl : NP -> A -> NP -> Cl -- John is older than her
mkCl : NP -> A -> NP -> Cl -- she is older than him
= \x,y,z -> PredVP x (UseComp (CompAP (ComparA y z))) ; --%
mkCl : NP -> A2 -> NP -> Cl -- John is married to her
mkCl : NP -> A2 -> NP -> Cl -- she is married to him
= \x,y,z -> PredVP x (UseComp (CompAP (ComplA2 y z))) ; --%
mkCl : NP -> AP -> Cl -- John is very old
mkCl : NP -> AP -> Cl -- she is very old
= \x,y -> PredVP x (UseComp (CompAP y)) ; --%
mkCl : NP -> NP -> Cl -- John is the man
mkCl : NP -> NP -> Cl -- she is the man
= \x,y -> PredVP x (UseComp (CompNP y)) ; --%
mkCl : NP -> N -> Cl -- John is a man
mkCl : NP -> N -> Cl -- she is a man
= \x,y -> PredVP x (UseComp (CompCN (UseN y))) ; --%
mkCl : NP -> CN -> Cl -- John is an old man
mkCl : NP -> CN -> Cl -- she is an old man
= \x,y -> PredVP x (UseComp (CompCN y)) ; --%
mkCl : NP -> Adv -> Cl -- John is here
mkCl : NP -> Adv -> Cl -- she is here
= \x,y -> PredVP x (UseComp (CompAdv y)) ; --%
-- As the general rule, a clause can be built from a subject noun phrase and
-- a verb phrase.
mkCl : NP -> VP -> Cl -- John always walks here --:
mkCl : NP -> VP -> Cl -- she always sleeps here --:
= PredVP ; --%
-- Existentials are a special form of clauses.
@@ -405,9 +405,9 @@ incomplete resource Constructors = open Grammar in { --%
-- There are also special forms in which a noun phrase or an adverb is
-- emphasized.
mkCl : NP -> RS -> Cl -- it is John who walks --:
mkCl : NP -> RS -> Cl -- it is she who sleeps --:
= CleftNP ; --%
mkCl : Adv -> S -> Cl -- it is here he walks --:
mkCl : Adv -> S -> Cl -- it is here he sleeps --:
= CleftAdv ; --%
-- Subjectless verb phrases are used for impersonal actions.
@@ -423,7 +423,7 @@ incomplete resource Constructors = open Grammar in { --%
-- Generic clauses are those with an impersonal subject.
genericCl : VP -> Cl -- one walks
genericCl : VP -> Cl -- one sleeps
= GenericCl ; --%
--2 Verb phrases and imperatives
@@ -437,7 +437,7 @@ incomplete resource Constructors = open Grammar in { --%
= UseV ; --%
mkVP : V2 -> NP -> VP -- love it
= ComplV2 ; --%
mkVP : V3 -> NP -> NP -> VP -- send a message to her
mkVP : V3 -> NP -> NP -> VP -- send a message to him
= ComplV3 ; --%
mkVP : VV -> VP -> VP -- want to run --:
= ComplVV ; --%
@@ -449,11 +449,11 @@ incomplete resource Constructors = open Grammar in { --%
= ComplVA ; --%
mkVP : V2A -> NP -> AP -> VP -- paint it red
= ComplV2A ; --%
mkVP : V2S -> NP -> S -> VP -- tell her that we walk
mkVP : V2S -> NP -> S -> VP -- tell him that we sleep
= \v,n,q -> (ComplSlash (SlashV2S v q) n) ; --%
mkVP : V2Q -> NP -> QS -> VP -- ask her who walks
mkVP : V2Q -> NP -> QS -> VP -- ask him who sleeps
= \v,n,q -> (ComplSlash (SlashV2Q v q) n) ; --%
mkVP : V2V -> NP -> VP -> VP -- force her to walk
mkVP : V2V -> NP -> VP -> VP -- force him to sleep
= \v,n,q -> (ComplSlash (SlashV2V v q) n) ; --%
-- The verb can also be a copula ("be"), and the relevant argument is
@@ -461,9 +461,9 @@ incomplete resource Constructors = open Grammar in { --%
mkVP : A -> VP -- be warm
= \a -> UseComp (CompAP (PositA a)) ; --%
mkVP : A -> NP -> VP -- be older than her
mkVP : A -> NP -> VP -- be older than him
= \y,z -> (UseComp (CompAP (ComparA y z))) ; --%
mkVP : A2 -> NP -> VP -- be married to her
mkVP : A2 -> NP -> VP -- be married to him
= \y,z -> (UseComp (CompAP (ComplA2 y z))) ; --%
mkVP : AP -> VP -- be warm
= \a -> UseComp (CompAP a) ; --%
@@ -530,11 +530,11 @@ incomplete resource Constructors = open Grammar in { --%
--3 SC, embedded sentence
mkSC = overload { --%
mkSC : S -> SC -- that he walks --:
mkSC : S -> SC -- that he sleeps --:
= EmbedS ; --%
mkSC : QS -> SC -- whether he walks --:
mkSC : QS -> SC -- whether he sleeps --:
= EmbedQS ; --%
mkSC : VP -> SC -- to walk --:
mkSC : VP -> SC -- to sleep --:
= EmbedVP ; --%
} ; --%
@@ -599,7 +599,7 @@ incomplete resource Constructors = open Grammar in { --%
-- Proper names and pronouns can be used as noun phrases.
mkNP : PN -> NP -- John --:
mkNP : PN -> NP -- she --:
= UsePN ; --%
mkNP : Pron -> NP -- he --:
= UsePron ; --%
@@ -940,9 +940,9 @@ incomplete resource Constructors = open Grammar in { --%
-- A common noun phrase can be modified by a relative clause or an adverb.
mkCN : N -> RS -> CN -- house that John owns
mkCN : N -> RS -> CN -- house that she owns
= \x,y -> RelCN (UseN x) y ; --%
mkCN : CN -> RS -> CN -- big house that John loves --:
mkCN : CN -> RS -> CN -- big house that she loves --:
= RelCN ; --%
mkCN : N -> Adv -> CN -- house on the hill
= \x,y -> AdvCN (UseN x) y ; --%
@@ -953,13 +953,13 @@ incomplete resource Constructors = open Grammar in { --%
-- questions, or infinitives. But syntactically this is possible for
-- all nouns.
mkCN : CN -> S -> CN -- rule that John walks
mkCN : CN -> S -> CN -- rule that she sleeps
= \cn,s -> SentCN cn (EmbedS s) ; --%
mkCN : CN -> QS -> CN -- question if John walks
mkCN : CN -> QS -> CN -- question if she sleeps
= \cn,s -> SentCN cn (EmbedQS s) ; --%
mkCN : CN -> VP -> CN -- reason to walk
mkCN : CN -> VP -> CN -- reason to sleep
= \cn,s -> SentCN cn (EmbedVP s) ; --%
mkCN : CN -> SC -> CN -- reason to walk --:
mkCN : CN -> SC -> CN -- reason to sleep --:
= \cn,s -> SentCN cn s ; --%
-- A noun can be used in apposition to a noun phrase, especially a proper name.
@@ -996,9 +996,9 @@ incomplete resource Constructors = open Grammar in { --%
-- questions, or infinitives. Syntactically this is possible for
-- all adjectives.
mkAP : AP -> S -> AP -- probable that John walks
mkAP : AP -> S -> AP -- probable that she sleeps
= \ap,s -> SentAP ap (EmbedS s) ; --%
mkAP : AP -> QS -> AP -- uncertain if John walks
mkAP : AP -> QS -> AP -- uncertain if she sleeps
= \ap,s -> SentAP ap (EmbedQS s) ; --%
mkAP : AP -> VP -> AP -- ready to go
= \ap,s -> SentAP ap (EmbedVP s) ; --%
@@ -1023,7 +1023,7 @@ incomplete resource Constructors = open Grammar in { --%
mkAP : Ord -> AP -- oldest
= AdjOrd ; --%
mkAP : CAdv -> AP -> NP -> AP -- as old as John
mkAP : CAdv -> AP -> NP -> AP -- as old as she
= CAdvAP ; --%
} ; --%
@@ -1048,12 +1048,12 @@ incomplete resource Constructors = open Grammar in { --%
-- Subordinate sentences are treated as adverbs.
mkAdv : Subj -> S -> Adv -- when John walks --:
mkAdv : Subj -> S -> Adv -- when she sleeps --:
= SubjS ; --%
-- An adjectival adverb can be compared to a noun phrase or a sentence.
mkAdv : CAdv -> A -> NP -> Adv -- more warmly than John --:
mkAdv : CAdv -> A -> NP -> Adv -- more warmly than she --:
= ComparAdvAdj ; --%
mkAdv : CAdv -> A -> S -> Adv -- more warmly than he runs --:
= ComparAdvAdjS ; --%
@@ -1098,7 +1098,7 @@ incomplete resource Constructors = open Grammar in { --%
= \t,p -> TUseQCl t ASimul p ; --%
mkQS : Ant -> Pol -> QCl -> QS --%
= \a,p -> TUseQCl TPres a p ; --%
mkQS : (Tense) -> (Ant) -> (Pol) -> QCl -> QS -- who wouldn't have walked
mkQS : (Tense) -> (Ant) -> (Pol) -> QCl -> QS -- who wouldn't have slept
= TUseQCl ; --%
-- Since 'yes-no' question clauses can be built from clauses (see below),
@@ -1117,7 +1117,7 @@ incomplete resource Constructors = open Grammar in { --%
-- 'Yes-no' question clauses are built from 'declarative' clauses.
mkQCl : Cl -> QCl -- does John walk --:
mkQCl : Cl -> QCl -- does she sleep --:
= QuestCl ; --%
-- 'Wh' questions are built from interrogative pronouns in subject
@@ -1126,29 +1126,29 @@ incomplete resource Constructors = open Grammar in { --%
-- 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 -- who walks --:
mkQCl : IP -> VP -> QCl -- who sleeps --:
= QuestVP ; --%
mkQCl : IP -> V -> QCl -- who walks
mkQCl : IP -> V -> QCl -- who sleeps
= \s,v -> QuestVP s (UseV v); --%
mkQCl : IP -> V2 -> NP -> QCl -- who loves her
= \s,v,o -> QuestVP s (ComplV2 v o); --%
mkQCl : IP -> V3 -> NP -> NP -> QCl -- who sends it to her
= \s,v,o,i -> QuestVP s (ComplV3 v o i); --%
mkQCl : IP -> VV -> VP -> QCl -- who wants to walk
mkQCl : IP -> VV -> VP -> QCl -- who wants to sleep
= \s,v,vp -> QuestVP s (ComplVV v vp) ; --%
mkQCl : IP -> VS -> S -> QCl -- who says that she walks
mkQCl : IP -> VS -> S -> QCl -- who says that she sleeps
= \s,v,p -> QuestVP s (ComplVS v p) ; --%
mkQCl : IP -> VQ -> QS -> QCl -- who wonders who walks
mkQCl : IP -> VQ -> QS -> QCl -- who wonders who sleeps
= \s,v,q -> QuestVP s (ComplVQ v q) ; --%
mkQCl : IP -> VA -> AP -> QCl -- who becomes old
= \s,v,q -> QuestVP s (ComplVA v q) ; --%
mkQCl : IP -> V2A -> NP -> AP -> QCl -- who paints it red
= \s,v,n,q -> QuestVP s (ComplV2A v n q) ; --%
mkQCl : IP -> V2S -> NP -> S -> QCl -- who tells her that we walk
mkQCl : IP -> V2S -> NP -> S -> QCl -- who tells her that we sleep
= \s,v,n,q -> QuestVP s (ComplSlash (SlashV2S v q) n) ; --%
mkQCl : IP -> V2Q -> NP -> QS -> QCl -- who asks her who walks
mkQCl : IP -> V2Q -> NP -> QS -> QCl -- who asks her who sleeps
= \s,v,n,q -> QuestVP s (ComplSlash (SlashV2Q v q) n) ; --%
mkQCl : IP -> V2V -> NP -> VP -> QCl -- who forces her to walk
mkQCl : IP -> V2V -> NP -> VP -> QCl -- who forces her to sleep
= \s,v,n,q -> QuestVP s (ComplSlash (SlashV2V v q) n) ; --%
mkQCl : IP -> A -> QCl -- who is old
= \x,y -> QuestVP x (UseComp (CompAP (PositA y))) ; --%
@@ -1166,22 +1166,22 @@ incomplete resource Constructors = open Grammar in { --%
= \x,y -> QuestVP x (UseComp (CompCN y)) ; --%
mkQCl : IP -> Adv -> QCl -- who is here
= \x,y -> QuestVP x (UseComp (CompAdv y)) ; --%
mkQCl : IP -> NP -> V2 -> QCl -- who does John love
mkQCl : IP -> NP -> V2 -> QCl -- who does she love
= \ip,np,v -> QuestSlash ip (SlashVP np (SlashV2a v)) ; --%
mkQCl : IP -> ClSlash -> QCl -- who does John today --:
mkQCl : IP -> ClSlash -> QCl -- who does she today --:
= QuestSlash ; --%
-- Adverbial 'wh' questions are built with interrogative adverbials, with the
-- special case of prepositional phrases with interrogative pronouns.
mkQCl : IAdv -> Cl -> QCl -- why does John walk --:
mkQCl : IAdv -> Cl -> QCl -- why does she sleep --:
= QuestIAdv ; --%
mkQCl : Prep -> IP -> Cl -> QCl -- with whom does John walk
mkQCl : Prep -> IP -> Cl -> QCl -- with whom does she sleep
= \p,ip -> QuestIAdv (PrepIP p ip) ; --%
-- An interrogative adverbial can serve as the complement of a copula.
mkQCl : IAdv -> NP -> QCl -- where is John
mkQCl : IAdv -> NP -> QCl -- where is she
= \a -> QuestIComp (CompIAdv a) ; --%
-- Asking about a known subject.
@@ -1289,11 +1289,11 @@ incomplete resource Constructors = open Grammar in { --%
= \t,p -> TUseRCl t ASimul p ; --%
mkRS : Ant -> Pol -> RCl -> RS --%
= \a,p -> TUseRCl TPres a p ; --%
mkRS : (Tense) -> (Ant) -> (Pol) -> RCl -> RS -- that wouldn't have walked
mkRS : (Tense) -> (Ant) -> (Pol) -> RCl -> RS -- that wouldn't have slept
= TUseRCl ; --%
mkRS : Conj -> RS -> RS -> RS -- who walks and whose mother runsx
mkRS : Conj -> RS -> RS -> RS -- who sleeps and whose mother runsx
= \c,x,y -> ConjRS c (BaseRS x y) ; --%
mkRS : Conj -> ListRS -> RS -- who walks, whom I see and who sleeps --:
mkRS : Conj -> ListRS -> RS -- who sleeps, whom I see and who sleeps --:
= \c,xy -> ConjRS c xy ; --%
} ; --%
@@ -1307,17 +1307,17 @@ incomplete resource Constructors = open Grammar in { --%
-- 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 -- that loves John --:
mkRCl : RP -> VP -> RCl -- that loves she --:
= RelVP ; --%
mkRCl : RP -> ClSlash -> RCl -- whom John loves today --:
mkRCl : RP -> ClSlash -> RCl -- whom she loves today --:
= RelSlash ; --%
mkRCl : RP -> NP -> V2 -> RCl -- whom John loves
mkRCl : RP -> NP -> V2 -> RCl -- whom she loves
= \rp,np,v2 -> RelSlash rp (SlashVP np (SlashV2a v2)) ; --%
-- There is a simple 'such that' construction for forming relative
-- clauses from clauses.
mkRCl : Cl -> RCl -- such that John loves her
mkRCl : Cl -> RCl -- such that she loves him
= RelCl ; --%
} ; --%
@@ -1361,7 +1361,7 @@ incomplete resource Constructors = open Grammar in { --%
-- The missing object can also be the noun phrase in a prepositional phrase.
mkClSlash : Cl -> Prep -> ClSlash -- (with whom) he walks --:
mkClSlash : Cl -> Prep -> ClSlash -- (with whom) he sleeps --:
= SlashPrep ; --%
-- An objectless sentence can be modified by an adverb.
@@ -1383,17 +1383,17 @@ incomplete resource Constructors = open Grammar in { --%
-- This is the deep level of many-argument predication, permitting extraction.
mkVPSlash : V2 -> VPSlash -- (whom) (John) loves --:
mkVPSlash : V2 -> VPSlash -- (whom) (she) loves --:
= SlashV2a ; --%
mkVPSlash : V3 -> NP -> VPSlash -- (whom) (John) gives an apple --:
mkVPSlash : V3 -> NP -> VPSlash -- (whom) (she) gives an apple --:
= Slash2V3 ; --%
mkVPSlash : V2A -> AP -> VPSlash -- (whom) (John) paints red --:
mkVPSlash : V2A -> AP -> VPSlash -- (whom) (she) paints red --:
= SlashV2A ; --%
mkVPSlash : V2Q -> QS -> VPSlash -- (whom) (John) asks who sleeps --:
mkVPSlash : V2Q -> QS -> VPSlash -- (whom) (she) asks who sleeps --:
= SlashV2Q ; --%
mkVPSlash : V2S -> S -> VPSlash -- (whom) (John) tells that we sleep --:
mkVPSlash : V2S -> S -> VPSlash -- (whom) (she) tells that we sleep --:
= SlashV2S ; --%
mkVPSlash : V2V -> VP -> VPSlash -- (whom) (John) forces to sleep --:
mkVPSlash : V2V -> VP -> VPSlash -- (whom) (she) forces to sleep --:
= SlashV2V ; --%
mkVPSlash : VV -> VPSlash -> VPSlash -- want always to buy --:
= SlashVV ; --%
@@ -1687,4 +1687,8 @@ oper
n1000_Numeral : Numeral
= num (pot3 (pot1as2 (pot0as1 pot01))) ; --%
-- for testing
she_NP : NP = mkNP she_Pron ;
}

1
src/compiler/GF/Command/Commands.hs
View File

@@ -216,6 +216,7 @@ allCommands env@(pgf, mos) = Map.fromList [
],
options = [
("all","pick all strings (forms and variants) from records and tables"),
("one","pick the first strings, if there is any, from records and tables"),
("table","show all strings labelled by parameters"),
("unqual","hide qualifying module names")
],

2
src/compiler/GF/Grammar/ShowTerm.hs
View File

@@ -13,6 +13,7 @@ showTerm gr style q t = render $
case style of
TermPrintTable -> vcat [p <+> s | (p,s) <- ppTermTabular gr q t]
TermPrintAll -> vcat [ s | (p,s) <- ppTermTabular gr q t]
TermPrintOne -> vcat [ s | (p,s) <- take 1 (ppTermTabular gr q t)]
TermPrintDefault -> ppTerm q 0 t
ppTermTabular :: SourceGrammar -> TermPrintQual -> Term -> [(Doc,Doc)]
@@ -37,4 +38,5 @@ ppTermTabular gr q = pr where
data TermPrintStyle
= TermPrintTable
| TermPrintAll
| TermPrintOne
| TermPrintDefault

1
src/compiler/GFI.hs
View File

@@ -111,6 +111,7 @@ loop opts gfenv0 = do
let
pOpts style q ("-table" :ws) = pOpts TermPrintTable q ws
pOpts style q ("-all" :ws) = pOpts TermPrintAll q ws
pOpts style q ("-one" :ws) = pOpts TermPrintOne q ws
pOpts style q ("-default":ws) = pOpts TermPrintDefault q ws
pOpts style q ("-unqual" :ws) = pOpts style Unqualified ws
pOpts style q ("-qual" :ws) = pOpts style Qualified ws