Perhaps -> Maybe refactoring and better error message for conflicts during module update

11 files changed, 277 insertions, 441 deletions

diff --git a/src/GF/Compile/BackOpt.hs b/src/GF/Compile/BackOpt.hs
index 484b1f1f0..529a74334 100644
--- a/src/GF/Compile/BackOpt.hs
+++ b/src/GF/Compile/BackOpt.hs
@@ -36,9 +36,9 @@ shareModule :: OptSpec -> SourceModule -> SourceModule
 shareModule opt (i,mo) = (i,M.replaceJudgements mo (mapTree (shareInfo opt) (M.jments mo)))
 
 shareInfo :: OptSpec -> (Ident, Info) -> Info
-shareInfo opt (c, CncCat ty (Yes t) m) = CncCat ty (Yes (shareOptim opt c t)) m
-shareInfo opt (c, CncFun kxs (Yes t) m) = CncFun kxs (Yes (shareOptim opt c t)) m
-shareInfo opt (c, ResOper ty (Yes t)) = ResOper ty (Yes (shareOptim opt c t))
+shareInfo opt (c, CncCat ty (Just t) m) = CncCat ty (Just (shareOptim opt c t)) m
+shareInfo opt (c, CncFun kxs (Just t) m) = CncFun kxs (Just (shareOptim opt c t)) m
+shareInfo opt (c, ResOper ty (Just t)) = ResOper ty (Just (shareOptim opt c t))
 shareInfo _ (_,i) = i
 
 -- the function putting together optimizations
diff --git a/src/GF/Compile/CheckGrammar.hs b/src/GF/Compile/CheckGrammar.hs
index 43b186a7c..552bd4177 100644
--- a/src/GF/Compile/CheckGrammar.hs
+++ b/src/GF/Compile/CheckGrammar.hs
@@ -121,19 +121,19 @@ checkAbsInfo ::
 checkAbsInfo st m mo (c,info) = do
 ---- checkReservedId c
  case info of
-   AbsCat (Yes cont) _ -> mkCheck "category" $ 
+   AbsCat (Just cont) _ -> mkCheck "category" $ 
      checkContext st cont ---- also cstrs
-   AbsFun (Yes typ0) md -> do
+   AbsFun (Just typ0) md -> do
     typ <- compAbsTyp [] typ0   -- to calculate let definitions
     mkCheck "type of function" $ checkTyp st typ 
     md' <- case md of
-       Yes d -> do
+       Just d -> do
          let d' = elimTables d
 ----         mkCheckWarn "definition of function" $ checkEquation st (m,c) d'
          mkCheck "definition of function" $ checkEquation st (m,c) d'
-         return $ Yes d'
+         return $ Just d'
        _ -> return md
