oops

(Ger) Corrections in Cat, Irreg, Lexicon ; added QVP in Question and GenIP, GenModIP in Extend

.envrc

@@ -0,0 +1 @@
+use flake

.github/workflows/release.yml

@@ -8,19 +8,26 @@ on:
 
 jobs:
   build:
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-24.04
     env:
-      GF_VERSION: 3.10-1
+      GF_VERSION: 3.12
       DEST: gf-rgl-${{ github.event.inputs.tag  }}
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
+
+    - name: Download GF
+      uses: dsaltares/fetch-gh-release-asset@1.1.1
+      with:
+        repo: 'GrammaticalFramework/gf-core'
+        version: 'tags/release-${{ env.GF_VERSION }}'
+        file: 'gf-${{ env.GF_VERSION }}-ubuntu-24.04.deb'
+        token: ${{ secrets.GITHUB_TOKEN }}
 
     - name: Install GF
       run: |
-        curl -s https://www.grammaticalframework.org/download/gf_${GF_VERSION}_amd64.deb -o gf.deb
+        sudo dpkg -i gf-${GF_VERSION}-ubuntu-24.04.deb
-        sudo dpkg -i gf.deb
 
     - name: Build RGL
       run: |

.github/workflows/test.yml

@@ -0,0 +1,33 @@
+name: Check that the RGL can successfully build
+
+on:
+  - push
+  - pull_request
+
+jobs:
+  build:
+    runs-on: ubuntu-24.04
+    env:
+      GF_VERSION: 3.12
+      DEST: gf-rgl
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+
+    - name: Download GF
+      uses: dsaltares/fetch-gh-release-asset@1.1.1
+      with:
+        repo: 'GrammaticalFramework/gf-core'
+        version: 'tags/release-${{ env.GF_VERSION }}'
+        file: 'gf-${{ env.GF_VERSION }}-ubuntu-24.04.deb'
+        token: ${{ secrets.GITHUB_TOKEN }}
+
+    - name: Install GF
+      run: |
+        sudo dpkg -i gf-${GF_VERSION}-ubuntu-24.04.deb
+
+    - name: Build RGL
+      run: |
+        mkdir -p ${DEST}
+        bash Setup.sh --dest=${DEST} --gf=gf --verbose

.gitignore

@@ -4,3 +4,16 @@ dist/
 *.o
 *.pgf
 *.tmp
+*~
+.direnv
+_grphp_*.dot
+_grphp_*.png
+_grpht_*.dot
+_grpht_*.png
+_gftmp
+t.dot
+t.dot.png
+u.dot.png
+t.dot.*.png
+u.dot.*.png
+u.dot

.travis.yml

@@ -4,7 +4,7 @@ language: c
 os:
   - linux
   - osx
-  - windows
+#  - windows
 
 addons:
   apt:

Config.hs

@@ -25,6 +25,7 @@ data LangInfo = LangInfo
   , langSymbolic :: Bool
   , langCompatibility :: Bool
   , langSynopsis :: Bool -- ^ include in RGL synopsis
+  , langMorphodict :: Bool
   } deriving (Show,Eq)
 
 -- | Load language information from default config file
@@ -55,6 +56,7 @@ loadLangsFrom configFile = do
             , langSymbolic = boolBit bits 8 True
             , langCompatibility = boolBit bits 9 False
             , langSynopsis = boolBit bits 10 False
+            , langMorphodict = boolBit bits 11 False
             }
 
 -- | Separate a string on a character

Makefile

@@ -1,16 +1,34 @@
-# A simple wrapper over the Haskell-based RGL build script
+# A wrapper over the Haskell and Bash build scripts
+# Will try and fallback in order:
+#   - runghc Setup.hs
+#   - stack runghc Setup.hs
+#   - ./Setup.sh
 
-RUNMAKE=runghc Setup.hs
+ifneq (, $(shell which runghc))
+RUNGHC=runghc Setup.hs
+else ifneq (, $(shell which stack))
+RUNGHC=stack runghc Setup.hs
+else
+RUNGHC=
+endif
 
 .PHONY: build copy install doc clean
 
 default: build copy
 
 build: src/*/*.gf
-	$(RUNMAKE) build
+ifneq (, $(RUNGHC))
+	$(RUNGHC) build
+	$(RUNGHC) build morphodict
+else
+	./Setup.sh
+endif
 
 copy:
-	$(RUNMAKE) copy
+ifneq (, $(RUNGHC))
+	$(RUNGHC) copy
+	$(RUNGHC) copy morphodict
+endif
 
 install: build copy
 
@@ -18,4 +36,8 @@ doc: build
 	make -C doc GF_LIB_PATH=../dist
 
 clean:
-	$(RUNMAKE) clean
+ifneq (, $(RUNGHC))
+	$(RUNGHC) clean
+else
+	rm -r dist
+endif

README.md

@@ -2,8 +2,6 @@
 
 # GF Resource Grammar Library (RGL)
 
-[![Build Status](https://travis-ci.org/GrammaticalFramework/gf-rgl.svg?branch=master)](https://travis-ci.org/GrammaticalFramework/gf-rgl)
-
 The GF Resource Grammar Library is the standard library for Grammatical Framework. It covers the morphology and basic syntax of over 30 languages.
 
 For more about the RGL, see the [synopsis page](http://www.grammaticalframework.org/lib/doc/synopsis/).
@@ -47,12 +45,7 @@ This file should be kept up-to-date and all build methods should read this confi
 
 If default is `y` then anything other than `n`, including the empty string, is treated as true (and vice versa when default is `n`).
 
-## Haskell script: `Setup.hs`
+## Using Make
-
-This build method gives you most options.
-You will need Haskell installed on your system.
-
-### Basic
 
 If you have `Make` installed and don't care about advanced settings,
 you can compile the RGL and install it to the default location with:
@@ -64,9 +57,15 @@ make install
 This is the same as `make build` followed by `make copy`.
 There is also `make clean` available.
 
-### Advanced
+The Makefile will try to use the Haskell install script,
+falling back to the shell script if you do not have Haskell installed.
 
-For more fine-grained control over the build process, you can run the build script directly:
+## Haskell script: `Setup.hs`
+
+This build method gives you most options.
+You will need Haskell installed on your system.
+
+Run the build script with:
 
 ```
 runghc Setup.hs ...

Setup.bat

@@ -37,20 +37,6 @@ if "%dest%"=="" (
 )
 :BreakLibPath
 
-set DATA_DIR=..\gf-core\DATA_DIR
-if "%dest%"=="" (
-  REM Look in already compiled GF folder
-  if exist %DATA_DIR% (
-    for /f "delims=" %%x in (%DATA_DIR%) do (
-      if not "%%x"=="" (
-        set dest=%%x\lib
-        goto BreakDataDir
-      )
-    )
-  )
-)
-:BreakDataDir
-
 if "%dest%"=="" (
   echo Unable to determine where to install the RGL. Please do one of the following:
   echo  - Pass the --dest=... flag to this script

Setup.hs

@@ -1,4 +1,4 @@
-{-# LANGUAGE CPP #-}
+{-# LANGUAGE CPP, LambdaCase #-}
 
 -- | Main build script for RGL
 
@@ -8,8 +8,8 @@ import System.IO (hPutStrLn,stderr)
 import System.IO.Error (catchIOError)
 import System.Exit (ExitCode(..),exitFailure)
 import System.Environment (getArgs,lookupEnv)
-import System.Process (rawSystem)
+import System.Process (rawSystem,readProcess)
-import System.FilePath ((</>),splitSearchPath) -- ,takeFileName,addExtension,dropExtension)
+import System.FilePath ((</>),splitSearchPath)
 import System.Directory (createDirectoryIfMissing,copyFile,getDirectoryContents,removeDirectoryRecursive,findFile)
 #if __GLASGOW_HASKELL__>=800
 import System.Directory (getModificationTime,setModificationTime)
@@ -61,7 +61,7 @@ errLocation = unlines $
   [ "Unable to determine where to install the RGL. Please do one of the following:"
   , " - Pass the " ++ destination_flag ++ "... flag to this script"
   , " - Set the GF_LIB_PATH environment variable"
-  , " - Compile & install GF from the gf-core repository (must be in same directory as gf-rgl)"
+  , " - Compile & install GF from the gf-core repository"
   ]
 
 -- | Copy single file between directories
@@ -116,10 +116,11 @@ data Info = Info
 mkInfo :: IO Info
 mkInfo = do
   args <- getArgs
+  let gf = maybe default_gf id (getFlag gf_flag args)
   -- Look for install location in a few different places
   let mflag = getFlag destination_flag args
-  mbuilt <- catchIOError (readFile "../gf-core/DATA_DIR" >>= \d -> return (Just (d </> "lib"))) (\e -> return Nothing)
   menvar <- lookupEnv "GF_LIB_PATH" >>= return . fmap (head . splitSearchPath)
+  mbuilt <- catchIOError (readProcess gf ["--version"] "" >>= return . getPath) (\e -> return Nothing)
   let
     inst_dir =
       case catMaybes [mflag,menvar,mbuilt] of
@@ -129,12 +130,18 @@ mkInfo = do
   return $ Info
     { infoBuildDir = "dist"
     , infoInstallDir = inst_dir
-    , infoGFPath = maybe default_gf id (getFlag gf_flag args)
+    , infoGFPath = gf
     , infoVerbose = verbose
     }
   where
     default_gf = "gf"
 
+    getPath s =
+      let l = last (lines s)
+      in if take 14 l == "Shared folder:"
+           then Just (drop 15 l </> "lib")
+           else Nothing
+
 getRGLBuildDir :: Info -> Mode -> FilePath
 getRGLBuildDir info mode = infoBuildDir info </> getRGLBuildSubDir mode
 
@@ -143,11 +150,12 @@ getRGLBuildSubDir mode =
   case mode of
     Present   -> "present"
     AllTenses -> "alltenses"
+    MorphoDict -> "morphodict"
 
 -------------------------------------------------------------------------------
 -- Build modes
 
-data Mode = Present | AllTenses
+data Mode = Present | AllTenses | MorphoDict
   deriving (Show,Eq)
 
 all_modes :: [String]
@@ -180,6 +188,7 @@ rglCommands =
   , RGLCommand "lang"    False $ gfcp [l,s]
   , RGLCommand "api"     False $ gfcp [t,sc]
   , RGLCommand "compat"  False $ gfcp [c]
+  , RGLCommand "morphodict" False $ gfcp [m]
 
   -- Special command, invoked when command ends in .gf
   , RGLCommand "modules"  False $ \modes args bi ->  do
@@ -216,14 +225,20 @@ rglCommands =
     s mode args = (symbol,optml mode langTry args)
     c mode args = (compat,optml AllTenses langCompatibility args)
     t mode args = (try,optml mode langTry args)
+    m mode args = (morphodict,optml mode langMorphodict args)
     sc mode args = (symbolic,optml mode langSymbolic args)
 
     optml :: Mode -> (LangInfo -> Bool) -> [String] -> ([LangInfo] -> [LangInfo])
     optml mode pred args =
       \langsAll ->
-        let langsDefault = filter (if mode == Present then langPresent else const True) (filter pred langsAll)
+        let langsDefault = filter (mode2langinfo mode) (filter pred langsAll)
         in  getOptLangs langsAll langsDefault args
 
+    mode2langinfo = \case
+      Present    -> langPresent
+      MorphoDict -> langMorphodict
+      _          -> const True
+
 -------------------------------------------------------------------------------
 -- Getting module paths/names
 
@@ -253,6 +268,9 @@ syntax l = sourceDir </> "api" </> ("Syntax" ++ langCode l ++ ".gf")
 symbolic :: LangInfo -> FilePath
 symbolic l = sourceDir </> "api" </> ("Symbolic" ++ langCode l ++ ".gf")
 
+morphodict :: LangInfo -> FilePath
+morphodict l = sourceDir </> "morphodict" </> ("MorphoDict" ++ langCode l ++ ".gf")
+
 -------------------------------------------------------------------------------
 -- Argument helpers
 
@@ -295,8 +313,9 @@ getOptMode args =
     else explicit_modes
   where
     explicit_modes =
-      [Present|have "present"]++
+      [Present | have "present"] ++
-      [AllTenses|have "alltenses"]
+      [AllTenses | have "alltenses"] ++
+      [MorphoDict | have "morphodict"]
     have mode = mode `elem` args
 
 -- | List of languages overriding the default definitions
@@ -359,8 +378,8 @@ gfcn :: Info -> Mode -> String -> [FilePath] -> IO ()
 gfcn bi mode summary files = do
   let dir = getRGLBuildDir bi mode
       preproc = case mode of
-                  Present   -> "--preproc=mkPresent"
+                  Present -> "--preproc=mkPresent"
-                  AllTenses -> ""
+                  _       -> ""
   createDirectoryIfMissing True dir
   if length files > 0
   then do

Setup.sh

@@ -38,15 +38,15 @@ done
 if [ -z "$dest" ]; then
   dest=$(echo "$GF_LIB_PATH" | sed 's/:.*$//')
 fi
-if [ -z "$dest" ] && [ -f "../gf-core/DATA_DIR" ]; then
+if [ -z "$dest" ] && [ "$(gf --version | tail -1 | cut -c -14)" == "Shared folder:" ]; then
-  dest=$(cat ../gf-core/DATA_DIR)
+  dest=$(gf --version | tail -1 | cut -c 16-)
   if [ -n "$dest" ]; then dest="${dest}/lib"; fi
 fi
 if [ -z "$dest" ]; then
   echo "Unable to determine where to install the RGL. Please do one of the following:"
   echo " - Pass the --dest=... flag to this script"
   echo " - Set the GF_LIB_PATH environment variable"
-  echo " - Compile & install GF from the gf-core repository (must be in same directory as gf-rgl)"
+  echo " - Compile & install GF from the gf-core repository"
   exit 1
 fi
 
@@ -59,6 +59,7 @@ gfc="${gf} --batch --quiet --gf-lib-path=${dist}"
 mkdir -p "${dist}/prelude"
 mkdir -p "${dist}/present"
 mkdir -p "${dist}/alltenses"
+mkdir -p "${dist}/morphodict"
 
 # Build: prelude
 echo "Building [prelude]"
@@ -68,10 +69,12 @@ ${gfc} --gfo-dir="${dist}"/prelude "${src}"/prelude/*.gf
 # Gather all language modules for building
 modules_present=
 modules_alltenses=
+modules_morphodict=
 for lang in $langs; do
   for mod in $modules_langs $modules_api; do
     if [ $mod == "Compatibility" ] && [[ "$langs_compat" != *"$lang"* ]]; then continue; fi
     if [ $mod == "Try" ] && [[ "$langs_try" != *"$lang"* ]]; then continue; fi
+    if [ $mod == "Symbol" ] && [[ "$langs_try" != *"$lang"* ]]; then continue; fi
     if [ $mod == "Symbolic" ] && [[ "$langs_symbolic" != *"$lang"* ]]; then continue; fi
     for file in "${src}"/*/"${mod}${lang}".gf; do
       if [ ! -f "$file" ]; then continue; fi
@@ -79,8 +82,12 @@ for lang in $langs; do
       modules_alltenses="${modules_alltenses} ${file}"
     done
   done
+  file="${src}/morphodict/MorphoDict${lang}.gf"
+  if [ ! -f "$file" ]; then continue; fi
+  modules_morphodict="${modules_morphodict} ${file}"
 done
 
+
 # Build: present
 echo "Building [present]"
 if [ $verbose = true ]; then echo $modules_present; fi
@@ -95,6 +102,15 @@ for module in $modules_alltenses; do
   ${gfc} --no-pmcfg --gfo-dir="${dist}"/alltenses "${module}"
 done
 
+# Build: morphodict
+echo "Building [morphodict]"
+if [ $verbose = true ]; then echo $modules_morphodict; fi
+for module in $modules_morphodict; do
+  ${gfc} --no-pmcfg --gfo-dir="${dist}"/morphodict "${module}"
+done
+
 # Copy
+if [ $dest == $dist ]; then exit 0; fi
 echo "Copying to ${dest}"
