carried over Art and Temp changes to next-resource/api/Constructors

lib/next-resource/api/Combinators.gf

@@ -0,0 +1,190 @@
+--1 Combinators: a High-Level Syntax API
+
+-- This module defines some "grammatical functions" that give shortcuts to
+-- typical constructions. [``Constructors`` Constructors.html] and the
+-- language-specific ``Paradigms`` modules are usually needed
+-- to construct arguments of these functions.
+
+incomplete resource Combinators = open Grammar in {
+
+  oper
+
+--2 Predication
+
+    pred : overload {
+      pred : V  -> NP -> Cl ;             -- x converges
+      pred : V2 -> NP -> NP -> Cl ;       -- x intersects y
+      pred : V3 -> NP -> NP -> NP -> Cl ; -- x intersects y at z
+      pred : V  -> NP -> NP -> Cl ;       -- x and y intersect
+      pred : A  -> NP -> Cl ;             -- x is even
+      pred : A2 -> NP -> NP -> Cl ;       -- x is divisible by y
+      pred : A  -> NP -> NP -> Cl ;       -- x and y are equal
+      pred : N  -> NP -> Cl ;             -- x is a maximum
+      pred : CN -> NP -> Cl ;             -- x is a local maximum
+      pred : NP -> NP -> Cl ;             -- x is the neutral element
+      pred : N  -> NP -> NP -> Cl ;       -- x and y are inverses 
+      pred : Adv -> NP -> Cl ;            -- x is in scope
+      pred : Prep -> NP -> NP -> Cl       -- x is outside y
+      } ;
+
+--2 Function application
+
+    app : overload {
+      app : N  -> NP ;
+      app : N2 -> NP -> NP ; 
+      app : N3 -> NP -> NP -> NP ;
+      app : N2 -> NP -> NP -> NP ;
+      app : N2 -> N -> CN
+      } ;
+
+--2 Coordination
+
+    coord : overload {
+      coord : Conj  -> Adv -> Adv -> Adv ;
+      coord : Conj  -> AP -> AP -> AP ;
+      coord : Conj  -> NP -> NP -> NP ;
+      coord : Conj  -> S  -> S  -> S ;
+      coord : Conj  -> ListAdv -> Adv ;
+      coord : Conj  -> ListAP -> AP ;
+      coord : Conj  -> ListNP -> NP ;
+      coord : Conj  -> ListS  -> S ;
+
+      } ;
+
+--2 Modification
+
+    mod : overload {
+      mod : A -> N -> CN ;
+      mod : AP -> CN -> CN ;
+      mod : AdA -> A -> AP ;
+      mod : Det -> N -> NP ;
+      mod : Det -> CN -> NP ;
+      mod : Quant -> N -> NP ;
+      mod : Quant -> CN -> NP ;
+      mod : Predet -> N -> NP ;
+      mod : Numeral -> N -> NP
+
+
+      } ;
+
+--2 Negation
+
+    neg : overload {
+      neg : Imp -> Utt ;
+      neg : Cl -> S ;
+      neg : QCl -> QS ;
+      neg : RCl -> RS 
+    };
+
+--2 Text append
+
+-- This is not in ground API, because it would destroy parsing.
+
+    appendText : Text -> Text -> Text ;
+
+--.
+
+    pred = overload {
+      pred : V  -> NP -> Cl
+                                       = \v,np -> PredVP np (UseV v) ;
+      pred : V2 -> NP -> NP -> Cl
+                                       = \v,np,ob -> PredVP np (ComplSlash (SlashV2a v) ob) ;
+      pred : V3 -> NP -> NP -> NP -> Cl 
+                                       = \v,np,ob,ob2 -> 
+                                          PredVP np (ComplSlash (Slash2V3 v ob) ob2) ;
+      pred : V  -> NP -> NP -> Cl
+                                       = \v,x,y -> PredVP (ConjNP and_Conj (BaseNP x y)) (UseV v) ;
+      pred : A  -> NP -> Cl 
+                                       = \a,np -> PredVP np (UseComp (CompAP (PositA a))) ;
+      pred : A2 -> NP -> NP -> Cl
+                                       = \a,x,y -> PredVP x (UseComp (CompAP (ComplA2 a y))) ;
+      pred : A  -> NP -> NP -> Cl      
+                                       = \a,x,y -> PredVP (ConjNP and_Conj (BaseNP x y)) (UseComp (CompAP (PositA a))) ;
+      pred : N -> NP -> Cl
+                                       = \n,x -> PredVP x (UseComp (CompNP (DetArtSg (IndefArt) (UseN n)))) ;
+      pred : CN -> NP -> Cl
+                                       = \n,x -> PredVP x (UseComp (CompNP (DetArtSg (IndefArt) n))) ;
+      pred : NP -> NP -> Cl
+                                       = \n,x -> PredVP x (UseComp (CompNP n)) ;      pred : N2 -> NP -> NP -> Cl 
+                                       = \n,x,y -> PredVP x (UseComp (CompNP (DetArtSg (IndefArt) (ComplN2 n y)))) ;
+      pred : N -> NP -> NP -> Cl 
+                                       = \n,x,y -> PredVP (ConjNP and_Conj (BaseNP x y)) (UseComp (CompNP (DetArtPl (IndefArt) (UseN n)))) ;
+      pred : Adv -> NP -> Cl 
+                                       = \a,x -> PredVP x (UseComp (CompAdv a)) ;
+      pred : Prep -> NP -> NP -> Cl        
+                                       = \p,x,y -> PredVP x (UseComp (CompAdv (PrepNP p y)))
+
+      } ;
+
+    app = overload {
+      app : N  -> NP
+                                       = \n -> (DetArtSg (DefArt) (UseN n)) ;
+      app : N2 -> NP -> NP 
+                                       = \n,x -> (DetArtSg (DefArt) (ComplN2 n x)) ;
+      app : N3 -> NP -> NP -> NP
+                                       = \n,x,y -> (DetArtSg (DefArt) (ComplN2 (ComplN3 n x) y)) ;
+      app : N2 -> NP -> NP -> NP
+                                       = \n,x,y -> (DetArtSg DefArt (ComplN2 n (ConjNP and_Conj (BaseNP x y)))) ;
+      app : N2 -> N -> CN
+                                       = \f,n -> ComplN2 f (DetArtPl (IndefArt) (UseN n))
+      } ;
+
+    coord = overload {
+      coord : Conj -> Adv -> Adv -> Adv
+                                        = \c,x,y -> ConjAdv c (BaseAdv x y) ;
+      coord : Conj -> AP -> AP -> AP
+                                        = \c,x,y -> ConjAP c (BaseAP x y) ;
+      coord : Conj -> NP -> NP -> NP
+                                        = \c,x,y -> ConjNP c (BaseNP x y) ;
+      coord : Conj -> S  -> S  -> S  
+                                        = \c,x,y -> ConjS c (BaseS x y) ;
+      coord : Conj -> ListAdv -> Adv
+                                        = \c,xy -> ConjAdv c xy ;
+      coord : Conj -> ListAP -> AP
+                                        = \c,xy -> ConjAP c xy ; 
+      coord : Conj -> ListNP -> NP
+                                        = \c,xy -> ConjNP c xy ;
+      coord : Conj -> ListS  -> S  
+                                        = \c,xy -> ConjS c xy
+      } ;
+
+    mod = overload {
+      mod : A -> N -> CN
+                                  = \a,n -> AdjCN (PositA a) (UseN n) ;
+      mod : AP -> CN -> CN
+                                  = \a,n -> AdjCN a n ;
+      mod : AdA -> A -> AP
+                                  = \m,a -> AdAP m (PositA a) ;
+
+      mod : Det -> N -> NP 
+	                          = \d,n -> DetCN d (UseN n) ;
+      mod : Det -> CN -> NP 
+	                          = \d,n -> DetCN d n ;
+      mod : Quant -> N -> NP
+                                  = \q,n -> DetCN (DetQuant (q) NumSg) (UseN n) ;
+      mod : Quant -> CN -> NP
+                                  = \q,n -> DetCN (DetQuant (q) NumSg) n ;
+      mod : Predet -> N -> NP 
+                                  = \q,n -> PredetNP q (DetArtPl (IndefArt)  (UseN n)) ;
+      mod : Numeral -> N -> NP
+                                  = \nu,n -> DetCN (DetArtCard (IndefArt) (NumNumeral nu)) (UseN n)
+
+      } ;
+
+    neg = overload {
+      neg : Imp -> Utt 
+	                 = UttImpSg PNeg ;
+      neg : Cl -> S 
+	                 = UseCl TPres ASimul PNeg;
+      neg : QCl -> QS 
+	                 = UseQCl TPres ASimul PNeg;
+      neg : RCl -> RS 
+	                 = UseRCl TPres ASimul PNeg
+    };
+
+-- This is not in ground API, because it would destroy parsing.
+
+    appendText : Text -> Text -> Text 
+                = \x,y -> {s = x.s ++ y.s ; lock_Text = <>} ;
+
+}