-    return $ (c,AbsFun (Yes typ) md')
+    return $ (c,AbsFun (Just typ) md')
    _ -> return (c,info)
  where
    mkCheck cat ss = case ss of
@@ -195,27 +195,27 @@ checkCompleteGrammar abs cnc = do
      CncCat _ _ _ -> True
      _ -> False
    checkOne js i@(c,info) = case info of
-     AbsFun (Yes _) _ -> case lookupIdent c js of
+     AbsFun (Just _) _ -> case lookupIdent c js of
        Ok _ -> return js
        _ -> do
          checkWarn $ "WARNING: no linearization of" +++ prt c
          return js
-     AbsCat (Yes _) _ -> case lookupIdent c js of
+     AbsCat (Just _) _ -> case lookupIdent c js of
        Ok (AnyInd _ _) -> return js
-       Ok (CncCat (Yes _) _ _) -> return js
+       Ok (CncCat (Just _) _ _) -> return js
        Ok (CncCat _ mt mp) -> do
          checkWarn $ 
            "Warning: no linearization type for" +++ prt c ++ 
            ", inserting default {s : Str}" 
-         return $ updateTree (c,CncCat (Yes defLinType) mt mp) js
+         return $ updateTree (c,CncCat (Just defLinType) mt mp) js
        _ -> do
          checkWarn $ 
            "Warning: no linearization type for" +++ prt c ++ 
            ", inserting default {s : Str}" 
-         return $ updateTree (c,CncCat (Yes defLinType) nope nope) js
+         return $ updateTree (c,CncCat (Just defLinType) Nothing Nothing) js
      _ -> return js
 
--- | General Principle: only Yes-values are checked. 
+-- | General Principle: only Just-values are checked. 
 -- A May-value has always been checked in its origin module.
 checkResInfo :: SourceGrammar -> Ident -> SourceModInfo -> (Ident,Info) -> Check (Ident,Info)
 checkResInfo gr mo mm (c,info) = do
@@ -223,17 +223,15 @@ checkResInfo gr mo mm (c,info) = do
   case info of
     ResOper pty pde -> chIn "operation" $ do
       (pty', pde') <- case (pty,pde) of
-         (Yes ty, Yes de) -> do
+         (Just ty, Just de) -> do
            ty'     <- check ty typeType >>= comp . fst
            (de',_) <- check de ty'
-           return (Yes ty', Yes de')
-         (_, Yes de) -> do
+           return (Just ty', Just de')
+         (_      , Just de) -> do
            (de',ty') <- infer de
-           return (Yes ty', Yes de')
-         (_,Nope) -> do
+           return (Just ty', Just de')
+         (_      , Nothing) -> do
            raise "No definition given to oper"
-           --return (pty,pde)
-         _ -> return (pty, pde) --- other cases are uninteresting
       return (c, ResOper pty' pde')
 
     ResOverload os tysts -> chIn "overloading" $ do
@@ -248,11 +246,11 @@ checkResInfo gr mo mm (c,info) = do
         sort [t : map snd xs | (x,_) <- tysts2, Ok (xs,t) <- [typeFormCnc x]]
       return (c,ResOverload os [(y,x) | (x,y) <- tysts'])
 
-    ResParam (Yes (pcs,_)) -> chIn "parameter type" $ do
+    ResParam (Just (pcs,_)) -> chIn "parameter type" $ do
 ----      mapM ((mapM (computeLType gr . snd)) . snd) pcs
       mapM_ ((mapM_ (checkIfParType gr . snd)) . snd) pcs
       ts <- checkErr $ lookupParamValues gr mo c
-      return (c,ResParam (Yes (pcs, Just ts)))
+      return (c,ResParam (Just (pcs, Just ts)))
 
     _ ->  return (c,info)
  where
@@ -277,26 +275,26 @@ checkCncInfo gr m mo (a,abs) (c,info) = do
   checkReservedId c
   case info of
 
-    CncFun _ (Yes trm) mpr -> chIn "linearization of" $ do
+    CncFun _ (Just trm) mpr -> chIn "linearization of" $ do
       typ        <- checkErr $ lookupFunType gr a c
       cat0       <- checkErr $ valCat typ
       (cont,val) <- linTypeOfType gr m typ         -- creates arg vars
       (trm',_)   <- check trm (mkFunType (map snd cont) val)  -- erases arg vars
       checkPrintname gr mpr
       cat        <- return $ snd cat0
-      return (c, CncFun (Just (cat,(cont,val))) (Yes trm') mpr)
+      return (c, CncFun (Just (cat,(cont,val))) (Just trm') mpr)
                                                    -- cat for cf, typ for pe
 
-    CncCat (Yes typ) mdef mpr -> chIn "linearization type of" $ do
+    CncCat (Just typ) mdef mpr -> chIn "linearization type of" $ do
       checkErr $ lookupCatContext gr a c
       typ'  <- checkIfLinType gr typ
       mdef' <- case mdef of
-        Yes def -> do
+        Just def -> do
           (def',_) <- checkLType gr def (mkFunType [typeStr] typ)
-          return $ Yes def'
+          return $ Just def'
         _ -> return mdef
       checkPrintname gr mpr
-      return (c,CncCat (Yes typ') mdef' mpr)
+      return (c,CncCat (Just typ') mdef' mpr)
 
     _ -> checkResInfo gr m mo (c,info)
 
@@ -400,9 +398,9 @@ computeLType gr t = do
 
     _ -> composOp comp ty
 
-checkPrintname :: SourceGrammar -> Perh Term -> Check ()
-checkPrintname st (Yes t) = checkLType st t typeStr >> return ()
-checkPrintname _ _ = return ()
+checkPrintname :: SourceGrammar -> Maybe Term -> Check ()
+checkPrintname st (Just t) = checkLType st t typeStr >> return ()
+checkPrintname _  _        = return ()
 
 -- | for grammars obtained otherwise than by parsing ---- update!!
 checkReservedId :: Ident -> Check ()
@@ -1105,15 +1103,15 @@ allDependencies ism b =
       Q n c | ism n -> [c]
       QC n c | ism n -> [c]
       _ -> collectOp opersIn t
-    opty (Yes ty) = opersIn ty
+    opty (Just ty) = opersIn ty
     opty _ = []
     pts i = case i of
       ResOper pty pt -> [pty,pt]
-      ResParam (Yes (ps,_)) -> [Yes t | (_,cont) <- ps, (_,t) <- cont]
+      ResParam (Just (ps,_)) -> [Just t | (_,cont) <- ps, (_,t) <- cont]
       CncCat pty _ _ -> [pty]
       CncFun _   pt _ -> [pt]  ---- (Maybe (Ident,(Context,Type))
       AbsFun pty ptr -> [pty] --- ptr is def, which can be mutual
-      AbsCat (Yes co) _ -> [Yes ty | (_,ty) <- co]
+      AbsCat (Just co) _ -> [Just ty | (_,ty) <- co]
       _              -> []
 
 topoSortOpers :: [(Ident,[Ident])] -> Err [Ident]
diff --git a/src/GF/Compile/Coding.hs b/src/GF/Compile/Coding.hs
index 088f7b8e8..511ceddef 100644
--- a/src/GF/Compile/Coding.hs
+++ b/src/GF/Compile/Coding.hs
@@ -24,10 +24,10 @@ codeSourceModule :: (String -> String) -> SourceModule -> SourceModule
 codeSourceModule co (id,mo) = (id,replaceJudgements mo (mapTree codj (jments mo)))
  where
     codj (c,info) = case info of
-      ResOper     pty pt  -> ResOper (mapP codt pty) (mapP codt pt) 
+      ResOper     pty pt  -> ResOper (fmap codt pty) (fmap codt pt) 
       ResOverload es tyts -> ResOverload es [(codt ty,codt t) | (ty,t) <- tyts]
-      CncCat pty pt mpr   -> CncCat pty (mapP codt pt) (mapP codt mpr)
-      CncFun mty pt mpr   -> CncFun mty (mapP codt pt) (mapP codt mpr)
+      CncCat pty pt mpr   -> CncCat pty (fmap codt pt) (fmap codt mpr)
+      CncFun mty pt mpr   -> CncFun mty (fmap codt pt) (fmap codt mpr)
       _ -> info
     codt t = case t of
       K s -> K (co s)
diff --git a/src/GF/Compile/Extend.hs b/src/GF/Compile/Extend.hs
deleted file mode 100644
index bb9310041..000000000
--- a/src/GF/Compile/Extend.hs
+++ /dev/null
@@ -1,140 +0,0 @@
-----------------------------------------------------------------------
--- |
--- Module      : Extend
--- Maintainer  : AR
--- Stability   : (stable)
--- Portability : (portable)
---
--- > CVS $Date: 2005/05/30 21:08:14 $ 
--- > CVS $Author: aarne $
--- > CVS $Revision: 1.18 $
---
--- AR 14\/5\/2003 -- 11\/11
---
--- The top-level function 'extendModule'
--- extends a module symbol table by indirections to the module it extends
------------------------------------------------------------------------------
-
-module GF.Compile.Extend (extendModule, extendMod
-	      ) where
-
-import GF.Grammar.Grammar
-import GF.Infra.Ident
-import GF.Grammar.PrGrammar
-import GF.Infra.Modules
-import GF.Compile.Update
-import GF.Grammar.Macros
-import GF.Data.Operations
-
-import Control.Monad
-import Data.List(nub)
-
-extendModule :: [SourceModule] -> SourceModule -> Err SourceModule
-extendModule ms (name,m)
-  ---- Just to allow inheritance in incomplete concrete (which are not
-  ---- compiled anyway), extensions are not built for them.
-  ---- Should be replaced by real control. AR 4/2/2005
-  | mstatus m == MSIncomplete && isModCnc m = return (name,m)
-  | otherwise                               = do m' <- foldM extOne m (extend m) 
-                                                 return (name,m')
- where
-   extOne mo (n,cond) = do
-     m0 <- lookupModule (MGrammar ms) n
-
-     -- test that the module types match, and find out if the old is complete
-     testErr (sameMType (mtype m) (mtype mo)) 
-             ("illegal extension type to module" +++ prt name)
-
-     let isCompl = isCompleteModule m0
-
-     -- build extension in a way depending on whether the old module is complete
-     js1 <- extendMod isCompl (n, isInherited cond) name (jments m0) (jments mo)
-
-     -- if incomplete, throw away extension information
-     return $ 
-          if isCompl
-            then mo {jments = js1}
-            else mo {extend = filter ((/=n) . fst) (extend mo)
-                    ,mexdeps= nub (n : mexdeps mo)
-                    ,jments = js1
-                    }
-
--- | When extending a complete module: new information is inserted,
--- and the process is interrupted if unification fails.
--- If the extended module is incomplete, its judgements are just copied.
-extendMod :: Bool -> (Ident,Ident -> Bool) -> Ident -> 
-             BinTree Ident Info -> BinTree Ident Info -> 
-             Err (BinTree Ident Info)
-extendMod isCompl (name,cond) base old new = foldM try new $ tree2list old where
-  try t i@(c,_) | not (cond c) = return t
-  try t i@(c,_) = errIn ("constant" +++ prt c) $
-                  tryInsert (extendAnyInfo isCompl name base) indirIf t i
-  indirIf = if isCompl then indirInfo name else id
-
-indirInfo :: Ident -> Info -> Info
-indirInfo n info = AnyInd b n' where 
-  (b,n') = case info of
-    ResValue _ -> (True,n)
-    ResParam _ -> (True,n)
-    AbsFun _ (Yes EData) -> (True,n) 
-    AnyInd b k -> (b,k)
-    _ -> (False,n) ---- canonical in Abs
-
-perhIndir :: Ident -> Perh a -> Perh a
-perhIndir n p = case p of
-  Yes _ -> May n
-  _ -> p
-
-extendAnyInfo :: Bool -> Ident -> Ident -> Info -> Info -> Err Info
-extendAnyInfo isc n o i j = 
- errIn ("building extension for" +++ prt n +++ "in" +++ prt o) $ case (i,j) of
-  (AbsCat mc1 mf1, AbsCat mc2 mf2) -> 
-    liftM2 AbsCat (updn isc n mc1 mc2) (updn isc n mf1 mf2) --- add cstrs
-  (AbsFun mt1 md1, AbsFun mt2 md2) -> 
-    liftM2 AbsFun (updn isc n mt1 mt2) (updn isc n md1 md2) --- add defs
-  (ResParam mt1, ResParam mt2) -> 
-    liftM ResParam $ updn isc n mt1 mt2
-  (ResValue mt1, ResValue mt2) -> 
-    liftM ResValue $ updn isc n mt1 mt2
-  (_, ResOverload ms t) | elem n ms ->
-    return $ ResOverload ms t
-  (ResOper mt1 m1, ResOper mt2 m2) ->           ---- extendResOper n mt1 m1 mt2 m2 
-    liftM2 ResOper (updn isc n mt1 mt2) (updn isc n m1 m2)
-  (CncCat mc1 mf1 mp1, CncCat mc2 mf2 mp2) -> 
-    liftM3 CncCat (updn isc n mc1 mc2) (updn isc n mf1 mf2) (updn isc n mp1 mp2)
-  (CncFun m mt1 md1, CncFun _ mt2 md2) -> 
-    liftM2 (CncFun m) (updn isc n mt1 mt2) (updn isc n md1 md2)
-
-----  (AnyInd _ _, ResOper _ _) -> return j ----
-
-  (AnyInd b1 m1, AnyInd b2 m2) -> do
-    testErr (b1 == b2) "inconsistent indirection status"
----- commented out as work-around for a spurious problem in
----- TestResourceFre; should look at building of completion. 17/11/2004 
-    testErr (m1 == m2) $ 
-      "different sources of indirection: " +++ show m1 +++ show m2
-    return i
-
-  _ -> Bad $ "cannot unify information in" ++++ show i ++++ "and" ++++ show j
-
---- where
-   
-updn isc n = if isc  then (updatePerhaps n) else (updatePerhapsHard n)
-updc isc n = if True then (updatePerhaps n) else (updatePerhapsHard n)
-
-
-
-{- ---- no more needed: this is done in Rebuild
--- opers declared in an interface and defined in an instance are a special case
-
-extendResOper n mt1 m1 mt2 m2 = case (m1,m2) of
-  (Nope,_) -> return $ ResOper (strip mt1) m2
-  _ -> liftM2 ResOper (updatePerhaps n mt1 mt2) (updatePerhaps n m1 m2)
- where
-   strip (Yes t) = Yes $ strp t
-   strip m = m
-   strp t = case t of
-     Q _ c  -> Vr c
-     QC _ c -> Vr c
-     _ -> composSafeOp strp t
--}
diff --git a/src/GF/Compile/GrammarToGFCC.hs b/src/GF/Compile/GrammarToGFCC.hs
index e57191de2..272692be7 100644
--- a/src/GF/Compile/GrammarToGFCC.hs
+++ b/src/GF/Compile/GrammarToGFCC.hs
@@ -69,15 +69,15 @@ canon2gfcc opts pars cgr@(M.MGrammar ((a,abm):cms)) =
   gflags = Map.empty
   aflags = Map.fromList [(mkCId f,x) | (f,x) <- optionsPGF (M.flags abm)]
   mkDef pty = case pty of
-    Yes t -> mkExp t
-    _ -> CM.primNotion
+    Just t -> mkExp t
+    _      -> CM.primNotion
 
   -- concretes
   lfuns = [(f', (mkType ty, mkDef pty)) | 
-             (f,AbsFun (Yes ty) pty) <- tree2list (M.jments abm), let f' = i2i f]
+             (f,AbsFun (Just ty) pty) <- tree2list (M.jments abm), let f' = i2i f]
   funs = Map.fromAscList lfuns
   lcats = [(i2i c, mkContext cont) |
-                (c,AbsCat (Yes cont) _) <- tree2list (M.jments abm)]
+                (c,AbsCat (Just cont) _) <- tree2list (M.jments abm)]
   cats = Map.fromAscList lcats
   catfuns = Map.fromList 
     [(cat,[f | (f, (C.DTyp _ c _,_)) <- lfuns, c==cat]) | (cat,_) <- lcats]
@@ -95,18 +95,18 @@ canon2gfcc opts pars cgr@(M.MGrammar ((a,abm):cms)) =
                 ---- then (trace "decode" D.convertStringsInTerm decodeUTF8) else id
       umkTerm = utf . mkTerm
       lins    = Map.fromAscList 
-        [(f', umkTerm tr)  | (f,CncFun _ (Yes tr) _) <- js, 
+        [(f', umkTerm tr)  | (f,CncFun _ (Just tr) _) <- js, 
             let f' = i2i f, exists f'] -- eliminating lins without fun 
             -- needed even here because of restricted inheritance
       lincats = Map.fromAscList 
-        [(i2i c, mkCType ty) | (c,CncCat (Yes ty) _ _) <- js]
+        [(i2i c, mkCType ty) | (c,CncCat (Just ty) _ _) <- js]
       lindefs = Map.fromAscList 
-        [(i2i c, umkTerm tr)  | (c,CncCat _ (Yes tr) _) <- js]
+        [(i2i c, umkTerm tr)  | (c,CncCat _ (Just tr) _) <- js]
       printnames = Map.union 
-        (Map.fromAscList [(i2i f, umkTerm tr) | (f,CncFun _ _ (Yes tr)) <- js])
-        (Map.fromAscList [(i2i f, umkTerm tr) | (f,CncCat _ _ (Yes tr)) <- js])
+        (Map.fromAscList [(i2i f, umkTerm tr) | (f,CncFun _ _ (Just tr)) <- js])
+        (Map.fromAscList [(i2i f, umkTerm tr) | (f,CncCat _ _ (Just tr)) <- js])
       params = Map.fromAscList 
-        [(i2i c, pars lang0 c) | (c,CncCat (Yes ty) _ _) <- js]
+        [(i2i c, pars lang0 c) | (c,CncCat (Just ty) _ _) <- js]
       fcfg = Nothing
 
       exists f = Map.member f funs
@@ -232,7 +232,7 @@ reorder abs cg = M.MGrammar $
        adefs = sorted2tree $ sortIds $
                  predefADefs ++ Look.allOrigInfos cg abs
        predefADefs = 
-         [(c, AbsCat (Yes []) Nope) | c <- [cFloat,cInt,cString]]
+         [(c, AbsCat (Just []) Nothing) | c <- [cFloat,cInt,cString]]
        aflags = 
          concatOptions [M.flags mo | (_,mo) <- M.modules cg, M.isModAbs mo]
 
@@ -246,7 +246,7 @@ reorder abs cg = M.MGrammar $
                      Just r <- [lookup i (M.allExtendSpecs cg la)]]
 
          predefCDefs = 
-           [(c, CncCat (Yes GM.defLinType) Nope Nope) | c <- [cInt,cFloat,cString]]
+           [(c, CncCat (Just GM.defLinType) Nothing Nothing) | c <- [cInt,cFloat,cString]]
 
        sortIds = sortBy (\ (f,_) (g,_) -> compare f g) 
 
@@ -279,8 +279,8 @@ canon2canon opts abs cg0 =
   j2j cg (f,j) = 
     let debug = if verbAtLeast opts Verbose then trace ("+ " ++ prt f) else id in
     case j of
-      CncFun x (Yes tr) z -> CncFun x (Yes (debug (t2t tr))) z
-      CncCat (Yes ty) (Yes x) y -> CncCat (Yes (ty2ty ty)) (Yes (t2t x)) y
+      CncFun x (Just tr) z -> CncFun x (Just (debug (t2t tr))) z
+      CncCat (Just ty) (Just x) y -> CncCat (Just (ty2ty ty)) (Just (t2t x)) y
       _ -> j
    where
       cg1 = cg
@@ -290,8 +290,8 @@ canon2canon opts abs cg0 =
 
     -- flatten record arguments of param constructors
   p2p (f,j) = case j of
-      ResParam (Yes (ps,v)) -> 
-        ResParam (Yes ([(c,concatMap unRec cont) | (c,cont) <- ps],Nothing))
+      ResParam (Just (ps,v)) -> 
+        ResParam (Just ([(c,concatMap unRec cont) | (c,cont) <- ps],Nothing))
       _ -> j
   unRec (x,ty) = case ty of
       RecType fs -> [ity | (_,typ) <- fs, ity <- unRec (identW,typ)] 
@@ -333,13 +333,13 @@ paramValues cgr = (labels,untyps,typs) where
   partyps = nub $ 
             --- [App (Q (IC "Predef") (IC "Ints")) (EInt i) | i <- [1,9]] ---linTypeInt 
             [ty | 
-              (_,(_,CncCat (Yes ty0) _ _)) <- jments,
+              (_,(_,CncCat (Just ty0) _ _)) <- jments,
               ty  <- typsFrom ty0
             ] ++ [
              Q m ty | 
               (m,(ty,ResParam _)) <- jments
             ] ++ [ty | 
-              (_,(_,CncFun _ (Yes tr) _)) <- jments,
+              (_,(_,CncFun _ (Just tr) _)) <- jments,
               ty  <- err (const []) snd $ appSTM (typsFromTrm tr) []
             ]
   params = [(ty, errVal (traceD ("UNKNOWN PARAM TYPE" +++ show ty) []) $ 
@@ -381,7 +381,7 @@ paramValues cgr = (labels,untyps,typs) where
     [(cat,[f | let RecType fs = GM.defLinType, f <- fs]) | cat <- [cInt,cFloat, cString]] ++
     reverse ---- TODO: really those lincats that are reached
             ---- reverse is enough to expel overshadowed ones... 
-      [(cat,ls) | (_,(cat,CncCat (Yes ty) _ _)) <- jments, 
+      [(cat,ls) | (_,(cat,CncCat (Just ty) _ _)) <- jments, 
                   RecType ls <- [unlockTy ty]]
   labels = Map.fromList $ concat 
     [((cat,[lab]),(typ,i)): 
diff --git a/src/GF/Compile/Optimize.hs b/src/GF/Compile/Optimize.hs
index 177e5bf70..7f6e451c7 100644
--- a/src/GF/Compile/Optimize.hs
+++ b/src/GF/Compile/Optimize.hs
@@ -85,6 +85,13 @@ evalModule oopts (ms,eenv) mo@(name,m0)
      info' <- evalResInfo oopts gr (i,info)
      return $ updateRes g name i info'
 
+-- | update a resource module by adding a new or changing an old definition
+updateRes :: SourceGrammar -> Ident -> Ident -> Info -> SourceGrammar
+updateRes gr@(MGrammar ms) m i info = MGrammar $ map upd ms where
+  upd (n,mo)
+    | n /= m = (n,mo)
+    | n == m = (n,updateModule mo i info)
+
 -- | only operations need be compiled in a resource, and this is local to each
 -- definition since the module is traversed in topological order
 evalResInfo :: Options -> SourceGrammar -> (Ident,Info) -> Err Info
@@ -92,8 +99,8 @@ evalResInfo oopts gr (c,info) = case info of
 
   ResOper pty pde -> eIn "operation" $ do
     pde' <- case pde of
-       Yes de | optres -> liftM yes $ comp de 
-       _ -> return pde
+              Just de | optres -> liftM Just $ comp de 
+              _                -> return pde
     return $ ResOper pty pde'
 
   _ ->  return info
@@ -114,26 +121,22 @@ evalCncInfo opts gr cnc abs (c,info) = do
 
   CncCat ptyp pde ppr -> do
     pde' <- case (ptyp,pde) of
-      (Yes typ, Yes de) -> 
-        liftM yes $ pEval ([(varStr, typeStr)], typ) de
-      (Yes typ, Nope)   -> 
-        liftM yes $ mkLinDefault gr typ >>= partEval noOptions gr ([(varStr, typeStr)],typ)
-      (May b, Nope) ->
-        return $ May b
+      (Just typ, Just de) -> 
+        liftM Just $ pEval ([(varStr, typeStr)], typ) de
+      (Just typ, Nothing) -> 
+        liftM Just $ mkLinDefault gr typ >>= partEval noOptions gr ([(varStr, typeStr)],typ)
       _ -> return pde   -- indirection
 
-    ppr' <- liftM yes $ evalPrintname gr c ppr (yes $ K $ prt c)
+    ppr' <- liftM Just $ evalPrintname gr c ppr (Just $ K $ prt c)
 
     return (CncCat ptyp pde' ppr')
 
   CncFun (mt@(Just (_,ty@(cont,val)))) pde ppr -> --trace (prt c) $
        eIn ("linearization in type" +++ prt (mkProd (cont,val,[])) ++++ "of function") $ do
     pde' <- case pde of
-      Yes de -> do
-        liftM yes $ pEval ty de
-
-      _ -> return pde
-    ppr' <-  liftM yes $ evalPrintname gr c ppr pde'
+      Just de -> liftM Just $ pEval ty de
+      Nothing -> return pde
+    ppr' <-  liftM Just $ evalPrintname gr c ppr pde'
     return $ CncFun mt pde' ppr' -- only cat in type actually needed
 
   _ ->  return info
@@ -202,13 +205,13 @@ mkLinDefault gr typ = do
 -- lin for functions, cat name for cats (dispatch made in evalCncDef above).
 --- We cannot use linearization at this stage, since we do not know the
 --- defaults we would need for question marks - and we're not yet in canon.
-evalPrintname :: SourceGrammar -> Ident -> MPr -> Perh Term -> Err Term
+evalPrintname :: SourceGrammar -> Ident -> Maybe Term -> Maybe Term -> Err Term
 evalPrintname gr c ppr lin =
   case ppr of
-    Yes pr -> comp pr
-    _ -> case lin of
-      Yes t -> return $ K $ clean $ prt $ oneBranch t ---- stringFromTerm
-      _ -> return $ K $ prt c ----
+    Just pr -> comp pr
+    Nothing -> case lin of
+                 Just t  -> return $ K $ clean $ prt $ oneBranch t ---- stringFromTerm
+                 Nothing -> return $ K $ prt c ----
  where
    comp = computeConcrete gr
 
diff --git a/src/GF/Compile/OptimizeGF.hs b/src/GF/Compile/OptimizeGF.hs
index 27627b137..8f7a0efef 100644
--- a/src/GF/Compile/OptimizeGF.hs
+++ b/src/GF/Compile/OptimizeGF.hs
@@ -48,9 +48,9 @@ processModule :: (Ident -> Term -> Term) -> SourceModule -> SourceModule
 processModule opt (i,mo) = (i,M.replaceJudgements mo (mapTree (shareInfo opt) (M.jments mo)))
 
 shareInfo :: (Ident -> Term -> Term) -> (Ident,Info) -> Info
-shareInfo opt (c, CncCat ty (Yes t) m) = CncCat ty (Yes (opt c t)) m
-shareInfo opt (c, CncFun kxs (Yes t) m) = CncFun kxs (Yes (opt c t)) m
-shareInfo opt (c, ResOper ty (Yes t)) = ResOper ty (Yes (opt c t))
+shareInfo opt (c, CncCat ty (Just t) m) = CncCat ty (Just (opt c t)) m
+shareInfo opt (c, CncFun kxs (Just t) m) = CncFun kxs (Just (opt c t)) m
+shareInfo opt (c, ResOper ty (Just t)) = ResOper ty (Just (opt c t))
 shareInfo _ (_,i) = i
 
 -- the function putting together optimizations
@@ -181,9 +181,9 @@ unsubexpModule sm@(i,mo)
     -- perform this iff the module has opers
     hasSub ljs = not $ null [c | (c,ResOper _ _) <- ljs]
     unparInfo (c,info) = case info of
-      CncFun xs (Yes t) m -> [(c, CncFun xs (Yes (unparTerm t)) m)]
-      ResOper (Yes (EInt 8)) _ -> [] -- subexp-generated opers
-      ResOper pty (Yes t) -> [(c, ResOper pty (Yes (unparTerm t)))]
+      CncFun xs (Just t) m -> [(c, CncFun xs (Just (unparTerm t)) m)]
+      ResOper (Just (EInt 8)) _ -> [] -- subexp-generated opers
+      ResOper pty (Just t) -> [(c, ResOper pty (Just (unparTerm t)))]
       _ -> [(c,info)]
     unparTerm t = case t of
       Q m c | isOperIdent c -> --- name convention of subexp opers
@@ -205,12 +205,12 @@ addSubexpConsts mo tree lins = do
  where
 
    mkOne (f,def) = case def of
-     CncFun xs (Yes trm) pn -> do
+     CncFun xs (Just trm) pn -> do
        trm' <- recomp f trm
-       return (f,CncFun xs (Yes trm') pn)
-     ResOper ty (Yes trm) -> do
+       return (f,CncFun xs (Just trm') pn)
+     ResOper ty (Just trm) -> do
        trm' <- recomp f trm
-       return (f,ResOper ty (Yes trm'))
+       return (f,ResOper ty (Just trm'))
      _ -> return (f,def)
    recomp f t = case Map.lookup t tree of
      Just (_,id) | operIdent id /= f -> return $ Q mo (operIdent id)
@@ -218,7 +218,7 @@ addSubexpConsts mo tree lins = do
 
    list = Map.toList tree
 
-   oper id trm = (operIdent id, ResOper (Yes (EInt 8)) (Yes trm)) 
+   oper id trm = (operIdent id, ResOper (Just (EInt 8)) (Just trm)) 
    --- impossible type encoding generated opers
 
 getSubtermsMod :: Ident -> [(Ident,Info)] -> TermM (Map Term (Int,Int))
@@ -228,10 +228,10 @@ getSubtermsMod mo js = do
   return $ Map.filter (\ (nu,_) -> nu > 1) tree0
  where
    getInfo get fi@(f,i) = case i of
-     CncFun xs (Yes trm) pn -> do
+     CncFun xs (Just trm) pn -> do
        get trm
        return $ fi
-     ResOper ty (Yes trm) -> do
+     ResOper ty (Just trm) -> do
        get trm
        return $ fi
      _ -> return fi
diff --git a/src/GF/Compile/Rebuild.hs b/src/GF/Compile/Rebuild.hs
deleted file mode 100644
index 8adf81824..000000000
--- a/src/GF/Compile/Rebuild.hs
+++ /dev/null
@@ -1,101 +0,0 @@
-----------------------------------------------------------------------
--- |
--- Module      : Rebuild
--- Maintainer  : AR
--- Stability   : (stable)
--- Portability : (portable)
---
--- > CVS $Date: 2005/05/30 21:08:14 $ 
--- > CVS $Author: aarne $
--- > CVS $Revision: 1.14 $
---
--- Rebuild a source module from incomplete and its with-instance.
------------------------------------------------------------------------------
-
-module GF.Compile.Rebuild (rebuildModule) where
-
-import GF.Grammar.Grammar
-import GF.Compile.ModDeps
-import GF.Grammar.PrGrammar
-import GF.Grammar.Lookup
-import GF.Compile.Extend
-import GF.Grammar.Macros
-
-import GF.Infra.Ident
-import GF.Infra.Modules
-import GF.Infra.Option
-import GF.Data.Operations
-
-import Data.List (nub)
-import Data.Maybe (isNothing)
-
--- | rebuilding instance + interface, and "with" modules, prior to renaming. 
--- AR 24/10/2003
-rebuildModule :: [SourceModule] -> SourceModule -> Err SourceModule
-rebuildModule ms mo@(i,mi@(ModInfo mt stat fs_ me mw ops_ med_ js_ ps_)) = do
-  let gr = MGrammar ms
-----  deps <- moduleDeps ms
-----  is   <- openInterfaces deps i
-  let is = [] ---- the method above is buggy: try "i -src" for two grs. AR 8/3/2005
-  mi'  <- case mw of
-
-    -- add the information given in interface into an instance module
-    Nothing -> do
-      testErr (null is || mstatus mi == MSIncomplete) 
-              ("module" +++ prt i +++ 
-               "has open interfaces and must therefore be declared incomplete") 
-      case mt of
-        MTInstance i0 -> do
-          m1 <- lookupModule gr i0
-          testErr (isModRes m1) ("interface expected instead of" +++ prt i0)
-          js' <- extendMod False (i0,const True) i (jments m1) (jments mi)
-          --- to avoid double inclusions, in instance I of I0 = J0 ** ...
-          case extends mi of
-            []  -> return $ replaceJudgements mi js'
-            j0s -> do
-                m0s <- mapM (lookupModule gr) j0s
-                let notInM0 c _  = all (not . isInBinTree c . jments) m0s
-                let js2 = filterBinTree notInM0 js'
-                return $ (replaceJudgements mi js2) 
-                  {positions = 
-                    buildTree (tree2list (positions m1) ++ 
-                               tree2list (positions mi))}
-        _ -> return mi
-
-    -- add the instance opens to an incomplete module "with" instances
-    Just (ext,incl,ops) -> do
-      let (infs,insts) = unzip ops
-      let stat' = ifNull MSComplete (const MSIncomplete)
-                    [i | i <- is, notElem i infs]
-      testErr (stat' == MSComplete || stat == MSIncomplete) 
-              ("module" +++ prt i +++ "remains incomplete")
-      ModInfo mt0 _ fs me' _ ops0 _ js ps0 <- lookupModule gr ext
-      let ops1 = nub $
-                   ops_ ++ -- N.B. js has been name-resolved already
-                   [OQualif i j | (i,j) <- ops] ++
-                   [o | o <- ops0, notElem (openedModule o) infs] ++
-                   [OQualif i i | i <- insts] ++
-                   [OSimple i   | i <- insts]
-
-      --- check if me is incomplete
-      let fs1 = fs `addOptions` fs_                           -- new flags have priority
-      let js0 = [ci | ci@(c,_) <- tree2list js, isInherited incl c]
-      let js1 = buildTree (tree2list js_ ++ js0)
-      let ps1 = buildTree (tree2list ps_ ++ tree2list ps0)
-      let med1= nub (ext : infs ++ insts ++ med_)
-      return $ ModInfo mt0 stat' fs1 me Nothing ops1 med1 js1 ps1
-
-  return (i,mi')
-
-checkCompleteInstance :: SourceModInfo -> SourceModInfo -> Err ()
-checkCompleteInstance abs cnc = ifNull (return ()) (Bad . unlines) $
-  checkComplete [f | (f, ResOper (Yes _) _) <- abs'] cnc'
-   where
-     abs' = tree2list $ jments abs
-     cnc' = jments cnc
-     checkComplete sought given = foldr ckOne [] sought
-       where
-         ckOne f = if isInBinTree f given 
-                      then id
-                      else (("Error: no definition given to" +++ prt f):)
-
diff --git a/src/GF/Compile/Refresh.hs b/src/GF/Compile/Refresh.hs
index d446008d0..ba6142ddd 100644
--- a/src/GF/Compile/Refresh.hs
+++ b/src/GF/Compile/Refresh.hs
@@ -116,18 +116,18 @@ refreshModule (k,ms) mi@(i,mo)
   | otherwise = return (k, mi:ms)
  where
   refreshRes (k,cs) ci@(c,info) = case info of
-    ResOper ptyp (Yes trm) -> do   ---- refresh ptyp
+    ResOper ptyp (Just trm) -> do   ---- refresh ptyp
       (k',trm') <- refreshTermKN k trm
-      return $ (k', (c, ResOper ptyp (Yes trm')):cs)
+      return $ (k', (c, ResOper ptyp (Just trm')):cs)
     ResOverload os tyts -> do
       (k',tyts') <- liftM (\ (t,(_,i)) -> (i,t)) $ 
                     appSTM (mapPairsM refresh tyts) (initIdStateN k)
       return $ (k', (c, ResOverload os tyts'):cs)
-    CncCat mt (Yes trm) pn -> do   ---- refresh mt, pn
+    CncCat mt (Just trm) pn -> do   ---- refresh mt, pn
       (k',trm') <- refreshTermKN k trm
-      return $ (k', (c, CncCat mt (Yes trm') pn):cs)
-    CncFun mt (Yes trm) pn -> do   ---- refresh pn
+      return $ (k', (c, CncCat mt (Just trm') pn):cs)
+    CncFun mt (Just trm) pn -> do   ---- refresh pn
       (k',trm') <- refreshTermKN k trm
-      return $ (k', (c, CncFun mt (Yes trm') pn):cs)
+      return $ (k', (c, CncFun mt (Just trm') pn):cs)
     _ -> return (k, ci:cs)
 
diff --git a/src/GF/Compile/Rename.hs b/src/GF/Compile/Rename.hs
index ba14cb02e..05ccfdb2c 100644
--- a/src/GF/Compile/Rename.hs
+++ b/src/GF/Compile/Rename.hs
@@ -36,7 +36,6 @@ import GF.Grammar.Macros
 import GF.Grammar.PrGrammar
 import GF.Grammar.AppPredefined
 import GF.Grammar.Lookup
-import GF.Compile.Extend
 import GF.Data.Operations
 
 import Control.Monad
@@ -115,7 +114,7 @@ renameIdentPatt env p = do
 
 info2status :: Maybe Ident -> (Ident,Info) -> StatusInfo
 info2status mq (c,i) = case i of
-  AbsFun _ (Yes EData) -> maybe Con QC mq
+  AbsFun _ (Just EData) -> maybe Con QC mq
   ResValue _  -> maybe Con QC mq
   ResParam _  -> maybe Con QC mq
   AnyInd True m -> maybe Con (const (QC m)) mq
@@ -161,12 +160,12 @@ renameInfo mo status (i,info) = errIn
   ResOverload os tysts -> 
     liftM (ResOverload os) (mapM (pairM rent) tysts)
 
-  ResParam (Yes (pp,m)) -> do
+  ResParam (Just (pp,m)) -> do
     pp' <- mapM (renameParam status) pp
-    return $ ResParam $ Yes (pp',m)
-  ResValue (Yes (t,m)) -> do
+    return $ ResParam $ Just (pp',m)
+  ResValue (Just (t,m)) -> do
     t' <- rent t
-    return $ ResValue $ Yes (t',m)
+    return $ ResValue $ Just (t',m)
   CncCat pty ptr ppr -> liftM3 CncCat (ren pty) (ren ptr) (ren ppr)
   CncFun mt  ptr ppr -> liftM2 (CncFun mt)      (ren ptr) (ren ppr)
   _ -> return info
@@ -174,9 +173,8 @@ renameInfo mo status (i,info) = errIn
    ren = renPerh rent
    rent = renameTerm status []
 
-renPerh ren pt = case pt of
-  Yes t -> liftM Yes $ ren t
-  _ -> return pt
+renPerh ren (Just t) = liftM Just $ ren t
+renPerh ren Nothing  = return Nothing
 
 renameTerm :: Status -> [Ident] -> Term -> Err Term
 renameTerm env vars = ren vars where
diff --git a/src/GF/Compile/Update.hs b/src/GF/Compile/Update.hs
index a0aefeea5..4bcea0db2 100644
--- a/src/GF/Compile/Update.hs
+++ b/src/GF/Compile/Update.hs
@@ -12,122 +12,200 @@
 -- (Description of the module)
 -----------------------------------------------------------------------------
 
-module GF.Compile.Update (updateRes, buildAnyTree, combineAnyInfos, unifyAnyInfo,
-	       -- * these auxiliaries should be somewhere else 
-	       -- since they don't use the info types
-	       groupInfos, sortInfos, combineInfos, unifyInfos,
-	       tryInsert, unifAbsDefs, unifConstrs
-	      ) where
+module GF.Compile.Update (buildAnyTree, extendModule, rebuildModule) where
 
 import GF.Infra.Ident
 import GF.Grammar.Grammar
-import GF.Grammar.PrGrammar
+import GF.Grammar.Printer
 import GF.Infra.Modules
+import GF.Infra.Option
 
 import GF.Data.Operations
 
 import Data.List
+import qualified Data.Map as Map
 import Control.Monad
-
--- | update a resource module by adding a new or changing an old definition
-updateRes :: SourceGrammar -> Ident -> Ident -> Info -> SourceGrammar
-updateRes gr@(MGrammar ms) m i info = MGrammar $ map upd ms where
-  upd (n,mo)
-    | n /= m = (n,mo)
-    | n == m = (n,updateModule mo i info)
+import Text.PrettyPrint
 
 -- | combine a list of definitions into a balanced binary search tree
-buildAnyTree :: [(Ident,Info)] -> Err (BinTree Ident Info)
-buildAnyTree ias = do
-  ias' <- combineAnyInfos ias
-  return $ buildTree ias'
-
-
--- | unifying information for abstract, resource, and concrete
-combineAnyInfos :: [(Ident,Info)] -> Err [(Ident,Info)]
-combineAnyInfos = combineInfos unifyAnyInfo
+buildAnyTree :: Ident -> [(Ident,Info)] -> Err (BinTree Ident Info)
+buildAnyTree m = go Map.empty
+  where
+    go map []         = return map
+    go map ((c,j):is) = do
+      case Map.lookup c map of
+        Just i  -> case unifyAnyInfo c i j of
+		     Ok k  -> go (Map.insert c k map) is
+		     Bad _ -> fail $ render (text "cannot unify the informations" $$ 
+		                             nest 4 (ppJudgement (c,i)) $$
+		                             text "and" $+$
+		                             nest 4 (ppJudgement (c,j)) $$
+		                             text "in module" <+> ppIdent m)
+        Nothing -> go (Map.insert c j map) is
+
+extendModule :: [SourceModule] -> SourceModule -> Err SourceModule
+extendModule ms (name,m)
+  ---- Just to allow inheritance in incomplete concrete (which are not
+  ---- compiled anyway), extensions are not built for them.
+  ---- Should be replaced by real control. AR 4/2/2005
+  | mstatus m == MSIncomplete && isModCnc m = return (name,m)
+  | otherwise                               = do m' <- foldM extOne m (extend m) 
+                                                 return (name,m')
+ where
+   extOne mo (n,cond) = do
+     m0 <- lookupModule (MGrammar ms) n
+
+     -- test that the module types match, and find out if the old is complete
+     testErr (sameMType (mtype m) (mtype mo)) 
+             ("illegal extension type to module" +++ prIdent name)
+
+     let isCompl = isCompleteModule m0
+
+     -- build extension in a way depending on whether the old module is complete
+     js1 <- extendMod isCompl (n, isInherited cond) name (jments m0) (jments mo)
+
+     -- if incomplete, throw away extension information
+     return $ 
+          if isCompl
+            then mo {jments = js1}
+            else mo {extend = filter ((/=n) . fst) (extend mo)
+                    ,mexdeps= nub (n : mexdeps mo)
+                    ,jments = js1
+                    }
+
+-- | rebuilding instance + interface, and "with" modules, prior to renaming. 
+-- AR 24/10/2003
+rebuildModule :: [SourceModule] -> SourceModule -> Err SourceModule
+rebuildModule ms mo@(i,mi@(ModInfo mt stat fs_ me mw ops_ med_ js_ ps_)) = do
+  let gr = MGrammar ms
+----  deps <- moduleDeps ms
+----  is   <- openInterfaces deps i
+  let is = [] ---- the method above is buggy: try "i -src" for two grs. AR 8/3/2005
+  mi'  <- case mw of
+
+    -- add the information given in interface into an instance module
+    Nothing -> do
+      testErr (null is || mstatus mi == MSIncomplete) 
+              ("module" +++ prIdent i +++ 
+               "has open interfaces and must therefore be declared incomplete") 
+      case mt of
+        MTInstance i0 -> do
+          m1 <- lookupModule gr i0
+          testErr (isModRes m1) ("interface expected instead of" +++ prIdent i0)
+          js' <- extendMod False (i0,const True) i (jments m1) (jments mi)
+          --- to avoid double inclusions, in instance I of I0 = J0 ** ...
+          case extends mi of
+            []  -> return $ replaceJudgements mi js'
+            j0s -> do
+                m0s <- mapM (lookupModule gr) j0s
+                let notInM0 c _  = all (not . isInBinTree c . jments) m0s
+                let js2 = filterBinTree notInM0 js'
+                return $ (replaceJudgements mi js2) 
+                  {positions = Map.union (positions m1) (positions mi)}
+        _ -> return mi
+
+    -- add the instance opens to an incomplete module "with" instances
+    Just (ext,incl,ops) -> do
+      let (infs,insts) = unzip ops
+      let stat' = ifNull MSComplete (const MSIncomplete)
+                    [i | i <- is, notElem i infs]
+      testErr (stat' == MSComplete || stat == MSIncomplete) 
+              ("module" +++ prIdent i +++ "remains incomplete")
+      ModInfo mt0 _ fs me' _ ops0 _ js ps0 <- lookupModule gr ext
+      let ops1 = nub $
+                   ops_ ++ -- N.B. js has been name-resolved already
+                   [OQualif i j | (i,j) <- ops] ++
+                   [o | o <- ops0, notElem (openedModule o) infs] ++
+                   [OQualif i i | i <- insts] ++
+                   [OSimple i   | i <- insts]
+
+      --- check if me is incomplete
+      let fs1 = fs `addOptions` fs_                           -- new flags have priority
+      let js0 = [ci | ci@(c,_) <- tree2list js, isInherited incl c]
+      let js1 = buildTree (tree2list js_ ++ js0)
+      let ps1 = Map.union ps_ ps0
+      let med1= nub (ext : infs ++ insts ++ med_)
+      return $ ModInfo mt0 stat' fs1 me Nothing ops1 med1 js1 ps1
+
+  return (i,mi')
+
+-- | When extending a complete module: new information is inserted,
+-- and the process is interrupted if unification fails.
+-- If the extended module is incomplete, its judgements are just copied.
+extendMod :: Bool -> (Ident,Ident -> Bool) -> Ident -> 
+             BinTree Ident Info -> BinTree Ident Info -> 
+             Err (BinTree Ident Info)
+extendMod isCompl (name,cond) base old new = foldM try new $ Map.toList old 
+  where
+    try new (c,i)
+      | not (cond c) = return new
+      | otherwise    = case Map.lookup c new of
+                         Just j -> case unifyAnyInfo c i j of
+		                     Ok k  -> return $ updateTree (c,k) new
+		                     Bad _ -> fail $ render (text "cannot unify the information" $$ 
+		                                             nest 4 (ppJudgement (c,i)) $$
+		                                             text "in module" <+> ppIdent name <+> text "with" $$
+		                                             nest 4 (ppJudgement (c,j)) $$
+		                                             text "in module" <+> ppIdent base)
+                         Nothing    -> if isCompl
+                                         then return $ updateTree (c,indirInfo name i) new
+                                         else return $ updateTree (c,i) new
+
+    indirInfo :: Ident -> Info -> Info
+    indirInfo n info = AnyInd b n' where 
+      (b,n') = case info of
+        ResValue _ -> (True,n)
+        ResParam _ -> (True,n)
+        AbsFun _ (Just EData) -> (True,n) 
+        AnyInd b k -> (b,k)
+        _ -> (False,n) ---- canonical in Abs
 
 unifyAnyInfo :: Ident -> Info -> Info -> Err Info
-unifyAnyInfo c i j = errIn ("combining information for" +++ prt c) $ case (i,j) of
+unifyAnyInfo c i j = case (i,j) of
   (AbsCat mc1 mf1, AbsCat mc2 mf2) -> 
-    liftM2 AbsCat (unifPerhaps mc1 mc2) (unifConstrs mf1 mf2) -- adding constrs
+    liftM2 AbsCat (unifMaybe mc1 mc2) (unifConstrs mf1 mf2) -- adding constrs
   (AbsFun mt1 md1, AbsFun mt2 md2) -> 
-    liftM2 AbsFun (unifPerhaps mt1 mt2) (unifAbsDefs md1 md2) -- adding defs
+    liftM2 AbsFun (unifMaybe mt1 mt2) (unifAbsDefs md1 md2) -- adding defs
 
-  (ResParam mt1, ResParam mt2) -> liftM ResParam $ unifPerhaps mt1 mt2
+  (ResParam mt1, ResParam mt2) -> liftM ResParam $ unifMaybe mt1 mt2
+  (ResValue mt1, ResValue mt2) -> 
+    liftM ResValue $ unifMaybe mt1 mt2
+  (_, ResOverload ms t) | elem c ms ->
+    return $ ResOverload ms t
   (ResOper mt1 m1, ResOper mt2 m2) -> 
-    liftM2 ResOper (unifPerhaps mt1 mt2) (unifPerhaps m1 m2)
+    liftM2 ResOper (unifMaybe mt1 mt2) (unifMaybe m1 m2)
 
   (CncCat mc1 mf1 mp1, CncCat mc2 mf2 mp2) -> 
-    liftM3 CncCat (unifPerhaps mc1 mc2) (unifPerhaps mf1 mf2) (unifPerhaps mp1 mp2)
+    liftM3 CncCat (unifMaybe mc1 mc2) (unifMaybe mf1 mf2) (unifMaybe mp1 mp2)
   (CncFun m mt1 md1, CncFun _ mt2 md2) -> 
-    liftM2 (CncFun m) (unifPerhaps mt1 mt2) (unifPerhaps md1 md2) ---- adding defs
--- for bw compatibility with unspecified printnames in old GF
-  (CncFun Nothing Nope (Yes pr),_) -> 
-    unifyAnyInfo c (CncCat Nope Nope (Yes pr)) j 
-  (_,CncFun Nothing Nope (Yes pr)) -> 
-    unifyAnyInfo c i (CncCat Nope Nope (Yes pr)) 
-
-  _ -> Bad $ "cannot unify informations in" ++++ show i ++++ "and" ++++ show j
-
---- these auxiliaries should be somewhere else since they don't use the info types
-
-groupInfos :: Eq a => [(a,b)] -> [[(a,b)]]
-groupInfos = groupBy (\i j -> fst i == fst j)
-
-sortInfos :: Ord a => [(a,b)] -> [(a,b)]
-sortInfos = sortBy (\i j -> compare (fst i) (fst j))
-
-combineInfos :: Ord a => (a -> b -> b -> Err b) -> [(a,b)] -> Err [(a,b)]
-combineInfos f ris = do
-  let riss = groupInfos $ sortInfos ris
-  mapM (unifyInfos f) riss
-
-unifyInfos :: (a -> b -> b -> Err b) -> [(a,b)] -> Err (a,b)
-unifyInfos _ [] = Bad "empty info list"
-unifyInfos unif ris = do
-  let c = fst $ head ris
-  let infos = map snd ris
-  let ([i],is) = splitAt 1 infos 
-  info <- foldM (unif c) i is
-  return (c,info)
-
-
-tryInsert :: Ord a => (b -> b -> Err b) -> (b -> b) ->
-             BinTree a b -> (a,b) -> Err (BinTree a b)
-tryInsert unif indir tree z@(x, info) = case justLookupTree x tree of
-  Ok info0 -> do
-    info1 <- unif info info0
-    return $ updateTree (x,info1) tree 
-  _ -> return $ updateTree (x,indir info) tree
-
-{- ----
-case tree of
- NT -> return $ BT (x, indir info) NT NT
- BT c@(a,info0) left right 
-   | x < a  -> do
-       left' <- tryInsert unif indir left z    
-       return $ BT c left' right 
-   | x > a  -> do
-       right' <- tryInsert unif indir right z    
-       return $ BT c left right' 
-   | x == a -> do
-       info' <- unif info info0
-       return $ BT (x,info') left right
--}
-
---- addToMaybeList m c = maybe (return c) (\old -> return (c ++ old)) m
-
-unifAbsDefs :: Perh Term -> Perh Term -> Err (Perh Term)
+    liftM2 (CncFun m) (unifMaybe mt1 mt2) (unifMaybe md1 md2) ---- adding defs
+
+  (AnyInd b1 m1, AnyInd b2 m2) -> do
+    testErr (b1 == b2) $ "indirection status"
+    testErr (m1 == m2) $ "different sources of indirection"
+    return i
+
+  _ -> fail "informations"
+
+-- | this is what happens when matching two values in the same module
+unifMaybe :: Eq a => Maybe a -> Maybe a -> Err (Maybe a)
+unifMaybe Nothing   Nothing   = return Nothing
+unifMaybe (Just p1) Nothing   = return (Just p1)
+unifMaybe Nothing   (Just p2) = return (Just p2)
+unifMaybe (Just p1) (Just p2)
+  | p1==p2                    = return (Just p1)
+  | otherwise                 = fail ""
+
+unifAbsDefs :: Maybe Term -> Maybe Term -> Err (Maybe Term)
 unifAbsDefs p1 p2 = case (p1,p2) of
-  (Nope, _)  -> return p2
-  (_, Nope)  -> return p1
-  (Yes (Eqs bs), Yes (Eqs ds)) -> return $ yes $ Eqs $ bs ++ ds --- order!
-  _ -> Bad "update conflict for definitions"
+  (Nothing, _)  -> return p2
+  (_, Nothing)  -> return p1
+  (Just (Eqs bs), Just (Eqs ds))
+                -> return $ Just $ Eqs $ bs ++ ds --- order!
+  _             -> fail "definitions"
 
-unifConstrs :: Perh [Term] -> Perh [Term] -> Err (Perh [Term])
+unifConstrs :: Maybe [Term] -> Maybe [Term] -> Err (Maybe [Term])
 unifConstrs p1 p2 = case (p1,p2) of
-  (Nope, _)  -> return p2
-  (_, Nope)  -> return p1
-  (Yes bs, Yes ds) -> return $ yes $ bs ++ ds
-  _ -> Bad "update conflict for constructors"
+  (Nothing, _)  -> return p2
+  (_, Nothing)  -> return p1
+  (Just bs, Just ds) -> return $ Just $ bs ++ ds