+mkdir -p "${dest}"
 cp -R "${dist}"/* "${dest}"

doc/missing-in-rgl-Grammar.tsv

@@ -0,0 +1,371 @@
+fun	type	Afr	Amh	Grc	Ara	Eus	Bul	Cat	Chi	Hrv	Cze	Dan	Dut	Gus	Eng	Est	Fin	Fre	Ger	Gre	Heb	Hin	Hun	Ice	Ina	Ita	Jpn	Kam	Kor	Lat	Lav	Lit	May	Mlt	Mon	Nep	Nor	Nno	Pes	Pol	Por	Pnb	Ron	Cgg	Rus	Snd	Slo	Slv	Som	Spa	Swa	Swe	Tam	Tel	Tha	Tur	Ukr	Urd	Zul
+AAnter	Ant	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	-	+	+
+ASimul	Ant	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+
+AdAP	AdA -> AP -> AP	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+
+AdAdv	AdA -> Adv -> Adv	+	+	-	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	-	-	+	+	+	+	-	+	+	+	-	+	+
+AdNum	AdN -> Card -> Card	+	-	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	-	+	+	+	-	-	+	+	+	+	+
+AdVVP	AdV -> VP -> VP	+	-	+	+	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	-	+	-	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	-	+	-	+	-	+	+	+	-	+	+
+AdVVPSlash	AdV -> VPSlash -> VPSlash	-	-	-	+	+	+	+	+	-	-	+	-	-	+	-	+	+	+	+	-	+	-	+	-	+	+	-	+	+	-	-	-	+	+	+	+	+	-	-	+	-	-	+	+	-	-	-	-	+	-	+	-	+	-	-	-	+	+
+AddAdvQVP	QVP -> IAdv -> QVP	-	-	-	+	-	-	+	-	-	-	+	-	+	+	-	-	+	-	+	+	-	-	+	-	+	+	+	-	-	-	-	-	+	+	+	+	+	-	-	+	-	-	-	-	-	-	-	-	+	-	+	-	+	-	-	-	-	+
+AdjCN	AP -> CN -> CN	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+
+AdjDAP	DAP -> AP -> DAP	-	-	-	-	+	+	+	-	-	-	+	-	+	+	+	-	+	-	-	-	-	-	+	-	+	+	+	-	-	-	-	-	-	-	-	+	+	-	-	+	-	-	+	+	-	-	-	-	+	+	+	-	-	-	+	-	-	+
+AdjOrd	Ord -> AP	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	+	-	+	+	+	+	+	+
+AdnCAdv	CAdv -> AdN	+	-	-	+	-	+	+	+	+	-	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	-	-	-	+	+	+	-	+	+	+	+	+	+
+AdvAP	AP -> Adv -> AP	-	-	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	-	+	+	+	-	+	+	-	+	+	+	+	+	+	+	-	+	-	-	-	+	-	+	+	-	+	+	+	-	+	-	+	+	+	+
+AdvCN	CN -> Adv -> CN	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	-	-	+	+	+	+	+
+AdvIAdv	IAdv -> Adv -> IAdv	+	-	-	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	-	-	-	+	-	+	-	+	+	+	-	+	+
+AdvIP	IP -> Adv -> IP	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	-	-	-	+	-	+	-	+	+	+	-	+	+
+AdvImp	Adv -> Imp -> Imp	-	-	-	-	-	+	+	-	-	-	+	-	-	+	-	-	+	-	-	-	-	-	-	-	+	-	-	-	-	-	-	-	-	-	-	+	+	-	-	+	-	-	-	-	-	-	-	-	+	-	+	-	+	-	-	-	-	+
+AdvNP	NP -> Adv -> NP	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	-	-	+	+	+	+	+
+AdvQVP	VP -> IAdv -> QVP	-	-	-	+	-	-	+	-	-	-	+	-	+	+	-	-	+	-	+	+	-	-	+	-	+	+	+	-	-	-	-	-	+	+	+	+	+	-	-	+	-	-	-	-	-	-	-	-	+	-	+	-	+	-	-	-	-	+
+AdvS	Adv -> S -> S	+	+	+	+	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	-	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	-	+	+	+	-	+	-	+	+	+	-	+	+
+AdvSlash	ClSlash -> Adv -> ClSlash	+	-	-	+	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	-	+	-	+	+	+	+	-	-	-	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	-	-	-	+	-	+	-	+	+	+	-	+	+
+AdvVP	VP -> Adv -> VP	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	-	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	+
+AdvVPSlash	VPSlash -> Adv -> VPSlash	-	-	-	-	+	+	+	+	-	-	+	-	-	+	+	+	+	+	+	-	+	+	+	-	+	+	-	+	+	-	-	-	+	+	+	+	+	-	-	+	-	-	+	+	-	-	-	+	+	-	+	-	+	-	-	-	+	+
+ApposCN	CN -> NP -> CN	+	+	-	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	-	+	+	+	+	+	+	-	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	-	+	-	-	+	+	+	+	+
+BaseAP	AP -> AP -> ListAP	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+
+BaseAdV	AdV -> AdV -> ListAdV	-	-	-	-	+	+	-	-	-	-	-	-	+	+	+	+	-	-	-	+	-	+	+	-	-	+	+	+	-	-	-	-	+	-	-	-	-	-	-	-	-	-	-	+	-	-	-	-	-	+	-	-	+	-	+	-	-	+
+BaseAdv	Adv -> Adv -> ListAdv	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	+	-	-	+	+	+	-	+	+	+	+	+	+
+BaseCN	CN -> CN -> ListCN	-	-	+	+	+	+	+	+	-	-	+	-	+	+	+	+	+	+	+	+	-	-	+	-	+	+	+	-	-	-	-	-	+	+	-	+	+	+	-	+	-	-	-	+	-	-	-	-	+	+	+	-	+	-	+	-	-	+
+BaseDAP	DAP -> DAP -> ListDAP	-	-	-	-	+	-	-	-	-	-	+	-	+	+	-	-	-	-	-	+	-	-	+	-	-	+	+	-	-	-	-	-	-	-	-	+	+	-	-	-	-	-	-	+	-	-	-	-	-	+	+	-	+	-	-	-	-	+
+BaseIAdv	IAdv -> IAdv -> ListIAdv	-	-	-	-	+	+	+	-	-	-	+	-	+	+	+	+	+	-	+	+	-	+	+	-	+	+	+	+	-	-	-	-	+	+	-	+	+	-	-	+	-	-	-	+	-	-	-	-	+	+	+	-	+	-	-	-	-	+
+BaseNP	NP -> NP -> ListNP	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+BaseRS	RS -> RS -> ListRS	+	-	-	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	+	-	-	+	+	+	-	+	+	+	+	+	+
+BaseS	S -> S -> ListS	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	+	-	-	+	+	+	-	+	+	+	+	+	+
+CAdvAP	CAdv -> AP -> NP -> AP	+	+	-	-	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	-	-	-	+	+	+	-	+	+	+	-	+	+
+CleftAdv	Adv -> S -> Cl	+	-	+	+	-	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	-	-	-	+	-	+	-	+	+	+	-	+	+
+CleftNP	NP -> RS -> Cl	+	-	+	-	-	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	-	-	-	+	-	+	-	+	+	+	-	+	+
+CompAP	AP -> Comp	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	-	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	+
+CompAdv	Adv -> Comp	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	-	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	+
+CompCN	CN -> Comp	+	-	+	+	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	-	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	-	+	-	+	+	+	-	+	+
+CompIAdv	IAdv -> IComp	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	-	+	-	+	+	+	-	+	+
+CompIP	IP -> IComp	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	-	+	-	+	+	+	-	+	+
+CompNP	NP -> Comp	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	-	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	+
+ComparA	A -> NP -> AP	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	-	-	+	+	+	+	-	+	+	+	+	+	+
+ComparAdvAdj	CAdv -> A -> NP -> Adv	+	+	+	-	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	-	-	-	+	+	+	-	+	+	+	-	+	+
+ComparAdvAdjS	CAdv -> A -> S -> Adv	+	-	-	-	-	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	-	-	-	+	+	+	-	+	+	+	-	+	+
+ComplA2	A2 -> NP -> AP	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	+	-	-	+	+	+	-	+	+	+	+	+	+
+ComplN2	N2 -> NP -> CN	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	+	-	-	+	+	-	+	+
+ComplN3	N3 -> NP -> N2	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	-	+	+	+	-	-	+	+	-	+	+
+ComplSlash	VPSlash -> NP -> VP	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	+
+ComplSlashIP	VPSlash -> IP -> QVP	-	-	-	+	-	-	+	-	-	-	+	-	+	+	-	-	+	-	+	+	-	-	+	-	+	+	+	-	-	-	-	-	+	+	+	+	+	-	-	+	-	-	-	-	-	-	-	-	+	-	+	-	+	-	-	-	-	+
+ComplVA	VA -> AP -> VP	+	+	+	+	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	-	+	-	+	+	+	+	-	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	-	+	-	+	-	+	+	+	-	+	+
+ComplVQ	VQ -> QS -> VP	+	-	+	+	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	-	+	-	+	+	+	+	-	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	-	+	-	+	-	+	+	+	-	+	+
+ComplVS	VS -> S -> VP	+	-	+	+	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	-	+	-	+	+	+	+	-	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	-	+	-	+	+	+	-	+	+
+ComplVV	VV -> VP -> VP	+	+	+	+	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	-	+	-	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	-	+	-	+	+	+	-	+	+
+ConjAP	Conj -> ListAP -> AP	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+
+ConjAdV	Conj -> ListAdV -> AdV	-	-	-	-	+	+	-	-	-	-	-	-	+	+	+	+	-	-	-	+	-	+	+	-	-	+	+	+	-	-	-	-	+	-	-	-	-	-	-	-	-	-	-	+	-	-	-	-	-	+	-	-	+	-	+	-	-	+
+ConjAdv	Conj -> ListAdv -> Adv	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	+	-	-	+	+	+	-	+	+	+	+	+	+
+ConjCN	Conj -> ListCN -> CN	-	-	+	+	+	+	+	+	-	-	+	-	+	+	+	+	+	+	+	+	-	-	+	-	+	+	+	-	-	-	-	-	+	+	-	+	+	+	-	+	-	-	-	+	-	-	-	-	+	+	+	-	+	-	+	-	-	+
+ConjDet	Conj -> ListDAP -> Det	-	-	-	-	+	-	-	-	-	-	+	-	+	+	-	-	-	-	-	+	-	-	+	-	-	+	+	-	-	-	-	-	-	-	-	+	+	-	-	-	-	-	-	+	-	-	-	-	-	+	+	-	+	-	-	-	-	+
+ConjIAdv	Conj -> ListIAdv -> IAdv	-	-	-	-	+	+	+	-	-	-	+	-	+	+	+	+	+	-	+	+	-	+	+	-	+	+	+	+	-	-	-	-	+	+	-	+	+	-	-	+	-	-	-	+	-	-	-	-	+	+	+	-	+	-	-	-	-	+
+ConjNP	Conj -> ListNP -> NP	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+ConjRS	Conj -> ListRS -> RS	+	-	-	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	+	-	-	+	+	+	-	+	+	+	+	+	+
+ConjS	Conj -> ListS -> S	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	+	-	-	+	+	+	-	+	+	+	+	+	+
+ConsAP	AP -> ListAP -> ListAP	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+
+ConsAdV	AdV -> ListAdV -> ListAdV	-	-	-	-	+	+	-	-	-	-	-	-	+	+	+	+	-	-	-	+	-	+	+	-	-	+	+	+	-	-	-	-	+	-	-	-	-	-	-	-	-	-	-	+	-	-	-	-	-	+	-	-	+	-	+	-	-	+
+ConsAdv	Adv -> ListAdv -> ListAdv	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	+	-	-	+	+	+	-	+	+	+	+	+	+
+ConsCN	CN -> ListCN -> ListCN	-	-	+	+	+	+	+	+	-	-	+	-	+	+	+	+	+	+	+	+	-	-	+	-	+	+	+	-	-	-	-	-	+	+	-	+	+	+	-	+	-	-	-	+	-	-	-	-	+	+	+	-	+	-	+	-	-	+
+ConsDAP	DAP -> ListDAP -> ListDAP	-	-	-	-	+	-	-	-	-	-	+	-	+	+	-	-	-	-	-	+	-	-	+	-	-	+	+	-	-	-	-	-	-	-	-	+	+	-	-	-	-	-	-	+	-	-	-	-	-	+	+	-	+	-	-	-	-	+
+ConsIAdv	IAdv -> ListIAdv -> ListIAdv	-	-	-	-	+	+	+	-	-	-	+	-	+	+	+	+	+	-	+	+	-	+	+	-	+	+	+	+	-	-	-	-	+	+	-	+	+	-	-	+	-	-	-	+	-	-	-	-	+	+	+	-	+	-	-	-	-	+
+ConsNP	NP -> ListNP -> ListNP	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+ConsRS	RS -> ListRS -> ListRS	+	-	-	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	+	-	-	+	+	+	-	+	+	+	+	+	+
+ConsS	S -> ListS -> ListS	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	+	-	-	+	+	+	-	+	+	+	+	+	+
+CountNP	Det -> NP -> NP	-	-	-	-	+	+	+	+	-	-	+	-	+	+	-	+	+	-	+	-	+	-	+	-	+	+	+	-	+	-	-	+	+	-	-	+	+	-	-	+	-	-	+	+	-	-	-	-	+	+	+	-	-	-	+	-	+	+
+D_0	Dig	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+D_1	Dig	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+D_2	Dig	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+D_3	Dig	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+D_4	Dig	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+D_5	Dig	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+D_6	Dig	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+D_7	Dig	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+D_8	Dig	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+D_9	Dig	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+DefArt	Quant	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+
+DetCN	Det -> CN -> NP	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+
+DetDAP	Det -> DAP	-	-	-	-	+	+	+	-	-	-	+	+	+	+	+	+	+	+	-	-	-	-	+	-	+	+	+	-	-	-	+	-	-	-	-	+	+	-	+	+	-	-	+	+	-	-	-	-	+	+	+	-	-	-	+	-	-	+
+DetNP	Det -> NP	+	+	-	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	-	+	+	+	+	+
+DetQuant	Quant -> Num -> Det	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+
+DetQuantOrd	Quant -> Num -> Ord -> Det	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	+	-	-	+	+	-	+	+
+EmbedQS	QS -> SC	+	-	-	+	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	-	+	-	+	+	+	+	-	-	-	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	-	-	-	+	-	+	-	+	+	+	-	+	+
+EmbedS	S -> SC	+	-	+	+	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	-	+	-	+	+	+	+	-	+	-	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	-	-	+	+	-	+	-	+	+	+	-	+	+
+EmbedVP	VP -> SC	+	+	-	+	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	-	+	-	+	+	+	+	-	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	-	+	-	+	+	+	-	+	+
+ExistIP	IP -> QCl	+	-	+	+	-	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	-	-	-	+	-	+	-	+	+	+	-	+	+
+ExistIPAdv	IP -> Adv -> QCl	-	-	+	-	-	+	-	-	-	-	-	-	+	+	-	+	-	+	-	+	-	-	+	-	-	+	+	-	+	-	-	-	+	+	-	-	-	-	-	+	-	-	-	+	-	-	-	-	+	-	+	-	+	-	-	-	-	+
+ExistNP	NP -> Cl	+	-	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	-	+	+	+	-	+	-	+	+	+	+	+	+
+ExistNPAdv	NP -> Adv -> Cl	-	-	+	+	-	+	-	-	+	-	-	-	+	+	-	+	+	+	-	+	-	-	+	-	+	+	+	-	+	-	-	-	+	+	-	-	-	+	-	+	-	-	-	+	-	-	-	-	+	-	+	-	+	-	-	+	-	+
+ExtAdvNP	NP -> Adv -> NP	-	-	-	-	+	+	+	+	-	-	+	+	+	+	-	+	+	+	-	-	-	+	+	-	+	+	+	-	+	-	-	+	+	-	-	+	+	-	-	+	-	-	+	+	-	-	-	-	+	+	+	-	-	-	+	-	-	+
+ExtAdvS	Adv -> S -> S	-	-	-	-	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	-	+	+	+	-	+	+	-	+	-	-	+	+	+	+	-	+	+	-	+	+	-	+	+	+	-	-	+	+	+	-	+	-	+	+	-	-	+	+
+ExtAdvVP	VP -> Adv -> VP	-	-	-	-	+	+	+	+	-	-	+	+	-	+	-	+	+	+	-	-	-	-	+	-	+	+	-	-	-	-	-	-	+	-	-	+	+	-	-	+	-	-	-	+	-	-	-	-	+	-	+	-	+	-	-	-	-	+
+FunRP	Prep -> NP -> RP -> RP	+	-	-	-	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	-	+	-	+	-	+	-	+	+	+	-	+	+
+GenericCl	VP -> Cl	+	-	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	-	-	+	+	-	+	-	+	+	+	-	+	+
+IDig	Dig -> Digits	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+IIDig	Dig -> Digits -> Digits	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+IdRP	RP	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	+
+IdetCN	IDet -> CN -> IP	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	-	+	-	+	+	+	-	+	+
+IdetIP	IDet -> IP	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	-	+	-	+	+	+	-	+	+
+IdetQuant	IQuant -> Num -> IDet	+	+	-	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	-	-	+	+	-	+	-	+	+	+	-	+	+
+ImpP3	NP -> VP -> Utt	-	-	+	-	-	-	-	-	-	-	-	-	+	+	-	+	+	+	+	+	+	-	+	-	-	+	+	-	+	+	-	-	+	+	+	-	-	+	-	+	+	-	-	+	+	-	-	-	-	-	-	-	+	-	-	-	+	+
+ImpPl1	VP -> Utt	+	-	+	-	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	-	+	-	+	-	+	+	+	-	+	+
+ImpVP	VP -> Imp	+	+	+	+	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	-	+	-	+	+	+	+	-	-	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	-	+	-	+	+	+	-	+	+
+ImpersCl	VP -> Cl	+	-	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	-	-	+	+	-	+	-	+	+	+	-	+	+
+IndefArt	Quant	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+
+MassNP	CN -> NP	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+
+NoPConj	PConj	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+NoVoc	Voc	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+NumCard	Card -> Num	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+
+NumDigits	Digits -> Card	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	-	-	+	+	+	+	+
+NumNumeral	Numeral -> Card	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+
+NumPl	Num	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+
+NumSg	Num	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+
+OrdDigits	Digits -> Ord	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	-	+	+	+	-	-	+	+	-	+	+
+OrdNumeral	Numeral -> Ord	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	+	-	-	+	+	-	+	+
+OrdNumeralSuperl	Numeral -> A -> Ord	-	-	-	-	+	-	+	+	-	-	+	+	+	+	-	+	+	+	-	-	-	-	+	-	+	+	+	-	-	-	-	+	-	-	-	+	+	-	-	+	-	-	+	+	-	-	-	-	+	+	+	-	-	-	+	-	-	+
+OrdSuperl	A -> Ord	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	+	-	-	+	+	+	+	+
+PConjConj	Conj -> PConj	+	-	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	-	+	+	+	+	+	+
+PNeg	Pol	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+
+PPartNP	NP -> V2 -> NP	+	+	-	-	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	-	+	-	+	+	+	+	-	-	-	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	-	+	-	+	-	-	+	+	-	+	+
+PPos	Pol	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+
+PartNP	CN -> NP -> CN	-	-	-	-	+	+	+	+	-	-	+	-	+	+	-	+	+	-	+	-	+	-	+	-	+	+	+	-	-	-	+	-	+	-	-	+	+	-	-	+	-	-	+	+	-	-	-	+	+	+	+	-	-	-	+	-	+	+
+PassV2	V2 -> VP	+	+	+	+	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	-	+	-	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	-	-	+	+	-	+	-	+	+	+	-	+	+
+PhrUtt	PConj -> Utt -> Voc -> Phr	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+PositA	A -> AP	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+PositAdAAdj	A -> AdA	+	-	-	-	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	-	+	+	+	-	+	-	-	-	+	+	-	+	+	-	-	+	-	-	-	+	-	-	-	-	+	+	+	-	+	-	-	-	+	+
+PositAdvAdj	A -> Adv	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	-	-	-	+	+	+	-	+	+	+	-	+	+
+PossNP	CN -> NP -> CN	-	-	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	-	+	+	+	-	-	-	+	+	+	-	-	+	+	+	-	+	-	-	+	+	-	-	-	+	+	+	+	-	-	-	+	-	+	+
+PossPron	Pron -> Quant	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+
+PredSCVP	SC -> VP -> Cl	+	-	+	-	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	-	+	-	+	+	+	+	-	+	-	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	-	-	-	+	-	+	-	+	+	+	-	+	+
+PredVP	NP -> VP -> Cl	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+PredetNP	Predet -> NP -> NP	+	+	-	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	+	-	-	+	+	-	+	+
+PrepIP	Prep -> IP -> IAdv	+	-	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	-	-	+	+	-	+	-	+	+	+	-	+	+
+PrepNP	Prep -> NP -> Adv	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+ProgrVP	VP -> VP	+	-	+	-	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	-	-	+	+	-	+	-	+	+	+	-	+	+
+QuestCl	Cl -> QCl	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	+
+QuestIAdv	IAdv -> Cl -> QCl	+	+	-	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	-	+	-	+	+	+	-	+	+
+QuestIComp	IComp -> NP -> QCl	+	-	-	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	-	+	-	+	+	+	-	+	+
+QuestQVP	IP -> QVP -> QCl	-	-	-	+	-	-	+	-	-	-	+	-	+	+	-	-	+	-	+	+	-	-	+	-	+	+	+	-	-	-	-	-	+	+	+	+	+	-	-	+	-	-	-	-	-	-	-	-	+	-	+	-	+	-	-	-	-	+
+QuestSlash	IP -> ClSlash -> QCl	+	-	-	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	-	+	-	+	+	+	-	+	+
+QuestVP	IP -> VP -> QCl	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	-	+	-	+	+	+	-	+	+
+ReflA2	A2 -> AP	+	-	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	-	-	-	+	+	+	-	+	+	+	-	+	+
+ReflVP	VPSlash -> VP	+	-	+	+	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	-	+	-	+	+	+	+	-	-	-	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	-	+	+	+	-	+	-	+	+	+	-	+	+
+RelCN	CN -> RS -> CN	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	-	-	+	+	+	+	+
+RelCl	Cl -> RCl	+	-	-	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	-	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	-	+	-	+	-	+	+	+	-	+	+
+RelNP	NP -> RS -> NP	+	-	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	+	-	-	+	+	-	+	+
+RelS	S -> RS -> S	+	-	+	-	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	-	+	-	+	+	+	+	-	-	-	-	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	-	-	-	+	-	+	-	+	+	-	-	+	+
+RelSlash	RP -> ClSlash -> RCl	+	-	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	-	+	-	+	+	+	-	+	+
+RelVP	RP -> VP -> RCl	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	+
+SSubjS	S -> Subj -> S -> S	-	+	-	-	+	+	+	+	-	-	+	+	-	+	-	+	+	+	+	-	+	-	+	-	+	+	-	-	-	-	-	-	+	+	+	+	+	+	-	+	+	-	-	+	+	-	-	+	+	-	+	-	+	+	-	-	+	+
+SelfAdVVP	VP -> VP	-	-	+	+	-	-	-	+	-	-	-	-	+	+	-	+	+	+	-	+	-	-	+	-	-	+	+	-	+	-	-	-	+	-	-	-	-	-	-	+	-	-	-	+	-	-	-	-	+	-	+	-	+	-	-	-	-	+
+SelfAdvVP	VP -> VP	-	-	+	+	-	-	-	+	-	-	-	-	+	+	-	+	+	+	-	+	-	-	+	-	-	+	+	-	+	-	-	-	+	-	-	-	-	-	-	+	-	-	-	+	-	-	-	-	+	-	+	-	+	-	-	-	-	+
+SelfNP	NP -> NP	-	-	+	+	-	-	-	+	-	-	-	-	+	+	-	+	+	+	-	+	-	-	+	-	-	+	+	-	+	-	-	-	+	-	-	-	-	-	-	+	-	-	-	+	-	-	-	-	-	-	+	-	+	-	-	-	-	+
+SentAP	AP -> SC -> AP	+	-	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	-	-	+	+	+	+	-	+	+	+	-	+	+
+SentCN	CN -> SC -> CN	+	-	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	+	-	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	-	+	+	+	-	-	+	+	-	+	+
+Slash2V3	V3 -> NP -> VPSlash	+	-	+	+	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	-	+	-	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	-	+	-	+	+	+	-	+	+
+Slash3V3	V3 -> NP -> VPSlash	+	+	+	+	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	-	+	-	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	-	+	-	+	+	+	-	+	+
+SlashPrep	Cl -> Prep -> ClSlash	+	-	+	-	-	+	+	+	-	-	+	+	-	+	+	+	+	+	+	-	+	-	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	-	-	-	+	-	+	-	+	+	+	-	+	+
+SlashV2A	V2A -> AP -> VPSlash	+	-	-	-	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	-	+	-	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	-	-	+	+	-	+	-	+	+	+	-	+	+
+SlashV2Q	V2Q -> QS -> VPSlash	+	-	+	-	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	-	+	-	+	+	+	+	-	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	-	-	-	+	-	+	-	+	+	+	-	+	+
+SlashV2S	V2S -> S -> VPSlash	+	-	+	+	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	-	+	-	+	+	+	+	-	-	-	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	-	-	+	+	-	+	-	+	+	+	-	+	+
+SlashV2V	V2V -> VP -> VPSlash	+	-	+	+	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	-	+	-	+	+	+	+	-	-	-	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	-	-	-	+	-	+	-	+	+	+	-	+	+
+SlashV2VNP	V2V -> NP -> VPSlash -> VPSlash	+	-	+	+	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	-	+	-	+	+	+	+	-	-	-	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	-	-	-	+	-	+	-	+	+	+	-	+	+
+SlashV2a	V2 -> VPSlash	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	+
+SlashVP	NP -> VPSlash -> ClSlash	+	+	+	+	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	-	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	-	+	-	+	+	+	-	+	+
+SlashVS	NP -> VS -> SSlash -> ClSlash	+	-	+	-	-	+	+	+	-	-	+	+	-	+	+	+	+	+	+	-	+	-	+	+	+	+	-	-	-	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	-	-	-	+	-	+	-	+	+	+	-	+	+
+SlashVV	VV -> VPSlash -> VPSlash	+	-	-	+	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	-	+	-	+	+	+	+	-	-	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	-	+	-	+	-	+	+	+	-	+	+
+SubjS	Subj -> S -> Adv	+	-	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	+	-	+	+	+	-	+	+
+TCond	Tense	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	-	+	+
+TEmpty	Text	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+
+TExclMark	Phr -> Text -> Text	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+
+TFullStop	Phr -> Text -> Text	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+
+TFut	Tense	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	-	+	+
+TPast	Tense	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+
+TPres	Tense	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+
+TQuestMark	Phr -> Text -> Text	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+
+TTAnt	Tense -> Ant -> Temp	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+
+Use2N3	N3 -> N2	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	+	-	-	+	+	-	+	+
+Use3N3	N3 -> N2	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	+	-	-	+	-	-	+	+
+UseA2	A2 -> AP	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	-	+	+	+	+	-	+	+	+	+	+	+
+UseCl	Temp -> Pol -> Cl -> S	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+UseComp	Comp -> VP	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	-	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	+
+UseComparA	A -> AP	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+UseCopula	VP	-	-	+	+	+	+	+	+	-	-	+	+	-	+	-	+	+	+	+	-	-	+	+	-	+	+	-	+	+	-	-	+	+	+	-	+	+	-	-	+	-	+	+	+	-	-	-	+	+	-	+	-	+	-	-	-	-	+
+UseN	N -> CN	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+
+UseN2	N2 -> CN	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	+	-	-	+	+	-	+	+
+UsePN	PN -> NP	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+
+UsePron	Pron -> NP	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+
+UseQCl	Temp -> Pol -> QCl -> QS	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	-	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	+
+UseRCl	Temp -> Pol -> RCl -> RS	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	-	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	-	+	-	+	+	+	+	+	+
+UseSlash	Temp -> Pol -> ClSlash -> SSlash	+	-	+	+	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	-	+	-	+	+	+	+	-	-	-	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	-	-	+	+	-	+	-	+	+	+	-	+	+
+UseV	V -> VP	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+UttAP	AP -> Utt	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	+
+UttAdv	Adv -> Utt	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+UttCN	CN -> Utt	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+UttCard	Card -> Utt	+	+	-	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	-	+	-	+	+	+	-	+	+
+UttIAdv	IAdv -> Utt	+	+	-	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	+	+	+	-	+	+
+UttIP	IP -> Utt	+	+	-	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	-	+	-	+	+	+	-	+	+
+UttImpPl	Pol -> Imp -> Utt	+	+	-	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	-	+	-	+	+	+	-	+	+
+UttImpPol	Pol -> Imp -> Utt	+	+	-	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	-	+	-	+	+	+	-	+	+
+UttImpSg	Pol -> Imp -> Utt	+	+	-	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	-	+	-	+	+	+	-	+	+
+UttInterj	Interj -> Utt	-	-	-	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	-	-	-	+	+	-	+	+	-	-	+	-	-	+	+	-	-	+	+	+	+	+	-	+	+	+	-	+	+
+UttNP	NP -> Utt	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+UttQS	QS -> Utt	+	+	-	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	+	+	+	-	+	+
+UttS	S -> Utt	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+UttVP	VP -> Utt	+	+	-	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	-	+	-	+	+	+	-	+	+
+VPSlashPrep	VP -> Prep -> VPSlash	-	-	-	+	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	+	+	-	+	-	+	+	-	-	-	+	-	-	+	+	-	+	+	+	-	+	-	+	-	+	-	-	-	+	+	-	+	-	+	-	-	-	+	+
+VocNP	NP -> Voc	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	-	+	-	+	+	+	+	+	+
+above_Prep	Prep	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	+	-	+	+	+	-	+	+
+active2passive	Cl -> Cl	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+
+after_Prep	Prep	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	-	+	+	+	-	+	+	+	-	+	+
+all_Predet	Predet	+	+	-	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	+	-	+	+	+	-	+	+
+almost_AdA	AdA	+	-	-	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	-	+	+	+	-	+	+	+	-	+	+
+almost_AdN	AdN	+	-	-	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	-	+	+	+	-	+	+	+	-	+	+
+although_Subj	Subj	+	+	+	-	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	-	+	+	+	-	+	+
+always_AdV	AdV	+	+	+	-	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	-	+	+	+	-	+	+	+	-	+	+
+and_Conj	Conj	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+as_CAdv	CAdv	+	+	-	-	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	+	+	-	+	+	+	-	+	+	+	-	+	+	+	-	-	+	+	+	+	+	+	+	+	-	-	-	+	-	+	-	+	+	+	-	+	+
+at_least_AdN	AdN	+	-	-	-	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	-	+	+	+	-	+	+	+	-	+	+	+	-	-	+	+	+	+	+	+	+	+	-	-	-	+	+	+	-	+	+	+	-	+	+
+at_most_AdN	AdN	+	-	-	-	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	-	+	+	+	-	+	+	+	-	+	+	+	-	-	+	+	+	+	+	+	+	+	-	-	-	+	+	+	-	+	+	+	-	+	+
+because_Subj	Subj	+	+	+	-	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	-	+	+	+	-	+	+
+before_Prep	Prep	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	-	+	+	+	-	+	+	+	-	+	+
+behind_Prep	Prep	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	-	+	+	+	-	+	+	+	-	+	+
+between_Prep	Prep	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	+	-	+	+	+	-	+	+
+both7and_DConj	Conj	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	-	+	+	+	-	+	+	+	-	+	+
+but_PConj	PConj	+	+	+	-	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	-	+	+	+	-	+	+	+	-	+	+
+by8agent_Prep	Prep	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	-	+	+	+	-	+	+
+by8means_Prep	Prep	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	-	+	+	+	-	+	+	+	-	+	+
+can8know_VV	VV	+	-	-	-	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	-	+	-	+	+	+	+	-	-	+	+	+	-	+	+	+	+	+	-	+	+	+	+	+	+	+	-	-	+	+	-	+	-	+	+	+	-	+	+
+can_VV	VV	+	-	-	+	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	-	+	-	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	-	+	-	+	+	+	-	+	+
+dconcat	Digits -> Digits -> Digits	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+
+digits2num	Digits -> Numeral	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+
+digits2numeral	Card -> Card	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+
+dn	Dig -> Digit	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+
+dn10	Dig -> Sub10	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+
+dn100	Dig -> Dig -> Sub100	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+
+dn1000	Dig -> Dig -> Dig -> Sub1000	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+
+dn1000000a	Dig -> Dig -> Dig -> Dig -> Sub1000000	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+
+dn1000000b	Dig -> Dig -> Dig -> Dig -> Dig -> Sub1000000	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+
+dn1000000c	Dig -> Dig -> Dig -> Dig -> Dig -> Dig -> Sub1000000	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+
+during_Prep	Prep	+	-	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	-	+	+	+	-	+	+	+	-	+	+
+either7or_DConj	Conj	+	+	+	-	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	+	-	+	+	+	-	+	+
+every_Det	Det	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	-	+	+	+	-	+	+	+	-	+	+
+everybody_NP	NP	+	+	-	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	-	+	+	+	+	-	+	+	+	-	+	+	+	+	+	-	+	+	+	+	+	+	-	-	-	-	+	+	+	-	+	+	+	-	+	+
+everything_NP	NP	+	+	-	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	-	-	-	-	+	+	+	-	+	+	+	-	+	+
+everywhere_Adv	Adv	+	+	+	-	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	-	+	+	+	-	+	+	+	-	+	+
+except_Prep	Prep	+	-	+	-	+	-	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	-	+	+	+	-	+	+	+	-	-	+	+	+	+	+	+	+	+	-	-	-	+	+	+	-	+	+	+	-	+	+
+few_Det	Det	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	-	+	+	+	-	+	+
+for_Prep	Prep	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	-	+	+	+	+	+	+
+from_Prep	Prep	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	-	+	+	+	+	+	+
+have_V2	V2	+	+	-	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	-	+	+	+	-	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	+
+he_Pron	Pron	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+here7from_Adv	Adv	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	-	+	+	+	-	+	+	+	-	+	+
+here7to_Adv	Adv	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	-	+	+	+	-	+	+	+	-	+	+
+here_Adv	Adv	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	-	+	+	+	-	+	+
+how8many_IDet	IDet	+	+	+	+	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	+	+	-	-	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	-	+	-	+	-	+	+	+	-	+	+
+how8much_IAdv	IAdv	+	-	-	+	+	+	+	+	-	-	-	+	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	-	+	+	-	-	+	+	+	-	-	+	-	+	+	+	+	+	+	-	+	-	+	+	+	-	+	+	+	-	+	+
+how_IAdv	IAdv	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	+	-	+	+	+	-	+	+
+i_Pron	Pron	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+if_Subj	Subj	+	-	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	-	+	+	+	-	+	+
+if_then_Conj	Conj	+	-	-	-	+	-	+	+	-	-	+	+	+	+	+	+	+	+	+	-	-	-	+	-	+	+	+	-	+	+	+	-	+	+	+	-	-	+	+	+	+	+	+	+	+	-	-	-	+	+	+	-	+	+	-	-	+	+
+in8front_Prep	Prep	+	+	-	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	+	-	+	+	+	-	+	+
+in_Prep	Prep	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+it_Pron	Pron	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+language_title_Utt	Utt	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	-	-	+	+	+	+	-	+	-	+	-	+	+
+less_CAdv	CAdv	+	+	-	-	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	-	+	-	+	-	+	+	+	-	+	+
+many_Det	Det	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	-	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	-	+	+	+	-	+	+
+more_CAdv	CAdv	+	+	-	-	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	-	+	-	+	-	+	+	+	-	+	+
+most_Predet	Predet	+	+	-	+	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	-	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	+	-	+	+	+	-	+	+
+much_Det	Det	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	-	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	-	+	+	+	-	+	+	+	-	+	+
+must_VV	VV	+	-	-	+	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	-	-	-	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	-	-	+	+	+	-	+	-	+	+	+	-	-	+
+n2	Digit	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+n3	Digit	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+n4	Digit	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+n5	Digit	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+n6	Digit	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+n7	Digit	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+n8	Digit	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+n9	Digit	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+nd	Digit -> Dig	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+
+nd10	Sub10 -> Digits	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+
+nd100	Sub100 -> Digits	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+
+nd1000	Sub1000 -> Digits	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+
+nd1000000	Sub1000000 -> Digits	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+
+no_Quant	Quant	+	-	-	-	+	-	+	+	-	-	+	+	-	+	+	+	+	+	+	-	-	-	-	-	+	+	+	-	+	+	+	-	+	+	+	-	-	+	+	+	+	+	+	+	+	-	-	-	+	+	+	-	+	+	+	-	+	+
+no_Utt	Utt	+	-	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	+	-	+	+	+	-	+	+
+nobody_NP	NP	+	-	+	-	+	-	+	+	-	-	+	+	+	+	+	+	+	+	+	-	-	-	-	-	+	+	+	-	+	+	+	-	+	+	+	-	-	+	+	+	+	+	+	+	-	-	+	-	+	+	+	-	+	+	+	-	+	+
+not_Predet	Predet	+	-	-	-	+	-	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	-	+	+	+	-	+	-	+	-	+	+	+	-	-	+	+	+	+	+	+	+	+	-	-	-	+	+	+	-	+	+	+	-	+	+
+nothing_NP	NP	+	-	+	+	+	-	+	+	-	-	+	+	+	+	+	+	+	+	+	-	-	-	-	-	+	+	+	-	+	+	+	-	+	+	+	-	-	+	+	+	+	+	+	+	-	-	+	-	+	+	+	-	+	+	+	-	+	+
+num	Sub1000000 -> Numeral	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+num2digits	Numeral -> Digits	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+
+on_Prep	Prep	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	+	-	+	+	+	-	+	+
+only_Predet	Predet	+	+	-	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	-	+	+	+	-	+	+	+	-	+	+
+or_Conj	Conj	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+otherwise_PConj	PConj	+	+	-	-	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	-	+	+	+	-	+	+	+	-	+	+
+part_Prep	Prep	+	-	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	-	+	+	+	-	+	+	+	-	+	+
+please_Voc	Voc	+	+	-	-	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	-	+	+	+	-	+	+	+	-	+	+
+possess_Prep	Prep	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	-	+	+	+	+	+	+
+pot0	Digit -> Sub10	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+pot01	Sub10	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+pot0as1	Sub10 -> Sub100	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+pot1	Digit -> Sub100	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+pot110	Sub100	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+pot111	Sub100	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+pot1as2	Sub100 -> Sub1000	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+pot1plus	Digit -> Sub10 -> Sub100	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+pot1to19	Digit -> Sub100	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+pot2	Sub10 -> Sub1000	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+pot21	Sub1000	-	-	-	-	-	+	-	-	-	-	-	-	-	+	-	-	-	-	-	+	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	+	-	-	-	-	-	-	-	-	-	-	+	-	+	-	-	-	-	+
+pot2as3	Sub1000 -> Sub1000000	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+pot2plus	Sub10 -> Sub100 -> Sub1000	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+pot3	Sub1000 -> Sub1000000	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+pot31	Sub1000000	-	-	-	-	-	+	-	-	-	-	-	-	-	+	-	-	-	-	-	+	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	+	-	-	-	-	-	-	-	-	-	-	+	-	+	-	-	-	-	+
+pot3as4	Sub1000000 -> Sub1000000000	+	-	+	-	-	+	+	+	-	-	-	+	-	+	+	+	+	+	+	+	-	-	-	-	+	-	-	+	-	+	-	-	+	-	-	-	-	-	+	+	-	+	-	+	-	+	+	+	+	+	+	-	+	+	+	-	-	+
+pot3float	Float -> Sub1000000	-	-	-	-	-	+	-	-	-	-	-	-	-	+	-	+	-	+	-	+	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	+	-	-	-	-	+
+pot3plus	Sub1000 -> Sub1000 -> Sub1000000	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+pot4	Sub1000 -> Sub1000000000	-	-	-	-	-	+	-	-	-	-	-	-	-	+	-	-	-	-	-	+	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	+	-	-	-	-	-	-	-	-	-	-	+	-	+	-	-	-	-	+
+pot41	Sub1000000000	-	-	-	-	-	+	-	-	-	-	-	-	-	+	-	-	-	-	-	+	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	+	-	-	-	-	-	-	-	-	-	-	+	-	+	-	-	-	-	+
+pot4as5	Sub1000000000 -> Sub1000000000000	+	-	+	-	-	+	+	+	-	-	-	+	-	+	+	+	+	+	+	+	-	-	-	-	+	-	-	+	-	+	-	-	+	-	-	-	-	-	+	+	-	+	-	+	-	+	+	+	+	+	+	-	+	+	+	-	-	+
+pot4float	Float -> Sub1000000000	-	-	-	-	-	+	-	-	-	-	-	-	-	+	-	+	-	+	-	+	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	+	-	+	-	-	-	-	+
+pot4plus	Sub1000 -> Sub1000000 -> Sub1000000000	-	-	-	-	-	+	-	-	-	-	-	-	-	+	-	-	-	-	-	+	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	+	-	-	-	-	-	-	-	-	-	-	+	-	+	-	-	-	-	+
+pot5	Sub1000 -> Sub1000000000000	-	-	-	-	-	+	-	-	-	-	-	-	-	+	-	-	-	-	-	+	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	+	-	+	-	-	-	-	+
+pot51	Sub1000000000000	-	-	-	-	-	+	-	-	-	-	-	-	-	+	-	+	-	+	-	+	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	+	-	+	-	-	-	-	+
+pot5float	Float -> Sub1000000000000	-	-	-	-	-	+	-	-	-	-	-	-	-	+	-	-	-	-	-	+	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	+	-	+	-	-	-	-	+
+pot5plus	Sub1000 -> Sub1000000000 -> Sub1000000000000	-	-	-	-	-	+	-	-	-	-	-	-	-	+	-	-	-	-	-	+	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	-	+	-	+	-	-	-	-	+
+quite_Adv	AdA	+	-	-	-	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	-	+	+	+	-	+	+	+	-	+	+
+she_Pron	Pron	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+so_AdA	AdA	+	+	-	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	-	+	+	+	-	+	+	+	-	+	+
+somePl_Det	Det	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	-	+	+	+	-	+	+
+someSg_Det	Det	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	+	-	+	+	+	-	+	+
+somebody_NP	NP	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	-	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	-	+	+	+	-	+	+	+	-	+	+
+something_NP	NP	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	-	+	+	-	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	-	+	+	+	-	+	+	+	-	+	+
+somewhere_Adv	Adv	+	+	+	-	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	-	+	+	+	-	+	+	+	+	+	+
+that_Quant	Quant	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+that_Subj	Subj	+	-	+	+	+	+	+	+	-	-	-	+	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	-	+	+	-	+	+	+	+	-	-	+	-	+	+	+	+	+	+	-	-	+	+	+	+	-	+	+	+	-	+	+
+there7from_Adv	Adv	+	+	+	-	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	-	+	+	+	-	+	+	+	-	+	+
+there7to_Adv	Adv	+	+	+	-	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	-	+	+	+	-	+	+	+	-	+	+
+there_Adv	Adv	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	-	+	+	+	-	+	+	+	-	+	+
+therefore_PConj	PConj	+	+	+	-	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	-	+	+	+	-	+	+	+	-	+	+
+they_Pron	Pron	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+this_Quant	Quant	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+
+through_Prep	Prep	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	-	+	+	+	-	+	+	-	-	+	+
+to_Prep	Prep	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	-	+	+	+	+	+	+
+too_AdA	AdA	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	-	+	+	+	-	+	+	+	-	+	+
+under_Prep	Prep	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	+	-	+	+	+	-	+	+
+very_AdA	AdA	+	+	-	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	-	+	+	+	-	+	+
+want_VV	VV	+	+	+	+	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	-	+	-	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	-	+	-	+	+	+	-	+	+
+we_Pron	Pron	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+whatPl_IP	IP	+	-	+	+	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	+	+	-	+	+	+	+	-	-	+	+	+	-	+	+	+	+	+	+	+	+	-	+	+	+	+	-	-	-	+	-	+	-	+	+	+	-	+	+
+whatSg_IP	IP	+	-	+	+	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	+	+	-	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	-	+	-	+	+	+	-	+	+
+when_IAdv	IAdv	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	-	+	+	+	-	+	+
+when_Subj	Subj	+	-	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	-	+	+	+	-	+	+
+where_IAdv	IAdv	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	+	+	+	-	+	+
+which_IQuant	IQuant	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	+	-	+	+	+	-	+	+
+whoPl_IP	IP	+	+	+	+	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	+	+	-	+	+	+	+	-	-	+	+	+	-	+	+	+	+	+	+	+	+	-	+	+	+	+	-	-	-	+	-	+	-	+	+	+	-	+	+
+whoSg_IP	IP	+	+	+	+	+	+	+	+	-	-	+	+	-	+	+	+	+	+	+	+	+	-	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	-	+	-	+	+	+	-	+	+
+why_IAdv	IAdv	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	+	+	+	-	+	+
+with_Prep	Prep	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+without_Prep	Prep	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	-	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	-	+	+	+	-	+	+	+	-	+	+
+yes_Utt	Utt	+	-	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	-	-	+	+	+	+	-	+	+	+	-	+	+
+youPl_Pron	Pron	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+
+youPol_Pron	Pron	+	+	+	+	+	+	+	+	-	-	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	-	+	+	+	-	+	+
+youSg_Pron	Pron	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	+	-	+	+	+	+	+	+

doc/rgl-publications.txt

@@ -159,7 +159,7 @@ The GF Resource Grammar Library.
 //Linguistic Issues in Language Technology//,
 2 (2),
 2009.
-[PDF http://elanguage.net/journals/index.php/lilt/article/viewFile/214/158]
+[PDF https://journals.colorado.edu/index.php/lilt/article/view/1205/1047]
 #BR
 //A systematic presentation of the library from the linguistic point of view.//
 //Not only about English, but English examples abound.//

doc/show_missing.py

@@ -0,0 +1,93 @@
+# show missing functions in the RGL languages
+# basic usage: python3 show_missing.py >missing-in-rgl-Grammar.tsv
+
+import subprocess
+
+# this is the functions you want to find: default is all funs in Grammar
+GF_LIB_PATH = '/Users/aarne/GF/dist/build/rgl/'
+ALLTENSES_PATH = GF_LIB_PATH + 'alltenses/'
+RGL_SOURCE_PATH = '/Users/aarne/GF/gf-rgl/src/'
+GRAMMAR = 'Grammar'
+
+# these are the languages you investigate
+LANGS = ['Cze', 'Urd']
+
+# get all functions in GRAMMAR, together with their types
+def get_funs(module=GRAMMAR):
+    cmd = 'echo "pg -funs" | gf -run ' + ALLTENSES_PATH + module + '.gfo'
+    missing = subprocess.Popen(cmd, text=True, shell=True,
+                               stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+    output = missing.communicate()[0].split(';')
+    return ([(fun.split()[0].strip(), ' '.join(fun.split()[2:]))  for fun in output if fun.split()])
+
+# get all missing functions in GRAMMARLng; this can take a long time
+def get_missing_from_compiled(Lng, module=GRAMMAR):
+    print('investigating', Lng)
+    cmd = 'echo "pg -missing" | gf -run ' + ALLTENSES_PATH + module + Lng + '.gfo'
+    missing = subprocess.Popen(cmd, text=True, shell=True,
+                               stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+    output = missing.communicate()[0].split()
+    return set(output[2:])
+
+# to get all languages in the compiled RGL, use all_langs from here
+def all_rgl_compiled_langs():
+    modules = subprocess.run(['ls', ALLTENSES_PATH], capture_output=True, text=True)
+    files = str(modules.stdout)
+    return [file[-7:-4] for file in files.split() if file[:-7].endswith(GRAMMAR)]
+
+# LANGS = all_rgl_compiled_langs()  # uncomment this line if you want all languages
+
+
+# it is much faster to use source files (sending gfos to /tmp)
+def str_until(c, s):
+    i = s.find(c)
+    if i >= 0:
+        return s[:i]
+    else:
+        return s
+    
+def get_missing_from_source(lang, gf_file):
+    cmd = 'gf -batch -retain -no-pmcfg -src -gfo-dir=/tmp ' + gf_file
+    missing = subprocess.Popen(cmd, text=True, shell=True,
+                               stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    output = missing.communicate()[1].split('\n')
+    missing = (lang, {str_until('\x1b[39;49m', line.split()[-1])
+                      for line in output
+                      if line.strip().startswith('Warning: no linearization of')})
+    return missing
+
+
+def all_rgl_source_modules(module=GRAMMAR):
+    cmd = 'ls ' + RGL_SOURCE_PATH + '*/' + module + '?*.gf'
+    files = subprocess.Popen(cmd, text=True, shell=True,
+                               stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+    output = files.communicate()[0].split()
+    return {file[-6:-3]: file for file in output}
+
+LANGS = all_rgl_source_modules()  # Lng: file dict
+
+# make a text with tab-separated strings withcolumns fun, type, langs and rows for each fun
+def make_table(funs=get_funs(), module=GRAMMAR, langs=LANGS):
+    header = ['fun', 'type'] + list(langs.keys())  # if dict, otherwise langs ###
+    rows = [header]
+    print('\t'.join(header))
+    
+#    missings = {lang: get_missing_from_compiled(lang, module) for lang in langs}
+    missings = {lang: get_missing_from_source(lang, file)[1] for lang,file in langs.items()}
+    for fun in funs:
+        row = [fun[0], fun[1]]
+        for lang in langs.keys():
+            if fun[0] in missings[lang]:
+                row.append('-')
+            else:
+                row.append('+')
+        rows.append(row)
+        print('\t'.join(row))
+
+
+# the output is send to stdout
+make_table()
+
+
+    
+

doc/status.txt

@@ -7,8 +7,6 @@ Aarne Ranta
 The following table gives the languages currently available in the
 GF Resource Grammar Library.
 
-For another view, see the
-[The Resource Grammar Library coverage map http://www.postcrashgames.com/gf_world/] .
 
 Corrections and additions are welcome! Notice that only those parts of implementations
 that are currently available via https://github.com/GrammaticalFramework/gf-rgl/

doc/synopsis/intro.txt

@@ -32,7 +32,6 @@ the library, view all functions in a module's scope, and quickly jump to their d
 Other relevant documents:
 - [The RGL Status Document ../status.html]: the current status of different languages
   and the authors of each grammar
-- [The Resource Grammar Library coverage map http://www.postcrashgames.com/gf_world/]
 - [RGL Documentation and Publications ../rgl-publications.html]: links to publications and other documentation
 - [More modules ../gfdoc/sources.html]: extra modules, dictionaries, and
   the internals of the resource grammar
@@ -46,7 +45,7 @@ abstract functions and their Universal Dependency labels
 - Paper "The GF Resource Grammar Library" by A. Ranta
   (//Linguistic Issues in Language Technology//, 2 (2), 2009). An overview of
   the library with linguistic motivations.
-  [PDF http://journals.linguisticsociety.org/elanguage/lilt/article/download/214/214-501-1-PB.pdf]
+  [PDF https://journals.colorado.edu/index.php/lilt/article/view/1205/1047]
 - Paper "Grammars as Software Libraries" by A. Ranta
   (In Y. Bertot, G. Huet, J-J. Lévy, and G. Plotkin (eds.),
    //From Semantics to Computer Science//, Cambridge University Press,

flake.lock

@@ -0,0 +1,62 @@
+{
+  "nodes": {
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1775036866,
+        "narHash": "sha256-ZojAnPuCdy657PbTq5V0Y+AHKhZAIwSIT2cb8UgAz/U=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "6201e203d09599479a3b3450ed24fa81537ebc4e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs_2": {
+      "locked": {
+        "lastModified": 1750386251,
+        "narHash": "sha256-1ovgdmuDYVo5OUC5NzdF+V4zx2uT8RtsgZahxidBTyw=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "076e8c6678d8c54204abcb4b1b14c366835a58bb",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixpkgs-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "nixpkgs": "nixpkgs",
+        "sydpkgs": "sydpkgs"
+      }
+    },
+    "sydpkgs": {
+      "inputs": {
+        "nixpkgs": "nixpkgs_2"
+      },
+      "locked": {
+        "lastModified": 1771299872,
+        "narHash": "sha256-+OPW1SKKHT7aqhyjs2O20gd1MXa7LyD+9/lwMUCVL7Y=",
+        "ref": "refs/heads/main",
+        "rev": "53bf019e26478666ab7f458f78e569b8b106cc1f",
+        "revCount": 36,
+        "type": "git",
+        "url": "https://git.deertopia.net/msyds/sydpkgs"
+      },
+      "original": {
+        "type": "git",
+        "url": "https://git.deertopia.net/msyds/sydpkgs"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

flake.nix

@@ -0,0 +1,55 @@
+{
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+    # gf.url = "github:anka-213/cclaw-nix-stuff/nix-flakes";
+    sydpkgs.url = "git+https://git.deertopia.net/msyds/sydpkgs";
+  };
+
+  outputs = { self, nixpkgs, sydpkgs, ... }@inputs:
+    let
+      supportedSystems = [
+        "aarch64-darwin"
+        "aarch64-linux"
+        "x86_64-darwin"
+        "x86_64-linux"
+      ];
+
+      each-system = f: nixpkgs.lib.genAttrs supportedSystems (system: f rec {
+	pkgs = import nixpkgs {
+	  inherit system;
+	  overlays = [
+	    # (final: prev: { inherit (gf.packages.${system}) gf-core; })
+	    sydpkgs.overlays.default
+	  ];
+	};
+	inherit (pkgs) lib;
+        inherit system;
+      });
+    in {
+      # Exposed as a REPL convenience.
+      _pkgs = each-system ({ pkgs, ... }: pkgs);
+
+      packages = each-system ({ pkgs, ... }: {
+	default = pkgs.callPackage ./package.nix {};
+      });
+
+      devShells = each-system ({ pkgs, system, ... }:
+        let
+	  gf-lsp = import
+	    (pkgs.fetchzip {
+	      url = "https://github.com/anka-213/gf-lsp/archive/refs/tags/1.0.6.0.tar.gz";
+	      hash = "sha256-UAI2qUslzLOWYjTirZJ0y4DZbkPZnVXTY0XtFO8+Rks=";
+	    }) {inherit system;};
+	in {
+	  default = pkgs.mkShell {
+	    inputsFrom = [ self.packages.${system}.default ];
+	    packages = [
+	      gf-lsp.gf-lsp
+	      pkgs.gftest
+	      pkgs.graphviz
+	      pkgs.imagemagick
+	    ];
+	  };
+	});
+    };
+}

languages.csv

@@ -1,50 +1,64 @@
-Code,Name,Directory,Functor,Unlexer,Present,All,Try,Symbolic,Compatibility,Synopsis
+Code,Name,Directory,Functor,Unlexer,Present,All,Try,Symbolic,Compatibility,Synopsis,MorphoDict
-Afr,Afrikaans,afrikaans,,,,,,n,,y
+Afr,Afrikaans,afrikaans,,,,,,n,,y,n
-Amh,Amharic,amharic,,,,,n,n,,n
+Amh,Amharic,amharic,,,,,n,n,,n,n
-Ara,Arabic,arabic,,,,,,y,,y
+Ara,Arabic,arabic,,,,,,y,,y,y
-Bul,Bulgarian,bulgarian,,,y,,,,,y
+Bel,Belarusian,belarusian,,,,y,n,n,n,y,n
-Cat,Catalan,catalan,Romance,,y,,,,y,y
+Bul,Bulgarian,bulgarian,,,y,,,,,y,n
-Cgg,Rukiga,rukiga,,,y,y,n,n,y,y
+Cat,Catalan,catalan,Romance,,y,,,,y,y,n
-Chi,Chinese (simplified),chinese,,,,,,,,y
+Cgg,Rukiga,rukiga,,,y,y,n,n,y,y,n
-Cze,Czech,czech,,,,,,n,,y
+Chi,Chinese (simplified),chinese,,,,,,,,y,y
-Dan,Danish,danish,Scand,,y,,,,,y
+Cze,Czech,czech,,,,,,n,,y,n
-Dut,Dutch,dutch,,,y,,,,,y
+Dan,Danish,danish,Scand,,y,,,,,y,n
-Eng,English,english,,,y,,,,y,y
+Dut,Dutch,dutch,,,y,,,,,y,n
-Est,Estonian,estonian,,,,,,,,y
+Eng,English,english,,,y,,,,y,y,y
-Eus,Basque,basque,,,,,,,,y
+Est,Estonian,estonian,,,,,,,,y,n
-Fin,Finnish,finnish,,,y,,,,y,y
+Eus,Basque,basque,,,,,,,,y,n
-Fre,French,french,Romance,,y,,,,y,y
+Fao,Faroese,faroese,,,,y,n,n,n,y,n
-Ger,German,german,,,y,,,,,y
+Fin,Finnish,finnish,,,y,,,,y,y,y
-Grc,Ancient Greek,ancient_greek,,,y,,n,n,,n
+Fre,French,french,Romance,,y,,,,y,y,y
-Gre,Greek,greek,,,,,,,,y
+Gla,Gaelic,gaelic,,,,y,n,n,n,y,n
-Heb,Hebrew,hebrew,,,,,n,n,,n
+Ger,German,german,,,y,,,,,y,y
-Hin,Hindi,hindi,Hindustani,to_devanagari,y,,,,,y
+Grc,Ancient Greek,ancient_greek,,,y,,n,n,,n,n
-Hun,Hungarian,hungarian,,,n,y,y,y,n,n
+Gre,Greek,greek,,,,,,,,y,n
-Ice,Icelandic,icelandic,,,,,,n,,y
+Heb,Hebrew,hebrew,,,,,n,n,,n,n
-Ina,Interlingua,interlingua,,,y,,n,n,,n
+Hin,Hindi,hindi,Hindustani,to_devanagari,y,,,,,y,n
-Ita,Italian,italian,Romance,,y,,,,y,y
+Hrv,Croatian,croatian,,,,,,y,,n,n
-Jpn,Japanese,japanese,,,,,,,,y
+Hun,Hungarian,hungarian,,,n,y,y,y,n,n,n
-Kor,Korean,korean,,,n,y,y,y,n,n
+Hye,Armenian,armenian,,,,y,n,n,n,y,n
-Lat,Latin,latin,,,,,y,y,n,y
+Ice,Icelandic,icelandic,,,,,,n,,y,n
-Lav,Latvian,latvian,,,,,,,y,y
+Ina,Interlingua,interlingua,,,y,,n,n,,n,n
-Mlt,Maltese,maltese,,,,,,,,y
+Ita,Italian,italian,Romance,,y,,,,y,y,y
-Mon,Mongolian,mongolian,,,,,,n,,y
+Jpn,Japanese,japanese,,,,,,,,y,n
-Nep,Nepali,nepali,,,,,,n,,y
+Kaz,Kazakh,kazakh,,,,y,n,n,n,y,n
-Nno,Norwegian (nynorsk),nynorsk,,,y,,,,,y
+Kor,Korean,korean,,,n,y,y,y,n,n,n
-Nor,Norwegian (bokmål),norwegian,Scand,,y,,,,,y
+Lat,Latin,latin,,,,,y,y,n,y,n
-Pes,Persian,persian,,,,,,,,y
+Lav,Latvian,latvian,,,,,,,y,y,n
-Pnb,Punjabi,punjabi,,,y,,,,,y
+Mkd,Macedonian,macedonian,,,,y,n,n,n,y,n
-Pol,Polish,polish,,,,,,,,y
+May,Malay,malay,,,y,,,,n,y,n
-Por,Portuguese,portuguese,Romance,,y,,,,y,y
+Mlt,Maltese,maltese,,,,,,,,y,n
-Ron,Romanian,romanian,,,y,,,,,y
+Mon,Mongolian,mongolian,,,,,,n,,y,n
-Rus,Russian,russian,,,y,,,,,y
+Nep,Nepali,nepali,,,,,,n,,y,n
-Slo,Slovak,slovak,,,,,,n,,y
+Nno,Norwegian (nynorsk),nynorsk,,,y,,,,,y,n
-Slv,Slovenian,slovenian,,,,,n,n,,n
+Nor,Norwegian (bokmål),norwegian,Scand,,y,,,,,y,n
-Snd,Sindhi,sindhi,,,,,,,,y
+Pes,Persian,persian,,,,,,,,y,n
-Spa,Spanish,spanish,Romance,,y,,,,y,y
+Pnb,Punjabi,punjabi,,,y,,,,,y,n
-Swa,Swahili,swahili,Bantu,,,n,n,n,n,n
+Pol,Polish,polish,,,,,,,,y,n
-Swe,Swedish,swedish,Scand,,y,,,,y,y
+Por,Portuguese,portuguese,Romance,,y,,,,y,y,y
-Tel,Telugu,telugu,,,y,n,n,n,,n
+Ron,Romanian,romanian,,,y,,,,,y,n
-Tha,Thai,thai,,to_thai,,,,,,y
+Rus,Russian,russian,,,y,,,,,y,n
-Tur,Turkish,turkish,,,y,,,n,,n
+Slo,Slovak,slovak,,,,,,n,,y,n
-Urd,Urdu,urdu,Hindustani,,,,,,,y
+Slv,Slovenian,slovenian,,,,,n,n,,n,n
+Snd,Sindhi,sindhi,,,,,,,,y,n
+Spa,Spanish,spanish,Romance,,y,,,,y,y,y
+Sqi,Albanian,albanian,,,,y,n,n,n,y,n
+Sco,Scots,scots,,,y,,,,,y,n
+Swa,Swahili,swahili,Bantu,,,y,n,n,n,n,n
+Swe,Swedish,swedish,Scand,,y,,,,y,y,y
+Tam,Tamil,tamil,n,n,n,n,n,n,n,n,n
+Tel,Telugu,telugu,,,y,n,n,n,,n,n
+Tha,Thai,thai,,to_thai,,,,,,y,n
+Tur,Turkish,turkish,,,y,,,n,,n,n
+Ukr,Ukrainian,ukrainian,,,,y,n,n,n,y,n
+Urd,Urdu,urdu,Hindustani,,,,,,,y,n
+Som,Somali,somali,,,,,n,n,,n,n
+Zul,Zulu,zulu,,,,,n,n,,n,n

package.nix

@@ -0,0 +1,23 @@
+{ stdenv
+, ghc
+, gf-core
+}:
+
+stdenv.mkDerivation {
+  name = "gf-rgl";
+  src = ./.;
+  buildInputs = [ ghc gf-core ];
+  # Keep references to source, so go to definition works
+  # postUnpack = ''
+  #   rm -r source/src
+  #   ln -s $src/src source/src
+  # '';
+  LC_ALL = "C.UTF-8";
+  buildPhase = ''
+    runghc Setup.hs build
+  '';
+  installPhase = ''
+    mkdir -p $out/share/gf/lib
+    runghc Setup.hs copy --dest=$out/share/gf/lib
+  '';
+}

src/Clone.hs

@@ -52,6 +52,12 @@ apiModules = ["Try","Symbolic","Syntax","Constructors","Combinators"]
 
 clone :: [String] -> String -> String -> String -> String -> (String, String) -> IO ()
 clone options fromdir todir from to (absname,absfx) = do
+  printf "clone options=%s\n\
+         \      fromdir=%s\n\
+         \      todir=%s\n\
+         \      from=%s\n\
+         \      to=%s\n" (show options) (show fromdir)
+         (show todir) (show from) (show to)
   s <- readFile (fromdir ++ "/" ++ absname ++ from ++ absfx ++ ".gf")
   writeAndReportFile (todir ++ "/" ++ absname ++ to ++ absfx ++ ".gf") (commentIf options (replaceLang from to s))
 

src/Lang.labels

@@ -1,157 +1,157 @@
-PredVP 	nsubj head
+PredVP	nsubj head
-PredVPS 	nsubj head
+PredVPS	nsubj head
-DirectComplVQ 	empty nsubj head ccomp  -- Temp argument can only be empty in English 
+DirectComplVQ	empty nsubj head ccomp  -- Temp argument can only be empty in English
-DirectComplVS 	empty nsubj head ccomp  -- Temp argument can only be empty in English 
+DirectComplVS	empty nsubj head ccomp  -- Temp argument can only be empty in English
-SlashVP 	nsubj head
+SlashVP	nsubj head
-SlashVS 	nsubj head ccomp
+SlashVS	nsubj head ccomp
-FocusObjS 	nsubj head              -- again might be wrong; more correct to call it dobj
+FocusObjS	nsubj head              -- again might be wrong; more correct to call it obj
-QuestIAdv 	advmod head		-- "where does John sleep" cf. AdvVP
+QuestIAdv	advmod head		-- "where does John sleep" cf. AdvVP
-QuestIComp 	head nsubj	-- "where is John": John is clearly nsubj, but is where the head?
+QuestIComp	head nsubj	-- "where is John": John is clearly nsubj, but is where the head?
-QuestQVP 	nsubj head
+QuestQVP	nsubj head
-QuestSlash 	obj head
+QuestSlash	obj head
-QuestVP 	nsubj head
+QuestVP	nsubj head
 IdetCN		det head
 
-PredSCVP 	csubj head
+PredSCVP	csubj head
 
-ComplSlash 	head obj
+ComplSlash	head obj
-ComplSlashIP 	head obj
+ComplSlashIP	head obj
-Slash3V3 	head obj
+Slash3V3	head obj
-SlashV2VNP 	head obj xcomp
+SlashV2VNP	head obj xcomp
-PastPartAgentAP 	head obj
+PastPartAgentAP	head obj
-AdvQVP 	head obj
+AdvQVP	head obj
 
-Slash2V3 	head iobj
+Slash2V3	head iobj
 
-ComplVS 	head ccomp
+ComplVS	head ccomp
-ComplVQ 	head ccomp
+ComplVQ	head ccomp
-SlashV2S 	head ccomp
+SlashV2S	head ccomp
-SlashV2Q 	head ccomp
+SlashV2Q	head ccomp
-CleftAdv 	head advcl            -- not sure
+CleftAdv	head advcl            -- not sure
 
-ComplVA 	head xcomp
+ComplVA	head xcomp
-ComplVV 	head xcomp
+ComplVV	head xcomp
-SlashVV 	head acl
+SlashVV	head acl
-SlashV2A 	head xcomp
+SlashV2A	head xcomp
-SlashV2V 	head xcomp
+SlashV2V	head xcomp
 
-AdvNP 	head nmod              -- not sure
+AdvNP	head nmod              -- not sure
-ExtAdvNP 	head nmod      -- not sure
+ExtAdvNP	head nmod      -- not sure
-PassAgentVPSlash 	head nmod    -- not sure
+PassAgentVPSlash	head nmod    -- not sure
-CleftNP 	head acl       -- this cannot be nmod, not with type RS
+CleftNP	head acl       -- this cannot be nmod, not with type RS
 
-SSubjS 	head mark advcl
+SSubjS	head mark advcl
-RelS 	head advcl
+RelS	head advcl
 
-AdNum 	advmod head
+AdNum	advmod head
-AdAP 	advmod head
+AdAP	advmod head
-AdvAP 	head advmod
+AdvAP	head advmod
-ComparAdvAdj 	advmod amod head
+ComparAdvAdj	advmod amod head
-ComparAdvAdjS 	advmod amod head
+ComparAdvAdjS	advmod amod head
-AdvIAdv 	advmod head
+AdvIAdv	advmod head
-AdVVP 	advmod head
+AdVVP	advmod head
-AdvVP 	head advmod
+AdvVP	head advmod
-ExtAdvVP 	head advmod
+ExtAdvVP	head advmod
-AddAdvQVP 	head advmod
+AddAdvQVP	head advmod
-AdVVPSlash 	advmod head
+AdVVPSlash	advmod head
-AdvVPSlash 	head advmod
+AdvVPSlash	head advmod
-AdvSlash 	head advmod
+AdvSlash	head advmod
-ExistIPAdv 	head advmod
+ExistIPAdv	head advmod
-AdvS 	advmod head
+AdvS	advmod head
-ExtAdvS 	advmod head
+ExtAdvS	advmod head
 
-SubjS 	mark head
+SubjS	mark head
-RelVP 	mark head
+RelVP	mark head
-RelSlash 	mark head
+RelSlash	mark head
 
-ComplN2 	head nmod
+ComplN2	head nmod
-ComplN3 	nmod head
+ComplN3	nmod head
-AdvCN 	head nmod
+AdvCN	head nmod
-PossNP 	head nmod 
+PossNP	head nmod
-PartNP 	head nmod 
+PartNP	head nmod
-ExistNPAdv 	head nmod
+ExistNPAdv	head nmod
 
-OrdNumeralSuperl 	nummod head  -- quite wrong; cannot find relevant details in the documentation; but most probably head lies outside the score of this function 
+OrdNumeralSuperl	nummod head  -- quite wrong; cannot find relevant details in the documentation; but most probably head lies outside the score of this function
-DetQuant 	head nummod          -- quite wrong; I think the head lies outside the scope of the function
+DetQuant	head nummod          -- quite wrong; I think the head lies outside the scope of the function
-CNNumNP 	head nummod          
+CNNumNP	head nummod
 
-ApposCN 	head appos
+ApposCN	head appos
-ApposNP 	head appos
+ApposNP	head appos
 
-RelNP 	head acl
+RelNP	head acl
-RelCN 	head acl
+RelCN	head acl
-SentCN 	head acl
+SentCN	head acl
-SentAP 	head acl
+SentAP	head acl
 
-DetQuantOrd 	head nummod amod     -- quite wrong; again for same reason as DetQuant function
+DetQuantOrd	head nummod amod     -- quite wrong; again for same reason as DetQuant function
-DetCN 	det head
+DetCN	det head
-IdetCN 	det head
+IdetCN	det head
 IdetQuant head nummod
-CountNP 	det head
+CountNP	det head
-PredetNP 	det head
+PredetNP	det head
 PPartNP		head amod	-- only in core RGL
 
-AdjCN 	amod head
+AdjCN	amod head
-AdjDAP 	head amod
+AdjDAP	head amod
-CAdvAP 	case amod head
+CAdvAP	case amod head
-ComparA 	amod head
+ComparA	amod head
-ComplA2 	amod head
+ComplA2	amod head
-CompoundAP 	head amod
+CompoundAP	head amod
-AdAdV 	amod head
+AdAdV	amod head
-AdAdv 	amod head
+AdAdv	amod head
 
-CompoundN 	compound head
+CompoundN	compound head
 
-IIDig 	head goeswith
+IIDig	head goeswith
 
-PrepNP 	case head
+PrepNP	case head
-PrepIP 	case head
+PrepIP	case head
-SlashPrep 	head case
+SlashPrep	head case
-VPSlashPrep 	head case
+VPSlashPrep	head case
 
-UttImpPl 	empty head
+UttImpPl	empty head
-UttImpPol 	empty head
+UttImpPol	empty head
-UttImpSg 	empty head
+UttImpSg	empty head
 
-MkVPS 	empty empty head
+MkVPS	empty empty head
 
-UseCl 	empty empty head
+UseCl	empty empty head
-UseQCl 	empty empty head
+UseQCl	empty empty head
-UseRCl 	empty empty head
+UseRCl	empty empty head
-UseSlash 	empty empty head
+UseSlash	empty empty head
-UseVC 	empty empty head
+UseVC	empty empty head
 
-BaseAP 	head conj
+BaseAP	head conj
-BaseAdV 	head conj
+BaseAdV	head conj
-BaseAdv 	head conj
+BaseAdv	head conj
-BaseCN 	head conj
+BaseCN	head conj
-BaseDAP 	head conj
+BaseDAP	head conj
-BaseIAdv 	head conj
+BaseIAdv	head conj
-BaseNP 	head conj
+BaseNP	head conj
-BaseRS 	head conj
+BaseRS	head conj
-BaseS 	head conj
+BaseS	head conj
-ConsAP 	head conj
+ConsAP	head conj
-ConsAdV 	head conj
+ConsAdV	head conj
-ConsAdv 	head conj
+ConsAdv	head conj
-ConsCN 	head conj
+ConsCN	head conj
-ConsDAP 	head conj
+ConsDAP	head conj
-ConsIAdv 	head conj
+ConsIAdv	head conj
-ConsNP 	head conj
+ConsNP	head conj
-ConsRS 	head conj
+ConsRS	head conj
-ConsS 	head conj
+ConsS	head conj
-ConjAP 	cc head
+ConjAP	cc head
-ConjAdV 	cc head
+ConjAdV	cc head
-ConjAdv 	cc head
+ConjAdv	cc head
-ConjCN 	cc head
+ConjCN	cc head
-ConjDet 	cc head
+ConjDet	cc head
-ConjIAdv 	cc head
+ConjIAdv	cc head
-ConjNP 	cc head
+ConjNP	cc head
-ConjRS 	cc head
+ConjRS	cc head
-ConjS 	cc head
+ConjS	cc head
-PhrUtt 	cc head discourse
+PhrUtt	cc head discourse
 
-PlusChunk 	head dep
+PlusChunk	head dep
-TTAnt 	empty empty head
+TTAnt	empty empty head
 
 TExclMark      head dep		-- punctuation in the middle in these three
 TFullStop      head dep
@@ -159,13 +159,13 @@ TQuestMark     head dep
 
 ComplV2	       head obj	-- shortcuts in App
 ComplV2V       head obj xcomp
-ComplV3	       head iobj obj   ---- could be dobj dobj
+ComplV3	       head iobj obj   ---- could be obj obj
 PassAgentV2    head ncomp	-- not sure
 RelV2	       mark nsubj head
 QuestV2	       obj nsubj head
 
 ModCN	       amod head  -- in ResourceDemo
-RSubjS	       mark advcl head 
+RSubjS	       mark advcl head
 SlashV2	       nsubj head
 RAdvCN	       head case nmod
 SubjCl	       head mark advcl
@@ -181,7 +181,7 @@ AdV	ADV
 Adv	ADV
 CAdv	ADV
 Card	NUM
-Conj	CONJ
+Conj	CCONJ
 Det	DET
 Digits	NUM
 IAdv	ADV
@@ -194,7 +194,7 @@ N2	NOUN
 N3	NOUN
 Numeral	NUM
 Ord	NUM
-PConj	CONJ
+PConj	CCONJ
 PN	PROPN
 Predet	DET
 Prep	ADP
@@ -214,7 +214,3 @@ VA	VERB
 VQ	VERB
 VS	VERB
 VV	VERB
-
-
-
-

src/README.md

@@ -0,0 +1,98 @@
+# Introduction
+
+## Intended audience of this Readme
+
+This Readme is designed for new developers who wish to either extend/improve on a resource grammar or create a new one. It provides an overview of the relationships between files and a simple working pipeline for developers to get started.
+
+Note that while files in this folder are meant to be named with 3 letter suffixes representing the language, e.g. "ResBul" for the Bulgarian resource file, this Readme will use a 4 letter suffix "Lang" to represent a language in general, e.g. "ResLang".
+
+## Author(s) of this Readme
+
+This Readme was written by Nemo and edited by Inari on 14th August 2022.
+
+# Creating a new resource grammar
+
+If you are working on an RGL for a new language, you will need to run "Clone.hs" in the "src" folder so that you can clone a project from another language to your language to give you a basis to start with.
+
+### From an existing RGL language
+
+If your language already has a close relative in the RGL, then you can clone your language from that one, in order reuse the same structures with only minor modifications. As per the instructions, the syntax is `Clone fromdir todir fromlang tolang`.Suppose you want to clone Slovak from Czech, then do as follows:
+
+```bash
+$ runghc Clone czech slovak Cze Slo
+```
+
+You may want to add the option `--comment-body` after the word `Clone` to comment out every line in the body of the files.
+
+```bash
+$ runghc Clone --comment-body czech slovak Cze Slo
+```
+
+### From a generic template
+
+Often it is easier to start from a rather clean slate, so the recommended way is to clone the [TEMPLATE](TEMPLATE/) module. So suppose you want to start a resource grammar for Albanian, do it as follows:
+
+```bash
+$ runghc Clone TEMPLATE albanian TMP Sqi
+```
+
+You will see more detailed instructions on how to continue from the cloned template in the [README file](template/README.md).
+
+# File hierarchy
+
+The number of files may be overwhelming, but they are related together following the graphic under "Module dependencies" under the rgl-tutorial. In the graphic, an example is that GrammarIta and ResIta are dependent on Prelude as they have arrows pointing towards the Prelude ellipse.
+
+http://www.grammaticalframework.org/lib/doc/rgl-tutorial/index.html
+
+The below graphic is an alternative graphic explaining the relations, taken from private correspondence with Inari.
+
+![File Hierarchy](FileHierarchy.png)
+
+CatLang defines the categories, and the modules AdjectiveLang, NounLang, SentenceLang, PhraseLang, and so on, all extend Cat. The Grammar is defined as a collection of all those AdjectiveLang, NounLang, SentenceLang, and so on modules. LangLang is defined as the collection GrammarLang and LexiconLang and is where you will be checking your program. You may ignore:
+
+- AllLangAbs, AllLang, ExtendLang, ExtraLangAbs, ExtraLang, ConstructionLang, DocumentationLang, MarkupLang, BackwardLang
+
+If the language you cloned from has any of these resource modules, you can remove them completely:
+
+-  IrregLang (unless you want to populate it with irregular verbs of your own language), MissingLang (see how to generate your own if you need it later: https://inariksit.github.io/gf/2018/08/28/gf-gotchas.html#generating-missingxxx)
+
+# Relationships between functions in files
+
+There may be several ways the functions within the files are organised relative to one another. In other words, there may be several schemas depending on the author. More recent RGLs might implement one schema detailed by this blog post by Inari.
+https://inariksit.github.io/gf/2018/08/28/gf-gotchas.html#my-naming-scheme-for-lincats-and-opers
+
+# Main goal
+
+You may think of your long-term goal as eventually implementing all the abstract functions found in the "abstract" folder. In other words, you are somewhat constrained by the available categories in Cat.gf and functions in relevant e.g. Noun.gf, Verb.gf etc. files.
+
+In the future, if you find that the available functions do not apply to your language, you may search in the Extend.gf file for more optional functions, or in Extra.gf. if it doesn't exist, create your own ExtraLangAbs.gf with the concrete ExtraLang.gf, all in the same directory gf-rgl/src/lang. This blog post contains more information.
+
+https://inariksit.github.io/gf/2021/02/15/rgl-api-core-extensions.html#language-specific-extra-modules
+
+There is a prioritised list of RGL functions for new resource grammars written by contributor heatherleaf. You can start by implementing the "+++" functions.
+
+https://github.com/GrammaticalFramework/gf-rgl/issues/238
+
+# Working pipeline example
+
+For a pipeline, You might wish to start with implementing functions that create Noun Phrase like DetCN: Det -> CN -> NP; a function that takes a Determiner and a Common Noun and gives a Noun Phrase. In this case, the workflow is done by editing:
+
+1. ResLang: Contains the relevant Operations (Opers) for e.g. "Noun", "mkN",  "Determiner" and "Quant".
+2. ParamLang: Contains the language paramters used in ResLang.
+3. CatLang: CatLang will be defined in terms of Opers found in ResLang. This means that instead of Defining NP in CatLang as, say, {s: Str}, you will define NP as ResLang.NounPhrase, which points to a NounPhrase Oper in ResLang. Then you need to implement the word syntax in NounLang.
+4. NounLang: Contains the relevant lins in defining sentence structure.
+5. LexiconLang: Contains the lins that define the Noun words.
+
+As you will have to define a determiner that is created from a Quant, you will have to look at the following files too.
+
+6. StructuralLang: Contains the lins that define the Quant/Determiner words.
+
+Note that you will have to use mkQuant instead of creating Det by mkDet directly.
+
+# Testing your work
+
+When you are done with your implementation, you may test that everything works by starting up LangLang and, in this case, writing something like:
+
+```DetCN (DetQuant xxxx_Quant NumSg) (UseN xxxx_N)```
+
+Where you replace 'xxxx' with the word in Lang.

src/TEMPLATE/AdjectiveTMP.gf

@@ -0,0 +1,68 @@
+concrete AdjectiveTMP of Adjective = CatTMP ** open ResTMP, Prelude in {
+
+  flags optimize=all_subs ;
+
+  lin
+
+  -- : AP -> Adv -> AP ; -- warm by nature
+  AdvAP  ap adv = ap ** {
+    s = ap.s ++ adv.s ;
+  } ;
+
+  -- : A  -> AP ;
+  PositA a = a ** {
+    compar = [] ;
+    } ;
+
+  -- : A  -> NP -> AP ;
+  ComparA a np = a ** {
+    compar = np.s
+    } ;
+
+  -- : A2 -> NP -> AP ;  -- married to her
+  -- ComplA2 a2 np = a2 ** { } ;
+
+  -- : A2 -> AP ;        -- married to itself
+  -- ReflA2 a2 = a2 ** { } ;
+
+  -- : A2 -> AP ;        -- married
+  UseA2 = PositA ;
+
+  -- : A  -> AP ;     -- warmer
+  -- UseComparA a = a ** {
+  --   s = \\af => "???" ++ a.s ! af ;
+  --   compar = []
+  --  } ;
+
+
+  -- : CAdv -> AP -> NP -> AP ; -- as cool as John
+  -- CAdvAP adv ap np = ap ** { } ;
+
+-- The superlative use is covered in $Ord$.
+
+  -- : Ord -> AP ;       -- warmest
+  -- AdjOrd ord = ord ** {
+  --   compar = []
+  --   } ;
+  -- AdjOrd : Ord -> AP  =
+  AdjOrd ord = ord ;
+
+-- Sentence and question complements defined for all adjectival
+-- phrases, although the semantics is only clear for some adjectives.
+
+  -- : AP -> SC -> AP ;  -- good that she is here
+  -- SentAP ap sc = ap ** {
+    -- s = \\af => ap.s ! af ++ sc.s
+    -- } ;
+
+-- An adjectival phrase can be modified by an *adadjective*, such as "very".
+
+  -- : AdA -> AP -> AP ;
+  -- AdAP ada ap = ap ** { } ;
+
+
+-- It can also be postmodified by an adverb, typically a prepositional phrase.
+
+
+
+}

src/TEMPLATE/AdverbTMP.gf

@@ -0,0 +1,39 @@
+concrete AdverbTMP of Adverb = CatTMP ** open ResTMP, ParadigmsTMP, Prelude in {
+{-
+lin
+
+  -- : A -> Adv ;
+  PositAdvAdj adj =
+
+  -- : CAdv -> A -> NP -> Adv ; -- more warmly than John
+  ComparAdvAdj cadv a np =
+
+  -- : CAdv -> A -> S  -> Adv ; -- more warmly than he runs
+  ComparAdvAdjS cadv a s =
+
+  -- : Prep -> NP -> Adv ;
+  PrepNP prep np =  ;
+
+-- Adverbs can be modified by 'adadjectives', just like adjectives.
+
+  -- : AdA -> Adv -> Adv ;             -- very quickly
+  AdAdv ada adv = adv **
+
+-- Like adverbs, adadjectives can be produced by adjectives.
+
+  -- : A -> AdA ;                 -- extremely
+  PositAdAAdj a =
+
+  -- Subordinate clauses can function as adverbs.
+
+  -- : Subj -> S -> Adv ;
+  SubjS subj s = {s = subj.s ++ s.s} ;
+
+-- Comparison adverbs also work as numeral adverbs.
+
+  -- : CAdv -> AdN ;                  -- less (than five)
+  AdnCAdv cadv =  ;
+
+-}
+
+}

src/TEMPLATE/AllTMP.gf

@@ -0,0 +1,6 @@
+--# -path=.:../abstract:../common:../prelude
+
+concrete AllTMP of AllTMPAbs =
+  LangTMP,
+  ExtendTMP
+  ;

src/TEMPLATE/AllTMPAbs.gf

@@ -0,0 +1,5 @@
+--# -path=.:../abstract:../common:prelude
+
+abstract AllTMPAbs =
+  Lang,
+  Extend ;

src/TEMPLATE/CatTMP.gf

@@ -0,0 +1,121 @@
+concrete CatTMP of Cat = CommonX ** open ResTMP, Coordination, Prelude in {
+
+  flags optimize=all_subs ;
+
+  lincat
+
+--2 Sentences and clauses
+-- Constructed in SentenceTMP, and also in IdiomTMP
+    S  = SS ;
+    QS = SS ;
+    RS = SS ;
+    -- relative sentence. Tense and polarity fixed,
+    -- but agreement may depend on the CN/NP it modifies.
+
+    Cl = ResTMP.LinCl ;
+    ClSlash = SS ;
+    SSlash  = SS ; -- sentence missing NP; e.g. "she has looked at"
+    Imp     = SS ; -- imperative             e.g. "look at this"
+
+--2 Questions and interrogatives
+
+-- Constructed in QuestionTMP.
+    QCl = SS ;
+    IComp = SS ;   -- interrogative complement of copula  e.g. "where"
+    IDet = SS ;    -- interrogative determiner            e.g. "how many"
+    IQuant = SS ;  -- interrogative quantifier            e.g. "which"
+    IP = SS ;      -- interrogative pronoun               e.g. "who"
+
+--2 Subord clauses and pronouns
+
+    RCl = SS ;
+    RP = SS ;
+
+--2 Verb phrases
+
+-- Constructed in VerbTMP.
+    VP = ResTMP.LinVP ;
+    VPSlash = SS ;
+    Comp = SS ;
+
+--2 Adjectival phrases
+
+-- Constructed in AdjectiveTMP.
+    AP = SS ;
+
+--2 Nouns and noun phrases
+
+-- Constructed in NounTMP.
+-- Many atomic noun phrases e.g. "everybody"
+-- are constructed in StructuralTMP.
+
+    CN = ResTMP.LinCN ;
+    NP = ResTMP.LinNP ;
+    Pron = SS ; -- NB. Pronouns need enough info to become NP or Quant.
+    Det = ResTMP.LinDet ; -- s : Str , n : Number
+    Predet = SS ;
+    Quant = ResTMP.LinQuant ; -- s : Number => Str
+    Num = ResTMP.LinDet ;
+    Card = ResTMP.LinDet ;
+    ACard = SS ;
+    Ord = SS ;
+    DAP = SS ;
+
+
+--2 Numerals
+
+-- Constructed in NumeralTMP.
+
+    Numeral = ResTMP.LinNumeral ;
+    Digits = ResTMP.LinNumeral ;
+
+--2 Structural words
+
+-- Constructed in StructuralTMP.
+    Conj = Coordination.ConjunctionDistr ** {
+        n : Number -- The number of the NP that results from
+                   -- coordinating a list of NPs with that Conj.
+        } ;        -- "[Ann and Bob] are children" → and_Conj.n = Pl
+    Subj = SS ;
+    Prep = SS ;
+
+
+
+--2 Words of open classes
+
+-- These are constructed in LexiconTMP and in
+-- additional lexicon modules.
+
+    -- TODO: eventually different lincats
+    VS,    -- sentence-complement verb            e.g. "claim"
+    VQ,    -- question-complement verb            e.g. "wonder"
+    VA,    -- adjective-complement verb           e.g. "look"
+    V = ResTMP.LinV ;
+
+    VV     -- verb-phrase-complement verb         e.g. "want"
+      = SS ;
+
+    V2A,   -- verb with NP and AP complement      e.g. "paint"
+    V2V,   -- verb with NP and V complement       e.g. "cause"
+    V2S,   -- verb with NP and S complement       e.g. "tell"
+    V2Q,   -- verb with NP and Q complement       e.g. "ask"
+    V2 = SS ;
+    V3 = SS ;
+
+    A = SS ;
+    A2  = SS ;
+
+    N = ResTMP.LinN ;
+    N2 = ResTMP.LinN ;
+    N3 = ResTMP.LinN ;
+    PN = SS ;
+
+    -- From the Names module, not in the official API as of 2023-08
+    GN = SS ; -- Given name,    e.g. "George"
+    SN = SS ; -- Second name,   e.g. "Washington"
+    LN = SS ; -- Location name, e.g. "Sweden"
+
+  linref
+    Cl = linCl ;
+
+}

src/TEMPLATE/ConjunctionTMP.gf

@@ -0,0 +1,147 @@
+concrete ConjunctionTMP of Conjunction =
+  CatTMP ** open ResTMP, Coordination, Prelude in {
+
+  flags optimize=all_subs ;
+
+    {- Conjunction for category X needs four things:
+       lincat [X]
+       lin BaseX
+       lin ConsX
+       lin ConjX
+
+    For example, if X is defined as
+
+      lincat X   = {s     : Number => Str ;   g : Gender} ;
+
+    then [X] will split its s field into two, and retain its other fields as is:
+
+      lincat [X] = {s1,s2 : Number => Str ;   g : Gender} ;
+
+    Let us look at a simple case: Adv is of type {s : Str}
+    Then [Adv] is {s1,s2 : Str}.
+    BaseAdv, ConsAdv and ConjAdv can all use functions defined in prelude/Coordination:
+
+      BaseAdv = twoSS ;
+      ConsAdv = consrSS comma ;
+      ConjAdv = conjunctSS ;
+
+    --}
+
+-----------------------------------------------------------------------------
+-- Adverb and other simple {s : Str} types.
+lincat
+  [Adv],[AdV],[IAdv] = {s1,s2 : Str} ;
+
+lin
+  BaseAdv, BaseAdV, BaseIAdv = twoSS ;
+  ConsAdv, ConsAdV, ConsIAdv = consrSS comma ;
+  ConjAdv, ConjAdV, ConjIAdv = conjunctDistrSS ;
+
+{-
+
+-----------------------------------------------------------------------------
+-- S is sometimes already {s : Str}, sometimes open for mood or word order.
+-- Simply take the lincat of S, and split the s field into s1 and s2.
+-- Then make sure that all of the other fields are retained.
+
+lincat
+  [S] = {s1, s2 : …} ;
+
+lin
+  -- : S -> S -> ListS ;      -- John walks, Mary runs
+  BaseS x y =
+
+  -- : S -> ListS -> ListS ;  -- John walks, Mary runs, Bill swims
+  ConsS x xs =
+
+  -- : Conj -> ListS -> S ;       -- he walks and she runs
+  ConjS conj xs =
+
+-----------------------------------------------------------------------------
+-- RS is variable on … and has inherent …
+-- RS can modify CNs, which are open for …, and have inherent …
+
+lincat
+  [RS] = {s1,s2 : … => Str} ;
+
+lin
+
+  -- : RS -> RS -> ListRS ;       -- who walks, whom I know
+  BaseRS x y =
+
+  -- : RS -> ListRS -> ListRS ;   -- who wals, whom I know, who is here
+  ConsRS x xs =
+
+  -- : Conj -> ListRS -> RS ;     -- who walks and whose mother runs
+  ConjRS conj xs =
+
+
+-----------------------------------------------------------------------------
+-- NP  is variable on … and has inherent …
+
+lincat
+  [NP] = {s1, s2 : …} ;
+
+lin
+  -- : NP -> NP -> ListNP ;      -- John, Mary
+  BaseNP x y =
+
+  -- : NP -> ListNP -> ListNP ;  -- John, Mary, Bill
+  ConsNP x xs =
+
+  -- : Conj -> ListNP -> NP ;     -- she or we
+  ConjNP conj xs =
+
+-----------------------------------------------------------------------------
+-- AP  is variable on … and has an inherent …
+
+lincat
+  [AP] = {s1, s2 : …} ;
+
+lin
+  -- : AP -> AP -> ListAP ;       -- red, white
+  BaseAP x y =
+
+  -- : AP -> ListAP -> ListAP ;   -- red, white, blue
+  ConsAP x xs =
+
+  -- : Conj -> ListAP -> AP ;     -- cold and warm
+  ConjAP conj xs =
+
+-----------------------------------------------------------------------------
+-- CN  is variable on …
+-- CN conjunction is not in the API, so this can be lower prio
+
+lincat
+  [CN] = {s1, s2 : …} ;
+
+lin
+  -- : CN -> CN -> ListCN ;      -- man, woman
+  BaseCN x y =
+
+  -- : CN -> ListCN -> ListCN ;  -- man, woman, child
+  ConsCN x xs =
+
+  -- : Conj -> ListCN -> CN ;     -- man and woman
+  ConjCN conj xs =
+
+-----------------------------------------------------------------------------
+-- Det and DAP
+-- Note that there is no [Det], the way to coordinate Dets is to make them
+-- into DAP first, using Noun.DetDAP : Det -> DAP ;
+-- DAP ("three small") isn't used in any API functions, so lower prio.
+
+lincat
+  [DAP] = {s1, s2 : …} ;
+
+lin
+  -- : DAP -> DAP -> ListDAP ;
+  BaseDAP x y =
+
+  -- : DAP -> ListDAP -> ListDAP ;
+  ConsDAP xs x =
+
+  -- : Conj -> ListDAP -> Det ;   -- his or her
+  ConjDet conj xs =
+-}
+}

src/TEMPLATE/ConstructionTMP.gf

@@ -0,0 +1,117 @@
+concrete ConstructionTMP of Construction = CatTMP ** open ParadigmsTMP in {
+
+lincat
+  Timeunit = N ;
+  Weekday = N ;
+  Monthday = NP ;
+  Month = N ;
+  Year = NP ;
+{-
+lin
+
+  timeunitAdv n time =
+  let n_card : Card   = n ;
+      n_hours_NP : NP = mkNP n_card time ;
+  in  SyntaxTMP.mkAdv for_Prep n_hours_NP | mkAdv (n_hours_NP.s ! R.npNom) ;
+
+  weekdayPunctualAdv w = ;         -- on Sunday
+  weekdayHabitualAdv w = ;         -- on Sundays
+  weekdayNextAdv w =      -- next Sunday
+  weekdayLastAdv w =      -- last Sunday
+
+  monthAdv m = mkAdv in_Prep (mkNP m) ;
+  yearAdv y = mkAdv in_Prep y ;
+  dayMonthAdv d m  =  ; -- on 17 TMP
+  monthYearAdv m y =  ; -- in TMP 2012
+  dayMonthYearAdv d m y =  ; -- on 17 TMP 2013
+
+  intYear = symb ;
+  intMonthday = symb ;
+
+lincat Language = N ;
+
+lin InLanguage l = mkAdv ???_Prep (mkNP l) ;
+
+lin
+  weekdayN w = w ;
+  monthN m = m ;
+
+  weekdayPN w = mkPN w ;
+  monthPN m = mkPN m ;
+
+  languageCN l = mkCN l ;
+  languageNP l = mkNP l ;
+
+
+oper mkLanguage : Str -> N = \s -> mkN s ;
+
+----------------------------------------------
+---- lexicon of special names
+
+lin second_Timeunit = mkN "second" ;
+lin minute_Timeunit = mkN "minute" ;
+lin hour_Timeunit = mkN "hour" ;
+lin day_Timeunit = mkN "day" ;
+lin week_Timeunit = mkN "week" ;
+lin month_Timeunit = mkN "month" ;
+lin year_Timeunit = mkN "year" ;
+
+lin monday_Weekday = mkN "Monday" ;
+lin tuesday_Weekday = mkN "Tuesday" ;
+lin wednesday_Weekday = mkN "Wednesday" ;
+lin thursday_Weekday = mkN "Thursday" ;
+lin friday_Weekday = mkN "Friday" ;
+lin saturday_Weekday = mkN "Saturday" ;
+lin sunday_Weekday = mkN "Sunday" ;
+
+lin january_Month = mkN "January" ;
+lin february_Month = mkN "February" ;
+lin march_Month = mkN "March" ;
+lin april_Month = mkN "April" ;
+lin may_Month = mkN "May" ;
+lin june_Month = mkN "June" ;
+lin july_Month = mkN "July" ;
+lin august_Month = mkN "August" ;
+lin september_Month = mkN "September" ;
+lin october_Month = mkN "October" ;
+lin november_Month = mkN "November" ;
+lin december_Month = mkN "December" ;
+
+lin afrikaans_Language = mkLanguage "Afrikaans" ;
+lin amharic_Language = mkLanguage "Amharic" ;
+lin arabic_Language = mkLanguage "Arabic" ;
+lin bulgarian_Language = mkLanguage "Bulgarian" ;
+lin catalan_Language = mkLanguage "Catalan" ;
+lin chinese_Language = mkLanguage "Chinese" ;
+lin danish_Language = mkLanguage "Danish" ;
+lin dutch_Language = mkLanguage "Dutch" ;
+lin english_Language = mkLanguage "Euslish" ;
+lin estonian_Language = mkLanguage "Estonian" ;
+lin finnish_Language = mkLanguage "Finnish" ;
+lin french_Language = mkLanguage "French" ;
+lin german_Language = mkLanguage "German" ;
+lin greek_Language = mkLanguage "Greek" ;
+lin hebrew_Language = mkLanguage "Hebrew" ;
+lin hindi_Language = mkLanguage "Hindi" ;
+lin japanese_Language = mkLanguage "Japanese" ;
+lin italian_Language = mkLanguage "Italian" ;
+lin latin_Language = mkLanguage "Latin" ;
+lin latvian_Language = mkLanguage "Latvian" ;
+lin maltese_Language = mkLanguage "Maltese" ;
+lin nepali_Language = mkLanguage "Nepali" ;
+lin norwegian_Language = mkLanguage "Norwegian" ;
+lin persian_Language = mkLanguage "Persian" ;
+lin polish_Language = mkLanguage "Polish" ;
+lin punjabi_Language = mkLanguage "Punjabi" ;
+lin romanian_Language = mkLanguage "Romanian" ;
+lin russian_Language = mkLanguage "Russian" ;
+lin sindhi_Language = mkLanguage "Sindhi" ;
+lin spanish_Language = mkLanguage "Spanish" ;
+lin swahili_Language = mkLanguage "Swahili" ;
+lin swedish_Language = mkLanguage "Swedish" ;
+lin thai_Language = mkLanguage "Thai" ;
+lin turkish_Language = mkLanguage "Turkish" ;
+lin urdu_Language = mkLanguage "Urdu" ;
+
+-}
+}

src/TEMPLATE/ExtendTMP.gf

@@ -0,0 +1,35 @@
+--# -path=.:../common:../abstract
+
+concrete ExtendTMP of Extend = CatTMP
+  ** ExtendFunctor - [
+    VPS           -- finite VP's with tense and polarity
+    , ListVPS
+    , VPI
+    , ListVPI -- infinitive VP's (TODO: with anteriority and polarity)
+    , MkVPS
+    , PredVPS
+
+    -- excluded because RGL funs needed for them not implemented yet
+    , SlashBareV2S
+    , PredAPVP
+    , ComplBareVS
+    , AdvIsNP, AdvIsNPAP
+    , CompBareCN
+    , CompIQuant
+    , ComplSlashPartLast
+    , ComplDirectVQ
+    , ComplDirectVS
+    , DetNPFem, DetNPMasc
+    , ExistCN, ExistMassCN, ExistPluralCN, ExistsNP
+    , ExistIPQS, ExistNPQS, ExistS
+    , PredIAdvVP
+    , PrepCN
+    , ReflPossPron
+    , UttVP, UttVPShort, UttAccNP, UttDatNP, UttAccIP, UttDatIP
+    , EmptyRelSlash, StrandQuestSlash, StrandRelSlash
+    , SubjRelNP
+    , UseComp_ser, UseComp_estar
+    , iFem_Pron, weFem_Pron, youFem_Pron, youPlFem_Pron, youPolFem_Pron, youPolPlFem_Pron, youPolPl_Pron, theyFem_Pron, theyNeutr_Pron
+    , GenModNP
+
+  ] with (Grammar=GrammarTMP) ;

src/TEMPLATE/GrammarTMP.gf

@@ -0,0 +1,17 @@
+concrete GrammarTMP of Grammar =
+    NounTMP
+  , VerbTMP
+  , AdjectiveTMP
+  , AdverbTMP
+  , NumeralTMP
+  , SentenceTMP
+  , QuestionTMP
+  , RelativeTMP
+  , ConjunctionTMP
+  , PhraseTMP
+  , TextX
+  , StructuralTMP
+  , IdiomTMP
+  , TenseX
+  , NamesTMP -- Not part of original Grammar, here to trigger compilation
+  ;

src/TEMPLATE/IdiomTMP.gf

@@ -0,0 +1,56 @@
+
+--1 Idiom: Idiomatic Expressions
+
+concrete IdiomTMP of Idiom = CatTMP ** open Prelude, ResTMP, VerbTMP, QuestionTMP, NounTMP, StructuralTMP in {
+
+-- This module defines constructions that are formed in fixed ways,
+-- often different even in closely related languages.
+
+{-
+   lin
+
+
+     -- ImpersCl : VP -> Cl ;        -- it is hot
+     ImpersCl vp = {
+       } ;
+
+      -- : NP -> Cl ;        -- there is a house
+      ExistNP np =
+
+      -- ExistIP   : IP -> QCl ;       -- which houses are there
+      ExistIP ip =
+
+    -- GenericCl : VP -> Cl ;        -- one sleeps
+    GenericCl vp =
+
+    CleftNP   : NP  -> RS -> Cl ; -- it is I who did it
+    CleftAdv  : Adv -> S  -> Cl ; -- it is here she slept
+
+  -- : NP -> Cl ;        -- there is a house
+  ExistNP np =
+
+  ExistIP   : IP -> QCl ;       -- which houses are there
+
+-- 7/12/2012 generalizations of these
+
+    ExistNPAdv : NP -> Adv -> Cl ;    -- there is a house in Paris
+    ExistIPAdv : IP -> Adv -> QCl ;   -- which houses are there in Paris
+
+  -- : VP -> VP ;
+  ProgrVP vp = vp ** {
+    } ;
+
+
+  -- : VP -> Utt ;       -- let's go
+  ImpPl1 vp = { } ;
+
+  ImpP3     : NP -> VP -> Utt ; -- let John walk
+
+-- 3/12/2013 non-reflexive uses of "self"
+
+    SelfAdvVP : VP -> VP ;        -- is at home himself
+    SelfAdVVP : VP -> VP ;        -- is himself at home
+    SelfNP    : NP -> NP ;        -- the president himself (is at home)
+-}
+
+}

src/TEMPLATE/LangTMP.gf

@@ -0,0 +1,5 @@
+--# -path=.:../abstract:../common:../prelude:../api
+concrete LangTMP of Lang =
+  GrammarTMP,
+  LexiconTMP,
+  ConstructionTMP ;

src/TEMPLATE/LexiconTMP.gf

@@ -0,0 +1,419 @@
+concrete LexiconTMP of Lexicon = CatTMP **
+  open ParadigmsTMP, ResTMP in {
+
+----
+-- A
+{-
+lin add_V3 = mkV3 (mkV "")  ;
+lin airplane_N = mkN "" ;
+lin alas_Interj = mkInterj "" ;
+lin already_Adv = mkA "" ;
+lin animal_N = mkN "" ;
+lin answer_V2S = mkV2S (mkV "") ;
+lin apartment_N = mkN "" ;
+lin apple_N = mkN "" ;
+lin art_N = mkN "" ;
+lin ashes_N = mkN "" ;
+lin ask_V2Q = mkV2Q (mkV "") ;
+
+----
+-- B
+
+lin baby_N = mkN "" ;
+lin back_N = mkN "" ;
+lin bad_A = mkA "" ;
+lin bank_N = mkN "" ;
+lin bark_N = mkN "" ;
+lin beautiful_A = mkA "" ;
+lin become_VA = mkVA (mkV "") ;
+lin beer_N = mkN "" ;
+lin beg_V2V = mkV2V (mkV "") ;
+lin belly_N = mkN "" ;
+lin big_A = mkA "" ;
+lin bike_N = mkN "" ;
+lin bird_N = mkN "" ;
+lin bite_V2 = mkV2 "" ;
+lin black_A = mkA "" ; -}
+lin blood_N = mkN "blood" ;
+{-lin blow_V = mkV "" ;
+lin blue_A = mkA "" ;
+lin boat_N = mkN "" ;
+lin bone_N = mkN "" ;
+lin boot_N = mkN "" ;
+lin boss_N = mkN "" ;
+lin book_N = mkN "" ;
+lin boy_N = mkN "" ;
+lin bread_N = mkN "" ;
+lin break_V2 = mkV2 "" ;
+lin breast_N = mkN "" ;
+lin breathe_V = mkV "" ;
+lin broad_A = mkA "" ;
+lin brother_N2 = mkN "" ;
+lin brown_A = mkA "" ;
+lin burn_V = mkV "" ;
+lin butter_N = mkN "" ;
+lin buy_V2 = mkV2 "" ;
+
+----
+-- C
+
+lin camera_N = mkN "" ;
+lin cap_N = mkN "" ;
+lin car_N = mkN "" ;
+lin carpet_N = mkN "" ;
+lin cat_N = mkN "" ;
+lin ceiling_N = mkN "" ;
+lin chair_N = mkN "" ;
+lin cheese_N = mkN "" ;
+lin child_N = mkN "" ;
+lin church_N = mkN "" ;
+lin city_N = mkN "" ;
+lin clean_A = mkA "" ;
+lin clever_A = mkA "" ;
+lin close_V2 = mkV2 "" ;
+lin cloud_N = mkN "" ;
+lin coat_N = mkN "" ;
+lin cold_A = mkA "" ;
+lin come_V = mkV "" ;
+lin computer_N = mkN "" ;
+lin correct_A = mkA "" ;
+lin count_V2 = mkV2 "" ;
+lin country_N = mkN "" ;
+lin cousin_N = mkN "" ;
+lin cow_N = mkN "" ;
+lin cut_V2 = mkV2 "" ;
+
+----
+-- D
+
+lin day_N = mkN "" ; -}
+lin die_V = mkV "die" ;
+{-lin dig_V = mkV "" ;
+lin dirty_A = mkA "" ;
+lin distance_N3 = mkN3 (mkN "") ;
+lin do_V2 = mkV2 "" ;
+lin doctor_N = mkN "" ;
+lin dog_N = mkN "" ;
+lin door_N = mkN "" ;
+lin drink_V2 = mkV2 "" ;
+lin dry_A = mkA "" ;
+lin dull_A = mkA "" ;
+lin dust_N = mkN "" ;
+
+----
+-- E
+
+lin ear_N = mkN "" ;
+lin earth_N = mkN "" ;
+lin eat_V2 = mkV "" ;
+lin egg_N = mkN "" ;
+lin empty_A = mkA "" ;
+lin enemy_N = mkN "" ;
+lin eye_N = mkN "" ;
+
+----
+-- F
+
+lin factory_N = mkN "" ;
+lin fall_V = mkV "" ;
+lin far_Adv = mkA "" ;
+lin fat_N = mkN "" ;
+lin father_N2 = mkN2 (mkN "") ;
+lin fear_V2 = mkV2 "" ;
+lin fear_VS = mkVS (mkV "") ;
+lin feather_N = mkN "" ;
+lin fight_V2 = mkV2 "" ;
+lin find_V2 = mkV2 "" ;
+lin fingernail_N = mkN "" ;
+lin fire_N = mkN "" ;
+lin fish_N = mkN "" ;
+lin float_V = mkV "" ;
+lin floor_N = mkN "" ;
+lin flow_V = mkV "" ;
+lin flower_N = mkN "" ;
+lin fly_V = mkV "" ;
+lin fog_N = mkN "" ;
+lin foot_N = mkN "" ;
+lin forest_N = mkN "" ;
+lin forget_V2 = mkV2 "" ;
+lin freeze_V = mkV "" ;
+lin fridge_N = mkN "" ;
+lin friend_N = mkN "" ;
+lin fruit_N = mkN "" ;
+lin full_A = mkA "" ;
+--lin fun_AV
+
+----
+-- G
+
+lin garden_N = mkN "" ;
+lin girl_N = mkN "" ;
+lin give_V3 = mkV3 (mkV "") ;
+lin glove_N = mkN "" ;
+lin go_V = mkV "" ;
+lin gold_N = mkN "" ;
+lin good_A = mkA "" ;
+lin grammar_N = mkN "" ;
+lin grass_N = mkN "" ;
+lin green_A = mkA "" ;
+
+----
+-- H
+
+lin hair_N = mkN "" ;
+lin hand_N = mkN "" ;
+lin harbour_N = mkN "" ;
+lin hat_N = mkN "" ;
+lin hate_V2 = mkV2 "" ;
+lin head_N = mkN "" ;
+lin hear_V2 = mkV2 "" ;
+lin heart_N = mkN "" ;
+lin heavy_A = mkA "" ;
+lin hill_N = mkN "" ;
+lin hit_V2 = mkV2 "" ;
+lin hold_V2 = mkV2 "" ;
+lin hope_VS = mkV "" ;
+lin horn_N = mkN "" ;
+lin horse_N = mkN "" ;
+lin hot_A = mkA "" ;
+lin house_N = mkN "" ;
+lin hunt_V2 = mkV2 "" ;
+lin husband_N = mkN "" ;
+
+--------
+-- I - K
+
+lin ice_N = mkN "" ;
+lin industry_N = mkN "" ;
+lin iron_N = mkN "" ;
+lin john_PN = mkPN "" ;
+lin jump_V = mkV "" ;
+lin kill_V2 = mkV2 "" ;
+lin king_N = mkN "" ;
+lin knee_N = mkN "" ;
+lin know_V2 = mkV2 "" ;
+lin know_VQ = mkVQ (mkV "") ;
+lin know_VS = mkV "" ;
+
+
+----
+-- L
+
+lin lake_N = mkN "" ;
+lin lamp_N = mkN "" ;
+lin language_N = mkN "" ;
+lin laugh_V = mkV "" ;
+lin leaf_N = mkN "" ;
+lin learn_V2 = mkV2 "" ;
+lin leather_N = mkN "" ;
+lin leave_V2 = mkV2 "" ;
+lin leg_N = mkN "" ;
+lin lie_V = mkV "" ;
+lin like_V2 = mkV2 "" ;
+lin listen_V2 = mkV2 "" ;
+lin live_V = mkV "";
+lin liver_N = mkN "" ;
+lin long_A = mkA "" ;
+lin lose_V2 = mkV2 "" ;
+lin louse_N = mkN "" ;
+lin love_N = mkN "" ;
+lin love_V2 = mkV2 "" ;
+
+----
+-- M
+
+lin man_N = mkN "" ;
+lin married_A2 = mkA2 (mkA "") ;
+lin meat_N = mkN "" ;
+lin milk_N = mkN "" ;
+lin moon_N = mkN "" ;
+lin mother_N2 = mkN2 (mkN "") ;
+lin mountain_N = mkN "" ;
+lin mouth_N = mkN "" ;
+lin music_N = mkN "" ;
+
+----
+-- N
+
+lin name_N = mkN "" ;
+lin narrow_A = mkA "" ;
+lin near_A = mkA "" ;
+lin neck_N = mkN "" ;
+lin new_A = mkA "" ;
+lin newspaper_N = mkN "" ;
+lin night_N = mkN "" ;
+lin nose_N = mkN "" ;
+lin now_Adv = mkAdv "" ;
+lin number_N = mkN "" ;
+
+--------
+-- O - P
+
+
+lin oil_N = mkN "" ;
+lin old_A = mkA "" ;
+lin open_V2 = mkV2 "" ;
+lin paint_V2A = mkV2A (mkV "") ;
+lin paper_N = mkN "" ;
+lin paris_PN = mkPN "Paris" ;
+lin peace_N = mkN "" ;
+lin pen_N = mkN "" ;
+lin person_N = mkN "" ;
+lin planet_N = mkN "" ;
+lin plastic_N = mkN "" ;
+lin play_V = mkV "" ;
+lin policeman_N = mkN "" ;
+lin priest_N = mkN "" ;
+lin pull_V2 = mkV2 "" ;
+lin push_V2 = mkV2 "" ;
+lin put_V2 = mkV2 "" ;
+
+--------
+-- Q - R
+
+
+lin queen_N = mkN "" ;
+lin question_N = mkN "" ;
+lin radio_N = mkN "" ;
+lin rain_N = mkN "" ;
+lin rain_V0 = mkV "" ;
+lin read_V2 = mkV2 "" ;
+lin ready_A = mkA "" ;
+lin reason_N = mkN "" ;
+lin red_A = mkA "" ;
+lin religion_N = mkN "" ;
+lin restaurant_N = mkN "" ;
+lin river_N = mkN "" ;
+lin road_N = mkN "" ;
+lin rock_N = mkN "" ;
+lin roof_N = mkN "" ;
+lin root_N = mkN "" ;
+lin rope_N = mkN "" ;
+lin rotten_A = mkA "" ;
+lin round_A = mkA "" ;
+lin rub_V2 = mkV2 "" ;
+lin rubber_N = mkN "" ;
+lin rule_N = mkN "" ;
+lin run_V = mkV "" ;
+
+----
+-- S
+
+lin salt_N = mkN "" ;
+lin sand_N = mkN "" ;
+lin say_VS = mkVS (mkV "") ;
+lin school_N = mkN "" ;
+lin science_N = mkN "" ;
+lin scratch_V2 = mkV2 "" ;
+lin sea_N = mkN "" ;
+lin see_V2 = mkV2 "" ;
+lin seed_N = mkN "" ;
+lin seek_V2 = mkV2 "" ;
+lin sell_V3 = mkV3 (mkV "" Meng) emptyPrep emptyPrep ; -- TODO
+lin send_V3 = mkV3 (mkV "") ;
+lin sew_V = mkV "" ;
+lin sharp_A = mkA "" ;
+lin sheep_N = mkN "" fem ;
+lin ship_N = mkN "" ;
+lin shirt_N = mkN "" ;
+lin shoe_N = mkN "" ;
+lin shop_N = mkN "" ;
+lin short_A = mkA "" ;
+lin silver_N = mkN "" ;
+lin sing_V = mkV "" ;
+lin sister_N = mkN "" ;
+lin sit_V = mkV "" ;
+lin skin_N = mkN "" ;
+lin sky_N = mkN "" ;
+lin sleep_V = mkV "" ;
+lin small_A = mkA "" ;
+lin smell_V = mkV "" ;
+lin smoke_N = mkN "" ;
+lin smooth_A = mkA "" ;
+lin snake_N = mkN "" ;
+lin snow_N = mkN "" ;
+lin sock_N = mkN "" ;
+lin song_N = mkN "" ;
+lin speak_V2 = mkV2 "" ;
+lin spit_V = mkV "" ;
+lin split_V2 = mkV2 "" ;
+lin squeeze_V2 = mkV2 "" ;
+lin stab_V2 = mkV2 "" ;
+lin stand_V = mkV "" ;
+lin star_N = mkN "" ;
+lin steel_N = mkN "" ;
+lin stick_N = mkN "" ;
+lin stone_N = mkN "" ;
+lin stop_V =  mkV "" ;
+lin stove_N = mkN "" ;
+lin straight_A = mkA "" ;
+lin student_N = mkN "" ;
+lin stupid_A = mkA "" ;
+lin suck_V2 = mkV2 "" ;
+lin sun_N = mkN "" ;
+lin swell_V = mkV "" ;
+lin swim_V = mkV "" ;
+
+----
+-- T
+
+
+lin table_N = mkN "" ;
+lin tail_N = mkN "" ;
+lin talk_V3 = mkV3 (mkV "" Ber) (mkPrep "") (mkPrep "") ;
+lin teach_V2 = mkV2 "" ;
+lin teacher_N = mkN "" ;
+lin television_N = mkN "" ;
+lin thick_A = mkA "" ;
+lin thin_A = mkA "" ;
+lin think_V = mkV "" ;
+lin throw_V2 = mkV2 "" ;
+lin tie_V2 = mkV2 "" ;
+lin today_Adv = mkA "" ;
+lin tongue_N = mkN "" ;
+lin tooth_N = mkN "" ;
+lin train_N = mkN "" ;
+lin travel_V = mkV "" ;
+lin tree_N = mkN "" ;
+lin turn_V = mkV "" ;
+
+--------
+-- U - V
+
+lin ugly_A = mkA "" ;
+lin uncertain_A = mkA "" ;
+lin understand_V2 = mkV2 "" ;
+lin university_N = mkN "" ;
+lin village_N = mkN "" ;
+lin vomit_V = mkV2 "" ;
+
+--------
+-- W - Y
+
+lin wait_V2 = mkV2 "" ;
+lin walk_V = mkV "" ;
+lin war_N = mkN "" ;
+lin warm_A = mkA "" ;
+lin wash_V2 = mkV2 "" ;
+lin watch_V2 = mkV2 "" ;
+lin water_N = mkNoun "" ;
+lin wet_A = mkA "" ;
+lin white_A = mkA "" ;
+lin wide_A = mkA "" ;
+lin wife_N = mkN "" ;
+lin win_V2 = mkV2 "" ;
+lin wind_N = mkN "" ;
+lin window_N = mkN "" ;
+lin wine_N = mkN "" ;
+lin wing_N = mkN "" ;
+lin wipe_V2 = mkV2 "" ;
+lin woman_N = mkN "" ;
+lin wonder_VQ = mkVQ (mkV "") ;
+lin wood_N = mkN "" ;
+lin worm_N = mkN "" ;
+lin write_V2 = mkV2 "" ;
+lin year_N = mkN "" ;
+lin yellow_A = mkA "" ;
+lin young_A = mkA "" ;
+-}
+}

src/TEMPLATE/MissingTMP.gf

@@ -0,0 +1,313 @@
+resource MissingTMP = open GrammarTMP, Prelude in {
+-- temporary definitions to enable the compilation of RGL API
+oper AdAP : AdA -> AP -> AP  = notYet "AdAP" ;
+oper AdAdv : AdA -> Adv -> Adv  = notYet "AdAdv" ;
+oper AdNum : AdN -> Card -> Card  = notYet "AdNum" ;
+oper AdVVP : AdV -> VP -> VP  = notYet "AdVVP" ;
+oper AdVVPSlash : AdV -> VPSlash -> VPSlash  = notYet "AdVVPSlash" ;
+oper AddAdvQVP : QVP -> IAdv -> QVP  = notYet "AddAdvQVP" ;
+oper AdjCN : AP -> CN -> CN  = notYet "AdjCN" ;
+oper AdjDAP : DAP -> AP -> DAP  = notYet "AdjDAP" ;
+oper AdjOrd : Ord -> AP  = notYet "AdjOrd" ;
+oper AdnCAdv : CAdv -> AdN  = notYet "AdnCAdv" ;
+oper AdvAP : AP -> Adv -> AP  = notYet "AdvAP" ;
+oper AdvCN : CN -> Adv -> CN  = notYet "AdvCN" ;
+oper AdvIAdv : IAdv -> Adv -> IAdv  = notYet "AdvIAdv" ;
+oper AdvIP : IP -> Adv -> IP  = notYet "AdvIP" ;
+oper AdvImp : Adv -> Imp -> Imp  = notYet "AdvImp" ;
+oper AdvNP : NP -> Adv -> NP  = notYet "AdvNP" ;
+oper AdvQVP : VP -> IAdv -> QVP  = notYet "AdvQVP" ;
+oper AdvS : Adv -> S -> S  = notYet "AdvS" ;
+oper AdvSlash : ClSlash -> Adv -> ClSlash  = notYet "AdvSlash" ;
+oper AdvVP : VP -> Adv -> VP  = notYet "AdvVP" ;
+oper AdvVPSlash : VPSlash -> Adv -> VPSlash  = notYet "AdvVPSlash" ;
+oper ApposCN : CN -> NP -> CN  = notYet "ApposCN" ;
+oper BaseAP : AP -> AP -> ListAP  = notYet "BaseAP" ;
+oper BaseAdV : AdV -> AdV -> ListAdV  = notYet "BaseAdV" ;
+oper BaseAdv : Adv -> Adv -> ListAdv  = notYet "BaseAdv" ;
+oper BaseCN : CN -> CN -> ListCN  = notYet "BaseCN" ;
+oper BaseIAdv : IAdv -> IAdv -> ListIAdv  = notYet "BaseIAdv" ;
+oper BaseNP : NP -> NP -> ListNP  = notYet "BaseNP" ;
+oper BaseRS : RS -> RS -> ListRS  = notYet "BaseRS" ;
+oper BaseS : S -> S -> ListS  = notYet "BaseS" ;
+oper CAdvAP : CAdv -> AP -> NP -> AP  = notYet "CAdvAP" ;
+oper CleftAdv : Adv -> S -> Cl  = notYet "CleftAdv" ;
+oper CleftNP : NP -> RS -> Cl  = notYet "CleftNP" ;
+oper CompAP : AP -> Comp  = notYet "CompAP" ;
+oper CompAdv : Adv -> Comp  = notYet "CompAdv" ;
+oper CompCN : CN -> Comp  = notYet "CompCN" ;
+oper CompIAdv : IAdv -> IComp  = notYet "CompIAdv" ;
+oper CompIP : IP -> IComp  = notYet "CompIP" ;
+oper CompNP : NP -> Comp  = notYet "CompNP" ;
+oper ComparA : A -> NP -> AP  = notYet "ComparA" ;
+oper ComparAdvAdj : CAdv -> A -> NP -> Adv  = notYet "ComparAdvAdj" ;
+oper ComparAdvAdjS : CAdv -> A -> S -> Adv  = notYet "ComparAdvAdjS" ;
+oper ComplA2 : A2 -> NP -> AP  = notYet "ComplA2" ;
+oper ComplN2 : N2 -> NP -> CN  = notYet "ComplN2" ;
+oper ComplN3 : N3 -> NP -> N2  = notYet "ComplN3" ;
+oper ComplSlash : VPSlash -> NP -> VP  = notYet "ComplSlash" ;
+oper ComplSlashIP : VPSlash -> IP -> QVP  = notYet "ComplSlashIP" ;
+oper ComplVA : VA -> AP -> VP  = notYet "ComplVA" ;
+oper ComplVQ : VQ -> QS -> VP  = notYet "ComplVQ" ;
+oper ComplVS : VS -> S -> VP  = notYet "ComplVS" ;
+oper ComplVV : VV -> VP -> VP  = notYet "ComplVV" ;
+oper ConjAP : Conj -> ListAP -> AP  = notYet "ConjAP" ;
+oper ConjAdV : Conj -> ListAdV -> AdV  = notYet "ConjAdV" ;
+oper ConjAdv : Conj -> ListAdv -> Adv  = notYet "ConjAdv" ;
+oper ConjCN : Conj -> ListCN -> CN  = notYet "ConjCN" ;
+oper ConjDet : Conj -> ListDAP -> Det  = notYet "ConjDet" ;
+oper ConjIAdv : Conj -> ListIAdv -> IAdv  = notYet "ConjIAdv" ;
+oper ConjNP : Conj -> ListNP -> NP  = notYet "ConjNP" ;
+oper ConjRS : Conj -> ListRS -> RS  = notYet "ConjRS" ;
+oper ConjS : Conj -> ListS -> S  = notYet "ConjS" ;
+oper ConsAP : AP -> ListAP -> ListAP  = notYet "ConsAP" ;
+oper ConsAdV : AdV -> ListAdV -> ListAdV  = notYet "ConsAdV" ;
+oper ConsAdv : Adv -> ListAdv -> ListAdv  = notYet "ConsAdv" ;
+oper ConsCN : CN -> ListCN -> ListCN  = notYet "ConsCN" ;
+oper ConsIAdv : IAdv -> ListIAdv -> ListIAdv  = notYet "ConsIAdv" ;
+oper ConsNP : NP -> ListNP -> ListNP  = notYet "ConsNP" ;
+oper ConsRS : RS -> ListRS -> ListRS  = notYet "ConsRS" ;
+oper ConsS : S -> ListS -> ListS  = notYet "ConsS" ;
+oper CountNP : Det -> NP -> NP  = notYet "CountNP" ;
+oper DetCN : Det -> CN -> NP  = notYet "DetCN" ;
+oper DetDAP : Det -> DAP  = notYet "DetDAP" ;
+oper DetNP : Det -> NP  = notYet "DetNP" ;
+oper DetQuantOrd : Quant -> Num -> Ord -> Det  = notYet "DetQuantOrd" ;
+oper EmbedQS : QS -> SC  = notYet "EmbedQS" ;
+oper EmbedS : S -> SC  = notYet "EmbedS" ;
+oper EmbedVP : VP -> SC  = notYet "EmbedVP" ;
+oper ExistIP : IP -> QCl  = notYet "ExistIP" ;
+oper ExistIPAdv : IP -> Adv -> QCl  = notYet "ExistIPAdv" ;
+oper ExistNP : NP -> Cl  = notYet "ExistNP" ;
+oper ExistNPAdv : NP -> Adv -> Cl  = notYet "ExistNPAdv" ;
+oper ExtAdvS : Adv -> S -> S  = notYet "ExtAdvS" ;
+oper ExtAdvVP : VP -> Adv -> VP  = notYet "ExtAdvVP" ;
+oper FunRP : Prep -> NP -> RP -> RP  = notYet "FunRP" ;
+oper GenericCl : VP -> Cl  = notYet "GenericCl" ;
+oper IdRP : RP  = notYet "IdRP" ;
+oper IdetCN : IDet -> CN -> IP  = notYet "IdetCN" ;
+oper IdetIP : IDet -> IP  = notYet "IdetIP" ;
+oper IdetQuant : IQuant -> Num -> IDet  = notYet "IdetQuant" ;
+oper ImpP3 : NP -> VP -> Utt  = notYet "ImpP3" ;
+oper ImpPl1 : VP -> Utt  = notYet "ImpPl1" ;
+oper ImpVP : VP -> Imp  = notYet "ImpVP" ;
+oper ImpersCl : VP -> Cl  = notYet "ImpersCl" ;
+oper MassNP : CN -> NP  = notYet "MassNP" ;
+oper NumCard : Card -> Num  = notYet "NumCard" ;
+oper NumDigits : Digits -> Card  = notYet "NumDigits" ;
+oper NumNumeral : Numeral -> Card  = notYet "NumNumeral" ;
+oper OrdDigits : Digits -> Ord  = notYet "OrdDigits" ;
+oper OrdNumeral : Numeral -> Ord  = notYet "OrdNumeral" ;
+oper OrdNumeralSuperl : Numeral -> A -> Ord  = notYet "OrdNumeralSuperl" ;
+oper OrdSuperl : A -> Ord  = notYet "OrdSuperl" ;
+oper PConjConj : Conj -> PConj  = notYet "PConjConj" ;
+oper PPartNP : NP -> V2 -> NP  = notYet "PPartNP" ;
+oper PartNP : CN -> NP -> CN  = notYet "PartNP" ;
+oper PassV2 : V2 -> VP  = notYet "PassV2" ;
+oper PhrUtt : PConj -> Utt -> Voc -> Phr  = notYet "PhrUtt" ;
+oper PositA : A -> AP  = notYet "PositA" ;
+oper PositAdAAdj : A -> AdA  = notYet "PositAdAAdj" ;
+oper PositAdvAdj : A -> Adv  = notYet "PositAdvAdj" ;
+oper PossNP : CN -> NP -> CN  = notYet "PossNP" ;
+oper PossPron : Pron -> Quant  = notYet "PossPron" ;
+oper PredSCVP : SC -> VP -> Cl  = notYet "PredSCVP" ;
+oper PredVP : NP -> VP -> Cl  = notYet "PredVP" ;
+oper PredetNP : Predet -> NP -> NP  = notYet "PredetNP" ;
+oper PrepIP : Prep -> IP -> IAdv  = notYet "PrepIP" ;
+oper PrepNP : Prep -> NP -> Adv  = notYet "PrepNP" ;
+oper ProgrVP : VP -> VP  = notYet "ProgrVP" ;
+oper QuestCl : Cl -> QCl  = notYet "QuestCl" ;
+oper QuestIAdv : IAdv -> Cl -> QCl  = notYet "QuestIAdv" ;
+oper QuestIComp : IComp -> NP -> QCl  = notYet "QuestIComp" ;
+oper QuestQVP : IP -> QVP -> QCl  = notYet "QuestQVP" ;
+oper QuestSlash : IP -> ClSlash -> QCl  = notYet "QuestSlash" ;
+oper QuestVP : IP -> VP -> QCl  = notYet "QuestVP" ;
+oper ReflA2 : A2 -> AP  = notYet "ReflA2" ;
+oper ReflVP : VPSlash -> VP  = notYet "ReflVP" ;
+oper RelCN : CN -> RS -> CN  = notYet "RelCN" ;
+oper RelCl : Cl -> RCl  = notYet "RelCl" ;
+oper RelNP : NP -> RS -> NP  = notYet "RelNP" ;
+oper RelS : S -> RS -> S  = notYet "RelS" ;
+oper RelSlash : RP -> ClSlash -> RCl  = notYet "RelSlash" ;
+oper RelVP : RP -> VP -> RCl  = notYet "RelVP" ;
+oper SSubjS : S -> Subj -> S -> S  = notYet "SSubjS" ;
+oper SelfAdVVP : VP -> VP  = notYet "SelfAdVVP" ;
+oper SelfAdvVP : VP -> VP  = notYet "SelfAdvVP" ;
+oper SelfNP : NP -> NP  = notYet "SelfNP" ;
+oper SentAP : AP -> SC -> AP  = notYet "SentAP" ;
+oper SentCN : CN -> SC -> CN  = notYet "SentCN" ;
+oper Slash2V3 : V3 -> NP -> VPSlash  = notYet "Slash2V3" ;
+oper Slash3V3 : V3 -> NP -> VPSlash  = notYet "Slash3V3" ;
+oper SlashPrep : Cl -> Prep -> ClSlash  = notYet "SlashPrep" ;
+oper SlashV2A : V2A -> AP -> VPSlash  = notYet "SlashV2A" ;
+oper SlashV2Q : V2Q -> QS -> VPSlash  = notYet "SlashV2Q" ;
+oper SlashV2S : V2S -> S -> VPSlash  = notYet "SlashV2S" ;
+oper SlashV2V : V2V -> VP -> VPSlash  = notYet "SlashV2V" ;
+oper SlashV2VNP : V2V -> NP -> VPSlash -> VPSlash  = notYet "SlashV2VNP" ;
+oper SlashV2a : V2 -> VPSlash  = notYet "SlashV2a" ;
+oper SlashVP : NP -> VPSlash -> ClSlash  = notYet "SlashVP" ;
+oper SlashVS : NP -> VS -> SSlash -> ClSlash  = notYet "SlashVS" ;
+oper SlashVV : VV -> VPSlash -> VPSlash  = notYet "SlashVV" ;
+oper SubjS : Subj -> S -> Adv  = notYet "SubjS" ;
+oper TFullStop : Phr -> Text -> Text  = notYet "TFullStop" ;
+oper Use2N3 : N3 -> N2  = notYet "Use2N3" ;
+oper Use3N3 : N3 -> N2  = notYet "Use3N3" ;
+oper UseA2 : A2 -> AP  = notYet "UseA2" ;
+oper UseCl : Temp -> Pol -> Cl -> S  = notYet "UseCl" ;
+oper UseComp : Comp -> VP  = notYet "UseComp" ;
+oper UseComparA : A -> AP  = notYet "UseComparA" ;
+oper UseCopula : VP  = notYet "UseCopula" ;
+oper UseN : N -> CN  = notYet "UseN" ;
+oper UseN2 : N2 -> CN  = notYet "UseN2" ;
+oper UsePN : PN -> NP  = notYet "UsePN" ;
+oper UsePron : Pron -> NP  = notYet "UsePron" ;
+oper UseQCl : Temp -> Pol -> QCl -> QS  = notYet "UseQCl" ;
+oper UseRCl : Temp -> Pol -> RCl -> RS  = notYet "UseRCl" ;
+oper UseSlash : Temp -> Pol -> ClSlash -> SSlash  = notYet "UseSlash" ;
+oper UseV : V -> VP  = notYet "UseV" ;
+oper UttAP : AP -> Utt  = notYet "UttAP" ;
+oper UttAdv : Adv -> Utt  = notYet "UttAdv" ;
+oper UttCN : CN -> Utt  = notYet "UttCN" ;
+oper UttCard : Card -> Utt  = notYet "UttCard" ;
+oper UttIAdv : IAdv -> Utt  = notYet "UttIAdv" ;
+oper UttIP : IP -> Utt  = notYet "UttIP" ;
+oper UttImpPl : Pol -> Imp -> Utt  = notYet "UttImpPl" ;
+oper UttImpPol : Pol -> Imp -> Utt  = notYet "UttImpPol" ;
+oper UttImpSg : Pol -> Imp -> Utt  = notYet "UttImpSg" ;
+oper UttInterj : Interj -> Utt  = notYet "UttInterj" ;
+oper UttNP : NP -> Utt  = notYet "UttNP" ;
+oper UttQS : QS -> Utt  = notYet "UttQS" ;
+oper UttS : S -> Utt  = notYet "UttS" ;
+oper UttVP : VP -> Utt  = notYet "UttVP" ;
+oper VPSlashPrep : VP -> Prep -> VPSlash  = notYet "VPSlashPrep" ;
+oper VocNP : NP -> Voc  = notYet "VocNP" ;
+oper above_Prep : Prep  = notYet "above_Prep" ;
+oper active2passive : Cl -> Cl  = notYet "active2passive" ;
+oper after_Prep : Prep  = notYet "after_Prep" ;
+oper alas_Interj : Interj  = notYet "alas_Interj" ;
+oper all_Predet : Predet  = notYet "all_Predet" ;
+oper almost_AdA : AdA  = notYet "almost_AdA" ;
+oper almost_AdN : AdN  = notYet "almost_AdN" ;
+oper already_Adv : Adv  = notYet "already_Adv" ;
+oper although_Subj : Subj  = notYet "although_Subj" ;
+oper always_AdV : AdV  = notYet "always_AdV" ;
+oper as_CAdv : CAdv  = notYet "as_CAdv" ;
+oper at_least_AdN : AdN  = notYet "at_least_AdN" ;
+oper at_most_AdN : AdN  = notYet "at_most_AdN" ;
+oper because_Subj : Subj  = notYet "because_Subj" ;
+oper before_Prep : Prep  = notYet "before_Prep" ;
+oper behind_Prep : Prep  = notYet "behind_Prep" ;
+oper between_Prep : Prep  = notYet "between_Prep" ;
+oper both7and_DConj : Conj  = notYet "both7and_DConj" ;
+oper but_PConj : PConj  = notYet "but_PConj" ;
+oper by8agent_Prep : Prep  = notYet "by8agent_Prep" ;
+oper by8means_Prep : Prep  = notYet "by8means_Prep" ;
+oper dconcat : Digits -> Digits -> Digits  = notYet "dconcat" ;
+oper digits2num : Digits -> Numeral  = notYet "digits2num" ;
+oper digits2numeral : Card -> Card  = notYet "digits2numeral" ;
+oper dn : Dig -> Digit  = notYet "dn" ;
+oper dn10 : Dig -> Sub10  = notYet "dn10" ;
+oper dn100 : Dig -> Dig -> Sub100  = notYet "dn100" ;
+oper dn1000 : Dig -> Dig -> Dig -> Sub1000  = notYet "dn1000" ;
+oper dn1000000a : Dig -> Dig -> Dig -> Dig -> Sub1000000  = notYet "dn1000000a" ;
+oper dn1000000b : Dig -> Dig -> Dig -> Dig -> Dig -> Sub1000000  = notYet "dn1000000b" ;
+oper dn1000000c : Dig -> Dig -> Dig -> Dig -> Dig -> Dig -> Sub1000000  = notYet "dn1000000c" ;
+oper during_Prep : Prep  = notYet "during_Prep" ;
+oper either7or_DConj : Conj  = notYet "either7or_DConj" ;
+oper every_Det : Det  = notYet "every_Det" ;
+oper everybody_NP : NP  = notYet "everybody_NP" ;
+oper everything_NP : NP  = notYet "everything_NP" ;
+oper everywhere_Adv : Adv  = notYet "everywhere_Adv" ;
+oper except_Prep : Prep  = notYet "except_Prep" ;
+oper few_Det : Det  = notYet "few_Det" ;
+oper for_Prep : Prep  = notYet "for_Prep" ;
+oper from_Prep : Prep  = notYet "from_Prep" ;
+oper he_Pron : Pron  = notYet "he_Pron" ;
+oper here7from_Adv : Adv  = notYet "here7from_Adv" ;
+oper here7to_Adv : Adv  = notYet "here7to_Adv" ;
+oper here_Adv : Adv  = notYet "here_Adv" ;
+oper how8many_IDet : IDet  = notYet "how8many_IDet" ;
+oper how8much_IAdv : IAdv  = notYet "how8much_IAdv" ;
+oper how_IAdv : IAdv  = notYet "how_IAdv" ;
+oper i_Pron : Pron  = notYet "i_Pron" ;
+oper if_Subj : Subj  = notYet "if_Subj" ;
+oper if_then_Conj : Conj  = notYet "if_then_Conj" ;
+oper in8front_Prep : Prep  = notYet "in8front_Prep" ;
+oper in_Prep : Prep  = notYet "in_Prep" ;
+oper it_Pron : Pron  = notYet "it_Pron" ;
+oper john_PN : PN  = notYet "john_PN" ;
+oper language_title_Utt : Utt  = notYet "language_title_Utt" ;
+oper left_Ord : Ord  = notYet "left_Ord" ;
+oper less_CAdv : CAdv  = notYet "less_CAdv" ;
+oper many_Det : Det  = notYet "many_Det" ;
+oper more_CAdv : CAdv  = notYet "more_CAdv" ;
+oper most_Predet : Predet  = notYet "most_Predet" ;
+oper much_Det : Det  = notYet "much_Det" ;
+oper nd : Digit -> Dig  = notYet "nd" ;
+oper nd10 : Sub10 -> Digits  = notYet "nd10" ;
+oper nd100 : Sub100 -> Digits  = notYet "nd100" ;
+oper nd1000 : Sub1000 -> Digits  = notYet "nd1000" ;
+oper nd1000000 : Sub1000000 -> Digits  = notYet "nd1000000" ;
+oper no_Quant : Quant  = notYet "no_Quant" ;
+oper no_Utt : Utt  = notYet "no_Utt" ;
+oper nobody_NP : NP  = notYet "nobody_NP" ;
+oper not_Predet : Predet  = notYet "not_Predet" ;
+oper nothing_NP : NP  = notYet "nothing_NP" ;
+oper num : Sub1000000 -> Numeral  = notYet "num" ;
+oper num2digits : Numeral -> Digits  = notYet "num2digits" ;
+oper on_Prep : Prep  = notYet "on_Prep" ;
+oper only_Predet : Predet  = notYet "only_Predet" ;
+oper or_Conj : Conj  = notYet "or_Conj" ;
+oper otherwise_PConj : PConj  = notYet "otherwise_PConj" ;
+oper part_Prep : Prep  = notYet "part_Prep" ;
+oper please_Voc : Voc  = notYet "please_Voc" ;
+oper possess_Prep : Prep  = notYet "possess_Prep" ;
+oper pot01 : Sub10  = notYet "pot01" ;
+oper pot1 : Digit -> Sub100  = notYet "pot1" ;
+oper pot110 : Sub100  = notYet "pot110" ;
+oper pot111 : Sub100  = notYet "pot111" ;
+oper pot1plus : Digit -> Sub10 -> Sub100  = notYet "pot1plus" ;
+oper pot1to19 : Digit -> Sub100  = notYet "pot1to19" ;
+oper pot2 : Sub10 -> Sub1000  = notYet "pot2" ;
+oper pot2plus : Sub10 -> Sub100 -> Sub1000  = notYet "pot2plus" ;
+oper pot3 : Sub1000 -> Sub1000000  = notYet "pot3" ;
+oper pot3plus : Sub1000 -> Sub1000 -> Sub1000000  = notYet "pot3plus" ;
+oper quite_Adv : AdA  = notYet "quite_Adv" ;
+oper right_Ord : Ord  = notYet "right_Ord" ;
+oper she_Pron : Pron  = notYet "she_Pron" ;
+oper so_AdA : AdA  = notYet "so_AdA" ;
+oper somePl_Det : Det  = notYet "somePl_Det" ;
+oper someSg_Det : Det  = notYet "someSg_Det" ;
+oper somebody_NP : NP  = notYet "somebody_NP" ;
+oper something_NP : NP  = notYet "something_NP" ;
+oper somewhere_Adv : Adv  = notYet "somewhere_Adv" ;
+oper that_Quant : Quant  = notYet "that_Quant" ;
+oper that_Subj : Subj  = notYet "that_Subj" ;
+oper there7from_Adv : Adv  = notYet "there7from_Adv" ;
+oper there7to_Adv : Adv  = notYet "there7to_Adv" ;
+oper there_Adv : Adv  = notYet "there_Adv" ;
+oper therefore_PConj : PConj  = notYet "therefore_PConj" ;
+oper they_Pron : Pron  = notYet "they_Pron" ;
+oper this_Quant : Quant  = notYet "this_Quant" ;
+oper through_Prep : Prep  = notYet "through_Prep" ;
+oper to_Prep : Prep  = notYet "to_Prep" ;
+oper too_AdA : AdA  = notYet "too_AdA" ;
+oper under_Prep : Prep  = notYet "under_Prep" ;
+oper very_AdA : AdA  = notYet "very_AdA" ;
+oper we_Pron : Pron  = notYet "we_Pron" ;
+oper whatPl_IP : IP  = notYet "whatPl_IP" ;
+oper whatSg_IP : IP  = notYet "whatSg_IP" ;
+oper when_IAdv : IAdv  = notYet "when_IAdv" ;
+oper when_Subj : Subj  = notYet "when_Subj" ;
+oper where_IAdv : IAdv  = notYet "where_IAdv" ;
+oper which_IQuant : IQuant  = notYet "which_IQuant" ;
+oper whoPl_IP : IP  = notYet "whoPl_IP" ;
+oper whoSg_IP : IP  = notYet "whoSg_IP" ;
+oper why_IAdv : IAdv  = notYet "why_IAdv" ;
+oper with_Prep : Prep  = notYet "with_Prep" ;
+oper without_Prep : Prep  = notYet "without_Prep" ;
+oper yes_Utt : Utt  = notYet "yes_Utt" ;
+oper youPl_Pron : Pron  = notYet "youPl_Pron" ;
+oper youPol_Pron : Pron  = notYet "youPol_Pron" ;
+oper youSg_Pron : Pron  = notYet "youSg_Pron" ;
+}

src/TEMPLATE/NamesTMP.gf

@@ -0,0 +1,36 @@
+concrete NamesTMP of Names = CatTMP ** open Prelude in {
+
+-- An API layer to deal with names
+-- Not part of the RGL API, but used in the AW project
+-- So depends on your goals whether this is high or low priority to implement.
+{-
+  lin
+    -- : GN -> NP ;
+    GivenName gn =
+
+    -- : SN -> NP ;
+    MaleSurname sn =
+
+    -- : SN -> NP ;
+    FemaleSurname sn =
+
+    -- : SN -> NP ;
+    PlSurname sn =
+
+    -- : GN -> SN -> NP ;
+    FullName gn sn =
+
+  lin
+    -- : LN -> NP ;
+    UseLN ln =
+
+    -- : LN -> NP ;
+    PlainLN ln =
+
+    -- : LN -> Adv ;
+    InLN ln =
+
+    -- : AP -> LN -> LN ;
+    AdjLN ap ln =
+-}
+}

src/TEMPLATE/NounTMP.gf

@@ -0,0 +1,210 @@
+concrete NounTMP of Noun = CatTMP ** open ResTMP, Prelude in {
+
+  flags optimize=all_subs ;
+
+  lin
+
+--2 Noun phrases
+
+-- : Det -> CN -> NP
+    DetCN det cn = emptyNP ** {
+      s = det.s ++ cn.s ! det.n
+      } ;
+{-
+  -- : PN -> NP ;
+  -- Assuming that lincat PN = lincat NP
+  UsePN pn = pn ;
+
+  -- : Pron -> NP ;
+  -- Assuming that lincat Pron = lincat NP
+  UsePron pron = pron ;
+
+  -- : Predet -> NP -> NP ; -- only the man
+  PredetNP predet np =
+
+-- A noun phrase can also be postmodified by the past participle of a
+-- verb, by an adverb, or by a relative clause
+
+  -- low prio
+  -- : NP -> V2  -> NP ;    -- the man seen
+  -- PPartNP np v2 = np ** {
+  --   s =
+  -- } ;
+
+  -- : NP -> Adv -> NP ;    -- Paris today
+  AdvNP np adv = np ** {
+    s = np.s ++ "," ++ adv.s
+  } ;
+
+  -- : NP -> Adv -> NP ;    -- boys, such as ..
+  ExtAdvNP np adv = AdvNP np {s = "," ++ adv.s} ;
+
+  -- : NP -> RS -> NP ;    -- Paris, which is here
+    RelNP np rs = np ** {
+
+      } ;
+
+-- Determiners can form noun phrases directly.
+
+  -- : Det -> NP ;
+    DetNP det = emptyNP ** {
+      s = \\_ => linDet det ;
+      } ;
+-}
+  -- MassNP : CN -> NP ;
+    MassNP cn = emptyNP ** {
+      s = linCN cn
+      } ;
+
+
+--2 Determiners
+
+-- The determiner has a fine-grained structure, in which a 'nucleus'
+-- quantifier and an optional numeral can be discerned.
+
+  -- : Quant -> Num -> Det ;
+    DetQuant quant num = quant ** {
+      s = quant.s ! num.n ++ num.s ;
+      n = num.n ;
+      } ;
+
+  -- : Quant -> Num -> Ord -> Det ;
+    -- DetQuantOrd quant num ord = quant ** {
+
+    -- } ;
+
+-- Whether the resulting determiner is singular or plural depends on the
+-- cardinal.
+
+-- All parts of the determiner can be empty, except $Quant$, which is
+-- the "kernel" of a determiner. It is, however, the $Num$ that determines
+-- the inherent number.
+
+  NumSg = {s = [] ; n = Sg} ;
+  NumPl = {s = [] ; n = Pl} ;
+
+{-
+  -- : Card -> Num ;    -- two
+  NumCard card = card ;
+
+  -- : Digits  -> Card ;
+  NumDigits dig = -- probably like OrdDigits, but choose the NCard form
+
+  -- : Numeral -> Card ;
+  NumNumeral num = {
+    s = num.s ! NCard ;
+    n = num.n -- inherits grammatical number (Sg, Pl, …) from the Numeral
+    } ;
+
+  -- : AdN -> Card -> Card ;
+  AdNum adn card = card ** { s = adn.s ++ card.s } ;
+
+  -- : Digits  -> Ord ;
+  OrdDigits digs = digs ** { s = digs.s ! NOrd } ;
+
+  -- : Numeral -> Ord ;
+  OrdNumeral num = {
+    s = num.s ! NOrd
+    } ;
+
+  -- : A       -> Ord ;
+  OrdSuperl a = {
+    s = "most" ++ a.s ! Superl
+    } ;
+
+-- One can combine a numeral and a superlative.
+
+  -- : Numeral -> A -> Ord ; -- third largest
+  OrdNumeralSuperl num a = {
+    s = num.s ! NOrd ++ a.s ! Superl
+  } ;
+-}
+
+  -- : Quant
+  DefArt = mkQuant "the" "the" ;
+
+  -- : Quant
+  IndefArt = mkQuant "a" [] ;
+
+{-
+  -- : Pron -> Quant        -- my
+  PossPron pron = mkQuant pron.s ** {
+
+    } ;
+-}
+
+--2 Common nouns
+
+  -- : N -> CN
+  UseN n = n ;
+
+{-
+  -- : N2 -> CN ;
+  UseN2 n2 =
+
+  -- : N2 -> NP -> CN ;
+  ComplN2 n2 np =
+
+  -- : N3 -> NP -> N2 ;    -- distance from this city (to Paris)
+  ComplN3 n3 np =
+
+  -- : N3 -> N2 ;          -- distance (from this city)
+  Use2N3 n3 = lin N2 n3 ** { c2 = n3.c3 } ;
+
+  -- : N3 -> N2 ;          -- distance (to Paris)
+  Use3N3 n3 = lin N2 n3 ;
+
+  -- : AP -> CN -> CN
+  AdjCN ap cn =
+
+  -- : CN -> RS -> CN ;
+  RelCN cn rs =
+
+
+  -- : CN -> Adv -> CN ;
+  AdvCN cn adv =
+
+-- Nouns can also be modified by embedded sentences and questions.
+-- For some nouns this makes little sense, but we leave this for applications
+-- to decide. Sentential complements are defined in VerbTMP.
+
+  -- : CN -> SC  -> CN ;   -- question where she sleeps
+  SentCN cn sc =
+
+--2 Apposition
+
+-- This is certainly overgenerating.
+
+  -- : CN -> NP -> CN ;    -- city Paris (, numbers x and y)
+  ApposCN cn np = cn ** {
+    s =
+    } ;
+
+--2 Possessive and partitive constructs
+-- NB. Below this, the functions are not in the API, so lower prio to implement
+
+  -- : PossNP  : CN -> NP -> CN ;
+  -- in English: book of someone; point is that we can add a determiner to the CN,
+  -- so it can become "a book of someone" or "the book of someone"
+  PossNP cn np =
+
+
+  -- : Det -> NP -> NP ; -- three of them, some of the boys
+  CountNP det np = -- Nonsense for DefArt or IndefArt, but don't worry about that! RGL can contain weird sentences, as long as it contains the non-weird stuff we want
+
+
+  -- : CN -> NP -> CN ;     -- glass of wine / two kilos of red apples
+  PartNP cn np =
+
+--3 Conjoinable determiners and ones with adjectives
+
+  -- : DAP -> AP -> DAP ;    -- the large (one)
+  AdjDAP dap ap = dap ** {
+
+    } ;
+
+  -- : Det -> DAP ;          -- this (or that)
+  DetDAP det = det ;
+-}
+
+}

src/TEMPLATE/NumeralTMP.gf

@@ -0,0 +1,115 @@
+concrete NumeralTMP of Numeral = CatTMP [Numeral,Digits] **
+  open Prelude, ResTMP in {
+
+  lincat
+    Digit = LinNumeral ;      -- 2..9
+    Sub10,                    -- 1..9
+    Sub100,                   -- 1..99
+    Sub1000,                  -- 1..999
+    Sub1000000,               -- 1..999999
+    Sub1000000000,            -- 1..999999999
+    Sub1000000000000          -- 1..999999999999
+     = LinNumeral ;
+
+-- param CardOrd   defined in ResTMP
+-- type LinNumeral  -""-
+
+
+  lin
+    -- : Sub1000000 -> Numeral ; -- 123456 [coercion to top category]
+    num x = x ;
+
+    -- : Digit ;
+    n2 = mkNumeral "two" ;
+    n3 = mkNumeral "three" ;
+    n4 = mkNumeral "four" ;
+    n5 = mkNumeral "five" ;
+    n6 = mkNumeral "six" ;
+    n7 = mkNumeral "seven" ;
+    n8 = mkNumeral "eight" ;
+    n9 = mkNumeral "nine" ;
+
+    -- : Sub10 ;                            -- 1
+    -- pot01 =
+
+    -- : Digit -> Sub10 ;                   -- d * 1
+    pot0 d = d ;
+
+    -- : Sub100 ;                           -- 10
+    -- pot110 = mkNum "ten" ;
+
+    -- : Sub100 ;                           -- 11
+    -- pot111 = mkNum "eleven" ;
+
+    -- : Digit -> Sub100 ;                  -- 10 + d
+    -- pot1to19 d =
+
+    -- : Sub10 -> Sub100 ;                  -- coercion of 1..9
+    pot0as1 n = n ;
+
+    -- : Digit -> Sub100 ;                  -- d * 10
+    -- pot1 d =
+
+    -- : Digit -> Sub10 -> Sub100 ;         -- d * 10 + n
+    -- pot1plus d e =
+
+    -- : Sub100 -> Sub1000 ;                -- coercion of 1..99
+    pot1as2 n = n ;
+
+    -- : Sub10 -> Sub1000 ;                 -- m * 100
+    -- pot2 d =
+
+    -- : Sub10 -> Sub100 -> Sub1000 ;       -- m * 100 + n
+    -- pot2plus d e =
+
+    -- : Sub1000 -> Sub1000000 ;            -- coercion of 1..999
+    pot2as3 n = n ;
+
+    -- : Sub1000 -> Sub1000000 ;            -- m * 1000
+    -- pot3 d =
+
+    -- : Sub1000 -> Sub1000 -> Sub1000000 ; -- m * 1000 + n
+    -- pot3plus d e =
+
+--------------------------------------------------------------------------------
+-- Numerals as sequences of digits have a separate, simpler grammar
+--
+
+  lincat
+    Dig = LinDig ;  -- single digit 0..9
+
+  lin
+    -- : Dig -> Digits ;       -- 8
+    IDig d = d ;
+
+    -- : Dig -> Digits -> Digits ; -- 876
+    IIDig d e = {
+      s = table {
+        NCard => glue (d.s ! NCard) (e.s ! NCard) ;
+        NOrd => glue (d.s ! NCard) (e.s ! NOrd)
+        } ;
+      n = Pl ;
+      } ;
+
+    -- : Dig ;
+    D_0 = mkDig "0" ;
+    D_1 = mkDig "1" ;
+    D_2 = mkDig "2" ;
+    D_3 = mkDig "3" ;
+    D_4 = mkDig "4" ;
+    D_5 = mkDig "5" ;
+    D_6 = mkDig "6" ;
+    D_7 = mkDig "7" ;
+    D_8 = mkDig "8" ;
+    D_9 = mkDig "9" ;
+
+  oper
+    LinDig : Type = {s : CardOrd => Str ; n : Number} ;
+    mkDig : Str -> LinDig = \s -> {
+      s = table {
+        NCard => s ;
+        NOrd  => s + "th"
+        } ;
+      n = Pl ; -- TODO: handle number 1
+      } ;
+}

src/TEMPLATE/ParadigmsTMP.gf

@@ -0,0 +1,211 @@
+resource ParadigmsTMP = open CatTMP, ResTMP, NounTMP, Prelude in {
+
+oper
+
+--2 Parameters
+--
+-- To abstract over number, valency and (some) case names,
+-- we define the following identifiers. The application programmer
+-- should always use these constants instead of the constructors
+-- defined in $ResSom$.
+
+  Prep : Type ;
+  noPrep : Prep ;
+
+  -- Add more overload instances if needed for all categories!
+
+--2 Nouns
+
+  mkN : overload {
+    mkN : Str -> N ; -- Predictable nouns
+  } ;
+
+  mkPN : overload {
+    mkPN : Str -> PN ; -- Proper nouns
+  } ;
+
+--2 Adjectives
+
+  mkA : overload {
+    mkA : Str -> A ; -- Predictable adjective
+  } ;
+
+  mkA2 : overload {
+    mkA2 : Str -> A2 ; -- Predictable A2, no preposition
+    mkA2 : A -> Prep -> A2 ; -- A2 made from A and Prep
+  } ;
+
+--2 Verbs
+
+  -- Verbs
+  mkV : overload {
+    mkV : Str -> V ; -- Predictable verb
+  } ;
+
+
+  mkV2 : overload {
+    mkV2 : Str -> V2 ;  -- Predictable transitive verb
+    mkV2 : V -> Prep  -> V2 ;   -- V2 made from V and Prep
+    } ;
+
+  mkV3 : overload {
+    mkV3 : V -> V3 ; -- No prepositions
+    mkV3 : V -> Prep -> Prep -> V3 ; -- Prepositions for direct and indirect objects given
+    } ;
+
+  mkVV : overload {
+    mkVV : V -> VV ;
+   } ;
+
+  mkVA : overload {
+    mkVA : V -> VA ;
+   } ;
+
+  mkVQ : overload {
+    mkVQ : V -> VQ ;
+   } ;
+
+  mkVS : overload {
+    mkV : V -> VS ;
+  } ;
+
+  -- Etc. do the same for other V subcats (V2A, V2V, V2S, …)
+
+
+  -----
+
+--2 Structural categories
+
+  -- If prepositions take case, add that as argument to mkPrep
+  mkPrep : overload {
+    mkPrep : Str -> Prep ;
+    } ;
+
+  mkConj : overload {
+    mkConj : (and : Str) -> Conj ; -- (coffee) and (tea)
+    mkConj : (either : Str) -> (or : Str) -> Conj ; -- either (coffee) or (tea)
+    } ;
+
+  mkSubj : overload {
+    mkSubj : Str -> Subj ;
+    } ;
+
+  mkAdv : overload {
+    mkAdv : Str -> Adv ;
+    } ;
+
+  mkAdV : overload {
+    mkAdV : Str -> AdV ;
+    } ;
+
+  mkAdA : overload {
+    mkAdA : Str -> AdA ;
+    } ;
+
+
+--.
+-------------------------------------------------------------------------------
+-- The definitions should not bother the user of the API. So they are
+-- hidden from the document.
+
+  Prep = CatTMP.Prep ;
+  noPrep = mkPrep [] ;
+
+  -- Add more overload instances if needed for all categories!
+
+  -- For explanation of `lin N`, see
+  -- https://inariksit.github.io/gf/2018/05/25/subtyping-gf.html#lock-fields
+
+  mkN = overload {
+    mkN : Str -> N = \s -> lin N (ResTMP.mkNoun s) ;
+    -- TODO: more overload instances
+  } ;
+
+{-
+  mkPN = overload {
+    mkPN : Str -> PN = …
+  } ;
+
+--2 Adjectives
+
+  mkA = overload {
+    mkA : Str -> A = \s -> …
+  } ;
+
+  mkA2 = overload {
+    mkA2 : Str -> A2 = \s -> …
+    mkA2 : A -> Prep -> A2 = \s -> …
+  } ;
+
+--2 Verbs
+-}
+  -- Verbs
+  mkV = overload {
+    mkV : Str -> V = \s -> lin V (mkVerb s) ;
+  } ;
+
+{-
+
+  mkV2 = overload {
+    mkV2 : Str -> V2 = \s -> …
+    mkV2 : V -> Prep -> V2 = \s -> …
+    } ;
+
+  mkV3 = overload {
+    mkV3 : V -> V3 = \s -> …
+    mkV3 : V -> Prep -> Prep -> V3 = \s -> …
+    } ;
+
+  mkVV = overload {
+    mkVV : V -> VV = \s -> …
+   } ;
+
+  mkVA = overload {
+    mkVA : V -> VA = \s -> …
+   } ;
+
+  mkVQ = overload {
+    mkVQ : V -> VQ = \s -> …
+   } ;
+
+
+  mkVS = overload {
+    mkV : V -> VS = \s -> …
+  } ;
+
+  -- Etc. do the same for other V subcats (V2A, V2V, V2S, …)
+
+
+  -----
+-}
+
+  -- If prepositions take case, add that as argument to mkPrep
+  mkPrep = overload {
+    mkPrep : Str -> Prep = \s -> lin Prep {s = s} ;
+    } ;
+{-
+  mkConj = overload {
+    mkConj : (and : Str) -> Conj = \s -> …
+    mkConj : (either : Str) -> (or : Str) -> Conj = \s -> …
+    } ;
+
+  mkSubj = overload {
+    mkSubj : Str -> Subj = \s -> …
+    } ;
+
+  mkAdv = overload {
+    mkAdv : Str -> Adv = \s -> …
+    } ;
+
+  mkAdV = overload {
+    mkAdV : Str -> AdV = \s -> …
+    } ;
+
+  mkAdA = overload {
+    mkAdA : Str -> AdA = \s -> …
+    } ;
+
+-}
+--------------------------------------------------------------------------------
+
+}

src/TEMPLATE/PhraseTMP.gf

@@ -0,0 +1,27 @@
+concrete PhraseTMP of Phrase = CatTMP ** open Prelude, ResTMP in {
+
+  lin
+    PhrUtt pconj utt voc = {s = pconj.s ++ utt.s ++ voc.s} ;
+
+    UttS s = s ;
+{-
+    UttQS qs = qs ;
+    UttIAdv iadv = iadv ;
+    UttNP np =
+    UttIP ip =
+    UttImpSg pol imp = { s = pol.s ++ imp.s ! Sg ! pol.p } ;
+    UttImpPl pol imp =
+    UttImpPol pol imp = {s = pol.s ++ imp.s ! Sg ! pol.p} ;
+    UttVP vp = {s = linVP vp} ;
+    UttAP ap = { s = ap.s } ;
+    UttAdv adv = {s = } ;
+    UttCN n = {s = } ;
+    UttCard n = {s = } ;
+    UttInterj i = i ; -}
+    NoPConj = {s = []} ;
+--    PConjConj conj = {s = conj.s1 ++ conj.s2 ! …} ;
+
+    NoVoc = {s = []} ;
+--    VocNP np = { s = "," ++ np.s ! … } ;
+
+}

src/TEMPLATE/QuestionTMP.gf

@@ -0,0 +1,105 @@
+concrete QuestionTMP of Question = CatTMP ** open
+  Prelude, ResTMP, ParadigmsTMP, (V=VerbTMP), (Noun=NounTMP), (S=StructuralTMP) in {
+
+-- A question can be formed from a clause ('yes-no question') or
+-- with an interrogative.
+-- Interrogative pronouns can be formed with interrogative
+-- determiners, with or without a noun.
+
+{-
+lin
+  -- : IDet -> CN -> IP ;       -- which five songs
+  IdetCN idet cn = Noun.DetCN idet cn ** {
+    } ;
+
+  -- : IDet       -> IP ;       -- which five
+  IdetIP idet = Noun.DetNP idet ** {sp = idet.sp};
+
+  -- : IQuant -> Num -> IDet ;  -- which (five)
+  IdetQuant iquant num = iquant ** {
+    } ;
+
+  -- : IP -> ClSlash -> QCl ; -- whom does John love
+  QuestSlash ip cls = cls ** {
+
+    } ;
+
+  -- : Cl -> QCl ;
+  QuestCl cl = cl ** {
+    };
+
+
+  -- : IP -> VP -> QCl ;
+  QuestVP ip cl =  cl ** {
+    } ;
+
+  -- : IAdv -> Cl -> QCl ;    -- why does John walk
+  QuestIAdv iadv cls = {
+    } ;
+
+  -- : IP -> IComp ;
+  CompIP ip = {s = ip.s !  } ;    -- who (is it)
+
+  -- : IComp -> NP -> QCl ;   -- where is John?
+  QuestIComp icomp np = {
+    } ;
+
+
+-- Interrogative pronouns can be formed with interrogative
+-- determiners, with or without a noun.
+
+  -- : IDet -> CN -> IP ;       -- which five songs
+  IdetCN idet cn =
+
+  -- : IDet       -> IP ;       -- which five
+  IdetIP idet =
+
+-- They can be modified with adverbs.
+
+  -- : IP -> Adv -> IP ;        -- who in Paris
+  AdvIP = Noun.AdvNP ;
+
+-- Interrogative quantifiers have number forms and can take number modifiers.
+
+  -- : IQuant -> Num -> IDet ;  -- which (five)
+  IdetQuant = Noun.DetQuant ;
+
+-- Interrogative adverbs can be formed prepositionally.
+  -- : Prep -> IP -> IAdv ;     -- with whom
+  PrepIP prep ip =
+
+-- They can be modified with other adverbs.
+
+  -- : IAdv -> Adv -> IAdv ;    -- where in Paris
+  AdvIAdv iadv adv =
+
+-- Interrogative complements to copulas can be both adverbs and
+-- pronouns.
+
+  -- : IAdv -> IComp ;
+  CompIAdv iadv = iadv ;            -- where (is it)
+
+
+-- More $IP$, $IDet$, and $IAdv$ are defined in $Structural$.
+
+-- Wh questions with two or more question words require a new, special category.
+
+  lincat
+    -- buy what where
+    QVP =
+  lin
+    -- : VPSlash -> IP -> QVP ;   -- buys what
+    ComplSlashIP vps ip =
+
+    -- : VP  ->   IAdv -> QVP ;   -- lives where
+    AdvQVP vp iadv =
+
+    -- : QVP ->   IAdv -> QVP ;   -- buys what where
+    AddAdvQVP qvp iadv =
+
+    -- : IP -> QVP -> QCl ;       -- who buys what where
+    QuestQVP ip qvp =
+-}
+
+
+}

src/TEMPLATE/README.md

@@ -0,0 +1,391 @@
+# TEMPLATE
+
+This is a starting point to clone a new RGL language. It has some pre-populated lincats and lins, mostly in the `Noun` module, but also a few minimal things for verbs and sentences. This README contains a guided tour of lincats and lins to implement first, and the modules also contain comments and suggestions aimed for new grammarians.
+
+**If you want a 100% just strings template**, you can find that in [github.com/daherb/gf-rgl-template](https://github.com/daherb/gf-rgl-template). If you choose the string-only template, you can still read this document for suggestions about implementation order.
+
+- [How to use this tutorial](#how-to-use-this-tutorial)
+- [Guided tour: what to implement first?](#guided-tour-what-to-implement-first)
+  * [1. N-CN-NP(-AP)](#1-n-cn-np-ap)
+    + [Already implemented](#already-implemented)
+    + [Next steps](#next-steps)
+      - [More morphology](#more-morphology)
+      - [More syntax](#more-syntax)
+    + [How about adjectives?](#how-about-adjectives)
+    + [Side note: a word about MassNP](#side-note-a-word-about-massnp)
+  * [2. V-VP](#2-v-vp)
+    + [Already implemented](#already-implemented-1)
+    + [Next steps](#next-steps-1)
+      - [Add morphology](#add-morphology)
+      - [Add syntax](#add-syntax)
+  * [3. Cl-S-Utt-Phr](#3-cl-s-utt-phr)
+    + [Already implemented](#already-implemented-2)
+    + [Next steps](#next-steps-2)
+      - [Declarative sentences](#declarative-sentences)
+      - [Imperatives](#imperatives)
+    + [Unused or nonexistent forms?](#unused-or-nonexistent-forms)
+- [Choose your own adventure: what to implement next](#choose-your-own-adventure-what-to-implement-next)
+  * [Questions](#questions)
+  * [Adjectives](#adjectives)
+  * [Relative clauses](#relative-clauses)
+  * [Numerals](#numerals)
+  * [Conjunctions](#conjunctions)
+    + [List without inflection table and single field](#list-without-inflection-table-and-single-field)
+    + [List with inflection table and multiple fields](#list-with-inflection-table-and-multiple-fields)
+    + [Inspiration from existing RGL languages](#inspiration-from-existing-rgl-languages)
+  * [Phrases](#phrases)
+  * [Idioms](#idioms)
+  * [Symbol](#symbol)
+  * [Extend](#extend)
+- [Functions outside the API or otherwise lower priority](#functions-outside-the-api-or-otherwise-lower-priority)
+# How to use this tutorial
+
+If you haven't done so yet, clone your language from this template as instructed [here](../README.md#from-a-generic-template). The cloning doesn't include README.md, so there's only one copy of this README document.
+
+You can open the grammar in a GF shell and see its functions as follows. (I'm using here the `TMP` concrete syntax, but you should have cloned it to some other concrete syntax with a different extension, so substitute as necessary.)
+
+```
+$ gf LangTMP.gf
+Lang> gr -depth=6  | l -treebank
+Lang: PhrUtt NoPConj (UttS (UseCl (TTAnt TPres ASimul) PPos (PredVP (DetCN (DetQuant DefArt NumSg) (UseN blood_N)) (UseV die_V)))) NoVoc
+LangTMP: the blood die
+```
+
+There are also a couple of unit tests in the [`unittest`](/unittest) directory. To see how to use them, see the [instructions](https://github.com/GrammaticalFramework/gf-rgl/tree/master/unittest#readme).
+
+
+# Guided tour: what to implement first?
+
+In this section, I group the RGL functions in clusters and suggest an implementation order. If you have different needs, e.g. you're making the resource grammar for a particular application and need specific RGL functions for that, feel free to prioritise your needs. I'm giving this list as a suggestion for people who just want something to start from.
+
+## 1. N-CN-NP(-AP)
+
+Most of these are in the Noun module. This is the cluster that has most work done in this template.
+
+### Already implemented
+
+With the following functions, it is possible to construct simple noun phrases.
+
+- `DetCN`
+- `DetQuant`
+- `DefArt`, `IndefArt` (no problem if they are empty strings in your language!)
+- `NumSg`, `NumPl`
+- `MassNP`
+- `UseN`
+- `blood_N` (in Lexicon module)
+
+You can see all NPs with the following command:
+
+```bash
+Lang> gt -cat=NP | l -treebank
+```
+
+### Next steps
+
+#### More morphology
+Check the categories and params in `ResTMP`: how well do they apply to your language? Is the initial implementation missing inflectional features that your language has, like case, gender/noun class, other numbers like dual?
+
+If so, then I would suggest adding the missing morphology before implementing any new syntactic functions. Whenever you change a lincat, e.g. by making something that used to be a Str into an inflection table, all the lins that handle that lincat will break. So it's less painful to change the lincats when the amount of lins is still small.
+
+#### More syntax
+Once you're happy with the morphology, you can start with other lins and lincats. In addition to nouns, the RGL allows making NPs out of pronouns and proper nouns:
+- lincat for `Pron`
+- lin for `UsePron` and `PossPron`
+- lin for some `Pron`s in Structural
+- lincat for `PN`
+- lin for `UsePN`
+- lin for `john_PN` and `paris_PN` in Lexicon
+
+You can also make the NPs a bit more varied by adding more quantifiers and modifiers:
+- lins for more `Quant`s, `Det`s etc. in Structural
+
+Some things in the Noun module will have to wait for other categories to be done. For instance, `AdjCN` relies on adjectives, `RelCN` on relatives, `NumCard` and `NumNumeral` on numerals, none of which is (properly) implemented in this template. So feel free to postpone the rest.
+
+### How about adjectives?
+
+In some languages, adjectives behave like nouns. In other languages, they behave like verbs. In yet other languages, the situation is more complicated. But if your language happens to be one where adjectives are like nouns, it's pretty cheap to just implement adjectives here as well. The minimal set is as follows:
+
+- lincat for `A` and `AP`
+- lin for some `A`s from Lexicon
+- lin for `PositA` and `AdjCN`
+
+But if adjectives are rather like verbs (e.g. Korean), or there are other complications (e.g. Zulu), just postpone their implementation.
+
+
+### Side note: a word about MassNP
+In the Noun module, there is a function called `MassNP : CN -> NP`. This is a *mass construction*, which is usually applied to mass nouns like "water".
+
+However, the RGL does not contain a semantic distinction between mass and count nouns, and thus the `MassNP` function can be applied to any CN. Sometimes this results in semantically weird results.
+
+As a resource grammarian, don't worry if `MassNP` applied to count nouns sounds weird. It's the application grammarian's problem to choose when to use MassNP and when DetCN. If `MassNP` sounds good when applied to mass nouns, then you're doing it right.
+
+## 2. V-VP
+
+### Already implemented
+
+For verbs, we have much fewer things implemented: a single intransitive verb, and a function that elevates an intransitive verb into a VP.
+
+* `UseV`
+* `die_V` (in Lexicon module)
+
+You can see all (=1) VPs with the following command.
+
+```bash
+Lang> gt -cat=VP | l -treebank
+Langs: UseV die_V
+LangTMP: die
+```
+
+### Next steps
+
+#### Add morphology
+
+Just like with nouns, look at the `VForm` param in the Res module, and add the missing inflectional features. If verbs are very complex in your language, it's fine to start with a smaller subset, e.g. only indicative mood, or only a couple of tenses.
+
+Again, you should extend the `VForm` param, and change the lincats of `V` and `VP` in other ways, if needed. It is very common that the lincat for `VP` has many fields, so that it
+
+In addition, you could implement some morphological paradigms, so that you can add some verbs in the lexicon.
+
+#### Add syntax
+
+In addition to intransitive verbs (`V`), the GF RGL has a large set of verb subcategories. So now you can start adding lincats to `V2` (direct object), `VV` (verbal complement), `VS` (sentence complement) etc.
+
+The most important are the following:
+
+- lincat for `V2` and `VPSlash`
+- lin for some `V2`s from Lexicon
+- lin for `SlashV2a` and `ComplSlash`
+
+If you have done a thorough implementation on noun morphology, you might find it useful here. For instance, if verbs mark their arguments with cases, now is a great time to add those cases as *inherent* argument in the verbs. (For explanation on parametric vs. inherent, see [GF tutorial](https://www.grammaticalframework.org/doc/tutorial/gf-tutorial.html#toc54)).
+
+Another way to make VPs is to use adjectives, noun phrases and adverbials as complements. If you haven't implemented adjectives yet, feel free to skip them at this step. But the other complements should be in reach already, so the next most important steps are the following:
+
+- lincat for `Comp`
+- lin for `CompNP`, (`CompAdv`) and `UseComp`
+- (If you already have AP: lin for `CompAP`)
+
+These functions don't care whether your language has an explicit copula or not. Just implement whatever strategy that it uses for non-V❋ predication.
+
+In terms of word order, you could consider how adverbials attach to verbs.
+
+## 3. Cl-S-Utt-Phr
+
+At this level, there is rarely new morphology to be added, but there can be interesting decisions about e.g. word order or subordination.
+
+### Already implemented
+
+The following rarely need any changes. By the time an `Utt` is reached, the grammatical decisions should have been already made, and the lincats of `Utt` and `Phr` should be just `{s : Str}`.
+- `PhrUtt`
+- `NoPConj`, `NoVoc`
+- `UttS`
+
+The following functions, and the lincats they operate on, are implemented in the most naive only-strings way, and they need to be changed.
+- `UseCl`
+- `TTAnt`, `TPres`, `TPast`, `TFut`, `TCond`, `ASimul`, `AAnter`
+- `PPos`, `PNeg`
+- `PredVP`
+
+### Next steps
+
+#### Declarative sentences
+
+If you have added verb inflection in the V❋ and VP categories, then you need to connect them to the Cl category. `PredVP : NP → VP → Cl` picks the correct person inflection from its VP argument, but any tense and polarity is still open. So in most languages, the lincat of `Cl` should have an inflection table, and only `UseCl : Temp → Pol → Cl → S` will choose the final form.
+
+Sometimes even the lincat of `S` has an inflection table or it is discontinuous. That's because `S` can be used in a VP or an Adv, and in those cases, it may have a different word order or inflectional form than as standalone sentence.
+
+If you're not sure whether the lincat of `S` should be still open for something, try to implement the following functions and see if it needs tweaking.
+
+- `ComplVS : VS → S → VP`
+- `SubjS : Subj → S → Adv`
+
+#### Imperatives
+
+In the Sentence module, there are also functions to construct imperatives. Depending on your language, it could be rather easy to implement them after you've added declarative sentences. But nothing depends on imperatives, so you can as well postpone them.
+
+### Unused or nonexistent forms?
+
+What if your language has no form that corresponds to e.g. future anterior negative (*won't have walked*)? That's fine, you can put some other form in that slot and move on.
+
+What if your language has tenses, aspects, moods, politeness forms or any other inflection that isn't accessible via the core RGL? That's fine too, you can always create a language-specific extra module with functions that do access them. If you're working towards a specific application that needs such forms, then you should of course prioritise them. But if covering the core RGL that is in the API is the most important, feel free to postpone all the verbal inflection that is not accessible via the core.
+
+# Choose your own adventure: what to implement next
+
+If you've implemented the first 3 clusters, you already have a nice chunk of the RGL!
+You have tackled many of the hard decisions, so it's natural that these things can take a long time, and you may need to revise often.
+
+The following set doesn't have to be followed in any particular order.
+
+## Questions
+
+The Question module introduces interrogative noun phrases (`IP`) like *who* or *whose car*, and question clauses (`QCl`) and sentences (`QS`). Their implementation is often similar to that of noun phrases and declarative clauses and sentences.
+
+Compared to declarative sentences, questions may require more variation in word order. You may need to make some fields discontinuous, e.g. splitting a single `s` field (e.g. *eat porridge*) of a VP into `verb` (*eat*) and `complement` (*porridge*).
+
+The minimal set to get questions is the following:
+- lincat for `QCl`
+- lin for `QuestCl`
+With these, you get yes/no questions, like "do you walk".
+
+To get wh-questions, like "who walks", you first need the `IP` category for interrogative noun phrases. Here's a full set for wh-questions with the IP as a subject.
+- lincat for `IP`, `IDet` and `IQuant`
+- lin for `IDetCN`, `IdetQuant`
+- lin for some `IQuant`s and `IP`s in Structural
+- lin for `QuestVP`
+
+The next thing to add is `IAdv` for interrogative adverbs, like "why" or "where". With these, you can ask questions like "why do you walk" and "where are you".
+- lincat for `IAdv`
+- lin for some `IAdv`s in Structural, and/or `PrepIP` in Question
+- lin for `QuestIAdv`
+- lincat for `IComp`
+- lin for `CompIAdv`, `CompIP` and `QuestIComp`
+
+Finally, we can also make a question using `IP` as an object, e.g. "who do you like". Where previously we have formed QCls from a normal VP with a special subject (`IP` instead of `NP`), here we introduce a new category `ClSlash`, which is a `Cl` missing an object. So you need the following:
+- lincat for `ClSlash`
+- lin for `QuestSlash`
+
+## Adjectives
+
+If you haven't implemented adjectives yet, it's about time! If your adjectives are more of the nouny type, I hope it's rather straightforward to do them. The minimal cluster is the following:
+
+- lincat for `A` and `AP`
+- lin for `PositA` and `AdjCN`
+- lin for `CompAP`, check whether you have to update lincat for `Comp`
+
+If adjectives behave like verbs, then the lincat for `Comp` and lin for `CompAP` can reuse the lincats and lins of the V-VP cluster. But `AdjCN` can be a bit difficult. Based on previous RGL languages that have verby adjectives, you get a lot of synergy with the Relative module. Basically, APs as modifiers behave just like relative clauses, so `AdjCN` and `RelCN` are similar or even identical.
+
+## Relative clauses
+
+These may be complicated, so feel free to postpone until further. But if your APs are verby, it makes sense to implement these in parallel with `AdjCN`, because you will need some way of making verby/clause-y things into modifiers.
+
+## Numerals
+
+There is a tentative lincat for numerals, and linearisations for the digits `D_0..D_9` and `n2..n9`, as well as the simple coercions `pot0`, `pot0as1`, `pot1as2`, `pot2as3` and `num`. However, it's possible that the simple lincat needs to be changed, and so I haven't implemented any of the lins that do something complex.
+
+The numeral module the oldest piece of code in the RGL, and hence it looks pretty strange compared to the rest of the RGL. If you don't understand it, don't worry–just leave it aside until you have other parts implemented. Nothing depends on it, and in fact, I would recommend that your N-CN-NP cluster is solid before you do numerals, because then you know better which inflectional features are needed in numerals.
+
+But eventually the time comes to tackle numerals. First tip is to check in https://github.com/GrammaticalFramework/gf-contrib/tree/master/numerals whether someone has already implemented them for your language, or a close relative that behaves similarly. Second tip is to look at the existing implementation of any RGL language that you know, and try to reverse engineer based on that. But even if these tips don't work, please submit your grammar to gf-rgl anyway! A grammar without full numeral implementation is much better than no grammar at all.
+
+Once you have some kind of implementation of the Numeral module, you can connect it to the Noun module by implementing the following. The minimal meaningful set is these two:
+
+- `NumNumeral : Numeral -> Card`
+- `NumCard : Card -> Num`
+
+With these, you get a `Num` that can be used in `DetQuant` to make a Det, and that unlocks numerals as determiners, like "two cats".
+
+## Conjunctions
+
+Conjunction for category X needs 4 things:
+
+- lincat for `[X]`
+- lin for `BaseX`
+- lin for `ConsX`
+- lin for `ConjX`
+
+For example, if `X` is defined as
+```haskell
+lincat X   = {s     : Case => Str ;   a : Agr} ;
+```
+then `[X]` will split its s field into two, and retain its other fields as is:
+
+```haskell
+lincat [X] = {s1,s2 : Case => Str ;   a : Agr} ;
+```
+
+### List without inflection table and single field
+
+Let's start with a simple case: Adv is of type `{s : Str}`. Then `[Adv]` is `{s1,s2 : Str}`.
+`BaseAdv`, `ConsAdv` and `ConjAdv` can all use functions defined in [prelude/Coordination](../prelude/Coordination.gf):
+
+```haskell
+lin BaseAdv = twoSS ;
+lin ConsAdv = consrSS comma ;
+lin ConjAdv = conjunctSS ;
+```
+
+### List with inflection table and multiple fields
+
+Let's take the previous example and call it NP. Our lincats are as follows:
+```haskell
+lincat
+  NP  = {s     : Case => Str ; a : Agr} ; -- in Cat
+ [NP] = {s1,s2 : Case => Str ; a : Agr} ; -- in Conjunction
+```
+
+Now we need to do a bit more work in our linearisations.
+```haskell
+lin
+ BaseNP x y = twoTable Case x y ** {a = conjAgr x.a y.a} ;
+
+oper
+  conjAgr : Agr -> Agr -> Agr ;
+  conjAgr agr1 agr2 = -- TODO actual implementation
+```
+First, we use the [twoTable](https://github.com/GrammaticalFramework/gf-rgl/blob/master/src/prelude/Coordination.gf#L57-L60) oper from Coordination, which puts the right values in the right fields.
+
+But it doesn't deal with the rest of the fields, `g : Agr` in our case, and so we need to put it in manually. That's what happens in the *record extension* with the two stars. To combine two Agrs into one Agr, we define an oper `conjAgr`, that takes two Agrs and returns their combination.
+
+Then let's do the rest of the linearisations.
+
+```haskell
+lin
+  ConsNP x xs = consrTable NPCase comma x xs ** {a = conjAgr xs.a x.a} ;
+  ConjNP conj xs = conjunctDistrTable NPCase conj xs ** {
+      a = -- xs.a, with possible Number input from the Conj
+      } ;
+```
+ConsNP is similar to BaseNP, except that we will now include the separator character. `comma` is defined as the string "," in Prelude, but other languages use other characters, e.g. **、** in Chinese.
+
+ConjNP puts together a NP from the list of NPs, using a conjunction: "Inari, Krasimir and Aarne". This resulting NP has to also have an `a` field, and in this final stage, we are putting together the `conjAgr` from all the arguments, and also taking into account the Conj itself. For instance, in [English style guides](https://editorsmanual.com/articles/compound-subject-singular-or-plural/),
+
+> Two or more nouns joined by and form a plural compound subject, which takes plural verbs. But when a compound subject contains or or nor, the verb should agree with the part of the subject closest to it.
+
+So in the English resource grammar, `and_Conj` has an inherent number Pl, and `or_Conj` has an inherent number Sg. If your language doesn't do that, then it's just the list of NPs that determines the agreement of the resulting coordinated NP.
+
+### Inspiration from existing RGL languages
+
+Most existing RGL languages use the Coordination module and its opers that are rather cryptic. Sometimes you can copy and paste an existing RGL language, just adjust the arity of the opers (e.g. call `twoTable3` instead of `twoTable2`) and which `param`s are given to those opers as argument. Other times you need to do more manual tweaking.
+
+Here are some examples of [coordination strategies that are more complex than English](https://inariksit.github.io/gf/2021/02/22/lists.html#natural-language-strategies-beyond-a-b-and-c). The more your language differs from English, the more work you need to do in the internal params.
+
+Some of the categories that have list instances may not be able to coordinate in your language. In such a case, you can decide whether to leave it unimplemented (thus trying to use it via the API gives an exception), or linearise something ungrammatical.
+
+## Phrases
+
+In the Phrase module, there are functions that create standalone utterances of multiple RGL categories. They are usually rather easy to implement: the `Utt` category should be just a `{s : Str}`, and the task is to decide which of the inflection forms is the standalone form.
+
+## Idioms
+
+The Idiom module defines constructions that are formed in idiosyncratic ways. Examples of its constructions are impersonal and generic clauses ("it is warm") and clefts ("it is John who sleeps"). This module is not a dependency of any other module, and its constructions are less frequent than the core modules like Noun and Verb. So this can be done whenever you like.
+
+
+## Symbol
+
+The Symbol module (exported in the API as Symbolic) is used for embedding symbolic notation in natural-language text, e.g. "level 4". This module is not a dependency of any other, and it mostly depends on Noun. So it can be done any time after the N-CN-NP cluster is solid.
+
+## Extend
+
+As the name suggests, this is an extension and not in the API. See [here](https://inariksit.github.io/gf/2021/02/15/rgl-api-core-extensions.html#extend) for more explanation.
+
+In my experience, the generalisations of VP are useful: `VPS` (VP with a tense and polarity), `VPI` (infinitival VP) and their transitive counterparts `VPS2` and `VPI2`. With these, you can do VP conjunctions, like "she runs and sings", "to eat and sleep".
+
+Extend is a rather large module, and not all funs have meaningful lins in all languages. So don't feel pressured to fill Extend all at once; often grammarians just add linearisations when the need arises for a particular structure.
+
+# Functions outside the API or otherwise lower priority
+
+What is low or high priority depends on the application. But if you want some general guidelines, these are usually less used, or not in the API at all.
+
+### Not in the API
+
+- The category DAP + its functions
+- CountNP, PossNP, PartNP
+- OrdNumeralSuperl
+- List instance for CN
+TODO: continue the list
+
+### Expensive
+
+- `SlashV2VNP` is often expensive, because it has so many arguments.
+
+For any function that turns out to be expensive, you can comment it out when implementing other parts of the grammar.
+
+###

src/TEMPLATE/RelativeTMP.gf

@@ -0,0 +1,24 @@
+concrete RelativeTMP of Relative = CatTMP ** open
+  ResTMP, Prelude in {
+
+{-
+lin
+  -- : Cl -> RCl ;            -- such that John loves her
+  RelCl cl = cl ** {
+    } ;
+
+  -- : RP -> VP -> RCl ;
+  RelVP rp vp = {
+    } ;
+
+  -- : RP -> ClSlash -> RCl ; -- who I went with
+  RelSlash rp cls = {
+    } ;
+
+  -- : RP ;
+  IdRP = {s = "that"} ;
+
+  -- : Prep -> NP -> RP -> RP ;  -- the mother of whom
+  FunRP prep np rp =
+-}
+}

src/TEMPLATE/ResTMP.gf

@@ -0,0 +1,296 @@
+resource ResTMP = open Prelude, Predef in {
+
+--------------------------------------------------------------------------------
+-- General notes
+
+-- ** Naming **
+{-
+I'm using the naming scheme for lincats and opers as explained here:
+https://inariksit.github.io/gf/2018/08/28/gf-gotchas.html#my-naming-scheme-for-lincats-and-opers
+-}
+
+-- ** File structure **
+-- The rest of this module is organised as follows:
+
+      -----------------------------
+      -- Grammatical categor(y|ies)
+
+      {-
+      General comments on the cat(s)
+
+      params related to the cat(s)
+
+      opers related to the cat(s)
+      -}
+
+--------------------------------------------------------------------------------
+-- Nouns
+
+{-The param Number comes from common/ParamX, and has the values Sg and Pl.
+    * If your language doesn't have number, remove Number from all records.
+    * If your language has number with more than 2 values, define your own number in this module
+      (e.g. uncomment line 56) and use that Number instead of Number.
+
+  The param Gender is defined here, and has the values Gender1 and Gender2.
+  Currently it's only as a suggestion to be an inherent field in LinN.
+    * If your language doesn't have gender, remove Gender from all records.
+    * If your language has genders/noun classes, replace the placeholder Gender1 and Gender1
+      with the actual values of your language (there can be more than 2!), and uncomment
+      the g : Gender field from the definition of LinN.
+
+  If your nouns inflect in more things, like case, you can do one of the following
+    * Replace the placeholder cases on line 53 and make the table 2-dimensional, like this:
+        oper LinN : Type = {s : Number => Case => Str ; …} ;
+    * Make your own parameter that combines all the relevant features, like this:
+        param NForm = Whatever | You | Need | For | Noun | Inflection ;
+        oper LinN : Type = {s : NForm => Str ; …} ;
+      This can be a good idea, if your inflection table has some gaps, i.e. not all combinations are in use
+      See https://gist.github.com/inariksit/708ab9df2498e88bc63aedf5fc7be2f3#file-tables-gf-L48-L122 for explanation
+ -}
+
+param
+  Gender = Gender1 | Gender2 ;   -- Just a placeholder, see lines 34-39 above
+  Case = Case1 | Case2 | Case3 ; -- Just a placeholder, see lines 41-48 above
+  Number = Sg
+         | Pl
+--       | Dual -- If your language has numbers other than Sg and Pl, add them to the parameter
+         ;
+  Person = P1 | P2 | P3 ;
+
+oper
+  LinN : Type = {
+    s :
+--      Case =>     -- uncomment if your language has case
+        Number =>   -- variable number: table {Sg => "house" ; Pl => "houses"}
+        Str ;
+  --  g : Gender ;  -- inherent gender/noun class, if your language has that
+    } ;
+
+  -- Most often, the lincat for CN is the same as N, with possibly some additional fields.
+  -- However, sometimes you need more fields than just the s field, e.g. to keep word order flexible, or to add clitics and make sure they attach to the head, not modifiers.
+  -- If you don't know what the previous line means, you can get started with just a single s field.
+  -- You'll notice later whether you need such a field or not.
+  LinCN : Type = LinN
+    -- ** {postmod/premod/… : Str} -- if needed
+    ;
+
+  LinPN : Type = {
+    s : Str ;
+    n : Number ; -- Proper nouns often have already an inherent number; you don't usually say "a Paris / many Parises"
+    -- g : Gender ; -- inherent gender/noun class, if your language has that
+  } ;
+
+  -- For inflection paradigms, see http://www.grammaticalframework.org/doc/tutorial/gf-tutorial.html#toc56
+  mkNoun : Str -> LinN = \str -> {
+    s = table {
+      _ => str -- TODO: actual morphology
+      } ;
+      -- If your nouns have gender, it should come here as inherent field.
+      -- Usually you need to give the gender as an argument to mkNoun.
+    } ;
+
+  linCN : LinCN -> Str = \cn -> cn.s ! Sg
+                     --      ++ cn.postmod   -- If there is another field, use here
+                                ;
+
+---------------------------------------------
+-- Numeral
+
+-- Used in NumeralTMP
+  param
+    CardOrd = NCard | NOrd ;
+
+  oper
+    LinNumeral : Type = {s : CardOrd => Str ; n : Number} ;
+
+    mkNumeral : Str -> LinNumeral = \s -> {
+      s = table {
+        NCard => s ;
+        NOrd  => s + "th"
+        } ;
+      n = Pl ; -- NB. probably singular for number 1
+      } ;
+
+---------------------------------------------
+-- Pronoun
+
+{-The param Person comes from common/ParamX, and has the values P1, P2 and P3.
+    * If your language doesn't inflect in person, you may be able to remove Person from all records.
+      - However, consider if it's really never present? How about e.g. reflexive ("myself", "yourself" etc?)
+    * If your language is more fine-grained than {P1,P2,P3} x {Sg,Pl} (for instance gender and familiarity),
+      you can define your own param. We provide an example called Agr to take inspiration from—remove if
+      not needed, or use and refine if needed.
+-}
+
+param
+  -- These params are just for inspiration, not used anywhere currently.
+  Agr = SgP1             -- I
+      | SgP2 Politeness  -- e.g. tū, tum, āp (Hindi) — note that the verb really inflects differently for all three!
+      | SgP3 Gender      -- e.g. he, she (verb inflects the same, but distinction in reflexive: himself / herself)
+      | FillInTheRestYourself ;
+  Politeness = Intimate | Familiar | Polite ;
+
+oper
+  LinPron : Type = {
+    s : Str ;
+    -- Alternative if your language has case and pronouns inflect in case (e.g. English I/me/my, she/her/hers)
+    -- s : Case => Str ;
+    n : Number ;
+    p : Person ;
+    -- Alternative to the `n` and `p` fields:
+    -- a : Agr -- sketched above, lines 97-103
+    } ;
+
+  mkPron : (_ : Str) -> Person -> Number -> LinPron = \str,per,num -> {
+    s = str ;
+    {- If there is case inflection, you need a table here
+        table {
+              _ => str -- Pronoun inflection is often irregular, so possibly this constructor requires several forms as argument, even if mkNoun is nice and regular
+            } ;
+    -}
+    p = per ;
+    n = num
+    } ;
+
+---------------------------------------------
+-- NP
+
+{-
+In the RGL, a NP may come from a common noun, proper noun or pronoun.
+Pronouns are the only ones that have an inherent person (nouns are almost always 3rd person! please give me counterexamples if you can think of any.)
+So we can often say that NP's lincat is the same as Prons.
+
+NB. for later, when you want to make Pron into possessives, you may need more fields in LinPron than in LinNP.
+That's why I'm copying over the definition below, instead of the neater `LinNP : Type = LinPron`.
+-}
+
+  LinNP : Type = {
+    s : Str ;
+    -- Alternative: If anything inflects in case (nouns, pronouns), NP has to also inflect in case!
+    -- s : Case => Str ;
+    n : Number ;
+    p : Person ;
+    -- Alternative to the `n` and `p` fields:
+    -- a : Agr -- sketched on lines 97-101
+    } ;
+
+  linNP : LinNP -> Str = \np -> np.s ; -- Change when you change LinNP
+
+  emptyNP : LinNP = { -- Change when you change LinNP
+    s = [] ;
+    n = Sg ;
+    p = P3 ;
+  } ;
+
+--------------------------------------------------------------------------------
+-- Det, Quant, Card, Ord
+
+  -- If your language has a number, it is very very very likely that
+  -- Quant has a variable number and Det has inherent number.
+
+  LinQuant : Type = {
+    s,  -- quantifier in a context, e.g. 'this (cat) (is nice)'
+    sp  -- quantifier as standalone, e.g. 'this (is nice)'
+     : Number => Str ;
+    } ;
+
+  LinDet : Type = {
+    s : Str ;
+    n : Number ;
+    } ;
+
+  -- Can you reuse your mkNoun? Do nouns and quantifiers inflect the same way?
+  mkQuant : Str -> Str -> LinQuant = \this, these -> {
+    s,
+    sp = table {
+      Sg => this ;
+      Pl => these } ;
+    };
+
+  mkDet : Str -> Number -> LinDet = \str, num -> {
+    s = str ;
+    n = num
+  } ;
+
+--------------------------------------------------------------------------------
+-- Adpositions
+
+{- The main use of Prep is in the fun
+
+      PrepNP : Prep -> NP -> Adv
+
+   Despite the name of the RGL category, a 'Prep' can be a preposition, postposition,
+   or just an instruction to choose a particular case from the NP.
+   A language may use one, two or all these strategies.
+
+-}
+
+oper
+  LinPrep : Type = {
+    s : Str ;
+
+    -- If your language has cases, and different prepositions choose different cases.
+    -- c2 : Case ;
+
+    -- If your language has both pre- and postpositions, you need an inherent parameter in Prep to record which one a given Prep is.
+    -- position : PreOrPost ;
+    } ;
+
+
+--------------------------------------------------------------------------------
+-- Adjectives
+
+  LinA : Type = SS ;
+  LinA2 : Type = LinA ;
+
+  mkAdj : Str -> LinA = \str -> {s = str} ;
+
+  AdjPhrase : Type = LinA ; -- ** {compar : Str} ;
+--------------------------------------------------------------------------------
+-- Verbs
+
+param
+  VForm = TODOVF Number Person ;
+
+oper
+  LinV : Type = {
+    s : VForm => Str
+    } ;
+
+  LinV2 : Type = LinV ** {
+    c2 : LinPrep ;
+    } ;
+
+  mkVerb : Str -> LinV = \str -> {
+    s = table {
+      _ => str
+      }
+    } ;
+
+  copula : LinV = {s = \\_ => "TODO: copula"} ; -- often useful
+
+------------------
+-- VP
+
+  LinVP : Type = {
+    s : VForm => Str ;
+    } ;
+
+  LinVPSlash : Type = LinVP ** {
+    c2 : LinPrep ;
+    } ;
+
+  linVP : LinVP -> Str = \vp -> vp.s ! TODOVF Sg P3 ;
+
+--------------------------------------------------------------------------------
+-- Cl, S
+
+  -- Operations for clauses, sentences
+  LinCl : Type = {
+    subj : Str ;
+    pred : Str ; -- TODO: depend on Temp and Pol
+  } ;
+
+  linCl : LinCl -> Str = \cl -> cl.subj ++ cl.pred ;
+
+}

src/TEMPLATE/SentenceTMP.gf

@@ -0,0 +1,76 @@
+
+concrete SentenceTMP of Sentence = CatTMP ** open
+  TenseX, ResTMP, (AM=AdverbTMP), Prelude in {
+
+flags optimize=all_subs ;
+
+lin
+
+--2 Clauses
+
+  -- : NP -> VP -> Cl
+  PredVP np vp = {
+    subj = np.s ; -- ! Nom, if there are cases
+    pred =
+     -- table {something with tense+polarity =>
+            vp.s ! TODOVF np.n np.p
+            -- TODO: all of the VP's tense and polarity should be open here!
+            -- PredVP only decides the subject.
+     -- }
+  } ;
+
+{-
+  -- : SC -> VP -> Cl ;         -- that she goes is good
+  PredSCVP sc vp = ;
+
+--2 Clauses missing object noun phrases
+  -- : NP -> VPSlash -> ClSlash ;
+  SlashVP =
+
+  -- : ClSlash -> Adv -> ClSlash ;     -- (whom) he sees today
+  AdvSlash cls adv =
+
+  -- : Cl -> Prep -> ClSlash ;         -- (with whom) he walks
+  SlashPrep cl prep = cl ** {c2 = prep} ;
+
+-- Imperatives
+  -- : VP -> Imp ;
+  ImpVP vp =
+
+--2 Embedded sentences
+
+  -- : S  -> SC ;
+  EmbedS s =
+
+  -- : QS -> SC ;
+  EmbedQS qs =
+
+  -- : VP -> SC ;
+  EmbedVP vp =
+-}
+--2 Sentences
+
+  -- : Temp -> Pol -> Cl -> S ;
+  UseCl t p cl = {
+    s = cl.subj ++ t.s ++ p.s ++ cl.pred --  ! t.t ! p.p  -- eventually
+    } ;
+{-
+  -- : Temp -> Pol -> QCl -> QS ;
+  UseQCl t p cl =
+
+  -- : Temp -> Pol -> RCl -> RS ;
+  UseRCl t p cl =
+
+  -- AdvS : Adv -> S  -> S ;            -- then I will go home
+  AdvS adv s =
+
+  -- ExtAdvS : Adv -> S  -> S ;         -- next week, I will go home
+  ExtAdvS adv s =
+
+  -- : S -> Subj -> S -> S ;
+  SSubjS s1 subj s2 =
+
+  --  : S -> RS -> S ;              -- she sleeps, which is good
+  RelS sent rs =
+-}
+}

src/TEMPLATE/StructuralTMP.gf

@@ -0,0 +1,171 @@
+concrete StructuralTMP of Structural = CatTMP **
+  open Prelude, ResTMP, (Noun=NounTMP), ParadigmsTMP in {
+
+-------
+-- Ad*
+{-
+lin almost_AdA =
+lin almost_AdN =
+lin at_least_AdN =
+lin at_most_AdN =
+lin so_AdA =
+lin too_AdA =
+lin very_AdA =
+
+lin as_CAdv =
+lin less_CAdv =
+lin more_CAdv =
+
+lin how8much_IAdv =
+lin when_IAdv =
+
+lin how_IAdv =
+lin where_IAdv =
+lin why_IAdv =
+
+lin always_AdV = ss "" ;
+
+lin everywhere_Adv = ss "" ;
+lin here7from_Adv = ss "" ;
+lin here7to_Adv = ss "" ;
+lin here_Adv = ss "" ;
+lin quite_Adv = ss "" ;
+lin somewhere_Adv = ss "" ;
+lin there7from_Adv = ss "" ;
+lin there7to_Adv = ss "" ;
+lin there_Adv = ss "" ;
+
+-}
+-------
+-- Conj
+
+-- The lincat of Conj is Coordination.ConjunctionDistr ** {n:Number}
+-- which means that there are two fields for the strings, and
+-- n:Number which specifies the number of the resulting NP.
+
+lin and_Conj = {s1 = [] ; s2 = "and" ; n = Pl} ;
+-- lin or_Conj =
+-- lin if_then_Conj =
+lin both7and_DConj = {s1 = "both" ; s2 = "and" ; n = Pl} ;
+-- lin either7or_DConj =
+
+-- lin but_PConj =
+-- lin otherwise_PConj =
+-- lin therefore_PConj =
+
+
+-----------------
+-- *Det and Quant
+{-
+lin how8many_IDet =
+lin every_Det =
+
+lin all_Predet = {s = ""} ;
+lin not_Predet = { s = "" } ;
+lin only_Predet = { s = "" } ;
+lin most_Predet = {s = ""} ;
+
+lin few_Det = R.indefDet "" pl ;
+lin many_Det = R.indefDet "" pl ;
+lin much_Det = R.indefDet "" sg ;
+
+lin somePl_Det =
+lin someSg_Det =
+
+lin no_Quant =
+lin that_Quant = mkQuant "" ;
+lin this_Quant = mkQuant "" ;
+lin which_IQuant = mkQuant "" ;
+
+-----
+-- NP
+
+lin somebody_NP =
+
+
+lin everybody_NP =
+lin everything_NP =
+lin nobody_NP =
+lin nothing_NP =
+lin somebody_NP =
+lin something_NP =
+
+-------
+-- Prep
+
+lin above_Prep = mkPrep "" ;
+lin after_Prep = mkPrep "" ;
+lin before_Prep = mkPrep "" ;
+lin behind_Prep = mkPrep ""  ;
+lin between_Prep = = mkPrep "" ;
+lin by8agent_Prep = mkPrep "" ;
+lin by8means_Prep = mkPrep "" ;
+lin during_Prep = mkPrep "" ;
+lin except_Prep = mkPrep "" ;
+lin for_Prep = mkPrep "" ;
+lin from_Prep = mkPrep "" ;
+lin in8front_Prep = mkPrep "" ;
+lin in_Prep = mkPrep "" ;
+lin on_Prep = mkPrep "" ;
+lin part_Prep = mkPrep ;
+lin possess_Prep = mkPrep "" ;
+lin through_Prep = mkPrep "" ;
+lin to_Prep = mkPrep "k" ;
+lin under_Prep = mkPrep "" ;
+lin with_Prep = mkPrep "" ;
+lin without_Prep = mkPrep "" ;
+
+-------
+-- Pron
+
+-- Pronouns are closed class, no constructor in ParadigmsTMP.
+lin it_Pron =
+lin i_Pron =
+lin youPol_Pron =
+lin youSg_Pron =
+lin he_Pron =
+lin she_Pron =
+lin we_Pron =
+lin youPl_Pron =
+lin they_Pron =
+
+lin whatPl_IP =
+lin whatSg_IP =
+lin whoPl_IP =
+lin whoSg_IP =
+
+-------
+-- Subj
+
+lin although_Subj =
+lin because_Subj =
+lin if_Subj =
+lin that_Subj =
+lin when_Subj =
+
+
+------
+-- Utt
+
+lin language_title_Utt = ss "" ;
+lin no_Utt = ss "" ;
+lin yes_Utt = ss "" ;
+
+
+-------
+-- Verb
+
+lin have_V2 =
+
+lin can8know_VV =  -- can (capacity)
+lin can_VV =  -- can (possibility)
+lin must_VV =
+lin want_VV =
+
+------
+-- Voc
+
+lin please_Voc = ss "" ;
+-}
+
+}

src/TEMPLATE/SymbolTMP.gf

@@ -0,0 +1,73 @@
+--# -path=.:../abstract:../common:../prelude
+
+concrete SymbolTMP of Symbol = CatTMP **
+  open Prelude, ParadigmsTMP, ResTMP, (Noun=NounTMP) in {
+
+lin
+
+  --  : Symb -> PN ;                -- x
+  SymbPN i = mkPN_onRuntimeToken i.s ;
+
+  -- : Int -> PN ;                 -- 27
+  IntPN i  = mkPN_onRuntimeToken i.s ;
+
+  -- : Float -> PN ;               -- 3.14159
+  FloatPN i = mkPN_onRuntimeToken i.s ;
+
+  -- : Card -> PN ;                -- twelve [as proper name]
+  NumPN i = mkPN_onRuntimeToken (i.s ! NCard) ;
+
+lin
+--  CNIntNP cn i = {} ;
+
+  -- : Det -> CN -> [Symb] -> NP ; -- (the) (2) numbers x and y
+  CNSymbNP det cn xs =
+    let cnSymb : CN = cn ** {postmod = cn.postmod ++ xs.s}
+     in Noun.DetCN det cnSymb ;
+
+  -- : CN -> Card -> NP ;          -- level five ; level 5
+  CNNumNP cn i =
+    let cnSymb : CN = cn ** {postmod = cn.postmod ++ i.s}
+     in Noun.MassNP cnSymb ;
+
+  -- : Symb -> S ;
+  SymbS sy = sy ;
+
+  -- : Symb -> Card ;
+  SymbNum sy = mkNumeral_onRuntimeToken sy.s ;
+
+  -- : Symb -> Ord ;
+  SymbOrd sy = sy ; ---- TODO: nothing added to it. Lincat of Ord is just SS from the beginning.
+
+  oper
+    -- To make Card or PN from a runtime argument, cannot use the single + operation.
+    -- See https://inariksit.github.io/gf/2018/08/28/gf-gotchas.html#unsupported-token-gluing
+
+    mkNumeral_onRuntimeToken : Str -> LinNumeral = \str -> {
+      s = table {
+        NCard => str ;
+        NOrd  => str ++ BIND ++ "th"
+        } ;
+      n = Pl ; -- NB. probably singular for number 1
+      } ;
+
+    mkPN_onRuntimeToken : Str -> LinPN = \str -> {
+      s =
+       -- table {_ =>  -- If lincat of PN changes so that it's an inflection table, uncomment this
+         str
+         -- }
+         ;
+      n = Sg ;
+      } ;
+
+lincat
+  Symb, [Symb] = SS ;
+
+lin
+  MkSymb s = s ;
+
+  BaseSymb = infixSS "and" ; -- this comes between the last two ones
+  ConsSymb = infixSS "," ;
+
+
+}

src/TEMPLATE/VerbTMP.gf

@@ -0,0 +1,114 @@
+concrete VerbTMP of Verb = CatTMP ** open ResTMP, AdverbTMP, Prelude in {
+
+
+lin
+
+-----
+-- VP
+  -- : V -> VP
+  -- NB. assumes that lincat V = lincat VP
+  -- This will most likely change when you start working with VPs
+  UseV v = v ;
+
+{-
+  --  : V2 -> VP ;
+  PassV2 v2 =
+
+  -- : VPSlash -> VP ;
+  ReflVP vps =
+
+  -- : VV  -> VP -> VP ;
+  ComplVV vv vp =
+
+  -- : VS  -> S  -> VP ;
+  ComplVS vs s =
+
+  -- : VQ -> QS -> VP ;
+  ComplVQ vq qs =
+
+  -- : VA -> AP -> VP ;
+  ComplVA va ap =
+
+  -- : Comp -> VP ;
+  UseComp comp =
+-}
+--------
+-- Slash
+{-
+  -- : V2 -> VPSlash
+  SlashV2a v2 =
+
+  -- : V3 -> NP -> VPSlash ; -- give it (to her)
+  Slash2V3 v3 dobj =
+
+  -- : V3 -> NP -> VPSlash ; -- give (it) to her
+  Slash3V3 v3 iobj =
+
+  SlashV2A v2 adj =
+
+  -- : V2S -> S  -> VPSlash ;  -- answer (to him) that it is good
+  SlashV2S v2s s =
+
+  -- : V2V -> VP -> VPSlash ;  -- beg (her) to go
+  SlashV2V v2v vp = ;
+
+  -- : V2Q -> QS -> VPSlash ;  -- ask (him) who came
+  SlashV2Q v2q qs = ;
+
+  -- : V2A -> AP -> VPSlash ;  -- paint (it) red
+  SlashV2A v2a ap = ;
+
+
+  -- : VPSlash -> NP -> VP
+  -- Often VPSlash has a field called c2, which is used to pick right form of np complement
+  ComplSlash vps np = vps ** {
+    compl = np.s ! vps.c2
+    } ;
+
+  -- : VV  -> VPSlash -> VPSlash ;
+  SlashVV vv vps = ComplVV vv vps ** {
+    } ;
+
+  -- : V2V -> NP -> VPSlash -> VPSlash ; -- beg me to buy
+  SlashV2VNP v2v np vps =
+
+  -- : VP -> Adv -> VP ;  -- sleep here
+  AdvVP vp adv =
+
+  -- : AdV -> VP -> VP ;  -- always sleep
+  AdVVP adv vp =
+
+  -- : VPSlash -> Adv -> VPSlash ;  -- use (it) here
+  AdvVPSlash = insertAdv ;
+
+  -- : VP -> Adv -> VP ;  -- sleep , even though ...
+  ExtAdvVP vp adv =  ;
+
+  -- : AdV -> VPSlash -> VPSlash ;  -- always use (it)
+  AdVVPSlash adv vps = vps ** { adv = adv.s ++ vps.adv } ;
+
+  -- : VP -> Prep -> VPSlash ;  -- live in (it)
+  VPSlashPrep vp prep = vp ** {c2 = prep} ;
+
+
+--2 Complements to copula
+
+-- Adjectival phrases, noun phrases, and adverbs can be used.
+
+  -- : AP  -> Comp ;
+  CompAP ap =
+
+  -- : CN  -> Comp ;
+  CompCN cn =
+
+  --  NP  -> Comp ;
+  CompNP np =
+
+  -- : Adv  -> Comp ;
+  CompAdv adv =
+
+  -- : VP -- Copula alone;
+  UseCopula =
+-}
+
+}

src/TEMPLATE/unittest/nouns.gftest

@@ -0,0 +1,9 @@
+-----------------------------------
+-- Just some simple noun phrases --
+-----------------------------------
+
+Lang: DetCN (DetQuant IndefArt NumSg) (UseN blood_N)
+LangTMP: a blood
+
+Lang: DetCN (DetQuant DefArt NumSg) (UseN blood_N)
+LangTMP: the blood

src/TEMPLATE/unittest/sentences.gftest

@@ -0,0 +1,7 @@
+--------------------------------
+-- Just some simple sentences --
+--------------------------------
+
+-- Replace with some tests that make sense for your language!
+Lang: PhrUtt NoPConj (UttS (UseCl (TTAnt TPres ASimul) PPos (PredVP (DetCN (DetQuant DefArt NumSg) (UseN blood_N)) (UseV die_V)))) NoVoc
+LangTMP: the blood die

src/abstract/Cat.gf

@@ -93,6 +93,7 @@ abstract Cat = Common ** {
 
     Numeral ; -- cardinal or ordinal in words       e.g. "five/fifth"
     Digits ;  -- cardinal or ordinal in digits      e.g. "1,000/1,000th"
+    Decimal ; -- decimal number                     e.g. "1/2/3.14/-1"
 
 --2 Structural words
 
@@ -126,7 +127,10 @@ abstract Cat = Common ** {
     N ;     -- common noun                         e.g. "house"
     N2 ;    -- relational noun                     e.g. "son"
     N3 ;    -- three-place relational noun         e.g. "connection"
-    PN ;    -- proper name                         e.g. "Paris"
+    GN ;    -- given name                          e.g. "George"
+    SN ;    -- second name                         e.g. "Washington"
+    LN ;    -- location name                       e.g. "Sweden"
+    PN ;    -- proper name
 
 -- DEPRECATED: QuantSg, QuantPl
 ---    QuantSg ;-- quantifier ('nucleus' of sing. Det) e.g. "every"

src/abstract/Common.gf

@@ -44,4 +44,8 @@ abstract Common = {
     Pol ;   -- polarity                            e.g. positive, negative
     Ant ;   -- anteriority                         e.g. simultaneous, anterior
 
+--2 Measures
+
+    MU ;       -- unit of measurement              e.g. "km", "cm", "%"
+
 }

src/abstract/Documentation.gf

@@ -13,6 +13,10 @@ fun
   InflectionN   : N -> Inflection ;
   InflectionN2  : N2 -> Inflection ;
   InflectionN3  : N3 -> Inflection ;
+  InflectionPN  : PN -> Inflection ;
+  InflectionLN  : LN -> Inflection ;
+  InflectionGN  : GN -> Inflection ;
+  InflectionSN  : SN -> Inflection ;
   InflectionA   : A -> Inflection ;
   InflectionA2  : A2 -> Inflection ;
   InflectionV   : V -> Inflection ;
@@ -27,6 +31,9 @@ fun
   InflectionV2Q : V2Q -> Inflection ;
   InflectionV2A : V2A -> Inflection ;
   InflectionAdv : Adv -> Inflection ;
+  InflectionAdV : AdV -> Inflection ;
+  InflectionAdA : AdA -> Inflection ;
+  InflectionAdN : AdN -> Inflection ;
   InflectionPrep : Prep -> Inflection ;
 
 fun

src/abstract/Extend.gf

@@ -27,9 +27,11 @@ abstract Extend = Cat ** {
 
     CompBareCN  : CN -> Comp ;        -- (is) teacher
 
+    PiedPipingQuestSlash : IP -> ClSlash -> QCl ;   -- with whom does John live
+    PiedPipingRelSlash   : RP -> ClSlash -> RCl ;   -- with whom John lives
     StrandQuestSlash : IP -> ClSlash -> QCl ;   -- whom does John live with
-    StrandRelSlash   : RP -> ClSlash -> RCl ;   -- that he lives in
+    StrandRelSlash   : RP -> ClSlash -> RCl ;   -- that he lives with
-    EmptyRelSlash    : ClSlash       -> RCl ;   -- he lives in
+    EmptyRelSlash    : ClSlash       -> RCl ;   -- he lives with
 
 
 -- $VP$ conjunction, separate categories for finite and infinitive forms (VPS and VPI, respectively)
@@ -47,6 +49,7 @@ abstract Extend = Cat ** {
     PredVPS    : NP   -> VPS -> S ;          -- she [has walked and won't sleep]
     SQuestVPS  : NP   -> VPS -> QS ;         -- has she walked
     QuestVPS   : IP   -> VPS -> QS ;         -- who has walked
+    RelVPS     : RP   -> VPS -> RS ;         -- which won't sleep
 
 -- existentials that work in the absence of Cl
     ExistS     : Temp -> Pol -> NP -> S ;    -- there was a party
@@ -69,11 +72,20 @@ abstract Extend = Cat ** {
     MkVPS2    : Temp -> Pol -> VPSlash -> VPS2 ;  -- has loved
     ConjVPS2  : Conj -> [VPS2] -> VPS2 ;          -- has loved and now hates
     ComplVPS2 : VPS2 -> NP -> VPS ;               -- has loved and now hates that person
+    ReflVPS2  : VPS2 -> RNP -> VPS ;              -- have loved and now hate myself and my car
 
     MkVPI2    : VPSlash -> VPI2 ;                 -- to love
     ConjVPI2  : Conj -> [VPI2] -> VPI2 ;          -- to love and hate
     ComplVPI2 : VPI2 -> NP -> VPI ;               -- to love and hate that person
 
+-- Conjunction of copula complements
+  cat [Comp]{2} ;
+  fun ConjComp : Conj -> ListComp -> Comp ;
+
+-- Conjunction of imperatives
+  cat [Imp] {2} ;
+  fun ConjImp : Conj -> ListImp -> Imp ;
+
   fun
     ProDrop : Pron -> Pron ;  -- unstressed subject pronoun becomes empty: "am tired"
 
@@ -116,6 +128,11 @@ abstract Extend = Cat ** {
 
     ProgrVPSlash : VPSlash -> VPSlash;
 
+-- construct VPSlash from A2 and N2
+
+    A2VPSlash : A2 -> VPSlash ; -- is married to (that person)
+    N2VPSlash : N2 -> VPSlash ; -- is a mother of (that person)
+
 -- existential for mathematics
 
     ExistsNP : NP -> Cl ;  -- there exists a number / there exist numbers
@@ -126,7 +143,7 @@ abstract Extend = Cat ** {
     ExistMassCN   : CN -> Cl ;  -- there is beer / there is no beer
     ExistPluralCN : CN -> Cl ;  -- there are trees / there are no trees
 
--- generalisation of existential, with adverb as a parameter
+-- generalisation of existential, with adverb as an argument
     AdvIsNP : Adv -> NP -> Cl ;  -- here is the tree / here are the trees
     AdvIsNPAP : Adv -> NP -> AP -> Cl ; -- here are the instructions documented
 
@@ -184,6 +201,15 @@ abstract Extend = Cat ** {
 
     PredetRNP : Predet -> RNP -> RNP ; -- all my brothers
 
+    AdvRNP : NP -> Prep -> RNP -> RNP ;   -- a dispute with his wife
+    AdvRVP : VP -> Prep -> RNP -> VP ;    -- lectured about her travels
+    AdvRAP : AP -> Prep -> RNP -> AP ;    -- adamant in his refusal
+
+    ReflA2RNP : A2 -> RNP -> AP ;         -- indifferent to their surroundings
+                                               -- NOTE: generalizes ReflA2
+
+    PossPronRNP : Pron -> Num -> CN -> RNP -> NP ; -- his abandonment of his wife and children
+
     ConjRNP : Conj -> RNPList -> RNP ;  -- my family, John and myself
 
     Base_rr_RNP : RNP -> RNP -> RNPList ;       -- my family, myself
@@ -193,6 +219,9 @@ abstract Extend = Cat ** {
     Cons_nr_RNP : NP  -> RNPList -> RNPList ;   -- John, my family, myself
 ----    Cons_rn_RNP : RNP -> ListNP  -> RNPList ;   -- myself, John, Mary
 
+-- reflexive possessive on its own right, like in Swedish, Czech, Slovak
+
+    ReflPossPron : Quant ;  -- Swe sin,sitt,sina
 
 --- from Extensions
 
@@ -240,6 +269,7 @@ abstract Extend = Cat ** {
   weFem_Pron     : Pron ; -- we (Fem)
   youPlFem_Pron  : Pron ; -- you plural (Fem)
   theyFem_Pron   : Pron ; -- they (Fem)
+  theyNeutr_Pron : Pron ; -- they (Neutr)
   youPolFem_Pron : Pron ; -- you polite (Fem)
   youPolPl_Pron  : Pron ; -- you polite plural (Masc)
   youPolPlFem_Pron : Pron ; -- you polite plural (Fem)
@@ -251,4 +281,28 @@ abstract Extend = Cat ** {
   UttDatIP : IP -> Utt ; -- whom (dative)
 
 
+-- UseDAP replaces DetNP from the RGL which is more limited.
+-- Instead of (DetNP d) use (UseDAP (DetDAP d)). The advantage
+-- is that now we can also have an adjective inserted, i.e.
+-- (UseDAP (AdjDAP (DetDAP d) a). There are also versions of
+-- UseDAP for different genders.
+fun UseDAP     : DAP -> NP ;
+    UseDAPMasc : DAP -> NP ;
+    UseDAPFem  : DAP -> NP ;
+
+cat X ; -- for words that are difficult to classify, mainly for MorphoDict
+
+fun
+  UseComp_estar : Comp -> VP ; -- esta lleno, as opposed to es lleno
+  UseComp_ser : Comp -> VP ; -- es lleno, as opposed to esta lleno
+
+fun
+  CardCNCard : Card -> CN -> Card ;  -- three million, four lakh, six dozen etc
+
+fun
+  TPastSimple : Tense ;
+
+fun
+  SubjunctRelCN : CN -> RS -> CN ; -- e.g. Romance languages when subjunctive/conjunctive is needed
+
 }

src/abstract/Grammar.gf

@@ -19,6 +19,6 @@ abstract Grammar =
   Structural,
   Idiom,
   Tense,
+  Names,
   Transfer 
   ;
-

src/abstract/Names.gf

@@ -0,0 +1,14 @@
+abstract Names = Cat ** {
+
+fun GivenName : GN -> NP ;
+    MaleSurname   : SN -> NP ;
+    FemaleSurname : SN -> NP ;
+    PlSurname     : SN -> NP ;
+    FullName  : GN -> SN -> NP ;
+
+fun UseLN : LN -> NP ;
+    PlainLN : LN -> NP ;
+    InLN : LN -> Adv ;
+    AdjLN : AP -> LN -> LN ;
+
+}

src/abstract/Noun.gf

@@ -58,6 +58,7 @@ abstract Noun = Cat ** {
 
   data
     NumDigits  : Digits  -> Card ;  -- 51
+    NumDecimal : Decimal -> Card ;  -- 3.14, -1, etc
     NumNumeral : Numeral -> Card ;  -- fifty-one
 
 -- The construction of numerals is defined in [Numeral Numeral.html].
@@ -155,4 +156,8 @@ abstract Noun = Cat ** {
     AdjDAP : DAP -> AP -> DAP ;    -- the large (one)
     DetDAP : Det -> DAP ;          -- this (or that) 
 
+--2 Quantities
+
+    QuantityNP : Decimal -> MU -> NP ;
+
 }

src/abstract/Numeral.gf

@@ -17,34 +17,56 @@
 -- parts of a numeral, which is often incorrect - more work on
 -- (un)lexing is needed to solve this problem.
 
-abstract Numeral = Cat [Numeral,Digits] ** {
+abstract Numeral = Cat [Numeral,Digits,Decimal] ** {
 
 cat 
-  Digit ;       -- 2..9
+  Digit ;            -- 2..9
-  Sub10 ;       -- 1..9
+  Sub10 ;            -- 1..9
-  Sub100 ;      -- 1..99
+  Sub100 ;           -- 1..99
-  Sub1000 ;     -- 1..999
+  Sub1000 ;          -- 1..999
-  Sub1000000 ;  -- 1..999999
+  Sub1000000 ;       -- 1..999999
+  Sub1000000000 ;    -- 1..999999999
+  Sub1000000000000 ; -- 1..999999999999
+
+data
 
-data 
   num : Sub1000000 -> Numeral ; -- 123456 [coercion to top category]
+  ---- num : Sub1000000000000 -> Numeral ; ---- should be this, but not yet available in most langs AR 6/2/2024
 
   n2, n3, n4, n5, n6, n7, n8, n9 : Digit ;
 
   pot01 : Sub10 ;                               -- 1
   pot0 : Digit -> Sub10 ;                       -- d * 1
+  pot0as1 : Sub10 -> Sub100 ;                   -- coercion of 1..9
+
   pot110 : Sub100 ;                             -- 10
   pot111 : Sub100 ;                             -- 11
   pot1to19 : Digit -> Sub100 ;                  -- 10 + d
-  pot0as1 : Sub10 -> Sub100 ;                   -- coercion of 1..9
   pot1 : Digit -> Sub100 ;                      -- d * 10
   pot1plus : Digit -> Sub10 -> Sub100 ;         -- d * 10 + n
   pot1as2 : Sub100 -> Sub1000 ;                 -- coercion of 1..99
+
+  pot21 : Sub1000 ;                             -- a hundred instead of one hundred
   pot2 : Sub10 -> Sub1000 ;                     -- m * 100
   pot2plus : Sub10 -> Sub100 -> Sub1000 ;       -- m * 100 + n
   pot2as3 : Sub1000 -> Sub1000000 ;             -- coercion of 1..999
+
+  pot31 : Sub1000000 ;                          -- a thousand instead of one thousand
   pot3 : Sub1000 -> Sub1000000 ;                -- m * 1000
   pot3plus : Sub1000 -> Sub1000 -> Sub1000000 ; -- m * 1000 + n
+  pot3as4 : Sub1000000 -> Sub1000000000 ;       -- coercion of 1..999999
+  pot3decimal : Decimal -> Sub1000000 ;         -- 3.5 thousand
+
+  pot41 : Sub1000000000 ;                                    -- a million instead of one million
+  pot4  : Sub1000 -> Sub1000000000 ;                         -- m * 1000000000
+  pot4plus : Sub1000 -> Sub1000000 -> Sub1000000000 ;        -- m * 1000000000 + n
+  pot4as5 : Sub1000000000 -> Sub1000000000000 ;              -- coercion of 1..999999999
+  pot4decimal : Decimal -> Sub1000000000 ;                   -- 3.5 million
+
+  pot51 : Sub1000000000000 ;                                 -- a billion instead of one billion
+  pot5  : Sub1000 -> Sub1000000000000 ;                      -- m * 1000000000
+  pot5plus : Sub1000 -> Sub1000000000 -> Sub1000000000000 ;  -- m * 1000000000 + n
+  pot5decimal : Decimal -> Sub1000000000000 ;                -- 3.5 billion
 
 -- Numerals as sequences of digits have a separate, simpler grammar
 
@@ -57,4 +79,8 @@ data
 
   D_0, D_1, D_2, D_3, D_4, D_5, D_6, D_7, D_8, D_9 : Dig ;
 
+  PosDecimal : Digits -> Decimal ;        --  8
+  NegDecimal : Digits -> Decimal ;        -- -8
+  IFrac : Decimal -> Dig -> Decimal ;     -- 3.14 -> 3.141
+
 }

src/abstract/Sentence.gf

@@ -40,6 +40,7 @@ abstract Sentence = Cat ** {
 -- To fix these parameters, see [Phrase Phrase.html].
 
     ImpVP     : VP -> Imp ;              -- love yourselves
+    AdvImp : Adv -> Imp -> Imp ;         -- please love yourselves
 
 --2 Embedded sentences
 

src/afrikaans/AllAfr.gf

@@ -3,7 +3,7 @@
 concrete AllAfr of AllAfrAbs = 
   LangAfr,
   IrregAfr,
-  ExtraAfr
+  ExtendAfr
   ** 
 {
 --{} ;

src/afrikaans/CatAfr.gf

@@ -62,6 +62,7 @@ concrete CatAfr of Cat =
 
     Numeral = {s : CardOrd => Str ; n : Number } ;
     Digits = {s : CardOrd => Str ; n : Number } ;
+    Decimal = {s : CardOrd => Str ; n : Number ; hasDot : Bool} ;
 
 -- Structural
 
@@ -84,5 +85,21 @@ concrete CatAfr of Cat =
     N2 = {s : NForm => Str ; g : Gender} ** {c2 : Preposition} ;
     N3 = {s : NForm => Str ; g : Gender} ** {c2,c3 : Preposition} ;
     PN = {s : NPCase => Str} ;
+    GN = {s : NPCase => Str; g : Sex} ;
+    SN = {s : Sex => NPCase => Str; pl : NPCase => Str} ;
+    LN = {s : Adjf => NPCase => Str ; hasArt : Bool ; n : Number} ;
+
+lindef
+    VPSlash = \s -> {
+      s  = {s = \\_ => s; prefix = ""; aux = VHebben; vtype = VAct} ;
+      a1 = \\_ => "" ;
+      n0 = \\_ => "" ;
+      n2 = \\_ => "" ;
+      a2 = "" ;
+      isAux = False ;
+      inf = <"",False> ;
+      ext = "" ;
+      c2 = ""
+      } ;
 
 }

src/afrikaans/DocumentationAfr.gf

@@ -0,0 +1,171 @@
+--# -path=.:../abstract:../common
+
+concrete DocumentationAfr of Documentation = CatAfr ** open 
+  ResAfr,
+  Prelude,
+  HTML
+in {
+
+
+lincat
+  Inflection = {t : Str; s1,s2 : Str} ;
+  Definition = {s : Str} ;
+  Document = {s : Str} ;
+  Tag = {s : Str} ;
+
+lin
+  InflectionN, InflectionN2, InflectionN3 = \noun -> {
+    t  = "s" ;
+    s1 = heading1 "Selfstandige Naamwoord" ;
+    s2 = frameTable ( 
+           tr (th "Enkelvoud"            ++ th "Meervoud"   ) ++
+           tr (td (noun.s ! NF Sg Nom) ++ td (noun.s ! NF Pl Nom)))
+    } ;
+
+  InflectionPN = \pn -> {
+    t  = "pn" ;
+    s1 = heading1 "Naam" ;
+    s2 = paragraph (pn.s ! NPNom)
+    } ;
+
+  InflectionLN = \ln -> {
+    t  = "pn" ;
+    s1 = heading1 "Naam" ;
+    s2 = paragraph (ln.s ! Strong ! NPNom)
+    } ;
+
+  InflectionGN = \pn -> {
+    t  = "vnm" ;
+    s1 = heading1 "Voornaam" ;
+    s2 = paragraph (pn.s ! NPNom)
+    } ;
+
+  InflectionSN = \pn -> {
+    t  = "van" ;
+    s1 = heading1 "Van" ;
+    s2 = paragraph (pn.s ! Male ! NPNom)
+    } ;
+
+  InflectionA, InflectionA2 = \adj ->
+    let
+      gforms : AForm -> Str = \a ->
+        td (adj.s ! Posit  ! a) ++
+        td (adj.s ! Compar ! a) ++
+        case a of {
+          AGen => td "-" ;    -- superlative partitive not used
+          _ => td (adj.s ! Superl ! a)
+          } ;
+      dtable : Str = 
+        frameTable ( 
+          tr (th []  ++ th "Stellend" ++ th "Vergrotend" ++ 
+                        th "Oortreffend") ++
+          tr (th "Predikatief" ++ gforms APred) ++
+          tr (th "Attributief" ++ gforms AAttr) ++
+          tr (th "Partitief"   ++ gforms AGen)
+          )
+    in { t  = "bv" ;
+         s1 = heading1 "Byvoeglike naamwoord" ;
+         s2 = dtable
+       } ;
+
+  InflectionAdv, InflectionAdV, InflectionAdA, InflectionAdN = \adv -> {
+    t  = "bw" ;
+    s1 = heading1 "Bywoord" ;
+    s2 = paragraph adv.s
+    } ;
+
+  InflectionPrep p = {
+    t  = "prep" ;
+    s1 = heading1 "Voorsetsel" ;
+    s2 = paragraph p.s
+    } ;
+
+  InflectionV v = {
+    t  = "w" ;
+    s1 = heading1 "Werkwoord" ;
+    s2 = inflVerb v
+    } ;
+
+  InflectionV2 v = {
+    t  = "v" ;
+    s1 = heading1 "Werkwoord" ;
+    s2 = inflVerb v
+    } ;
+
+  InflectionV3 v = {
+    t  = "v" ;
+    s1 = heading1 "Werkwoord" ;
+    s2 = inflVerb v
+    } ;
+
+  InflectionV2V v = {
+    t  = "v" ;
+    s1 = heading1 "Werkwoord" ;
+    s2 = inflVerb v
+    } ;
+
+  InflectionV2S v = {
+    t  = "v" ;
+    s1 = heading1 "Werkwoord" ;
+    s2 = inflVerb v
+    } ;
+
+  InflectionV2Q v = {
+    t  = "v" ;
+    s1 = heading1 "Werkwoord" ;
+    s2 = inflVerb v
+    } ;
+
+  InflectionV2A v = {
+    t  = "v" ;
+    s1 = heading1 "Werkwoord" ;
+    s2 = inflVerb v
+    } ;
+
+  InflectionVV v = {
+    t  = "v" ;
+    s1 = heading1 "Werkwoord" ;
+    s2 = inflVerb v
+    } ;
+
+  InflectionVS v = {
+    t  = "v" ;
+    s1 = heading1 "Werkwoord" ;
+    s2 = inflVerb v
+    } ;
+
+  InflectionVQ v = {
+    t  = "v" ;
+    s1 = heading1 "Werkwoord" ;
+    s2 = inflVerb v
+    } ;
+
+  InflectionVA v = {
+    t  = "v" ;
+    s1 = heading1 "Werkwoord" ;
+    s2 = inflVerb v
+    } ;
+
+lin
+  NoDefinition   t     = {s=t.s};
+  MkDefinition   t d   = {s="<p><b>Definisie:</b>"++t.s++d.s++"</p>"};
+  MkDefinitionEx t d e = {s="<p><b>Definisie:</b>"++t.s++d.s++"</p><p><b>Voorbeeld:</b>"++e.s++"</p>"};
+
+  MkDocument d i e = ss (i.s1 ++ d.s ++ i.s2 ++ paragraph e.s) ;  -- explanation appended in a new paragraph
+  MkTag i = ss i.t ;
+
+oper 
+  inflVerb : VVerb -> Str = \verb -> 
+     let 
+       vfin : VForm -> Str = \f ->
+         verb.s ! f ++ verb.prefix ; 
+       gforms : VForm -> Str = \f -> 
+         td (vfin f) ;
+
+     in frameTable (
+          tr (th "Infinitief"       ++ td (verb.s ! VInf)) ++
+          tr (th "Teenwoordige Tyd" ++ td (verb.s ! VPres)) ++
+          tr (th "Verlede Tyd"      ++ td (verb.s ! VPast)) ++
+          tr (th "Perfectief"       ++ td (verb.s ! VPerf))
+        ) ;
+}

src/afrikaans/ExtendAfr.gf

@@ -0,0 +1,15 @@
+concrete ExtendAfr of Extend =
+  CatAfr ** ExtendFunctor - [PassVPSlash,PassAgentVPSlash]
+  with
+    (Grammar = GrammarAfr) **
+
+  open
+    ParadigmsAfr, ResAfr in {
+
+-- KA: guessed from PassV2 in Afrikaans and the equivalents in Dutch
+lin PassVPSlash vps = 
+      insertInf (vps.s.s ! VPerf) (predV word_V) ;
+    PassAgentVPSlash vps np = 
+      insertAdv (appPrep "door" np.s) (insertInf (vps.s.s ! VPerf) (predV word_V)) ;
+
+}

src/afrikaans/GrammarAfr.gf

@@ -14,4 +14,5 @@ concrete GrammarAfr of Grammar =
   TextX,
   IdiomAfr,
   StructuralAfr,
-  TenseX ;
+  TenseX,
+  NamesAfr ;

src/afrikaans/LangAfr.gf

@@ -2,4 +2,6 @@
 
 concrete LangAfr of Lang = 
   GrammarAfr,
-  LexiconAfr ;
+  LexiconAfr
+  ,DocumentationAfr --# notpresent
+ ;

src/afrikaans/NamesAfr.gf

@@ -0,0 +1,40 @@
+concrete NamesAfr of Names = CatAfr ** open ResAfr, Prelude in {
+
+lin GivenName = \n -> {s = n.s ; a = agrP3 Sg ; isPron = False} ;
+lin MaleSurname = \n -> {s = n.s ! Male ; a = agrP3 Sg ; isPron = False} ;
+lin FemaleSurname = \n -> {s = n.s ! Female; a = agrP3 Sg ; isPron = False} ;
+lin PlSurname = \n -> {s = n.pl ; a = agrP3 Sg ; isPron = False} ;
+
+lin FullName gn sn =
+      {s = \\c => gn.s ! NPNom ++ sn.s ! gn.g ! c ; a = agrP3 Sg ; isPron = False} ;
+
+lin UseLN ln = {
+      s = \\c => case ln.hasArt of {
+                   True  => "die" ++ ln.s ! Weak ! c ;
+                   False => ln.s ! Strong ! c
+                 } ;
+      a = agrP3 ln.n ;
+      isPron = False
+    } ;
+
+   PlainLN ln = {
+      s = \\c => ln.s ! Strong ! c ;
+      a = agrP3 ln.n ;
+      isPron = False
+    } ;
+
+   InLN ln = {
+      s = appPrep "in" (\\c => case ln.hasArt of {
+                                 True  => "die" ++ ln.s ! Weak ! c ;
+                                 False => ln.s ! Strong ! c
+                               })
+    } ;
+
+   AdjLN ap ln = ln ** {
+      s = \\a,c =>
+               preOrPost ap.isPre
+                 (ap.s ! agrAdj Neutr a (NF ln.n Nom))
+                 (ln.s ! a ! c) ;
+      } ;
+
+}

src/afrikaans/NounAfr.gf

@@ -77,6 +77,8 @@ concrete NounAfr of Noun = CatAfr ** open ResAfr, Prelude in {
     NumDigits numeral = {s = \\g,c => numeral.s ! NCard g c; n = numeral.n } ;
     OrdDigits numeral = {s = \\af => numeral.s ! NOrd af} ;
 
+    NumDecimal dec = {s = \\g,c => dec.s ! NCard g c; n = dec.n } ;
+
     NumNumeral numeral = {s = \\g,c => numeral.s ! NCard g c; n = numeral.n } ;
     OrdNumeral numeral = {s = \\af => numeral.s ! NOrd af} ;
 
@@ -177,4 +179,10 @@ concrete NounAfr of Noun = CatAfr ** open ResAfr, Prelude in {
       isMod = cn.isMod
       } ;
 
+    QuantityNP n m = {
+      s = \\c => preOrPost m.isPre m.s (n.s ! NCard Neutr Nom) ;
+      a = agrP3 n.n ;
+      isPron = False
+      } ;
+
 }

src/afrikaans/NumeralAfr.gf

@@ -1,5 +1,5 @@
 
-concrete NumeralAfr of Numeral = CatAfr [Numeral,Digits] ** open ResAfr, Prelude in {
+concrete NumeralAfr of Numeral = CatAfr [Numeral,Digits,Decimal] ** open ResAfr, Prelude in {
 
 flags optimize = all_subs ;
   coding=utf8 ;
@@ -7,7 +7,7 @@ flags optimize = all_subs ;
 lincat 
   Digit = {s : DForm => CardOrd => Str ; en : Str} ;
   Sub10 = {s : DForm => CardOrd => Str ; n : Number ; en : Str ; attr : Str} ;
-  Sub100, Sub1000, Sub1000000 = 
+  Sub100, Sub1000, Sub1000000, Sub1000000000, Sub1000000000000 = 
           {s :          CardOrd => Str ; n : Number ; attr : Str} ;
 
 lin 
@@ -50,6 +50,8 @@ lin
   pot3plus n m = 
     addAttr {s = \\g => n.attr ++ "duisend" ++ m.s ! g ; n = Pl} ;
 
+  pot3as4 n = n ;
+  pot4as5 n = n ;
 
   lincat 
     Dig = TDigit ;
@@ -73,6 +75,20 @@ lin
     D_8 = mkDig "8" ;
     D_9 = mkDig "9" ;
 
+    PosDecimal d = d ** {hasDot=False} ;
+    NegDecimal d = {
+      s = \\o => "-" ++ BIND ++ d.s ! o ;
+      n = Pl ;
+      hasDot=False
+      } ;
+    IFrac d i = {
+      s = \\o => d.s ! invNum ++
+                 if_then_Str d.hasDot BIND (BIND++"."++BIND) ++
+                 i.s ! o;
+      n = Pl ;
+      hasDot=True
+    } ;
+
   oper
     mk2Dig : Str -> Str -> TDigit = \c,o -> mk3Dig c o Pl ;
     mkDig : Str -> TDigit = \c -> mk2Dig c (c + "e") ;

src/afrikaans/ParadigmsAfr.gf

@@ -73,6 +73,25 @@ oper
     mkPN : Str -> PN ; -- proper name
     } ;
 
+  mkGN = overload {  -- given name
+    mkGN : Str -> GN = \s -> lin GN {s = \\_ => s; g = Male} ;
+    mkGN : Str -> Sex -> GN = \s,g -> lin GN {s = \\_ => s; g = g} ;
+    } ;
+
+  mkSN = overload {  -- given name
+    mkSN : Str -> SN = \s -> lin SN {s = \\_,_ => s; pl = \\_=>s} ;
+    mkSN : Str -> Str -> Str -> SN = \male,female,pl -> lin SN {s = table {Male=>\\_=>male; Female=>\\_=>female}; pl=\\_=>pl} ;
+    } ;
+
+  mkLN = overload {
+    mkLN : Str -> LN  -- location name
+     = \s -> lin LN {s = \\_,_ => s; hasArt = False; n = Sg} ;
+    mkLN : Str -> Number -> LN  -- location name
+     = \s,n -> lin LN {s = \\_,_ => s; hasArt = False; n = n} ;
+    } ;
+
+  defLN : LN -> LN = \n -> n ** {hasArt = True} ;
+
 
 --2 Adjectives
 
@@ -205,6 +224,8 @@ oper
   feminine  = Neutr ;
   het,neuter = Neutr ;
   de,utrum = Neutr ;
+  male = Male ;
+  female = Female ;
 
   mkA = overload {
     mkA : (vers : Str) -> A = \a -> lin A (regAdjective a) ;
@@ -494,4 +515,6 @@ oper
 --
 --}
 
+  mkMU : Str -> MU = \s -> lin MU {s=s; isPre=False} ;
+
 }

src/afrikaans/ResAfr.gf

@@ -315,7 +315,7 @@ param
 
 --2 Transformations between parameter types
 
-  oper Agr : Type = {g : Gender ; n : Number ; p : Person} ;
+  oper Agr : PType = {g : Gender ; n : Number ; p : Person} ;
 
   oper
     agrP3 : Number -> Agr = agrgP3 Neutr ;

src/albanian/AdjectiveSqi.gf

@@ -0,0 +1,11 @@
+concrete AdjectiveSqi of Adjective = CatSqi ** open ResSqi, Prelude in {
+
+  lin
+    PositA  a = {
+      s = \\spec,c,g,n => case a.clit of {
+                            True  => link_clitic ! spec ! c ! g ! n ++ a.s ! c ! g ! n ;
+                            False => a.s ! c ! g ! n
+                          }
+      } ;
+
+}

src/albanian/AllSqi.gf

@@ -0,0 +1,4 @@
+concrete AllSqi of AllSqiAbs =
+  LangSqi
+  **
+    {} ;

src/albanian/AllSqiAbs.gf

@@ -0,0 +1,3 @@
+abstract AllSqiAbs =
+  Lang
+  ** {}

src/albanian/CatSqi.gf

@@ -0,0 +1,25 @@
+concrete CatSqi of Cat = CommonX ** open ParamX, Prelude, ResSqi in {
+
+lincat N = Noun ;
+lincat N2 = Noun ** {c2 : Compl} ;
+lincat N3 = Noun ** {c2,c3 : Compl} ;
+lincat A = Adj ;
+lincat A2 = Adj ** {c2 : Compl} ;
+lincat V, VA, VV, VS, VQ = Verb ;
+lincat V2, V2S, V2Q = Verb ** {c2 : Compl} ;
+lincat V3, V2A, V2V = Verb ** {c2,c3 : Compl} ;
+lincat Prep = Compl ;
+
+lincat Numeral = {s : Str} ;
+lincat Digits  = {s : Str; n : Number; tail : DTail} ;
+lincat Decimal = {s : Str; n : Number; hasDot : Bool} ;
+
+lincat AP = {s: Species => Case => Gender => Number => Str} ;
+lincat CN = Noun ;
+lincat Num = {s : Str; n : Number} ;
+lincat Quant = {s : Case => Gender => Number => Str; spec : Species} ;
+lincat Det = {s : Case => Gender => Str; spec : Species; n : Number} ;
+lincat NP = {s: Case => Str; a : Agr} ;
+lincat Pron = {s: Case => Str; acc_clit, dat_clit : Str; a : Agr} ;
+
+}

src/albanian/DocumentationSqi.gf

@@ -0,0 +1,117 @@
+concrete DocumentationSqi of Documentation = CatSqi ** open
+  ParamX, ResSqi, Prelude, HTML in {
+
+lincat
+  Inflection = {t : Str; s1,s2,s3 : Str} ;
+  Definition = {s : Str} ;
+  Document   = {s : Str} ;
+  Tag        = {s : Str} ;
+
+lin InflectionN = \x -> {
+      t="em" ;
+      s1=heading1 ("Emër" ++
+                   case x.g of {
+                     Masc => "(mashkullor)" ;
+                     Fem  => "(femëror)"
+                   }) ;
+      s2=frameTable (
+           tr (intagAttr "th" "colspan=\"2\"" "" ++ th "Sg" ++ th "Pl") ++
+           tr (intagAttr "th" "rowspan=\"4\"" "Indef" ++ th "Nom" ++ td (x.s ! Indef ! Nom ! Sg) ++ td (x.s ! Indef ! Nom ! Pl)) ++
+           tr (th "Acc" ++ td (x.s ! Indef ! Acc ! Sg) ++ td (x.s ! Indef ! Acc ! Pl)) ++
+           tr (th "Dat" ++ td (x.s ! Indef ! Dat ! Sg) ++ td (x.s ! Indef ! Dat ! Pl)) ++
+           tr (th "Ablat" ++ td (x.s ! Indef ! Ablat ! Sg) ++ td (x.s ! Indef ! Ablat ! Pl)) ++
+           tr (intagAttr "th" "rowspan=\"4\"" "Def" ++ th "Nom" ++ td (x.s ! Def ! Nom ! Sg) ++ td (x.s ! Def ! Nom ! Pl)) ++
+           tr (th "Acc" ++ td (x.s ! Def ! Acc ! Sg) ++ td (x.s ! Def ! Acc ! Pl)) ++
+           tr (th "Dat" ++ td (x.s ! Def ! Dat ! Sg) ++ td (x.s ! Def ! Dat ! Pl)) ++
+           tr (th "Ablat" ++ td (x.s ! Def ! Ablat ! Sg) ++ td (x.s ! Def ! Ablat ! Pl))) ;
+      s3=[]
+    } ;
+lin InflectionA = \x -> {
+      t="mb" ;
+      s1=heading1 "Mbiemër" ;
+      s2=frameTable (
+           tr (intagAttr "th" "colspan=\"2\"" "" ++ th "Sg" ++ th "Pl") ++
+           tr (intagAttr "th" "rowspan=\"2\"" "Nom" ++ th "Masc" ++ td (y ! Nom ! Masc ! Sg) ++ td (y ! Nom ! Masc ! Pl)) ++
+           tr (th "Fem" ++ td (y ! Nom ! Fem ! Sg) ++ td (y ! Nom ! Fem ! Pl)) ++
+           tr (intagAttr "th" "rowspan=\"2\"" "Acc" ++ th "Masc" ++ td (y ! Acc ! Masc ! Sg) ++ td (y ! Acc ! Masc ! Pl)) ++
+           tr (th "Fem" ++ td (y ! Acc ! Fem ! Sg) ++ td (y ! Acc ! Fem ! Pl)) ++
+           tr (intagAttr "th" "rowspan=\"2\"" "Dat" ++ th "Masc" ++ td (y ! Dat ! Masc ! Sg) ++ td (y ! Dat ! Masc ! Pl)) ++
+           tr (th "Fem" ++ td (y ! Dat ! Fem ! Sg) ++ td (y ! Dat ! Fem ! Pl)) ++
+           tr (intagAttr "th" "rowspan=\"2\"" "Ablat" ++ th "Masc" ++ td (y ! Ablat ! Masc ! Sg) ++ td (y ! Ablat ! Masc ! Pl)) ++
+           tr (th "Fem" ++ td (y ! Ablat ! Fem ! Sg) ++ td (y ! Ablat ! Fem ! Pl))) ;
+      s3=[]
+    } where {
+        y : Case => Gender => Number => Str =
+          \\c,g,n => case x.clit of {
+                       True  => link_clitic ! Indef ! c ! g ! n ++ x.s ! c ! g ! n ;
+                       False => x.s ! c ! g ! n
+                     } ;
+    } ;
+lin InflectionV = \x -> {
+      t="fl" ;
+      s1=heading1 "Folje" ;
+      s2=frameTable (
+           tr (intagAttr "th" "rowspan=\"24\"" "Indicative" ++ intagAttr "th" "rowspan=\"6\"" "Pres" ++ intagAttr "th" "rowspan=\"3\"" "Sg" ++ th "P1" ++ td (x.Indicative ! Pres ! Sg ! P1)) ++
+           tr (th "P2" ++ td (x.Indicative ! Pres ! Sg ! P2)) ++
+           tr (th "P3" ++ td (x.Indicative ! Pres ! Sg ! P3)) ++
+           tr (intagAttr "th" "rowspan=\"3\"" "Pl" ++ th "P1" ++ td (x.Indicative ! Pres ! Pl ! P1)) ++
+           tr (th "P2" ++ td (x.Indicative ! Pres ! Pl ! P2)) ++
+           tr (th "P3" ++ td (x.Indicative ! Pres ! Pl ! P3)) ++
+           tr (intagAttr "th" "rowspan=\"6\"" "Past" ++ intagAttr "th" "rowspan=\"3\"" "Sg" ++ th "P1" ++ td (x.Indicative ! Past ! Sg ! P1)) ++
+           tr (th "P2" ++ td (x.Indicative ! Past ! Sg ! P2)) ++
+           tr (th "P3" ++ td (x.Indicative ! Past ! Sg ! P3)) ++
+           tr (intagAttr "th" "rowspan=\"3\"" "Pl" ++ th "P1" ++ td (x.Indicative ! Past ! Pl ! P1)) ++
+           tr (th "P2" ++ td (x.Indicative ! Past ! Pl ! P2)) ++
+           tr (th "P3" ++ td (x.Indicative ! Past ! Pl ! P3)) ++
+           tr (intagAttr "th" "rowspan=\"6\"" "Aorist" ++ intagAttr "th" "rowspan=\"3\"" "Sg" ++ th "P1" ++ td (x.Indicative ! Aorist ! Sg ! P1)) ++
+           tr (th "P2" ++ td (x.Indicative ! Aorist ! Sg ! P2)) ++
+           tr (th "P3" ++ td (x.Indicative ! Aorist ! Sg ! P3)) ++
+           tr (intagAttr "th" "rowspan=\"3\"" "Pl" ++ th "P1" ++ td (x.Indicative ! Aorist ! Pl ! P1)) ++
+           tr (th "P2" ++ td (x.Indicative ! Aorist ! Pl ! P2)) ++
+           tr (th "P3" ++ td (x.Indicative ! Aorist ! Pl ! P3)) ++
+           tr (intagAttr "th" "rowspan=\"6\"" "Imperfect" ++ intagAttr "th" "rowspan=\"3\"" "Sg" ++ th "P1" ++ td (x.Indicative ! Imperfect ! Sg ! P1)) ++
+           tr (th "P2" ++ td (x.Indicative ! Imperfect ! Sg ! P2)) ++
+           tr (th "P3" ++ td (x.Indicative ! Imperfect ! Sg ! P3)) ++
+           tr (intagAttr "th" "rowspan=\"3\"" "Pl" ++ th "P1" ++ td (x.Indicative ! Imperfect ! Pl ! P1)) ++
+           tr (th "P2" ++ td (x.Indicative ! Imperfect ! Pl ! P2)) ++
+           tr (th "P3" ++ td (x.Indicative ! Imperfect ! Pl ! P3)) ++
+           tr (intagAttr "th" "rowspan=\"2\"" "Imperative" ++ th "Sg" ++ td (x.Imperative ! Sg)) ++
+           tr (th "Pl" ++ td (x.Imperative ! Pl)) ++
+           tr (th "participle" ++ td (x.participle)) ++
+           tr (intagAttr "th" "rowspan=\"6\"" "pres_optative" ++ intagAttr "th" "rowspan=\"3\"" "Sg" ++ th "P1" ++ td (x.pres_optative ! Sg ! P1)) ++
+           tr (th "P2" ++ td (x.pres_optative ! Sg ! P2)) ++
+           tr (th "P3" ++ td (x.pres_optative ! Sg ! P3)) ++
+           tr (intagAttr "th" "rowspan=\"3\"" "Pl" ++ th "P1" ++ td (x.pres_optative ! Pl ! P1)) ++
+           tr (th "P2" ++ td (x.pres_optative ! Pl ! P2)) ++
+           tr (th "P3" ++ td (x.pres_optative ! Pl ! P3)) ++
+           tr (intagAttr "th" "rowspan=\"6\"" "perf_optative" ++ intagAttr "th" "rowspan=\"3\"" "Sg" ++ th "P1" ++ td (x.perf_optative ! Sg ! P1)) ++
+           tr (th "P2" ++ td (x.perf_optative ! Sg ! P2)) ++
+           tr (th "P3" ++ td (x.perf_optative ! Sg ! P3)) ++
+           tr (intagAttr "th" "rowspan=\"3\"" "Pl" ++ th "P1" ++ td (x.perf_optative ! Pl ! P1)) ++
+           tr (th "P2" ++ td (x.perf_optative ! Pl ! P2)) ++
+           tr (th "P3" ++ td (x.perf_optative ! Pl ! P3)) ++
+           tr (intagAttr "th" "rowspan=\"6\"" "pres_admirative" ++ intagAttr "th" "rowspan=\"3\"" "Sg" ++ th "P1" ++ td (x.pres_admirative ! Sg ! P1)) ++
+           tr (th "P2" ++ td (x.pres_admirative ! Sg ! P2)) ++
+           tr (th "P3" ++ td (x.pres_admirative ! Sg ! P3)) ++
+           tr (intagAttr "th" "rowspan=\"3\"" "Pl" ++ th "P1" ++ td (x.pres_admirative ! Pl ! P1)) ++
+           tr (th "P2" ++ td (x.pres_admirative ! Pl ! P2)) ++
+           tr (th "P3" ++ td (x.pres_admirative ! Pl ! P3)) ++
+           tr (intagAttr "th" "rowspan=\"6\"" "imperf_admirative" ++ intagAttr "th" "rowspan=\"3\"" "Sg" ++ th "P1" ++ td (x.imperf_admirative ! Sg ! P1)) ++
+           tr (th "P2" ++ td (x.imperf_admirative ! Sg ! P2)) ++
+           tr (th "P3" ++ td (x.imperf_admirative ! Sg ! P3)) ++
+           tr (intagAttr "th" "rowspan=\"3\"" "Pl" ++ th "P1" ++ td (x.imperf_admirative ! Pl ! P1)) ++
+           tr (th "P2" ++ td (x.imperf_admirative ! Pl ! P2)) ++
+           tr (th "P3" ++ td (x.imperf_admirative ! Pl ! P3))) ;
+      s3=[]
+    } ;
+lin InflectionAdv = \x -> {
+      t="nd" ;
+      s1=heading1 "Ndajfolje" ;
+      s2=frameTable (
+           tr (th "s" ++ td (x.s))) ;
+      s3=[]
+    } ;
+lin
+NoDefinition   t     = {s=t.s};
+MkDefinition   t d   = {s="<p><b>Definition:</b>"++t.s++d.s++"</p>"};
+MkDefinitionEx t d e = {s="<p><b>Definition:</b>"++t.s++d.s++"</p><p><b>Example:</b>"++e.s++"</p>"};lin  MkDocument d i e = {s = i.s1 ++ d.s ++ i.s2 ++ i.s3 ++ e.s} ;  MkTag i = {s = i.t} ;}

src/albanian/GrammarSqi.gf

@@ -0,0 +1,9 @@
+concrete GrammarSqi of Grammar =
+  NounSqi,
+  AdjectiveSqi,
+  NumeralSqi,
+  PhraseSqi,
+  StructuralSqi
+  ** {
+
+} ;

src/albanian/LangSqi.gf

@@ -0,0 +1,10 @@
+--# -path=.:../abstract
+concrete LangSqi of Lang =
+  GrammarSqi,
+  LexiconSqi
+  ,DocumentationSqi --# notpresent
+  ** {
+
+flags startcat = Phr ;
+
+}

src/albanian/LexiconSqi.gf

@@ -0,0 +1,8 @@
+concrete LexiconSqi of Lexicon = CatSqi ** open ParadigmsSqi in {
+
+lin
+  airplane_N = mkN032 "aeroplan" ;
+  apple_N = mkN069 "mollë" ;
+  good_A = mkA "mirë" ;
+
+}

src/albanian/NounSqi.gf

@@ -0,0 +1,40 @@
+concrete NounSqi of Noun = CatSqi ** open MorphoSqi, ResSqi in {
+
+  flags optimize=all_subs ;
+
+  lin
+    DetCN det cn = {
+      s = \\c => det.s ! c ! cn.g ++ cn.s ! det.spec ! c ! det.n ;
+      a = agrgP3 cn.g det.n
+      } ;
+
+    UsePron p = p ;
+
+    DetQuant quant num = {
+      s  = \\c,g => quant.s ! c ! g ! num.n ++ num.s ;
+      n  = num.n ;
+      spec = quant.spec
+      } ;
+
+    NumSg = {s = []; n = Sg} ;
+    NumPl = {s = []; n = Pl} ;
+
+    DefArt = {
+      s  = \\c,g,n => [] ;
+      spec = Def
+      } ;
+
+    IndefArt = {
+      s = \\c,g => table Number ["një"; []] ;
+      spec = Indef
+      } ;
+
+    UseN n = n ;
+    UseN2 n = n ;
+
+    AdjCN ap cn = {
+      s = \\spec,c,n => cn.s ! spec ! c ! n ++ ap.s ! spec ! c ! cn.g ! n ;
+      g = cn.g
+      } ;
+
+}

src/albanian/NumeralSqi.gf

@@ -0,0 +1,87 @@
+concrete NumeralSqi of Numeral = CatSqi ** open ParamX, Prelude in {
+
+oper bind : Str -> Str -> Str = \a -> \b -> a ++ b ;
+
+param DForm = unit | teen | ten ;
+
+oper LinDigit = {s : DForm => Str };
+oper LinSub100 = {s : Str } ;
+
+lincat Digit =      LinDigit ;
+lincat Sub10 =      LinDigit ;
+lincat Sub100 =     LinSub100 ;
+lincat Sub1000 =    LinSub100 ;
+lincat Sub1000000 = { s : Str } ;
+
+oper mkNum : Str -> LinDigit = \tri -> 
+  { s = table {unit => tri ; teen => tri + "mbë" + "dhjetë" ; ten => tri + "dhjetë" }};
+
+lin num x = {s = x.s } ; 
+
+lin n2 = {s = table {unit => "dy" ; teen => "dy" + "mbë" + "dhjetë" ; ten => "njëzet" }};
+lin n3 = mkNum "tre" ;
+lin n4 = {s = table {unit => "katër" ; teen => "katër" + "mbë" + "dhjetë" ; ten => "dyzet" } };
+lin n5 = mkNum "pesë" ;
+lin n6 = mkNum "gjashtë";
+lin n7 = mkNum "shtatë";
+lin n8 = mkNum "tetë";
+lin n9 = mkNum "nëntë";
+
+oper mkR : Str -> LinSub100 = \n -> {s = n } ;
+
+lin pot01 = { s = table {_ => "një" }};
+lin pot0 d = d ;
+lin pot110 = mkR "dhjetë" ;
+lin pot111 = mkR ("një" + "mbë" + "dhjetë") ;
+lin pot1to19 d = mkR (d.s ! teen) ;
+lin pot0as1 n = mkR (n.s ! unit) ;
+lin pot1 d = mkR (d.s ! ten) ;
+lin pot1plus d e = mkR ((d.s ! ten) ++ "e" ++ (e.s ! unit)) ;
+lin pot1as2 n = n ;
+lin pot2 d = mkR (bind (d.s ! unit) "qind") ;
+lin pot2plus d e = mkR ((bind (d.s ! unit) "qind") ++ "e" ++ e.s) ;
+lin pot2as3 n = {s = n.s };
+lin pot3 n = {s = n.s ++ "mijë" } ;
+lin pot3plus n m = {s = n.s ++ "mijë" ++ m.s} ;
+
+
+lincat Dig = {s : Str; n : Number} ;
+
+lin IDig d = d ** {tail = T1} ;
+
+    IIDig d i = {
+      s = d.s ++ spaceIf i.tail ++ i.s ;
+      n = Pl ;
+      tail = inc i.tail
+    } ;
+
+    D_0 = mkDig "0" Pl ;
+    D_1 = mkDig "1" Sg ;
+    D_2 = mkDig "2" Pl ;
+    D_3 = mkDig "3" Pl ;
+    D_4 = mkDig "4" Pl ;
+    D_5 = mkDig "5" Pl ;
+    D_6 = mkDig "6" Pl ;
+    D_7 = mkDig "7" Pl ;
+    D_8 = mkDig "8" Pl ;
+    D_9 = mkDig "9" Pl ;
+
+lin PosDecimal d = d ** {hasDot=False} ;
+    NegDecimal d = {s="-" ++ BIND ++ d.s;  hasDot=False; n = Pl} ;
+    IFrac d i = {
+        s=d.s ++
+          if_then_Str d.hasDot BIND (BIND++","++BIND) ++
+          i.s ;
+        hasDot=True;
+        n = Pl
+    } ;
+
+oper
+    mkDig : Str -> Number -> Dig = \s,n -> lin Dig {s=s; n=n} ;
+
+    spaceIf : DTail -> Str = \t -> case t of {
+      T3 => "" ;
+      _  => BIND
+      } ;
+
+}

src/albanian/PhraseSqi.gf

@@ -0,0 +1,14 @@
+concrete PhraseSqi of Phrase = CatSqi ** open Prelude, ResSqi in {
+
+  lin
+    PhrUtt pconj utt voc = {s = pconj.s ++ utt.s ++ voc.s} ;
+
+    UttS s = s ;
+    UttNP np = {s = np.s ! Nom} ;
+    UttInterj i = i ;
+
+    NoPConj = {s = []} ;
+
+    NoVoc = {s = []} ;
+
+}

src/albanian/ResSqi.gf

@@ -0,0 +1,261 @@
+resource ResSqi = ParamX-[Tense,Past,Pres] ** open Prelude in {
+
+oper Compl = {s : Str} ;
+
+param Species = Indef | Def ;
+param Case = Nom | Acc | Dat | Ablat ;
+param Gender = Masc | Fem ;
+
+param GenNum = GSg Gender | GPl ;
+oper Agr = {gn : GenNum; p : Person} ;
+
+oper Noun = {s: Species => Case => Number => Str; g: Gender} ; -- 3978
+oper mkNoun : (_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_ : Str) -> Gender -> Noun =
+       \f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15,f16,g ->
+          { s = table {
+                  Indef => table {
+                             Nom => table {
+                                      Sg => f1 ;
+                                      Pl => f2
+                                    } ;
+                             Acc => table {
+                                      Sg => f3 ;
+                                      Pl => f4
+                                    } ;
+                             Dat => table {
+                                      Sg => f5 ;
+                                      Pl => f6
+                                    } ;
+                             Ablat => table {
+                                        Sg => f7 ;
+                                        Pl => f8
+                                      }
+                           } ;
+                  Def => table {
+                           Nom => table {
+                                    Sg => f9 ;
+                                    Pl => f10
+                                  } ;
+                           Acc => table {
+                                    Sg => f11 ;
+                                    Pl => f12
+                                  } ;
+                           Dat => table {
+                                    Sg => f13 ;
+                                    Pl => f14
+                                  } ;
+                           Ablat => table {
+                                      Sg => f15 ;
+                                      Pl => f16
+                                    }
+                         }
+                } ;
+            g = g
+          } ;
+
+
+oper Adj = {s: Case => Gender => Number => Str; clit: Bool} ; -- 462
+oper mkAdj : (_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_ : Str) -> Bool -> Adj =
+       \f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15,f16,clit ->
+          { s = table {
+                  Nom => table {
+                           Masc => table {
+                                     Sg => f1 ;
+                                     Pl => f2
+                                   } ;
+                           Fem => table {
+                                    Sg => f3 ;
+                                    Pl => f4
+                                  }
+                         } ;
+                  Acc => table {
+                           Masc => table {
+                                     Sg => f5 ;
+                                     Pl => f6
+                                   } ;
+                           Fem => table {
+                                    Sg => f7 ;
+                                    Pl => f8
+                                  }
+                         } ;
+                  Dat => table {
+                           Masc => table {
+                                     Sg => f9 ;
+                                     Pl => f10
+                                   } ;
+                           Fem => table {
+                                    Sg => f11 ;
+                                    Pl => f12
+                                  }
+                         } ;
+                  Ablat => table {
+                             Masc => table {
+                                       Sg => f13 ;
+                                       Pl => f14
+                                     } ;
+                             Fem => table {
+                                      Sg => f15 ;
+                                      Pl => f16
+                                    }
+                           }
+                } ;
+            clit = clit
+          } ;
+
+
+param Tense = Pres | Past | Imperfect | Aorist ;
+oper Verb = {Indicative: Tense => Number => Person => Str; Imperative: Number => Str; participle: Str; pres_optative: Number => Person => Str; perf_optative: Number => Person => Str; pres_admirative: Number => Person => Str; imperf_admirative: Number => Person => Str} ; -- 758
+oper mkVerb : (_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_ : Str) -> Verb =
+       \f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15,f16,f17,f18,f19,f20,f21,f22,f23,f24,f25,f26,f27,f28,f29,f30,f31,f32,f33,f34,f35,f36,f37,f38,f39,f40,f41,f42,f43,f44,f45,f46,f47,f48,f49,f50,f51 ->
+          { Indicative = table {
+                           Pres => table {
+                                     Sg => table {
+                                             P1 => f1 ;
+                                             P2 => f2 ;
+                                             P3 => f3
+                                           } ;
+                                     Pl => table {
+                                             P1 => f4 ;
+                                             P2 => f5 ;
+                                             P3 => f6
+                                           }
+                                   } ;
+                           Past => table {
+                                     Sg => table {
+                                             P1 => f7 ;
+                                             P2 => f8 ;
+                                             P3 => f9
+                                           } ;
+                                     Pl => table {
+                                             P1 => f10 ;
+                                             P2 => f11 ;
+                                             P3 => f12
+                                           }
+                                   } ;
+                           Aorist => table {
+                                       Sg => table {
+                                               P1 => f13 ;
+                                               P2 => f14 ;
+                                               P3 => f15
+                                             } ;
+                                       Pl => table {
+                                               P1 => f16 ;
+                                               P2 => f17 ;
+                                               P3 => f18
+                                             }
+                                     } ;
+                           Imperfect => table {
+                                          Sg => table {
+                                                  P1 => f19 ;
+                                                  P2 => f20 ;
+                                                  P3 => f21
+                                                } ;
+                                          Pl => table {
+                                                  P1 => f22 ;
+                                                  P2 => f23 ;
+                                                  P3 => f24
+                                                }
+                                        }
+                         } ;
+            Imperative = table {
+                           Sg => f25 ;
+                           Pl => f26
+                         } ;
+            participle = f27 ;
+            pres_optative = table {
+                              Sg => table {
+                                      P1 => f28 ;
+                                      P2 => f29 ;
+                                      P3 => f30
+                                    } ;
+                              Pl => table {
+                                      P1 => f31 ;
+                                      P2 => f32 ;
+                                      P3 => f33
+                                    }
+                            } ;
+            perf_optative = table {
+                              Sg => table {
+                                      P1 => f34 ;
+                                      P2 => f35 ;
+                                      P3 => f36
+                                    } ;
+                              Pl => table {
+                                      P1 => f37 ;
+                                      P2 => f38 ;
+                                      P3 => f39
+                                    }
+                            } ;
+            pres_admirative = table {
+                                Sg => table {
+                                        P1 => f40 ;
+                                        P2 => f41 ;
+                                        P3 => f42
+                                      } ;
+                                Pl => table {
+                                        P1 => f43 ;
+                                        P2 => f44 ;
+                                        P3 => f45
+                                      }
+                              } ;
+            imperf_admirative = table {
+                                  Sg => table {
+                                          P1 => f46 ;
+                                          P2 => f47 ;
+                                          P3 => f48
+                                        } ;
+                                  Pl => table {
+                                          P1 => f49 ;
+                                          P2 => f50 ;
+                                          P3 => f51
+                                        }
+                                }
+          } ;
+
+oper link_clitic : Species => Case => Gender => Number => Str =
+       table {
+         Indef => table {
+                    Nom => table {
+                             Masc => table {
+                                       Sg => "i" ;
+                                       Pl => "të"
+                                     } ;
+                             Fem => table {
+                                      Sg => "e" ;
+                                      Pl => "të"
+                                    }
+                           } ;
+                    _ => \\_,_ => "të"
+                  } ;
+         Def => table {
+                    Nom => table {
+                             Masc => table {
+                                       Sg => "i" ;
+                                       Pl => "e"
+                                     } ;
+                             Fem => table {
+                                      Sg => "e" ;
+                                      Pl => "e"
+                                    }
+                           } ;
+                    Acc => \\_,_ => "e" ;
+                    _   => table {
+                             Masc => \\_ => "të" ;
+                             Fem => table {
+                                      Sg => "së" ;
+                                      Pl => "të"
+                                    }
+                           }
+                  }
+          } ;
+
+oper genNum : Gender -> Number -> GenNum = \g,n ->
+       case n of {
+         Sg => GSg g ;
+         Pl => GPl
+       } ;
+
+     agrgP3 : Gender -> Number -> Agr = 
+       \g,n -> {gn=genNum g n; p=P3} ;
+
+}

src/albanian/StructuralSqi.gf

@@ -0,0 +1,19 @@
+concrete StructuralSqi of Structural = CatSqi ** open ResSqi, ParadigmsSqi in {
+
+lin i_Pron = mkPron "unë" "mua" "mua" "meje" "më" "më" (GSg Masc) P1 ;
+lin youSg_Pron = mkPron "ti" "ty" "ty" "teje" "të" "të" (GSg Masc) P2 ;
+lin he_Pron = mkPron "ai" "atë" "atij" "atij" "e" "i" (GSg Masc) P3 ;
+lin she_Pron = mkPron "ajo" "atë" "asaj" "asaj" "e" "i" (GSg Fem) P3 ;
+lin it_Pron = mkPron "ai" "atë" "atij" "atij" "e" "i" (GSg Masc) P3 ;
+lin we_Pron = mkPron "ne" "ne" "neve" "nesh" "na" "na" GPl P1 ;
+lin youPl_Pron = mkPron "ju" "ju" "juve" "jush" "ju" "ju" GPl P2 ;
+lin they_Pron = mkPron "ata" "ata" "atyre" "atyre" "i" "u" GPl P3 ;
+lin this_Quant = mkQuant "ky"    "këta"     "kjo"   "këto"
+                         "këtë"  "këtyre"   "këtë"  "këtyre"
+                         "këtij" "këtyre"   "kësaj" "këtyre"
+                         "këtij" "këtyre"   "kësaj" "këtyre" ;
+lin that_Quant = mkQuant "ai"   "ata"   "ajo"  "ato"
+                         "atë"  "ata"   "atë"  "ato"
+                         "atij" "atyre" "asaj" "atyre"
+                         "atij" "atyre" "asaj" "atyre" ;
+}

src/amharic/CatAmh.gf

@@ -22,6 +22,7 @@ lincat
 	Prep = ResAmh.Prep;
 	Numeral = ResAmh.Numeral; --{s : CardOrd => Case => Str ; n : Number} ;
 	Digits  = ResAmh.Digits;--{s : CardOrd => Case => Str ; n : Number ; tail : DTail} ;
+	Decimal = ResAmh.Decimal;
 	Ord = ResAmh.Ord ; --{ s : Case => Str } ;
 	Num  = ResAmh.Num;--{s : Case => Str ; n : Number ; hasCard : Bool} ;
 	Card = ResAmh.Card;--{s : Case => Str ; n : Number} ;

src/amharic/NounAmh.gf

@@ -94,6 +94,7 @@ lin
 	NumCard n = {s = \\s,c => n.s!Masc!Sg!s!c ; n = Pl; hasCard = True} ;
 
 	NumDigits n = {s = n.s ! NCard } ;
+	NumDecimal n = {s = n.s ! NCard } ;
 	
 	NumNumeral numeral = {s = numeral.s ! NCard} ;
 

src/amharic/NumeralAmh.gf

@@ -1,5 +1,5 @@
 
-concrete NumeralAmh of Numeral = CatAmh [Numeral,Digits] ** open ResAmh,ParamX,Prelude in {
+concrete NumeralAmh of Numeral = CatAmh [Numeral,Digits,Decimal] ** open ResAmh,ParamX,Prelude in {
 flags coding = utf8;
 lincat 
 
@@ -91,17 +91,24 @@ lin pot3plus n m = {
     D_8 = mkDig "8" ;
     D_9 = mk2Dig "9" "9ኛ";
 
+    PosDecimal d = d ** {hasDot=False} ;
+    NegDecimal d = {
+      s = \\o,g,n,s,c => "-" ++ BIND ++ d.s !o!g!n!s!c ;
+      hasDot=False
+    } ;
+    IFrac d i = {
+      s = \\o,g,n,s,c => d.s!NCard!Masc!Sg!Indef!c ++
+                         if_then_Str d.hasDot BIND (BIND++"."++BIND) ++
+                         i.s ! o ! g ! n ! s ! c;
+      hasDot=True
+      } ;
+
   oper
     commaIf : DTail -> Str = \t -> case t of {
       T3 => BIND++","++BIND ;
       _  => BIND
       } ;
 
-    inc : DTail -> DTail = \t -> case t of {
-      T1 => T2 ;
-      T2 => T3 ;
-      T3 => T1
-      } ;
 ------------------ :) what a releif 
 
     mk2Dig : Str -> Str -> TDigit = \c,o -> mk3Dig c o  ;

src/amharic/ResAmh.gf

@@ -161,6 +161,10 @@ resource ResAmh =  PatternsAmh** open Prelude,MorphoAmh,ParamX in {
                             s : CardOrd=>Gender=>Number=>Species=>Case => Str ; 
                             tail : DTail
                           } ;
+    		Decimal  = {
+                            s : CardOrd=>Gender=>Number=>Species=>Case => Str ; 
+                            hasDot : Bool
+                          } ;
 
  		Ord =  {s : Gender=>Number=>Species=>Case => Str} ;
 
@@ -991,8 +995,8 @@ pronNP : (N,A,G,D : Str) -> PerNumGen -> NP = \N,A,G,D,png-> {
     {     
       s = \\c =>case c of
 		{
-		Gen|Dat => affix!c + word;
+		Gen|Dat => affix!c ++ Predef.BIND ++ word;
-		   _    => word + affix!c 
+		   _    => word ++ Predef.BIND ++ affix!c 
 		};
       a = {png = Per3 n Masc ; isPron = False };
       lock_NP = <>

src/ancient_greek/CatGrc.gf

@@ -90,6 +90,7 @@ concrete CatGrc of Cat = CommonX - [Temp,Tense] ** open ResGrc, Prelude in {
 
     Numeral = {s : CardOrd => Str ; n : Number} ;
     Digits  = {s : Str ; unit : Unit} ;
+    Decimal = {s : Str ; unit : Unit ; hasDot : Bool} ;
 
 -- Structural
 

src/ancient_greek/ExtraGrc.gf

@@ -323,8 +323,8 @@ concrete ExtraGrc of ExtraGrcAbs = CatGrc, NumeralGrc[Sub1000000,tenthousand] **
     Sub10000 = {s : CardOrd => Str ; n : Number} ;   -- TODO: constructors
 
   lin                                                -- d * 10000
-    pot4 d = { s = \\f => d.s ! NAdv ++ (tenthousand ! f) ; n = Pl } ;
+    pot3X d = { s = \\f => d.s ! NAdv ++ (tenthousand ! f) ; n = Pl } ;
-    pot4plus d m = {
+    pot3Xplus d m = {
          s = \\f => d.s ! NAdv ++ tenthousand ! f ++ "kai`" ++ m.s ! f ; n = Pl} ;
 
 

src/ancient_greek/ExtraGrcAbs.gf

@@ -153,8 +153,8 @@ abstract ExtraGrcAbs = Extra, Numeral[Sub1000000] ** {
     Sub10000 ;     -- 1..9999
 
   data
-    pot4 : Sub10000 -> Sub1000000 ;                 -- m * 10000
+    pot3X : Sub10000 -> Sub1000000 ;                 -- m * 10000
-    pot4plus : Sub10000 -> Sub10000 -> Sub1000000 ; -- m * 10000 + n
+    pot3Xplus : Sub10000 -> Sub10000 -> Sub1000000 ; -- m * 10000 + n
 
 -- Conjunctions: 
 

src/ancient_greek/NounGrc.gf

@@ -83,6 +83,8 @@ concrete NounGrc of Noun = CatGrc ** open Prelude, ResGrc, (M = MorphoGrc) in {
     -- TODO: check the following two:
     NumDigits digits = let num : Number = case digits.unit of {one => Sg ; _ => Pl}
                         in {s = \\g,c => digits.s ++ "'"; n = num ; isCard = True} ;
+    NumDecimal digits = let num : Number = case digits.unit of {one => Sg ; _ => Pl}
+                        in {s = \\g,c => digits.s ++ "'"; n = num ; isCard = True} ;
     NumNumeral numeral = {s = \\g,c => numeral.s ! NCard g c; n = numeral.n } ;
 
     AdNum adn num = {s = \\g,c => adn.s ++ num.s ! g ! c ; n = num.n} ;

src/ancient_greek/NumeralGrc.gf

@@ -1,13 +1,15 @@
 --# -path=.:../abstract:../common:../prelude:
 
-concrete NumeralGrc of Numeral = CatGrc ** open ResGrc, MorphoGrc in {
+concrete NumeralGrc of Numeral = CatGrc ** open ResGrc, MorphoGrc, Prelude in {
 
 lincat 
   Digit = {s : DForm => CardOrd => Str} ;
   Sub10 = {s : DForm => CardOrd => Str ; n : Number} ;
-  Sub100     = {s : CardOrd => Str ; n : Number} ;
+  Sub100           = {s : CardOrd => Str ; n : Number} ;
-  Sub1000    = {s : CardOrd => Str ; n : Number} ;
+  Sub1000          = {s : CardOrd => Str ; n : Number} ;
-  Sub1000000 = {s : CardOrd => Str ; n : Number} ;
+  Sub1000000       = {s : CardOrd => Str ; n : Number} ;
+  Sub1000000000    = {s : CardOrd => Str ; n : Number} ;
+  Sub1000000000000 = {s : CardOrd => Str ; n : Number} ;
 
 lin num x = x ;
 
@@ -52,6 +54,8 @@ lin -- mkDigit   d       (d+10)           (d*10)          d-th         d-times
   pot3plus d m = {
      s = \\f => d.s ! NAdv ++ thousand ! f ++ "kai`" ++ m.s ! f ; n = Pl} ;
 
+  pot3as4 n = n ;
+  pot4as5 n = n ;
 
 -- numerals as sequences of digits
 
@@ -77,6 +81,8 @@ lin -- mkDigit   d       (d+10)           (d*10)          d-th         d-times
     D_8 = mkDig "h"  "p" "w"  ;
     D_9 = mkDig "v"  "K" "P"  ;  -- TODO: replace K by koppa, P by sampi (not in ut -ancientgreek)
 
+    PosDecimal d = d ** {hasDot=False} ;
+
   oper
     TDigit = {
       s : Unit => Str

src/ancient_greek/ResGrc.gf

@@ -18,7 +18,7 @@
 -- Author: Hans Leiß, LMU Munich, CIS
 
 
-resource ResGrc = ParamX - [Number,Sg,Pl,ImpForm,numImp,Tense,ImpF] 
+resource ResGrc = ParamX - [Number,Sg,Pl,ImpForm,numImp,Tense,ImpF,inc,DTail]
                   ** open Prelude, PhonoGrc, Predef in {
 flags 
   optimize = noexpand ;  -- optimize=all is impossible with addAccent

src/api/CombinatorsHrv.gf

@@ -0,0 +1,9 @@
+--# -path=.:alltenses:prelude
+
+resource CombinatorsHrv = Combinators with 
+  (Cat = CatHrv),
+  (Structural = StructuralHrv),
+  (Constructors = ConstructorsHrv)
+    ** open MissingHrv in {}
+    
+

src/api/CombinatorsMay.gf

@@ -0,0 +1,8 @@
+--# -path=.:alltenses:prelude
+
+resource CombinatorsMay = Combinators - [ appCN, appCNc ] with 
+  (Cat = CatMay),
+  (Structural = StructuralMay),
+  (Noun = NounMay),
+  (Constructors = ConstructorsMay) ** 
+  {}