chinese (Chi) in place and compiles, based on work by Jolene Zhuo Lin Qiqige

lib/src/chinese/ResChi.gf

@@ -0,0 +1,221 @@
+--# -path=.:../abstract:../common:../../prelude
+
+--1 Thai auxiliary operations.
+--
+---- This module contains operations that are needed to make the
+---- resource syntax work. To define everything that is needed to
+---- implement $Test$, it moreover contains regular lexical
+---- patterns needed for $Lex$.
+--
+resource ResChi = ParamX ** open Prelude in {
+
+  flags coding = utf8 ;
+
+  oper
+
+-- strings ----
+
+  defaultStr = "" ;
+
+  than_s = "比" ;
+  progressive_s = defaultStr ;
+  possessive_s = "的" ;
+  imperneg_s = neg_s ;
+  conjThat = emptyStr ; ----
+  reflPron = word "自己" ;   -- pron + refl
+  passive_s = defaultStr ;
+  relative_s = possessive_s ; -- relative
+  superlative_s = "最" ; -- superlative, sup + adj + de
+  zai_s = "在" ;  -- copula for place
+  you_s = "有" ; -- to have
+
+  copula_s = "是" ;
+  exist_s = word "存在" ;
+  neg_s = "不" ;
+  question_s = "吗" ;
+  yi_s = "一" ;
+  ordinal_s = "第" ;
+  xie_s = "些" ;
+  the_s = "那" ;
+  geng_s = "更" ; -- more, in comparison
+
+  zai_V = mkVerb "在" [] [] [] [] "不" ;
+  fullstop_s = "。" ;
+  questmark_s = "？" ;
+  exclmark_s = "!" ;
+  ge_s = "个" ;
+  di_s = "是" ; -- used in QuestSlash
+
+  emptyStr = [] ;
+
+
+-- Write the characters that constitute a word separately. This enables straightforward tokenization.
+
+  bword : Str -> Str -> Str = \x,y -> x ++ y ; -- change to x + y to treat words as single tokens
+
+  word : Str -> Str = \s -> case s of {
+      x@? + y@? + z@? + u@? => bword x (bword y (bword z u)) ;
+      x@? + y@? + z@? => bword x (bword y z) ;
+      x@? + y@? => bword x y ;
+      _ => s
+      } ;
+
+  ssword : Str -> SS = \s -> ss (word s) ;
+
+------------------------------------------------ from Jolene
+
+-- parameters
+
+param
+    Aspect = APlain | APerf | ADurStat | ADurProg | AExper ;  ---- APlain added by AR
+    ConjForm = CPhr CPosType | CSent;
+    CPosType = CAPhrase | CNPhrase | CVPhrase ;
+    DeForm = DeNoun | NdNoun ;    -- parameter created for noun with/out partical "de"
+
+    AdvType = ATPlace | ATTime | ATManner ;
+
+-- parts of speech
+
+oper
+
+  VP = {verb : Verb ; compl : Str ; prePart : Str} ;
+  NP = {s : Str} ; 
+
+-- for morphology
+
+  Noun : Type = {s : Str; c : Str} ;
+  Adj  : Type = {s : Str; monoSyl: Bool} ;
+  Verb : Type = {s : Str ; pp,ds,dp,ep : Str ; neg : Str} ;
+
+  regNoun : Str -> Str -> Noun = \s,c -> {s = word s ; c = word c};
+
+  mkAdj : Str -> Bool -> Adj = \s,b -> {s = word s ; monoSyl = b};
+
+  complexAP : Str -> Adj = \s -> {s = s ; monoSyl = False} ;
+
+  simpleAdj : Str -> Adj = \s -> case s of {
+    ? => mkAdj s True ; -- monosyllabic
+    _ => mkAdj s False
+    } ;
+
+  copula : Verb = mkVerb "是" [] [] [] [] "不" ;
+
+  regVerb : (walk : Str) -> Verb = \v -> 
+    mkVerb v "了" "着" "在" "过" "没" ;
+
+  mkVerb : (v : Str) -> (pp,ds,dp,ep,neg : Str) -> Verb = \v,pp,ds,dp,ep,neg -> 
+    {s = word v ; pp = pp ; ds = ds ; dp = dp ; ep = ep ; neg = neg} ;
+
+  useVerb : Verb -> Polarity => Aspect => Str = \v -> 
+    table {
+          Pos => table {
+            APlain   => v.s ;
+            APerf    => v.s ++ v.pp ;
+            ADurStat => v.s ++ v.ds ;
+            ADurProg => v.dp ++ v.s ;
+            AExper   => v.s ++ v.ep
+            } ;
+          Neg => table {
+            APlain   => v.neg ++ v.s ; --- neg?
+            APerf    => "不" ++ v.s ++ v.pp ;
+            ADurStat => "不" ++ v.s ;
+            ADurProg => v.neg ++ v.dp ++ v.s ;  -- mei or bu
+            AExper   => v.neg ++ v.s ++ v.ep
+            }
+     } ;
+
+  infVP : VP -> Str = \vp -> vp.prePart ++ vp.verb.s ++ vp.compl ; 
+
+  predV : Verb -> VP = \v -> {
+      verb = v ; 
+      compl = [] ;
+      prePart = [] ;
+      } ; 
+
+  insertObj : NP -> VP -> VP = \np,vp -> {
+     verb  = vp.verb ;
+     compl = np.s ++ vp.compl ;
+     prePart = vp.prePart
+     } ; 
+
+  insertObjPost : NP -> VP -> VP = \np,vp -> {
+     verb  = vp.verb ;
+     compl = vp.compl ++ np.s ;
+     prePart = vp.prePart
+     } ; 
+
+   insertAdv : SS -> VP -> VP = \adv,vp -> {
+     verb  = vp.verb ;
+     compl = vp.compl ;
+     prePart = adv.s
+     } ; 
+
+   insertExtra : SS -> VP -> VP = \ext,vp ->
+     insertObjPost ext vp ;
+
+-- clauses: keep np and vp separate to enable insertion of IAdv
+
+   Clause : Type = {
+     s  : Polarity => Aspect => Str ; 
+     np : Str; 
+     vp : Polarity => Aspect => Str
+     } ; 
+
+
+   mkClause = overload {
+     mkClause : Str -> Verb -> Clause = \np,v -> mkClauseCompl np (useVerb v) [] ;
+     mkClause : Str -> (Polarity => Aspect => Str) -> Str -> Clause = mkClauseCompl ;
+     mkClause : Str -> Verb -> Str -> Clause = \subj,verb,obj ->
+       mkClauseCompl subj (useVerb verb) obj ;
+     mkClause : Str -> VP -> Clause = \np,vp -> 
+       mkClauseCompl np (\\p,a => vp.prePart ++ useVerb vp.verb ! p ! a) vp.compl ;
+     } ;
+ 
+   mkClauseCompl : Str -> (Polarity => Aspect => Str) -> Str -> Clause = \np,vp,compl -> {
+     s = \\p,a => np ++ vp ! p ! a ++ compl ;
+     np = np ;
+     vp = \\p,a => vp ! p ! a ++ compl
+     } ;
+   
+
+-- for structural words
+
+param 
+  DetType = DTFull Number | DTNum | DTPoss ;  -- this, these, five, our
+  NumType = NTFull | NTVoid Number ;          -- five, sg, pl
+
+oper
+  Determiner = {s : Str ; detType : DetType} ;
+
+  mkDet = overload {
+    mkDet : Str ->            Determiner = \s   -> {s = s ; detType = DTFull Sg} ;
+    mkDet : Str -> Number  -> Determiner = \s,n -> {s = s ; detType = DTFull n} ;
+    mkDet : Str -> DetType -> Determiner = \s,d -> {s = s ; detType = d} ;
+    } ;
+
+  mkQuant : Str -> {s : Str} = ss ;
+
+  pronNP : (s : Str) -> NP = \s -> {
+    s = word s
+    } ;
+    
+  mkPreposition : Str -> Str -> Preposition = \s,b -> {
+    prepMain = word s ;
+    prepPre = word b
+    } ;
+    
+  mkSubj : Str -> Str -> {prePart : Str ; sufPart : Str} = \p,s -> {
+    prePart = word p ;
+    sufPart = word s
+    } ;
+
+  Preposition = {prepMain : Str ; prepPre : Str} ;  
+
+-- added by AR
+
+  mkNP : Str -> NP = ss ;
+
+  appPrep : Preposition -> Str -> Str = \prep,s -> 
+    prep.prepPre ++ s ++ prep.prepMain ;
+
+}