From e465bd5b9385d5f1e9a024861289fffef72b2c3e Mon Sep 17 00:00:00 2001 From: aarne Date: Mon, 2 Jul 2007 13:58:02 +0000 Subject: [PATCH] parsing overloaded constructors as result --- lib/resource-1.0/api/toplevel/FromOverload.hs | 36 + lib/resource-1.0/api/toplevel/OverGrammar.gf | 264 ++++++++ .../api/toplevel/OverGrammarEng.gf | 263 ++++++++ lib/resource-1.0/api/toplevel/OverLang.gf | 3 + lib/resource-1.0/api/toplevel/OverLangEng.gf | 5 + lib/resource-1.0/api/toplevel/README | 18 + lib/resource-1.0/api/toplevel/constr.gf | 620 ++++++++++++++++++ src/GF/Shell.hs | 10 + src/GF/Shell/ShellCommands.hs | 2 +- src/GF/UseGrammar/MakeOverload.hs | 73 +++ 10 files changed, 1293 insertions(+), 1 deletion(-) create mode 100644 lib/resource-1.0/api/toplevel/FromOverload.hs create mode 100644 lib/resource-1.0/api/toplevel/OverGrammar.gf create mode 100644 lib/resource-1.0/api/toplevel/OverGrammarEng.gf create mode 100644 lib/resource-1.0/api/toplevel/OverLang.gf create mode 100644 lib/resource-1.0/api/toplevel/OverLangEng.gf create mode 100644 lib/resource-1.0/api/toplevel/README create mode 100644 lib/resource-1.0/api/toplevel/constr.gf create mode 100644 src/GF/UseGrammar/MakeOverload.hs diff --git a/lib/resource-1.0/api/toplevel/FromOverload.hs b/lib/resource-1.0/api/toplevel/FromOverload.hs new file mode 100644 index 000000000..1833963a0 --- /dev/null +++ b/lib/resource-1.0/api/toplevel/FromOverload.hs @@ -0,0 +1,36 @@ +import Monad + +main = do + ss <- readFile src >>= return . map words . lines + writeFile abstr "abstract OverGrammar = Structural,Numeral,Conjunction[ListS,ListNP,ListAP,ListAdv] ** {\n" + appendFile abstr "cat ImpForm ; Punct ;\n" + writeFile concr "concrete OverGrammarEng of OverGrammar = StructuralEng,NumeralEng,ConjunctionEng[ListS,ListNP,ListAP,ListAdv] ** open GrammarEng in {\n" + foldM process ("",0) ss + appendFile abstr "}\n" + appendFile concr "}\n" + return () + +src = "constr.gf" +abstr = "OverGrammar.gf" +concr = "OverGrammarEng.gf" + + +process env@(mk,count) line = case line of + ('-':'-':_) : _ -> return env + _:rest | elem "=" rest && notElem "overload" rest -> do + let (fun,lin) = span (/="=") line + env2 <- process env fun + process env2 lin + mk1 : ":" : typ -> do + let mk2 = withCount count mk1 + put abstr $ "fun" : mk2 : ":" : takeWhile (/="--") typ ++ [";\n"] + return $ (mk2,count) + "=" : trm -> do + put concr $ "lin" : mk : "=" : takeWhile (/=";") trm ++ [";\n"] + return $ (mk,count + 1) + _ -> return env + +put file ws = appendFile file $ unwords ws + +withCount count mk = "ovrld" ++ show count ++ "_" ++ mk + diff --git a/lib/resource-1.0/api/toplevel/OverGrammar.gf b/lib/resource-1.0/api/toplevel/OverGrammar.gf new file mode 100644 index 000000000..d16c4f8e1 --- /dev/null +++ b/lib/resource-1.0/api/toplevel/OverGrammar.gf @@ -0,0 +1,264 @@ +abstract OverGrammar = Structural,Numeral,Conjunction[ListS,ListNP,ListAP,ListAdv] ** { +cat ImpForm ; Punct ; +fun ovrld0_mkAP : A -> AP ; +fun ovrld1_mkAP : A -> NP -> AP ; +fun ovrld2_mkAP : A2 -> NP -> AP ; +fun ovrld3_mkAP : A2 -> AP ; +fun ovrld4_mkAP : AP -> S -> AP ; +fun ovrld5_mkAP : AP -> QS -> AP ; +fun ovrld6_mkAP : AP -> VP -> AP ; +fun ovrld7_mkAP : AdA -> A -> AP ; +fun ovrld8_mkAP : AdA -> AP -> AP ; +fun ovrld9_mkAP : Conj -> AP -> AP -> AP ; +fun ovrld10_mkAP : DConj -> AP -> AP -> AP ; +fun ovrld11_mkAP : Conj -> ListAP -> AP ; +fun ovrld12_mkAP : DConj -> ListAP -> AP ; +fun ovrld13_mkAdv : A -> Adv ; +fun ovrld14_mkAdv : Prep -> NP -> Adv ; +fun ovrld15_mkAdv : CAdv -> A -> NP -> Adv ; +fun ovrld16_mkAdv : CAdv -> A -> S -> Adv ; +fun ovrld17_mkAdv : AdA -> Adv -> Adv ; +fun ovrld18_mkAdv : Subj -> S -> Adv ; +fun ovrld19_mkAdv : Conj -> Adv -> Adv -> Adv ; +fun ovrld20_mkAdv : DConj -> Adv -> Adv -> Adv ; +fun ovrld21_mkAdv : Conj -> ListAdv -> Adv ; +fun ovrld22_mkAdv : DConj -> ListAdv -> Adv ; +fun ovrld23_mkCl : NP -> VP -> Cl ; +fun ovrld24_mkCl : NP -> V -> Cl ; +fun ovrld25_mkCl : NP -> V2 -> NP -> Cl ; +fun ovrld26_mkCl : NP -> V3 -> NP -> NP -> Cl ; +fun ovrld27_mkCl : NP -> VV -> VP -> Cl ; +fun ovrld28_mkCl : NP -> VS -> S -> Cl ; +fun ovrld29_mkCl : NP -> VQ -> QS -> Cl ; +fun ovrld30_mkCl : NP -> VA -> AP -> Cl ; +fun ovrld31_mkCl : NP -> V2A ->NP -> AP -> Cl ; +fun ovrld32_mkCl : VP -> Cl ; +fun ovrld33_mkCl : NP -> RS -> Cl ; +fun ovrld34_mkCl : Adv -> S -> Cl ; +fun ovrld35_mkCl : N -> Cl ; +fun ovrld36_mkCl : CN -> Cl ; +fun ovrld37_mkCl : NP -> Cl ; +fun ovrld38_mkCl : NP -> AP -> Cl ; +fun ovrld39_mkCl : NP -> A -> Cl ; +fun ovrld40_mkCl : NP -> A -> NP -> Cl ; +fun ovrld41_mkCl : NP -> A2 -> NP -> Cl ; +fun ovrld42_mkCl : NP -> NP -> Cl ; +fun ovrld43_mkCl : NP -> CN -> Cl ; +fun ovrld44_mkCl : NP -> N -> Cl ; +fun ovrld45_mkCl : NP -> Adv -> Cl ; +fun ovrld46_mkCl : V -> Cl ; +fun ovrld47_genericCl : VP -> Cl ; +fun ovrld48_mkNP : Det -> CN -> NP ; +fun ovrld49_mkNP : Det -> N -> NP ; +fun ovrld50_mkNP : Num -> CN -> NP ; +fun ovrld51_mkNP : Num -> N -> NP ; +fun ovrld52_mkNP : QuantSg -> CN -> NP ; +fun ovrld53_mkNP : QuantSg -> N -> NP ; +fun ovrld54_mkNP : QuantPl -> CN -> NP ; +fun ovrld55_mkNP : QuantPl -> N -> NP ; +fun ovrld56_mkNP : Pron -> CN -> NP ; +fun ovrld57_mkNP : Pron -> N -> NP ; +fun ovrld58_mkNP : Numeral -> CN -> NP ; +fun ovrld59_mkNP : Numeral -> N -> NP ; +fun ovrld60_mkNP : Int -> CN -> NP ; +fun ovrld61_mkNP : Int -> N -> NP ; +fun ovrld62_mkNP : PN -> NP ; +fun ovrld63_mkNP : Pron -> NP ; +fun ovrld64_mkNP : Predet -> NP -> NP ; +fun ovrld65_mkNP : NP -> V2 -> NP ; +fun ovrld66_mkNP : NP -> Adv -> NP ; +fun ovrld67_mkNP : Conj -> NP -> NP -> NP ; +fun ovrld68_mkNP : DConj -> NP -> NP -> NP ; +fun ovrld69_mkNP : Conj -> ListNP -> NP ; +fun ovrld70_mkNP : DConj -> ListNP -> NP ; +fun ovrld71_mkDet : QuantSg -> Ord -> Det ; +fun ovrld72_mkDet : QuantSg -> Det ; +fun ovrld73_mkDet : QuantPl -> Num -> Ord -> Det ; +fun ovrld74_mkDet : QuantPl -> Det ; +fun ovrld75_mkDet : Quant -> Det ; +fun ovrld76_mkDet : Quant -> Num -> Det ; +fun ovrld77_mkDet : Num -> Det ; +fun ovrld78_mkDet : Int -> Det ; +fun ovrld79_mkDet : Numeral -> Det ; +fun ovrld80_mkDet : Pron -> Det ; +fun ovrld81_defSgDet : Det ; +fun ovrld82_defPlDet : Det ; +fun ovrld83_indefSgDet : Det ; +fun ovrld84_indefPlDet : Det ; +fun ovrld85_mkQuantSg : Quant -> QuantSg ; +fun ovrld86_mkQuantPl : Quant -> QuantPl ; +fun ovrld87_defQuant : Quant ; +fun ovrld88_indefQuant : Quant ; +fun ovrld89_massQuant : QuantSg ; +fun ovrld90_mkNum : Numeral -> Num ; +fun ovrld91_mkNum : Int -> Num ; +fun ovrld92_mkNum : Digit -> Num ; +fun ovrld93_mkNum : AdN -> Num -> Num ; +fun ovrld94_noNum : Num ; +fun ovrld95_n1_Numeral : Numeral ; +fun ovrld96_n2_Numeral : Numeral ; +fun ovrld97_n3_Numeral : Numeral ; +fun ovrld98_n4_Numeral : Numeral ; +fun ovrld99_n5_Numeral : Numeral ; +fun ovrld100_n6_Numeral : Numeral ; +fun ovrld101_n7_Numeral : Numeral ; +fun ovrld102_n8_Numeral : Numeral ; +fun ovrld103_n9_Numeral : Numeral ; +fun ovrld104_n10_Numeral : Numeral ; +fun ovrld105_n20_Numeral : Numeral ; +fun ovrld106_n100_Numeral : Numeral ; +fun ovrld107_n1000_Numeral : Numeral ; +fun ovrld108_mkAdN : CAdv -> AdN ; +fun ovrld109_mkOrd : Numeral -> Ord ; +fun ovrld110_mkOrd : Int -> Ord ; +fun ovrld111_mkOrd : Digit -> Ord ; +fun ovrld112_mkOrd : A -> Ord ; +fun ovrld113_noOrd : Ord ; +fun ovrld114_mkCN : N -> CN ; +fun ovrld115_mkCN : N2 -> NP -> CN ; +fun ovrld116_mkCN : N3 -> NP -> NP -> CN ; +fun ovrld117_mkCN : N2 -> CN ; +fun ovrld118_mkCN : N3 -> CN ; +fun ovrld119_mkCN : AP -> CN -> CN ; +fun ovrld120_mkCN : AP -> N -> CN ; +fun ovrld121_mkCN : CN -> AP -> CN ; +fun ovrld122_mkCN : N -> AP -> CN ; +fun ovrld123_mkCN : A -> CN -> CN ; +fun ovrld124_mkCN : A -> N -> CN ; +fun ovrld125_mkCN : CN -> RS -> CN ; +fun ovrld126_mkCN : N -> RS -> CN ; +fun ovrld127_mkCN : CN -> Adv -> CN ; +fun ovrld128_mkCN : N -> Adv -> CN ; +fun ovrld129_mkCN : CN -> S -> CN ; +fun ovrld130_mkCN : CN -> QS -> CN ; +fun ovrld131_mkCN : CN -> VP -> CN ; +fun ovrld132_mkCN : CN -> NP -> CN ; +fun ovrld133_mkCN : N -> NP -> CN ; +fun ovrld134_mkPhr : PConj -> Utt -> Voc -> Phr ; +fun ovrld135_mkPhr : Utt -> Voc -> Phr ; +fun ovrld136_mkPhr : PConj -> Utt -> Phr ; +fun ovrld137_mkPhr : Utt -> Phr ; +fun ovrld138_mkPhr : S -> Phr ; +fun ovrld139_mkPhr : Cl -> Phr ; +fun ovrld140_mkPhr : QS -> Phr ; +fun ovrld141_mkPhr : Imp -> Phr ; +fun ovrld142_mkPConj : Conj -> PConj ; +fun ovrld143_noPConj : PConj ; +fun ovrld144_mkVoc : NP -> Voc ; +fun ovrld145_noVoc : Voc ; +fun ovrld146_positivePol : Pol ; +fun ovrld147_negativePol : Pol ; +fun ovrld148_simultaneousAnt : Ant ; +fun ovrld149_anteriorAnt : Ant ; +fun ovrld150_presentTense : Tense ; +fun ovrld151_pastTense : Tense ; +fun ovrld152_futureTense : Tense ; +fun ovrld153_conditionalTense : Tense ; +fun ovrld154_mkUtt : S -> Utt ; +fun ovrld155_mkUtt : Cl -> Utt ; +fun ovrld156_mkUtt : QS -> Utt ; +fun ovrld157_mkUtt : Pol -> Imp -> Utt ; +fun ovrld158_mkUtt : Imp -> Utt ; +fun ovrld159_mkUtt : IP -> Utt ; +fun ovrld160_mkUtt : IAdv -> Utt ; +fun ovrld161_mkUtt : NP -> Utt ; +fun ovrld162_mkUtt : Adv -> Utt ; +fun ovrld163_mkUtt : VP -> Utt ; +fun ovrld164_lets_Utt : VP -> Utt ; +fun ovrld165_mkQCl : Cl -> QCl ; +fun ovrld166_mkQCl : IP -> VP -> QCl ; +fun ovrld167_mkQCl : IP -> Slash -> QCl ; +fun ovrld168_mkQCl : IP -> NP -> V2 -> QCl ; +fun ovrld169_mkQCl : IAdv -> Cl -> QCl ; +fun ovrld170_mkQCl : Prep -> IP -> Cl -> QCl ; +fun ovrld171_mkQCl : IAdv -> NP -> QCl ; +fun ovrld172_mkQCl : IP -> QCl ; +fun ovrld173_mkIP : IDet -> Num -> Ord -> CN -> IP ; +fun ovrld174_mkIP : IDet -> Ord -> CN -> IP ; +fun ovrld175_mkIP : IDet -> Num -> CN -> IP ; +fun ovrld176_mkIP : IDet -> N -> IP ; +fun ovrld177_mkIP : IP -> Adv -> IP ; +fun ovrld178_mkIAdv : Prep -> IP -> IAdv ; +fun ovrld179_mkRCl : Cl -> RCl ; +fun ovrld180_mkRCl : RP -> VP -> RCl ; +fun ovrld181_mkRCl : RP -> Slash -> RCl ; +fun ovrld182_mkRCl : RP -> NP -> V2 -> RCl ; +fun ovrld183_which_RP : RP ; +fun ovrld184_mkRP : Prep -> NP -> RP -> RP ; +fun ovrld185_mkSlash : NP -> V2 -> Slash ; +fun ovrld186_mkSlash : NP -> VV -> V2 -> Slash ; +fun ovrld187_mkSlash : Slash -> Adv -> Slash ; +fun ovrld188_mkSlash : Cl -> Prep -> Slash ; +fun ovrld189_mkImp : VP -> Imp ; +fun ovrld190_mkImp : V -> Imp ; +fun ovrld191_mkImp : V2 -> NP -> Imp ; +fun ovrld192_mkS : Cl -> S ; +fun ovrld193_mkS : Tense -> Cl -> S ; +fun ovrld194_mkS : Ant -> Cl -> S ; +fun ovrld195_mkS : Pol -> Cl -> S ; +fun ovrld196_mkS : Tense -> Ant -> Cl -> S ; +fun ovrld197_mkS : Tense -> Pol -> Cl -> S ; +fun ovrld198_mkS : Ant -> Pol -> Cl -> S ; +fun ovrld199_mkS : Tense -> Ant -> Pol -> Cl -> S ; +fun ovrld200_mkS : Conj -> S -> S -> S ; +fun ovrld201_mkS : DConj -> S -> S -> S ; +fun ovrld202_mkS : Conj -> ListS -> S ; +fun ovrld203_mkS : DConj -> ListS -> S ; +fun ovrld204_mkS : Adv -> S -> S ; +fun ovrld205_mkQS : QCl -> QS ; +fun ovrld206_mkQS : Tense -> QCl -> QS ; +fun ovrld207_mkQS : Ant -> QCl -> QS ; +fun ovrld208_mkQS : Pol -> QCl -> QS ; +fun ovrld209_mkQS : Tense -> Ant -> QCl -> QS ; +fun ovrld210_mkQS : Tense -> Pol -> QCl -> QS ; +fun ovrld211_mkQS : Ant -> Pol -> QCl -> QS ; +fun ovrld212_mkQS : Tense -> Ant -> Pol -> QCl -> QS ; +fun ovrld213_mkQS : Cl -> QS ; +fun ovrld214_mkRS : RCl -> RS ; +fun ovrld215_mkRS : Tense -> RCl -> RS ; +fun ovrld216_mkRS : Ant -> RCl -> RS ; +fun ovrld217_mkRS : Pol -> RCl -> RS ; +fun ovrld218_mkRS : Tense -> Ant -> RCl -> RS ; +fun ovrld219_mkRS : Tense -> Pol -> RCl -> RS ; +fun ovrld220_mkRS : Ant -> Pol -> RCl -> RS ; +fun ovrld221_mkRS : Tense -> Ant -> Pol -> RCl -> RS ; +fun ovrld222_emptyText : Text ; +fun ovrld223_mkText : Phr -> Text ; +fun ovrld224_mkText : Utt -> Text ; +fun ovrld225_mkText : S -> Text ; +fun ovrld226_mkText : Cl -> Text ; +fun ovrld227_mkText : QS -> Text ; +fun ovrld228_mkText : Imp -> Text ; +fun ovrld229_mkText : Pol -> Imp -> Text ; +fun ovrld230_mkText : Phr -> Text -> Text ; +fun ovrld231_mkVP : V -> VP ; +fun ovrld232_mkVP : V2 -> NP -> VP ; +fun ovrld233_mkVP : V3 -> NP -> NP -> VP ; +fun ovrld234_mkVP : VV -> VP -> VP ; +fun ovrld235_mkVP : VS -> S -> VP ; +fun ovrld236_mkVP : VQ -> QS -> VP ; +fun ovrld237_mkVP : VA -> AP -> VP ; +fun ovrld238_mkVP : V2A -> NP -> AP -> VP ; +fun ovrld239_mkVP : A -> VP ; +fun ovrld240_mkVP : A -> NP -> VP ; +fun ovrld241_mkVP : A2 -> NP -> VP ; +fun ovrld242_mkVP : AP -> VP ; +fun ovrld243_mkVP : NP -> VP ; +fun ovrld244_mkVP : CN -> VP ; +fun ovrld245_mkVP : N -> VP ; +fun ovrld246_mkVP : Adv -> VP ; +fun ovrld247_mkVP : VP -> Adv -> VP ; +fun ovrld248_mkVP : AdV -> VP -> VP ; +fun ovrld249_reflexiveVP : V2 -> VP ; +fun ovrld250_passiveVP : V2 -> VP ; +fun ovrld251_passiveVP : V2 -> NP -> VP ; +fun ovrld252_progressiveVP : VP -> VP ; +fun ovrld253_mkListS : S -> S -> ListS ; +fun ovrld254_mkListS : S -> ListS -> ListS ; +fun ovrld255_mkListAP : AP -> AP -> ListAP ; +fun ovrld256_mkListAP : AP -> ListAP -> ListAP ; +fun ovrld257_mkListAdv : Adv -> Adv -> ListAdv ; +fun ovrld258_mkListAdv : Adv -> ListAdv -> ListAdv ; +fun ovrld259_mkListNP : NP -> NP -> ListNP ; +fun ovrld260_mkListNP : NP -> ListNP -> ListNP ; +} diff --git a/lib/resource-1.0/api/toplevel/OverGrammarEng.gf b/lib/resource-1.0/api/toplevel/OverGrammarEng.gf new file mode 100644 index 000000000..989a327cb --- /dev/null +++ b/lib/resource-1.0/api/toplevel/OverGrammarEng.gf @@ -0,0 +1,263 @@ +concrete OverGrammarEng of OverGrammar = StructuralEng,NumeralEng,ConjunctionEng[ListS,ListNP,ListAP,ListAdv] ** open GrammarEng in { +lin ovrld0_mkAP = PositA ; +lin ovrld1_mkAP = ComparA ; +lin ovrld2_mkAP = ComplA2 ; +lin ovrld3_mkAP = ReflA2 ; +lin ovrld4_mkAP = \ap,s -> SentAP ap (EmbedS s) ; +lin ovrld5_mkAP = \ap,s -> SentAP ap (EmbedQS s) ; +lin ovrld6_mkAP = \ap,s -> SentAP ap (EmbedVP s) ; +lin ovrld7_mkAP = \x,y -> AdAP x (PositA y) ; +lin ovrld8_mkAP = AdAP ; +lin ovrld9_mkAP = \c,x,y -> ConjAP c (BaseAP x y) ; +lin ovrld10_mkAP = \c,x,y -> DConjAP c (BaseAP x y) ; +lin ovrld11_mkAP = \c,xy -> ConjAP c xy ; +lin ovrld12_mkAP = \c,xy -> DConjAP c xy ; +lin ovrld13_mkAdv = PositAdvAdj ; +lin ovrld14_mkAdv = PrepNP ; +lin ovrld15_mkAdv = ComparAdvAdj ; +lin ovrld16_mkAdv = ComparAdvAdjS ; +lin ovrld17_mkAdv = AdAdv ; +lin ovrld18_mkAdv = SubjS ; +lin ovrld19_mkAdv = \c,x,y -> ConjAdv c (BaseAdv x y) ; +lin ovrld20_mkAdv = \c,x,y -> DConjAdv c (BaseAdv x y) ; +lin ovrld21_mkAdv = \c,xy -> ConjAdv c xy ; +lin ovrld22_mkAdv = \c,xy -> DConjAdv c xy ; +lin ovrld23_mkCl = PredVP ; +lin ovrld24_mkCl = \s,v -> PredVP s (UseV v) ; +lin ovrld25_mkCl = \s,v,o -> PredVP s (ComplV2 v o) ; +lin ovrld26_mkCl = \s,v,o,i -> PredVP s (ComplV3 v o i) ; +lin ovrld27_mkCl = \s,v,vp -> PredVP s (ComplVV v vp) ; +lin ovrld28_mkCl = \s,v,p -> PredVP s (ComplVS v p) ; +lin ovrld29_mkCl = \s,v,q -> PredVP s (ComplVQ v q) ; +lin ovrld30_mkCl = \s,v,q -> PredVP s (ComplVA v q) ; +lin ovrld31_mkCl = \s,v,n,q -> PredVP s (ComplV2A v n q) ; +lin ovrld32_mkCl = ImpersCl ; +lin ovrld33_mkCl = CleftNP ; +lin ovrld34_mkCl = CleftAdv ; +lin ovrld35_mkCl = \y -> ExistNP (DetCN (DetSg (SgQuant IndefArt) NoOrd) (UseN y)) ; +lin ovrld36_mkCl = \y -> ExistNP (DetCN (DetSg (SgQuant IndefArt) NoOrd) y) ; +lin ovrld37_mkCl = ExistNP ; +lin ovrld38_mkCl = \x,y -> PredVP x (UseComp (CompAP y)) ; +lin ovrld39_mkCl = \x,y -> PredVP x (UseComp (CompAP (PositA y))) ; +lin ovrld40_mkCl = \x,y,z -> PredVP x (UseComp (CompAP (ComparA y z))) ; +lin ovrld41_mkCl = \x,y,z -> PredVP x (UseComp (CompAP (ComplA2 y z))) ; +lin ovrld42_mkCl = \x,y -> PredVP x (UseComp (CompNP y)) ; +lin ovrld43_mkCl = \x,y -> PredVP x (UseComp (CompNP (DetCN (DetSg (SgQuant IndefArt) NoOrd) y))) ; +lin ovrld44_mkCl = \x,y -> PredVP x (UseComp (CompNP (DetCN (DetSg (SgQuant IndefArt) NoOrd) (UseN y)))) ; +lin ovrld45_mkCl = \x,y -> PredVP x (UseComp (CompAdv y)) ; +lin ovrld46_mkCl = \v -> ImpersCl (UseV v) ; +lin ovrld47_genericCl = GenericCl ; +lin ovrld48_mkNP = DetCN ; +lin ovrld49_mkNP = \d,n -> DetCN d (UseN n) ; +lin ovrld50_mkNP = \d,n -> DetCN (DetPl (PlQuant IndefArt) d NoOrd) n ; +lin ovrld51_mkNP = \d,n -> DetCN (DetPl (PlQuant IndefArt) d NoOrd) (UseN n) ; +lin ovrld52_mkNP = \q,n -> DetCN (DetSg q NoOrd) n ; +lin ovrld53_mkNP = \q,n -> DetCN (DetSg q NoOrd) (UseN n) ; +lin ovrld54_mkNP = \q,n -> DetCN (DetPl q NoNum NoOrd) n ; +lin ovrld55_mkNP = \q,n -> DetCN (DetPl q NoNum NoOrd) (UseN n) ; +lin ovrld56_mkNP = \p,n -> DetCN (DetSg (SgQuant (PossPron p)) NoOrd) n ; +lin ovrld57_mkNP = \p,n -> DetCN (DetSg (SgQuant (PossPron p)) NoOrd) (UseN n) ; +lin ovrld58_mkNP = \d,n -> DetCN (DetPl (PlQuant IndefArt) (NumNumeral d) NoOrd) n ; +lin ovrld59_mkNP = \d,n -> DetCN (DetPl (PlQuant IndefArt) (NumNumeral d) NoOrd) (UseN n) ; +lin ovrld60_mkNP = \d,n -> DetCN (DetPl (PlQuant IndefArt) (NumInt d) NoOrd) n ; +lin ovrld61_mkNP = \d,n -> DetCN (DetPl (PlQuant IndefArt) (NumInt d) NoOrd) (UseN n) ; +lin ovrld62_mkNP = UsePN ; +lin ovrld63_mkNP = UsePron ; +lin ovrld64_mkNP = PredetNP ; +lin ovrld65_mkNP = PPartNP ; +lin ovrld66_mkNP = AdvNP ; +lin ovrld67_mkNP = \c,x,y -> ConjNP c (BaseNP x y) ; +lin ovrld68_mkNP = \c,x,y -> DConjNP c (BaseNP x y) ; +lin ovrld69_mkNP = \c,xy -> ConjNP c xy ; +lin ovrld70_mkNP = \c,xy -> DConjNP c xy ; +lin ovrld71_mkDet = DetSg ; +lin ovrld72_mkDet = \q -> DetSg q NoOrd ; +lin ovrld73_mkDet = DetPl ; +lin ovrld74_mkDet = \q -> DetPl q NoNum NoOrd ; +lin ovrld75_mkDet = \q -> DetSg (SgQuant q) NoOrd ; +lin ovrld76_mkDet = \q,nu -> DetPl (PlQuant q) nu NoOrd ; +lin ovrld77_mkDet = \n -> DetPl (PlQuant IndefArt) n NoOrd ; +lin ovrld78_mkDet = \n -> DetPl (PlQuant IndefArt) (NumInt n) NoOrd ; +lin ovrld79_mkDet = \d -> DetPl (PlQuant IndefArt) (NumNumeral d) NoOrd ; +lin ovrld80_mkDet = \p -> DetSg (SgQuant (PossPron p)) NoOrd ; +lin ovrld81_defSgDet = DetSg (SgQuant DefArt) NoOrd ; +lin ovrld82_defPlDet = DetPl (PlQuant DefArt) NoNum NoOrd ; +lin ovrld83_indefSgDet = DetSg (SgQuant IndefArt) NoOrd ; +lin ovrld84_indefPlDet = DetPl (PlQuant IndefArt) NoNum NoOrd ; +lin ovrld85_mkQuantSg = SgQuant ; +lin ovrld86_mkQuantPl = PlQuant ; +lin ovrld87_defQuant = DefArt ; +lin ovrld88_indefQuant = IndefArt ; +lin ovrld89_massQuant = MassDet ; +lin ovrld90_mkNum = NumNumeral ; +lin ovrld91_mkNum = NumInt ; +lin ovrld92_mkNum = \d -> NumNumeral (num (pot2as3 (pot1as2 (pot0as1 (pot0 d))))) ; +lin ovrld93_mkNum = AdNum ; +lin ovrld94_noNum = NoNum ; +lin ovrld95_n1_Numeral = num (pot2as3 (pot1as2 (pot0as1 pot01))) ; +lin ovrld96_n2_Numeral = num (pot2as3 (pot1as2 (pot0as1 (pot0 n2)))) ; +lin ovrld97_n3_Numeral = num (pot2as3 (pot1as2 (pot0as1 (pot0 n3)))) ; +lin ovrld98_n4_Numeral = num (pot2as3 (pot1as2 (pot0as1 (pot0 n4)))) ; +lin ovrld99_n5_Numeral = num (pot2as3 (pot1as2 (pot0as1 (pot0 n5)))) ; +lin ovrld100_n6_Numeral = num (pot2as3 (pot1as2 (pot0as1 (pot0 n6)))) ; +lin ovrld101_n7_Numeral = num (pot2as3 (pot1as2 (pot0as1 (pot0 n7)))) ; +lin ovrld102_n8_Numeral = num (pot2as3 (pot1as2 (pot0as1 (pot0 n8)))) ; +lin ovrld103_n9_Numeral = num (pot2as3 (pot1as2 (pot0as1 (pot0 n9)))) ; +lin ovrld104_n10_Numeral = num (pot2as3 (pot1as2 pot110)) ; +lin ovrld105_n20_Numeral = num (pot2as3 (pot1as2 (pot1 n2))) ; +lin ovrld106_n100_Numeral = num (pot2as3 (pot2 pot01)) ; +lin ovrld107_n1000_Numeral = num (pot3 (pot1as2 (pot0as1 pot01))) ; +lin ovrld108_mkAdN = AdnCAdv ; +lin ovrld109_mkOrd = OrdNumeral ; +lin ovrld110_mkOrd = OrdInt ; +lin ovrld111_mkOrd = \d -> OrdNumeral (num (pot2as3 (pot1as2 (pot0as1 (pot0 d))))) ; +lin ovrld112_mkOrd = OrdSuperl ; +lin ovrld113_noOrd = NoOrd ; +lin ovrld114_mkCN = UseN ; +lin ovrld115_mkCN = ComplN2 ; +lin ovrld116_mkCN = \f,x -> ComplN2 (ComplN3 f x) ; +lin ovrld117_mkCN = UseN2 ; +lin ovrld118_mkCN = UseN3 ; +lin ovrld119_mkCN = AdjCN ; +lin ovrld120_mkCN = \x,y -> AdjCN x (UseN y) ; +lin ovrld121_mkCN = \x,y -> AdjCN y x ; +lin ovrld122_mkCN = \x,y -> AdjCN y (UseN x) ; +lin ovrld123_mkCN = \x,y -> AdjCN (PositA x) y ; +lin ovrld124_mkCN = \x,y -> AdjCN (PositA x) (UseN y) ; +lin ovrld125_mkCN = RelCN ; +lin ovrld126_mkCN = \x,y -> RelCN (UseN x) y ; +lin ovrld127_mkCN = AdvCN ; +lin ovrld128_mkCN = \x,y -> AdvCN (UseN x) y ; +lin ovrld129_mkCN = \cn,s -> SentCN cn (EmbedS s) ; +lin ovrld130_mkCN = \cn,s -> SentCN cn (EmbedQS s) ; +lin ovrld131_mkCN = \cn,s -> SentCN cn (EmbedVP s) ; +lin ovrld132_mkCN = ApposCN ; +lin ovrld133_mkCN = \x,y -> ApposCN (UseN x) y ; +lin ovrld134_mkPhr = PhrUtt ; +lin ovrld135_mkPhr = \u,v -> PhrUtt NoPConj u v ; +lin ovrld136_mkPhr = \u,v -> PhrUtt u v NoVoc ; +lin ovrld137_mkPhr = \u -> PhrUtt NoPConj u NoVoc ; +lin ovrld138_mkPhr = \s -> PhrUtt NoPConj (UttS s) NoVoc ; +lin ovrld139_mkPhr = \s -> PhrUtt NoPConj (UttS (UseCl TPres ASimul PPos s)) NoVoc ; +lin ovrld140_mkPhr = \s -> PhrUtt NoPConj (UttQS s) NoVoc ; +lin ovrld141_mkPhr = \s -> PhrUtt NoPConj (UttImpSg PPos s) NoVoc ; +lin ovrld142_mkPConj = PConjConj ; +lin ovrld143_noPConj = NoPConj ; +lin ovrld144_mkVoc = VocNP ; +lin ovrld145_noVoc = NoVoc ; +lin ovrld146_positivePol = PPos ; +lin ovrld147_negativePol = PNeg ; +lin ovrld148_simultaneousAnt = ASimul ; +lin ovrld149_anteriorAnt = AAnter ; +lin ovrld150_presentTense = TPres ; +lin ovrld151_pastTense = TPast ; +lin ovrld152_futureTense = TFut ; +lin ovrld153_conditionalTense = TCond ; +lin ovrld154_mkUtt = UttS ; +lin ovrld155_mkUtt = \c -> UttS (UseCl TPres ASimul PPos c) ; +lin ovrld156_mkUtt = UttQS ; +lin ovrld157_mkUtt = UttImpSg ; +lin ovrld158_mkUtt = UttImpSg PPos ; +lin ovrld159_mkUtt = UttIP ; +lin ovrld160_mkUtt = UttIAdv ; +lin ovrld161_mkUtt = UttNP ; +lin ovrld162_mkUtt = UttAdv ; +lin ovrld163_mkUtt = UttVP ; +lin ovrld164_lets_Utt = ImpPl1 ; +lin ovrld165_mkQCl = QuestCl ; +lin ovrld166_mkQCl = QuestVP ; +lin ovrld167_mkQCl = QuestSlash ; +lin ovrld168_mkQCl = \ip,np,v -> QuestSlash ip (SlashV2 np v) ; +lin ovrld169_mkQCl = QuestIAdv ; +lin ovrld170_mkQCl = \p,ip -> QuestIAdv (PrepIP p ip) ; +lin ovrld171_mkQCl = \a -> QuestIComp (CompIAdv a) ; +lin ovrld172_mkQCl = ExistIP ; +lin ovrld173_mkIP = IDetCN ; +lin ovrld174_mkIP = \i -> IDetCN i NoNum ; +lin ovrld175_mkIP = \i,n -> IDetCN i n NoOrd ; +lin ovrld176_mkIP = \i,n -> IDetCN i NoNum NoOrd (UseN n) ; +lin ovrld177_mkIP = AdvIP ; +lin ovrld178_mkIAdv = PrepIP ; +lin ovrld179_mkRCl = RelCl ; +lin ovrld180_mkRCl = RelVP ; +lin ovrld181_mkRCl = RelSlash ; +lin ovrld182_mkRCl = \rp,np,v2 -> RelSlash rp (SlashV2 np v2) ; +lin ovrld183_which_RP = IdRP ; +lin ovrld184_mkRP = FunRP ; +lin ovrld185_mkSlash = SlashV2 ; +lin ovrld186_mkSlash = SlashVVV2 ; +lin ovrld187_mkSlash = AdvSlash ; +lin ovrld188_mkSlash = SlashPrep ; +lin ovrld189_mkImp = ImpVP ; +lin ovrld190_mkImp = \v -> ImpVP (UseV v) ; +lin ovrld191_mkImp = \v,np -> ImpVP (ComplV2 v np) ; +lin ovrld192_mkS = UseCl TPres ASimul PPos ; +lin ovrld193_mkS = \t -> UseCl t ASimul PPos ; +lin ovrld194_mkS = \a -> UseCl TPres a PPos ; +lin ovrld195_mkS = \p -> UseCl TPres ASimul p ; +lin ovrld196_mkS = \t,a -> UseCl t a PPos ; +lin ovrld197_mkS = \t,p -> UseCl t ASimul p ; +lin ovrld198_mkS = \a,p -> UseCl TPres a p ; +lin ovrld199_mkS = UseCl ; +lin ovrld200_mkS = \c,x,y -> ConjS c (BaseS x y) ; +lin ovrld201_mkS = \c,x,y -> DConjS c (BaseS x y) ; +lin ovrld202_mkS = \c,xy -> ConjS c xy ; +lin ovrld203_mkS = \c,xy -> DConjS c xy ; +lin ovrld204_mkS = AdvS ; +lin ovrld205_mkQS = UseQCl TPres ASimul PPos ; +lin ovrld206_mkQS = \t -> UseQCl t ASimul PPos ; +lin ovrld207_mkQS = \a -> UseQCl TPres a PPos ; +lin ovrld208_mkQS = \p -> UseQCl TPres ASimul p ; +lin ovrld209_mkQS = \t,a -> UseQCl t a PPos ; +lin ovrld210_mkQS = \t,p -> UseQCl t ASimul p ; +lin ovrld211_mkQS = \a,p -> UseQCl TPres a p ; +lin ovrld212_mkQS = UseQCl ; +lin ovrld213_mkQS = \x -> UseQCl TPres ASimul PPos (QuestCl x) ; +lin ovrld214_mkRS = UseRCl TPres ASimul PPos ; +lin ovrld215_mkRS = \t,c -> UseRCl t ASimul PPos c ; +lin ovrld216_mkRS = \a,c -> UseRCl TPres a PPos c ; +lin ovrld217_mkRS = \p,c -> UseRCl TPres ASimul p c ; +lin ovrld218_mkRS = \t,a,c -> UseRCl t a PPos c ; +lin ovrld219_mkRS = \t,p,c -> UseRCl t ASimul p c ; +lin ovrld220_mkRS = \a,p,c -> UseRCl TPres a p c ; +lin ovrld221_mkRS = UseRCl ; +lin ovrld222_emptyText = TEmpty ; +lin ovrld223_mkText = \x -> TFullStop x TEmpty ; +lin ovrld224_mkText = \u -> TFullStop (PhrUtt NoPConj u NoVoc) TEmpty ; +lin ovrld225_mkText = \s -> TFullStop (PhrUtt NoPConj (UttS s) NoVoc) TEmpty ; +lin ovrld226_mkText = \c -> TFullStop (PhrUtt NoPConj (UttS (UseCl TPres ASimul PPos c)) NoVoc) TEmpty ; +lin ovrld227_mkText = \q -> TQuestMark (PhrUtt NoPConj (UttQS q) NoVoc) TEmpty ; +lin ovrld228_mkText = \i -> TExclMark (PhrUtt NoPConj (UttImpSg PPos i) NoVoc) TEmpty ; +lin ovrld229_mkText = \p,i -> TExclMark (PhrUtt NoPConj (UttImpSg p i) NoVoc) TEmpty ; +lin ovrld230_mkText = TFullStop ; +lin ovrld231_mkVP = UseV ; +lin ovrld232_mkVP = ComplV2 ; +lin ovrld233_mkVP = ComplV3 ; +lin ovrld234_mkVP = ComplVV ; +lin ovrld235_mkVP = ComplVS ; +lin ovrld236_mkVP = ComplVQ ; +lin ovrld237_mkVP = ComplVA ; +lin ovrld238_mkVP = ComplV2A ; +lin ovrld239_mkVP = \a -> UseComp (CompAP (PositA a)) ; +lin ovrld240_mkVP = \y,z -> (UseComp (CompAP (ComparA y z))) ; +lin ovrld241_mkVP = \y,z -> (UseComp (CompAP (ComplA2 y z))) ; +lin ovrld242_mkVP = \a -> UseComp (CompAP a) ; +lin ovrld243_mkVP = \a -> UseComp (CompNP a) ; +lin ovrld244_mkVP = \y -> (UseComp (CompNP (DetCN (DetSg (SgQuant IndefArt) NoOrd) y))) ; +lin ovrld245_mkVP = \y -> (UseComp (CompNP (DetCN (DetSg (SgQuant IndefArt) NoOrd) (UseN y)))) ; +lin ovrld246_mkVP = \a -> UseComp (CompAdv a) ; +lin ovrld247_mkVP = AdvVP ; +lin ovrld248_mkVP = AdVVP ; +lin ovrld249_reflexiveVP = ReflV2 ; +lin ovrld250_passiveVP = PassV2 ; +lin ovrld251_passiveVP = \v,np -> (AdvVP (PassV2 v) (PrepNP by8agent_Prep np)) ; +lin ovrld252_progressiveVP = ProgrVP ; +lin ovrld253_mkListS = BaseS ; +lin ovrld254_mkListS = ConsS ; +lin ovrld255_mkListAP = BaseAP ; +lin ovrld256_mkListAP = ConsAP ; +lin ovrld257_mkListAdv = BaseAdv ; +lin ovrld258_mkListAdv = ConsAdv ; +lin ovrld259_mkListNP = BaseNP ; +lin ovrld260_mkListNP = ConsNP ; +} diff --git a/lib/resource-1.0/api/toplevel/OverLang.gf b/lib/resource-1.0/api/toplevel/OverLang.gf new file mode 100644 index 000000000..028d59ee2 --- /dev/null +++ b/lib/resource-1.0/api/toplevel/OverLang.gf @@ -0,0 +1,3 @@ +abstract OverLang = + OverGrammar-[PPos,PNeg,TPres,TPast,TFut,TCond,ASimul,AAnter], + Lexicon-[PPos,PNeg,TPres,TPast,TFut,TCond,ASimul,AAnter] ; diff --git a/lib/resource-1.0/api/toplevel/OverLangEng.gf b/lib/resource-1.0/api/toplevel/OverLangEng.gf new file mode 100644 index 000000000..1f535e410 --- /dev/null +++ b/lib/resource-1.0/api/toplevel/OverLangEng.gf @@ -0,0 +1,5 @@ +--# -path=alltenses:prelude + +concrete OverLangEng of OverLang = + OverGrammarEng-[PPos,PNeg,TPres,TPast,TFut,TCond,ASimul,AAnter], + LexiconEng-[PPos,PNeg,TPres,TPast,TFut,TCond,ASimul,AAnter] ; diff --git a/lib/resource-1.0/api/toplevel/README b/lib/resource-1.0/api/toplevel/README new file mode 100644 index 000000000..8de793f03 --- /dev/null +++ b/lib/resource-1.0/api/toplevel/README @@ -0,0 +1,18 @@ +Parsing overloaded resource constructors. + +AR 2/7/2007. + +Do this way in gf: + + > i OverLangEng.gf + + > p -overload -cat=S "I loved her" + + mkS pastTense (mkCl (mkNP i_Pron) love_V2 (mkNP she_Pron)) + +The program FromOverload.hs creates the files OverGrammar.gf and OverGrammarEng.gf +from constr.gf (which in turn is the latter part of ../Constructors.gf). + + +Some imperative and punctuation forms are still missing, since they are treated +with special parameters. diff --git a/lib/resource-1.0/api/toplevel/constr.gf b/lib/resource-1.0/api/toplevel/constr.gf new file mode 100644 index 000000000..f96e1d0b2 --- /dev/null +++ b/lib/resource-1.0/api/toplevel/constr.gf @@ -0,0 +1,620 @@ + + 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 = ss [] ; +-- pluralImpForm : ImpForm = ss [] ; +-- politeImpForm : ImpForm = ss [] ; + +-- 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 +-- = mkUttImp ; +-- mkUtt : ImpForm -> Imp -> Utt -- help yourselves +-- = \f -> mkUttImp f 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 = +-- \phr,punct,text -> case punct of { +-- PFullStop => TFullStop phr text ; +-- PExclMark => TExclMark phr text ; +-- PQuestMark => TQuestMark phr text +-- } ; +-- mkText : Phr -> Punct -> Text = +-- \phr,punct -> case punct of { +-- PFullStop => TFullStop phr TEmpty ; +-- PExclMark => TExclMark phr TEmpty ; +-- PQuestMark => TQuestMark phr 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 + } ; + diff --git a/src/GF/Shell.hs b/src/GF/Shell.hs index dd8267a91..139a2ab07 100644 --- a/src/GF/Shell.hs +++ b/src/GF/Shell.hs @@ -30,6 +30,7 @@ import GF.Grammar.Values import GF.UseGrammar.GetTree import GF.UseGrammar.Generate (generateAll) ---- should be in API import GF.UseGrammar.Treebank +import GF.UseGrammar.MakeOverload (getOverloadResults) import GF.Shell.ShellCommands @@ -242,6 +243,9 @@ execC co@(comm, opts0) sa@(sh@(st,(h,_,_,_)),a) = checkOptions st co >> case com CParse ---- | oElem showMulti opts -> do + | oElem (iOpt "overload") opts -> do + p <- parse $ prCommandArg a + changeArg (opTTs2CommandArg getOverloadResults) p | oElem byLines opts -> do let ss = (if oElem showAll opts then id else filter (not . null)) $ lines $ prCommandArg a @@ -576,3 +580,9 @@ opTT2CommandArg :: (Tree -> Err [Tree]) -> CommandArg -> CommandArg opTT2CommandArg f (ATrms ts) = err AError (ATrms . concat) $ mapM f ts opTT2CommandArg _ (AError s) = AError ("expected term, but got error:" ++++ s) opTT2CommandArg _ a = AError ("expected term, but got:" ++++ prCommandArg a) + +opTTs2CommandArg :: ([Tree] -> [Tree]) -> CommandArg -> CommandArg +opTTs2CommandArg f (ATrms ts) = ATrms $ f ts +opTTs2CommandArg _ (AError s) = AError ("expected terms, but got error:" ++++ s) +opTTs2CommandArg _ a = AError ("expected terms, but got:" ++++ prCommandArg a) + diff --git a/src/GF/Shell/ShellCommands.hs b/src/GF/Shell/ShellCommands.hs index fba8a80a7..70238817b 100644 --- a/src/GF/Shell/ShellCommands.hs +++ b/src/GF/Shell/ShellCommands.hs @@ -185,7 +185,7 @@ optionsOfCommand co = case co of CConvertLatex _ -> none CLinearize _ -> both "utf8 table struct record all multi" "lang number unlexer mark" CParse -> - both "ambiguous fail cut new newer old cfg mcfg fcfg n ign raw v lines all prob" + both "ambiguous fail cut new newer old overload cfg mcfg fcfg n ign raw v lines all prob" "cat lang lexer parser number rawtrees" CTranslate _ _ -> opts "cat lexer parser" CGenerateRandom -> both "cf prob" "cat lang number depth atoms noexpand doexpand" diff --git a/src/GF/UseGrammar/MakeOverload.hs b/src/GF/UseGrammar/MakeOverload.hs new file mode 100644 index 000000000..1d574d001 --- /dev/null +++ b/src/GF/UseGrammar/MakeOverload.hs @@ -0,0 +1,73 @@ +---------------------------------------------------------------------- +-- | +-- Module : MakeOverload +-- Maintainer : AR +-- Stability : (stable) +-- Portability : (portable) +-- +-- choose shallowest trees, and remove an overload resolution prefix +----------------------------------------------------------------------------- + +module GF.UseGrammar.MakeOverload where + +import GF.Grammar.Abstract +import GF.Grammar.Macros + +import GF.Data.Operations +import GF.Data.Zipper +import Data.List + +-- AR 2/7/2007 +-- The top-level function takes a set of trees (typically parses) +-- and returns the list of those trees that have the minimum size. +-- In addition, the overload prefix "ovrld123_", is removed +-- from each constructor in which it appears. This is used for +-- showing the library API constructors in a parsable grammar. + +getOverloadResults :: [Tree] -> [Tree] +getOverloadResults = smallestTrs . map mkOverload + +-- NB: this does not always give the desired result, since +-- some genuine alternatives may be deeper: now we will exclude the +-- latter of +-- +-- mkCl this_NP love_V2 (mkNP that_NP here_Adv) +-- mkCl this_NP (mkVP (mkVP love_V2 that_NP) here_Adv) +-- +-- A perfect method would know the definitional equivalences of constructors. +-- +-- Notice also that size is a better measure than depth, because: +-- 1. Global depth does not exclude the latter of +-- +-- mkCl (mkNP he_Pron) love_V2 that_NP +-- mkCl (mkNP he_Pron) (mkVP love_V2 that_NP) +-- +-- 2. Length is needed to exclude the latter of +-- +-- mkS (mkCl (mkNP he_Pron) love_V2 that_NP) +-- mkS presentTense (mkCl (mkNP he_Pron) love_V2 that_NP) +-- + + +smallestTrs :: [Tr a] -> [Tr a] +smallestTrs ts = map fst $ filter ((==mx) . snd) tds where + tds = [(t, size t) | t <- ts] + mx = minimum $ map snd tds + size = sizeTr -- depthTr + +depthTr :: Tr a -> Int +depthTr (Tr (_, ts)) = case ts of + [] -> 1 + _ -> 1 + (maximum $ map depthTr ts) + +sizeTr :: Tr a -> Int +sizeTr (Tr (_, ts)) = 1 + sum (map sizeTr ts) + +-- format: ovrld123_mkNP + +mkOverload :: Tree -> Tree +mkOverload = mapTr (changeAtom overAtom) where + overAtom a = case a of + AtC (m, IC f) | take 5 f == "ovrld" -> + AtC (m, IC (tail (dropWhile (/='_') f))) + _ -> a