Founding the newly structured GF2.0 cvs archive.

12 files changed, 2142 insertions, 0 deletions

diff --git a/grammars/resource/german/DatabaseDeu.gf b/grammars/resource/german/DatabaseDeu.gf
new file mode 100644
index 000000000..a7a8f278e
--- /dev/null
+++ b/grammars/resource/german/DatabaseDeu.gf
@@ -0,0 +1,52 @@
+concrete DatabaseDeu of Database = 
+  open Prelude,Syntax,Deutsch,Predication,Paradigms,DatabaseRes in {
+
+flags lexer=text ; unlexer=text ;
+
+lincat 
+  Phras      = SS1 Bool ;            -- long or short form
+  Subject    = NP ;
+  Noun       = CN ;  
+  Property   = AP ;
+  Comparison = AdjDeg ;
+  Relation   = Adj2 ;
+  Feature    = Fun ;
+  Value      = NP ;
+  Name       = ProperName ;
+
+lin
+  LongForm  sent = ss (sent.s ! True ++ "?") ;
+  ShortForm sent = ss (sent.s ! False ++ "?") ;
+
+  WhichAre A B = mkSent (defaultQuestion (IntVP (NounIPMany A) (PosA B)))
+                        (defaultNounPhrase (IndefManyNP (ModAdj B A))) ;
+
+  IsIt Q A   = mkSentSame (defaultQuestion (QuestVP Q (PosA A))) ;
+
+  MoreThan   = ComparAdjP ;
+  TheMost    = SuperlNP ;
+  Relatively C _  = PositAdjP C ; 
+
+  RelatedTo  = ComplAdj ;
+
+  FeatureOf = appFun1 ;
+  ValueOf F V = appFun1 F (UsePN V) ;
+
+  WithProperty A B = ModAdj B A ;
+
+  Individual = nameNounPhrase ;
+
+  AllN = DetNP AllDet ;
+  MostN = DetNP MostDet ;
+  EveryN = DetNP EveryDet ;
+
+-- only these are language-dependent
+
+  Any = detNounPhrase einDet ;
+
+  IsThere A  = mkSentPrel ["gibt es"] (defaultNounPhrase (IndefOneNP A)) ;
+  AreThere A = mkSentPrel ["gibt es"] (defaultNounPhrase (IndefManyNP A)) ;
+
+  WhatIs V   = mkSentPrel ["was ist"] (defaultNounPhrase V) ;
+
+} ;
diff --git a/grammars/resource/german/DatabaseRes.gf b/grammars/resource/german/DatabaseRes.gf
new file mode 100644
index 000000000..57bac16ac
--- /dev/null
+++ b/grammars/resource/german/DatabaseRes.gf
@@ -0,0 +1,11 @@
+resource DatabaseRes = open Prelude in {
+oper
+  mkSent : SS -> SS -> SS1 Bool = \long, short -> 
+    {s = table {b => if_then_else Str b long.s short.s}} ;
+
+  mkSentPrel : Str -> SS -> SS1 Bool = \prel, matter -> 
+    mkSent (ss (prel ++ matter.s)) matter ;
+
+  mkSentSame : SS -> SS1 Bool = \s -> 
+    mkSent s s ;
+} ;
diff --git a/grammars/resource/german/Deutsch.gf b/grammars/resource/german/Deutsch.gf
new file mode 100644
index 000000000..4a91ad219
--- /dev/null
+++ b/grammars/resource/german/Deutsch.gf
@@ -0,0 +1 @@
+resource Deutsch = reuse ResDeu ;
diff --git a/grammars/resource/german/Logical.gf b/grammars/resource/german/Logical.gf
new file mode 100644
index 000000000..3347ae129
--- /dev/null
+++ b/grammars/resource/german/Logical.gf
@@ -0,0 +1,23 @@
+-- Slightly ad hoc and formal negation and connectives.
+
+resource Logical = Predication ** open Deutsch, Paradigms in {
+
+  oper
+    negS : S -> S ;         -- es ist nicht der Fall, dass S
+    univS : CN -> S -> S ;  -- für alle CNs gilt es, dass S
+    existS : CN -> S -> S ; -- es gibt ein CN derart, dass S
+    existManyS : CN -> S -> S ; -- es gibt CNs derart, dass S
+--.
+
+    negS = \A -> 
+      PredVP ItNP (NegNP (DefOneNP (CNthatS (UseN (nRaum "Fall" "Fälle")) A))) ;
+    univS = \A,B ->
+      PredVP ItNP (AdvVP (PosVS (mkV "gelten" "gilt" "gelte" "gegolten") B)
+                    (mkPP accusative "für" (DetNP AllDet A))) ;
+    existS = \A,B ->
+      PredVP ItNP (PosTV (tvDir (mkV "geben" "gibt" "gib" "gegeben"))
+                     (IndefOneNP (ModRC A (RelSuch B)))) ;
+    existManyS = \A,B ->
+     PredVP ItNP (PosTV (tvDir (mkV "geben" "gibt" "gib" "gegeben"))
+                    (IndefManyNP (ModRC A (RelSuch B)))) ;
+} ;
diff --git a/grammars/resource/german/Morpho.gf b/grammars/resource/german/Morpho.gf
new file mode 100644
index 000000000..f286bc3b7
--- /dev/null
+++ b/grammars/resource/german/Morpho.gf
@@ -0,0 +1,399 @@
+--1 A Simple German Resource Morphology
+--
+-- Aarne Ranta 2002
+--
+-- This resource morphology contains definitions needed in the resource
+-- syntax. It moreover contains the most usual inflectional patterns.
+--
+-- We use the parameter types and word classes defined in $types.Deu.gf$.
+
+resource Morpho = Types ** open (Predef=Predef), Prelude in {
+
+--2 Nouns
+--
+-- For conciseness and abstraction, we define a method for
+-- generating a case-dependent table from a list of four forms.
+
+oper
+  caselist : (_,_,_,_ : Str) -> Case => Str = \n,a,d,g -> table {
+    Nom => n ; Acc => a ; Dat => d ; Gen => g} ;
+
+-- The *worst-case macro* for common nouns needs six forms: all plural forms
+-- are always the same except for the dative.
+
+  mkNoun  : (_,_,_,_,_,_ : Str) -> Gender -> CommNoun = 
+    \mann, mannen, manne, mannes, männer, männern, g -> {s = table {
+       Sg => caselist mann mannen manne mannes ;
+       Pl => caselist männer männer männern männer
+       } ; g = g} ;
+
+-- But we never need all the six forms at the same time. Often
+-- we need just two, three, or four forms.
+
+  mkNoun4 : (_,_,_,_ : Str) -> Gender -> CommNoun = \kuh,kuhes,kühe,kühen ->
+      mkNoun kuh kuh kuh kuhes kühe kühen ;
+
+  mkNoun3 : (_,_,_ : Str) -> Gender -> CommNoun = \kuh,kühe,kühen ->
+      mkNoun kuh kuh kuh kuh kühe kühen ;
+
+  mkNoun2n : (_,_ : Str) -> Gender -> CommNoun = \zahl, zahlen -> 
+      mkNoun3 zahl zahlen zahlen ;
+
+  mkNoun2es : (_,_ : Str) -> Gender -> CommNoun = \wort, wörter -> 
+      mkNoun wort wort wort (wort + "es") wörter (wörter + "n") ;
+
+  mkNoun2s : (_,_ : Str) -> Gender -> CommNoun = \vater, väter -> 
+      mkNoun vater vater vater (vater + "s") väter (väter + "n") ;
+
+  mkNoun2ses : (_,_ : Str) -> Gender -> CommNoun = \wort,wörter -> 
+      mkNoun wort wort wort (wort + variants {"es" ; "s"}) wörter (wörter + "n") ;
+
+-- Here are the school grammar declensions with their commonest variations.
+-- Unfortunately we cannot define *Umlaut* in GF, but have to give two forms.
+--
+-- First declension, with plural "en"/"n", including weak masculins:
+
+  declN1  : Str -> CommNoun = \zahl  -> 
+    mkNoun2n zahl  (zahl + "en") Fem ;
+
+  declN1e : Str -> CommNoun = \stufe -> 
+    mkNoun2n stufe (stufe + "n") Fem ;  
+
+  declN1M : Str -> CommNoun = \junge -> let {jungen = junge + "n"} in
+    mkNoun junge jungen jungen jungen jungen jungen Masc ;
+
+  declN1eM : Str -> CommNoun = \soldat -> let {soldaten = soldat + "en"} in
+    mkNoun soldat soldaten soldaten soldaten soldaten soldaten Masc ;
+
+-- Second declension, with plural "e":
+
+  declN2  : Str -> CommNoun = \punkt -> 
+    mkNoun2es punkt (punkt+"e") Masc ;
+
+  declN2i  : Str -> CommNoun = \onkel -> 
+    mkNoun2s onkel onkel Masc ;
+
+  declN2u : (_,_ : Str) -> CommNoun = \raum,räume -> 
+    mkNoun2es raum räume Masc ;
+
+  declN2uF : (_,_ : Str) -> CommNoun = \kuh,kühe -> 
+    mkNoun3 kuh kühe (kühe + "n") Fem ;
+
+-- Third declension, with plural "er":
+
+  declN3  : Str -> CommNoun = \punkt -> 
+    mkNoun2es punkt (punkt+"er") Neut ;
+
+  declN3u : (_,_ : Str) -> CommNoun = \buch,bücher -> 
+    mkNoun2ses buch bücher Neut ;
+
+  declN3uS : (_,_ : Str) -> CommNoun = \haus,häuser -> 
+    mkNoun2es haus häuser Neut ;
+
+-- Plural with "s":
+
+  declNs : Str -> CommNoun = \restaurant -> 
+    mkNoun3 restaurant (restaurant+"s") (restaurant+"s") Neut ;
+
+
+--2 Pronouns
+--
+-- Here we define personal and relative pronouns.
+-- All personal pronouns, except "ihr", conform to the simple
+-- pattern $mkPronPers$.
+
+  ProPN = {s : NPForm => Str ; n : Number ; p : Person} ;
+
+  mkPronPers : (_,_,_,_,_ : Str) -> Number -> Person -> ProPN = 
+    \ich,mich,mir,meines,mein,n,p -> {
+      s = table {
+        NPCase c    => caselist ich mich mir meines ! c ;
+        NPPoss gn c => mein + pronEnding ! gn ! c
+        } ;
+      n = n ;
+      p = p
+      } ;
+
+  pronEnding : GenNum => Case => Str = table {
+    GSg Masc => caselist ""  "en" "em" "es" ;
+    GSg Fem  => caselist "e" "e"  "er" "er" ;
+    GSg Neut => caselist ""  ""   "em" "es" ;
+    GPl      => caselist "e"  "e" "en" "er"
+    } ;
+
+  pronIch  = mkPronPers "ich" "mich" "mir"   "meines" "mein"  Sg P1 ;
+  pronDu   = mkPronPers "du"  "dich" "dir"   "deines" "dein"  Sg P2 ;
+  pronEr   = mkPronPers "er"  "ihn"  "ihm"   "seines" "sein"  Sg P3 ;
+  pronSie  = mkPronPers "sie" "sie"  "ihr"   "ihres"  "ihr"   Sg P3 ;
+  pronEs   = mkPronPers "es"  "es"   "ihm"   "seines" "sein"  Sg P3 ;
+  pronWir  = mkPronPers "wir" "uns"  "uns"   "unser"  "unser" Pl P1 ;
+
+  pronSiePl = mkPronPers "sie" "sie"  "ihnen" "ihrer"  "ihr"   Pl P3 ;
+  pronSSie  = mkPronPers "Sie" "Sie"  "Ihnen" "Ihrer"  "Ihr"   Pl P3 ; ---
+
+-- We still have wrong agreement with the complement of the polite "Sie":
+-- it is in plural, like the verb, although it should be in singular.
+
+-- The peculiarity with "ihr" is the presence of "e" in forms without an ending.
+
+  pronIhr  = 
+     {s = table {
+        NPPoss (GSg Masc) Nom => "euer" ;
+        NPPoss (GSg Neut) Nom => "euer" ;
+        NPPoss (GSg Neut) Acc => "euer" ;
+        pf => (mkPronPers "ihr" "euch" "euch"  "euer"  "eur"  Pl P2).s ! pf
+        } ;
+      n = Pl ;
+      p = P2
+      } ;
+
+-- Relative pronouns are like the definite article, except in the genitive and
+-- the plural dative. The function $artDef$ will be defined right below.
+
+  RelPron : Type = {s : GenNum => Case => Str} ;
+
+  relPron : RelPron = {s = \\gn,c => 
+    case <gn,c> of {
+      <GSg Fem,Gen> => "deren" ;
+      <GSg g,Gen>   => "dessen" ;
+      <GPl,Dat>     => "denen" ;
+      <GPl,Gen>     => "deren" ;
+      _ => artDef ! gn ! c
+    } 
+  } ;
+
+
+--2 Articles
+--
+-- Here are all forms the indefinite and definite article.
+-- The indefinite article is like a large class of pronouns.
+-- The definite article is more peculiar; we don't try to
+-- subsume it to any general rule.
+
+  artIndef : Gender => Case => Str = \\g,c => "ein" + pronEnding ! GSg g ! c ;
+
+  artDef : GenNum => Case => Str = table {
+    GSg Masc => caselist "der" "den" "dem" "des" ;
+    GSg Fem  => caselist "die" "die" "der" "der" ;
+    GSg Neut => caselist "das" "das" "dem" "des" ;
+    GPl      => caselist "die" "die" "den" "der"
+    } ;
+
+
+--2 Adjectives
+--
+-- As explained in $types.Deu.gf$, it
+-- would be superfluous to use the cross product of gender and number,
+-- since there is no gender distinction in the plural. But it is handy to have
+-- a function that constructs gender-number complexes.
+  
+  gNumber : Gender -> Number -> GenNum = \g,n -> 
+    case n of {
+      Sg => GSg g ;
+      Pl => GPl
+      } ;
+
+-- It's also handy to have a function that finds out the number from such a complex.
+
+  numGenNum : GenNum -> Number = \gn -> 
+    case gn of {
+      GSg _ => Sg ;
+      GPl => Pl
+      } ;
+
+-- This function costructs parameters in the complex type of adjective forms.
+
+  aMod : Adjf -> Gender -> Number -> Case -> AForm = \a,g,n,c -> 
+    AMod a (gNumber g n) c ;
+
+-- The worst-case macro for adjectives (positive degree) only needs
+-- two forms.
+  
+  mkAdjective : (_,_ : Str) -> Adjective = \böse,bös -> {s = table {
+    APred => böse ;
+    AMod Strong (GSg Masc) c => 
+      caselist (bös+"er") (bös+"en") (bös+"em") (bös+"es") ! c ;
+    AMod Strong (GSg Fem) c => 
+      caselist (bös+"e") (bös+"e") (bös+"er") (bös+"er") ! c ;
+    AMod Strong (GSg Neut) c => 
+      caselist (bös+"es") (bös+"es") (bös+"em") (bös+"es") ! c ;
+    AMod Strong GPl c => 
+      caselist (bös+"e") (bös+"e") (bös+"en") (bös+"er") ! c ;
+    AMod Weak (GSg g) c => case <g,c> of {
+      <_,Nom>    => bös+"e" ;
+      <Masc,Acc> => bös+"en" ;
+      <_,Acc>    => bös+"e" ;
+      _          => bös+"en" } ;
+    AMod Weak GPl c => bös+"en"
+    }} ;
+
+-- Here are some classes of adjectives:
+ 
+  adjReg   : Str -> Adjective = \gut -> mkAdjective gut gut ;
+  adjE     : Str -> Adjective = \bös -> mkAdjective (bös+"e") bös ;
+  adjEr    : Str -> Adjective = \teu -> mkAdjective (teu+"er") (teu+"r") ;
+  adjInvar : Str -> Adjective = \prima -> {s = table {_ => prima}} ;
+
+-- The first three classes can be recognized from the end of the word, depending
+-- on if it is "e", "er", or something else.
+
+  adjGen : Str -> Adjective = \gut -> let {
+    er  = Predef.dp 2 gut ;
+    teu = Predef.tk 2 gut ;
+    e   = Predef.dp 1 gut ;
+    bös = Predef.tk 1 gut
+  } in
+  ifTok Adjective er "er" (adjEr  teu) (
+  ifTok Adjective e  "e"  (adjE   bös) (
+                          (adjReg gut))) ;
+
+
+-- The comparison of adjectives needs three adjectives in the worst case.
+
+  mkAdjComp : (_,_,_ : Adjective) -> AdjComp = \gut,besser,best -> 
+    {s = table {Pos => gut.s ; Comp => besser.s ; Sup => best.s}} ;
+
+-- It can be done by just three strings, if each of the comparison
+-- forms taken separately is a regular adjective.
+
+  adjCompReg3 : (_,_,_ : Str) -> AdjComp = \gut,besser,best ->
+    mkAdjComp (adjReg gut) (adjReg besser) (adjReg best) ;
+
+-- If also the comparison forms are regular, one string is enough.
+
+  adjCompReg : Str -> AdjComp = \billig ->
+    adjCompReg3 billig (billig+"er") (billig+"st") ;
+
+
+--2 Verbs
+--
+-- We limit ourselves to verbs in present tense infinitive, indicative, 
+-- and imperative, and past participle. Other forms will be introduced later.
+--
+-- The worst-case macro needs three forms: the infinitive, the third person
+-- singular indicative, and the second person singular imperative. 
+-- We take care of the special cases "ten", "sen", "ln", "rn".
+--
+-- A famous law about Germanic languages says that plural first and third person
+-- are similar.
+
+  mkVerbum : (_,_,_,_ : Str) -> Verbum = \geben, gib, gb, gegeben -> 
+    let {
+       en = Predef.dp 2 geben ;
+       geb = ifTok Tok (Predef.tk 1 en) "e" (Predef.tk 2 geben)(Predef.tk 1 geben) ;
+       gebt = ifTok Tok (Predef.dp 1 geb) "t" (geb + "et") (geb + "t") ;
+       gibst = ifTok Tok (Predef.dp 1 gib) "s" (gib + "t") (gib + "st") ;
+       gegebener = (adjReg gegeben).s
+    } in table {
+           VInf       => geben ;
+           VInd Sg P1 => geb + "e" ;
+           VInd Sg P2 => gibst ;
+           VInd Sg P3 => gib + "t" ;
+           VInd Pl P2 => gebt ;
+           VInd Pl _  => geben ; -- the famous law
+           VImp Sg    => gb ;
+           VImp Pl    => gebt ;
+           VPart a    => gegebener ! a
+           } ;
+
+-- Regular verbs:
+
+  regVerb : Str -> Verbum = \legen ->
+    let {lege = ifTok Tok (Predef.dp 3 legen) "ten" (Predef.tk 1 legen) (
+                ifTok Tok (Predef.dp 2 legen) "en"  (Predef.tk 2 legen) (
+                                                     Predef.tk 1 legen))} in
+    mkVerbum legen lege lege ("ge" + (lege + "t")) ;
+
+-- Verbs ending with "t"; now recognized in $mkVerbum$.
+
+  verbWarten : Str -> Verbum = regVerb ;
+
+-- Verbs with Umlaut in the second and third person singular and imperative:
+
+  verbSehen : Str -> Str -> Str -> Verbum = \sehen, sieht, gesehen -> 
+    let {sieh = Predef.tk 1 sieht} in mkVerbum sehen sieh sieh gesehen ;
+
+-- Verbs with Umlaut in the second and third person singular but not imperative:
+
+  verbLaufen : Str -> Str -> Str -> Verbum = \laufen, läuft, gelaufen -> 
+    let {läuf = Predef.tk 1 läuft ; laufe = Predef.tk 1 laufen} 
+    in mkVerbum laufen läuf laufe gelaufen ;
+
+-- The verb "be":
+
+  verbumSein : Verbum = let {
+    gewesen = (adjReg "gewesen").s
+  } in
+  table {
+    VInf       => "sein" ;
+    VInd Sg P1 => "bin" ;
+    VInd Sg P2 => "bist" ;
+    VInd Sg P3 => "ist" ;
+    VInd Pl P2 => "seid" ;
+    VInd Pl _  => "sind" ;
+    VImp Sg    => "sei" ;
+    VImp Pl    => "seiet" ;
+    VPart a    => gewesen ! a
+    } ;
+
+-- The verb "have":
+
+  verbumHaben :  Verbum = let {
+    haben = (regVerb "haben")
+    } in 
+    table {
+      VInd Sg P2 => "hast" ;
+      VInd Sg P3 => "hat" ;
+      v          => haben ! v
+      } ;
+
+-- The verb "become", used as the passive auxiliary:
+
+  verbumWerden :  Verbum = let {
+    werden = regVerb "werden" ;
+    geworden = (adjReg "geworden").s
+    } in 
+    table {
+      VInd Sg P2 => "wirst" ;
+      VInd Sg P3 => "wird" ;
+      VPart a    => geworden ! a ;
+      v          => werden ! v
+      } ;
+
+-- A *full verb* ($Verb$) consists of the inflection forms ($Verbum$) and
+-- a *particle* (e.g. "aus-sehen"). Simple verbs are the ones that have no 
+-- such particle.
+
+  mkVerb : Verbum -> Particle -> Verb = \v,p -> {s = v ; s2 = p} ;
+
+  mkVerbSimple : Verbum -> Verb = \v -> mkVerb v [] ;
+
+  verbSein = mkVerbSimple verbumSein ;
+  verbHaben = mkVerbSimple verbumHaben ;
+  verbWerden = mkVerbSimple verbumWerden ;
+
+{-
+  -- tests for optimizer
+  verbumSein2 : Verbum = 
+  table {
+    VInf       => "sein" ;
+    VInd Sg P1 => "bin" ;
+    VInd Sg P2 => "bist" ;
+    VInd Sg P3 => "ist" ;
+    VInd Pl P2 => "seid" ;
+    VInd Pl _  => "sind" ;
+    VImp Sg    => "sei" ;
+    VImp Pl    => "seiet" ;
+    VPart a    => (adjReg "gewesen").s ! a
+    } ;
+
+  verbumHaben2 :  Verbum = 
+    table {
+      VInd Sg P2 => "hast" ;
+      VInd Sg P3 => "hat" ;
+      v          => regVerb "haben" ! v
+      } ;
+-}
+
+} ;
+
diff --git a/grammars/resource/german/Paradigms.gf b/grammars/resource/german/Paradigms.gf
new file mode 100644
index 000000000..d31e3fecd
--- /dev/null
+++ b/grammars/resource/german/Paradigms.gf
@@ -0,0 +1,300 @@
+--1 German Lexical Paradigms
+--
+-- Aarne Ranta 2003
+--
+-- This is an API to the user of the resource grammar 
+-- for adding lexical items. It give shortcuts for forming
+-- expressions of basic categories: nouns, adjectives, verbs.
+-- 
+-- Closed categories (determiners, pronouns, conjunctions) are
+-- accessed through the resource syntax API, $resource.Abs.gf$. 
+--
+-- The main difference with $morpho.Deu.gf$ is that the types
+-- referred to are compiled resource grammar types. We have moreover
+-- had the design principle of always having existing forms as string
+-- arguments of the paradigms, not stems.
+--
+-- The following modules are presupposed:
+
+resource Paradigms = open (Predef=Predef), Prelude, (Morpho=Morpho), Syntax, Deutsch in {
+
+
+--2 Parameters 
+--
+-- To abstract over gender names, we define the following identifiers.
+
+oper
+  masculine : Gender ;
+  feminine  : Gender ;
+  neuter    : Gender ;
+
+-- To abstract over case names, we define the following.
+
+  nominative : Case ;
+  accusative : Case ;
+  dative     : Case ;
+  genitive   : Case ;
+
+-- To abstract over number names, we define the following.
+
+  singular : Number ;
+  plural   : Number ;
+
+
+--2 Nouns
+
+-- Worst case: give all four singular forms, two plural forms (others + dative),
+-- and the gender.
+
+  mkN  : (_,_,_,_,_,_ : Str) -> Gender -> N ; 
+                                 -- mann, mann, manne, mannes, männer, männern
+
+-- Often it is enough with singular and plural nominatives, and singular
+-- genitive. The plural dative
+-- is computed by the heuristic that it is the same as the nominative this
+-- ends with "n" or "s", otherwise "n" is added.
+
+  nGen : Str -> Str -> Str ->  Gender -> N ; -- punkt,punktes,punkt
+  
+-- Here are some common patterns. Singular nominative or two nominatives are needed.
+-- Two forms are needed in case of Umlaut, which would be complicated to define.
+-- For the same reason, we have separate patterns for multisyllable stems.
+-- 
+-- The weak masculine pattern $nSoldat$ avoids duplicating the final "e".
+
+  nRaum   : (_,_ : Str) -> N ;    -- Raum, (Raumes,) Räume (masc)
+  nTisch  : Str -> N ;            -- Tisch, (Tisches, Tische) (masc)
+  nVater  : (_,_ : Str) -> N ;    -- Vater, (Vaters,) Väter (masc)
+  nFehler : Str -> N ;            -- Fehler, (fehlers, Fehler) (masc)
+  nSoldat : Str -> N ;            -- Soldat (, Soldaten) ; Kunde (, Kunden) (masc)
+
+-- Neuter patterns. 
+
+  nBuch   : (_,_ : Str) -> N ;    -- Buch, (Buches, Bücher) (neut)
+  nMesser : Str -> N ;            -- Messer, (Messers, Messer) (neut)
+  nAuto   : Str -> N ;            -- Auto, (Autos, Autos) (neut)
+
+-- Feminine patterns. Duplicated "e" is avoided in $nFrau$.
+
+  nHand   : (_,_ : Str) -> N ;    -- Hand, Hände; Mutter, Mütter (fem)
+  nFrau   : Str -> N ;            -- Frau (, Frauen) ; Wiese (, Wiesen) (fem)
+
+
+-- Nouns used as functions need a preposition. The most common is "von".
+
+  mkFun  : N -> Preposition -> Case -> Fun ;
+  funVon : N -> Fun ;
+
+-- Proper names, with their possibly
+-- irregular genitive. The regular genitive is  "s", omitted after "s".
+
+  mkPN  : (karolus, karoli : Str) -> PN ; -- karolus, karoli
+  pnReg : (Johann : Str) -> PN ;          -- Johann, Johanns ; Johannes, Johannes
+
+-- On the top level, it is maybe $CN$ that is used rather than $N$, and
+-- $NP$ rather than $PN$.
+
+  mkCN  : N -> CN ;
+  mkNP  : (karolus,karoli : Str) -> NP ;
+
+  npReg : Str -> NP ;   -- Johann, Johanns
+
+-- In some cases, you may want to make a complex $CN$ into a function.
+
+  mkFunCN  : CN -> Preposition -> Case -> Fun ;
+  funVonCN : CN -> Fun ;
+
+
+--2 Adjectives
+
+-- Non-comparison one-place adjectives need two forms in the worst case:
+-- the one in predication and the one before the ending "e".
+
+  mkAdj1 : (teuer,teur : Str) -> Adj1 ;
+
+-- Invariable adjective are a special case.
+
+  adjInvar : Str -> Adj1 ;          -- prima
+
+-- The following heuristic recognizes the the end of the word, and builds
+-- the second form depending on if it is "e", "er", or something else.
+-- N.B. a contraction is made with "er", which works for "teuer" but not
+-- for "bitter".
+
+  adjGen : Str -> Adj1 ;            -- gut; teuer; böse
+
+-- Two-place adjectives need a preposition and a case as extra arguments.
+
+  mkAdj2 : Adj1 -> Str -> Case -> Adj2 ;  -- teilbar, durch, acc
+
+-- Comparison adjectives may need three adjective, corresponding to the
+-- three comparison forms. 
+
+  mkAdjDeg : (gut,besser,best : Adj1) -> AdjDeg ;
+
+-- In many cases, each of these adjectives is itself regular. Then we only
+-- need three strings. Notice that contraction with "er" is not performed
+-- ("bessere", not "bessre").
+
+  aDeg3 : (gut,besser,best : Str) -> AdjDeg ;
+
+-- In the completely regular case, the comparison forms are constructed by
+-- the endings "er" and "st".
+
+  aReg : Str -> AdjDeg ;    -- billig, billiger, billigst
+
+-- The past participle of a verb can be used as an adjective.
+
+  aPastPart : V -> Adj1 ;   -- gefangen
+
+-- On top level, there are adjectival phrases. The most common case is
+-- just to use a one-place adjective. The variation in $adjGen$ is taken
+-- into account.
+
+  apReg : Str -> AP ;
+
+
+--2 Verbs
+--
+-- The fragment only has present tense so far, but in all persons.
+-- It also has the infinitive and the past participles.
+-- The worst case macro needs four forms: : the infinitive and 
+-- the third person singular (where Umlaut may occur), the singular imperative,
+-- and the past participle.
+-- 
+-- The function recognizes if the stem ends with "s" or "t" and performs the
+-- appropriate contractions.
+
+  mkV : (_,_,_,_ : Str) -> V ;   -- geben, gibt, gib, gegeben
+
+-- Regular verbs are those where no Umlaut occurs.
+
+  vReg  : Str -> V ;         -- kommen
+
+-- The verbs 'be' and 'have' are special.
+
+  vSein  : V ;
+  vHaben : V ;
+
+-- Verbs with a detachable particle, with regular ones as a special case.
+
+  vPart    :  (_,_,_,_,_ : Str) -> V ;     -- sehen, sieht, sieh, gesehen, aus
+  vPartReg :  (_,_     : Str) -> V ;       -- bringen, um
+
+-- Two-place verbs, and the special case with direct object. Notice that
+-- a particle can be included in a $V$.
+
+  mkTV     : V   -> Str -> Case -> TV ;  -- hören, zu, dative
+
+  tvReg    : Str -> Str -> Case -> TV ;  -- hören, zu, dative
+  tvDir    : V -> TV ;                   -- umbringen
+  tvDirReg : Str -> TV ;                 -- lieben
+
+--2 Adverbials
+--
+-- Adverbials for modifying verbs, adjectives, and sentences can be formed 
+-- from strings.
+
+  mkAdV : Str -> AdV ;
+  mkAdA : Str -> AdA ;
+  mkAdS : Str -> AdS ;
+
+-- Prepositional phrases are another productive form of adverbials.
+
+  mkPP : Case -> Str -> NP -> AdV ;
+
+-- The definitions should not bother the user of the API. So they are
+-- hidden from the document.
+--.
+
+
+  masculine = Masc ;
+  feminine  = Fem ;
+  neuter = Neut ;
+  nominative = Nom ;
+  accusative = Acc ;
+  dative = Dat ;
+  genitive = Gen ;
+  -- singular defined in Types
+  -- plural defined in Types
+
+  mkN = mkNoun ;
+
+  nGen = \punkt, punktes, punkte, g -> let {
+      e   = Predef.dp 1 punkte ; 
+      eqy = ifTok (Gender -> N) e ;
+      noN = mkNoun4 punkt punktes punkte punkte
+    } in
+    eqy "n" noN (
+    eqy "s" noN (
+            mkNoun4 punkt punktes punkte (punkte+"n"))) g ;
+
+  nRaum = \raum, räume -> nGen raum (raum + "es") räume masculine ;
+  nTisch = \tisch -> 
+    mkNoun4 tisch (tisch + "es") (tisch + "e") (tisch +"en") masculine ;
+  nVater = \vater, väter -> nGen vater (vater + "s") väter masculine ;
+  nFehler = \fehler -> nVater fehler fehler ;
+
+  nSoldat = \soldat -> let {
+     e = Predef.dp 1 soldat ; 
+     soldaten = ifTok Tok e "e" (soldat + "n") (soldat + "en")
+    } in
+    mkN soldat soldaten soldaten soldaten soldaten soldaten masculine ;
+
+  nBuch = \buch, bücher -> nGen buch (buch + "es") bücher neuter ;
+  nMesser = \messer -> nGen messer (messer + "s") messer neuter ;
+  nAuto = \auto -> let {autos = auto + "s"} in 
+          mkNoun4 auto autos autos autos neuter ;
+
+  nHand = \hand, hände -> nGen hand hand hände feminine ;
+
+  nFrau = \frau -> let {
+     e = Predef.dp 1 frau ; 
+     frauen = ifTok Tok e "e" (frau + "n") (frau + "en")
+    } in
+    mkN frau frau frau frau frauen frauen feminine ;
+
+  mkFun = \n -> mkFunCN (n2n n) ;
+  funVon = \n -> funVonCN (n2n n) ;
+
+  mkPN = \karolus, karoli -> {s = table {Gen => karoli ; _ => karolus}} ;
+  pnReg = \horst -> 
+    mkPN horst (ifTok Tok (Predef.dp 1 horst) "s" horst (horst + "s")) ;
+
+  mkCN = UseN ;
+  mkNP = \x,y -> UsePN (mkPN x y) ;
+  npReg = \s -> UsePN (pnReg s) ;
+
+  mkFunCN = mkFunC ;
+  funVonCN = funVonC ;
+
+  mkAdj1 = mkAdjective ;
+  adjInvar = Morpho.adjInvar ;
+  adjGen = Morpho.adjGen ;
+  mkAdj2 = \a,p,c -> a ** {s2 = p ; c = c} ;
+
+  mkAdjDeg = mkAdjComp ;
+  aDeg3 = adjCompReg3 ;
+  aReg = adjCompReg ;
+  aPastPart = \v -> {s = table AForm {a => v.s ! VPart a}} ; 
+  apReg = \s -> AdjP1 (adjGen s) ;
+
+  mkV = \sehen, sieht, sieh, gesehen -> 
+    mkVerbSimple (mkVerbum sehen sieht sieh gesehen) ;
+  vReg = \s -> mkVerbSimple (regVerb s) ;
+  vSein = verbSein ;
+  vHaben = verbHaben ;
+  vPart = \sehen, sieht, sieh, gesehen, aus -> 
+    mkVerb (mkVerbum sehen sieht sieh gesehen) aus ;
+  vPartReg = \sehen, aus -> mkVerb (regVerb sehen) aus ;
+
+  mkTV = mkTransVerb ;
+  tvReg = \hören, zu, dat -> mkTV (vReg hören) zu dat ;
+  tvDir = \v -> mkTV v [] accusative ;
+  tvDirReg = \v -> tvReg v [] accusative ; 
+
+  mkAdV = ss ;
+  mkPP = prepPhrase ;
+  mkAdA = ss ;
+  mkAdS = ss ;
+} ;
diff --git a/grammars/resource/german/Predication.gf b/grammars/resource/german/Predication.gf
new file mode 100644
index 000000000..9c05cc69b
--- /dev/null
+++ b/grammars/resource/german/Predication.gf
@@ -0,0 +1,87 @@
+
+--1 A Small Predication Library
+--
+-- (c) Aarne Ranta 2003 under Gnu GPL.
+--
+-- This library is built on a language-independent API of
+-- resource grammars. It has a common part, the type signatures
+-- (defined here), and language-dependent parts. The user of
+-- the library should only have to look at the type signatures.
+
+resource Predication = open Deutsch in {
+
+-- We first define a set of predication patterns.
+
+oper
+  predV1 : V -> NP -> S ;             -- one-place verb: "John walks"
+  predV2 : TV -> NP -> NP -> S ;      -- two-place verb: "John loves Mary"
+  predVColl : V -> NP -> NP -> S ;    -- collective verb: "John and Mary fight"
+  predA1 : Adj1 -> NP -> S ;          -- one-place adjective: "John is old"
+  predA2 : Adj2 -> NP -> NP -> S ;    -- two-place adj: "John is married to Mary"
+  predAComp : AdjDeg -> NP -> NP -> S ; -- compar adj: "John is older than Mary"
+  predAColl : Adj1 -> NP -> NP -> S ; -- collective adj: "John and Mary are married"
+  predN1 : N -> NP -> S ;             -- one-place noun: "John is a man"
+  predN2 : Fun -> NP -> NP -> S ;     -- two-place noun: "John is a lover of Mary"
+  predNColl : N -> NP -> NP -> S ;    -- collective noun: "John and Mary are lovers"
+
+-- Individual-valued function applications.
+
+  appFun1 : Fun -> NP -> NP ;          -- one-place function: "the successor of x"
+  appFun2 : Fun -> NP -> NP -> NP ;    -- two-place function: "the line from x to y"
+  appFunColl : Fun -> NP -> NP -> NP ; -- collective function: "the sum of x and y"
+
+-- Families of types, expressed by common nouns depending on arguments.
+
+  appFam1 : Fun -> NP -> CN ;          -- one-place family: "divisor of x"
+  appFam2 : Fun -> NP -> NP -> CN ;    -- two-place family: "line from x to y"
+  appFamColl : Fun -> NP -> NP -> CN ; -- collective family: "path between x and y"
+
+-- Type constructor, similar to a family except that the argument is a type.
+
+  constrTyp1 : Fun -> CN -> CN ;
+
+-- Logical connectives on two sentences.
+
+  conjS : S -> S -> S ;
+  disjS : S -> S -> S ;
+  implS : S -> S -> S ;
+
+-- As an auxiliary, we need two-place conjunction of names ("John and Mary"), 
+-- used in collective predication.
+
+  conjNP : NP -> NP -> NP ;
+
+
+-----------------------------
+
+---- what follows should be an implementation of the preceding
+
+oper
+  predV1 = \F, x -> PredVP x (PosV F) ;
+  predV2 = \F, x, y -> PredVP x (PosTV F y) ;
+  predVColl = \F, x, y -> PredVP (conjNP x y) (PosV F) ;
+  predA1 = \F, x -> PredVP x (PosA F) ;
+  predA2 = \F, x, y -> PredVP x (PosA (ComplAdj F y)) ;
+  predAComp = \F, x, y -> PredVP x (PosA (ComparAdjP F y)) ;
+  predAColl = \F, x, y -> PredVP (conjNP x y) (PosA F) ;
+  predN1 = \F, x -> PredVP x (PosCN (UseN F)) ;
+  predN2 = \F, x, y -> PredVP x (PosCN (AppFun F y)) ;
+  predNColl = \F, x, y -> PredVP (conjNP x y) (PosCN (UseN F)) ;
+
+  appFun1 = \f, x -> DefOneNP (AppFun f x) ;
+  appFun2 = \f, x, y -> DefOneNP (AppFun (AppFun2 f x) y) ;
+  appFunColl = \f, x, y -> DefOneNP (AppFun f (conjNP x y)) ;
+
+  appFam1 = \F, x -> AppFun F x ;
+  appFam2 = \F, x, y -> AppFun (AppFun2 F x) y ;
+  appFamColl = \F, x, y -> AppFun F (conjNP x y) ;
+
+  conjS = \A, B -> ConjS AndConj (TwoS A B) ;
+  disjS = \A, B -> ConjS OrConj (TwoS A B) ;
+  implS = \A, B -> SubjS IfSubj A B ;
+
+  constrTyp1 = \F, A -> AppFun F (IndefManyNP A) ;
+
+  conjNP = \x, y -> ConjNP AndConj (TwoNP x y) ;
+
+} ;
diff --git a/grammars/resource/german/ResDeu.gf b/grammars/resource/german/ResDeu.gf
new file mode 100644
index 000000000..dd2b160b3
--- /dev/null
+++ b/grammars/resource/german/ResDeu.gf
@@ -0,0 +1,217 @@
+--1 The Top-Level German Resource Grammar
+--
+-- Aarne Ranta 2002 -- 2003
+--
+-- This is the German concrete syntax of the multilingual resource
+-- grammar. Most of the work is done in the file $syntax.Deu.gf$.
+-- However, for the purpose of documentation, we make here explicit the
+-- linearization types of each category, so that their structures and
+-- dependencies can be seen.
+-- Another substantial part are the linearization rules of some
+-- structural words.
+--
+-- The users of the resource grammar should not look at this file for the
+-- linearization rules, which are in fact hidden in the document version.
+-- They should use $resource.Abs.gf$ to access the syntactic rules.
+-- This file can be consulted in those, hopefully rare, occasions in which
+-- one has to know how the syntactic categories are
+-- implemented. The parameter types are defined in $Types.gf$.
+
+concrete ResDeu of ResAbs = open Prelude, Syntax in {
+
+flags 
+  startcat=Phr ; 
+  parser=chart ;
+
+lincat 
+  CN     = CommNounPhrase ; 
+      -- = {s : Adjf => Number => Case => Str ; g : Gender} ;
+  N      = CommNoun ;
+      -- = {s : Number => Case => Str ; g : Gender} ; 
+  NP     = NounPhrase ;
+      -- = {s : NPForm => Str ; n : Number ; p : Person ; pro : Bool} ;
+  PN     = ProperName ;
+      -- = {s : Case => Str} ;
+  Det    = {s : Gender => Case => Str ; n : Number ; a : Adjf} ;
+  Fun    = Function ;
+      -- = CommNounPhrase ** {s2 : Preposition ; c : Case} ;
+  Fun2   = Function ** {s3 : Preposition ; c2 : Case} ;
+
+  Adj1   = Adjective ;
+      -- = {s : AForm => Str} ;
+  Adj2   = Adjective ** {s2 : Preposition ; c : Case} ;
+  AdjDeg = {s : Degree => AForm => Str} ;
+  AP     = Adjective ** {p : Bool} ;
+
+  V      = Verb ; 
+      -- = {s : VForm => Str ; s2 : Particle} ;
+  VP     = Verb ** {s3 : Number => Str} ;
+  TV     = Verb ** {s3 : Preposition ; c : Case} ;
+  VS     = Verb ;
+  AdV    = {s : Str} ;
+
+  S      = Sentence ;
+      -- = {s : Order => Str} ; 
+  Slash  = Sentence ** {s2 : Preposition ; c : Case} ;
+
+  RP     = {s : GenNum => Case => Str} ;
+  RC     = {s : GenNum => Str} ;
+
+  IP     = ProperName ** {n : Number} ;
+  Qu     = {s : QuestForm => Str} ;
+  Imp    = {s : Number => Str} ;
+  Phr    = {s : Str} ;
+  Text   = {s : Str} ;
+
+  Conj   = {s : Str ; n : Number} ;
+  ConjD  = {s1,s2 : Str ; n : Number} ;
+
+  ListS  = {s1,s2 : Order => Str} ; 
+  ListAP = {s1,s2 : AForm => Str ; p : Bool} ;
+  ListNP = {s1,s2 : NPForm => Str ; n : Number ; p : Person ; pro : Bool} ;
+
+--.
+
+lin 
+  UseN = noun2CommNounPhrase ;
+  ModAdj = modCommNounPhrase ;
+  ModGenOne = npGenDet singular ;
+  ModGenMany = npGenDet plural ;
+  UsePN = nameNounPhrase ;
+  UseFun = funAsCommNounPhrase ;
+  AppFun = appFunComm ;
+  AppFun2 = appFun2 ;
+  AdjP1 = adj2adjPhrase ;
+  ComplAdj = complAdj ;
+  PositAdjP = positAdjPhrase ;
+  ComparAdjP = comparAdjPhrase ;
+  SuperlNP = superlNounPhrase ;
+
+  DetNP = detNounPhrase ;
+  IndefOneNP = indefNounPhrase singular ;
+  IndefManyNP = indefNounPhrase plural ;
+  DefOneNP = defNounPhrase singular ;
+  DefManyNP = defNounPhrase plural ;
+
+  CNthatS = nounThatSentence ;
+
+  PredVP = predVerbPhrase ;
+  PosV = predVerb True ;
+  NegV = predVerb False ;
+  PosA = predAdjective True ;
+  NegA = predAdjective False ;
+  PosCN = predCommNoun True ;
+  NegCN = predCommNoun False ;
+  PosTV = complTransVerb True ;
+  NegTV = complTransVerb False ;
+  PosPassV = passVerb True ;
+  NegPassV = passVerb False ;
+  PosNP = predNounPhrase True ;
+  NegNP = predNounPhrase False ;
+  PosVS = complSentVerb True ;
+  NegVS = complSentVerb False ;
+
+  AdvVP = adVerbPhrase ;
+  LocNP = locativeNounPhrase ;
+  AdvCN = advCommNounPhrase ;
+  AdvAP = advAdjPhrase ;
+
+  PosSlashTV = slashTransVerb True ;
+  NegSlashTV = slashTransVerb False ;
+  OneVP = predVerbPhrase (nameNounPhrase {s = \\_ => "man"}) ;
+
+  IdRP = identRelPron ;
+  FunRP = funRelPron ;
+  RelVP = relVerbPhrase ;
+  RelSlash = relSlash ;
+  ModRC = modRelClause ;
+  RelSuch = relSuch ;
+
+  WhoOne = intPronWho singular ;
+  WhoMany = intPronWho plural ;
+  WhatOne = intPronWhat singular ;
+  WhatMany = intPronWhat plural ;
+  FunIP = funIntPron ;
+  NounIPOne = nounIntPron singular ;
+  NounIPMany = nounIntPron plural ;
+
+  QuestVP = questVerbPhrase ;
+  IntVP = intVerbPhrase ;
+  IntSlash = intSlash ;
+  QuestAdv = questAdverbial ;
+
+  ImperVP = imperVerbPhrase ;
+
+  IndicPhrase = indicUtt ;
+  QuestPhrase = interrogUtt ;
+  ImperOne = imperUtterance singular ;
+  ImperMany = imperUtterance plural ;
+
+  AdvS = advSentence ;
+
+lin
+  TwoS = twoSentence ;
+  ConsS = consSentence ;
+  ConjS = conjunctSentence ;
+  ConjDS = conjunctDistrSentence ;
+
+  TwoAP = twoAdjPhrase ;
+  ConsAP = consAdjPhrase ;
+  ConjAP = conjunctAdjPhrase ;
+  ConjDAP = conjunctDistrAdjPhrase ;
+
+  TwoNP = twoNounPhrase ;
+  ConsNP = consNounPhrase ;
+  ConjNP = conjunctNounPhrase ;
+  ConjDNP = conjunctDistrNounPhrase ;
+
+  SubjS = subjunctSentence ;
+  SubjImper = subjunctImperative ;
+  SubjQu = subjunctQuestion ;
+
+  PhrNP = useNounPhrase ;
+  PhrOneCN = useCommonNounPhrase singular ;
+  PhrManyCN = useCommonNounPhrase plural ;
+  PhrIP ip = ip ;
+  PhrIAdv ia = ia ;
+
+  OnePhr p = p ;
+  ConsPhr = cc2 ;
+
+  INP    = pronNounPhrase pronIch ;
+  ThouNP = pronNounPhrase pronDu ;
+  HeNP   = pronNounPhrase pronEr ;
+  SheNP  = pronNounPhrase pronSie ; 
+  ItNP   = pronNounPhrase pronEs ; 
+  WeNP   = pronNounPhrase pronWir ;
+  YeNP   = pronNounPhrase pronIhr ;
+  TheyNP = pronNounPhrase pronSiePl ;
+
+  YouNP  = pronNounPhrase pronSSie ;
+
+  EveryDet = jederDet ; 
+  AllDet   = alleDet ; 
+  WhichDet = welcherDet ;
+  MostDet  = meistDet ;
+
+  HowIAdv   = ss "wie" ;
+  WhenIAdv  = ss "wann" ;
+  WhereIAdv = ss "war" ;
+  WhyIAdv   = ss "warum" ;
+
+  AndConj  = ss "und" ** {n = Pl} ;
+  OrConj   = ss "oder" ** {n = Sg} ;
+  BothAnd  = sd2 "sowohl" ["als auch"] ** {n = Pl} ;
+  EitherOr = sd2 "entweder" "oder" ** {n = Sg} ;
+  NeitherNor = sd2 "weder" "noch" ** {n = Sg} ;
+  IfSubj   = ss "wenn" ;
+  WhenSubj = ss "wenn" ;
+
+  PhrYes = ss ["Ja ."] ;
+  PhrNo = ss ["Nein ."] ;
+
+  VeryAdv = ss "sehr" ;
+  TooAdv = ss "zu" ;
+  OtherwiseAdv = ss "sonst" ;
+  ThereforeAdv = ss "deshalb" ;
+} ;
diff --git a/grammars/resource/german/RestaurantDeu.gf b/grammars/resource/german/RestaurantDeu.gf
new file mode 100644
index 000000000..3a6d6f8d6
--- /dev/null
+++ b/grammars/resource/german/RestaurantDeu.gf
@@ -0,0 +1,24 @@
+concrete RestaurantDeu of Restaurant = 
+  DatabaseDeu ** open Prelude,Paradigms,Deutsch,DatabaseRes in {
+
+lin 
+  Restaurant = UseN (nAuto "Restaurant") ;
+  Bar = UseN (nAuto "Bar") ; --- ??
+  French = apReg "Französisch" ;
+  Italian = apReg "Italienisch" ;
+  Indian = apReg "Indisch" ;
+  Japanese = apReg "Japanisch" ;
+
+  address = funVon (nFrau "Adresse") ;
+  phone = funVon (nFrau "Rufnummer") ; ----
+  priceLevel = funVon (nFrau "Preisstufe") ;
+
+  Cheap = aReg "billig" ;
+  Expensive = aDeg3 "teuer" "teurer" "teurest" ;
+
+  WhoRecommend rest = mkSentSame (ss2 ["wer empfiehlt"] (rest.s ! accusative)) ;
+  WhoHellRecommend rest = 
+    mkSentSame (ss2 ["wer zum Teufel empfiehlt"] (rest.s ! accusative)) ;
+
+  LucasCarton = mkPN ["Lucas Carton"] ["Lucas Cartons"] ;
+} ;
diff --git a/grammars/resource/german/Syntax.gf b/grammars/resource/german/Syntax.gf
new file mode 100644
index 000000000..904cd1903
--- /dev/null
+++ b/grammars/resource/german/Syntax.gf
@@ -0,0 +1,891 @@
+--1 A Small German Resource Syntax
+--
+-- Aarne Ranta 2002
+--
+-- This resource grammar contains definitions needed to construct 
+-- indicative, interrogative, and imperative sentences in German.
+--
+-- The following modules are presupposed:
+
+resource Syntax = Morpho ** open Prelude, (CO = Coordination) in {
+
+--2 Common Nouns
+--
+-- Simple common nouns are defined as the type $CommNoun$ in $morpho.Deu.gf$.
+
+--3 Common noun phrases
+
+-- The need for this more complex type comes from the variation in the way in
+-- which a modifying adjective is inflected after different determiners.
+-- We use the $Adjf$ parameter for this ($Strong$/$Weak$).
+
+oper
+
+  CommNounPhrase : Type = {s : Adjf => Number => Case => Str ; g : Gender} ;
+
+  noun2CommNounPhrase : CommNoun -> CommNounPhrase = \haus ->
+    {s = \\_ => haus.s ; g = haus.g} ;
+
+  n2n = noun2CommNounPhrase ;
+
+
+
+--2 Noun phrases
+--
+-- The worst case is pronouns, which have inflection in the possessive
+-- forms. Other noun phrases express all possessive forms with the genitive case.
+-- The parameter $pro$ tells if the $NP$ is a pronoun, which is needed in e.g.
+-- genitive constructions.
+
+  NounPhrase : Type = {
+    s : NPForm => Str ; 
+    n : Number ; 
+    p : Person ; 
+    pro : Bool
+    } ;
+
+  pronNounPhrase : ProPN -> NounPhrase = \ich -> 
+    ich ** {pro = True} ;
+
+  caseNP : NPForm -> Case = \np -> case np of {
+    NPCase c   => c ;
+    NPPoss _ _ => Gen
+    } ;
+
+  normalNounPhrase : (Case => Str) -> Number -> NounPhrase = \cs,n ->
+    {s = \\c => cs ! caseNP c ;
+     n = n ;
+     p = P3 ;    -- third person
+     pro = False -- not a pronoun
+    } ;
+
+-- Proper names are a simple kind of noun phrases. They can usually
+-- be constructed from strings in a regular way.
+
+  ProperName : Type = {s : Case => Str} ;
+
+  nameNounPhrase : ProperName -> NounPhrase = \john -> 
+    {s = \\np => john.s ! caseNP np ; n = Sg ; p = P3 ; pro = False} ;
+
+  mkProperName : Str -> ProperName = \horst ->
+    {s = table {Gen => horst + "s" ; _ => horst}} ;
+
+--2 Determiners
+--
+-- Determiners are inflected according to the nouns they determine.
+-- The determiner determines the number and adjectival form from the determiner.
+
+  Determiner : Type = {s : Gender => Case => Str ; n : Number ; a : Adjf} ;
+
+  detNounPhrase : Determiner -> CommNounPhrase -> NounPhrase = \ein, mann -> 
+    {s = \\c => let {nc = caseNP c} in 
+            ein.s ! mann.g ! nc ++ mann.s ! adjfCas ein.a nc ! ein.n ! nc ;
+     p = P3 ; 
+     n = ein.n ;
+     pro = False
+     } ;
+
+-- The adjectival form after a determiner depends both on the inferent form
+-- and on the case ("ein alter Mann" but "einem alten Mann").
+
+  adjfCas : Adjf -> Case -> Adjf = \a,c -> case <a,c> of {
+    <Strong,Nom> => Strong ;
+    <Strong,Acc> => Strong ;
+    _ => Weak
+    } ;
+
+-- The following macros are sufficient to define most determiners,
+-- as shown by the examples that follow.
+
+  DetSg = Gender => Case => Str ;
+  DetPl = Case => Str ;
+
+  mkDeterminerSg :  DetSg -> Adjf -> Determiner = \ein, a -> 
+    {s = ein ; n = Sg ; a = a} ;
+
+  mkDeterminerPl :  DetPl -> Adjf -> Determiner = \alle, a -> 
+    {s = \\_ => alle ; n = Pl ; a = a} ;
+
+  detLikeAdj : Str -> Determiner = \jed -> mkDeterminerSg
+    (\\g,c => (adjReg jed).s ! AMod Strong (GSg g) c) Weak ;
+
+  jederDet = detLikeAdj "jed" ;
+  alleDet = mkDeterminerPl (caselist "alle" "alle" "allen" "aller") Weak ;
+  einDet = mkDeterminerSg artIndef Strong ;
+  derDet = mkDeterminerSg (table {g => artDef ! GSg g}) Weak ;
+  dieDet = mkDeterminerPl (artDef ! GPl) Weak ;
+
+  meistDet = mkDeterminerPl (table {c => artDef ! GPl ! c ++ "meisten"}) Weak ;
+  welcherDet = detLikeAdj "welch" ;
+  welcheDet = mkDeterminerPl (caselist "welche" "welche" "welchen" "welcher") Weak ;
+
+-- Choose "welcher"/"welche"
+
+  welchDet : Number -> Determiner = \n -> 
+    case n of {Sg => welcherDet ; Pl => welcheDet} ;
+
+-- Genitives of noun phrases can be used like determiners, to build noun phrases.
+-- The number argument makes the difference between "mein Haus" - "meine Häuser".
+--
+-- If the 'owner' is a pronoun, only one form is available "mein Haus".
+-- In other cases, two variants are available: "Johanns Haus" / "das Haus Johanns".
+
+  npGenDet : Number -> NounPhrase -> CommNounPhrase -> NounPhrase = \n,haus,Wein -> 
+   let {
+     hauses  : Case   => Str = \\c => haus.s ! NPPoss (gNumber Wein.g n) c ;
+     wein    : NPForm => Str = \\c => Wein.s ! Strong ! n ! caseNP c ;
+     derwein : NPForm => Str = (defNounPhrase n Wein).s
+     }
+   in
+    {s = \\c => variants {
+                  hauses ! caseNP c ++ wein ! c ;
+                  if_then_else Str haus.pro
+                    nonExist 
+                    (derwein ! c ++ hauses ! Nom) -- the case does not matter
+                  } ;
+     p = P3 ;
+     n = n ;
+     pro = False
+     } ;
+
+-- *Bare plural noun phrases* like "Männer", "gute Häuser", are built without a 
+-- determiner word.
+
+  plurDet : CommNounPhrase -> NounPhrase = \cn -> 
+    normalNounPhrase (cn.s ! Strong ! Pl) Pl ;
+
+-- Macros for indef/def Sg/Pl noun phrases are needed in many places even
+-- if they might not be constituents.
+
+  indefNounPhrase : Number -> CommNounPhrase -> NounPhrase = \n,haus -> case n of {
+    Sg => detNounPhrase einDet haus ;
+    Pl => plurDet haus
+    } ;
+
+  defNounPhrase : Number -> CommNounPhrase -> NounPhrase = \n,haus -> case n of {
+    Sg => detNounPhrase derDet haus ;
+    Pl => detNounPhrase dieDet haus
+    } ;
+
+  indefNoun : Number -> CommNounPhrase -> Str = \n, mann -> case n of {
+    Sg => (detNounPhrase einDet mann).s ! NPCase Nom ; 
+    Pl => (plurDet mann).s ! NPCase Nom
+    } ;
+
+-- Constructions like "die Idee, dass zwei gerade ist" are formed at the
+-- first place as common nouns, so that one can also have "ein Vorschlag, dass...".
+
+  nounThatSentence : CommNounPhrase -> Sentence -> CommNounPhrase = \idee,x -> 
+    {s = \\a,n,c => idee.s ! a! n ! c ++ [", dass"] ++ x.s ! Sub ; 
+     g = idee.g
+    } ;
+
+--2 Adjectives
+--
+-- Adjectival phrases have a parameter $p$ telling if postposition is 
+-- allowed (complex APs). 
+
+  AdjPhrase : Type = Adjective ** {p : Bool} ;
+
+  adj2adjPhrase : Adjective -> AdjPhrase = \ny -> ny ** {p = False} ;
+
+--3 Comparison adjectives
+--
+-- The type is defined in $types.Deu.gf$.
+
+  AdjDegr : Type = AdjComp ;
+
+-- Each of the comparison forms has a characteristic use:
+--
+-- Positive forms are used alone, as adjectival phrases ("jung").
+
+  positAdjPhrase : AdjDegr -> AdjPhrase = \jung ->
+    {s = jung.s ! Pos ; p = False} ;
+
+-- Comparative forms are used with an object of comparison, as
+-- adjectival phrases ("besser als Rolf").
+
+  comparAdjPhrase : AdjDegr -> NounPhrase -> AdjPhrase = \besser,rolf ->
+    {s = \\a => besser.s ! Comp ! a ++ "als" ++ rolf.s ! NPCase Nom ;
+     p = True
+    } ;
+
+-- Superlative forms are used with a common noun, picking out the
+-- maximal representative of a domain ("der Jüngste Mann").
+
+  superlNounPhrase : AdjDegr -> CommNounPhrase -> NounPhrase = \best,mann ->
+    let {gen = mann.g} in
+    {s = \\c => let {nc = caseNP c} in
+                artDef ! gNumber gen Sg ! nc ++ 
+                best.s ! Sup ! aMod Weak gen Sg nc ++
+                mann.s ! Weak ! Sg ! nc ; 
+     p = P3 ; 
+     n = Sg ;
+     pro = False
+    } ;
+
+--3 Two-place adjectives
+--
+-- A two-place adjective is an adjective with a preposition used before
+-- the complement, and the complement case.
+
+  AdjCompl = Adjective ** {s2 : Preposition ; c : Case} ;
+
+  complAdj : AdjCompl -> NounPhrase -> AdjPhrase = \verwandt,dich ->
+    {s = \\a => 
+            bothWays (verwandt.s ! a) (verwandt.s2 ++ dich.s ! NPCase verwandt.c) ;
+     p = True
+    } ;
+
+--3 Modification of common nouns
+--
+-- The two main functions of adjective are in predication ("Johann ist jung")
+-- and in modification ("ein junger Mann"). Predication will be defined
+-- later, in the chapter on verbs.
+--
+-- Modification must pay attention to pre- and post-noun
+-- adjectives: "gutes Haus"; "besseres als X haus" / "haus besseres als X"
+
+  modCommNounPhrase : AdjPhrase -> CommNounPhrase -> CommNounPhrase = \gut,haus ->
+    {s = \\a,n,c => let {
+             gutes = gut.s ! aMod a haus.g n c ; 
+             Haus  = haus.s ! a ! n ! c
+             } in
+           if_then_else Str gut.p (bothWays gutes Haus) (gutes ++ Haus) ;
+     g = haus.g} ;
+
+--2 Function expressions
+
+-- A function expression is a common noun together with the
+-- preposition prefixed to its argument ("Mutter von x").
+-- The type is analogous to two-place adjectives and transitive verbs.
+
+  Function = CommNounPhrase ** {s2 : Preposition ; c : Case} ;
+
+-- The application of a function gives, in the first place, a common noun:
+-- "Mutter/Mütter von Johann". From this, other rules of the resource grammar 
+-- give noun phrases, such as "die Mutter von Johann", "die Mütter von Johann",
+-- "die Mütter von Johann und Maria", and "die Mutter von Johann und Maria" (the
+-- latter two corresponding to distributive and collective functions,
+-- respectively). Semantics will eventually tell when each
+-- of the readings is meaningful.
+
+  appFunComm : Function -> NounPhrase -> CommNounPhrase = \mutter,uwe -> 
+      {s = \\a,n,c => mutter.s ! a ! n ! c ++ mutter.s2 ++ uwe.s ! NPCase mutter.c ;
+       g = mutter.g
+      } ;
+
+-- It is possible to use a function word as a common noun; the semantics is
+-- often existential or indexical.
+
+  funAsCommNounPhrase : Function -> CommNounPhrase = \x -> x ; 
+
+-- The following is an aggregate corresponding to the original function application
+-- producing "Johanns Mutter" and "die Mutter von Johann". It does not appear in the
+-- resource grammar API any longer.
+
+  appFun : Bool -> Function -> NounPhrase -> NounPhrase = \coll, mutter, uwe ->
+    let {n = uwe.n ; g = mutter.g ; nf = if_then_else Number coll Sg n} in 
+    variants {
+      defNounPhrase nf (appFunComm mutter uwe) ;
+      npGenDet nf uwe mutter
+      } ;
+
+-- The commonest cases are functions with "von" and functions with Genitive.
+
+  mkFunC : CommNounPhrase -> Preposition -> Case -> Function = \f,p,c ->
+    f ** {s2 = p ; c = c} ;
+
+  funVonC : CommNounPhrase -> Function = \wert -> 
+    mkFunC wert "von" Dat ;
+
+  funGenC : CommNounPhrase -> Function = \wert -> 
+    mkFunC wert [] Gen ;
+
+-- Two-place functions add one argument place.
+
+  Function2 = Function ** {s3 : Preposition ; c2 : Case} ;
+
+-- There application starts by filling the first place.
+
+  appFun2 : Function2 -> NounPhrase -> Function = \flug, paris ->
+    {s  = \\a,n,c => flug.s ! a ! n ! c ++ flug.s2 ++ paris.s ! NPCase flug.c ;
+     g  = flug.g ;
+     s2 = flug.s3 ;
+     c  = flug.c2
+    } ;
+
+
+--2 Verbs
+--
+--3 Verb phrases
+--
+-- Verb phrases are discontinuous: the parts of a verb phrase are
+-- (s) an inflected verb, (s2) particle, and 
+-- (s3) negation and complement. This discontinuity is needed in sentence formation
+-- to account for word order variations.
+
+  VerbPhrase = Verb ** {s3 : Number => Str} ; 
+
+-- A simple verb can be made into a verb phrase with an empty complement.
+-- There are two versions, depending on if we want to negate the verb.
+-- N.B. negation is *not* a function applicable to a verb phrase, since
+-- double negations with "nicht" are not grammatical.
+
+  predVerb : Bool -> Verb -> VerbPhrase = \b,aussehen -> 
+    aussehen ** {
+     s3 = \\_ => negation b
+     } ;
+
+  negation : Bool -> Str = \b -> if_then_else Str b [] "nicht" ;
+
+-- Sometimes we want to extract the verb part of a verb phrase.
+
+  verbOfPhrase : VerbPhrase -> Verb = \v -> {s = v.s ; s2 = v.s2} ;
+
+-- Verb phrases can also be formed from adjectives ("ist gut"),
+-- common nouns ("ist ein Mann"), and noun phrases ("ist der jüngste Mann").
+-- The third rule is overgenerating: "ist jeder Mann" has to be ruled out
+-- on semantic grounds.
+
+  predAdjective : Bool -> Adjective -> VerbPhrase = \b,gut ->
+    verbSein ** {
+      s3 = \\_ => negation b ++ gut.s ! APred
+      } ;
+
+  predCommNoun : Bool -> CommNounPhrase -> VerbPhrase = \b,man ->
+    verbSein ** {
+      s3 = \\n => negation b ++ indefNoun n man
+     } ;
+
+  predNounPhrase : Bool -> NounPhrase -> VerbPhrase = \b,dermann ->
+    verbSein ** {
+      s3 = \\n => negation b ++ dermann.s ! NPCase Nom
+     } ;
+
+--3 Transitive verbs
+--
+-- Transitive verbs are verbs with a preposition for the complement,
+-- in analogy with two-place adjectives and functions.
+-- One might prefer to use the term "2-place verb", since
+-- "transitive" traditionally means that the inherent preposition is empty.
+-- Such a verb is one with a *direct object* - which may still be accusative,
+-- dative, or genitive.
+
+  TransVerb = Verb ** {s3 : Preposition ; c : Case} ; 
+
+  mkTransVerb : Verb -> Preposition -> Case -> TransVerb =
+    \v,p,c -> v ** {s3 = p ; c = c} ;
+
+-- The rule for using transitive verbs is the complementization rule:
+
+  complTransVerb : Bool -> TransVerb -> NounPhrase -> VerbPhrase = 
+    \b,warten,dich ->
+    let {
+      aufdich = warten.s3 ++ dich.s ! NPCase warten.c ;
+      nicht = negation b
+      } in
+    {s  = warten.s ; 
+     s2 = warten.s2 ; 
+     s3 = \\_ => bothWays aufdich nicht
+    } ;
+
+-- Transitive verbs with accusative objects can be used passively. 
+-- The function does not check that the verb is transitive.
+-- Therefore, the function can also be used for "es wird gelaufen", etc.
+
+  passVerb : Bool -> Verb -> VerbPhrase = \b,lieben ->
+    {s  = verbumWerden ; 
+     s2 = [] ; 
+     s3 = \\_ => negation b ++ lieben.s ! VPart APred
+    } ;
+
+
+--2 Adverbials
+--
+-- Adverbials are not inflected (we ignore comparison, and treat
+-- compared adverbials as separate expressions; this could be done another way).
+
+  Adverb : Type = SS ;
+
+  mkAdverb : Str -> Adverb = ss ;
+
+  adVerbPhrase : VerbPhrase -> Adverb -> VerbPhrase = \spielt, gut ->
+    {s  = spielt.s ; 
+     s2 = spielt.s2 ;
+     s3 = \\n => spielt.s3 ! n ++ gut.s 
+    } ;
+
+  advAdjPhrase : Adverb -> AdjPhrase -> AdjPhrase = \sehr, gut ->
+    {s = \\a => sehr.s ++ gut.s ! a ;
+     p = gut.p
+    } ;
+
+-- Adverbials are typically generated by prefixing prepositions.
+-- The rule for creating locative noun phrases by the preposition "in"
+-- is a little shaky, since other prepositions may be preferred ("an", "auf").
+
+  prepPhrase : Case -> Preposition -> NounPhrase -> Adverb = \c,auf,ihm ->
+    ss (auf ++ ihm.s ! NPCase c) ;
+ 
+  locativeNounPhrase : NounPhrase -> Adverb = 
+    prepPhrase Dat "in" ;
+
+-- This is a source of the "Mann mit einem Teleskop" ambiguity, and may produce
+-- strange things, like "Autos immer" (while "Autos heute" is OK).
+-- Semantics will have to make finer distinctions among adverbials.
+
+  advCommNounPhrase : CommNounPhrase -> Adverb -> CommNounPhrase = \haus,heute ->
+    {s = \\a, n, c => haus.s ! a ! n ! c ++ heute.s ;
+     g = haus.g} ;    
+
+
+
+--2 Sentences
+--
+-- Sentences depend on a *word order parameter* selecting between main clause,
+-- inverted, and subordinate clause.
+
+  Sentence : Type = SS1 Order ;
+
+-- This is the traditional $S -> NP VP$ rule. It takes care of both
+-- word order and agreement.
+
+  predVerbPhrase : NounPhrase -> VerbPhrase -> Sentence = 
+    \Ich,LiebeDichNichtAus -> 
+    let {
+      ich   = Ich.s ! NPCase Nom ; 
+      liebe = LiebeDichNichtAus.s ! VInd Ich.n Ich.p ;
+      aus   = LiebeDichNichtAus.s2 ;
+      dichnichtgut = LiebeDichNichtAus.s3 ! Ich.n
+    } in
+    {s = table {
+       Main => ich ++ liebe ++ dichnichtgut ++ aus ;
+       Inv  => liebe ++ ich ++ dichnichtgut ++ aus ;
+       Sub  => ich ++ dichnichtgut ++ aus ++ liebe
+       }
+    } ;
+
+--3 Sentence-complement verbs
+--
+-- Sentence-complement verbs take sentences as complements.
+
+  SentenceVerb : Type = Verb ;
+
+  complSentVerb : Bool -> SentenceVerb -> Sentence -> VerbPhrase = \b,sage,duisst ->
+    sage **
+    {s3 = \\_ => negation b ++ "," ++ "dass" ++ duisst.s ! Sub} ;
+
+
+--2 Sentences missing noun phrases
+--
+-- This is one instance of Gazdar's *slash categories*, corresponding to his
+-- $S/NP$.
+-- We cannot have - nor would we want to have - a productive slash-category former.
+-- Perhaps a handful more will be needed.
+--
+-- Notice that the slash category has the same relation to sentences as
+-- transitive verbs have to verbs: it's like a *sentence taking a complement*.
+
+  SentenceSlashNounPhrase : Type = Sentence ** {s2 : Preposition ; c : Case} ;
+
+  slashTransVerb : Bool -> NounPhrase -> TransVerb -> SentenceSlashNounPhrase = 
+    \b, Ich, sehen -> 
+    let {
+      ich   = Ich.s ! NPCase Nom ; 
+      sehe  = sehen.s ! VInd Ich.n P3 ;
+      aus   = sehen.s2 ;
+      nicht = negation b
+    } in
+    {s = table {
+       Main => ich ++ sehe ++ nicht ++ aus ;  
+       Inv  => sehe ++ ich ++ nicht ++ aus ;
+       Sub  => ich ++ nicht ++ aus ++ sehe
+       } ;
+     s2 = sehen.s3 ; 
+     c = sehen.c
+    } ;
+
+--2 Relative pronouns and relative clauses
+--
+-- Relative pronouns are inflected in
+-- gender, number, and case just like adjectives.
+
+oper
+  identRelPron : RelPron = relPron ;
+
+  funRelPron : Function -> RelPron -> RelPron = \wert, der -> 
+    {s = \\gn,c => let {nu = numGenNum gn} in
+           artDef ! gNumber wert.g nu ! c ++ wert.s ! Weak ! nu ! c ++  
+           wert.s2 ++ der.s ! gn ! wert.c
+    } ;
+
+-- Relative clauses can be formed from both verb phrases ("der schläft") and
+-- slash expressions ("den ich sehe", "auf dem ich sitze"). 
+
+  RelClause : Type = {s : GenNum => Str} ;
+
+  relVerbPhrase : RelPron -> VerbPhrase -> RelClause = \der, geht ->
+    {s = \\gn => (predVerbPhrase (normalNounPhrase (der.s ! gn) (numGenNum gn))
+                                 geht
+                 ).s ! Sub
+    } ;
+
+  relSlash : RelPron -> SentenceSlashNounPhrase -> RelClause = \den, ichSehe ->
+    {s = \\gn => ichSehe.s2 ++ den.s ! gn ! ichSehe.c ++ ichSehe.s ! Sub
+    } ;
+
+-- A 'degenerate' relative clause is the one often used in mathematics, e.g.
+-- "Zahl x derart, dass x gerade ist".
+
+  relSuch : Sentence -> RelClause = \A ->
+    {s = \\_ => "derart" ++ "dass" ++ A.s ! Sub} ;
+
+-- The main use of relative clauses is to modify common nouns.
+-- The result is a common noun, out of which noun phrases can be formed
+-- by determiners. A comma is used before the relative clause.
+
+  modRelClause : CommNounPhrase -> RelClause -> CommNounPhrase = \mann,dergeht ->
+    {s = \\a,n,c => mann.s ! a ! n ! c ++ "," ++ dergeht.s ! gNumber mann.g n ;
+     g = mann.g
+    } ;
+
+
+--2 Interrogative pronouns
+--
+-- If relative pronouns are adjective-like, interrogative pronouns are
+-- noun-phrase-like. We use a simplified type, since we don't need the possessive
+-- forms.
+
+  IntPron : Type = ProperName ** {n : Number} ; 
+
+-- In analogy with relative pronouns, we have a rule for applying a function
+-- to a relative pronoun to create a new one. 
+
+  funIntPron : Function -> IntPron -> IntPron = \wert, wer ->
+    let {n = wer.n} in 
+    {s = \\c => 
+           artDef ! gNumber wert.g n ! c ++ wert.s ! Weak ! n ! c ++  
+           wert.s2 ++ wer.s ! wert.c ;
+     n = n
+    } ;
+
+-- There is a variety of simple interrogative pronouns:
+-- "welches Haus", "wer", "was".
+
+  nounIntPron : Number -> CommNounPhrase -> IntPron = \n,cn ->
+    let {np = detNounPhrase (welchDet n) cn} in
+      {s = \\c => np.s ! NPCase c ;
+       n = np.n} ;
+
+  intPronWho : Number -> IntPron = \num -> {
+    s = caselist "wer" "wen" "wem" "weren" ;
+    n = num
+  } ;
+
+  intPronWhat : Number -> IntPron = \num -> {
+    s = caselist "was" "was" nonExist nonExist ; ---
+    n = num
+  } ;
+
+
+
+--2 Utterances
+
+-- By utterances we mean whole phrases, such as 
+-- 'can be used as moves in a language game': indicatives, questions, imperative,
+-- and one-word utterances. The rules are far from complete.
+--
+-- N.B. we have not included rules for texts, which we find we cannot say much
+-- about on this level. In semantically rich GF grammars, texts, dialogues, etc, 
+-- will of course play an important role as categories not reducible to utterances.
+-- An example is proof texts, whose semantics show a dependence between premises
+-- and conclusions. Another example is intersentential anaphora.
+
+  Utterance = SS ;
+  
+  indicUtt : Sentence -> Utterance = \x -> ss (x.s ! Main ++ ".") ;
+  interrogUtt : Question -> Utterance = \x -> ss (x.s ! DirQ ++ "?") ;
+
+
+--2 Questions
+--
+-- Questions are either direct ("bist du müde") or indirect 
+-- ("ob du müde bist").
+
+param 
+  QuestForm = DirQ | IndirQ ;
+
+oper
+  Question = SS1 QuestForm ;
+
+--3 Yes-no questions 
+--
+-- Yes-no questions are used both independently ("bist du müde")
+-- and after interrogative adverbials ("warum bist du müde").
+-- It is economical to handle with these two cases by the one
+-- rule, $questVerbPhrase'$. The only difference is if "ob" appears
+-- in the indirect form.
+
+  questVerbPhrase : NounPhrase -> VerbPhrase -> Question = 
+    questVerbPhrase' False ;
+
+  questVerbPhrase' : Bool -> NounPhrase -> VerbPhrase -> Question = 
+    \adv, du,gehst ->
+    let {dugehst = (predVerbPhrase du gehst).s} in
+    {s = table {
+      DirQ   => dugehst ! Inv ;
+      IndirQ => (if_then_else Str adv [] "ob") ++ dugehst ! Sub
+      }
+    } ;
+
+
+--3 Wh-questions
+--
+-- Wh-questions are of two kinds: ones that are like $NP - VP$ sentences,
+-- others that are line $S/NP - NP$ sentences.
+
+  intVerbPhrase : IntPron -> VerbPhrase -> Question = \Wer,geht ->
+    let {wer : NounPhrase = normalNounPhrase Wer.s Wer.n ;
+         wergeht : Sentence = predVerbPhrase wer geht
+        } in
+    {s = table {
+      DirQ   => wergeht.s ! Main ;
+      IndirQ => wergeht.s ! Sub 
+      }
+    } ;
+
+  intSlash : IntPron -> SentenceSlashNounPhrase -> Question = \wer, ichSehe ->
+    let {zuwen = ichSehe.s2 ++ wer.s ! ichSehe.c} in
+    {s = table {
+      DirQ   => zuwen ++ ichSehe.s ! Inv ;
+      IndirQ => zuwen ++ ichSehe.s ! Sub
+      } 
+    } ;
+
+
+--3 Interrogative adverbials
+--
+-- These adverbials will be defined in the lexicon: they include
+-- "wann", "war", "wie", "warum", etc, which are all invariant one-word
+-- expressions. In addition, they can be formed by adding prepositions
+-- to interrogative pronouns, in the same way as adverbials are formed
+-- from noun phrases. 
+
+  IntAdverb = SS ;
+
+  prepIntAdverb : Case -> Preposition -> IntPron -> IntAdverb =\ c,auf,wem ->
+    ss (auf ++ wem.s ! c) ;
+
+-- A question adverbial can be applied to anything, and whether this makes
+-- sense is a semantic question.
+
+  questAdverbial : IntAdverb -> NounPhrase -> VerbPhrase -> Question = 
+    \wie, du, tust ->
+    {s = \\q => wie.s ++ (questVerbPhrase du tust).s ! q} ;
+
+
+--2 Imperatives
+--
+-- We only consider second-person imperatives. No polite "Sie" form so far.
+
+  Imperative = SS1 Number ;
+
+  imperVerbPhrase : VerbPhrase -> Imperative = \komm -> 
+    {s = \\n => komm.s ! VImp n ++ komm.s3 ! n ++ komm.s2} ;  
+
+  imperUtterance : Number -> Imperative -> Utterance = \n,I ->
+    ss (I.s ! n ++ "!") ;
+
+--2 Sentence adverbials
+--
+-- This class covers adverbials such as "sonst", "folgelich", which are prefixed
+-- to a sentence to form a phrase; the sentence gets inverted word order.
+
+  advSentence : Adverb -> Sentence -> Utterance = \sonst,ist1gerade ->
+    ss (sonst.s ++ ist1gerade.s ! Inv ++ ".") ;
+
+--2 Coordination
+--
+-- Coordination is to some extent orthogonal to the rest of syntax, and
+-- has been treated in a generic way in the module $CO$ in the file
+-- $coordination.gf$. The overall structure is independent of category,
+-- but there can be differences in parameter dependencies.
+--
+--3 Conjunctions
+--
+-- Coordinated phrases are built by using conjunctions, which are either
+-- simple ("und", "oder") or distributed ("sowohl - als auch", "entweder - oder").
+--
+-- The conjunction has an inherent number, which is used when conjoining
+-- noun phrases: "John und Mary sind..." vs. "John oder Mary ist..."; in the
+-- case of "oder", the result is however plural if any of the disjuncts is.
+
+  Conjunction = CO.Conjunction ** {n : Number} ;
+  ConjunctionDistr = CO.ConjunctionDistr ** {n : Number} ;
+
+
+--3 Coordinating sentences
+--
+-- We need a category of lists of sentences. It is a discontinuous
+-- category, the parts corresponding to 'init' and 'last' segments
+-- (rather than 'head' and 'tail', because we have to keep track of the slot between
+-- the last two elements of the list). A list has at least two elements.
+
+  ListSentence : Type = {s1,s2 : Order => Str} ; 
+
+  twoSentence : (_,_ : Sentence) -> ListSentence = 
+    CO.twoTable Order ;
+
+  consSentence : ListSentence -> Sentence -> ListSentence = 
+    CO.consTable Order CO.comma ;
+
+-- To coordinate a list of sentences by a simple conjunction, we place
+-- it between the last two elements; commas are put in the other slots,
+-- e.g. "du rauchst, er trinkt und ich esse".
+
+  conjunctSentence : Conjunction -> ListSentence -> Sentence = 
+    CO.conjunctTable Order ;
+
+-- To coordinate a list of sentences by a distributed conjunction, we place
+-- the first part (e.g. "entweder") in front of the first element, the second
+-- part ("oder") between the last two elements, and commas in the other slots.
+-- For sentences this is really not used.
+
+  conjunctDistrSentence : ConjunctionDistr -> ListSentence -> Sentence = 
+    CO.conjunctDistrTable Order ;
+
+--3 Coordinating adjective phrases
+--
+-- The structure is the same as for sentences. The result is a prefix adjective
+-- if and only if all elements are prefix.
+
+  ListAdjPhrase : Type = 
+    {s1,s2 : AForm => Str ; p : Bool} ;
+
+  twoAdjPhrase : (_,_ : AdjPhrase) -> ListAdjPhrase = \x,y ->
+    CO.twoTable AForm x y ** {p = andB x.p y.p} ;
+  consAdjPhrase : ListAdjPhrase -> AdjPhrase -> ListAdjPhrase =  \xs,x ->
+    CO.consTable AForm CO.comma xs x ** {p = andB xs.p x.p} ;
+
+  conjunctAdjPhrase : Conjunction -> ListAdjPhrase -> AdjPhrase = \c,xs ->
+    CO.conjunctTable AForm c xs ** {p = xs.p} ;
+
+  conjunctDistrAdjPhrase : ConjunctionDistr -> ListAdjPhrase -> AdjPhrase = \c,xs ->
+    CO.conjunctDistrTable AForm c xs ** {p = xs.p} ;
+
+
+
+--3 Coordinating noun phrases
+--
+-- The structure is the same as for sentences. The result is either always plural
+-- or plural if any of the components is, depending on the conjunction.
+-- The result is a pronoun if all components are.
+
+  ListNounPhrase : Type = 
+    {s1,s2 : NPForm => Str ; n : Number ; p : Person ; pro : Bool} ;
+
+  twoNounPhrase : (_,_ : NounPhrase) -> ListNounPhrase = \x,y ->
+    CO.twoTable NPForm x y ** 
+    {n = conjNumber x.n y.n ; p = conjPerson x.p y.p ; pro = andB x.pro y.pro} ;
+
+  consNounPhrase : ListNounPhrase -> NounPhrase -> ListNounPhrase =  \xs,x ->
+    CO.consTable NPForm CO.comma xs x ** 
+    {n = conjNumber xs.n x.n ; p = conjPerson xs.p x.p ; pro = andB xs.pro x.pro} ;
+
+  conjunctNounPhrase : Conjunction -> ListNounPhrase -> NounPhrase = \c,xs ->
+    CO.conjunctTable NPForm c xs ** 
+    {n = conjNumber c.n xs.n ; p = xs.p ; pro = xs.pro} ;
+
+  conjunctDistrNounPhrase : ConjunctionDistr -> ListNounPhrase -> NounPhrase = 
+    \c,xs ->
+    CO.conjunctDistrTable NPForm c xs ** 
+    {n = conjNumber c.n xs.n ; p = xs.p ; pro = xs.pro} ;
+
+-- We have to define a calculus of numbers of persons. For numbers,
+-- it is like the conjunction with $Pl$ corresponding to $False$.
+
+  conjNumber : Number -> Number -> Number = \m,n -> case <m,n> of {
+    <Sg,Sg> => Sg ;
+    _ => Pl 
+    } ;
+
+-- For persons, we go in the descending order:
+-- "ich und dich sind stark", "er oder du bist stark".
+-- This is not always quite clear.
+
+  conjPerson : Person -> Person -> Person = \p,q -> case <p,q> of {
+    <P3,P3> => P3 ;
+    <P1,_>  => P1 ;
+    <_,P1>  => P1 ;
+    _       => P2
+    } ;
+
+
+--2 Subjunction
+--
+-- Subjunctions ("wenn", "falls", etc) 
+-- are a different way to combine sentences than conjunctions.
+-- The main clause can be a sentences, an imperatives, or a question,
+-- but the subjoined clause must be a sentence.
+
+  Subjunction = SS ;
+
+  subjunctSentence : Subjunction -> Sentence -> Sentence -> Sentence = \if, A, B ->
+    let {As = A.s ! Sub} in 
+    {s = table {
+           Main => variants {if.s ++ As ++ "," ++ B.s ! Inv ; 
+                             B.s ! Main ++ "," ++ if.s ++ As} ;
+           o    => B.s ! o ++ "," ++ if.s ++ As
+           } 
+     } ;
+
+  subjunctImperative : Subjunction -> Sentence -> Imperative -> Imperative = 
+    \if, A, B -> 
+    {s = \\n => subjunctVariants if A (B.s ! n)} ;
+
+  subjunctQuestion : Subjunction -> Sentence -> Question -> Question = \if, A, B ->
+    {s = \\q => subjunctVariants if A (B.s ! q)} ;
+
+-- There are uniformly two variant word orders, e.g. 
+-- "wenn du rauchst, werde ish böse"
+-- and "ich werde böse, wenn du rauchst".
+
+  subjunctVariants : Subjunction -> Sentence -> Str -> Str = \if,A,B ->
+    let {As = A.s ! Sub} in 
+    variants {if.s ++ As ++ "," ++ B ; B ++ "," ++ if.s ++ As} ;
+
+
+--2 One-word utterances
+-- 
+-- An utterance can consist of one phrase of almost any category, 
+-- the limiting case being one-word utterances. These
+-- utterances are often (but not always) in what can be called the
+-- default form of a category, e.g. the nominative.
+-- This list is far from exhaustive.
+
+  useNounPhrase : NounPhrase -> Utterance = \john ->
+    postfixSS "." (defaultNounPhrase john) ;
+  useCommonNounPhrase : Number -> CommNounPhrase -> Utterance = \n,car -> 
+    useNounPhrase (indefNounPhrase n car) ;
+
+-- Here are some default forms.
+
+  defaultNounPhrase : NounPhrase -> SS = \john -> 
+    ss (john.s ! NPCase Nom) ;
+
+  defaultQuestion : Question -> SS = \whoareyou ->
+    ss (whoareyou.s ! DirQ) ;
+
+  defaultSentence : Sentence -> Utterance = \x -> ss (x.s ! Main) ;
+
+--3 Puzzle
+--
+-- Adding some lexicon, we can generate the sentence
+--
+-- "der grösste alte Mann ist nicht ein Auto auf die Mutter von dem Männer warten"
+--
+-- which looks completely ungrammatical! What you should do to decipher it is
+-- put parentheses around "auf die Mutter von dem".
+
+} ;
diff --git a/grammars/resource/german/TestDeu.gf b/grammars/resource/german/TestDeu.gf
new file mode 100644
index 000000000..e09b60d1f
--- /dev/null
+++ b/grammars/resource/german/TestDeu.gf
@@ -0,0 +1,39 @@
+concrete TestDeu of TestAbs = ResDeu ** open Syntax in {
+
+flags startcat=Phr ; lexer=text ; parser=chart ; unlexer=text ;
+
+-- a random sample from the lexicon
+
+lin
+  Big = adjCompReg3 "gross" "grösser" "grösst";
+  Small = adjCompReg "klein" ;
+  Old = adjCompReg3 "alt" "älter" "ältest";
+  Young = adjCompReg3 "jung" "jünger" "jüngst";
+  Man = declN2u "Mann" "Männer" ;
+  Woman = declN1 "Frau" ;
+  Car = declNs "Auto" ;
+  House = declN3uS "Haus" "Häuser" ;
+  Light = declN3 "Licht" ;
+  Walk = mkVerbSimple (verbLaufen "gehen" "geht" "gegangen") ;
+  Run = mkVerbSimple (verbLaufen "laufen" "läuft" "gelaufen") ; 
+  Say = mkVerbSimple (regVerb "sagen") ;
+  Prove = mkVerbSimple (regVerb "beweisen") ;
+  Send = mkTransVerb (mkVerbSimple (verbLaufen "senden" "sendet" "gesandt")) [] Acc;
+  Love = mkTransVerb (mkVerbSimple (regVerb "lieben")) [] Acc ;
+  Wait =  mkTransVerb (mkVerbSimple (verbWarten "warten")) "auf" Acc ;
+  Mother = mkFunC (n2n (declN2uF "Mutter" "Mütter")) "von" Dat ;
+  Uncle = mkFunC (n2n (declN2i "Onkel")) "von" Dat ;
+  Connection = mkFunC (n2n (declN1 "Verbindung")) "von" Dat ** 
+                                     {s3 = "nach" ; c2 = Dat} ;
+
+  Always = mkAdverb "immer" ;
+  Well = mkAdverb "gut" ;
+
+  SwitchOn  = mkTransVerb (mkVerb (verbWarten "schalten") "auf") [] Acc  ;
+  SwitchOff = mkTransVerb (mkVerb (verbWarten "schalten") "aus") [] Acc  ;
+
+  John = mkProperName "Johann" ;
+  Mary = mkProperName "Maria" ;
+
+} ;
+
diff --git a/grammars/resource/german/Types.gf b/grammars/resource/german/Types.gf
new file mode 100644
index 000000000..d597223cd
--- /dev/null
+++ b/grammars/resource/german/Types.gf
@@ -0,0 +1,98 @@
+--1 German Word Classes and Morphological Parameters
+--
+-- This is a resource module for German morphology, defining the
+-- morphological parameters and word classes of German. It is so far only
+-- complete w.r.t. the syntax part of the resource grammar.
+-- It does not include those parameters that are not needed for
+-- analysing individual words: such parameters are defined in syntax modules.
+--
+
+resource Types = open Prelude in {
+
+--2 Enumerated parameter types 
+--
+-- These types are the ones found in school grammars.
+-- Their parameter values are atomic.
+
+param 
+  Number = Sg | Pl ;
+  Gender = Masc | Fem | Neut ;
+  Person = P1 | P2 | P3 ;
+  Case   = Nom | Acc | Dat | Gen ;
+  Adjf   = Strong | Weak ;          -- the main division in adjective declension
+  Order  = Main | Inv | Sub ;       -- word order: direct, indirect, subordinate
+
+-- For abstraction and API compatibility, we define two synonyms:
+
+oper 
+  singular = Sg ; 
+  plural = Pl ;
+
+--2 Word classes and hierarchical parameter types
+--
+-- Real parameter types (i.e. ones on which words and phrases depend) 
+-- are mostly hierarchical. The alternative is cross-products of
+-- simple parameters, but this cannot be always used since it overgenerates.
+--
+
+--3 Common nouns
+--
+-- Common nouns are inflected in number and case and they have an inherent gender.
+
+  CommNoun : Type = {s : Number => Case => Str ; g : Gender} ;
+
+--3 Pronouns
+--
+-- Pronouns are an example - the worst-case one of noun phrases,
+-- which are properly defined in $syntax.Deu.gf$.
+-- Their inflection tables has, in addition to the normal genitive,
+-- the possessive forms, which are inflected like determiners.
+
+param
+  NPForm = NPCase Case | NPPoss GenNum Case ;
+
+--3 Adjectives
+--
+-- Adjectives are a very complex class, and the full table has as many as
+-- 99 different forms. The major division is between the comparison degrees.
+-- There is no gender distinction in the plural, 
+-- and the predicative forms ("X ist Adj") are not inflected.
+
+param
+  GenNum = GSg Gender | GPl ;
+  AForm  = APred | AMod Adjf GenNum Case ;  
+
+oper
+  Adjective : Type = {s : AForm => Str} ;
+  AdjComp : Type = {s : Degree => AForm => Str} ;
+
+-- Comparison of adjectives:
+
+param Degree = Pos | Comp | Sup ;
+
+--3 Verbs 
+--
+-- We have a reduced conjugation with only the present tense infinitive, 
+-- indicative, and imperative forms, and past participles.
+
+param VForm = VInf | VInd Number Person | VImp Number | VPart AForm ;
+
+oper Verbum : Type = VForm => Str ;
+
+-- On the general level, we have to account for composite verbs as well, 
+-- such as "aus" + "sehen" etc.
+
+  Particle = Str ;
+
+  Verb = {s : Verbum ; s2 : Particle} ;
+
+
+--2 Prepositions
+--
+-- We define prepositions simply as strings. Thus we do not capture the
+-- contractions "vom", "ins", etc. To define them in GF grammar we would need
+-- to introduce a parameter system, which we postpone.
+
+  Preposition = Str ;
+
+} ;