diff --git a/lib/src/api/abstract_to_api/AbsToAPI.gf b/lib/src/api/abstract_to_api/AbsToAPI.gf new file mode 100644 index 000000000..bbf89ce7e --- /dev/null +++ b/lib/src/api/abstract_to_api/AbsToAPI.gf @@ -0,0 +1,476 @@ +abstract AbsToAPI = { + +cat +A; A2; AP; AdA; AdN; AdV; Adv; Ant; Art; CAdv; CN; Card; Cl; ClSlash; Comp; Conj; Det; Dig; Digit; Digits; IAdv; IComp; IDet; IP; IQuant; Imp; Interj; ListAP; ListAdv; ListCN; ListIAdv; ListNP; ListRS; ListS; N; N2; N3; NP; Num; Numeral; Ord; PConj; PN; Phr; Pol; Predet; Prep; Pron; QCl; QS; QVP; Quant; RCl; RP; RS; S; SC; SSlash; Subj; Temp; Tense; Text; Utt; V; V2; V2A; V2Q; V2S; V2V; V3; VA; VP; VPSlash; VQ; VS; VV; Voc; Punct; String ; ImpForm ; QuantSg; QuantPl ; + +fun + + mkText1 : Phr -> Punct -> Text -> Text ; + mkText2 : Phr -> Text -> Text ; + mkText3 : Phr -> Punct -> Text ; + mkText4 : Phr -> Text ; + mkText5 : Utt -> Text ; + mkText6 : S -> Text ; + mkText7 : Cl -> Text ; + mkText8 : QS -> Text ; + mkText9 : Pol -> Imp -> Text ; + mkText10 : Imp -> Text ; + emptyText : Text ; + + fullStopPunct : Punct ; + questMarkPunct : Punct ; + exclMarkPunct : Punct ; + + mkPhr1 : PConj -> Utt -> Voc -> Phr ; + mkPhr2 : Utt -> Voc -> Phr ; + mkPhr3 : PConj -> Utt -> Phr ; + mkPhr4 : Utt -> Phr ; + mkPhr5 : S -> Phr ; + mkPhr6 : Cl -> Phr ; + mkPhr7 : QS -> Phr ; + mkPhr8 : Imp -> Phr ; + + mkPConj : Conj -> PConj ; + noPConj : PConj ; + + mkVoc : NP -> Voc ; + noVoc : Voc ; + + mkUtt1 : S -> Utt ; + mkUtt2 : Cl -> Utt ; + mkUtt3 : QS -> Utt ; + mkUtt4 : QCl -> Utt ; + mkUtt5 : ImpForm -> Pol -> Imp -> Utt ; + mkUtt6 : ImpForm -> Imp -> Utt ; + mkUtt7 : Pol -> Imp -> Utt ; + mkUtt8 : Imp -> Utt ; + mkUtt9 : IP -> Utt ; + mkUtt10 : IAdv -> Utt ; + mkUtt11 : NP -> Utt ; + mkUtt12 : Adv -> Utt ; + mkUtt13 : VP -> Utt ; + mkUtt14 : CN -> Utt ; + mkUtt15 : AP -> Utt ; + mkUtt16 : Card -> Utt ; + + lets_Utt : VP -> Utt ; + + positivePol : Pol ; + negativePol : Pol ; + + simultaneousAnt : Ant ; + anteriorAnt : Ant ; + + presentTense : Tense ; + pastTense : Tense ; + futureTense : Tense ; + conditionalTense : Tense ; + + mkTemp : Tense -> Ant -> Temp ; + + singularImpForm : ImpForm ; + pluralImpForm : ImpForm ; + politeImpForm : ImpForm ; + +mkS1 : Cl -> S ; + mkS2 : Tense -> Cl -> S ; + mkS3 : Ant -> Cl -> S ; + mkS4 : Pol -> Cl -> S ; + mkS5 : Tense -> Ant -> Cl -> S ; + mkS6 : Tense -> Pol -> Cl -> S ; + mkS7 : Ant -> Pol -> Cl -> S ; + mkS8 : Tense -> Ant -> Pol -> Cl -> S ; + mkS9 : Temp -> Pol -> Cl -> S ; + mkS10 : Conj -> S -> S -> S ; + mkS11 : Conj -> ListS -> S ; + mkS12 : Adv -> S -> S ; + + mkCl1 : NP -> V -> Cl ; + mkCl2 : NP -> V2 -> NP -> Cl ; + mkCl3 : NP -> V3 -> NP -> NP -> Cl ; + mkCl4 : NP -> VV -> VP -> Cl ; + mkCl5 : NP -> VS -> S -> Cl ; + mkCl6 : NP -> VQ -> QS -> Cl ; + mkCl7 : NP -> VA -> A -> Cl ; + mkCl8 : NP -> VA -> AP -> Cl ; + mkCl9 : NP -> V2A -> NP -> A -> Cl ; + mkCl10 : NP -> V2A -> NP -> AP -> Cl ; + mkCl11 : NP -> V2S -> NP -> S -> Cl ; + mkCl12 : NP -> V2Q -> NP -> QS -> Cl ; + mkCl13 : NP -> V2V -> NP -> VP -> Cl ; + mkCl14 : NP -> A -> Cl ; + mkCl15 : NP -> A -> NP -> Cl ; + mkCl16 : NP -> A2 -> NP -> Cl ; + mkCl17 : NP -> AP -> Cl ; + mkCl18 : NP -> NP -> Cl ; + mkCl19 : NP -> N -> Cl ; + mkCl20 : NP -> CN -> Cl ; + mkCl21 : NP -> Adv -> Cl ; + mkCl22 : NP -> VP -> Cl ; + mkCl23 : N -> Cl ; + mkCl24 : CN -> Cl ; + mkCl25 : NP -> Cl ; + mkCl26 : NP -> RS -> Cl ; + mkCl27 : Adv -> S -> Cl ; + mkCl28 : V -> Cl ; + mkCl29 : VP -> Cl ; + mkCl30 : SC -> VP -> Cl ; + + genericCl : VP -> Cl ; + + mkVP1 : V -> VP ; + mkVP2 : V2 -> NP -> VP ; + mkVP3 : V3 -> NP -> NP -> VP ; + mkVP4 : VV -> VP -> VP ; + mkVP5 : VS -> S -> VP ; + mkVP6 : VQ -> QS -> VP ; + mkVP7 : VA -> AP -> VP ; + mkVP8 : V2A -> NP -> AP -> VP ; + mkVP9 : V2S -> NP -> S -> VP ; + mkVP10 : V2Q -> NP -> QS -> VP ; + mkVP11 : V2V -> NP -> VP -> VP ; + mkVP12 : A -> VP ; + mkVP13 : A -> NP -> VP ; + mkVP14 : A2 -> NP -> VP ; + mkVP15 : AP -> VP ; + mkVP16 : N -> VP ; + mkVP17 : CN -> VP ; + mkVP18 : NP -> VP ; + mkVP19 : Adv -> VP ; + mkVP20 : VP -> Adv -> VP ; + mkVP21 : AdV -> VP -> VP ; + mkVP22 : VPSlash -> NP -> VP ; + mkVP23 : VPSlash -> VP ; + mkVP24 : Comp -> VP ; + + reflexiveVP1 : V2 -> VP ; + reflexiveVP2 : VPSlash -> VP ; + + passiveVP1 : V2 -> VP ; + passiveVP2 : V2 -> NP -> VP ; + + progressiveVP : VP -> VP ; + + mkComp1 : AP -> Comp ; + mkComp2 : NP -> Comp ; + mkComp3 : Adv -> Comp ; + + mkSC1 : S -> SC ; + mkSC2 : QS -> SC ; + mkSC3 : VP -> SC ; + + mkImp1 : VP -> Imp ; + mkImp2 : V -> Imp ; + mkImp3 : V2 -> NP -> Imp ; + + mkNP1 : Quant -> N -> NP ; + mkNP2 : Quant -> CN -> NP ; + mkNP3 : Quant -> Num -> CN -> NP ; + mkNP4 : Quant -> Num -> Ord -> CN -> NP ; + mkNP5 : Quant -> Num -> N -> NP ; + mkNP6 : Det -> CN -> NP ; + mkNP7 : Det -> N -> NP ; + mkNP8 : Numeral -> CN -> NP ; + mkNP9 : Numeral -> N -> NP ; + mkNP10 : Digits -> CN -> NP ; + mkNP11 : Digits -> N -> NP ; + mkNP12 : Digit -> CN -> NP ; + mkNP13 : Digit -> N -> NP ; + mkNP14 : Card -> CN -> NP ; + mkNP15 : Card -> N -> NP ; + mkNP16 : Pron -> CN -> NP ; + mkNP17 : Pron -> N -> NP ; + mkNP18 : PN -> NP ; + mkNP19 : Pron -> NP ; + mkNP20 : Quant -> NP ; + mkNP21 : Quant -> Num -> NP ; + mkNP22 : Det -> NP ; + mkNP23 : CN -> NP ; + mkNP24 : N -> NP ; + mkNP25 : Predet -> NP -> NP ; + mkNP26 : NP -> V2 -> NP ; + mkNP27 : NP -> Adv -> NP ; + mkNP28 : NP -> RS -> NP ; + mkNP29 : Conj -> NP -> NP -> NP ; + mkNP30 : Conj -> ListNP -> NP ; + mkNP31 : QuantSg -> CN -> NP ; + mkNP32 : QuantPl -> CN -> NP ; + + i_NP : NP ; + you_NP : NP ; + youPol_NP : NP ; + he_NP : NP ; + she_NP : NP ; + it_NP : NP ; + we_NP : NP ; + youPl_NP : NP ; + they_NP : NP ; + this_NP : NP ; + that_NP : NP ; + these_NP : NP ; +those_NP : NP ; + + mkDet1 : Quant -> Det ; + mkDet2 : Quant -> Card -> Det ; + mkDet3 : Quant -> Ord -> Det ; + mkDet4 : Quant -> Num -> Ord -> Det ; + mkDet5 : Quant -> Num -> Det ; + mkDet6 : Card -> Det ; + mkDet7 : Digits -> Det ; + mkDet8 : Numeral -> Det ; + mkDet9 : Pron -> Det ; + mkDet10 : Pron -> Num -> Det ; + + the_Det : Det ; + a_Det : Det ; + theSg_Det : Det ; + thePl_Det : Det ; + aSg_Det : Det ; + aPl_Det : Det ; + this_Det : Det ; + that_Det : Det ; + these_Det : Det ; + those_Det : Det ; + + mkQuant : Pron -> Quant ; + + the_Quant : Quant ; + a_Quant : Quant ; + + --mkNum1 : Str -> Num ; + mkNum2 : Numeral -> Num ; + mkNum3 : Digits -> Num ; + mkNum4 : Digit -> Num ; + mkNum5 : Card -> Num ; + mkNum6 : AdN -> Card -> Num ; + + singularNum : Num ; + pluralNum : Num ; + + --mkCard1 : Str -> Card ; + mkCard2 : Numeral -> Card ; + mkCard3 : Digits -> Card ; + mkCard4 : AdN -> Card -> Card ; + + mkOrd1 : Numeral -> Ord ; + mkOrd2 : Digits -> Ord ; + mkOrd3 : Digit -> Ord ; + mkOrd4 : A -> Ord ; + + mkAdN : CAdv -> AdN ; + + mkCN1 : N -> CN ; + mkCN2 : N2 -> NP -> CN ; + mkCN3 : N3 -> NP -> NP -> CN ; + mkCN4 : N2 -> CN ; + mkCN5 : N3 -> CN ; + mkCN6 : A -> N -> CN ; + mkCN7 : A -> CN -> CN ; + mkCN8 : AP -> N -> CN ; + mkCN9 : AP -> CN -> CN ; + mkCN10 : CN -> AP -> CN ; + mkCN11 : N -> AP -> CN ; + mkCN12 : N -> RS -> CN ; + mkCN13 : CN -> RS -> CN ; + mkCN14 : N -> Adv -> CN ; + mkCN15 : CN -> Adv -> CN ; + mkCN16 : CN -> S -> CN ; + mkCN17 : CN -> QS -> CN ; + mkCN18 : CN -> VP -> CN ; + mkCN19 : CN -> SC -> CN ; + mkCN20 : N -> NP -> CN ; + mkCN21 : CN -> NP -> CN ; + + mkAP1 : A -> AP ; + mkAP2 : A -> NP -> AP ; + mkAP3 : A2 -> NP -> AP ; + mkAP4 : A2 -> AP ; + mkAP5 : AP -> S -> AP ; + mkAP6 : AP -> QS -> AP ; + mkAP7 : AP -> VP -> AP ; + mkAP8 : AP -> SC -> AP ; + mkAP9 : AdA -> A -> AP ; + mkAP10 : AdA -> AP -> AP ; + mkAP11 : Conj -> AP -> AP -> AP ; + mkAP12 : Conj -> ListAP -> AP ; + mkAP13 : Ord -> AP ; + mkAP14 : CAdv -> AP -> NP -> AP ; + + reflAP : A2 -> AP ; + comparAP : A -> AP ; + + mkAdv1 : A -> Adv ; + mkAdv2 : Prep -> NP -> Adv ; + mkAdv3 : Subj -> S -> Adv ; + mkAdv4 : CAdv -> A -> NP -> Adv ; + mkAdv5 : CAdv -> A -> S -> Adv ; + mkAdv6 : AdA -> Adv -> Adv ; + mkAdv7 : Conj -> Adv -> Adv -> Adv ; + mkAdv8 : Conj -> ListAdv -> Adv ; + + mkQS1 : QCl -> QS ; + mkQS2 : Tense -> QCl -> QS ; + mkQS3 : Ant -> QCl -> QS ; + mkQS4 : Pol -> QCl -> QS ; + mkQS5 : Tense -> Ant -> QCl -> QS ; + mkQS6 : Tense -> Pol -> QCl -> QS ; + mkQS7 : Ant -> Pol -> QCl -> QS ; + mkQS8 : Tense -> Ant -> Pol -> QCl -> QS ; + mkQS9 : Cl -> QS ; + + mkQCl1 : Cl -> QCl ; + mkQCl2 : IP -> VP -> QCl ; + mkQCl3 : IP -> V -> QCl ; + mkQCl4 : IP -> V2 -> NP -> QCl ; + mkQCl5 : IP -> V3 -> NP -> NP -> QCl ; + mkQCl6 : IP -> VV -> VP -> QCl ; + mkQCl7 : IP -> VS -> S -> QCl ; + mkQCl8 : IP -> VQ -> QS -> QCl ; + mkQCl9 : IP -> VA -> A -> QCl ; + mkQCl10 : IP -> VA -> AP -> QCl ; + mkQCl11 : IP -> V2A -> NP -> A -> QCl ; + mkQCl12 : IP -> V2A -> NP -> AP -> QCl ; + mkQCl13 : IP -> V2S -> NP -> S -> QCl ; + mkQCl14 : IP -> V2Q -> NP -> QS -> QCl ; + mkQCl15 : IP -> V2V -> NP -> VP -> QCl ; + mkQCl16 : IP -> A -> QCl ; + mkQCl17 : IP -> A -> NP -> QCl ; + mkQCl18 : IP -> A2 -> NP -> QCl ; + mkQCl19 : IP -> AP -> QCl ; + mkQCl20 : IP -> NP -> QCl ; + mkQCl21 : IP -> N -> QCl ; + mkQCl22 : IP -> CN -> QCl ; + mkQCl23 : IP -> Adv -> QCl ; + mkQCl24 : IP -> NP -> V2 -> QCl ; + mkQCl25 : IP -> ClSlash -> QCl ; + mkQCl26 : IAdv -> Cl -> QCl ; + mkQCl27 : Prep -> IP -> Cl -> QCl ; + mkQCl28 : IAdv -> NP -> QCl ; + mkQCl29 : IComp -> NP -> QCl ; + mkQCl30 : IP -> QCl ; + + mkIComp1 : IAdv -> IComp ; + mkIComp2 : IP -> IComp ; + + mkIP1 : IDet -> CN -> IP ; + mkIP2 : IDet -> N -> IP ; + mkIP3 : IDet -> IP ; + mkIP4 : IQuant -> CN -> IP ; + mkIP5 : IQuant -> Num -> CN -> IP ; + mkIP6 : IQuant -> N -> IP ; + mkIP7 : IP -> Adv -> IP ; + + what_IP : IP ; + who_IP : IP ; + + mkIAdv1 : Prep -> IP -> IAdv ; + mkIAdv2 : IAdv -> Adv -> IAdv ; + + mkIDet1 : IQuant -> Num -> IDet ; + mkIDet2 : IQuant -> IDet ; + + which_IDet : IDet ; + whichSg_IDet : IDet ; + whichPl_IDet : IDet ; + + mkRS1 : RCl -> RS ; + mkRS2 : Tense -> RCl -> RS ; + mkRS3 : Ant -> RCl -> RS ; + mkRS4 : Pol -> RCl -> RS ; + mkRS5 : Tense -> Ant -> RCl -> RS ; + mkRS6 : Tense -> Pol -> RCl -> RS ; + mkRS7 : Ant -> Pol -> RCl -> RS ; + mkRS8 : Tense -> Ant -> Pol -> RCl -> RS ; + mkRS9 : Temp -> Pol -> RCl -> RS ; + mkRS10 : Conj -> RS -> RS -> RS ; + mkRS11 : Conj -> ListRS -> RS ; + + mkRCl1 : RP -> VP -> RCl ; + mkRCl2 : RP -> V -> RCl ; + mkRCl3 : RP -> V2 -> NP -> RCl ; + mkRCl4 : RP -> V3 -> NP -> NP -> RCl ; + mkRCl5 : RP -> VV -> VP -> RCl ; + mkRCl6 : RP -> VS -> S -> RCl ; + mkRCl7 : RP -> VQ -> QS -> RCl ; + mkRCl8 : RP -> VA -> A -> RCl ; + mkRCl9 : RP -> VA -> AP -> RCl ; + mkRCl10 : RP -> V2A -> NP -> A -> RCl ; + mkRCl11 : RP -> V2A -> NP -> AP -> RCl ; + mkRCl12 : RP -> V2S -> NP -> S -> RCl ; + mkRCl13 : RP -> V2Q -> NP -> QS -> RCl ; + mkRCl14 : RP -> V2V -> NP -> VP -> RCl ; + mkRCl15 : RP -> A -> RCl ; + mkRCl16 : RP -> A -> NP -> RCl ; + mkRCl17 : RP -> A2 -> NP -> RCl ; + mkRCl18 : RP -> AP -> RCl ; + mkRCl19 : RP -> NP -> RCl ; + mkRCl20 : RP -> N -> RCl ; + mkRCl21 : RP -> CN -> RCl ; + mkRCl22 : RP -> Adv -> RCl ; + mkRCl23 : RP -> NP -> V2 -> RCl ; + mkRCl24 : RP -> ClSlash -> RCl ; + mkRCl25 : Cl -> RCl ; + + which_RP : RP ; + + mkRP : Prep -> NP -> RP -> RP ; + + mkSSlash : Temp -> Pol -> ClSlash -> SSlash ; + + mkClSlash1 : NP -> VPSlash -> ClSlash ; + mkClSlash2 : NP -> V2 -> ClSlash ; + mkClSlash3 : NP -> VV -> V2 -> ClSlash ; + mkClSlash4 : Cl -> Prep -> ClSlash ; + mkClSlash5 : ClSlash -> Adv -> ClSlash ; + mkClSlash6 : NP -> VS -> SSlash -> ClSlash ; + + mkVPSlash1 : V2 -> VPSlash ; + mkVPSlash2 : V3 -> NP -> VPSlash ; + mkVPSlash3 : V2A -> AP -> VPSlash ; + mkVPSlash4 : V2Q -> QS -> VPSlash ; + mkVPSlash5 : V2S -> S -> VPSlash ; + mkVPSlash6 : V2V -> VP -> VPSlash ; + mkVPSlash7 : VV -> VPSlash -> VPSlash ; + mkVPSlash8 : V2V -> NP -> VPSlash -> VPSlash ; + + mkListS1 : S -> S -> ListS ; + mkListS2 : S -> ListS -> ListS ; + + mkListAdv1 : Adv -> Adv -> ListAdv ; + mkListAdv2 : Adv -> ListAdv -> ListAdv ; + + mkListAP1 : AP -> AP -> ListAP ; + mkListAP2 : AP -> ListAP -> ListAP ; + + mkListNP1 : NP -> NP -> ListNP ; + mkListNP2 : NP -> ListNP -> ListNP ; + + mkListRS1 : RS -> RS -> ListRS ; + mkListRS2 : RS -> ListRS -> ListRS ; + + + the_Art : Art ; + a_Art : Art ; + sgNum : Num ; + plNum : Num ; + +{- + DetSg : Quant -> Ord -> Det = \q -> DetQuantOrd q NumSg ; + DetPl : Quant -> Num -> Ord -> Det = DetQuantOrd ; + ComplV2 : V2 -> NP -> VP = \v,np -> ComplSlash (SlashV2a v) np ; + ComplV2A : V2A -> NP -> AP -> VP = \v,np,ap -> ComplSlash (SlashV2A v ap) np ; + ComplV3 : V3 -> NP -> NP -> VP = \v,o,d -> ComplSlash (Slash3V3 v d) o ; +-} + +----------------------------- + +testNoun : Int -> N ; +testA : Int -> A ; +testV : Int -> V ; +testV2 : Int -> V2 ; +testAdv : Int -> Adv ; + + + + +} diff --git a/lib/src/api/abstract_to_api/AbsToAPIAbs.gf b/lib/src/api/abstract_to_api/AbsToAPIAbs.gf new file mode 100644 index 000000000..bb051f5c1 --- /dev/null +++ b/lib/src/api/abstract_to_api/AbsToAPIAbs.gf @@ -0,0 +1,512 @@ +concrete AbsToAPIAbs of AbsToAPI = { + +lincat +A, A2, AP, AdA, AdN, AdV, Adv, Ant, Art, CAdv, CN, Card, Cl, ClSlash, Comp, Conj, Det, Dig, Digit, Digits, IAdv, IComp, IDet, IP, IQuant, Imp, Interj, ListAP, ListAdv, ListCN, ListIAdv, ListNP, ListRS, ListS, N, N2, N3, NP, Num, Numeral, Ord, PConj, PN, Phr, Pol, Predet, Prep, Pron, QCl, QS, QVP, Quant, RCl, RP, RS, S, SC, SSlash, Subj, Temp, Tense, Text, Utt, V, V2, V2A, V2Q, V2S, V2V, V3, VA, VP, VPSlash, VQ, VS, VV, Voc, String, QuantSg, QuantPl = {ind : Str; attr : Str} ; + +ImpForm = {ind : Str; attr : Str; iform : IForm} ; +Punct = {ind : Str; attr : Str; pform : PForm } ; + +param PForm = PFullStop | PQuestMark | PExclMark ; +param IForm = IFSg | IFPl | IFPol ; + +lin + + +mkText1 = \phr,punct,text -> case punct.pform of + { PFullStop => mkCompCat ( "TFullStop" ++ phr.attr ++ text.attr ) ; + PExclMark => mkCompCat ("TExclMark" ++ phr.attr ++ text.attr ) ; + _ => mkCompCat ("TQuestMark" ++ phr.attr ++ text.attr) }; + +mkText2 = \x,t -> mkCompCat ("TFullStop" ++ x.attr ++ t.attr) ; +mkText3 = \phr,punct -> case punct.pform of + {PFullStop => mkCompCat ("TFullStop" ++ phr.attr ++ "TEmpty") ; + PExclMark => mkCompCat ("TExclMark" ++ phr.attr ++ "TEmpty") ; + _ => mkCompCat ("TQuestMark" ++ phr.attr ++ "TEmpty") }; +mkText4 = \x -> mkCompCat ( "TFullStop" ++ x.attr ++ "TEmpty" ) ; +mkText5 = \u -> mkCompCat ( "TFullStop" ++ "(" ++ "PhrUtt" ++ "NoPConj" ++ u.attr ++ "NoVoc" ++ ")" ++ "TEmpty" ) ; +mkText6 = \s -> mkCompCat ( "TFullStop" ++ "(" ++ "PhrUtt" ++ "NoPConj" ++ "(" ++ "UttS" ++ s.attr ++ ")" ++ "NoVoc" ++ ")" ++ "TEmpty" ) ; +mkText7 = \c -> mkCompCat ( "TFullStop" ++ "(" ++ "PhrUtt" ++ "NoPConj" ++ "(" ++ "UttS" ++ "(" ++ "UseCl" ++"(" ++ "TTAnt" ++ "TPres" ++ ")" ++ "ASimul" ++ "PPos" ++ c.attr ++ ")" ++ ")" ++ "NoVoc" ++ ")" ++ "TEmpty" ); +mkText8 = \q -> mkCompCat ( "TQuestMark" ++ "(" ++ "PhrUtt" ++ "NoPConj" ++ "(" ++ "UttQS" ++ q.attr ++ ")" ++ "NoVoc" ++ ")" ++ "TEmpty" ) ; +mkText9 = \p,i -> mkCompCat ( "TExclMark" ++ "(" ++ "PhrUtt" ++ "NoPConj" ++ "(" ++ "UttImpSg" ++ p.attr ++ i.attr ++ ")" ++ "NoVoc" ++ ")" ++ "TEmpty" ) ; +mkText10 = \i -> mkCompCat ( "TExclMark" ++ "(" ++ "PhrUtt" ++ "NoPConj" ++ "(" ++ "UttImpSg" ++ "PPos" ++ i.attr ++ ")" ++ "NoVoc" ++ ")" ++ "TEmpty" ) ; + +emptyText = mkSimpCat "TEmpty" ; + +fullStopPunct = mkSimpCat "PFullStop" ** {pform = PFullStop}; +questMarkPunct = mkSimpCat "PQuestMark" ** {pform = PQuestMark} ; +exclMarkPunct = mkSimpCat "PExclMark" ** {pform = PExclMark}; + +mkPhr1 = mkTernaryCat "PhrUtt" ; +mkPhr2 = \u,v -> mkCompCat ( "PhrUtt" ++ "NoPConj" ++ u.attr ++ v.attr ) ; +mkPhr3 = \u,v -> mkCompCat ( "PhrUtt" ++ u.attr ++ v.attr ++ "NoVoc" ) ; +mkPhr4 = \u -> mkCompCat ( "PhrUtt" ++ "NoPConj" ++ u.attr ++ "NoVoc" ) ; +mkPhr5 = \s -> mkCompCat ( "PhrUtt" ++ "NoPConj" ++ "(" ++ "UttS" ++ s.attr ++ ")" ++ "NoVoc" ) ; +mkPhr6 = \s -> mkCompCat ( "PhrUtt" ++ "NoPConj" ++ "(" ++ "UttS" ++ "(" ++ "UseCl" ++ "(" ++ "TTAnt" ++"TPres" ++ "ASimul" ++ ")" ++ "PPos" ++ s.attr ++ ")" ++ ")" ++ "NoVoc" ) ; +mkPhr7 = \s -> mkCompCat ( "PhrUtt" ++ "NoPConj" ++ "(" ++ "UttQS" ++ s.attr ++ ")" ++ "NoVoc" ) ; +mkPhr8 = \s -> mkCompCat ( "PhrUtt" ++ "NoPConj" ++ "(" ++ "UttImpSg" ++ "PPos" ++ s.attr ++ ")" ++ "NoVoc" ) ; + +mkPConj = mkUnaryCat "PConjConj" ; +noPConj = mkSimpCat "NoPConj" ; + +mkVoc = mkUnaryCat "VocNP" ; +noVoc = mkSimpCat "NoVoc" ; + +mkUtt1 = mkUnaryCat "UttS" ; +mkUtt2 = \c -> mkCompCat ( "UttS" ++ "(" ++ "UseCl" ++ "(" ++ "TTAnt" ++ "TPres" ++ "ASimul" ++ ")"++ "PPos" ++ c.attr ++ ")" ) ; +mkUtt3 = mkUnaryCat "UttQS" ; +mkUtt4 = \c -> mkCompCat ( "UttQS" ++ "(" ++ "UseQCl" ++ "(" ++ "TTAnt" ++ "TPres" ++ "ASimul" ++ ")" ++ "PPos" ++ c.attr ++ ")" ) ; +mkUtt5 = \f, p, i -> case f.iform of + { IFSg => mkCompCat ("UttImpSg" ++ p.attr ++ i.attr ) ; + IFPl => mkCompCat ("UttImpPl" ++ p.attr ++ i.attr) ; + _ => mkCompCat ("UttImpPol" ++ p.attr ++ i.attr) } ; +mkUtt6 = \f,i -> case f.iform of + { IFSg => mkCompCat ("UttImpSg" ++ "PPos" ++ i.attr ) ; + IFPl => mkCompCat ("UttImpPl" ++ "PPos" ++ i.attr) ; + _ => mkCompCat ("UttImpPol" ++ "PPos" ++ i.attr) } ; +mkUtt7 = mkBinaryCat "UttImpSg" ; +mkUtt8 = mkUnaryCat ("UttImpSg" ++ "PPos") ; +mkUtt9 = mkUnaryCat "UttIP" ; +mkUtt10 = mkUnaryCat "UttIAdv" ; +mkUtt11 = mkUnaryCat "UttNP" ; +mkUtt12 = mkUnaryCat "UttAdv" ; +mkUtt13 = mkUnaryCat "UttVP" ; +mkUtt14 = mkUnaryCat "UttCN" ; +mkUtt15 = mkUnaryCat "UttAP" ; +mkUtt16 = mkUnaryCat "UttCard" ; + +lets_Utt = mkUnaryCat "ImpPl1" ; + +negativePol = mkSimpCat "PNeg" ; +positivePol = mkSimpCat "PPos" ; + +simultaneousAnt = mkSimpCat "ASimul" ; +anteriorAnt = mkSimpCat "AAnter" ; + +presentTense = mkSimpCat "TPres" ; +pastTense = mkSimpCat "TPast" ; +futureTense = mkSimpCat "TFut" ; +conditionalTense = mkSimpCat "TCond" ; + +mkTemp = mkBinaryCat "TTAnt" ; + +singularImpForm = mkSimpCat "IFSg" ** {iform = IFSg} ; +pluralImpForm = mkSimpCat "IFPI" ** {iform = IFPl}; +politeImpForm = mkSimpCat "IFPol" ** {iform = IFPol} ; + +mkS1 = mkUnaryCat ("UseCl" ++ "(" ++ "TTAnt" ++ "TPres" ++ "ASimul" ++ ")" ++ "PPos" ) ; +mkS2 = \t, cl -> mkCompCat ( "UseCl" ++ "(" ++ "TTAnt" ++ t.attr ++ "ASimul" ++ ")" ++ "PPos" ++ cl.attr) ; +mkS3 = \a, cl -> mkCompCat ( "UseCl" ++ "(" ++ "TTAnt" ++"TPres" ++ a.attr ++ ")" ++ "PPos" ++ cl.attr) ; +mkS4 = \p, cl -> mkCompCat ( "UseCl" ++ "(" ++ "TTAnt" ++ "TPres" ++ "ASimul" ++ ")" ++ p.attr ++ cl.attr) ; +mkS5 = \t,a, cl -> mkCompCat ( "UseCl" ++ "(" ++ "TTAnt" ++ t.attr ++ a.attr ++ ")" ++ "PPos" ++ cl.attr ) ; +mkS6 = \t,p, cl -> mkCompCat ( "UseCl" ++ "(" ++ "TTAnt" ++ t.attr ++ "ASimul" ++ ")" ++ p.attr ++ cl.attr) ; +mkS7 = \a,p, cl -> mkCompCat ( "UseCl" ++ "(" ++ "TTAnt" ++"TPres" ++ a.attr ++ ")" ++ p.attr ++ cl.attr) ; +mkS8 = \t,a,p,cl -> mkCompCat ( "UseCl" ++ "(" ++ "TTAnt" ++ t.attr ++ a.attr ++ ")" ++ p.attr ++ cl.attr ) ; +mkS9 = mkTernaryCat "UseCl" ; +mkS10 = \c,x,y -> mkCompCat ( "ConjS" ++ c.attr ++ "(" ++ "BaseS" ++ x.attr ++ y.attr ++ ")" ) ; +mkS11 = \c,xy -> mkCompCat ( "ConjS" ++ c.attr ++ xy.attr ) ; +mkS12 = mkBinaryCat "AdvS" ; + +mkCl1 = \s,v -> mkCompCat ( "PredVP" ++ s.attr ++ "(" ++ "UseV" ++ v.attr ++ ")" ) ; +mkCl2 = \s,v,o -> mkCompCat ( "PredVP" ++ s.attr ++ "(" ++ "ComplV2" ++ v.attr ++ o.attr ++ ")" ) ; +mkCl3 = \s,v,o,i -> mkCompCat ( "PredVP" ++ s.attr ++ "(" ++ "ComplV3" ++ v.attr ++ o.attr ++ i.attr ++ ")" ) ; +mkCl4 = \s,v,vp -> mkCompCat ( "PredVP" ++ s.attr ++ "(" ++ "ComplVV" ++ v.attr ++ vp.attr ++ ")" ) ; +mkCl5 = \s,v,p -> mkCompCat ( "PredVP" ++ s.attr ++ "(" ++ "ComplVS" ++ v.attr ++ p.attr ++ ")" ) ; +mkCl6 = \s,v,q -> mkCompCat ( "PredVP" ++ s.attr ++ "(" ++ "ComplVQ" ++ v.attr ++ q.attr ++ ")" ) ; +mkCl7 = \s,v,q -> mkCompCat ( "PredVP" ++ s.attr ++ "(" ++ "ComplVA" ++ v.attr ++ "(" ++ "PositA" ++ q.attr ++ ")" ++ ")" ) ; +mkCl8 = \s,v,q -> mkCompCat ( "PredVP" ++ s.attr ++ "(" ++ "ComplVA" ++ v.attr ++ q.attr ++ ")" ) ; +mkCl9 = \s,v,n,q -> mkCompCat ( "PredVP" ++ s.attr ++ "(" ++ "ComplV2A" ++ v.attr ++ n.attr ++ "(" ++ "PositA" ++ q.attr ++ ")" ++ ")" ) ; +mkCl10 = \s,v,n,q -> mkCompCat ( "PredVP" ++ s.attr ++ "(" ++ "ComplV2A" ++ v.attr ++ n.attr ++ q.attr ++ ")" ) ; +mkCl11 = \s,v,n,q -> mkCompCat ( "PredVP" ++ s.attr ++ "(" ++ "ComplSlash" ++ "(" ++ "SlashV2S" ++ v.attr ++ q.attr ++ ")" ++ n.attr ++ ")" ) ; +mkCl12 = \s,v,n,q -> mkCompCat ( "PredVP" ++ s.attr ++ "(" ++ "ComplSlash" ++ "(" ++ "SlashV2Q" ++ v.attr ++ q.attr ++ ")" ++ n.attr ++ ")" ) ; +mkCl13 = \s,v,n,q -> mkCompCat ( "PredVP" ++ s.attr ++ "(" ++ "ComplSlash" ++ "(" ++ "SlashV2V" ++ v.attr ++ q.attr ++ ")" ++ n.attr ++ ")" ) ; +mkCl14 = \x,y -> mkCompCat ( "PredVP" ++ x.attr ++ "(" ++ "UseComp" ++ "(" ++ "CompAP" ++ "(" ++ "PositA" ++ y.attr ++ ")" ++ ")" ++ ")" ) ; +mkCl15 = \x,y,z -> mkCompCat ( "PredVP" ++ x.attr ++ "(" ++ "UseComp" ++ "(" ++ "CompAP" ++ "(" ++ "ComparA" ++ y.attr ++ z.attr ++ ")" ++ ")" ++ ")" ) ; +mkCl16 = \x,y,z -> mkCompCat ( "PredVP" ++ x.attr ++ "(" ++ "UseComp" ++ "(" ++ "CompAP" ++ "(" ++ "ComplA2" ++ y.attr ++ z.attr ++ ")" ++ ")" ++ ")" ) ; +mkCl17 = \x,y -> mkCompCat ( "PredVP" ++ x.attr ++ "(" ++ "UseComp" ++ "(" ++ "CompAP" ++ y.attr ++ ")" ++ ")" ) ; +mkCl18 = \x,y -> mkCompCat ( "PredVP" ++ x.attr ++ "(" ++ "UseComp" ++ "(" ++ "CompNP" ++ y.attr ++ ")" ++ ")" ) ; +mkCl19 = \x,y -> mkCompCat ( "PredVP" ++ x.attr ++ "(" ++ "UseComp" ++ "(" ++ "CompCN" ++ "(" ++ "UseN" ++ y.attr ++ ")" ++ ")" ++ ")" ) ; +mkCl20 = \x,y -> mkCompCat ( "PredVP" ++ x.attr ++ "(" ++ "UseComp" ++ "(" ++ "CompCN" ++ y.attr ++ ")" ++ ")" ) ; +mkCl21 = \x,y -> mkCompCat ( "PredVP" ++ x.attr ++ "(" ++ "UseComp" ++ "(" ++ "CompAdv" ++ y.attr ++ ")" ++ ")" ) ; +mkCl22 = mkBinaryCat "PredVP" ; +mkCl23 = \y -> mkCompCat ( "ExistNP" ++ "(" ++ "DetArtSg" ++ "IndefArt" ++ "(" ++ "UseN" ++ y.attr ++ ")" ++ ")" ) ; +mkCl24 = \y -> mkCompCat ( "ExistNP" ++ "(" ++ "DetArtSg" ++ "IndefArt" ++ y.attr ++ ")" ) ; +mkCl25 = mkUnaryCat "ExistNP" ; +mkCl26 = mkBinaryCat "CleftNP" ; +mkCl27 = mkBinaryCat "CleftAdv" ; +mkCl28 = \v -> mkCompCat ( "ImpersCl" ++ "(" ++ "UseV" ++ v.attr ++ ")" ) ; +mkCl29 = mkUnaryCat "ImpersCl" ; +mkCl30 = mkBinaryCat "PredSCVP" ; + +genericCl = mkUnaryCat "GenericCl" ; + +mkVP1 = mkUnaryCat "UseV" ; +mkVP2 = mkBinaryCat "ComplV2" ; +mkVP3 = mkTernaryCat "ComplV3" ; +mkVP4 = mkBinaryCat "ComplVV" ; +mkVP5 = mkBinaryCat "ComplVS" ; +mkVP6 = mkBinaryCat "ComplVQ" ; +mkVP7 = mkBinaryCat "ComplVA" ; +mkVP8 = mkTernaryCat "ComplV2A" ; +mkVP9 = \v,n,q -> mkCompCat ( "ComplSlash" ++ "(" ++ "SlashV2S" ++ v.attr ++ q.attr ++ ")" ++ n.attr ) ; +mkVP10 = \v,n,q -> mkCompCat ( "ComplSlash" ++ "(" ++ "SlashV2Q" ++ v.attr ++ q.attr ++ ")" ++ n.attr ) ; +mkVP11 = \v,n,q -> mkCompCat ( "ComplSlash" ++ "(" ++ "SlashV2V" ++ v.attr ++ q.attr ++ ")" ++ n.attr ) ; +mkVP12 = \a -> mkCompCat ( "UseComp" ++ "(" ++ "CompAP" ++ "(" ++ "PositA" ++ a.attr ++ ")" ++ ")" ) ; +mkVP13 = \y,z -> mkCompCat ( "UseComp" ++ "(" ++ "CompAP" ++ "(" ++ "ComparA" ++ y.attr ++ z.attr ++ ")" ++ ")" ) ; +mkVP14 = \y,z -> mkCompCat ( "UseComp" ++ "(" ++ "CompAP" ++ "(" ++ "ComplA2" ++ y.attr ++ z.attr ++ ")" ++ ")" ) ; +mkVP15 = \a -> mkCompCat ( "UseComp" ++ "(" ++ "CompAP" ++ a.attr ++ ")" ) ; +mkVP16 = \y -> mkCompCat ( "UseComp" ++ "(" ++ "CompCN" ++ "(" ++ "UseN" ++ y.attr ++ ")" ++ ")" ) ; +mkVP17 = \y -> mkCompCat ( "UseComp" ++ "(" ++ "CompCN" ++ y.attr ++ ")" ) ; +mkVP18 = \a -> mkCompCat ( "UseComp" ++ "(" ++ "CompNP" ++ a.attr ++ ")" ) ; +mkVP19 = \a -> mkCompCat ( "UseComp" ++ "(" ++ "CompAdv" ++ a.attr ++ ")" ) ; +mkVP20 = mkBinaryCat "AdvVP" ; +mkVP21 = mkBinaryCat "AdVVP" ; +mkVP22 = mkBinaryCat "ComplSlash" ; +mkVP23 = mkUnaryCat "ReflVP" ; +mkVP24 = mkUnaryCat "UseComp" ; + +reflexiveVP1 = \v -> mkCompCat ( "ReflVP" ++ "(" ++ "SlashV2a" ++ v.attr ++ ")" ) ; +reflexiveVP2 = mkUnaryCat "ReflVP" ; + +passiveVP1 = mkUnaryCat "PassV2" ; +passiveVP2 = \v,np -> mkCompCat ( "AdvVP" ++ "(" ++ "PassV2" ++ v.attr ++ ")" ++ "(" ++ "PrepNP" ++ "by8agent_Prep" ++ np.attr ++ ")" ) ; + +progressiveVP = mkUnaryCat "ProgrVP" ; + +mkComp1 = mkUnaryCat "CompAP" ; +mkComp2 = mkUnaryCat "CompNP" ; +mkComp3 = mkUnaryCat "CompAdv" ; + +mkSC1 = mkUnaryCat "EmbedS" ; +mkSC2 = mkUnaryCat "EmbedQS" ; +mkSC3 = mkUnaryCat "EmbedVP" ; + +mkImp1 = mkUnaryCat "ImpVP" ; +mkImp2 = \v -> mkCompCat ( "ImpVP" ++ "(" ++ "UseV" ++ v.attr ++ ")" ) ; +mkImp3 = \v,np -> mkCompCat ( "ImpVP" ++ "(" ++ "ComplV2" ++ v.attr ++ np.attr ++ ")" ) ; + +mkNP1 = \q,n -> mkCompCat ( "DetCN" ++ "(" ++ "DetQuant" ++ q.attr ++ "NumSg" ++ ")" ++ "(" ++ "UseN" ++ n.attr ++ ")" ) ; +mkNP2 = \q,n -> mkCompCat ( "DetCN" ++ "(" ++ "DetQuant" ++ q.attr ++ "NumSg" ++ ")" ++ n.attr ) ; +mkNP3 = \q,nu,n -> mkCompCat ( "DetCN" ++ "(" ++ "DetQuant" ++ q.attr ++ nu.attr ++ ")" ++ n.attr ) ; +mkNP4 = \q,nu,or,n -> mkCompCat ( "DetCN" ++ "(" ++ "DetQuantOrd" ++ q.attr ++ nu.attr ++ or.attr ++ ")" ++ n.attr ) ; +mkNP5 = \q,nu,n -> mkCompCat ( "DetCN" ++ "(" ++ "DetQuant" ++ q.attr ++ nu.attr ++ ")" ++ "(" ++ "UseN" ++ n.attr ++ ")" ) ; +mkNP6 = mkBinaryCat "DetCN" ; +mkNP7 = \d,n -> mkCompCat ( "DetCN" ++ d.attr ++ "(" ++ "UseN" ++ n.attr ++ ")" ) ; +mkNP8 = \d,n -> mkCompCat ( "DetCN" ++ "(" ++ "DetArtCard" ++ "IndefArt" ++ "(" ++ "NumNumeral" ++ d.attr ++ ")" ++ ")" ++ n.attr ) ; +mkNP9 = \d,n -> mkCompCat ( "DetCN" ++ "(" ++ "DetArtCard" ++ "IndefArt" ++ "(" ++ "NumNumeral" ++ d.attr ++ ")" ++ ")" ++ "(" ++ "UseN" ++ n.attr ++ ")" ) ; +mkNP10 = \d,n -> mkCompCat ( "DetCN" ++ "(" ++ "DetArtCard" ++ "IndefArt" ++ "(" ++ "NumDigits" ++ d.attr ++ ")" ++ ")" ++ n.attr ) ; +mkNP11 = \d,n -> mkCompCat ( "DetCN" ++ "(" ++ "DetArtCard" ++ "IndefArt" ++ "(" ++ "NumDigits" ++ d.attr ++ ")" ++ ")" ++ "(" ++ "UseN" ++ n.attr ++ ")" ) ; +mkNP12 = \d,n -> mkCompCat ( "DetCN" ++ "(" ++ "DetArtCard" ++ "IndefArt" ++ "(" ++ "NumNumeral" ++ "(" ++ "num" ++ "(" ++ "pot2as3" ++ "(" ++ "pot1as2" ++ "(" ++ "pot0as1" ++ "(" ++ "pot0" ++ d.attr ++ ")" ++ ")" ++ ")" ++ ")" ++ ")" ++ ")" ++ ")" ++ n.attr ) ; +mkNP13 = \d,n -> mkCompCat ( "DetCN" ++ "(" ++ "DetArtCard" ++ "IndefArt" ++ "(" ++ "NumNumeral" ++ "(" ++ "num" ++ "(" ++ "pot2as3" ++ "(" ++ "pot1as2" ++ "(" ++ "pot0as1" ++ "(" ++ "pot0" ++ d.attr ++ ")" ++ ")" ++ ")" ++ ")" ++ ")" ++ ")" ++ ")" ++ "(" ++ "UseN" ++ n.attr ++ ")" ) ; +mkNP14 = \d,n -> mkCompCat ( "DetCN" ++ "(" ++ "DetArtCard" ++ "IndefArt" ++ d.attr ++ ")" ++ n.attr ) ; +mkNP15 = \d,n -> mkCompCat ( "DetCN" ++ "(" ++ "DetArtCard" ++ "IndefArt" ++ d.attr ++ ")" ++ "(" ++ "UseN" ++ n.attr ++ ")" ) ; +mkNP16 = \p,n -> mkCompCat ( "DetCN" ++ "(" ++ "DetQuant" ++ "(" ++ "PossPron" ++ p.attr ++ ")" ++ "NumSg" ++ ")" ++ n.attr ) ; +mkNP17 = \p,n -> mkCompCat ( "DetCN" ++ "(" ++ "DetQuant" ++ "(" ++ "PossPron" ++ p.attr ++ ")" ++ "NumSg" ++ ")" ++ "(" ++ "UseN" ++ n.attr ++ ")" ) ; +mkNP18 = mkUnaryCat "UsePN" ; +mkNP19 = mkUnaryCat "UsePron" ; +mkNP20 = \q -> mkCompCat ( "DetNP" ++ "(" ++ "DetQuant" ++ q.attr ++ "NumSg" ++ ")" ) ; +mkNP21 = \q,n -> mkCompCat ( "DetNP" ++ "(" ++ "DetQuant" ++ q.attr ++ n.attr ++ ")" ) ; +mkNP22 = mkUnaryCat "DetNP" ; +mkNP23 = mkUnaryCat "MassNP" ; +mkNP24 = \n -> mkCompCat ( "MassNP" ++ "(" ++ "UseN" ++ n.attr ++ ")" ) ; +mkNP25 = mkBinaryCat "PredetNP" ; +mkNP26 = mkBinaryCat "PPartNP" ; +mkNP27 = mkBinaryCat "AdvNP" ; +mkNP28 = mkBinaryCat "RelNP" ; +mkNP29 = \c,x,y -> mkCompCat ( "ConjNP" ++ c.attr ++ "(" ++ "BaseNP" ++ x.attr ++ y.attr ++ ")" ) ; +mkNP30 = \c,xy -> mkCompCat ( "ConjNP" ++ c.attr ++ xy.attr ) ; +mkNP31 = \q,n -> mkCompCat ( "DetCN" ++ "(" ++ "DetQuant" ++ q.attr ++ "NumSg" ++ ")" ++ n.attr ) ; +mkNP32 = \q,n -> mkCompCat ( "DetCN" ++ "(" ++ "DetQuant" ++ q.attr ++ "NumPl" ++ ")" ++ n.attr ) ; + +i_NP = mkCompCat ("mkNP" ++ "i_Pron") ; +you_NP = mkCompCat ("mkNP" ++ "youSg_Pron") ; +youPol_NP = mkCompCat ("mkNP" ++ "youPol_Pron") ; +he_NP = mkCompCat ("mkNP" ++ "he_Pron") ; +she_NP = mkCompCat ("mkNP" ++ "she_Pron") ; +it_NP = mkCompCat ("mkNP" ++ "it_Pron") ; +we_NP = mkCompCat ("mkNP" ++ "we_Pron") ; +youPl_NP = mkCompCat ("mkNP" ++ "youPl_Pron") ; +they_NP = mkCompCat ("mkNP" ++ "they_Pron") ; +this_NP = mkCompCat ("DetNP" ++ "(" ++ "DetQuant" ++ "this_Quant" ++ "NumSg" ++ ")") ; +that_NP = mkCompCat ("DetNP" ++ "(" ++ "DetQuant" ++ "that_Quant" ++ "NumSg" ++ ")") ; +these_NP = mkCompCat ("DetNP" ++ "(" ++ "DetQuant" ++ "this_Quant" ++ "NumPl" ++ ")") ; +those_NP = mkCompCat ("DetNP" ++ "(" ++ "DetQuant" ++ "that_Quant" ++ "NumPl" ++ ")") ; + + +mkDet1 = \q -> mkCompCat ( "DetQuant" ++ q.attr ++ "NumSg" ) ; +mkDet2 = \d,nu -> mkCompCat ( "DetQuant" ++ d.attr ++ "(" ++ "NumCard" ++ nu.attr ++ ")" ) ; +mkDet3 = \q,o -> mkCompCat ( "DetQuantOrd" ++ q.attr ++ "NumSg" ++ o.attr ) ; +mkDet4 = mkTernaryCat "DetQuantOrd" ; +mkDet5 = mkBinaryCat "DetQuant" ; +mkDet6 = mkUnaryCat ("DetArtCard" ++ "IndefArt" ) ; +mkDet7 = \d -> mkCompCat ( "DetArtCard" ++ "IndefArt" ++ "(" ++ "NumDigits" ++ d.attr ++ ")" ) ; +mkDet8 = \d -> mkCompCat ( "DetArtCard" ++ "IndefArt" ++ "(" ++ "NumNumeral" ++ d.attr ++ ")" ) ; +mkDet9 = \p -> mkCompCat ( "DetQuant" ++ "(" ++ "PossPron" ++ p.attr ++ ")" ++ "NumSg" ) ; +mkDet10 = \p,n -> mkCompCat ( "DetQuant" ++ "(" ++ "PossPron" ++ p.attr ++ ")" ++ n.attr ) ; + +the_Det = mkCompCat ("DetQuant" ++ "DefArt" ++ "NumSg") ; +a_Det = mkCompCat ("DetQuant" ++ "IndefArt" ++ "NumSg") ; +theSg_Det = mkCompCat ("DetQuant" ++ "DefArt" ++ "NumSg") ; +thePl_Det = mkCompCat ("DetQuant" ++ "DefArt" ++ "NumPl") ; +aSg_Det = mkCompCat ("DetQuant" ++ "IndefArt" ++ "NumSg") ; +aPl_Det = mkCompCat ("DetQuant" ++ "DefArt" ++ "NumPl") ; +this_Det = mkCompCat ("DetQuant" ++ "this_Quant" ++ "NumSg") ; +that_Det = mkCompCat ("DetQuant" ++ "that_Quant" ++ "NumSg") ; +these_Det = mkCompCat ("DetQuant" ++ "this_Quant" ++ "NumPl") ; +those_Det = mkCompCat ("DetQuant" ++ "that_Quant" ++ "NumPl") ; + +mkQuant = mkUnaryCat "PossPron" ; + +the_Quant = mkSimpCat "DefArt" ; +a_Quant = mkSimpCat "IndefArt" ; + +mkNum2 = \d -> mkCompCat ( "NumCard" ++ "(" ++ "NumNumeral" ++ d.attr ++ ")" ) ; +mkNum3 = \d -> mkCompCat ( "NumCard" ++ "(" ++ "NumDigits" ++ d.attr ++ ")" ) ; +mkNum4 = \d -> mkCompCat ( "NumCard" ++ "(" ++ "NumNumeral" ++ "(" ++ "num" ++ "(" ++ "pot2as3" ++ "(" ++ "pot1as2" ++ "(" ++ "pot0as1" ++ "(" ++ "pot0" ++ d.attr ++ ")" ++ ")" ++ ")" ++ ")" ++ ")" ++ ")" ) ; +mkNum5 = mkUnaryCat "NumCard" ; +mkNum6 = \a,c -> mkCompCat ( "NumCard" ++ "(" ++ "AdNum" ++ a.attr ++ c.attr ++")" ) ; + +singularNum = mkSimpCat "NumSg" ; +pluralNum = mkSimpCat "NumPl" ; + +mkCard2 = mkUnaryCat "NumNumeral" ; +mkCard3 = mkUnaryCat "NumDigits" ; +mkCard4 = mkBinaryCat "AdNum" ; + +mkOrd1 = mkUnaryCat "OrdNumeral" ; +mkOrd2 = mkUnaryCat "OrdDigits" ; +mkOrd3 = \d -> mkCompCat ( "OrdNumeral" ++ "(" ++ "num" ++ "(" ++ "pot2as3" ++ "(" ++ "pot1as2" ++ "(" ++ "pot0as1" ++ "(" ++ "pot0" ++ d.attr ++ ")" ++ ")" ++ ")" ++ ")" ++ ")" ) ; +mkOrd4 = mkUnaryCat "OrdSuperl" ; + + +mkAdN = mkUnaryCat "AdnCAdv" ; + +mkCN1 = mkUnaryCat "UseN" ; +mkCN2 = mkBinaryCat "ComplN2" ; +mkCN3 = \f,x,n -> mkCompCat ( "ComplN2" ++ "(" ++ "ComplN3" ++ f.attr ++ x.attr ++ ")" ++ n.attr ) ; +mkCN4 = mkUnaryCat "UseN2" ; +mkCN5 = \n -> mkCompCat ( "UseN2" ++ "(" ++ "Use2N3" ++ n.attr ++ ")" ) ; +mkCN6 = \x,y -> mkCompCat ( "AdjCN" ++ "(" ++ "PositA" ++ x.attr ++ ")" ++ "(" ++ "UseN" ++ y.attr ++ ")" ) ; +mkCN7 = \x,y -> mkCompCat ( "AdjCN" ++ "(" ++ "PositA" ++ x.attr ++ ")" ++ y.attr ) ; +mkCN8 = \x,y -> mkCompCat ( "AdjCN" ++ x.attr ++ "(" ++ "UseN" ++ y.attr ++ ")" ) ; +mkCN9 = mkBinaryCat "AdjCN" ; +mkCN10 = \x,y -> mkCompCat ( "AdjCN" ++ y.attr ++ x.attr ) ; +mkCN11 = \x,y -> mkCompCat ( "AdjCN" ++ y.attr ++ "(" ++ "UseN" ++ x.attr ++ ")" ) ; +mkCN12 = \x,y -> mkCompCat ( "RelCN" ++ "(" ++ "UseN" ++ x.attr ++ ")" ++ y.attr ) ; +mkCN13 = mkBinaryCat "RelCN" ; +mkCN14 = \x,y -> mkCompCat ( "AdvCN" ++ "(" ++ "UseN" ++ x.attr ++ ")" ++ y.attr ) ; +mkCN15 = mkBinaryCat "AdvCN" ; +mkCN16 = \cn,s -> mkCompCat ( "SentCN" ++ cn.attr ++ "(" ++ "EmbedS" ++ s.attr ++ ")" ) ; +mkCN17 = \cn,s -> mkCompCat ( "SentCN" ++ cn.attr ++ "(" ++ "EmbedQS" ++ s.attr ++ ")" ) ; +mkCN18 = \cn,s -> mkCompCat ( "SentCN" ++ cn.attr ++ "(" ++ "EmbedVP" ++ s.attr ++ ")" ) ; +mkCN19 = \cn,s -> mkCompCat ( "SentCN" ++ cn.attr ++ s.attr ) ; +mkCN20 = \x,y -> mkCompCat ( "ApposCN" ++ "(" ++ "UseN" ++ x.attr ++ ")" ++ y.attr ) ; +mkCN21 = mkBinaryCat "ApposCN" ; + + + +mkAP1 = mkUnaryCat "PositA" ; +mkAP2 = mkBinaryCat "ComparA" ; +mkAP3 = mkBinaryCat "ComplA2" ; +mkAP4 = mkUnaryCat "UseA2" ; +mkAP5 = \ap,s -> mkCompCat ( "SentAP" ++ ap.attr ++ "(" ++ "EmbedS" ++ s.attr ++ ")" ) ; +mkAP6 = \ap,s -> mkCompCat ( "SentAP" ++ ap.attr ++ "(" ++ "EmbedQS" ++ s.attr ++ ")" ) ; +mkAP7 = \ap,s -> mkCompCat ( "SentAP" ++ ap.attr ++ "(" ++ "EmbedVP" ++ s.attr ++ ")" ) ; +mkAP8 = \ap,s -> mkCompCat ( "SentAP" ++ ap.attr ++ s.attr ) ; +mkAP9 =\x,y -> mkCompCat ( "AdAP" ++ x.attr ++ "(" ++ "PositA" ++ y.attr ++ ")" ) ; +mkAP10 = mkBinaryCat "AdAP" ; +mkAP11 = \c,x,y -> mkCompCat ( "ConjAP" ++ c.attr ++ "(" ++ "BaseAP" ++ x.attr ++ y.attr ++ ")" ) ; +mkAP12 = \c,xy -> mkCompCat ( "ConjAP" ++ c.attr ++ xy.attr ) ; +mkAP13 = mkUnaryCat "AdjOrd" ; +mkAP14 = mkTernaryCat "CAdvAP" ; + +reflAP = mkUnaryCat "ReflA2" ; +comparAP = mkUnaryCat "UseComparA" ; + +mkAdv1 = mkUnaryCat "PositAdvAdj" ; +mkAdv2 = mkBinaryCat "PrepNP" ; +mkAdv3 = mkBinaryCat "SubjS" ; +mkAdv4 = mkTernaryCat "ComparAdvAdj" ; +mkAdv5 = mkTernaryCat "ComparAdvAdjS" ; +mkAdv6 = mkBinaryCat "AdAdv" ; +mkAdv7 = \c,x,y -> mkCompCat ( "ConjAdv" ++ c.attr ++ "(" ++ "BaseAdv" ++ x.attr ++ y.attr ++ ")" ) ; +mkAdv8 = \c,xy -> mkCompCat ( "ConjAdv" ++ c.attr ++ xy.attr ) ; + +mkQS1 = mkUnaryCat ("UseQCl" ++ "(" ++ "TTAnt" ++ "TPres" ++ "ASimul" ++ ")" ++ "PPos") ; +mkQS2 = \t, qcl -> mkCompCat ( "UseQCl" ++ "(" ++ "TTAnt" ++ t.attr ++ "ASimul" ++ ")" ++ "PPos" ++ qcl.attr) ; +mkQS3 = \a, qcl -> mkCompCat ( "UseQCl" ++ "(" ++ "TTAnt" ++"TPres" ++ a.attr ++ ")" ++ "PPos" ++ qcl.attr) ; +mkQS4 = \p, qcl -> mkCompCat ( "UseQCl" ++ "(" ++ "TTAnt" ++ "TPres" ++ "ASimul" ++ ")" ++ p.attr ++ qcl.attr) ; +mkQS5 = \t,a, qcl -> mkCompCat ( "UseQCl" ++ "(" ++ "TTAnt" ++ t.attr ++ a.attr ++ ")" ++ "PPos" ++ qcl.attr) ; +mkQS6 = \t,p, qcl -> mkCompCat ( "UseQCl" ++ "(" ++ "TTAnt" ++ t.attr ++ "ASimul" ++ ")" ++ p.attr ++ qcl.attr) ; +mkQS7 = \a,p, qcl -> mkCompCat ( "UseQCl" ++ "(" ++ "TTAnt" ++"TPres" ++ a.attr ++ ")" ++ p.attr ++ qcl.attr ) ; +mkQS8 = \t,a, p, qcl -> mkCompCat ("UseQCl" ++ "(" ++ "TTAnt" ++ t.attr ++ a.attr ++ ")" ++ p.attr ++ qcl.attr ) ; +mkQS9 = \x -> mkCompCat ( "UseQCl" ++ "(" ++ "TTAnt" ++"TPres" ++ "ASimul" ++ ")"++ "PPos" ++ "(" ++ "QuestCl" ++ x.attr ++ ")") ; + +mkQCl1 = mkUnaryCat "QuestCl" ; +mkQCl2 = mkBinaryCat "QuestVP" ; +mkQCl3 = \s,v -> mkCompCat ( "QuestVP" ++ s.attr ++ "(" ++ "UseV" ++ v.attr ++ ")" ) ; +mkQCl4 = \s,v,o -> mkCompCat ( "QuestVP" ++ s.attr ++ "(" ++ "ComplV2" ++ v.attr ++ o.attr ++ ")" ) ; +mkQCl5 = \s,v,o,i -> mkCompCat ( "QuestVP" ++ s.attr ++ "(" ++ "ComplV3" ++ v.attr ++ o.attr ++ i.attr ++ ")" ) ; +mkQCl6 = \s,v,vp -> mkCompCat ( "QuestVP" ++ s.attr ++ "(" ++ "ComplVV" ++ v.attr ++ vp.attr ++ ")" ) ; +mkQCl7 = \s,v,p -> mkCompCat ( "QuestVP" ++ s.attr ++ "(" ++ "ComplVS" ++ v.attr ++ p.attr ++ ")" ) ; +mkQCl8 = \s,v,q -> mkCompCat ( "QuestVP" ++ s.attr ++ "(" ++ "ComplVQ" ++ v.attr ++ q.attr ++ ")" ) ; +mkQCl9 = \s,v,q -> mkCompCat ( "QuestVP" ++ s.attr ++ "(" ++ "ComplVA" ++ v.attr ++ "(" ++ "PositA" ++ q.attr ++ ")" ++ ")" ) ; +mkQCl10 = \s,v,q -> mkCompCat ( "QuestVP" ++ s.attr ++ "(" ++ "ComplVA" ++ v.attr ++ q.attr ++ ")" ) ; +mkQCl11 = \s,v,n,q -> mkCompCat ( "QuestVP" ++ s.attr ++ "(" ++ "ComplV2A" ++ v.attr ++ n.attr ++ "(" ++ "PositA" ++ q.attr ++ ")" ++ ")" ) ; +mkQCl12 = \s,v,n,q -> mkCompCat ( "QuestVP" ++ s.attr ++ "(" ++ "ComplV2A" ++ v.attr ++ n.attr ++ q.attr ++ ")" ) ; +mkQCl13 = \s,v,n,q -> mkCompCat ( "QuestVP" ++ s.attr ++ "(" ++ "ComplSlash" ++ "(" ++ "SlashV2S" ++ v.attr ++ q.attr ++ ")" ++ n.attr ++ ")" ) ; +mkQCl14 = \s,v,n,q -> mkCompCat ( "QuestVP" ++ s.attr ++ "(" ++ "ComplSlash" ++ "(" ++ "SlashV2Q" ++ v.attr ++ q.attr ++ ")" ++ n.attr ++ ")" ) ; +mkQCl15 = \s,v,n,q -> mkCompCat ( "QuestVP" ++ s.attr ++ "(" ++ "ComplSlash" ++ "(" ++ "SlashV2V" ++ v.attr ++ q.attr ++ ")" ++ n.attr ++ ")" ) ; +mkQCl16 = \x,y -> mkCompCat ( "QuestVP" ++ x.attr ++ "(" ++ "UseComp" ++ "(" ++ "CompAP" ++ "(" ++ "PositA" ++ y.attr ++ ")" ++ ")" ++ ")" ) ; +mkQCl17 = \x,y,z -> mkCompCat ( "QuestVP" ++ x.attr ++ "(" ++ "UseComp" ++ "(" ++ "CompAP" ++ "(" ++ "ComparA" ++ y.attr ++ z.attr ++ ")" ++ ")" ++ ")" ) ; +mkQCl18 = \x,y,z -> mkCompCat ( "QuestVP" ++ x.attr ++ "(" ++ "UseComp" ++ "(" ++ "CompAP" ++ "(" ++ "ComplA2" ++ y.attr ++ z.attr ++ ")" ++ ")" ++ ")" ) ; +mkQCl19 = \x,y -> mkCompCat ( "QuestVP" ++ x.attr ++ "(" ++ "UseComp" ++ "(" ++ "CompAP" ++ y.attr ++ ")" ++ ")" ) ; +mkQCl20 = \x,y -> mkCompCat ( "QuestVP" ++ x.attr ++ "(" ++ "UseComp" ++ "(" ++ "CompNP" ++ y.attr ++ ")" ++ ")" ) ; +mkQCl21 = \x,y -> mkCompCat ( "QuestVP" ++ x.attr ++ "(" ++ "UseComp" ++ "(" ++ "CompCN" ++ "(" ++ "UseN" ++ y.attr ++ ")" ++ ")" ++ ")" ) ; +mkQCl22 = \x,y -> mkCompCat ( "QuestVP" ++ x.attr ++ "(" ++ "UseComp" ++ "(" ++ "CompCN" ++ y.attr ++ ")" ++ ")" ) ; +mkQCl23 = \x,y -> mkCompCat ( "QuestVP" ++ x.attr ++ "(" ++ "UseComp" ++ "(" ++ "CompAdv" ++ y.attr ++ ")" ++ ")" ) ; +mkQCl24 = \ip,np,v -> mkCompCat ( "QuestSlash" ++ ip.attr ++ "(" ++ "SlashVP" ++ np.attr ++ "(" ++ "SlashV2a" ++ v.attr ++ ")" ++ ")" ) ; +mkQCl25 = mkBinaryCat "QuestSlash" ; +mkQCl26 = mkBinaryCat "QuestIAdv" ; +mkQCl27 = \p,ip, cl -> mkCompCat ( "QuestIAdv" ++ "(" ++ "PrepIP" ++ p.attr ++ ip.attr ++ ")" ++ cl.attr ) ; +mkQCl28 = \a,n -> mkCompCat ( "QuestIComp" ++ "(" ++ "CompIAdv" ++ a.attr ++ ")" ++ n.attr ) ; +mkQCl29 = \a,n -> mkCompCat ( "QuestIComp" ++ a.attr ++ n.attr) ; +mkQCl30 = mkUnaryCat "ExistIP" ; + +mkIComp1 = mkUnaryCat "CompIAdv" ; +mkIComp2 = mkUnaryCat "CompIP" ; + +mkIP1 = mkBinaryCat "IdetCN" ; +mkIP2 = \i,n -> mkCompCat ( "IdetCN" ++ i.attr ++ "(" ++ "UseN" ++ n.attr ++ ")" ) ; +mkIP3 = mkUnaryCat "IdetIP" ; +mkIP4 = \i,n -> mkCompCat ( "IdetCN" ++ "(" ++ "IdetQuant" ++ i.attr ++ "NumSg" ++ ")" ++ n.attr ) ; +mkIP5 = \i,nu,n -> mkCompCat ( "IdetCN" ++ "(" ++ "IdetQuant" ++ i.attr ++ nu.attr ++ ")" ++ n.attr ) ; +mkIP6 = \i,n -> mkCompCat ( "IdetCN" ++ "(" ++ "IdetQuant" ++ i.attr ++ "NumSg" ++ ")" ++ "(" ++ "UseN" ++ n.attr ++ ")" ) ; +mkIP7 = mkBinaryCat "AdvIP" ; + +what_IP = mkSimpCat "whatSg_IP" ; +who_IP = mkSimpCat "whoSg_IP" ; + +mkIAdv1 = mkBinaryCat "PrepIP" ; +mkIAdv2 = mkBinaryCat "AdvIAdv" ; + +mkIDet1 = \i,nu -> mkCompCat ( "IdetQuant" ++ i.attr ++ nu.attr ) ; +mkIDet2 = \i -> mkCompCat ( "IdetQuant" ++ i.attr ++ "NumSg" ) ; + +which_IDet = mkSimpCat "whichSg_IDet" ; +whichSg_IDet =mkCompCat ("IdetQuant" ++ "which_IQuant" ++ "NumSg") ; +whichPl_IDet = mkCompCat ("IdetQuant" ++ "which_IQuant" ++ "NumPl") ; + +mkRS1 = mkUnaryCat ("UseRCl" ++ "(" ++ "TTAnt" ++ "TPres" ++ "ASimul" ++ ")" ++ "PPos") ; +mkRS2 = \t, rcl -> mkCompCat ( "UseRCl" ++ "(" ++ "TTAnt" ++ t.attr ++ "ASimul" ++ ")" ++ "PPos" ++ rcl.attr ) ; +mkRS3 = \a, rcl -> mkCompCat ( "UseRCl" ++ "(" ++ "TTAnt" ++ "TPres" ++ a.attr ++ ")" ++ "PPos" ++ rcl.attr ) ; +mkRS4 = \p, rcl -> mkCompCat ( "UseRCl" ++ "(" ++ "TTAnt" ++ "TPres" ++ "ASimul" ++ ")" ++ p.attr ++ rcl.attr ) ; +mkRS5 = \t,a, rcl -> mkCompCat ( "UseRCl" ++ "(" ++ "TTAnt" ++ t.attr ++ a.attr ++ ")" ++ "PPos" ++ rcl.attr) ; +mkRS6 = \t,p, rcl -> mkCompCat ( "UseRCl" ++ "(" ++ "TTAnt" ++ t.attr ++ "ASimul" ++ ")" ++ p.attr ++ rcl.attr) ; +mkRS7 = \a,p, rcl -> mkCompCat ( "UseRCl" ++ "(" ++ "TTAnt" ++"TPres" ++ a.attr ++ ")" ++ p.attr ++ rcl.attr ) ; +mkRS8 = \t,a,p,rcl -> mkCompCat ("UseRCl" ++ "(" ++ "TTAnt" ++ t.attr ++ a.attr ++ ")" ++ p.attr ++ rcl.attr ) ; +mkRS9 = mkTernaryCat "UseRCl" ; +mkRS10 = \c,x,y -> mkCompCat ( "ConjRS" ++ c.attr ++ "(" ++ "BaseRS" ++ x.attr ++ y.attr ++ ")" ) ; +mkRS11 = \c,xy -> mkCompCat ( "ConjRS" ++ c.attr ++ xy.attr ) ; + +mkRCl1 = mkBinaryCat "RelVP" ; +mkRCl2 = \s,v -> mkCompCat ( "RelVP" ++ s.attr ++ "(" ++ "UseV" ++ v.attr ++ ")" ) ; +mkRCl3 = \s,v,o -> mkCompCat ( "RelVP" ++ s.attr ++ "(" ++ "ComplV2" ++ v.attr ++ o.attr ++ ")" ) ; +mkRCl4 = \s,v,o,i -> mkCompCat ( "RelVP" ++ s.attr ++ "(" ++ "ComplV3" ++ v.attr ++ o.attr ++ i.attr ++ ")" ) ; +mkRCl5 = \s,v,vp -> mkCompCat ( "RelVP" ++ s.attr ++ "(" ++ "ComplVV" ++ v.attr ++ vp.attr ++ ")" ) ; +mkRCl6 = \s,v,p -> mkCompCat ( "RelVP" ++ s.attr ++ "(" ++ "ComplVS" ++ v.attr ++ p.attr ++ ")" ) ; +mkRCl7 = \s,v,q -> mkCompCat ( "RelVP" ++ s.attr ++ "(" ++ "ComplVQ" ++ v.attr ++ q.attr ++ ")" ) ; +mkRCl8 = \s,v,q -> mkCompCat ( "RelVP" ++ s.attr ++ "(" ++ "ComplVA" ++ v.attr ++ "(" ++ "PositA" ++ q.attr ++ ")" ++ ")" ) ; +mkRCl9 = \s,v,q -> mkCompCat ( "RelVP" ++ s.attr ++ "(" ++ "ComplVA" ++ v.attr ++ q.attr ++ ")" ) ; +mkRCl10 = \s,v,n,q -> mkCompCat ( "RelVP" ++ s.attr ++ "(" ++ "ComplV2A" ++ v.attr ++ n.attr ++ "(" ++ "PositA" ++ q.attr ++ ")" ++ ")" ) ; +mkRCl11 = \s,v,n,q -> mkCompCat ( "RelVP" ++ s.attr ++ "(" ++ "ComplV2A" ++ v.attr ++ n.attr ++ q.attr ++ ")" ) ; +mkRCl12 = \s,v,n,q -> mkCompCat ( "RelVP" ++ s.attr ++ "(" ++ "ComplSlash" ++ "(" ++ "SlashV2S" ++ v.attr ++ q.attr ++ ")" ++ n.attr ++ ")" ) ; +mkRCl13 = \s,v,n,q -> mkCompCat ( "RelVP" ++ s.attr ++ "(" ++ "ComplSlash" ++ "(" ++ "SlashV2Q" ++ v.attr ++ q.attr ++ ")" ++ n.attr ++ ")" ) ; +mkRCl14 = \s,v,n,q -> mkCompCat ( "RelVP" ++ s.attr ++ "(" ++ "ComplSlash" ++ "(" ++ "SlashV2V" ++ v.attr ++ q.attr ++ ")" ++ n.attr ++ ")" ) ; +mkRCl15 = \x,y -> mkCompCat ( "RelVP" ++ x.attr ++ "(" ++ "UseComp" ++ "(" ++ "CompAP" ++ "(" ++ "PositA" ++ y.attr ++ ")" ++ ")" ++ ")" ) ; +mkRCl16 = \x,y,z -> mkCompCat ( "RelVP" ++ x.attr ++ "(" ++ "UseComp" ++ "(" ++ "CompAP" ++ "(" ++ "ComparA" ++ y.attr ++ z.attr ++ ")" ++ ")" ++ ")" ) ; +mkRCl17 = \x,y,z -> mkCompCat ( "RelVP" ++ x.attr ++ "(" ++ "UseComp" ++ "(" ++ "CompAP" ++ "(" ++ "ComplA2" ++ y.attr ++ z.attr ++ ")" ++ ")" ++ ")" ) ; +mkRCl18 = \x,y -> mkCompCat ( "RelVP" ++ x.attr ++ "(" ++ "UseComp" ++ "(" ++ "CompAP" ++ y.attr ++ ")" ++ ")" ) ; +mkRCl19 = \x,y -> mkCompCat ( "RelVP" ++ x.attr ++ "(" ++ "UseComp" ++ "(" ++ "CompNP" ++ y.attr ++ ")" ++ ")" ) ; +mkRCl20 = \x,y -> mkCompCat ( "RelVP" ++ x.attr ++ "(" ++ "UseComp" ++ "(" ++ "CompCN" ++ "(" ++ "UseN" ++ y.attr ++ ")" ++ ")" ++ ")" ) ; +mkRCl21 = \x,y -> mkCompCat ( "RelVP" ++ x.attr ++ "(" ++ "UseComp" ++ "(" ++ "CompCN" ++ y.attr ++ ")" ++ ")" ) ; +mkRCl22 = \x,y -> mkCompCat ( "RelVP" ++ x.attr ++ "(" ++ "UseComp" ++ "(" ++ "CompAdv" ++ y.attr ++ ")" ++ ")" ) ; +mkRCl23 = \ip,np,v -> mkCompCat ( "RelSlash" ++ ip.attr ++ "(" ++ "SlashVP" ++ np.attr ++ "(" ++ "SlashV2a" ++ v.attr ++ ")" ++ ")" ) ; +mkRCl24 = mkBinaryCat "RelSlash" ; +mkRCl25 = mkUnaryCat "RelCl" ; + +which_RP = mkSimpCat "IdRP" ; + +mkRP = mkTernaryCat "FunRP" ; + +mkSSlash = mkTernaryCat "UseSlash" ; + +mkClSlash1 = \np,vps -> mkCompCat ( "SlashVP" ++ np.attr ++ vps.attr ) ; +mkClSlash2 = \np,v2 -> mkCompCat ( "SlashVP" ++ np.attr ++ "(" ++ "SlashV2a" ++ v2.attr ++ ")" ) ; +mkClSlash3 = \np,vv,v2 -> mkCompCat ( "SlashVP" ++ np.attr ++ "(" ++ "SlashVV" ++ vv.attr ++ "(" ++ "SlashV2a" ++ v2.attr ++ ")" ++ ")" ) ; +mkClSlash4 = mkBinaryCat "SlashPrep" ; +mkClSlash5 = mkBinaryCat "AdvSlash" ; +mkClSlash6 = mkTernaryCat "SlashVS" ; + +mkVPSlash1 = mkUnaryCat "SlashV2a" ; +mkVPSlash2 = mkBinaryCat "Slash2V3" ; +mkVPSlash3 = mkBinaryCat "SlashV2A" ; +mkVPSlash4 = mkBinaryCat "SlashV2Q" ; +mkVPSlash5 = mkBinaryCat "SlashV2S" ; +mkVPSlash6 = mkBinaryCat "SlashV2V" ; +mkVPSlash7 = mkBinaryCat "SlashVV" ; +mkVPSlash8 = mkTernaryCat "SlashV2VNP" ; + +mkListS1 = mkBinaryCat "BaseS" ; +mkListS2 = mkBinaryCat "ConsS" ; + +mkListAdv1 = mkBinaryCat "BaseAdv" ; +mkListAdv2 = mkBinaryCat "ConsAdv" ; + +mkListAP1 = mkBinaryCat "BaseAP" ; +mkListAP2 = mkBinaryCat "ConsAP" ; + +mkListNP1 = mkBinaryCat "BaseNP" ; +mkListNP2 = mkBinaryCat "ConsNP" ; + +mkListRS1 = mkBinaryCat "BaseRS" ; +mkListRS2 = mkBinaryCat "ConsRS" ; + + the_Art = mkSimpCat "DefArt" ; + a_Art = mkSimpCat "IndefArt" ; + sgNum = mkSimpCat "NumSg"; + plNum = mkSimpCat "NumPl" ; + +oper mkSimpCat : Str-> {ind : Str ; attr : Str} = \s -> {ind = s; attr = s}; + +oper mkCompCat : Str -> {ind : Str ; attr : Str} = \s -> {ind = s; attr = "(" ++ s ++ ")"} ; + +oper mkUnaryCat : Str -> {ind : Str ; attr : Str} -> {ind : Str ; attr : Str} = \s, o1 -> + {ind = s ++ o1.attr ; + attr = "(" ++ s ++ o1.attr ++ ")"}; + +oper mkBinaryCat : Str -> {ind : Str; attr : Str} -> {ind : Str; attr : Str} -> {ind : Str ; attr : Str} = \s, o1, o2 -> + {ind = s ++ o1.attr ++ o2.attr; + attr = "(" ++ s ++ o1.attr ++ o2.attr ++ ")"}; + +oper mkTernaryCat : Str -> {ind : Str; attr : Str} -> {ind : Str; attr : Str} -> {ind : Str; attr: Str} -> {ind : Str ; attr : Str} = \s, o1, o2, o3 -> + {ind = s ++ o1.attr ++ o2.attr ++ o3.attr; + attr = "(" ++ s ++ o1.attr ++ o2.attr ++ o3.attr ++")"}; + + +oper mkQuaternaryCat : Str -> {ind : Str; attr : Str} -> {ind : Str; attr : Str} -> {ind : Str; attr : Str} -> {ind : Str; attr: Str} -> {ind : Str ; attr : Str} = \s, o1, o2, o3, o4 -> + {ind = s ++ o1.attr ++ o2.attr ++ o3.attr ++ o4.attr; + attr = "(" ++ s ++ o1.attr ++ o2.attr ++ o3.attr ++o4.attr++ ")"}; + + +----------------------------- + +----------------------------- +lin + +testNoun i = mkCompCat ("noun"++ i.s) ; +testA i = mkCompCat ("adj" ++ i.s) ; +testV i = mkCompCat ("verb" ++ i.s) ; +testV2 i = mkCompCat ("verb2" ++ i.s) ; +testAdv i = mkCompCat ("adv" ++ i.s) ; + +} diff --git a/lib/src/api/abstract_to_api/AbsToAPIapi.gf b/lib/src/api/abstract_to_api/AbsToAPIapi.gf new file mode 100644 index 000000000..052be40de --- /dev/null +++ b/lib/src/api/abstract_to_api/AbsToAPIapi.gf @@ -0,0 +1,500 @@ +concrete AbsToAPIapi of AbsToAPI = { + +lincat +A, A2, AP, AdA, AdN, AdV, Adv, Ant, Art, CAdv, CN, Card, Cl, ClSlash, Comp, Conj, Det, Dig, Digit, Digits, IAdv, IComp, IDet, IP, IQuant, Imp, Interj, ListAP, ListAdv, ListCN, ListIAdv, ListNP, ListRS, ListS, N, N2, N3, NP, Num, Numeral, Ord, PConj, PN, Phr, Pol, Predet, Prep, Pron, QCl, QS, QVP, Quant, RCl, RP, RS, S, SC, SSlash, Subj, Temp, Tense, Text, Utt, V, V2, V2A, V2Q, V2S, V2V, V3, VA, VP, VPSlash, VQ, VS, VV, Voc, Punct, String , QuantSg , QuantPl , ImpForm = {ind : Str; attr : Str} ; + +lin + + mkText1 = mkTernaryCat "mkText" ; + mkText2 = mkBinaryCat "mkText" ; + mkText3 = mkBinaryCat "mkText" ; + mkText4 = mkUnaryCat "mkText" ; + mkText5 = mkUnaryCat "mkText" ; + mkText6 = mkUnaryCat "mkText" ; + mkText7 = mkUnaryCat "mkText" ; + mkText8 = mkUnaryCat "mkText" ; + mkText9 = mkBinaryCat "mkText" ; + mkText10 = mkUnaryCat "mkText" ; + + emptyText = mkSimpCat "emptyText"; + + + fullStopPunct = mkSimpCat "fullStopPunct" ; + questMarkPunct = mkSimpCat "questMarkPunct" ; + exclMarkPunct = mkSimpCat "exclMarkPunct" ; + + mkPhr1 = mkTernaryCat "mkPhr" ; + mkPhr2 = mkBinaryCat "mkPhr" ; + mkPhr3 = mkBinaryCat "mkPhr" ; + mkPhr4 = mkUnaryCat "mkPhr" ; + mkPhr5 = mkUnaryCat "mkPhr" ; + mkPhr6 = mkUnaryCat "mkPhr" ; + mkPhr7 = mkUnaryCat "mkPhr" ; + mkPhr8 = mkUnaryCat "mkPhr" ; + + mkPConj = mkUnaryCat "mkPConj" ; + noPConj = mkSimpCat "noPConj" ; + + mkVoc = mkUnaryCat "mkVoc" ; + noVoc = mkSimpCat "noVoc" ; + + mkUtt1 = mkUnaryCat "mkUtt" ; + mkUtt2 = mkUnaryCat "mkUtt" ; + mkUtt3 = mkUnaryCat "mkUtt" ; + mkUtt4 = mkUnaryCat "mkUtt" ; + mkUtt5 = mkTernaryCat "mkUtt" ; + mkUtt6 = mkBinaryCat "mkUtt" ; + mkUtt7 = mkBinaryCat "mkUtt" ; + mkUtt8 = mkUnaryCat "mkUtt" ; + mkUtt9 = mkUnaryCat "mkUtt" ; + mkUtt10 = mkUnaryCat "mkUtt" ; + mkUtt11 = mkUnaryCat "mkUtt" ; + mkUtt12 = mkUnaryCat "mkUtt" ; + mkUtt13 = mkUnaryCat "mkUtt" ; + mkUtt14 = mkUnaryCat "mkUtt" ; + mkUtt15 = mkUnaryCat "mkUtt" ; + mkUtt16 = mkUnaryCat "mkUtt" ; + + lets_Utt = mkUnaryCat "lets_Utt" ; + + positivePol = mkSimpCat "positivePol" ; + negativePol = mkSimpCat "negativePol" ; + + simultaneousAnt = mkSimpCat "simultaneousAnt" ; + anteriorAnt = mkSimpCat "anteriorAnt" ; + + presentTense = mkSimpCat "presentTense" ; + pastTense = mkSimpCat "pastTense" ; + futureTense = mkSimpCat "futureTense" ; + conditionalTense = mkSimpCat "conditionalTense" ; + + mkTemp = mkBinaryCat "mkTemp" ; + + singularImpForm = mkSimpCat "singularImpForm" ; + pluralImpForm = mkSimpCat "pluralImpForm" ; + politeImpForm = mkSimpCat "politeImpForm" ; + + mkS1 = mkUnaryCat "mkS" ; + mkS2 = mkBinaryCat "mkS" ; + mkS3 = mkBinaryCat "mkS" ; + mkS4 = mkBinaryCat "mkS" ; + mkS5 = mkTernaryCat "mkS" ; + mkS6 = mkTernaryCat "mkS" ; + mkS7 = mkTernaryCat "mkS" ; + mkS8 = mkQuaternaryCat "mkS" ; + mkS9 = mkTernaryCat "mkS" ; + mkS10 = mkTernaryCat "mkS" ; + mkS11 = mkBinaryCat "mkS" ; + mkS12 = mkBinaryCat "mkS" ; + + mkCl1 = mkBinaryCat "mkCl" ; + mkCl2 = mkTernaryCat "mkCl" ; + mkCl3 = mkQuaternaryCat "mkCl" ; + mkCl4 = mkTernaryCat "mkCl" ; + mkCl5 = mkTernaryCat "mkCl" ; + mkCl6 = mkTernaryCat "mkCl" ; + mkCl7 = mkTernaryCat "mkCl" ; + mkCl8 = mkTernaryCat "mkCl" ; + mkCl9 = mkQuaternaryCat "mkCl" ; + mkCl10 = mkQuaternaryCat "mkCl" ; + mkCl11 = mkQuaternaryCat "mkCl" ; + mkCl12 = mkQuaternaryCat "mkCl" ; + mkCl13 = mkQuaternaryCat "mkCl" ; + mkCl14 = mkBinaryCat "mkCl" ; + mkCl15 = mkTernaryCat "mkCl" ; + mkCl16 = mkTernaryCat "mkCl" ; + mkCl17 = mkBinaryCat "mkCl" ; + mkCl18 = mkBinaryCat "mkCl" ; + mkCl19 = mkBinaryCat "mkCl" ; + mkCl20 = mkBinaryCat "mkCl" ; + mkCl21 = mkBinaryCat "mkCl" ; + mkCl22 = mkBinaryCat "mkCl" ; + mkCl23 = mkUnaryCat "mkCl" ; + mkCl24 = mkUnaryCat "mkCl" ; + mkCl25 = mkUnaryCat "mkCl" ; + mkCl26 = mkBinaryCat "mkCl" ; + mkCl27 = mkBinaryCat "mkCl" ; + mkCl28 = mkUnaryCat "mkCl" ; + mkCl29 = mkUnaryCat "mkCl" ; + mkCl30 = mkBinaryCat "mkCl" ; + + genericCl = mkUnaryCat "genericCl" ; + + mkVP1 = mkUnaryCat "mkVP" ; + mkVP2 = mkBinaryCat "mkVP" ; + mkVP3 = mkTernaryCat "mkVP" ; + mkVP4 = mkBinaryCat "mkVP" ; + mkVP5 = mkBinaryCat "mkVP" ; + mkVP6 = mkBinaryCat "mkVP" ; + mkVP7 = mkBinaryCat "mkVP" ; + mkVP8 = mkTernaryCat "mkVP" ; + mkVP9 = mkTernaryCat "mkVP" ; + mkVP10 = mkTernaryCat "mkVP" ; + mkVP11 = mkTernaryCat "mkVP" ; + mkVP12 = mkUnaryCat "mkVP" ; + mkVP13 = mkBinaryCat "mkVP" ; + mkVP14 = mkBinaryCat "mkVP" ; + mkVP15 = mkUnaryCat "mkVP" ; + mkVP16 = mkUnaryCat "mkVP" ; + mkVP17 = mkUnaryCat "mkVP" ; + mkVP18 = mkUnaryCat "mkVP" ; + mkVP19 = mkUnaryCat "mkVP" ; + mkVP20 = mkBinaryCat "mkVP" ; + mkVP21 = mkBinaryCat "mkVP" ; + mkVP22 = mkBinaryCat "mkVP" ; + mkVP23 = mkUnaryCat "mkVP" ; + mkVP24 = mkUnaryCat "mkVP" ; + + reflexiveVP1 = mkUnaryCat "reflexiveVP" ; + reflexiveVP2 = mkUnaryCat "reflexiveVP" ; + + passiveVP1 = mkUnaryCat "passiveVP" ; + passiveVP2 = mkBinaryCat "passiveVP" ; + + progressiveVP = mkUnaryCat "progressiveVP" ; + + mkComp1 = mkUnaryCat "mkComp" ; + mkComp2 = mkUnaryCat "mkComp" ; + mkComp3 = mkUnaryCat "mkComp" ; + + mkSC1 = mkUnaryCat "mkSC" ; + mkSC2 = mkUnaryCat "mkSC" ; + mkSC3 = mkUnaryCat "mkSC" ; + + mkImp1 = mkUnaryCat "mkImp" ; + mkImp2 = mkUnaryCat "mkImp" ; + mkImp3 = mkBinaryCat "mkImp" ; + + mkNP1 = mkBinaryCat "mkNP" ; + mkNP2 = mkBinaryCat "mkNP" ; + mkNP3 = mkTernaryCat "mkNP" ; + mkNP4 = mkQuaternaryCat "mkNP" ; + mkNP5 = mkTernaryCat "mkNP" ; + mkNP6 = mkBinaryCat "mkNP" ; + mkNP7 = mkBinaryCat "mkNP" ; + mkNP8 = mkBinaryCat "mkNP" ; + mkNP9 = mkBinaryCat "mkNP" ; + mkNP10 = mkBinaryCat "mkNP" ; + mkNP11 = mkBinaryCat "mkNP" ; + mkNP12 = mkBinaryCat "mkNP" ; + mkNP13 = mkBinaryCat "mkNP" ; + mkNP14 = mkBinaryCat "mkNP" ; + mkNP15 = mkBinaryCat "mkNP" ; + mkNP16 = mkBinaryCat "mkNP" ; + mkNP17 = mkBinaryCat "mkNP" ; + mkNP18 = mkUnaryCat "mkNP" ; + mkNP19 = mkUnaryCat "mkNP" ; + mkNP20 = mkUnaryCat "mkNP" ; + mkNP21 = mkBinaryCat "mkNP" ; + mkNP22 = mkUnaryCat "mkNP" ; + mkNP23 = mkUnaryCat "mkNP" ; + mkNP24 = mkUnaryCat "mkNP" ; + mkNP25 = mkBinaryCat "mkNP" ; + mkNP26 = mkBinaryCat "mkNP" ; + mkNP27 = mkBinaryCat "mkNP" ; + mkNP28 = mkBinaryCat "mkNP" ; + mkNP29 = mkTernaryCat "mkNP" ; + mkNP30 = mkBinaryCat "mkNP" ; + mkNP31 = mkBinaryCat "mkNP" ; + mkNP32 = mkBinaryCat "mkNP" ; + + i_NP = mkSimpCat "i_NP" ; + you_NP = mkSimpCat "you_NP" ; + youPol_NP = mkSimpCat "youPol_NP" ; + he_NP = mkSimpCat "he_NP" ; + she_NP = mkSimpCat "she_NP" ; + it_NP = mkSimpCat "it_NP" ; + we_NP = mkSimpCat "we_NP" ; + youPl_NP = mkSimpCat "youPl_NP" ; + they_NP = mkSimpCat "they_NP" ; + this_NP = mkSimpCat "this_NP" ; + that_NP = mkSimpCat "that_NP" ; + these_NP = mkSimpCat "these_NP" ; + those_NP = mkSimpCat "those_NP" ; + + mkDet1 = mkUnaryCat "mkDet" ; + mkDet2 = mkBinaryCat "mkDet" ; + mkDet3 = mkBinaryCat "mkDet" ; + mkDet4 = mkTernaryCat "mkDet" ; + mkDet5 = mkBinaryCat "mkDet" ; + mkDet6 = mkUnaryCat "mkDet" ; + mkDet7 = mkUnaryCat "mkDet" ; + mkDet8 = mkUnaryCat "mkDet" ; + mkDet9 = mkUnaryCat "mkDet" ; + mkDet10 = mkBinaryCat "mkDet" ; + + the_Det = mkSimpCat "the_Det" ; + a_Det = mkSimpCat "a_Det" ; + theSg_Det = mkSimpCat "theSg_Det" ; + thePl_Det = mkSimpCat "thePl_Det" ; + aSg_Det = mkSimpCat "aSg_Det" ; + aPl_Det = mkSimpCat "aPl_Det" ; + this_Det = mkSimpCat "this_Det" ; + that_Det = mkSimpCat "that_Det" ; + these_Det = mkSimpCat "these_Det" ; + those_Det = mkSimpCat "those_Det" ; + + mkQuant = mkUnaryCat "mkQuant" ; + + the_Quant = mkSimpCat "the_Quant" ; + a_Quant = mkSimpCat "a_Quant" ; + + --mkNum1 = mkUnaryCat "mkNum" ; + mkNum2 = mkUnaryCat "mkNum" ; + mkNum3 = mkUnaryCat "mkNum" ; + mkNum4 = mkUnaryCat "mkNum" ; + mkNum5 = mkUnaryCat "mkNum" ; + mkNum6 = mkBinaryCat "mkNum" ; + + singularNum = mkSimpCat "singularNum" ; + pluralNum = mkSimpCat "pluralNum" ; + + --mkCard1 = mkUnaryCat "mkCard" ; + mkCard2 = mkUnaryCat "mkCard" ; + mkCard3 = mkUnaryCat "mkCard" ; + mkCard4 = mkBinaryCat "mkCard" ; + + mkOrd1 = mkUnaryCat "mkOrd" ; + mkOrd2 = mkUnaryCat "mkOrd" ; + mkOrd3 = mkUnaryCat "mkOrd" ; + mkOrd4 = mkUnaryCat "mkOrd" ; + + mkAdN = mkUnaryCat "mkAdN" ; + + mkCN1 = mkUnaryCat "mkCN" ; + mkCN2 = mkBinaryCat "mkCN" ; + mkCN3 = mkTernaryCat "mkCN" ; + mkCN4 = mkUnaryCat "mkCN" ; + mkCN5 = mkUnaryCat "mkCN" ; + mkCN6 = mkBinaryCat "mkCN" ; + mkCN7 = mkBinaryCat "mkCN" ; + mkCN8 = mkBinaryCat "mkCN" ; + mkCN9 = mkBinaryCat "mkCN" ; + mkCN10 = mkBinaryCat "mkCN" ; + mkCN11 = mkBinaryCat "mkCN" ; + mkCN12 = mkBinaryCat "mkCN" ; + mkCN13 = mkBinaryCat "mkCN" ; + mkCN14 = mkBinaryCat "mkCN" ; + mkCN15 = mkBinaryCat "mkCN" ; + mkCN16 = mkBinaryCat "mkCN" ; + mkCN17 = mkBinaryCat "mkCN" ; + mkCN18 = mkBinaryCat "mkCN" ; + mkCN19 = mkBinaryCat "mkCN" ; + mkCN20 = mkBinaryCat "mkCN" ; + mkCN21 = mkBinaryCat "mkCN" ; + + mkAP1 = mkUnaryCat "mkAP" ; + mkAP2 = mkBinaryCat "mkAP" ; + mkAP3 = mkBinaryCat "mkAP" ; + mkAP4 = mkUnaryCat "mkAP" ; + mkAP5 = mkBinaryCat "mkAP" ; + mkAP6 = mkBinaryCat "mkAP" ; + mkAP7 = mkBinaryCat "mkAP" ; + mkAP8 = mkBinaryCat "mkAP" ; + mkAP9 = mkBinaryCat "mkAP" ; + mkAP10 = mkBinaryCat "mkAP" ; + mkAP11 = mkTernaryCat "mkAP" ; + mkAP12 = mkBinaryCat "mkAP" ; + mkAP13 = mkUnaryCat "mkAP" ; + mkAP14 = mkTernaryCat "mkAP" ; + + reflAP = mkUnaryCat "reflAP" ; + comparAP = mkUnaryCat "comparAP" ; + + mkAdv1 = mkUnaryCat "mkAdv" ; + mkAdv2 = mkBinaryCat "mkAdv" ; + mkAdv3 = mkBinaryCat "mkAdv" ; + mkAdv4 = mkTernaryCat "mkAdv" ; + mkAdv5 = mkTernaryCat "mkAdv" ; + mkAdv6 = mkBinaryCat "mkAdv" ; + mkAdv7 = mkTernaryCat "mkAdv" ; + mkAdv8 = mkBinaryCat "mkAdv" ; + + mkQS1 = mkUnaryCat "mkQS" ; + mkQS2 = mkBinaryCat "mkQS" ; + mkQS3 = mkBinaryCat "mkQS" ; + mkQS4 = mkBinaryCat "mkQS" ; + mkQS5 = mkTernaryCat "mkQS" ; + mkQS6 = mkTernaryCat "mkQS" ; + mkQS7 = mkTernaryCat "mkQS" ; + mkQS8 = mkQuaternaryCat "mkQS" ; + mkQS9 = mkUnaryCat "mkQS" ; + + mkQCl1 = mkUnaryCat "mkQCl" ; + mkQCl2 = mkBinaryCat "mkQCl" ; + mkQCl3 = mkBinaryCat "mkQCl" ; + mkQCl4 = mkTernaryCat "mkQCl" ; + mkQCl5 = mkQuaternaryCat "mkQCl" ; + mkQCl6 = mkTernaryCat "mkQCl" ; + mkQCl7 = mkTernaryCat "mkQCl" ; + mkQCl8 = mkTernaryCat "mkQCl" ; + mkQCl9 = mkTernaryCat "mkQCl" ; + mkQCl10 = mkTernaryCat "mkQCl" ; + mkQCl11 = mkQuaternaryCat "mkQCl" ; + mkQCl12 = mkQuaternaryCat "mkQCl" ; + mkQCl13 = mkQuaternaryCat "mkQCl" ; + mkQCl14 = mkQuaternaryCat "mkQCl" ; + mkQCl15 = mkQuaternaryCat "mkQCl" ; + mkQCl16 = mkBinaryCat "mkQCl" ; + mkQCl17 = mkTernaryCat "mkQCl" ; + mkQCl18 = mkTernaryCat "mkQCl" ; + mkQCl19 = mkBinaryCat "mkQCl" ; + mkQCl20 = mkBinaryCat "mkQCl" ; + mkQCl21 = mkBinaryCat "mkQCl" ; + mkQCl22 = mkBinaryCat "mkQCl" ; + mkQCl23 = mkBinaryCat "mkQCl" ; + mkQCl24 = mkTernaryCat "mkQCl" ; + mkQCl25 = mkBinaryCat "mkQCl" ; + mkQCl26 = mkBinaryCat "mkQCl" ; + mkQCl27 = mkTernaryCat "mkQCl" ; + mkQCl28 = mkBinaryCat "mkQCl" ; + mkQCl29 = mkBinaryCat "mkQCl" ; + mkQCl30 = mkUnaryCat "mkQCl" ; + + mkIComp1 = mkUnaryCat "mkIComp" ; + mkIComp2 = mkUnaryCat "mkIComp" ; + + mkIP1 = mkBinaryCat "mkIP" ; + mkIP2 = mkBinaryCat "mkIP" ; + mkIP3 = mkUnaryCat "mkIP" ; + mkIP4 = mkBinaryCat "mkIP" ; + mkIP5 = mkTernaryCat "mkIP" ; + mkIP6 = mkBinaryCat "mkIP" ; + mkIP7 = mkBinaryCat "mkIP" ; + + what_IP = mkSimpCat "what_IP" ; + who_IP = mkSimpCat "who_IP" ; + + mkIAdv1 = mkBinaryCat "mkIAdv" ; + mkIAdv2 = mkBinaryCat "mkIAdv" ; + + mkIDet1 = mkBinaryCat "mkIDet" ; + mkIDet2 = mkUnaryCat "mkIDet" ; + + which_IDet = mkSimpCat "which_IDet" ; + whichSg_IDet = mkSimpCat "whichSg_IDet" ; + whichPl_IDet = mkSimpCat "whichPl_IDet" ; + + mkRS1 = mkUnaryCat "mkRS" ; + mkRS2 = mkBinaryCat "mkRS" ; + mkRS3 = mkBinaryCat "mkRS" ; + mkRS4 = mkBinaryCat "mkRS" ; + mkRS5 = mkTernaryCat "mkRS" ; + mkRS6 = mkTernaryCat "mkRS" ; + mkRS7 = mkTernaryCat "mkRS" ; + mkRS8 = mkQuaternaryCat "mkRS" ; + mkRS9 = mkTernaryCat "mkRS" ; + mkRS10 = mkTernaryCat "mkRS" ; + mkRS11 = mkBinaryCat "mkRS" ; + + mkRCl1 = mkBinaryCat "mkRCl" ; + mkRCl2 = mkBinaryCat "mkRCl" ; + mkRCl3 = mkTernaryCat "mkRCl" ; + mkRCl4 = mkQuaternaryCat "mkRCl" ; + mkRCl5 = mkTernaryCat "mkRCl" ; + mkRCl6 = mkTernaryCat "mkRCl" ; + mkRCl7 = mkTernaryCat "mkRCl" ; + mkRCl8 = mkTernaryCat "mkRCl" ; + mkRCl9 = mkTernaryCat "mkRCl" ; + mkRCl10 = mkQuaternaryCat "mkRCl" ; + mkRCl11 = mkQuaternaryCat "mkRCl" ; + mkRCl12 = mkQuaternaryCat "mkRCl" ; + mkRCl13 = mkQuaternaryCat "mkRCl" ; + mkRCl14 = mkQuaternaryCat "mkRCl" ; + mkRCl15 = mkBinaryCat "mkRCl" ; + mkRCl16 = mkTernaryCat "mkRCl" ; + mkRCl17 = mkTernaryCat "mkRCl" ; + mkRCl18 = mkBinaryCat "mkRCl" ; + mkRCl19 = mkBinaryCat "mkRCl" ; + mkRCl20 = mkBinaryCat "mkRCl" ; + mkRCl21 = mkBinaryCat "mkRCl" ; + mkRCl22 = mkBinaryCat "mkRCl" ; + mkRCl23 = mkTernaryCat "mkRCl" ; + mkRCl24 = mkBinaryCat "mkRCl" ; + mkRCl25 = mkUnaryCat "mkRCl" ; + + which_RP = mkSimpCat "which_RP" ; + + mkRP = mkTernaryCat "mkRP" ; + + mkSSlash = mkTernaryCat "mkSSlash" ; + + mkClSlash1 = mkBinaryCat "mkClSlash" ; + mkClSlash2 = mkBinaryCat "mkClSlash" ; + mkClSlash3 = mkTernaryCat "mkClSlash" ; + mkClSlash4 = mkBinaryCat "mkClSlash" ; + mkClSlash5 = mkBinaryCat "mkClSlash" ; + mkClSlash6 = mkTernaryCat "mkClSlash" ; + + mkVPSlash1 = mkUnaryCat "mkClSlash" ; + mkVPSlash2 = mkBinaryCat "mkClSlash" ; + mkVPSlash3 = mkBinaryCat "mkClSlash" ; + mkVPSlash4 = mkBinaryCat "mkClSlash" ; + mkVPSlash5 = mkBinaryCat "mkClSlash" ; + mkVPSlash6 = mkBinaryCat "mkClSlash" ; + mkVPSlash7 = mkBinaryCat "mkClSlash" ; + mkVPSlash8 = mkTernaryCat "mkVPSlash" ; + + mkListS1 = mkBinaryCat "mkListS" ; + mkListS2 = mkBinaryCat "mkListS" ; + + mkListAdv1 = mkBinaryCat "mkListAdv" ; + mkListAdv2 = mkBinaryCat "mkListAdv" ; + + mkListAP1 = mkBinaryCat "mkListAP" ; + mkListAP2 = mkBinaryCat "mkListAP" ; + + mkListNP1 = mkBinaryCat "mkListNP" ; + mkListNP2 = mkBinaryCat "mkListNP" ; + + mkListRS1 = mkBinaryCat "mkListRS" ; + mkListRS2 = mkBinaryCat "mkListRS" ; + + + the_Art = mkSimpCat "the_Art" ; + a_Art = mkSimpCat "a_Art" ; + sgNum = mkSimpCat "sgNum" ; + plNum = mkSimpCat "plNum" ; + + + + +{- + DetSg : Quant -> Ord -> Det = \q -> DetQuantOrd q NumSg ; + DetPl : Quant -> Num -> Ord -> Det = DetQuantOrd ; + ComplV2 : V2 -> NP -> VP = \v,np -> ComplSlash (SlashV2a v) np ; + ComplV2A : V2A -> NP -> AP -> VP = \v,np,ap -> ComplSlash (SlashV2A v ap) np ; + ComplV3 : V3 -> NP -> NP -> VP = \v,o,d -> ComplSlash (Slash3V3 v d) o ; +-} + + +oper mkSimpCat : Str-> {ind : Str ; attr : Str} = \s -> {ind = s; attr = s}; + +oper mkUnaryCat : Str -> {ind : Str ; attr : Str} -> {ind : Str ; attr : Str} = \s, o1 -> + {ind = s ++ o1.attr ; + attr = "(" ++ s ++ o1.attr ++ ")"}; + +oper mkBinaryCat : Str -> {ind : Str; attr : Str} -> {ind : Str; attr : Str} -> {ind : Str ; attr : Str} = \s, o1, o2 -> + {ind = s ++ o1.attr ++ o2.attr; + attr = "(" ++ s ++ o1.attr ++ o2.attr ++ ")"}; + +oper mkTernaryCat : Str -> {ind : Str; attr : Str} -> {ind : Str; attr : Str} -> {ind : Str; attr: Str} -> {ind : Str ; attr : Str} = \s, o1, o2, o3 -> + {ind = s ++ o1.attr ++ o2.attr ++ o3.attr; + attr = "(" ++ s ++ o1.attr ++ o2.attr ++ o3.attr ++")"}; + + +oper mkQuaternaryCat : Str -> {ind : Str; attr : Str} -> {ind : Str; attr : Str} -> {ind : Str; attr : Str} -> {ind : Str; attr: Str} -> {ind : Str ; attr : Str} = \s, o1, o2, o3, o4 -> + {ind = s ++ o1.attr ++ o2.attr ++ o3.attr ++ o4.attr; + attr = "(" ++ s ++ o1.attr ++ o2.attr ++ o3.attr ++o4.attr++ ")"}; + +----------------------------- +lin + +testNoun i = mkSimpCat ("noun"++i.s) ; +testA i = mkSimpCat ("adj" ++ i.s) ; +testV i = mkSimpCat ("verb" ++ i.s) ; +testV2 i = mkSimpCat ("verb2" ++ i.s) ; +testAdv i = mkSimpCat ("adv" ++ i.s) ; + + +}