diff --git a/src/dutch/AdjectiveDut.gf b/src/dutch/AdjectiveDut.gf
index dcc2f5e5d..64865f064 100644
--- a/src/dutch/AdjectiveDut.gf
+++ b/src/dutch/AdjectiveDut.gf
@@ -30,12 +30,12 @@ concrete AdjectiveDut of Adjective = CatDut ** open ResDut, Prelude in
 -- $SuperlA$ belongs to determiner syntax in $Noun$.
 
     ComplA2 a np = {
-      s = \\af => a.s ! Posit ! af ++ appPrep a.c2 np.s ; 
+      s = \\af => a.s ! Posit ! af ++ appPrep a.c2 np ; 
       isPre = True
       } ;
 
     ReflA2 a = {
-      s = \\af => a.s ! Posit ! APred ++ appPrep a.c2 (\\_ => reflPron ! agrP3 Sg) ; --- agr 
+      s = \\af => a.s ! Posit ! APred ++ appPrep a.c2 (npLite (\\_ => reflPron ! agrP3 Sg)) ; --- agr 
       isPre = True
       } ;
 
diff --git a/src/dutch/AdverbDut.gf b/src/dutch/AdverbDut.gf
index 8d39790d6..a4b7fa32c 100644
--- a/src/dutch/AdverbDut.gf
+++ b/src/dutch/AdverbDut.gf
@@ -11,7 +11,7 @@ concrete AdverbDut of Adverb = CatDut ** open ResDut, Prelude in {
       s = cadv.s ++ a.s ! Posit ! APred ++ cadv.p ++ s.s ! Sub
       } ;
 
-    PrepNP prep np = {s = appPrep prep.s np.s} ;
+    PrepNP prep np = {s = appPrep prep np} ;
 
     AdAdv = cc2 ;
 
diff --git a/src/dutch/CatDut.gf b/src/dutch/CatDut.gf
index 5e384c66a..09ae24dfd 100644
--- a/src/dutch/CatDut.gf
+++ b/src/dutch/CatDut.gf
@@ -44,15 +44,12 @@ concrete CatDut of Cat =
 -- Noun
 
     CN = {s : Adjf => NForm => Str ; g : Gender} ;
-    NP = {s : NPCase => Str ; a : Agr ; isPron : Bool} ;
+    NP = NounPhrase ; 
+
     Pron = Pronoun ;
 
-    Det = {s,sp : Gender => Str ; n : Number ; a : Adjf} ;
-    Quant = {
-      s  : Bool => Number => Gender => Str ; 
-      sp : Number => Gender => Str ; 
-      a  : Adjf
-      } ;
+    Det = Determiner ;
+    Quant = Quantifier ;
     Predet = {s : Number => Gender => Str} ;
     Num = {s : Str ; n : Number ; isNum : Bool} ;
     Card = {s : Gender => Case => Str ; n : Number} ;
@@ -67,7 +64,7 @@ concrete CatDut of Cat =
 
     Conj = {s1,s2 : Str ; n : Number} ;
     Subj = {s : Str} ;
-    Prep = {s : Str} ;
+    Prep = Preposition ;
 
 -- Open lexical classes, e.g. Lexicon
 
diff --git a/src/dutch/ConjunctionDut.gf b/src/dutch/ConjunctionDut.gf
index 9257174e3..09df6bbe6 100644
--- a/src/dutch/ConjunctionDut.gf
+++ b/src/dutch/ConjunctionDut.gf
@@ -9,7 +9,7 @@ concrete ConjunctionDut of Conjunction =
 
     ConjAdv conj ss = conjunctDistrSS conj ss ;
 
