mirror of
https://github.com/GrammaticalFramework/gf-core.git
synced 2026-04-13 14:59:32 -06:00
619 lines
29 KiB
Plaintext
619 lines
29 KiB
Plaintext
|
|
mkAP = overload {
|
|
mkAP : A -> AP -- warm
|
|
= PositA ;
|
|
mkAP : A -> NP -> AP -- warmer than Spain
|
|
= ComparA ;
|
|
mkAP : A2 -> NP -> AP -- divisible by 2
|
|
= ComplA2 ;
|
|
mkAP : A2 -> AP -- divisible by itself
|
|
= ReflA2 ;
|
|
mkAP : AP -> S -> AP -- great that she won
|
|
= \ap,s -> SentAP ap (EmbedS s) ;
|
|
mkAP : AP -> QS -> AP -- great that she won
|
|
= \ap,s -> SentAP ap (EmbedQS s) ;
|
|
mkAP : AP -> VP -> AP -- great that she won
|
|
= \ap,s -> SentAP ap (EmbedVP s) ;
|
|
mkAP : AdA -> A -> AP -- very uncertain
|
|
= \x,y -> AdAP x (PositA y) ;
|
|
mkAP : AdA -> AP -> AP -- very uncertain
|
|
= AdAP ;
|
|
mkAP : Conj -> AP -> AP -> AP
|
|
= \c,x,y -> ConjAP c (BaseAP x y) ;
|
|
mkAP : DConj -> AP -> AP -> AP
|
|
= \c,x,y -> DConjAP c (BaseAP x y) ;
|
|
mkAP : Conj -> ListAP -> AP
|
|
= \c,xy -> ConjAP c xy ;
|
|
mkAP : DConj -> ListAP -> AP
|
|
= \c,xy -> DConjAP c xy
|
|
|
|
} ;
|
|
|
|
mkAdv = overload {
|
|
mkAdv : A -> Adv -- quickly
|
|
= PositAdvAdj ;
|
|
mkAdv : Prep -> NP -> Adv -- in the house
|
|
= PrepNP ;
|
|
mkAdv : CAdv -> A -> NP -> Adv -- more quickly than John
|
|
= ComparAdvAdj ;
|
|
mkAdv : CAdv -> A -> S -> Adv -- more quickly than he runs
|
|
= ComparAdvAdjS ;
|
|
mkAdv : AdA -> Adv -> Adv -- very quickly
|
|
= AdAdv ;
|
|
mkAdv : Subj -> S -> Adv -- when he arrives
|
|
= SubjS ;
|
|
mkAdv : Conj -> Adv -> Adv -> Adv
|
|
= \c,x,y -> ConjAdv c (BaseAdv x y) ;
|
|
mkAdv : DConj -> Adv -> Adv -> Adv
|
|
= \c,x,y -> DConjAdv c (BaseAdv x y) ;
|
|
mkAdv : Conj -> ListAdv -> Adv
|
|
= \c,xy -> ConjAdv c xy ;
|
|
mkAdv : DConj -> ListAdv -> Adv
|
|
= \c,xy -> DConjAdv c xy
|
|
|
|
} ;
|
|
|
|
mkCl = overload {
|
|
mkCl : NP -> VP -> Cl -- John wants to walk walks
|
|
= PredVP ;
|
|
mkCl : NP -> V -> Cl -- John walks
|
|
= \s,v -> PredVP s (UseV v) ;
|
|
mkCl : NP -> V2 -> NP -> Cl -- John uses it
|
|
= \s,v,o -> PredVP s (ComplV2 v o) ;
|
|
mkCl : NP -> V3 -> NP -> NP -> Cl
|
|
= \s,v,o,i -> PredVP s (ComplV3 v o i) ;
|
|
|
|
mkCl : NP -> VV -> VP -> Cl = \s,v,vp -> PredVP s (ComplVV v vp) ;
|
|
mkCl : NP -> VS -> S -> Cl = \s,v,p -> PredVP s (ComplVS v p) ;
|
|
mkCl : NP -> VQ -> QS -> Cl = \s,v,q -> PredVP s (ComplVQ v q) ;
|
|
mkCl : NP -> VA -> AP -> Cl = \s,v,q -> PredVP s (ComplVA v q) ;
|
|
mkCl : NP -> V2A ->NP -> AP -> Cl = \s,v,n,q -> PredVP s (ComplV2A v n q) ;
|
|
|
|
|
|
|
|
mkCl : VP -> Cl -- it rains
|
|
= ImpersCl ;
|
|
mkCl : NP -> RS -> Cl -- it is you who did it
|
|
= CleftNP ;
|
|
mkCl : Adv -> S -> Cl -- it is yesterday she arrived
|
|
= CleftAdv ;
|
|
mkCl : N -> Cl -- there is a house
|
|
= \y -> ExistNP (DetCN (DetSg (SgQuant IndefArt) NoOrd) (UseN y)) ;
|
|
mkCl : CN -> Cl -- there is a house
|
|
= \y -> ExistNP (DetCN (DetSg (SgQuant IndefArt) NoOrd) y) ;
|
|
mkCl : NP -> Cl -- there is a house
|
|
= ExistNP ;
|
|
mkCl : NP -> AP -> Cl -- John is nice and warm
|
|
= \x,y -> PredVP x (UseComp (CompAP y)) ;
|
|
mkCl : NP -> A -> Cl -- John is warm
|
|
= \x,y -> PredVP x (UseComp (CompAP (PositA y))) ;
|
|
mkCl : NP -> A -> NP -> Cl -- John is warmer than Mary
|
|
= \x,y,z -> PredVP x (UseComp (CompAP (ComparA y z))) ;
|
|
mkCl : NP -> A2 -> NP -> Cl -- John is married to Mary
|
|
= \x,y,z -> PredVP x (UseComp (CompAP (ComplA2 y z))) ;
|
|
mkCl : NP -> NP -> Cl -- John is the man
|
|
= \x,y -> PredVP x (UseComp (CompNP y)) ;
|
|
mkCl : NP -> CN -> Cl -- John is a man
|
|
= \x,y -> PredVP x (UseComp (CompNP (DetCN (DetSg (SgQuant IndefArt) NoOrd) y))) ;
|
|
mkCl : NP -> N -> Cl -- John is a man
|
|
= \x,y -> PredVP x (UseComp (CompNP (DetCN (DetSg (SgQuant IndefArt) NoOrd) (UseN y)))) ;
|
|
mkCl : NP -> Adv -> Cl -- John is here
|
|
= \x,y -> PredVP x (UseComp (CompAdv y)) ;
|
|
mkCl : V -> Cl -- it rains
|
|
= \v -> ImpersCl (UseV v)
|
|
} ;
|
|
|
|
genericCl : VP -> Cl = GenericCl ;
|
|
|
|
mkNP = overload {
|
|
mkNP : Det -> CN -> NP -- the old man
|
|
= DetCN ;
|
|
mkNP : Det -> N -> NP -- the man
|
|
= \d,n -> DetCN d (UseN n) ;
|
|
mkNP : Num -> CN -> NP -- forty-five old men
|
|
= \d,n -> DetCN (DetPl (PlQuant IndefArt) d NoOrd) n ;
|
|
mkNP : Num -> N -> NP -- forty-five men
|
|
= \d,n -> DetCN (DetPl (PlQuant IndefArt) d NoOrd) (UseN n) ;
|
|
|
|
mkNP : QuantSg -> CN -> NP = \q,n -> DetCN (DetSg q NoOrd) n ;
|
|
mkNP : QuantSg -> N -> NP = \q,n -> DetCN (DetSg q NoOrd) (UseN n) ;
|
|
mkNP : QuantPl -> CN -> NP = \q,n -> DetCN (DetPl q NoNum NoOrd) n ;
|
|
mkNP : QuantPl -> N -> NP = \q,n -> DetCN (DetPl q NoNum NoOrd) (UseN n) ;
|
|
|
|
mkNP : Pron -> CN -> NP = \p,n -> DetCN (DetSg (SgQuant (PossPron p)) NoOrd) n ;
|
|
mkNP : Pron -> N -> NP = \p,n -> DetCN (DetSg (SgQuant (PossPron p)) NoOrd) (UseN n) ;
|
|
|
|
mkNP : Numeral -> CN -> NP -- 51 old men
|
|
= \d,n -> DetCN (DetPl (PlQuant IndefArt) (NumNumeral d) NoOrd) n ;
|
|
mkNP : Numeral -> N -> NP -- 51 men
|
|
= \d,n -> DetCN (DetPl (PlQuant IndefArt) (NumNumeral d) NoOrd) (UseN n) ;
|
|
mkNP : Int -> CN -> NP -- 51 old men
|
|
= \d,n -> DetCN (DetPl (PlQuant IndefArt) (NumInt d) NoOrd) n ;
|
|
mkNP : Int -> N -> NP -- 51 men
|
|
= \d,n -> DetCN (DetPl (PlQuant IndefArt) (NumInt d) NoOrd) (UseN n) ;
|
|
|
|
|
|
mkNP : PN -> NP -- John
|
|
= UsePN ;
|
|
mkNP : Pron -> NP -- he
|
|
= UsePron ;
|
|
mkNP : Predet -> NP -> NP -- only the man
|
|
= PredetNP ;
|
|
mkNP : NP -> V2 -> NP -- the number squared
|
|
= PPartNP ;
|
|
mkNP : NP -> Adv -> NP -- Paris at midnight
|
|
= AdvNP ;
|
|
mkNP : Conj -> NP -> NP -> NP
|
|
= \c,x,y -> ConjNP c (BaseNP x y) ;
|
|
mkNP : DConj -> NP -> NP -> NP
|
|
= \c,x,y -> DConjNP c (BaseNP x y) ;
|
|
mkNP : Conj -> ListNP -> NP
|
|
= \c,xy -> ConjNP c xy ;
|
|
mkNP : DConj -> ListNP -> NP
|
|
= \c,xy -> DConjNP c xy
|
|
} ;
|
|
|
|
mkDet = overload {
|
|
mkDet : QuantSg -> Ord -> Det -- this best man
|
|
= DetSg ;
|
|
mkDet : QuantSg -> Det -- this man
|
|
= \q -> DetSg q NoOrd ;
|
|
mkDet : QuantPl -> Num -> Ord -> Det -- these five best men
|
|
= DetPl ;
|
|
mkDet : QuantPl -> Det -- these men
|
|
= \q -> DetPl q NoNum NoOrd ;
|
|
mkDet : Quant -> Det -- this man
|
|
= \q -> DetSg (SgQuant q) NoOrd ;
|
|
mkDet : Quant -> Num -> Det -- these five man
|
|
= \q,nu -> DetPl (PlQuant q) nu NoOrd ;
|
|
mkDet : Num -> Det -- forty-five men
|
|
= \n -> DetPl (PlQuant IndefArt) n NoOrd ;
|
|
mkDet : Int -> Det -- 51 (men)
|
|
= \n -> DetPl (PlQuant IndefArt) (NumInt n) NoOrd ;
|
|
mkDet : Numeral -> Det --
|
|
= \d -> DetPl (PlQuant IndefArt) (NumNumeral d) NoOrd ;
|
|
|
|
mkDet : Pron -> Det -- my (house)
|
|
= \p -> DetSg (SgQuant (PossPron p)) NoOrd
|
|
} ;
|
|
|
|
|
|
defSgDet : Det = DetSg (SgQuant DefArt) NoOrd ; -- the (man)
|
|
defPlDet : Det = DetPl (PlQuant DefArt) NoNum NoOrd ; -- the (man)
|
|
indefSgDet : Det = DetSg (SgQuant IndefArt) NoOrd ; -- the (man)
|
|
indefPlDet : Det = DetPl (PlQuant IndefArt) NoNum NoOrd ; -- the (man)
|
|
|
|
|
|
mkQuantSg : Quant -> QuantSg = SgQuant ;
|
|
mkQuantPl : Quant -> QuantPl = PlQuant ;
|
|
|
|
defQuant : Quant = DefArt ;
|
|
indefQuant : Quant = IndefArt ;
|
|
|
|
massQuant : QuantSg = MassDet ;
|
|
|
|
|
|
|
|
mkNum = overload {
|
|
mkNum : Numeral -> Num = NumNumeral ;
|
|
mkNum : Int -> Num -- 51
|
|
= NumInt ;
|
|
mkNum : Digit -> Num
|
|
= \d -> NumNumeral (num (pot2as3 (pot1as2 (pot0as1 (pot0 d))))) ;
|
|
|
|
mkNum : AdN -> Num -> Num = AdNum
|
|
} ;
|
|
|
|
noNum : Num -- [no num]
|
|
= NoNum ;
|
|
|
|
n1_Numeral : Numeral = num (pot2as3 (pot1as2 (pot0as1 pot01))) ;
|
|
n2_Numeral : Numeral = num (pot2as3 (pot1as2 (pot0as1 (pot0 n2)))) ;
|
|
n3_Numeral : Numeral = num (pot2as3 (pot1as2 (pot0as1 (pot0 n3)))) ;
|
|
n4_Numeral : Numeral = num (pot2as3 (pot1as2 (pot0as1 (pot0 n4)))) ;
|
|
n5_Numeral : Numeral = num (pot2as3 (pot1as2 (pot0as1 (pot0 n5)))) ;
|
|
n6_Numeral : Numeral = num (pot2as3 (pot1as2 (pot0as1 (pot0 n6)))) ;
|
|
n7_Numeral : Numeral = num (pot2as3 (pot1as2 (pot0as1 (pot0 n7)))) ;
|
|
n8_Numeral : Numeral = num (pot2as3 (pot1as2 (pot0as1 (pot0 n8)))) ;
|
|
n9_Numeral : Numeral = num (pot2as3 (pot1as2 (pot0as1 (pot0 n9)))) ;
|
|
n10_Numeral : Numeral = num (pot2as3 (pot1as2 pot110)) ;
|
|
n20_Numeral : Numeral = num (pot2as3 (pot1as2 (pot1 n2))) ;
|
|
n100_Numeral : Numeral = num (pot2as3 (pot2 pot01)) ;
|
|
n1000_Numeral : Numeral = num (pot3 (pot1as2 (pot0as1 pot01))) ;
|
|
|
|
|
|
mkAdN : CAdv -> AdN = AdnCAdv ; -- more (than five)
|
|
|
|
mkOrd = overload {
|
|
mkOrd : Numeral -> Ord = OrdNumeral ;
|
|
mkOrd : Int -> Ord -- 51st
|
|
= OrdInt ;
|
|
mkOrd : Digit -> Ord -- fifth
|
|
= \d -> OrdNumeral (num (pot2as3 (pot1as2 (pot0as1 (pot0 d))))) ;
|
|
mkOrd : A -> Ord -- largest
|
|
= OrdSuperl
|
|
} ;
|
|
|
|
noOrd : Ord -- [no ord]
|
|
= NoOrd ;
|
|
|
|
|
|
mkCN = overload {
|
|
mkCN : N -> CN -- house
|
|
= UseN ;
|
|
mkCN : N2 -> NP -> CN -- son of the king
|
|
= ComplN2 ;
|
|
mkCN : N3 -> NP -> NP -> CN -- flight from Moscow (to Paris)
|
|
= \f,x -> ComplN2 (ComplN3 f x) ;
|
|
mkCN : N2 -> CN -- son
|
|
= UseN2 ;
|
|
mkCN : N3 -> CN -- flight
|
|
= UseN3 ;
|
|
mkCN : AP -> CN -> CN -- nice and big blue house
|
|
= AdjCN ;
|
|
mkCN : AP -> N -> CN -- nice and big house
|
|
= \x,y -> AdjCN x (UseN y) ;
|
|
mkCN : CN -> AP -> CN -- nice and big blue house
|
|
= \x,y -> AdjCN y x ;
|
|
mkCN : N -> AP -> CN -- nice and big house
|
|
= \x,y -> AdjCN y (UseN x) ;
|
|
mkCN : A -> CN -> CN -- big blue house
|
|
= \x,y -> AdjCN (PositA x) y ;
|
|
mkCN : A -> N -> CN -- big house
|
|
= \x,y -> AdjCN (PositA x) (UseN y) ;
|
|
mkCN : CN -> RS -> CN -- house that John owns
|
|
= RelCN ;
|
|
mkCN : N -> RS -> CN -- house that John owns
|
|
= \x,y -> RelCN (UseN x) y ;
|
|
mkCN : CN -> Adv -> CN -- house on the hill
|
|
= AdvCN ;
|
|
mkCN : N -> Adv -> CN -- house on the hill
|
|
= \x,y -> AdvCN (UseN x) y ;
|
|
mkCN : CN -> S -> CN -- fact that John smokes
|
|
= \cn,s -> SentCN cn (EmbedS s) ;
|
|
mkCN : CN -> QS -> CN -- question if John smokes
|
|
= \cn,s -> SentCN cn (EmbedQS s) ;
|
|
mkCN : CN -> VP -> CN -- reason to smoke
|
|
= \cn,s -> SentCN cn (EmbedVP s) ;
|
|
mkCN : CN -> NP -> CN -- number x, numbers x and y
|
|
= ApposCN ;
|
|
mkCN : N -> NP -> CN -- number x, numbers x and y
|
|
= \x,y -> ApposCN (UseN x) y
|
|
} ;
|
|
|
|
|
|
mkPhr = overload {
|
|
mkPhr : PConj -> Utt -> Voc -> Phr -- But go home my friend
|
|
= PhrUtt ;
|
|
mkPhr : Utt -> Voc -> Phr
|
|
= \u,v -> PhrUtt NoPConj u v ;
|
|
mkPhr : PConj -> Utt -> Phr
|
|
= \u,v -> PhrUtt u v NoVoc ;
|
|
mkPhr : Utt -> Phr -- Go home
|
|
= \u -> PhrUtt NoPConj u NoVoc ;
|
|
mkPhr : S -> Phr -- I go home
|
|
= \s -> PhrUtt NoPConj (UttS s) NoVoc ;
|
|
mkPhr : Cl -> Phr -- I go home
|
|
= \s -> PhrUtt NoPConj (UttS (UseCl TPres ASimul PPos s)) NoVoc ;
|
|
mkPhr : QS -> Phr -- I go home
|
|
= \s -> PhrUtt NoPConj (UttQS s) NoVoc ;
|
|
mkPhr : Imp -> Phr -- I go home
|
|
= \s -> PhrUtt NoPConj (UttImpSg PPos s) NoVoc
|
|
|
|
} ;
|
|
|
|
mkPConj : Conj -> PConj = PConjConj ;
|
|
noPConj : PConj = NoPConj ;
|
|
|
|
mkVoc : NP -> Voc = VocNP ;
|
|
noVoc : Voc = NoVoc ;
|
|
|
|
positivePol : Pol = PPos ;
|
|
negativePol : Pol = PNeg ;
|
|
|
|
simultaneousAnt : Ant = ASimul ;
|
|
anteriorAnt : Ant = AAnter ; --# notpresent
|
|
|
|
presentTense : Tense = TPres ;
|
|
pastTense : Tense = TPast ; --# notpresent
|
|
futureTense : Tense = TFut ; --# notpresent
|
|
conditionalTense : Tense = TCond ; --# notpresent
|
|
|
|
singularImpForm : ImpForm
|
|
= {p= IFSg; s= []} ;
|
|
pluralImpForm : ImpForm
|
|
= {p= IFPl; s= []} ;
|
|
politeImpForm : ImpForm
|
|
= {p= IFPol; s= []} ;
|
|
|
|
-- mkUttImp : ImpForm -> Pol -> Imp -> Utt = \f,p,i -> case f of {
|
|
IFSg => UttImpSg p i ;
|
|
IFPl => UttImpPl p i ;
|
|
IFPol => UttImpPol p i
|
|
} ;
|
|
|
|
mkUtt = overload {
|
|
mkUtt : S -> Utt -- John walked
|
|
= UttS ;
|
|
mkUtt : Cl -> Utt -- John walks
|
|
= \c -> UttS (UseCl TPres ASimul PPos c) ;
|
|
mkUtt : QS -> Utt -- is it good
|
|
= UttQS
|
|
mkUtt : ImpForm -> Pol -> Imp -> Utt -- don't help yourselves
|
|
= \f -> mkUttImp f.p f.s ;
|
|
mkUtt : ImpForm -> Imp -> Utt -- help yourselves
|
|
= \f -> mkUttImp f.p f.s PPos ;
|
|
mkUtt : Pol -> Imp -> Utt -- (don't) help yourself
|
|
= UttImpSg ;
|
|
mkUtt : Imp -> Utt -- help yourself
|
|
= UttImpSg PPos ;
|
|
mkUtt : IP -> Utt -- who
|
|
= UttIP ;
|
|
mkUtt : IAdv -> Utt -- why
|
|
= UttIAdv ;
|
|
mkUtt : NP -> Utt -- this man
|
|
= UttNP ;
|
|
mkUtt : Adv -> Utt -- here
|
|
= UttAdv ;
|
|
mkUtt : VP -> Utt -- to sleep
|
|
= UttVP
|
|
} ;
|
|
|
|
lets_Utt : VP -> Utt = ImpPl1 ;
|
|
|
|
mkQCl = overload {
|
|
|
|
mkQCl : Cl -> QCl -- does John walk
|
|
= QuestCl ;
|
|
mkQCl : IP -> VP -> QCl -- who walks
|
|
= QuestVP ;
|
|
mkQCl : IP -> Slash -> QCl -- who does John love
|
|
= QuestSlash ;
|
|
mkQCl : IP -> NP -> V2 -> QCl -- who does John love
|
|
= \ip,np,v -> QuestSlash ip (SlashV2 np v) ;
|
|
mkQCl : IAdv -> Cl -> QCl -- why does John walk
|
|
= QuestIAdv ;
|
|
mkQCl : Prep -> IP -> Cl -> QCl -- with whom does John walk
|
|
= \p,ip -> QuestIAdv (PrepIP p ip) ;
|
|
mkQCl : IAdv -> NP -> QCl -- where is John
|
|
= \a -> QuestIComp (CompIAdv a) ;
|
|
mkQCl : IP -> QCl -- which houses are there
|
|
= ExistIP
|
|
|
|
} ;
|
|
|
|
mkIP = overload {
|
|
mkIP : IDet -> Num -> Ord -> CN -> IP -- which five best songs
|
|
= IDetCN ;
|
|
mkIP : IDet -> Ord -> CN -> IP -- which five best songs
|
|
= \i -> IDetCN i NoNum ;
|
|
mkIP : IDet -> Num -> CN -> IP -- which five best songs
|
|
= \i,n -> IDetCN i n NoOrd ;
|
|
mkIP : IDet -> N -> IP -- which song
|
|
= \i,n -> IDetCN i NoNum NoOrd (UseN n) ;
|
|
mkIP : IP -> Adv -> IP -- who in Europe
|
|
= AdvIP
|
|
} ;
|
|
|
|
mkIAdv : Prep -> IP -> IAdv = PrepIP ;
|
|
|
|
mkRCl = overload {
|
|
mkRCl : Cl -> RCl -- such that John loves her
|
|
= RelCl ;
|
|
mkRCl : RP -> VP -> RCl -- who loves John
|
|
= RelVP ;
|
|
mkRCl : RP -> Slash -> RCl -- whom John loves
|
|
= RelSlash ;
|
|
mkRCl : RP -> NP -> V2 -> RCl -- whom John loves
|
|
= \rp,np,v2 -> RelSlash rp (SlashV2 np v2)
|
|
} ;
|
|
|
|
which_RP : RP -- which
|
|
= IdRP ;
|
|
mkRP : Prep -> NP -> RP -> RP -- all the roots of which
|
|
= FunRP
|
|
;
|
|
|
|
mkSlash = overload {
|
|
mkSlash : NP -> V2 -> Slash -- (whom) he sees
|
|
= SlashV2 ;
|
|
mkSlash : NP -> VV -> V2 -> Slash -- (whom) he wants to see
|
|
= SlashVVV2 ;
|
|
mkSlash : Slash -> Adv -> Slash -- (whom) he sees tomorrow
|
|
= AdvSlash ;
|
|
mkSlash : Cl -> Prep -> Slash -- (with whom) he walks
|
|
= SlashPrep
|
|
} ;
|
|
|
|
mkImp = overload {
|
|
mkImp : VP -> Imp -- go
|
|
= ImpVP ;
|
|
mkImp : V -> Imp
|
|
= \v -> ImpVP (UseV v) ;
|
|
mkImp : V2 -> NP -> Imp
|
|
= \v,np -> ImpVP (ComplV2 v np)
|
|
} ;
|
|
|
|
mkS = overload {
|
|
mkS : Cl -> S
|
|
= UseCl TPres ASimul PPos ;
|
|
mkS : Tense -> Cl -> S
|
|
= \t -> UseCl t ASimul PPos ;
|
|
mkS : Ant -> Cl -> S
|
|
= \a -> UseCl TPres a PPos ;
|
|
mkS : Pol -> Cl -> S
|
|
= \p -> UseCl TPres ASimul p ;
|
|
mkS : Tense -> Ant -> Cl -> S
|
|
= \t,a -> UseCl t a PPos ;
|
|
mkS : Tense -> Pol -> Cl -> S
|
|
= \t,p -> UseCl t ASimul p ;
|
|
mkS : Ant -> Pol -> Cl -> S
|
|
= \a,p -> UseCl TPres a p ;
|
|
mkS : Tense -> Ant -> Pol -> Cl -> S
|
|
= UseCl ;
|
|
mkS : Conj -> S -> S -> S
|
|
= \c,x,y -> ConjS c (BaseS x y) ;
|
|
mkS : DConj -> S -> S -> S
|
|
= \c,x,y -> DConjS c (BaseS x y) ;
|
|
mkS : Conj -> ListS -> S
|
|
= \c,xy -> ConjS c xy ;
|
|
mkS : DConj -> ListS -> S
|
|
= \c,xy -> DConjS c xy ;
|
|
mkS : Adv -> S -> S
|
|
= AdvS
|
|
|
|
} ;
|
|
|
|
mkQS = overload {
|
|
|
|
mkQS : QCl -> QS
|
|
= UseQCl TPres ASimul PPos ;
|
|
mkQS : Tense -> QCl -> QS
|
|
= \t -> UseQCl t ASimul PPos ;
|
|
mkQS : Ant -> QCl -> QS
|
|
= \a -> UseQCl TPres a PPos ;
|
|
mkQS : Pol -> QCl -> QS
|
|
= \p -> UseQCl TPres ASimul p ;
|
|
mkQS : Tense -> Ant -> QCl -> QS
|
|
= \t,a -> UseQCl t a PPos ;
|
|
mkQS : Tense -> Pol -> QCl -> QS
|
|
= \t,p -> UseQCl t ASimul p ;
|
|
mkQS : Ant -> Pol -> QCl -> QS
|
|
= \a,p -> UseQCl TPres a p ;
|
|
mkQS : Tense -> Ant -> Pol -> QCl -> QS
|
|
= UseQCl ;
|
|
mkQS : Cl -> QS
|
|
= \x -> UseQCl TPres ASimul PPos (QuestCl x)
|
|
} ;
|
|
|
|
|
|
mkRS = overload {
|
|
|
|
mkRS : RCl -> RS
|
|
= UseRCl TPres ASimul PPos ;
|
|
mkRS : Tense -> RCl -> RS
|
|
= \t,c -> UseRCl t ASimul PPos c ;
|
|
mkRS : Ant -> RCl -> RS
|
|
= \a,c -> UseRCl TPres a PPos c ;
|
|
mkRS : Pol -> RCl -> RS
|
|
= \p,c -> UseRCl TPres ASimul p c ;
|
|
mkRS : Tense -> Ant -> RCl -> RS
|
|
= \t,a,c -> UseRCl t a PPos c ;
|
|
mkRS : Tense -> Pol -> RCl -> RS
|
|
= \t,p,c -> UseRCl t ASimul p c ;
|
|
mkRS : Ant -> Pol -> RCl -> RS
|
|
= \a,p,c -> UseRCl TPres a p c ;
|
|
mkRS : Tense -> Ant -> Pol -> RCl -> RS
|
|
= UseRCl
|
|
} ;
|
|
|
|
|
|
|
|
oper
|
|
emptyText : Text = TEmpty ; -- [empty text]
|
|
|
|
fullStopPunct : Punct
|
|
= {p= PFullStop; s= []} ; -- .
|
|
questMarkPunct : Punct
|
|
= {p= PQuestMark; s= []} ; -- .
|
|
exclMarkPunct : Punct
|
|
= {p= PExclMark; s= []} ; -- .
|
|
|
|
-- lincat Impform = {p : PImpForm ; s : Str} ;
|
|
-- lincat Punct = {p : PPunct ; s : Str} ;
|
|
-- param PImpForm = IFSg | IFPl | IFPol ;
|
|
-- param PPunct = PFullStop | PExclMark | PQuestMark ;
|
|
|
|
mkText = overload {
|
|
mkText : Phr -> Punct -> Text -> Text
|
|
= \p,f -> mkPhrPunct p f.p f.s ;
|
|
mkText : Phr -> Punct -> Text
|
|
= \p,f -> mkPhrPunct p f.p f.s TEmpty ;
|
|
mkText : Phr -> Text -- John walks.
|
|
= \x -> TFullStop x TEmpty ;
|
|
mkText : Utt -> Text
|
|
= \u -> TFullStop (PhrUtt NoPConj u NoVoc) TEmpty ;
|
|
mkText : S -> Text
|
|
= \s -> TFullStop (PhrUtt NoPConj (UttS s) NoVoc) TEmpty ;
|
|
mkText : Cl -> Text
|
|
= \c -> TFullStop (PhrUtt NoPConj (UttS (UseCl TPres ASimul PPos c)) NoVoc) TEmpty ;
|
|
mkText : QS -> Text
|
|
= \q -> TQuestMark (PhrUtt NoPConj (UttQS q) NoVoc) TEmpty ;
|
|
mkText : Imp -> Text
|
|
= \i -> TExclMark (PhrUtt NoPConj (UttImpSg PPos i) NoVoc) TEmpty ;
|
|
mkText : Pol -> Imp -> Text
|
|
= \p,i -> TExclMark (PhrUtt NoPConj (UttImpSg p i) NoVoc) TEmpty ;
|
|
mkText : Phr -> Text -> Text -- John walks. ...
|
|
= TFullStop
|
|
} ;
|
|
|
|
mkVP = overload {
|
|
mkVP : V -> VP -- sleep
|
|
= UseV ;
|
|
mkVP : V2 -> NP -> VP -- use it
|
|
= ComplV2 ;
|
|
mkVP : V3 -> NP -> NP -> VP -- send a message to her
|
|
= ComplV3 ;
|
|
mkVP : VV -> VP -> VP -- want to run
|
|
= ComplVV ;
|
|
mkVP : VS -> S -> VP -- know that she runs
|
|
= ComplVS ;
|
|
mkVP : VQ -> QS -> VP -- ask if she runs
|
|
= ComplVQ ;
|
|
--- mkVP : VS -> NP -> VP = \v -> ComplV2 (UseVS v) ;
|
|
--- mkVP : VQ -> NP -> VP = \v -> ComplV2 (UseVQ v) ;
|
|
mkVP : VA -> AP -> VP -- look red
|
|
= ComplVA ;
|
|
mkVP : V2A -> NP -> AP -> VP -- paint the house red
|
|
= ComplV2A ;
|
|
mkVP : A -> VP -- be warm
|
|
= \a -> UseComp (CompAP (PositA a)) ;
|
|
mkVP : A -> NP -> VP -- John is warmer than Mary
|
|
= \y,z -> (UseComp (CompAP (ComparA y z))) ;
|
|
mkVP : A2 -> NP -> VP -- John is married to Mary
|
|
= \y,z -> (UseComp (CompAP (ComplA2 y z))) ;
|
|
mkVP : AP -> VP -- be warm
|
|
= \a -> UseComp (CompAP a) ;
|
|
mkVP : NP -> VP -- be a man
|
|
= \a -> UseComp (CompNP a) ;
|
|
mkVP : CN -> VP -- be a man
|
|
= \y -> (UseComp (CompNP (DetCN (DetSg (SgQuant IndefArt) NoOrd) y))) ;
|
|
mkVP : N -> VP -- be a man
|
|
= \y -> (UseComp (CompNP (DetCN (DetSg (SgQuant IndefArt) NoOrd) (UseN y)))) ;
|
|
mkVP : Adv -> VP -- be here
|
|
= \a -> UseComp (CompAdv a) ;
|
|
mkVP : VP -> Adv -> VP -- sleep here
|
|
= AdvVP ;
|
|
mkVP : AdV -> VP -> VP -- always sleep
|
|
= AdVVP
|
|
} ;
|
|
|
|
reflexiveVP : V2 -> VP = ReflV2 ;
|
|
passiveVP = overload {
|
|
passiveVP : V2 -> VP = PassV2 ;
|
|
passiveVP : V2 -> NP -> VP = \v,np -> (AdvVP (PassV2 v) (PrepNP by8agent_Prep np))
|
|
} ;
|
|
progressiveVP : VP -> VP = ProgrVP ;
|
|
|
|
|
|
mkListS = overload {
|
|
mkListS : S -> S -> ListS = BaseS ;
|
|
mkListS : S -> ListS -> ListS = ConsS
|
|
} ;
|
|
|
|
mkListAP = overload {
|
|
mkListAP : AP -> AP -> ListAP = BaseAP ;
|
|
mkListAP : AP -> ListAP -> ListAP = ConsAP
|
|
} ;
|
|
|
|
mkListAdv = overload {
|
|
mkListAdv : Adv -> Adv -> ListAdv = BaseAdv ;
|
|
mkListAdv : Adv -> ListAdv -> ListAdv = ConsAdv
|
|
} ;
|
|
|
|
mkListNP = overload {
|
|
mkListNP : NP -> NP -> ListNP = BaseNP ;
|
|
mkListNP : NP -> ListNP -> ListNP = ConsNP
|
|
} ;
|
|
|