added example for NLG from logical formula. See examples/nlg

examples/nlg/Logic.gf

@@ -0,0 +1,20 @@
+abstract Logic = {
+
+cat
+  Ind; Prop;
+
+fun
+  john : Ind;
+  mary : Ind;
+  boy   : Ind -> Prop;
+  love  : Ind -> Ind -> Prop;
+  leave : Ind -> Prop;
+  smart : Ind -> Prop;
+  exists : (Ind -> Prop) -> Prop;
+  forall : (Ind -> Prop) -> Prop;
+  and,or : Prop -> Prop -> Prop;
+  impl : Prop -> Prop -> Prop;
+  not : Prop -> Prop;
+  eq : Ind -> Ind -> Prop;
+
+}

examples/nlg/LogicEng.gf

@@ -0,0 +1,23 @@
+--# -path=present
+concrete LogicEng of Logic = open (Eng=GrammarEng), ParadigmsEng, ResEng in {
+
+lincat
+  Ind = {s : Str};
+  Prop = {s:Str};
+
+lin
+  john = {s="john"};
+  mary = {s="mary"};
+  boy x = {s="boy"++"("++x.s++")"};
+  smart x = {s="smart"++"("++x.s++")"};
+  love x y = {s="love"++"("++x.s++","++y.s++")"};
+  leave x = {s="leave"++"("++x.s++")"};
+  and  x y = {s=x.s++"&&"++y.s};
+  or   x y = {s=x.s++"||"++y.s};
+  impl x y = {s=x.s++"=>"++y.s};
+  forall f = {s="forall"++f.$0++"."++"("++f.s++")"};
+  exists f = {s="exists"++f.$0++"."++"("++f.s++")"};
+  not p = {s="not"++"("++p.s++")"};
+  eq x y = {s=x.s++"="++y.s};
+
+}

examples/nlg/NLG.gf

@@ -0,0 +1,102 @@
+abstract NLG = Logic ** {
+
+flags
+  startcat = Utt;
+
+cat
+  N  (Ind -> Prop);
+  A  (Ind -> Prop);
+  CN (Ind -> Prop);
+  Det ((Ind -> Prop) -> (Ind -> Prop) -> Prop);
+  PN Ind;
+  NP ((Ind -> Prop) -> Prop);
+  AP (Ind -> Prop);
+  VP (Ind -> Prop);
+  V  (Ind -> Prop);
+  V2 (Ind -> Ind -> Prop);
+  Comp (Ind -> Prop);
+  Pol (Prop -> Prop);
+  Cl Prop;
+  S Prop;
+  Utt;
+
+  Conj (Prop -> Prop -> Prop) ;
+  ListNP ((Prop -> Prop -> Prop) -> (Ind -> Prop) -> Prop) ;
+  ListS  ((Prop -> Prop -> Prop) -> Prop) ;
+
+fun
+  PredVP : ({np} : (Ind -> Prop) -> Prop) ->
+           ({vp} : Ind -> Prop) ->
+           NP np -> VP vp -> Cl (np vp) ;
+
+  UseV : ({v} : Ind -> Prop) ->
+         V v -> VP v ;
+
+  ComplV2 : ({v2} : Ind -> Ind -> Prop) ->
+            ({np} : (Ind -> Prop) -> Prop) ->
+            V2 v2 -> NP np -> VP (\i -> np (v2 i)) ;
+            
+  UseComp : ({c} : Ind -> Prop) ->
+            Comp c -> VP c ;
+
+  CompAP : ({ap} : Ind -> Prop) ->
+           AP ap -> Comp ap ;
+
+  CompNP : ({np} : (Ind -> Prop) -> Prop) ->
+           NP np -> Comp (\x -> np (\y -> eq x y)) ;
+
+  UsePN : (i : Ind) -> PN i -> NP (\f -> f i) ;
+
+  DetCN : ({det} : (Ind -> Prop) -> (Ind -> Prop) -> Prop) ->
+          ({cn} : Ind -> Prop) ->            
+          Det det -> CN cn -> NP (\f -> det cn f);
+
+  AdjCN : ({ap,cn} : Ind -> Prop) ->
+          AP ap -> CN cn -> CN (\x -> and (ap x) (cn x)) ;
+
+  PositA : ({a} : Ind -> Prop) ->
+           A a -> AP a ;
+
+  UseN : ({n} : Ind -> Prop) -> N n -> CN n;
+  
+  BaseNP : ({np1,np2} : (Ind -> Prop) -> Prop) ->
+           NP np1 -> NP np2 -> ListNP (\conj,f -> conj (np1 f) (np2 f)) ;
+  ConsNP : ({np1} : (Ind -> Prop) -> Prop) ->
+           ({lst} : (Prop -> Prop -> Prop) -> (Ind -> Prop) -> Prop) ->
+           NP np1 -> ListNP lst -> ListNP (\conj,f -> conj (np1 f) (lst conj f)) ;
+  ConjNP : ({cnj} : Prop -> Prop -> Prop) ->
+           ({lst} : (Prop -> Prop -> Prop) -> (Ind -> Prop) -> Prop) ->
+           Conj cnj -> ListNP lst -> NP (lst cnj) ;
+
+  BaseS : ({s1,s2} : Prop) ->
+          S s1 -> S s2 -> ListS (\conj -> conj s1 s2) ;
+  ConsS : ({s1} : Prop) ->
+          ({lst} : (Prop -> Prop -> Prop) -> Prop) ->
+          S s1 -> ListS lst -> ListS (\conj -> conj s1 (lst conj)) ;
+  ConjS : ({cnj} : Prop -> Prop -> Prop) ->
+          ({lst} : (Prop -> Prop -> Prop) -> Prop) ->
+          Conj cnj -> ListS lst -> S (lst cnj) ;
+
+  john_PN : PN john;
+  mary_PN : PN mary;
+  boy_N : N boy;
+  somebody_NP  : NP exists;
+  everybody_NP : NP forall;
+  love_V2 : V2 love ;
+  leave_V : V leave ;
+  smart_A : A smart ;
+  a_Det : Det (\d,f -> exists (\x -> and (d x) (f x)));
+  every_Det : Det (\d,f -> forall (\x -> impl (d x) (f x)));
+  some_Det : Det (\d,f -> exists (\x -> and (d x) (f x)));
+  PPos : Pol (\t -> t) ;
+  PNeg : Pol (\t -> not t) ;
+  and_Conj : Conj and ;
+  or_Conj : Conj or ;
+    
+  UseCl : ({cl} : Prop) -> 
+          ({p} : Prop -> Prop) ->
+          Pol p -> Cl cl -> S (p cl);
+
+  UttS : ({s} : Prop) -> S s -> Utt;
+
+}