lib/next-resource/api/CombinatorsEng.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource CombinatorsEng = Combinators with (Grammar = GrammarEng) ;

lib/next-resource/api/ConstructorsBul.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource ConstructorsBul = Constructors with (Grammar = GrammarBul) ;

lib/next-resource/api/ConstructorsCat.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource ConstructorsCat = Constructors with (Grammar = GrammarCat) ;

lib/next-resource/api/ConstructorsDan.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource ConstructorsDan = Constructors with (Grammar = GrammarDan) ;

lib/next-resource/api/ConstructorsEng.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource ConstructorsEng = Constructors with (Grammar = GrammarEng) ;

lib/next-resource/api/ConstructorsFin.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource ConstructorsFin = Constructors with (Grammar = GrammarFin) ;

lib/next-resource/api/ConstructorsFre.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource ConstructorsFre = Constructors with (Grammar = GrammarFre) ;

lib/next-resource/api/ConstructorsGer.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource ConstructorsGer = Constructors with (Grammar = GrammarGer) ;

lib/next-resource/api/ConstructorsIta.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource ConstructorsIta = Constructors with (Grammar = GrammarIta) ;

lib/next-resource/api/ConstructorsNor.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource ConstructorsNor = Constructors with (Grammar = GrammarNor) ;