-    ConjNP conj ss = heavyNP (conjunctDistrTable NPCase conj ss ** {
+    ConjNP conj ss = noMerge ** heavyNP (conjunctDistrTable NPCase conj ss ** {
       a = {g = Utr ; n = conjNumber conj.n ss.a.n ; p = ss.a.p}
       }) ;
 
diff --git a/src/dutch/ExtraDut.gf b/src/dutch/ExtraDut.gf
index 7baed49d0..95ff440a6 100644
--- a/src/dutch/ExtraDut.gf
+++ b/src/dutch/ExtraDut.gf
@@ -1,5 +1,5 @@
 concrete ExtraDut of ExtraDutAbs = CatDut ** 
-  open ResDut, MorphoDut, Coordination, Prelude, IrregDut, (P = ParadigmsDut) in 
+  open ResDut, MorphoDut, Coordination, Prelude, IrregDut, (P = ParadigmsDut), NounDut in 
 {
 
   flags coding=utf8 ;
@@ -117,12 +117,12 @@ lin
     PassVPSlash vps = 
       insertInf (vps.s.s ! VPerf) (predV ResDut.worden_V) ;
     PassAgentVPSlash vps np = 
-      insertAdv (appPrep "door" np.s) (insertInf (vps.s.s ! VPerf) (predV ResDut.worden_V)) ;
+      insertAdv (appPrep (P.mkPrep "door") np) (insertInf (vps.s.s ! VPerf) (predV ResDut.worden_V)) ;
 
 lin
  NominalizeVPSlashNP vpslash np =
            --False for negation place; doesn't matter because vp.a1 ! Pos is chosen
-           let  vp : ResDut.VP = insertObjNP np.isPron AfterObjs (\\_ => appPrep vpslash.c2.p1 np.s) vpslash ;
+           let  vp : ResDut.VP = insertObjNP np.isPron AfterObjs (\\_ => appPrep vpslash.c2.p1 np) vpslash ;
                 agrDef : Agr = agrP3 Sg ; 
                 compl : Str = vp.n0 ! agrDef ++ vp.a1 ! Pos ++ vp.n2 ! agrDef ++ vp.s.prefix ; 
                 inf : Str = vp.inf.p1 ;
@@ -134,10 +134,7 @@ lin
 lin
   zullen_VV = lin VV (zullen_V ** {isAux = True}) ;
 
-  StressedPron pron = {
-      s = table {NPNom => pron.stressed.nom ; NPAcc => pron.stressed.acc} ;
-      a = pron.a ;
-      isPron = True
-      } ; 
+  StressedPron pron = UsePron pron ** {
+      s = table {NPNom => pron.stressed.nom ; NPAcc => pron.stressed.acc} } ; 
 
 }
diff --git a/src/dutch/NounDut.gf b/src/dutch/NounDut.gf
index 70b6e3b15..9d014af93 100644
--- a/src/dutch/NounDut.gf
+++ b/src/dutch/NounDut.gf
@@ -3,43 +3,47 @@ concrete NounDut of Noun = CatDut ** open ResDut, Prelude in {
   flags optimize=all_subs ;
 
   lin
-    DetCN det cn = {
+    DetCN det cn = noMerge ** {
       s = \\c => det.s ! cn.g ++ cn.s ! det.a ! NF det.n Nom ;
       a = agrP3 det.n ;
-      isPron = False
+      isPron = False ;
       } ;
 
     DetNP det = {
       s = \\_ => det.sp ! Neutr ;
       a = agrP3 det.n ;
-      isPron = False
+      isPron = False ;
+      mergesWithPrep = det.mergesWithPrep ;
+      mergeForm = det.mergeForm
       } ;
 
-    UsePN pn = {s = pn.s ; a = agrP3 Sg ; isPron = False} ;
+    UsePN pn = noMerge ** {s = pn.s ; a = agrP3 Sg ; isPron = False} ;
 
     UsePron pron = {
       s = table {NPNom => pron.unstressed.nom ; NPAcc => pron.unstressed.acc} ;
       a = pron.a ;
-      isPron = True
+      isPron = True ;
+      mergesWithPrep = pron.mergesWithPrep ;
+      mergeForm = pron.mergeForm
       } ;
 
-    PredetNP pred np = heavyNP {
+    PredetNP pred np = np ** heavyNP {
       s = \\c => 
         pred.s ! np.a.n ! np.a.g ++ np.s ! c ; ---- g
       a = np.a
       } ;
 
-    PPartNP np v2 = heavyNP {
+    PPartNP np v2 = np ** heavyNP {
       s = \\c => np.s ! c ++ v2.s ! VPerf ; -- invar part
       a = np.a
       } ;
 
-    AdvNP np adv = heavyNP {
+    AdvNP np adv = np ** heavyNP {
       s = \\c => np.s ! c ++ adv.s ;
       a = np.a
       } ;
 
-    ExtAdvNP np adv = heavyNP {
+    ExtAdvNP np adv = np ** heavyNP {
       s = \\c => np.s ! c ++ embedInCommas adv.s ;
       a = np.a
       } ;
@@ -54,7 +58,9 @@ concrete NounDut of Noun = CatDut ** open ResDut, Prelude in {
         sp = \\g => quant.sp ! n ! g ++ 
                       num.s ++ ord.s ! agrAdj g quant.a (NF n Nom) ;
         n = n ;
-        a = a
+        a = a ;
+        mergesWithPrep = quant.mergesWithPrep ;
+        mergeForm = quant.mergeForm
         } ;
 
     DetQuant quant num = 
@@ -68,12 +74,14 @@ concrete NounDut of Noun = CatDut ** open ResDut, Prelude in {
 	  True  => quant.s ! True ! n ! g ++ num.s
 	  } ;
         n = n ;
-        a = a
+        a = a ;
+        mergesWithPrep = quant.mergesWithPrep ;
+        mergeForm = quant.mergeForm
         } ;
 
-    PossPron p = {
+    PossPron p = noMerge ** {
       s  = \\_,n,g => p.unstressed.poss ;
-      sp = \\n,g => p.substposs ;
+      sp = \\n,g => DefArt.s ! True ! n ! g ++ p.substposs ! n ;
       a = Weak
       } ;
 
@@ -94,13 +102,13 @@ concrete NounDut of Noun = CatDut ** open ResDut, Prelude in {
 
     OrdNumeralSuperl n a = {s = \\af => n.s ! NOrd af ++ a.s ! Superl ! af} ;
 
-    DefArt = {
+    DefArt = noMerge ** {
       s = \\_,n,g  => case <n,g> of {<Sg,Neutr> => "het" ; _ => "de"} ;
       sp = \\n,g => "die" ;
       a = Weak
       } ;
 
-    IndefArt = {
+    IndefArt = noMerge ** {
       s = table {
         True => \\_,_ => [] ; 
         False => table {
@@ -115,7 +123,7 @@ concrete NounDut of Noun = CatDut ** open ResDut, Prelude in {
       a = Strong
       } ;
 
-    MassNP cn = {
+    MassNP cn = noMerge ** {
       s = \\c => cn.s ! Strong ! NF Sg Nom ;
       a = agrP3 Sg ;
       isPron = False
@@ -127,12 +135,12 @@ concrete NounDut of Noun = CatDut ** open ResDut, Prelude in {
       } ;
 
     ComplN2 f x = {
-      s = \\_,nc => f.s ! nc ++ appPrep f.c2 x.s ;
+      s = \\_,nc => f.s ! nc ++ appPrep f.c2 x ;
       g = f.g
       } ;
 
     ComplN3 f x = {
-      s = \\nc => f.s ! nc ++ appPrep f.c2 x.s ;
+      s = \\nc => f.s ! nc ++ appPrep f.c2 x ;
       g = f.g ; 
       c2 = f.c3
       } ;
@@ -165,7 +173,7 @@ concrete NounDut of Noun = CatDut ** open ResDut, Prelude in {
       g = cn.g
       } ;
 
-    RelNP np rs = {
+    RelNP np rs = np ** {
       s = \\c => np.s ! c ++ "," ++ rs.s ! np.a.g ! np.a.n ;
       a = np.a ;
       isPron = False
diff --git a/src/dutch/ParadigmsDut.gf b/src/dutch/ParadigmsDut.gf
index c0fcb43ca..c9b9d6f47 100644
--- a/src/dutch/ParadigmsDut.gf
+++ b/src/dutch/ParadigmsDut.gf
@@ -231,11 +231,11 @@ oper
 
   mkN2 = overload {
     mkN2 : N -> N2 
-    = \n -> lin N2 (n ** {c2 = "van"}) ; 
+    = \n -> lin N2 (n ** {c2 = mkPrep "van"}) ; 
     mkN2 : N -> Prep -> N2 
-    = \n,p -> lin N2 (n ** {c2 = p.s}) ; 
+    = \n,p -> lin N2 (n ** {c2 = p}) ; 
     } ;   
-  mkN3 n p q = lin N3 (n ** {c2 = p.s ; c3 = q.s}) ; 
+  mkN3 n p q = lin N3 (n ** {c2 = p ; c3 = q}) ;
 
   mkPN = overload {
     mkPN : Str -> PN = \s -> lin PN {s = \\_ => s} ;
@@ -255,7 +255,10 @@ oper
     mkA : (goed,goede,goeds,beter,best : Str) -> A = \a,b,c,d,e -> lin A (mkAdjective a b c d e) ;
     } ;
 
-  mkPrep s = lin Prep (ss s) ;
+  mkPrep s = lin Prep { s, mergeForm = s ; mergesWithPrep = True } ;
+
+  nomergePrep : Str -> Prep = \s -> lin Prep (noMerge ** ss s); 
+
   van_Prep = mkPrep "van" ;
   te_Prep = mkPrep "te" ;
 
@@ -305,9 +308,9 @@ oper
   hebben_V : V = lin V ResDut.hebben_V ;
 
   mkV2 = overload {
-    mkV2 : Str -> V2 = \s -> lin V2 (v2vv (regVerb s) ** {c2 = <[],False>}) ;
-    mkV2 : V -> V2 = \s -> lin V2 (s ** {c2 = <[],False>}) ;
-    mkV2 : V -> Prep -> V2  = \s,p -> lin V2 (s ** {c2 = <p.s,True>}) ;
+    mkV2 : Str -> V2 = \s -> lin V2 (v2vv (regVerb s) ** {c2 = <noPrep,False>}) ;
+    mkV2 : V -> V2 = \s -> lin V2 (s ** {c2 = <noPrep,False>}) ;
+    mkV2 : V -> Prep -> V2  = \s,p -> lin V2 (s ** {c2 = <p,True>}) ;
     } ;
 
 
@@ -323,7 +326,7 @@ oper
     mkV3 : V -> Prep -> V3 = \v,p -> mkmaxV3 v (mkPrep []) p ; 
     mkV3 : V -> V3 = \v -> mkmaxV3 v (mkPrep []) (mkPrep []) ; 
     } ;
-  mkmaxV3 : V -> Prep -> Prep -> V3 = \v,c,d -> lin V3 (v ** {c2 = <c.s,True> ; c3 = <d.s,True>}) ;
+  mkmaxV3 : V -> Prep -> Prep -> V3 = \v,c,d -> lin V3 (v ** {c2 = <c,True> ; c3 = <d,True>}) ;
 
 
 
@@ -427,7 +430,7 @@ oper
 
   invarA = \s -> lin A {s = \\_,_ => s} ; ---- comparison
 
-  mkA2 = \a,p -> lin A2 (a ** {c2 = p.s}) ;
+  mkA2 = \a,p -> lin A2 (a ** {c2 = p}) ;
 
   mkAdv s = {s = s ; lock_Adv = <>} ;
 --
@@ -489,10 +492,10 @@ oper
 --  werden_V = MorphoDut.werden_V ** {lock_V = <>} ;
 --
   prepV2 : V -> Prep -> V2 ;
-  prepV2 v c = lin V2 (v ** {c2 = <c.s,True>}) ; --if it has prep, needed for word order (place of negation)
+  prepV2 v c = lin V2 (v ** {c2 = <c,True>}) ; --if it has prep, needed for word order (place of negation)
 
   noprepV2 : V -> V2 ;
-  noprepV2 v = lin V2 (v ** {c2 = <[],False>}) ; 
+  noprepV2 v = lin V2 (v ** {c2 = <noPrep,False>}) ; 
 --  dirV2 v = prepV2 v (mkPrep [] accusative) ;
 --  datV2 v = prepV2 v (mkPrep [] dative) ;
 --
diff --git a/src/dutch/QuestionDut.gf b/src/dutch/QuestionDut.gf
index 6d28f92d4..802dde0c5 100644
--- a/src/dutch/QuestionDut.gf
+++ b/src/dutch/QuestionDut.gf
@@ -29,7 +29,7 @@ concrete QuestionDut of Question = CatDut ** open ResDut in {
       s = \\t,a,p => 
             let 
               cls = slash.s ! t ! a ! p ;
-              who = appPrep slash.c2 ip.s
+              who = appPrep slash.c2 (noMerge ** ip)
             in table {
               QDir   => who ++ cls ! Inv ;
               QIndir => who ++ cls ! Sub
@@ -60,7 +60,7 @@ concrete QuestionDut of Question = CatDut ** open ResDut in {
       } ;
 
     PrepIP p ip = {
-      s = appPrep p.s ip.s
+      s = appPrep p (noMerge ** ip)
       } ;
 
     AdvIP ip adv = {
diff --git a/src/dutch/RelativeDut.gf b/src/dutch/RelativeDut.gf
index 74ff961d4..17b79810a 100644
--- a/src/dutch/RelativeDut.gf
+++ b/src/dutch/RelativeDut.gf
@@ -23,12 +23,13 @@ concrete RelativeDut of Relative = CatDut ** open ResDut in {
 
     RelSlash rp slash = {
       s = \\t,a,p,g,n => 
-          appPrep slash.c2 (\\_ => rp.s ! g ! n) ++ slash.s ! t ! a ! p ! Sub ;
+          appPrep slash.c2 (npLite (\\_ => rp.s ! g ! n))
+          ++ slash.s ! t ! a ! p ! Sub ;
       c = slash.c2.c
       } ;
 
     FunRP p np rp = {
-      s = \\g,n => np.s ! NPNom ++ appPrep p.s (\\_ => rp.s ! g ! n) ;
+      s = \\g,n => np.s ! NPNom ++ appPrep p (npLite (\\_ => rp.s ! g ! n)) ;
       a = RAg np.a.n np.a.p
       } ;
 
diff --git a/src/dutch/ResDut.gf b/src/dutch/ResDut.gf
index 719c964b6..1aff9fbb9 100644
--- a/src/dutch/ResDut.gf
+++ b/src/dutch/ResDut.gf
@@ -19,7 +19,7 @@ resource ResDut = ParamX ** open Prelude, Predef in {
 
     NPCase = NPNom | NPAcc ;
 
-  oper 
+  oper     
     Noun = {s : NForm => Str ; g : Gender} ;
 
     mkNoun : (_,_ : Str) -> Gender -> Noun = \sg,pl,g -> {
@@ -380,23 +380,25 @@ param
   worden_V = irregVerb2 "worden" "werd" "werden" "geworden" ** {
     aux = VZijn ; prefix = [] ; particle = [] ; vtype = VAct} ; 
 
-    Pronoun : Type = {
+    Pronoun : Type = MergesWithPrep ** {
       unstressed,stressed : {nom, acc, poss : Str} ;
-      substposs : Str ;
-      a : Agr
+      substposs : Number => Str ;
+      a : Agr ;
       } ; 
 
     mkPronoun : (x1,_,_,_,_,x6,x7 : Str) -> Gender -> Number -> Person -> Pronoun = 
-      \ik,me,mn,Ik,mij,mijn,mijne,g,n,p -> {
+      \ik,me,mn,Ik,mij,mijn,mijne,g,n,p -> noMerge ** {
          unstressed = {nom = ik ; acc = me  ; poss = mn} ;
          stressed   = {nom = Ik ; acc = mij ; poss = mijn} ;
-         substposs  = mijne ;
+         substposs  = table {Sg => mijne ; Pl => mijne + "n" } ; --overgenerates *jullien /IL2018
          a = {g = g ; n = n ; p = p}
          } ;
 
     het_Pron : Pronoun = mkPronoun "het" "het" "ze" "hij" "hem" "zijn" "zijne" Neutr Sg P3 ; -- cunger: 't -> het 
 
 
+    MergesWithPrep = { mergesWithPrep : Bool ; mergeForm : Str } ;
+    noMerge : MergesWithPrep = { mergesWithPrep = False ; mergeForm = [] } ;
 -- Complex $CN$s, like adjectives, have strong and weak forms.
 
 param
@@ -423,8 +425,22 @@ param
 ---- clause, inverted, or subordinate.
 
   oper 
-    Preposition = Str ; 
-    appPrep : Preposition -> (NPCase => Str) -> Str = \p,np -> p ++ np ! NPAcc ; ----
+    Preposition : Type = MergesWithPrep ** { s : Str } ;
+
+    -- This is a hack for appPrep: sometimes we don't really need a full NP
+    NPLite : Type = MergesWithPrep ** { s : NPCase => Str } ;
+    npLite : (NPCase => Str) -> NPLite = \nplite -> noMerge ** {s = nplite} ;
+
+    -- Applying a preposition to a noun phrase
+    -- In order to decide whether to merge, have to check both NP and Prep:
+    -- e.g. deze + met -> hiermee , but zonder + met -> "met zonder"
+    appPrep : Preposition -> NPLite -> Str 
+     = \prep,np -> 
+          case <np.mergesWithPrep,prep.mergesWithPrep> of {
+            <True,True> => glue np.mergeForm prep.mergeForm ;
+            _           => prep.s ++ np.s ! NPAcc } ;
+
+
 
   param  
     Order = Main | Inv | Sub ;
@@ -685,20 +701,22 @@ param
  
   infPart : Bool -> Str = \b -> if_then_Str b [] "te" ;
 
-  mkDet : Str -> Str -> Number -> {s,sp : Gender => Str ; n : Number ; a : Adjf} =
-    \deze,dit,n -> {
+  Determiner : Type = MergesWithPrep ** {s,sp : Gender => Str ; n : Number ; a : Adjf} ;
+
+  mkDet : Str -> Str -> Number -> Determiner =
+    \deze,dit,n -> noMerge ** {
       s  = \\g => case <n,g> of {<Sg,Neutr> => dit ; _ => deze} ;
       sp = \\g => case <n,g> of {<Sg,Neutr> => dit ; _ => deze} ;
       n = n ;
       a = Weak
       } ;
-
-  mkQuant : Str -> Str -> {
-    s  : Bool => Number => Gender => Str ; 
-    sp : Number => Gender => Str ; 
-    a  : Adjf
-    } = 
-    \deze,dit -> {
+  Quantifier : Type = MergesWithPrep ** {
+      s  : Bool => Number => Gender => Str ; 
+      sp : Number => Gender => Str ; 
+      a  : Adjf
+      } ;
+  mkQuant : Str -> Str -> Quantifier = 
+    \deze,dit -> noMerge ** {
       s  = \\_ ,n,g => case <n,g> of {<Sg,Neutr> => dit ; _ => deze} ;
       sp = \\   n,g => case <n,g> of {<Sg,Neutr> => dit ; _ => deze} ;
       a = Weak
@@ -709,8 +727,9 @@ param
       s  = \\n,g => case <n,g> of {<Sg,Neutr> => dit ; _ => deze}
       } ;
 
-  mkNP : Str -> Gender -> Number -> {s : NPCase => Str ; a : Agr ; isPron : Bool} = 
-    \s,g,n -> heavyNP {
+  NounPhrase : Type = MergesWithPrep ** {s : NPCase => Str ; a : Agr ; isPron : Bool } ; 
+  mkNP : Str -> Gender -> Number -> NounPhrase = 
+    \s,g,n -> noMerge ** heavyNP {
       s = \\_ => s ;
       a = agrgP3 g n ;
       } ;
diff --git a/src/dutch/SentenceDut.gf b/src/dutch/SentenceDut.gf
index 30903244f..258f3102b 100644
--- a/src/dutch/SentenceDut.gf
+++ b/src/dutch/SentenceDut.gf
@@ -42,7 +42,7 @@ concrete SentenceDut of Sentence = CatDut ** open ResDut, Prelude in {
       c2 = slash.c2
     } ;
 
-    SlashPrep cl prep = cl ** {c2 = prep.s} ;
+    SlashPrep cl prep = cl ** {c2 = prep} ;
 
     SlashVS np vs slash = 
         mkClause (np.s ! NPNom) np.a 
diff --git a/src/dutch/StructuralDut.gf b/src/dutch/StructuralDut.gf
index 409d9b408..713b18472 100644
--- a/src/dutch/StructuralDut.gf
+++ b/src/dutch/StructuralDut.gf
@@ -22,9 +22,9 @@ concrete StructuralDut of Structural = CatDut, Prelude **
   both7and_DConj = {s1 = "zowel" ; s2 = "als" ; n = Pl} ;
   but_PConj = ss "maar" ;
   by8agent_Prep = mkPrep "door" ;
-  by8means_Prep = mkPrep "met" ;
+  by8means_Prep = mkPrep "met" ** {mergeForm = "mee"} ;
   can8know_VV, can_VV = auxVV kunnen_V ;
-  during_Prep = mkPrep "tijdens" ;
+  during_Prep = nomergePrep "tijdens" ; -- doesn't combine
   either7or_DConj = {s1 = "ofwel" ; s2 = "of" ; n = Pl} ;
   everybody_NP = mkNP "alle" Utr Pl ; ----
   every_Det = mkDet "elke" "elk" Sg ; ----
@@ -43,7 +43,7 @@ concrete StructuralDut of Structural = CatDut, Prelude **
   if_Subj = ss "als" ;
   in8front_Prep = mkPrep "voor" ;
   i_Pron = mkPronoun "ik" "me" "mijn" "ik" "mij" "mijn" "mijne" Utr Sg P1 ;
-  in_Prep = ss "in" ;
+  in_Prep = mkPrep "in" ;
   it_Pron = mkPronoun "het" "het" "zijn" "het" "het" "zijn" "zijne" Neutr Sg P3 ;
 
   less_CAdv = X.mkCAdv "minder" "dan" ;
@@ -71,7 +71,7 @@ concrete StructuralDut of Structural = CatDut, Prelude **
   someSg_Det = mkDet "enige" "enig" Sg ;
   something_NP = mkNP "iets" Utr Sg ;
   somewhere_Adv = ss "ergens" ;
-  that_Quant = mkQuant "die" "dat" ;
+  that_Quant = mkQuant "die" "dat" ** { mergesWithPrep = True ; mergeForm = "daar" } ;
   that_Subj = ss "dat" ;
   there_Adv = ss "daar" ;
   there7to_Adv = ss "daar" ;
@@ -80,7 +80,7 @@ concrete StructuralDut of Structural = CatDut, Prelude **
 
   they_Pron = mkPronoun "ze" "ze" "hun" "zij" "hen" "hun" "hunne" Utr Pl P3 ; ----
 
-  this_Quant = mkQuant "deze" "dit" ;
+  this_Quant = mkQuant "deze" "dit" ** { mergesWithPrep = True ; mergeForm = "hier" } ;
   through_Prep = mkPrep "door" ;
   too_AdA = ss "te" ;
   to_Prep = mkPrep "naar" ;
@@ -101,8 +101,8 @@ concrete StructuralDut of Structural = CatDut, Prelude **
   whoSg_IP = {s = \\_ => "wie" ; n = Sg} ;
   whoPl_IP = {s = \\_ => "wie" ; n = Pl} ;
   why_IAdv = ss "waarom" ;
-  without_Prep = mkPrep "zonder" ;
-  with_Prep = mkPrep "met" ;
+  without_Prep = nomergePrep "zonder" ; -- doesn't combine
+  with_Prep = mkPrep "met" ** { mergeForm = "mee" } ;
   youSg_Pron = mkPronoun "je" "je" "je" "jij" "jou" "je" "jouwe" Neutr Sg P2 ;  --- Neutr as hack for familiarity
   youPl_Pron = mkPronoun "jullie" "jullie" "je" "jullie" "jullie" "jullie" "uwe" Utr Pl P2 ;
   youPol_Pron = mkPronoun "u" "u" "uw" "u" "u" "uw" "uwe" Utr Sg P2 ;
@@ -115,7 +115,7 @@ concrete StructuralDut of Structural = CatDut, Prelude **
   nothing_NP = mkNP "niets" Neutr Sg ;
   at_least_AdN = ss "ten minste" ;
   at_most_AdN = ss "hooguit" ;
-  except_Prep = mkPrep "met uitzondering van" ;
+  except_Prep = nomergePrep "met uitzondering van" ; -- doesn't combine like "met dat" -> "daarmee"
 
   as_CAdv = X.mkCAdv "zo" "als" ;
   have_V2 = mkV2 ParadigmsDut.hebben_V ;
diff --git a/src/dutch/SymbolDut.gf b/src/dutch/SymbolDut.gf
index 9c9519fac..339dc0786 100644
--- a/src/dutch/SymbolDut.gf
+++ b/src/dutch/SymbolDut.gf
@@ -10,17 +10,17 @@ lin
   FloatPN i  = {s = \\c => i.s ; g = Neutr} ; --- c
   NumPN i  = {s = \\_ => i.s ! Neutr ! Nom ; g = Neutr} ; --- c
 
-  CNIntNP cn i = {
+  CNIntNP cn i = noMerge ** {
     s = \\c => cn.s ! Weak ! NF Sg Nom ++ i.s ;
     a = agrP3 Sg ;
     isPron = False
     } ;
-  CNSymbNP det cn xs = let g = cn.g in {
+  CNSymbNP det cn xs = let g = cn.g in noMerge ** {
     s = \\c => det.s ! g ++ cn.s ! det.a ! NF det.n Nom ++ xs.s ; 
     a = agrP3 det.n ;
     isPron = False
     } ;
-  CNNumNP cn i = {
+  CNNumNP cn i = noMerge ** {
     s = \\c => artDef Sg cn.g ++ cn.s ! Weak ! NF Sg Nom ++ i.s ! Neutr ! Nom ;
     a = agrP3 Sg ;
     isPron = False
diff --git a/src/dutch/VerbDut.gf b/src/dutch/VerbDut.gf
index b8eb08f83..1805479c1 100644
--- a/src/dutch/VerbDut.gf
+++ b/src/dutch/VerbDut.gf
@@ -28,9 +28,9 @@ concrete VerbDut of Verb = CatDut ** open Prelude, ResDut in {
     SlashV2a v = predV (v2v v) ** {c2 = v.c2} ; 
       
     Slash2V3 v np =
-      insertObj (\\_ => appPrep v.c2.p1 np.s) (predVv v) ** {c2 = v.c3} ;
+      insertObj (\\_ => appPrep v.c2.p1 np) (predVv v) ** {c2 = v.c3} ;
     Slash3V3 v np =
-      insertObj (\\_ => appPrep v.c3.p1 np.s) (predVv v) ** {c2 = v.c2} ;
+      insertObj (\\_ => appPrep v.c3.p1 np) (predVv v) ** {c2 = v.c2} ;
 
     SlashV2S v s = 
       insertExtrapos (conjThat ++ s.s ! Sub) (predVv v) ** {c2 = v.c2} ;
@@ -48,7 +48,7 @@ concrete VerbDut of Verb = CatDut ** open Prelude, ResDut in {
       insertObj (\\_ => ap.s ! APred) (predVGen False BetweenObjs (v2v v)) ** {c2 = v.c2} ;
 
     --vp.c2.p2: if the verb has a preposition or not
-    ComplSlash vp np = insertObjNP np.isPron (case vp.c2.p2 of {True => BeforeObjs; False => vp.negPos}) (\\_ => appPrep vp.c2.p1 np.s) vp ;
+    ComplSlash vp np = insertObjNP np.isPron (case vp.c2.p2 of {True => BeforeObjs; False => vp.negPos}) (\\_ => appPrep vp.c2.p1 np) vp ;
 
     SlashVV v vp = 
       let 
@@ -66,7 +66,7 @@ concrete VerbDut of Verb = CatDut ** open Prelude, ResDut in {
       insertExtrapos vpi.p3 (
         insertInf vpi.p2 (
           insertObj vpi.p1 (
-            insertObj (\\_ => appPrep v.c2.p1 np.s) (
+            insertObj (\\_ => appPrep v.c2.p1 np) (
               predVGen v.isAux vp.negPos v)))) ** {c2 = v.c2} ;
 
     -- BeforeObjs, because negation comes before copula complement 
@@ -87,11 +87,13 @@ concrete VerbDut of Verb = CatDut ** open Prelude, ResDut in {
 
     AdVVP adv vp = insertAdV adv.s vp ;
 
-    ReflVP vp = insertObj (\\a => appPrep vp.c2.p1 (\\_ => reflPron ! a)) vp ;
+    ReflVP vp = insertObj (\\a => appPrep vp.c2.p1 
+                                          (npLite (\\_ => reflPron ! a))
+                          ) vp ;
 
     PassV2 v = insertInf (v.s ! VPerf) (predV worden_V) ;
 
-    VPSlashPrep vp prep = vp ** {c2 = <prep.s,True>} ;
+    VPSlashPrep vp prep = vp ** {c2 = <prep,True>} ;
 
 ---- workaround for a subtyping bug
   oper