examples/nlg/NLGEng.gf

@@ -0,0 +1,61 @@
+--# -path=present
+concrete NLGEng of NLG = LogicEng ** open (Eng=GrammarEng), ParadigmsEng, ResEng in {
+
+lincat
+  Det = Eng.Det;
+  N  = Eng.N;
+  A  = Eng.A;
+  CN = Eng.CN;
+  PN = Eng.PN;
+  NP = Eng.NP;
+  AP = Eng.AP;
+  VP = Eng.VP;
+  V2 = Eng.V2;
+  V  = Eng.V;
+  Comp=Eng.Comp;
+  Pol= Eng.Pol;
+  Cl = Eng.Cl;
+  S  = Eng.S;
+  Utt= Eng.Utt;
+  Conj = Eng.Conj;
+  ListNP = Eng.ListNP;
+  ListS = Eng.ListS;
+
+lin
+  DetCN _ _ = Eng.DetCN;
+  UseN _ = Eng.UseN;
+  UsePN _ = Eng.UsePN;
+  ComplV2 _ _ v2 np = Eng.ComplSlash (Eng.SlashV2a v2) np;
+  UseComp _ = Eng.UseComp ;
+  CompAP _ = Eng.CompAP ;
+  CompNP _ = Eng.CompNP ;
+  PredVP _ _ = Eng.PredVP;
+  PositA _ = Eng.PositA;
+  AdjCN _ _ = Eng.AdjCN;
+  UseV _ = Eng.UseV;
+  PPos = Eng.PPos;
+  PNeg = Eng.PNeg;
+  BaseNP _ _ = Eng.BaseNP;
+  ConsNP _ _ = Eng.ConsNP;
+  ConjNP _ _ = Eng.ConjNP;
+  BaseS _ _ = Eng.BaseS;
+  ConsS _ _ = Eng.ConsS;
+  ConjS _ _ = Eng.ConjS;
+  UseCl _ _ p x = Eng.UseCl (Eng.TTAnt Eng.TPres Eng.ASimul) p x;
+  UttS _ s = Eng.UttS s;
+
+  john_PN = mkPN "John";
+  mary_PN = mkPN "Mary";
+  love_V2 = mkV2 (mkV "love");
+  leave_V = mkV "leave" "left" "left";
+  somebody_NP = Eng.somebody_NP;
+  everybody_NP = Eng.everybody_NP;
+  boy_N = mkN "boy";
+  every_Det = Eng.every_Det;
+  some_Det = Eng.someSg_Det;
+  a_Det = Eng.DetQuant Eng.IndefArt Eng.NumSg;
+  smart_A = mkA "smart";
+  and_Conj = Eng.and_Conj;
+  or_Conj = Eng.or_Conj;
+
+}