lib/next-resource/api/ConstructorsRus.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource ConstructorsRus = Constructors with (Grammar = GrammarRus) ;

lib/next-resource/api/ConstructorsSpa.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource ConstructorsSpa = Constructors with (Grammar = GrammarSpa) ;

lib/next-resource/api/ConstructorsSwe.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource ConstructorsSwe = Constructors with (Grammar = GrammarSwe) ;

lib/next-resource/api/Syntax.gf

@@ -0,0 +1,4 @@
+--# -path=.:alltenses:prelude
+
+interface Syntax = Constructors, Cat, Structural, Numeral ;
+

lib/next-resource/api/SyntaxBul.gf

@@ -0,0 +1,4 @@
+--# -path=.:alltenses:prelude
+
+instance SyntaxBul of Syntax = ConstructorsBul, CatBul, StructuralBul, NumeralBul ;
+

lib/next-resource/api/SyntaxCat.gf

@@ -0,0 +1,4 @@
+--# -path=.:alltenses:prelude
+
+instance SyntaxCat of Syntax = ConstructorsCat, CatCat, StructuralCat, NumeralCat ;
+

lib/next-resource/api/SyntaxDan.gf

@@ -0,0 +1,4 @@
+--# -path=.:alltenses:prelude
+
+instance SyntaxDan of Syntax = ConstructorsDan, CatDan, StructuralDan, NumeralDan ;
+

lib/next-resource/api/SyntaxEng.gf

@@ -0,0 +1,4 @@
+--# -path=.:alltenses:prelude
+
+instance SyntaxEng of Syntax = ConstructorsEng, CatEng, StructuralEng, NumeralEng ;
+

lib/next-resource/api/SyntaxFin.gf

@@ -0,0 +1,4 @@
+--# -path=.:alltenses:prelude
+
+instance SyntaxFin of Syntax = ConstructorsFin, CatFin, StructuralFin, NumeralFin ;
+

lib/next-resource/api/SyntaxFre.gf

@@ -0,0 +1,4 @@
+--# -path=.:alltenses:prelude
+
+instance SyntaxFre of Syntax = ConstructorsFre, CatFre, StructuralFre, NumeralFre ;
+

lib/next-resource/api/SyntaxGer.gf

@@ -0,0 +1,4 @@
+--# -path=.:alltenses:prelude
+
+instance SyntaxGer of Syntax = ConstructorsGer, CatGer, StructuralGer, NumeralGer ;
+

lib/next-resource/api/SyntaxIta.gf

