Remove the grammars directory. It was full of old grammars that don't compile these days. See the old source distributions if you want them.

11 files changed, 0 insertions, 1879 deletions

diff --git a/grammars/resource/english/DatabaseEng.gf b/grammars/resource/english/DatabaseEng.gf
deleted file mode 100644
index 927434d9a..000000000
--- a/grammars/resource/english/DatabaseEng.gf
+++ /dev/null
@@ -1,51 +0,0 @@
-concrete DatabaseEng of Database = open Prelude,Syntax,English,Predication,Paradigms,DatabaseEngRes 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       = PN ;
-
-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 = UsePN ;
-
-  AllN = DetNP AllDet ;
-  MostN = DetNP MostDet ;
-  EveryN = DetNP EveryDet ;
-
--- only these are language-dependent
-
-  Any n = detNounPhrase anyPlDet n ** {lock_NP = <>} ; ---
-
-  IsThere A  = mkSentPrel ["is there"]  (defaultNounPhrase (IndefOneNP A)) ;
-  AreThere A = mkSentPrel ["are there"] (defaultNounPhrase (IndefManyNP A)) ;
-
-  WhatIs V   = mkSentPrel ["what is"] (defaultNounPhrase V) ;
-
-} ;
diff --git a/grammars/resource/english/DatabaseEngRes.gf b/grammars/resource/english/DatabaseEngRes.gf
deleted file mode 100644
index e00501a47..000000000
--- a/grammars/resource/english/DatabaseEngRes.gf
+++ /dev/null
@@ -1,11 +0,0 @@
-resource DatabaseEngRes = 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/english/English.gf b/grammars/resource/english/English.gf
deleted file mode 100644
index 6a3d4b9f6..000000000
--- a/grammars/resource/english/English.gf
+++ /dev/null
@@ -1,3 +0,0 @@
---# -path=.:../abstract:../../prelude
-
-resource English = reuse ResEng ;
diff --git a/grammars/resource/english/Morpho.gf b/grammars/resource/english/Morpho.gf
deleted file mode 100644
index bd6ac1ca1..000000000
--- a/grammars/resource/english/Morpho.gf
+++ /dev/null
@@ -1,167 +0,0 @@
---1 A Simple English 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.gf$.
-
-resource Morpho = Types ** open Prelude in {
-
---2 Nouns
---
--- For conciseness and abstraction, we define a worst-case macro for
--- noun inflection. It is used for defining special case that
--- only need one string as argument.
-
-oper
-  mkNoun  : (_,_,_,_ : Str) -> CommonNoun = 
-    \man,men, mans, mens -> {s = table {
-       Sg => table {Nom => man ; Gen => mans} ;
-       Pl => table {Nom => men ; Gen => mens}
-      }} ;
-
-  nounReg : Str -> CommonNoun = \dog -> 
-    mkNoun dog (dog + "s") (dog + "'s") (dog + "s'");
-
-  nounS   : Str -> CommonNoun = \kiss -> 
-    mkNoun kiss (kiss + "es") (kiss + "'s") (kiss + "es'") ;
-
-  nounY   : Str -> CommonNoun = \fl -> 
-    mkNoun (fl + "y") (fl + "ies") (fl + "y's") (fl + "ies'") ;
-
---3 Proper names
---
--- Regular proper names are inflected with "'s" in the genitive.
-
-  nameReg : Str -> ProperName = \john -> 
-    {s = table {Nom => john ; Gen => john + "'s"}} ;
-
-
---2 Pronouns
---
--- Here we define personal and relative pronouns.
-
-  mkPronoun : (_,_,_,_ : Str) -> Number -> Person -> Pronoun = \I,me,my,mine,n,p -> 
-    {s = table {NomP => I ; AccP => me ; GenP => my ; GenSP => mine} ; 
-     n = n ; p = p} ;
-
-  pronI = mkPronoun "I" "me" "my" "mine" Sg P1 ;
-  pronYouSg = mkPronoun "you" "you" "your" "yours" Sg P2 ; -- verb form still OK
-  pronHe = mkPronoun "he" "him" "his" "his" Sg P3 ;
-  pronShe = mkPronoun "she" "her" "her" "hers" Sg P3 ;
-  pronIt = mkPronoun "it" "it" "its" "it" Sg P3 ;
-
-  pronWe = mkPronoun "we" "us" "our" "ours" Pl P1 ;
-  pronYouPl = mkPronoun "you" "you" "your" "yours" Pl P2 ;
-  pronThey = mkPronoun "they" "them" "their" "theirs" Pl P3 ;
-
--- Relative pronouns in the accusative have the 'no pronoun' variant.
--- The simple pronouns do not really depend on number.
-
-  relPron : RelPron = {s = table {
-    NoHum => \\_ => table {
-      NomP => variants {"that" ; "which"} ;
-      AccP => variants {"that" ; "which" ; []} ;
-      GenP => variants {"whose"} ;
-      GenSP => variants {"which"}
-      } ;
-    Hum => \\_ => table {
-      NomP => variants {"that" ; "who"} ;
-      AccP => variants {"that" ; "who" ; "whom" ; []} ;
-      GenP => variants {"whose"} ;
-      GenSP => variants {"whom"}
-      }
-    }
-  } ;
-
-
---3 Determiners
---
--- We have just a heuristic definition of the indefinite article.
--- There are lots of exceptions: consonantic "e" ("euphemism"), consonantic
--- "o" ("one-sided"), vocalic "u" ("umbrella").
-
-  artIndef = pre {"a" ; 
-                  "an" / strs {"a" ; "e" ; "i" ; "o" ; "A" ; "E" ; "I" ; "O" }} ;
-
-  artDef = "the" ;
-
---2 Adjectives
---
--- For the comparison of adjectives, three forms are needed in the worst case.
-
-  mkAdjDegr : (_,_,_ : Str) -> AdjDegr = \good,better,best -> 
-    {s = table {Pos => good ; Comp => better ; Sup => best}} ;
-
-  adjDegrReg : Str -> AdjDegr = \long ->
-    mkAdjDegr long (long + "er") (long + "est") ;
-
-  adjDegrY : Str -> AdjDegr = \lovel ->
-    mkAdjDegr (lovel + "y") (lovel + "ier") (lovel + "iest") ;
-
--- Many adjectives are 'inflected' by adding a comparison word.
-
-  adjDegrLong : Str -> AdjDegr = \ridiculous ->
-    mkAdjDegr ridiculous ("more" ++ ridiculous) ("most" ++ ridiculous) ;
-
--- simple adjectives are just strings
-
-  simpleAdj : Str -> Adjective = ss ;
-
---3 Verbs
---
--- Except for "be", the worst case needs four forms.
-
-  mkVerbP3 : (_,_,_,_: Str) -> VerbP3 = \go,goes,went,gone -> 
-    {s = table {
-       InfImp => go ; 
-       Indic P3 => goes ; 
-       Indic _ => go ; 
-       Past _ => went ;
-       PPart => gone
-       }
-    } ;
-
-  mkVerb : (_,_,_ : Str) -> VerbP3 = \ring,rang,rung ->
-    mkVerbP3 ring (ring + "s") rang rung ;
-
-  regVerbP3 : Str -> VerbP3 = \walk -> 
-    mkVerb walk (walk + "ed") (walk + "ed") ;
-
-  verbP3s   : Str -> VerbP3 = \kiss -> 
-    mkVerbP3 kiss (kiss + "es") (kiss + "ed") (kiss + "ed") ;
-
-  verbP3e   : Str -> VerbP3 = \love -> 
-    mkVerbP3 love (love + "s") (love + "d") (love + "d") ;
-
-  verbP3y   : Str -> VerbP3 = \cr -> 
-    mkVerbP3 (cr + "y") (cr + "ies") (cr + "ied") (cr + "ied") ;
-
-  verbP3Have = mkVerbP3 "have" "has" "had" "had" ;
-
-  verbP3Do   = mkVerbP3 "do" "does" "did" "done" ;
-
-  verbBe : VerbP3 = {s = table {
-    InfImp => "be" ; 
-    Indic P1 => "am" ; 
-    Indic P2 => "are" ;
-    Indic P3 => "is" ;
-    Past Sg  => "was" ;
-    Past Pl  => "were" ;
-    PPart => "been"
-    }} ;
-
-  verbPart : VerbP3 -> Particle -> Verb = \v,p ->
-    v ** {s1 = p} ;
-
-  verbNoPart : VerbP3 -> Verb = \v -> verbPart v [] ;
-
--- The optional negation contraction is a useful macro e.g. for "do".
-
-  contractNot : Str -> Str = \is -> variants {is ++ "not" ; is + "n't"} ;
-
-  dont = contractNot (verbP3Do.s ! InfImp) ;
-} ;
-
diff --git a/grammars/resource/english/Paradigms.gf b/grammars/resource/english/Paradigms.gf
deleted file mode 100644
index d13179338..000000000
--- a/grammars/resource/english/Paradigms.gf
+++ /dev/null
@@ -1,243 +0,0 @@
---# -path=.:../abstract:../../prelude
-
---1 English 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 $MorphoEng.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, Syntax, English in {
-
---2 Parameters 
---
--- To abstract over gender names, we define the following identifiers.
-
-oper
-  human    : Gender ;
-  nonhuman : Gender ;
-
--- To abstract over number names, we define the following.
-
-  singular : Number ;
-  plural   : Number ;
-
-
---2 Nouns
-
--- Worst case: give all four forms and the semantic gender.
--- In practice the worst case is just: give singular and plural nominative.
-
-oper
-  mkN  : (man,men,man's,men's : Str) -> Gender -> N ;
-  nMan : (man,men : Str) -> Gender -> N ;
-
--- Regular nouns, nouns ending with "s", "y", or "o", and nouns with the same
--- plural form as the singular.
-
-  nReg   : Str -> Gender -> N ;   -- dog, dogs
-  nKiss  : Str -> Gender -> N ;   -- kiss, kisses
-  nFly   : Str -> Gender -> N ;   -- fly, flies
-  nHero  : Str -> Gender -> N ;   -- hero, heroes (= nKiss !)
-  nSheep : Str -> Gender -> N ;   -- sheep, sheep
-  
--- These use general heuristics, that recognizes the last letter. *N.B* it 
--- does not get right with "boy", "rush", since it only looks at one letter.
-
-  nHuman    : Str -> N ;  -- gambler/actress/nanny
-  nNonhuman : Str -> N ;  -- dog/kiss/fly
-
--- Nouns used as functions need a preposition. The most common is "of".
-
-  mkFun : N -> Preposition -> Fun ;
-
-  funHuman    : Str -> Fun ;  -- the father/mistress/daddy of 
-  funNonhuman : Str -> Fun ;  -- the successor/address/copy of 
-
--- Proper names, with their regular genitive.
-
-  pnReg : (John : Str) -> PN ;          -- John, John's
-
--- The most common cases on the top level havee shortcuts.
--- The regular "y"/"s" variation is taken into account in $CN$.
-
-  cnNonhuman : Str -> CN ;
-  cnHuman    : Str -> CN ;
-  npReg      : Str -> NP ;
-
--- In some cases, you may want to make a complex $CN$ into a function.
-
-  mkFunCN  : CN -> Preposition -> Fun ;
-  funOfCN : CN -> Fun ;
-
---2 Adjectives
-
--- Non-comparison one-place adjectives just have one form.
-
-  mkAdj1 : (even : Str) -> Adj1 ;
- 
--- Two-place adjectives need a preposition as second argument.
-
-  mkAdj2 : (divisible, by : Str) -> Adj2 ;
-
--- Comparison adjectives have three forms. The common irregular
--- cases are ones ending with "y" and a consonant that is duplicated.
-
-  mkAdjDeg : (good,better,best : Str) -> AdjDeg ;
-
-  aReg        : (long  : Str) -> AdjDeg ;      -- long, longer, longest
-  aHappy      : (happy : Str) -> AdjDeg ;      -- happy, happier, happiest
-  aFat        : (fat   : Str) -> AdjDeg ;      -- fat, fatter, fattest
-  aRidiculous : (ridiculous : Str) -> AdjDeg ; -- -/more/most ridiculous
-
--- On top level, there are adjectival phrases. The most common case is
--- just to use a one-place adjective.
-
-  apReg : Str -> AP ;
-
-
---2 Verbs
---
--- The fragment now has all verb forms, except the gerund/present participle.
--- Except for "be", the worst case needs four forms: the infinitive and
--- the third person singular present, the past indicative, and the past participle.
-
-  mkV   : (go, goes, went, gone : Str) -> V ;
-
-  vReg  : (walk : Str) -> V ;  -- walk, walks
-  vKiss : (kiss : Str) -> V ;  -- kiss, kisses
-  vFly  : (fly  : Str) -> V ;  -- fly, flies
-  vGo   : (go   : Str) -> V ;  -- go, goes (= vKiss !)
-
--- This generic function recognizes the special cases where the last
--- character is "y", "s", or "z". It is not right for "finish" and "convey".
-
-  vGen : Str -> V ; -- walk/kiss/fly
-
--- The verbs "be" and "have" are special.
-
-  vBe   : V ;
-  vHave : V ;
-
--- Verbs with a particle.
-
-  vPart    : (go, goes, went, gone, up : Str) -> V ;
-  vPartReg : (get,      up : Str) -> V ;    
-
--- Two-place verbs, and the special case with direct object.
--- Notice that a particle can already be included in $V$.
-
-  mkTV  : V -> Str -> TV ;              -- look for, kill
-
-  tvGen    : (look, for : Str) -> TV ;  -- look for, talk about
-  tvDir    : V                 -> TV ;  -- switch off
-  tvGenDir : (kill      : Str) -> TV ;  -- kill
-
--- Regular two-place verbs with a particle.
-
-  tvPartReg : Str -> Str -> Str -> TV ; -- get, along, with
-
--- The definitions should not bother the user of the API. So they are
--- hidden from the document.
---.
-
-  human = Hum ; 
-  nonhuman = NoHum ;
-  -- singular defined in types.Eng
-  -- plural defined in types.Eng
-
-  nominative = Nom ;
-
-  mkN = \man,men,man's,men's,g -> 
-    mkNoun man men man's men's ** {g = g ; lock_N = <>} ;
-  nReg a g = addGenN nounReg a g ;
-  nKiss n g = addGenN nounS n g ;
-  nFly = \fly -> addGenN nounY (Predef.tk 1 fly) ;
-  nMan = \man,men -> mkN man men (man + "'s") (men + "'s") ;
-  nHero = nKiss ;
-  nSheep = \sheep -> nMan sheep sheep ;
-
-  nHuman = \s -> nGen s Hum ;
-  nNonhuman = \s -> nGen s NoHum ;
-
-  nGen : Str -> Gender -> N = \fly,g -> let {
-      fl  = Predef.tk 1 fly ; 
-      y   = Predef.dp 1 fly ; 
-      eqy = ifTok (Str -> Gender -> N) y
-    } in
-    eqy "y" nFly  (
-    eqy "s" nKiss (
-    eqy "z" nKiss (
-            nReg))) fly g ;
-
-  mkFun = \n,p -> n ** {lock_Fun = <> ; s2 = p} ;
-  funNonhuman = \s -> mkFun (nNonhuman s) "of" ;
-  funHuman = \s -> mkFun (nHuman s) "of" ;
-
-  pnReg n = nameReg n ** {lock_PN = <>} ;
-
-  cnNonhuman = \s -> UseN (nGen s nonhuman) ;
-  cnHuman = \s -> UseN (nGen s human) ;
-  npReg = \s -> UsePN (pnReg s) ;  
-
-  mkFunCN = \n,p -> n ** {lock_Fun = <> ; s2 = p} ;
-  funOfCN = \n -> mkFunCN n "of" ;
-
-  addGenN : (Str -> CommonNoun) -> Str -> Gender -> N = \f -> 
-    \s,g -> f s ** {g = g ; lock_N = <>} ;
-
-  mkAdj1 a = simpleAdj a ** {lock_Adj1 = <>} ;
-  mkAdj2 = \s,p -> simpleAdj s ** {s2 = p} ** {lock_Adj2 = <>} ;
-  mkAdjDeg a b c = mkAdjDegr a b c ** {lock_AdjDeg = <>} ;
-  aReg a = adjDegrReg a ** {lock_AdjDeg = <>} ;
-  aHappy = \happy -> adjDegrY (Predef.tk 1 happy) ** {lock_AdjDeg = <>} ;
-  aFat = \fat -> let {fatt = fat + Predef.dp 1 fat} in 
-         mkAdjDeg fat (fatt + "er") (fatt + "est") ;
-  aRidiculous a = adjDegrLong a ** {lock_AdjDeg = <>} ;
-  apReg = \s -> AdjP1 (mkAdj1 s) ;
-
-  mkV = \go,goes,went,gone -> verbNoPart (mkVerbP3 go goes went gone) ** 
-    {lock_V = <>} ;
-  vReg = \walk -> mkV walk (walk + "s") (walk + "ed") (walk + "ed") ;
-  vKiss = \kiss -> mkV kiss (kiss + "es") (kiss + "ed") (kiss + "ed") ;
-  vFly = \cry -> let {cr = Predef.tk 1 cry} in 
-                   mkV cry (cr + "ies") (cr + "ied") (cr + "ied") ;
-  vGo = vKiss ;
-
-  vGen = \fly -> let {
-      fl  = Predef.tk 1 fly ; 
-      y   = Predef.dp 1 fly ; 
-      eqy = ifTok (Str -> V) y
-    } in
-    eqy "y" vFly  (
-    eqy "s" vKiss (
-    eqy "z" vKiss (
-            vReg))) fly ;
-
-  vPart = \go, goes, went, gone, up -> 
-    verbPart (mkVerbP3 go goes went gone) up ** {lock_V = <>} ;
-  vPartReg = \get, up -> 
-    verbPart (regVerbP3 get) up  ** {lock_V = <>} ;
-
-  mkTV = \v,p -> v ** {lock_TV = <> ; s3 = p} ;
-  tvPartReg = \get, along, to -> mkTV (vPartReg get along) to ;
-
-  vBe = verbBe  ** {s1 = [] ; lock_V = <>} ;
-  vHave = verbP3Have  ** {s1 = [] ; lock_V = <>} ;
-
-  tvGen = \s,p -> mkTV (vGen s) p ;
-  tvDir = \v -> mkTV v [] ;
-  tvGenDir = \s -> tvDir (vGen s) ;
-
-} ;
diff --git a/grammars/resource/english/Predication.gf b/grammars/resource/english/Predication.gf
deleted file mode 100644
index 4285a8e24..000000000
--- a/grammars/resource/english/Predication.gf
+++ /dev/null
@@ -1,83 +0,0 @@
-
---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 English 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"
-  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"
-  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 (AdjP1 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 (AdjP1 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) ;
-  appFunColl = \f, x, y -> DefOneNP (AppFun f (conjNP x y)) ;
-
-  appFam1 = \F, x -> AppFun F x ;
-  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/english/ResEng.gf b/grammars/resource/english/ResEng.gf
deleted file mode 100644
index 6ae9c7fb3..000000000
--- a/grammars/resource/english/ResEng.gf
+++ /dev/null
@@ -1,223 +0,0 @@
---# -path=.:../abstract:../../prelude
-
---1 The Top-Level English Resource Grammar
---
--- Aarne Ranta 2002 -- 2003
---
--- This is the English concrete syntax of the multilingual resource
--- grammar. Most of the work is done in the file $syntax.Eng.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 $TypesEng.gf$.
-
-concrete ResEng of ResAbs = open Prelude, Syntax in {
-
-flags 
-  startcat=Phr ; 
-  lexer=text ;
-  unlexer=text ;
-
-lincat 
-  N      = CommNoun ;         
-      -- = {s : Number => Case => Str}
-  CN     = CommNounPhrase ;   
-      -- = CommNoun ** {g : Gender}
-  NP     = {s : NPForm => Str ; n : Number ; p : Person} ;
-  PN     = {s : Case => Str} ;
-  Det    = {s : Str ; n : Number} ;
-  Fun    = Function ;
-      -- = CommNounPhrase ** {s2 : Preposition} ;
-  Fun2   = Function ** {s3 : Preposition} ;
-
-  Adj1   = Adjective ; 
-      -- = {s : Str}
-  Adj2   = Adjective ** {s2 : Preposition} ;
-  AdjDeg = {s : Degree => Str} ;
-  AP     = Adjective ** {p : Bool} ;
-
-  V      = Verb ; 
-      -- = {s : VForm => Str ; s1 : Particle}
-  VP     = {s : VForm => Str ; s2 : Number => Str ; isAux : Bool} ;
-  TV     = TransVerb ; 
-      -- = Verb ** {s3 : Preposition} ;
-  V3     = TransVerb ** {s4 : Preposition} ;
-  VS     = Verb ;
-
-  AdV    = {s : Str ; p : Bool} ;
-
-  S      = {s : Str} ; 
-  Slash  = {s : Bool => Str ; s2 : Preposition} ;
-  RP     = {s : Gender => Number => NPForm => Str} ;
-  RC     = {s : Gender => Number => Str} ;
-
-  IP     = {s : NPForm => Str ; n : Number} ;
-  Qu     = {s : QuestForm => Str} ;
-  Imp    = {s : Number => Str} ;
-  Phr    = {s : Str} ;
-  Text   = {s : Str} ;
-
-  Conj   = {s : Str ; n : Number} ;
-  ConjD  = {s1 : Str ; s2 : Str ; n : Number} ;
-
-  ListS  = {s1 : Str ; s2 : Str} ;
-  ListAP = {s1 : Str ; s2 : Str ; p : Bool} ;
-  ListNP = {s1,s2 : NPForm => Str ; n : Number ; p : Person} ;
-
---.
-
-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 ;
-  PosV3 = complDitransVerb True ;
-  NegV3 = complDitransVerb False ;
-  PosPassV = passVerb True ;
-  NegPassV = passVerb False ;
-  PosNP = predNounPhrase True ;
-  NegNP = predNounPhrase False ;
-  PosVS = complSentVerb True ;
-  NegVS = complSentVerb False ;
-  VTrans = transAsVerb ;
-
-  AdvVP = adVerbPhrase ;
-  LocNP = locativeNounPhrase ;
-  AdvCN = advCommNounPhrase ;
-  AdvAP = advAdjPhrase ;
-
-  PosSlashTV = slashTransVerb True ;
-  NegSlashTV = slashTransVerb False ;
-  OneVP = predVerbPhrase (nameNounPhrase (nameReg "one")) ;
-
-  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 ;
-  SubjVP = subjunctVerbPhrase ;
-
-  PhrNP = useNounPhrase ;
-  PhrOneCN = useCommonNounPhrase singular ;
-  PhrManyCN = useCommonNounPhrase plural ;
-  PhrIP ip = ip ;
-  PhrIAdv ia = ia ;
-
-  OnePhr p = p ;
-  ConsPhr = cc2 ;
-
-  INP    = pronI ;
-  ThouNP = pronYouSg ;
-  HeNP   = pronHe ;
-  SheNP  = pronShe ;
-  ItNP   = pronIt ;
-  WeNP   = pronWe ;
-  YeNP   = pronYouPl ;
-  YouNP  = pronYouSg ;
-  TheyNP = pronThey ;
-
-  EveryDet = everyDet ; 
-  AllDet   = allDet ; 
-  WhichDet = whichDet ;
-  MostDet  = mostDet ;
-
-  HowIAdv = ss "how" ;
-  WhenIAdv = ss "when" ;
-  WhereIAdv = ss "where" ;
-  WhyIAdv = ss "why" ;
-
-  AndConj = ss "and" ** {n = Pl} ;
-  OrConj = ss "or" ** {n = Sg} ;
-  BothAnd = sd2 "both" "and" ** {n = Pl} ;
-  EitherOr = sd2 "either" "or" ** {n = Sg} ;
-  NeitherNor = sd2 "neither" "nor" ** {n = Sg} ;
-  IfSubj = ss "if" ;
-  WhenSubj = ss "when" ;
-
-  PhrYes = ss "Yes." ;
-  PhrNo = ss "No." ;
-
-  VeryAdv = ss "very" ;
-  TooAdv = ss "too" ;
-  OtherwiseAdv = ss "otherwise" ;
-  ThereforeAdv = ss "therefore" ;
-
-} ;
diff --git a/grammars/resource/english/RestaurantEng.gf b/grammars/resource/english/RestaurantEng.gf
deleted file mode 100644
index 69905ee32..000000000
--- a/grammars/resource/english/RestaurantEng.gf
+++ /dev/null
@@ -1,27 +0,0 @@
---# -path=.:../abstract:../../prelude
-
-concrete RestaurantEng of Restaurant = 
-  DatabaseEng ** open Prelude,Paradigms,DatabaseEngRes in {
-
-lin 
-  Restaurant = cnNonhuman "restaurant" ;
-  Bar = cnNonhuman "bar" ;
-  French = apReg "French" ;
-  Italian = apReg "Italian" ;
-  Indian = apReg "Indian" ;
-  Japanese = apReg "Japanese" ;
-
-  address = funNonhuman "address" ;
-  phone = funNonhuman ["number"] ;  --- phone
-  priceLevel = funNonhuman ["level"] ; --- price
-
-  Cheap = aReg "cheap" ;
-  Expensive = aRidiculous "expensive" ;
-
-  WhoRecommend rest = mkSentSame (ss (["who recommended"] ++ rest.s ! nominative)) ;
-  WhoHellRecommend rest = 
-    mkSentSame (ss (["who the hell recommended"] ++ rest.s ! nominative)) ;
-
-  LucasCarton = pnReg ["Lucas Carton"] ;
-
-} ;
diff --git a/grammars/resource/english/Syntax.gf b/grammars/resource/english/Syntax.gf
deleted file mode 100644
index 07f4c7358..000000000
--- a/grammars/resource/english/Syntax.gf
+++ /dev/null
@@ -1,924 +0,0 @@
---1 A Small English Resource Syntax
---
--- Aarne Ranta 2002
---
--- This resource grammar contains definitions needed to construct 
--- indicative, interrogative, and imperative sentences in English.
---
--- The following files 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
-
--- To the common nouns of morphology,
--- we add natural gender (human/nonhuman) which is needed in syntactic
--- combinations (e.g. "man who runs" - "program which runs").
-
-oper
-  CommNoun = CommonNoun ** {g : Gender} ;
-
-  CommNounPhrase = CommNoun ;
-
-  noun2CommNounPhrase : CommNoun -> CommNounPhrase = \man ->
-    man ;
-
-  cnGen : CommonNoun -> Gender -> CommNoun = \cn,g ->
-    cn ** {g = g} ;
-
-  cnHum : CommonNoun -> CommNoun = \cn ->
-    cnGen cn Hum ;
-  cnNoHum : CommonNoun -> CommNoun = \cn ->
-    cnGen cn NoHum ;
-
---2 Noun phrases
---
--- The worst case is pronouns, which have inflection in the possessive forms. 
--- Proper names are a special case.
-
-  NounPhrase : Type = Pronoun ;
-
-  nameNounPhrase : ProperName -> NounPhrase = \john -> 
-    {s = \\c => john.s ! toCase c ; n = Sg ; p = P3} ;
-
---2 Determiners
---
--- Determiners are inflected according to the nouns they determine.
--- The determiner is not inflected.
-  Determiner : Type = {s : Str ; n : Number} ;
-
-  detNounPhrase : Determiner -> CommNounPhrase -> NounPhrase = \every, man -> 
-    {s = \\c => every.s ++ man.s ! every.n ! toCase c ; 
-     n = every.n ; 
-     p = P3
-    } ;
-
-  mkDeterminer : Number -> Str -> Determiner = \n,det -> 
-    {s = det ; 
-     n = n
-    } ;
-
-  everyDet = mkDeterminer Sg "every" ;
-  allDet   = mkDeterminer Pl "all" ;
-  mostDet  = mkDeterminer Pl "most" ;
-  aDet     = mkDeterminer Sg artIndef ;
-  plDet    = mkDeterminer Pl [] ;
-  theSgDet = mkDeterminer Sg "the" ;
-  thePlDet = mkDeterminer Pl "the" ;
-  anySgDet = mkDeterminer Sg "any" ;
-  anyPlDet = mkDeterminer Pl "any" ;
-
-  whichSgDet = mkDeterminer Sg "which" ;
-  whichPlDet = mkDeterminer Pl "which" ;
-
-  whichDet = whichSgDet ; --- API
-
-  indefNoun : Number -> CommNoun -> Str = \n,man -> 
-    (indefNounPhrase n man).s ! NomP ;
-
-  indefNounPhrase : Number -> CommNounPhrase -> NounPhrase = \n,man -> 
-    {s = \\c => case n of {
-                       Sg => artIndef ++ man.s ! n ! toCase c ; 
-                       Pl => man.s ! n ! toCase c
-                       } ;
-     n = n ; p = P3
-    } ;
-
-  defNounPhrase : Number -> CommNounPhrase -> NounPhrase = \n,car -> 
-    {s = \\c => artDef ++ car.s ! n ! toCase c ; n = n ; p = P3} ;
-
--- Genitives of noun phrases can be used like determiners, to build noun phrases.
--- The number argument makes the difference between "my house" - "my houses".
---
--- We have the variation "the car of John / the car of John's / John's car"
-
-  npGenDet : Number -> NounPhrase -> CommNounPhrase -> NounPhrase = 
-    \n,john,car -> 
-      {s = \\c => variants {
-             artDef ++ car.s ! n ! Nom ++ "of" ++ john.s ! GenSP ; 
-             john.s ! GenP ++ car.s ! n ! toCase c
-             } ;
-       n = n ; 
-       p = P3
-      } ;
-
--- *Bare plural noun phrases* like "men", "good cars", are built without a 
--- determiner word.
-
-  plurDet : CommNounPhrase -> NounPhrase = \cn -> 
-    {s = \\c => cn.s ! plural ! toCase c ; 
-     p = P3 ; 
-     n = Pl
-    } ;
-
--- Constructions like "the idea that two is even" are formed at the
--- first place as common nouns, so that one can also have "a suggestion that...".
-
-  nounThatSentence : CommNounPhrase -> Sentence -> CommNounPhrase = \idea,x -> 
-    {s = \\n,c => idea.s ! n ! c ++ "that" ++ x.s ; 
-     g = idea.g
-    } ;
-
-
---2 Adjectives
---
--- Adjectival phrases have a parameter $p$ telling if they are prefixed ($True$) or 
--- postfixed (complex APs). 
-
-  AdjPhrase : Type = Adjective ** {p : Bool} ;
-
-  adj2adjPhrase : Adjective -> AdjPhrase = \new -> new ** {p = True} ;
-
-  simpleAdjPhrase : Str -> AdjPhrase = \French ->
-    adj2adjPhrase (simpleAdj French) ;
-
-
---3 Comparison adjectives
---
--- Each of the comparison forms has a characteristic use:
---
--- Positive forms are used alone, as adjectival phrases ("big").
-
-  positAdjPhrase : AdjDegr -> AdjPhrase = \big -> 
-    adj2adjPhrase (ss (big.s ! Pos)) ;
-
--- Comparative forms are used with an object of comparison, as
--- adjectival phrases ("bigger then you").
-
-  comparAdjPhrase : AdjDegr -> NounPhrase -> AdjPhrase = \big, you ->
-    {s = big.s ! Comp ++ "than" ++ you.s ! NomP ; 
-     p = False
-    } ;
-
--- Superlative forms are used with a modified noun, picking out the
--- maximal representative of a domain ("the biggest house").
-
-  superlNounPhrase : AdjDegr -> CommNoun -> NounPhrase = \big, house ->
-    {s = \\c => "the" ++ big.s ! Sup ++ house.s ! Sg ! toCase c ; 
-     n = Sg ; 
-     p = P3
-    } ;
-
-
---3 Two-place adjectives
---
--- A two-place adjective is an adjective with a preposition used before
--- the complement.
-
-  Preposition = Str ;
-
-  AdjCompl = Adjective ** {s2 : Preposition} ;
-
-  complAdj : AdjCompl -> NounPhrase -> AdjPhrase = \related,john ->
-    {s = related.s ++ related.s2 ++ john.s ! AccP ; 
-     p = False
-    } ;
-
-
---3 Modification of common nouns
---
--- The two main functions of adjective are in predication ("John is old")
--- and in modification ("an old man"). Predication will be defined
--- later, in the chapter on verbs.
---
--- Modification must pay attention to pre- and post-noun
--- adjectives: "big car"/"car bigger than X"
-
-  modCommNounPhrase : AdjPhrase -> CommNounPhrase -> CommNounPhrase = \big, car -> 
-    {s = \\n => if_then_else (Case => Str) big.p 
-           (\\c => big.s ++ car.s ! n ! c)
-           (table {Nom => car.s ! n ! Nom ++ big.s ; Gen => variants {}}) ;
-     g = car.g
-    } ;
-
-
---2 Function expressions
-
--- A function expression is a common noun together with the
--- preposition prefixed to its argument ("mother of x").
--- The type is analogous to two-place adjectives and transitive verbs.
-
-  Function = CommNounPhrase ** {s2 : Preposition} ;
-
--- The application of a function gives, in the first place, a common noun:
--- "mother/mothers of John". From this, other rules of the resource grammar 
--- give noun phrases, such as "the mother of John", "the mothers of John",
--- "the mothers of John and Mary", and "the mother of John and Mary" (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 = \mother,john -> 
-    {s = \\n => table {
-            Gen => nonExist ; --- ?
-            _ => mother.s ! n ! Nom ++ mother.s2 ++ john.s ! GenSP 
-            } ;
-     g = mother.g
-    } ;
-
--- It is possible to use a function word as a common noun; the semantics is
--- often existential or indexical.
-
-  funAsCommNounPhrase : Function -> CommNounPhrase = 
-    noun2CommNounPhrase ;
-
--- The following is an aggregate corresponding to the original function application
--- producing "John's mother" and "the mother of John". It does not appear in the
--- resource grammar API any longer.
-
-  appFun : Bool -> Function -> NounPhrase -> NounPhrase = \coll, mother,john -> 
-    let {n = john.n ; nf = if_then_else Number coll Sg n} in 
-    variants {
-      defNounPhrase nf (appFunComm mother john) ;
-      npGenDet nf john mother
-      } ;
-
--- The commonest case is functions with the preposition  "of".
-
-  funOf : CommNoun -> Function = \mother -> 
-    mother ** {s2 = "of"} ;
-
-  funOfReg : Str -> Gender -> Function = \mother,g -> 
-    funOf (nounReg mother ** {g = g}) ;
-
--- Two-place functions add one argument place.
-
-  Function2 = Function ** {s3 : Preposition} ;
-
--- There application starts by filling the first place.
-
-  appFun2 : Function2 -> NounPhrase -> Function = \train, paris ->
-    {s  = \\n,c => train.s ! n ! c ++ train.s2 ++ paris.s ! AccP ;
-     g  = train.g ;
-     s2 = train.s3
-    } ;
-
-
---2 Verbs
---
---3 Verb phrases
---
--- Verb phrases are discontinuous: the two parts of a verb phrase are
--- (s) an inflected verb, (s2) infinitive and complement.
--- For instance: "doesn't" - "walk" ; "isn't" - "old" ; "is" - "a man"
--- There's also a parameter telling if the verb is an auxiliary:
--- this is needed in question.
-
-  VerbPhrase = VerbP3 ** {s2 : Number => Str ; isAux : Bool} ;
-
--- From the inflection table, we selecting the finite form as function 
--- of person and number:
-
-  indicVerb : VerbP3 -> Person -> Number -> Str = \v,p,n -> case n of {
-    Sg => v.s ! Indic p ;
-    Pl => v.s ! Indic P2
-    } ;
-
--- 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 "don't" are not grammatical.
-
-  predVerb : Bool -> Verb -> VerbPhrase = \b,walk ->
-    if_then_else VerbPhrase b 
-      {s = \\v => walk.s ! v ++ walk.s1 ;
-       s2 = \\_ => [] ; 
-       isAux = False
-      }
-      {s  = \\v => contractNot (verbP3Do.s ! v) ; 
-       s2 = \\_ => walk.s ! InfImp ++ walk.s1 ;
-       isAux = True
-      } ;
-
--- Sometimes we want to extract the verb part of a verb phrase.
-
-  verbOfPhrase : VerbPhrase -> VerbP3 = \v -> {s = v.s} ;
-
--- Verb phrases can also be formed from adjectives ("is old"),
--- common nouns ("is a man"), and noun phrases ("ist John").
--- The third rule is overgenerating: "is every man" has to be ruled out
--- on semantic grounds.
-
-  predAdjective : Bool -> Adjective -> VerbPhrase = \b,old ->
-    {s = beOrNotBe b ;
-     s2 = \\_ => old.s ;
-     isAux = True
-    } ;
-
-  predCommNoun : Bool -> CommNoun -> VerbPhrase = \b,man ->
-    {s = beOrNotBe b ;
-     s2 = \\n => indefNoun n man ;
-     isAux = True
-    } ;
-
-  predNounPhrase : Bool -> NounPhrase -> VerbPhrase = \b,john ->
-    {s = beOrNotBe b ;
-     s2 = \\_ => john.s ! NomP ;
-     isAux = True
-    } ;
-
--- We use an auxiliary giving all forms of "be".
-
-  beOrNotBe : Bool -> (VForm => Str) = \b -> 
-    if_then_else (VForm => Str) b 
-      verbBe.s
-      (table {
-        InfImp   => contractNot "do" ++ "be" ;
-        Indic P1 => "am" ++ "not" ;
-        v        => contractNot (verbBe.s ! v)
-        }) ;
-
---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*.
-
-  TransVerb : Type = Verb ** {s3 : Preposition} ;
-
--- The rule for using transitive verbs is the complementization rule.
--- Particles produce free variation: before or after the complement 
--- ("I switch on the TV" / "I switch the TV on").
-
-  complTransVerb : Bool -> TransVerb -> NounPhrase -> VerbPhrase = 
-    \b,lookat,john ->
-    let {lookatjohn = bothWays lookat.s1 (lookat.s3 ++ john.s ! AccP)} in
-    if_then_else VerbPhrase b 
-      {s = lookat.s ; 
-       s2 = \\_ => lookatjohn ; 
-       isAux = False}
-      {s = \\v => contractNot (verbP3Do.s ! v) ; 
-       s2 = \\_ => lookat.s ! InfImp ++ lookatjohn ;
-       isAux = True} ;
-
-
--- Verbs that take direct object and a  particle:
-  mkTransVerbPart : VerbP3 -> Str -> TransVerb = \turn,off -> 
-    {s = turn.s ; s1 = off ; s3 = []} ;
-
--- Verbs that take prepositional object, no particle:
-  mkTransVerb : VerbP3 -> Str -> TransVerb = \wait,for -> 
-    {s = wait.s ; s1 = [] ; s3 = for} ;
-
--- Verbs that take direct object, no particle:
-  mkTransVerbDir : VerbP3 -> TransVerb = \love -> 
-    mkTransVerbPart love [] ;
-
--- 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 "he is swum", etc.
--- The syntax is the same as for adjectival predication.
-
-  passVerb : Bool -> Verb -> VerbPhrase = \b,love ->
-    predAdjective b (adj2adjPhrase (ss (love.s ! PPart))) ;
-
--- Transitive verbs can be used elliptically as verbs. The semantics
--- is left to applications. The definition is trivial, due to record
--- subtyping.
-
-  transAsVerb : TransVerb -> Verb = \love -> 
-    love ;
-
--- *Ditransitive verbs* are verbs with three argument places.
--- We treat so far only the rule in which the ditransitive
--- verb takes both complements to form a verb phrase.
-
-  DitransVerb = TransVerb ** {s4 : Preposition} ; 
-
-  mkDitransVerb : Verb -> Preposition -> Preposition -> DitransVerb = \v,p1,p2 -> 
-    v ** {s3 = p1 ; s4 = p2} ;
-
-  complDitransVerb : 
-    Bool -> DitransVerb -> NounPhrase -> NounPhrase -> VerbPhrase = 
-    \b,give,you,beer ->
-      let {
-        youbeer = give.s1 ++ give.s3 ++ you.s ! AccP ++ give.s4 ++ beer.s ! AccP
-      } in
-      if_then_else VerbPhrase b 
-      {s = give.s ; 
-       s2 = \\_ => youbeer ;
-       isAux = False
-      }
-      {s = \\v => contractNot (verbP3Do.s ! v) ; 
-       s2 = \\_ => give.s ! InfImp ++ youbeer ;
-       isAux = True
-      } ;
-
-
---2 Adverbials
---
--- Adverbials are not inflected (we ignore comparison, and treat
--- compared adverbials as separate expressions; this could be done another way).
--- We distinguish between post- and pre-verbal adverbs.
-
-  Adverb : Type = SS ** {p : Bool} ;
-
-  advPre  : Str -> Adverb = \seldom -> ss seldom ** {p = False} ;
-  advPost : Str -> Adverb = \well   -> ss well   ** {p = True} ;
-
--- N.B. this rule generates the cyclic parsing rule $VP#2 ::= VP#2$
--- and cannot thus be parsed.
-
-  adVerbPhrase : VerbPhrase -> Adverb -> VerbPhrase = \sings, well ->
-    let {postp = orB well.p sings.isAux} in
-    {
-     s = \\v => (if_then_else Str postp [] well.s) ++ sings.s ! v ;
-     s2 = \\n => sings.s2 ! n ++ (if_then_else Str postp well.s []) ;
-     isAux = sings.isAux
-    } ;
-
-  advAdjPhrase : SS -> AdjPhrase -> AdjPhrase = \very, good ->
-    {s = very.s ++ good.s ;
-     p = good.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 ("on", "at").
-
-  prepPhrase : Preposition -> NounPhrase -> Adverb = \on, it ->
-    advPost (on ++ it.s ! AccP) ;
-
-  locativeNounPhrase : NounPhrase -> Adverb = 
-    prepPhrase "in" ;
-
--- This is a source of the "mann with a telescope" ambiguity, and may produce
--- strange things, like "cars always" (while "cars today" is OK).
--- Semantics will have to make finer distinctions among adverbials.
---
--- N.B. the genitive case created in this way would not make sense.
-
-  advCommNounPhrase : CommNounPhrase -> Adverb -> CommNounPhrase = \car,today ->
-   {s = \\n => table {
-      Nom => car.s ! n ! Nom ++ today.s ; 
-      Gen => nonExist
-      } ;
-    g = car.g
-   } ;
-
-
---2 Sentences
---
--- Sentences are not inflected in this fragment of English without tense.
-
-  Sentence : Type = SS ;
-
--- This is the traditional $S -> NP VP$ rule. It takes care of
--- agreement between subject and verb. Recall that the VP may already
--- contain negation. 
-
-  predVerbPhrase : NounPhrase -> VerbPhrase -> Sentence = \john,walks ->
-    ss (john.s ! NomP ++ indicVerb (verbOfPhrase walks) john.p john.n ++ 
-        walks.s2 ! john.n) ;
-
-
--- This is a macro for simultaneous predication and complementization.
-
-  predTransVerb : Bool -> NounPhrase -> TransVerb -> NounPhrase -> Sentence = 
-    \b,you,see,john -> 
-    predVerbPhrase you (complTransVerb b see john) ;
-
-
---3 Sentence-complement verbs
---
--- Sentence-complement verbs take sentences as complements.
-
-  SentenceVerb : Type = Verb ;
-
--- To generate "says that John walks" / "doesn't say that John walks":
-
-  complSentVerb : Bool -> SentenceVerb -> Sentence -> VerbPhrase = 
-    \b,say,johnruns ->
-    let {thatjohnruns = optStr "that" ++ johnruns.s} in
-    if_then_else VerbPhrase b 
-      {s  = say.s ; 
-       s2 = \\_ => thatjohnruns ; 
-       isAux = False}
-      {s  = \\v => contractNot (verbP3Do.s ! v) ; 
-       s2 = \\_ => say.s ! InfImp ++ thatjohnruns ;
-       isAux = True} ;
-
-
---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 a similar relation to sentences as
--- transitive verbs have to verbs: it's like a *sentence taking a complement*.
--- However, we need something more to distinguish its use in direct questions:
--- not just "you see" but ("whom") "do you see".
---
--- The particle always follows the verb, but the preposition can fly:
--- "whom you make it up with" / "with whom you make it up".
-
-  SentenceSlashNounPhrase = {s : Bool => Str ; s2 : Preposition} ;
-
-  slashTransVerb : Bool -> NounPhrase -> TransVerb -> SentenceSlashNounPhrase = 
-    \b,You,lookat ->
-    let {you   = You.s ! NomP ;
-         looks = indicVerb {s = lookat.s} You.p You.n ;
-         look  = lookat.s ! InfImp ;
-         do    = indicVerb verbP3Do You.p You.n ;
-         dont  = contractNot do ;
-         up    = lookat.s1
-        } in
-    {s  = table {
-            True  => if_then_else Str b do dont ++ you ++ look ++ up ; 
-            False => you ++ if_then_else Str b looks (dont ++ look) ++ up
-            } ;
-     s2 = lookat.s3   
-    } ;
-
-
---2 Relative pronouns and relative clauses
---
--- As described in $types.Eng.gf$, relative pronouns are inflected in 
--- gender (human/nonhuman), number, and case.
---
--- We get the simple relative pronoun ("who"/"which"/"whom"/"whose"/"that"/$""$)
--- from $morpho.Eng.gf$.
-
-  identRelPron : RelPron = relPron ;
-
-  funRelPron : Function -> RelPron -> RelPron = \mother,which -> 
-    {s = \\g,n,c => "the" ++ mother.s ! n ! Nom ++ 
-                    mother.s2 ++ which.s ! g ! n ! GenSP
-    } ;
-
--- Relative clauses can be formed from both verb phrases ("who walks") and
--- slash expressions ("whom you see", "on which you sit" / "that you sit on"). 
-
-  RelClause : Type = {s : Gender => Number => Str} ;
-
-  relVerbPhrase : RelPron -> VerbPhrase -> RelClause = \who,walks ->
-    {s = \\g, n => who.s ! g ! n ! NomP ++ 
-                   indicVerb (verbOfPhrase walks) P3 n ++ walks.s2 ! n
-    } ;
-
-  relSlash : RelPron -> SentenceSlashNounPhrase -> RelClause = \who,yousee ->
-    {s = \\g,n => 
-           let {youSee = yousee.s ! False} in
-           variants {
-             who.s ! g ! n ! AccP ++ youSee ++ yousee.s2 ;
-             yousee.s2 ++ who.s ! g ! n ! GenSP ++ youSee
-             }
-    } ;
-
--- A 'degenerate' relative clause is the one often used in mathematics, e.g.
--- "number x such that x is even".
-
-  relSuch : Sentence -> RelClause = \A ->
-    {s = \\_,_ => "such" ++ "that" ++ A.s} ;
-
--- 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. No comma is used before these relative clause.
-
-  modRelClause : CommNounPhrase -> RelClause -> CommNounPhrase = \man,whoruns ->
-    {s = \\n,c => man.s ! n ! c ++ whoruns.s ! man.g ! n ;
-     g = man.g
-    } ;
-
-
---2 Interrogative pronouns
---
--- If relative pronouns are adjective-like, interrogative pronouns are
--- noun-phrase-like. 
-
-  IntPron : Type = {s : NPForm => Str ; 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 = \mother,which -> 
-    {s = \\c => "the" ++ mother.s ! which.n ! Nom ++ mother.s2 ++ which.s ! GenSP ;
-     n = which.n
-    } ;
-
--- There is a variety of simple interrogative pronouns:
--- "which house", "who", "what".
-
-  nounIntPron : Number -> CommNounPhrase -> IntPron = \n, car ->
-    {s = \\c => "which" ++ car.s ! n ! toCase c ; 
-     n = n
-    } ; 
-
-  intPronWho : Number -> IntPron = \num -> {
-    s = table {
-      NomP  => "who" ;
-      AccP  => variants {"who" ; "whom"} ;
-      GenP  => "whose" ;
-      GenSP => "whom"
-      } ;
-    n = num
-  } ;
-
-  intPronWhat : Number -> IntPron = \num -> {
-    s = table {
-      GenP  => "what's" ;
-      _ => "what"
-      } ;
-    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 ++ ".") ;
-  interrogUtt : Question -> Utterance = \x -> ss (x.s ! DirQ ++ "?") ;
-
-
---2 Questions
---
--- Questions are either direct ("are you happy") or indirect 
--- ("if/whether you are happy").
-
-param 
-  QuestForm = DirQ | IndirQ ;
-
-oper
-  Question = SS1 QuestForm ;
-
---3 Yes-no questions 
---
--- Yes-no questions are used both independently 
--- ("does John walk" / "if John walks")
--- and after interrogative adverbials 
--- ("why does John walk" / "why John walks").
--- 
--- It is economical to handle with all these cases by the one
--- rule, $questVerbPhrase'$. The word ("ob" / "whether") never appears
--- if there is an adverbial.
-
-  questVerbPhrase : NounPhrase -> VerbPhrase -> Question = 
-    questVerbPhrase' False ;
-
-  questVerbPhrase' : Bool -> NounPhrase -> VerbPhrase -> Question = 
-    \adv,john,walk ->
-    {s = table {
-      DirQ   => if_then_else Str walk.isAux 
-                  (indicVerb (verbOfPhrase walk) john.p john.n ++
-                   john.s ! NomP ++ walk.s2 ! john.n) 
-                  (indicVerb verbP3Do john.p john.n ++ 
-                   john.s ! NomP ++ walk.s ! InfImp ++ walk.s2 ! john.n) ;
-      IndirQ => if_then_else Str adv [] (variants {"if" ; "whether"}) ++ 
-                (predVerbPhrase john walk).s
-      }
-    } ;
-
-
-
---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 = \who,walk ->
-    {s = \\_ => who.s ! NomP ++ indicVerb (verbOfPhrase walk) P3 who.n ++ 
-                walk.s2 ! who.n 
-    } ;
-
-  intSlash : IntPron -> SentenceSlashNounPhrase -> Question = \who,yousee ->
-    {s = \\q =>
-           let {youSee = case q of {
-                  DirQ   => yousee.s ! True ; 
-                  IndirQ => yousee.s ! False
-                  }
-           } in
-           variants {
-             who.s ! AccP ++ youSee ++ yousee.s2 ;
-             yousee.s2 ++ who.s ! GenSP ++ youSee
-             } 
-    } ;
-
---3 Interrogative adverbials
---
--- These adverbials will be defined in the lexicon: they include
--- "when", "where", "how", "why", 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 : Preposition -> IntPron -> IntAdverb = \at, whom ->
-    ss (at ++ whom.s ! AccP) ;
-
--- A question adverbial can be applied to anything, and whether this makes
--- sense is a semantic question.
-
-  questAdverbial : IntAdverb -> NounPhrase -> VerbPhrase -> Question = 
-    \why, you, walk ->
-    {s = \\q => why.s ++ (questVerbPhrase' True you walk).s ! q} ;
-
-
---2 Imperatives
---
--- We only consider second-person imperatives. 
-
-  Imperative = SS1 Number ;
-
-  imperVerbPhrase : VerbPhrase -> Imperative = \walk -> 
-    {s = \\n => walk.s ! InfImp ++ walk.s2 ! n} ;
-
-  imperUtterance : Number -> Imperative -> Utterance = \n,I ->
-    ss (I.s ! n ++ "!") ;
-
---2 Sentence adverbials
---
--- This class covers adverbials such as "otherwise", "therefore", which are prefixed
--- to a sentence to form a phrase.
-
-  advSentence : SS -> Sentence -> Utterance = \hence,itiseven ->
-    ss (hence.s ++ itiseven.s ++ ".") ;
-
-
---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 ("and", "or") or distributed ("both - and", "either - or").
---
--- The conjunction has an inherent number, which is used when conjoining
--- noun phrases: "John and Mary are..." vs. "John or Mary is..."; in the
--- case of "or", 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 = SD2 ;
-
-  twoSentence : (_,_ : Sentence) -> ListSentence = CO.twoSS ;
-
-  consSentence : ListSentence -> Sentence -> ListSentence =
-    CO.consSS 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 = \c,xs ->
-    ss (CO.conjunctX c xs) ;
-
--- To coordinate a list of sentences by a distributed conjunction, we place
--- the first part (e.g. "either") in front of the first element, the second
--- part ("or") between the last two elements, and commas in the other slots.
--- For sentences this is really not used.
-
-  conjunctDistrSentence : ConjunctionDistr -> ListSentence -> Sentence = 
-    \c,xs ->
-    ss (CO.conjunctDistrX c xs) ;
-
---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 = SD2 ** {p : Bool} ;
-
-  twoAdjPhrase : (_,_ : AdjPhrase) -> ListAdjPhrase = \x,y ->
-    CO.twoStr x.s y.s ** {p = andB x.p y.p} ;
-
-  consAdjPhrase : ListAdjPhrase -> AdjPhrase -> ListAdjPhrase =  \xs,x ->
-    CO.consStr CO.comma xs x.s ** {p = andB xs.p x.p} ;
-
-  conjunctAdjPhrase : Conjunction -> ListAdjPhrase -> AdjPhrase = \c,xs ->
-    ss (CO.conjunctX c xs) ** {p = xs.p} ;
-
-  conjunctDistrAdjPhrase : ConjunctionDistr -> ListAdjPhrase -> AdjPhrase = 
-    \c,xs ->
-    ss (CO.conjunctDistrX 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.
-
-  ListNounPhrase : Type = {s1,s2 : NPForm => Str ; n : Number ; p : Person} ;
-
-  twoNounPhrase : (_,_ : NounPhrase) -> ListNounPhrase = \x,y ->
-    CO.twoTable NPForm x y ** {n = conjNumber x.n y.n ; p = conjPerson x.p y.p} ;
-
-  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} ;
-
-  conjunctNounPhrase : Conjunction -> ListNounPhrase -> NounPhrase = \c,xs ->
-    CO.conjunctTable NPForm c xs ** {n = conjNumber c.n xs.n ; p = xs.p} ;
-
-  conjunctDistrNounPhrase : ConjunctionDistr -> ListNounPhrase -> NounPhrase = 
-    \c,xs ->
-    CO.conjunctDistrTable NPForm c xs ** {n = conjNumber c.n xs.n ; p = xs.p} ;
-
--- 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 let the latter argument win ("either you or I am absent"
--- but "either I or you are absent"). This is not quite clear.
-
-  conjPerson : Person -> Person -> Person = \_,p -> 
-    p ;
-
-
-
---2 Subjunction
---
--- Subjunctions ("when", "if", 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.
---
--- There are uniformly two variant word orders, e.g. 
--- "if you smoke I get angry"
--- and "I get angry if you smoke".
-
-  Subjunction = SS ;
-
-  subjunctSentence : Subjunction -> Sentence -> Sentence -> Sentence = 
-    \if, A, B -> 
-    ss (subjunctVariants if A.s B.s) ;
-
-  subjunctImperative : Subjunction -> Sentence -> Imperative -> Imperative = 
-    \if, A, B -> 
-    {s = \\n => subjunctVariants if A.s (B.s ! n)} ;
-
-  subjunctQuestion : Subjunction -> Sentence -> Question -> Question = 
-    \if, A, B ->
-    {s = \\q => subjunctVariants if A.s (B.s ! q)} ;
-
-  subjunctVariants : Subjunction -> Str -> Str -> Str = \if,A,B ->
-    variants {if.s ++ A ++ "," ++ B ; B ++ "," ++ if.s ++ A} ;
-
-  subjunctVerbPhrase : VerbPhrase -> Subjunction -> Sentence -> VerbPhrase =
-    \V, if, A -> 
-    adVerbPhrase V (advPost (if.s ++ A.s)) ;
-
---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) ;
-
-  useRegularName : SS -> NounPhrase = \john -> 
-    nameNounPhrase (nameReg john.s) ;
-
--- Here are some default forms.
-
-  defaultNounPhrase : NounPhrase -> SS = \john -> 
-    ss (john.s ! NomP) ;
-
-  defaultQuestion : Question -> SS = \whoareyou ->
-    ss (whoareyou.s ! DirQ) ;
-
-  defaultSentence : Sentence -> Utterance = \x -> 
-    x ;
-
-} ;
diff --git a/grammars/resource/english/TestEng.gf b/grammars/resource/english/TestEng.gf
deleted file mode 100644
index 5515cc9de..000000000
--- a/grammars/resource/english/TestEng.gf
+++ /dev/null
@@ -1,46 +0,0 @@
--- use this path to read the grammar from the same directory
---# -path=.:../abstract:../../prelude
-
-concrete TestEng of TestAbs = ResEng ** open Syntax in {
-
-flags startcat=Phr ; lexer=text ; parser=chart ; unlexer=text ;
-
--- a random sample from the lexicon
-
-lin
-  Big = mkAdjDegr "big" "bigger" "biggest";
-  Small = adjDegrReg "small" ;
-  Old = adjDegrReg "old" ;
-  Young = adjDegrReg "young" ;
-  American = simpleAdj "American" ;
-  Finnish = simpleAdj "Finnish" ;
-  Married = simpleAdj "married" ** {s2 = "to"} ;
-  Man = cnHum (mkNoun "man" "men" "man's" "men's") ;
-  Woman = cnHum (mkNoun "woman" "women" "woman's" "women's") ;
-  Car = cnNoHum (nounReg "car") ;
-  House = cnNoHum (nounReg "house") ;
-  Light = cnNoHum (nounReg "light") ;
-  Walk = verbNoPart (regVerbP3 "walk") ;
-  Run = verbNoPart (mkVerb "run" "ran" "run") ;
-  Say = verbNoPart (mkVerb "say" "said" "said") ;
-  Prove = verbNoPart (regVerbP3 "prove") ; 
-  Send = mkTransVerbDir (verbNoPart (mkVerb "send" "sent" "sent")) ;
-  Love = mkTransVerbDir (verbNoPart (verbP3e "love")) ;
-  Wait = mkTransVerb (verbNoPart (regVerbP3 "wait")) "for" ;
-  Give = mkDitransVerb (verbNoPart (mkVerb "give" "gave" "given")) [] [] ;
-  Prefer = mkDitransVerb 
-    (verbNoPart (mkVerb "prefer" "preferred" "preferred")) [] "to" ;
-  Mother = funOfReg "mother" Hum ;
-  Uncle = funOfReg "uncle" Hum ;
-  Connection = cnNoHum (nounReg "connection") ** {s2 = "from" ; s3 = "to"} ;
-
-  Always = advPre "always" ;
-  Well = advPost "well" ;
-
-  SwitchOn  = mkTransVerbPart (verbP3s "switch") "on" ;
-  SwitchOff = mkTransVerbPart (verbP3s "switch") "off" ;
-
-  John = nameReg "John" ;
-  Mary = nameReg "Mary" ;
-
-} ;
diff --git a/grammars/resource/english/Types.gf b/grammars/resource/english/Types.gf
deleted file mode 100644
index ad96db43b..000000000
--- a/grammars/resource/english/Types.gf
+++ /dev/null
@@ -1,101 +0,0 @@
---1 English Word Classes and Morphological Parameters
---
--- This is a resource module for English morphology, defining the
--- morphological parameters and word classes of English. It is aimed
--- to be complete w.r.t. the description of word forms.
--- However, it only includes those parameters that are needed for
--- analysing individual words: such parameters are defined in syntax modules.
---
--- We use the language-independent prelude.
-
-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 = NoHum | Hum ;
-  Case   = Nom | Gen ;
-  Person = P1 | P2 | P3 ;
-  Degree = Pos | Comp | Sup ;
-
--- For data abstraction, we define
-
-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 often hierarchical. The alternative would be cross-products of
--- simple parameters, but this would usually overgenerate.
---
-
---3 Common nouns
---
--- Common nouns are inflected in number and case.
-
-  CommonNoun : Type = {s : Number => Case => Str} ;
-
-
---
---3 Adjectives
---
--- The major division is between the comparison degrees, but it
--- is also good to leave room for adjectives that cannon be compared.
--- Such adjectives are simply strings.
-
-  Adjective : Type = SS ;
-  AdjDegr = SS1 Degree ;
-
---3 Verbs
---
--- We treat the full conjugation now.
--- The present tense is made to depend on person, which correspond to forms
--- in the singular; plural forms are uniformly equal to the 2nd person singular.
-
-param
-  VForm = InfImp | Indic Person | Past Number | PPart ;
-
-oper
-  VerbP3 : Type = SS1 VForm ;
-
--- A full verb can moreover have a particle.
-
-  Particle : Type = Str ;
-  Verb = VerbP3 ** {s1 : Particle} ; 
-
---
---3 Pronouns
---
--- For pronouns, we need four case forms: "I" - "me" - "my" - "mine".
-
-param
-  NPForm = NomP | AccP | GenP | GenSP ; 
-
-oper
-  Pronoun  : Type = {s : NPForm => Str ; n : Number ; p : Person} ;
-
--- Coercions between pronoun cases and ordinaty cases.
-
-  toCase  : NPForm -> Case = \c -> case c of {GenP => Gen ; _ => Nom} ;
-  toNPForm : Case -> NPForm = \c -> case c of {Gen  => GenP ; _ => NomP} ; ---
-
---3 Proper names
---
--- Proper names only need two cases.
-
-  ProperName : Type = SS1 Case ;
-
---3 Relative pronouns
---
--- Relative pronouns are inflected in gender (human/nonhuman), number, and case.
-
-  RelPron : Type = {s : Gender => Number => NPForm => Str} ;
-} ;
-