--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 : DConj -> Adv -> Adv -> Adv ;
      coord : DConj -> AP -> AP -> AP ;
      coord : DConj -> NP -> NP -> NP ;
      coord : DConj -> S  -> S  -> S ;
      coord : Conj  -> ListAdv -> Adv ;
      coord : Conj  -> ListAP -> AP ;
      coord : Conj  -> ListNP -> NP ;
      coord : Conj  -> ListS  -> S ;
      coord : DConj -> ListAdv -> Adv ;
      coord : DConj -> ListAP -> AP ;
      coord : DConj -> ListNP -> NP ;
      coord : DConj -> 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 (ComplV2 v ob) ;
      pred : V3 -> NP -> NP -> NP -> Cl 
                                       = \v,np,ob,ob2 -> 
                                          PredVP np (ComplV3 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 (DetCN (DetSg (IndefArt) NoOrd) (UseN n)))) ;
      pred : CN -> NP -> Cl
                                       = \n,x -> PredVP x (UseComp (CompNP (DetCN (DetSg (IndefArt) NoOrd) n))) ;
      pred : NP -> NP -> Cl
                                       = \n,x -> PredVP x (UseComp (CompNP n)) ;      pred : N2 -> NP -> NP -> Cl 
                                       = \n,x,y -> PredVP x (UseComp (CompNP (DetCN (DetSg (IndefArt) NoOrd) (ComplN2 n y)))) ;
      pred : N -> NP -> NP -> Cl 
                                       = \n,x,y -> PredVP (ConjNP and_Conj (BaseNP x y)) (UseComp (CompNP (DetCN (DetPl (IndefArt) NoNum NoOrd) (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 -> DetCN (DetSg (DefArt) NoOrd) (UseN n) ;
      app : N2 -> NP -> NP 
                                       = \n,x -> DetCN (DetSg (DefArt) NoOrd) (ComplN2 n x) ;
      app : N3 -> NP -> NP -> NP
                                       = \n,x,y -> DetCN (DetSg (DefArt) NoOrd) (ComplN2 (ComplN3 n x) y) ;
      app : N2 -> NP -> NP -> NP
                                       = \n,x,y -> DetCN (DetSg (DefArt) NoOrd) (ComplN2 n (ConjNP and_Conj (BaseNP x y))) ;
      app : N2 -> N -> CN
                                       = \f,n -> ComplN2 f (DetCN (DetPl (IndefArt) NoNum NoOrd) (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 : DConj -> Adv -> Adv -> Adv
                                        = \c,x,y -> DConjAdv c (BaseAdv x y) ;
      coord : DConj -> AP -> AP -> AP
                                        = \c,x,y -> DConjAP c (BaseAP x y) ;
      coord : DConj -> NP -> NP -> NP
                                        = \c,x,y -> DConjNP c (BaseNP x y) ;
      coord : DConj -> S  -> S  -> S  
                                        = \c,x,y -> DConjS 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 ;
      coord : DConj -> ListAdv -> Adv
                                        = \c,xy -> DConjAdv c xy ;
      coord : DConj -> ListAP -> AP
                                        = \c,xy -> DConjAP c xy ; 
      coord : DConj -> ListNP -> NP
                                        = \c,xy -> DConjNP c xy ;
      coord : DConj -> ListS  -> S  
                                        = \c,xy -> DConjS 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 (DetSg (q) NoOrd) (UseN n) ;
      mod : Quant -> CN -> NP
                                  = \q,n -> DetCN (DetSg (q) NoOrd) n ;
      mod : Predet -> N -> NP 
                                  = \q,n -> PredetNP q (DetCN (DetPl (IndefArt)  NoNum NoOrd) (UseN n)) ;
      mod : Numeral -> N -> NP
                                  = \nu,n -> DetCN (DetPl (IndefArt) (NumNumeral nu) NoOrd) (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 = <>} ;

}