@@ -0,0 +1,4 @@
+--# -path=.:alltenses:prelude
+
+instance SyntaxIta of Syntax = ConstructorsIta, CatIta, StructuralIta, NumeralIta ;
+

lib/next-resource/api/SyntaxNor.gf

@@ -0,0 +1,5 @@
+--# -path=.:alltenses:prelude
+
+instance SyntaxNor of Syntax = ConstructorsNor, CatNor, StructuralNor, NumeralNor
+ ;
+

lib/next-resource/api/SyntaxRus.gf

@@ -0,0 +1,4 @@
+--# -path=.:alltenses:prelude
+
+instance SyntaxRus of Syntax = ConstructorsRus, CatRus, StructuralRus, NumeralRus ;
+

lib/next-resource/api/SyntaxSpa.gf

@@ -0,0 +1,4 @@
+--# -path=.:alltenses:prelude
+
+instance SyntaxSpa of Syntax = ConstructorsSpa, CatSpa, StructuralSpa, NumeralSpa ;
+

lib/next-resource/api/SyntaxSwe.gf

@@ -0,0 +1,4 @@
+--# -path=.:alltenses:prelude
+
+instance SyntaxSwe of Syntax = ConstructorsSwe, CatSwe, StructuralSwe, NumeralSwe ;
+

lib/next-resource/api/TryBul.gf

@@ -0,0 +1,13 @@
+--# -path=.:alltenses:prelude
+
+resource TryBul = SyntaxBul, LexiconBul, ParadigmsBul - [mkAdv] ** 
+  open (P = ParadigmsBul), in {
+
+oper
+
+  mkAdv = overload SyntaxBul {
+    mkAdv : Str -> Adv = P.mkAdv ;
+  } ;
+
+
+}

lib/next-resource/api/TryCat.gf

@@ -0,0 +1,13 @@
+--# -path=.:alltenses:prelude
+
+resource TryCat = SyntaxCat, LexiconCat, ParadigmsCat - [mkAdv] ** 
+  open (P = ParadigmsCat), in {
+
+oper
+
+  mkAdv = overload SyntaxCat {
+    mkAdv : Str -> Adv = P.mkAdv ;
+  } ;
+
+
+}

lib/next-resource/api/TryDan.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource TryDan = SyntaxDan, LexiconDan, ParadigmsDan - [mkAdv] ;

lib/next-resource/api/TryEng.gf

@@ -0,0 +1,13 @@
+--# -path=.:alltenses:prelude
+
+resource TryEng = SyntaxEng, LexiconEng, ParadigmsEng - [mkAdv] ** 
+  open (P = ParadigmsEng), in {
+
+oper
+
+  mkAdv = overload SyntaxEng {
+    mkAdv : Str -> Adv = P.mkAdv ;
+  } ;
+
+
+}

lib/next-resource/api/TryFin.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource TryFin = SyntaxFin, LexiconFin-[mkOrd], ParadigmsFin - [mkAdv] ;

lib/next-resource/api/TryFre.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource TryFre = SyntaxFre, LexiconFre, ParadigmsFre - [mkAdv] ;

lib/next-resource/api/TryGer.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource TryGer = SyntaxGer, LexiconGer, ParadigmsGer - [mkAdv] ;

lib/next-resource/api/TryIta.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource TryIta = SyntaxIta, LexiconIta, ParadigmsIta - [mkAdv,in_Prep] ;

lib/next-resource/api/TryNor.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource TryNor = SyntaxNor, LexiconNor, ParadigmsNor - [mkAdv] ;

lib/next-resource/api/TryRus.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource TryRus = SyntaxRus, LexiconRus, ParadigmsRus - [mkAdv] ;

lib/next-resource/api/TrySpa.gf

@@ -0,0 +1,3 @@
+--# -path=.:alltenses:prelude
+
+resource TrySpa = SyntaxSpa, LexiconSpa, ParadigmsSpa - [mkAdv] ;

lib/next-resource/api/TrySwe.gf

@@ -0,0 +1,12 @@
+--# -path=.:alltenses:prelude
+
+resource TrySwe = SyntaxSwe, LexiconSwe, ParadigmsSwe - [mkAdv] ** 
+  open (P = ParadigmsSwe), in {
+
+oper
+
+  mkAdv = overload SyntaxSwe {
+    mkAdv : Str -> Adv = P.mkAdv ;
+  } ;
+
+}