----------------------------------------------------------------------
-- |
-- Module      : Update
-- Maintainer  : AR
-- Stability   : (stable)
-- Portability : (portable)
--
-- > CVS $Date: 2005/05/30 18:39:44 $
-- > CVS $Author: aarne $
-- > CVS $Revision: 1.8 $
--
-- (Description of the module)
-----------------------------------------------------------------------------

module GF.Compile.Update (buildAnyTree, extendModule, rebuildModule) where

import GF.Infra.Ident
import GF.Infra.Option
import GF.Infra.CheckM
import GF.Grammar.Grammar
import GF.Grammar.Printer
import GF.Grammar.Lookup

import GF.Data.Operations

import Data.List
import qualified Data.Map as Map
import Control.Monad
import GF.Text.Pretty
import qualified Control.Monad.Fail as Fail

-- | combine a list of definitions into a balanced binary search tree
buildAnyTree :: Fail.MonadFail m => ModuleName -> [(Ident,Info)] -> m (Map.Map Ident Info)
buildAnyTree :: ModuleName -> [(Ident, Info)] -> m (Map Ident Info)
buildAnyTree ModuleName
m = Map Ident Info -> [(Ident, Info)] -> m (Map Ident Info)
forall (m :: * -> *) k.
(Ord k, MonadFail m, Pretty k) =>
Map k Info -> [(k, Info)] -> m (Map k Info)
go Map Ident Info
forall k a. Map k a
Map.empty
  where
    go :: Map k Info -> [(k, Info)] -> m (Map k Info)
go Map k Info
map []         = Map k Info -> m (Map k Info)
forall (m :: * -> *) a. Monad m => a -> m a
return Map k Info
map
    go Map k Info
map ((k
c,Info
j):[(k, Info)]
is) =
      case k -> Map k Info -> Maybe Info
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup k
c Map k Info
map of
        Just Info
i  -> case ModuleName -> Info -> Info -> Err Info
unifyAnyInfo ModuleName
m Info
i Info
j of
          Ok Info
k  -> Map k Info -> [(k, Info)] -> m (Map k Info)
go (k -> Info -> Map k Info -> Map k Info
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert k
c Info
k Map k Info
map) [(k, Info)]
is
          Bad String
_ -> String -> m (Map k Info)
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> m (Map k Info)) -> String -> m (Map k Info)
forall a b. (a -> b) -> a -> b
$ Doc -> String
forall a. Pretty a => a -> String
render (String
"conflicting information in module"String -> ModuleName -> Doc
forall a1 a2. (Pretty a1, Pretty a2) => a1 -> a2 -> Doc
<+>ModuleName
m Doc -> Doc -> Doc
forall a1 a2. (Pretty a1, Pretty a2) => a1 -> a2 -> Doc
$$
                                  Int -> Doc -> Doc
forall a. Pretty a => Int -> a -> Doc
nest Int
4 (TermPrintQual -> (k, Info) -> Doc
forall a2. Pretty a2 => TermPrintQual -> (a2, Info) -> Doc
ppJudgement TermPrintQual
Qualified (k
c,Info
i)) Doc -> String -> Doc
forall a1 a2. (Pretty a1, Pretty a2) => a1 -> a2 -> Doc
$$
                                  String
"and" Doc -> Doc -> Doc
forall a1 a2. (Pretty a1, Pretty a2) => a1 -> a2 -> Doc
$+$
                                  Int -> Doc -> Doc
forall a. Pretty a => Int -> a -> Doc
nest Int
4 (TermPrintQual -> (k, Info) -> Doc
forall a2. Pretty a2 => TermPrintQual -> (a2, Info) -> Doc
ppJudgement TermPrintQual
Qualified (k
c,Info
j)))
        Maybe Info
Nothing -> Map k Info -> [(k, Info)] -> m (Map k Info)
go (k -> Info -> Map k Info -> Map k Info
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert k
c Info
j Map k Info
map) [(k, Info)]
is

extendModule :: FilePath -> SourceGrammar -> SourceModule -> Check SourceModule
extendModule :: String -> SourceGrammar -> SourceModule -> Check SourceModule
extendModule String
cwd SourceGrammar
gr (ModuleName
name,ModuleInfo
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
  | ModuleInfo -> ModuleStatus
mstatus ModuleInfo
m ModuleStatus -> ModuleStatus -> Bool
forall a. Eq a => a -> a -> Bool
== ModuleStatus
MSIncomplete Bool -> Bool -> Bool
&& ModuleInfo -> Bool
isModCnc ModuleInfo
m = SourceModule -> Check SourceModule
forall (m :: * -> *) a. Monad m => a -> m a
return (ModuleName
name,ModuleInfo
m)
  | Bool
otherwise                               = String
-> ModuleInfo
-> Location
-> Doc
-> Check SourceModule
-> Check SourceModule
forall a1 a2 a3.
(Pretty a1, HasSourcePath a2) =>
String -> a2 -> Location -> a1 -> Check a3 -> Check a3
checkInModule String
cwd ModuleInfo
m Location
NoLoc Doc
empty (Check SourceModule -> Check SourceModule)
-> Check SourceModule -> Check SourceModule
forall a b. (a -> b) -> a -> b
$ do
                                                 ModuleInfo
m' <- (ModuleInfo -> (ModuleName, MInclude) -> Check ModuleInfo)
-> ModuleInfo -> [(ModuleName, MInclude)] -> Check ModuleInfo
forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldM ModuleInfo -> (ModuleName, MInclude) -> Check ModuleInfo
extOne ModuleInfo
m (ModuleInfo -> [(ModuleName, MInclude)]
mextend ModuleInfo
m)
                                                 SourceModule -> Check SourceModule
forall (m :: * -> *) a. Monad m => a -> m a
return (ModuleName
name,ModuleInfo
m')
 where
   extOne :: ModuleInfo -> (ModuleName, MInclude) -> Check ModuleInfo
extOne ModuleInfo
mo (ModuleName
n,MInclude
cond) = do
     ModuleInfo
m0 <- SourceGrammar -> ModuleName -> Check ModuleInfo
forall (m :: * -> *).
ErrorMonad m =>
SourceGrammar -> ModuleName -> m ModuleInfo
lookupModule SourceGrammar
gr ModuleName
n

     -- test that the module types match, and find out if the old is complete
     Bool -> Check () -> Check ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (ModuleType -> ModuleType -> Bool
sameMType (ModuleInfo -> ModuleType
mtype ModuleInfo
m) (ModuleInfo -> ModuleType
mtype ModuleInfo
mo))
            (Doc -> Check ()
forall a. Doc -> Check a
checkError (String
"illegal extension type to module" String -> ModuleName -> Doc
forall a1 a2. (Pretty a1, Pretty a2) => a1 -> a2 -> Doc
<+> ModuleName
name))

     let isCompl :: Bool
isCompl = ModuleInfo -> Bool
isCompleteModule ModuleInfo
m0

     -- build extension in a way depending on whether the old module is complete
     Map Ident Info
js1 <- SourceGrammar
-> Bool
-> (SourceModule, Ident -> Bool)
-> ModuleName
-> Map Ident Info
-> Check (Map Ident Info)
extendMod SourceGrammar
gr Bool
isCompl ((ModuleName
n,ModuleInfo
m0), MInclude -> Ident -> Bool
isInherited MInclude
cond) ModuleName
name (ModuleInfo -> Map Ident Info
jments ModuleInfo
mo)

     -- if incomplete, throw away extension information
     ModuleInfo -> Check ModuleInfo
forall (m :: * -> *) a. Monad m => a -> m a
return (ModuleInfo -> Check ModuleInfo) -> ModuleInfo -> Check ModuleInfo
forall a b. (a -> b) -> a -> b
$
          if Bool
isCompl
            then ModuleInfo
mo {jments :: Map Ident Info
jments = Map Ident Info
js1}
            else ModuleInfo
mo {mextend :: [(ModuleName, MInclude)]
mextend= ((ModuleName, MInclude) -> Bool)
-> [(ModuleName, MInclude)] -> [(ModuleName, MInclude)]
forall a. (a -> Bool) -> [a] -> [a]
filter ((ModuleName -> ModuleName -> Bool
forall a. Eq a => a -> a -> Bool
/=ModuleName
n) (ModuleName -> Bool)
-> ((ModuleName, MInclude) -> ModuleName)
-> (ModuleName, MInclude)
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ModuleName, MInclude) -> ModuleName
forall a b. (a, b) -> a
fst) (ModuleInfo -> [(ModuleName, MInclude)]
mextend ModuleInfo
mo)
                    ,mexdeps :: [ModuleName]
mexdeps= [ModuleName] -> [ModuleName]
forall a. Eq a => [a] -> [a]
nub (ModuleName
n ModuleName -> [ModuleName] -> [ModuleName]
forall a. a -> [a] -> [a]
: ModuleInfo -> [ModuleName]
mexdeps ModuleInfo
mo)
                    ,jments :: Map Ident Info
jments = Map Ident Info
js1
                    }

-- | rebuilding instance + interface, and "with" modules, prior to renaming.
-- AR 24/10/2003
rebuildModule :: FilePath -> SourceGrammar -> SourceModule -> Check SourceModule
rebuildModule :: String -> SourceGrammar -> SourceModule -> Check SourceModule
rebuildModule String
cwd SourceGrammar
gr mo :: SourceModule
mo@(ModuleName
i,mi :: ModuleInfo
mi@(ModInfo ModuleType
mt ModuleStatus
stat Options
fs_ [(ModuleName, MInclude)]
me Maybe (ModuleName, MInclude, [(ModuleName, ModuleName)])
mw [OpenSpec]
ops_ [ModuleName]
med_ String
msrc_ Maybe (Array Int Sequence)
env_ Map Ident Info
js_)) =
  String
-> ModuleInfo
-> Location
-> Doc
-> Check SourceModule
-> Check SourceModule
forall a1 a2 a3.
(Pretty a1, HasSourcePath a2) =>
String -> a2 -> Location -> a1 -> Check a3 -> Check a3
checkInModule String
cwd ModuleInfo
mi Location
NoLoc Doc
empty (Check SourceModule -> Check SourceModule)
-> Check SourceModule -> Check SourceModule
forall a b. (a -> b) -> a -> b
$ do

----  deps <- moduleDeps ms
----  is   <- openInterfaces deps i
  let is :: [a]
is = [] ---- the method above is buggy: try "i -src" for two grs. AR 8/3/2005
  ModuleInfo
mi'  <- case Maybe (ModuleName, MInclude, [(ModuleName, ModuleName)])
mw of

    -- add the information given in interface into an instance module
    Maybe (ModuleName, MInclude, [(ModuleName, ModuleName)])
Nothing -> do
      Bool -> Check () -> Check ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless ([Any] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Any]
forall a. [a]
is Bool -> Bool -> Bool
|| ModuleInfo -> ModuleStatus
mstatus ModuleInfo
mi ModuleStatus -> ModuleStatus -> Bool
forall a. Eq a => a -> a -> Bool
== ModuleStatus
MSIncomplete)
             (Doc -> Check ()
forall a. Doc -> Check a
checkError (String
"module" String -> ModuleName -> Doc
forall a1 a2. (Pretty a1, Pretty a2) => a1 -> a2 -> Doc
<+> ModuleName
i Doc -> String -> Doc
forall a1 a2. (Pretty a1, Pretty a2) => a1 -> a2 -> Doc
<+>
                          String
"has open interfaces and must therefore be declared incomplete"))
      case ModuleType
mt of
        MTInstance (ModuleName
i0,MInclude
mincl) -> do
          ModuleInfo
m1 <- SourceGrammar -> ModuleName -> Check ModuleInfo
forall (m :: * -> *).
ErrorMonad m =>
SourceGrammar -> ModuleName -> m ModuleInfo
lookupModule SourceGrammar
gr ModuleName
i0
          Bool -> Check () -> Check ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (ModuleInfo -> Bool
isModRes ModuleInfo
m1)
                 (Doc -> Check ()
forall a. Doc -> Check a
checkError (String
"interface expected instead of" String -> ModuleName -> Doc
forall a1 a2. (Pretty a1, Pretty a2) => a1 -> a2 -> Doc
<+> ModuleName
i0))
          Map Ident Info
js' <- SourceGrammar
-> Bool
-> (SourceModule, Ident -> Bool)
-> ModuleName
-> Map Ident Info
-> Check (Map Ident Info)
extendMod SourceGrammar
gr Bool
False ((ModuleName
i0,ModuleInfo
m1), MInclude -> Ident -> Bool
isInherited MInclude
mincl) ModuleName
i (ModuleInfo -> Map Ident Info
jments ModuleInfo
mi)
          --- to avoid double inclusions, in instance I of I0 = J0 ** ...
          case ModuleInfo -> [ModuleName]
extends ModuleInfo
mi of
            []  -> ModuleInfo -> Check ModuleInfo
forall (m :: * -> *) a. Monad m => a -> m a
return ModuleInfo
mi{jments :: Map Ident Info
jments=Map Ident Info
js'}
            [ModuleName]
j0s -> do
                [ModuleInfo]
m0s <- (ModuleName -> Check ModuleInfo)
-> [ModuleName] -> Check [ModuleInfo]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (SourceGrammar -> ModuleName -> Check ModuleInfo
forall (m :: * -> *).
ErrorMonad m =>
SourceGrammar -> ModuleName -> m ModuleInfo
lookupModule SourceGrammar
gr) [ModuleName]
j0s
                let notInM0 :: Ident -> p -> Bool
notInM0 Ident
c p
_  = (ModuleInfo -> Bool) -> [ModuleInfo] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all (Bool -> Bool
not (Bool -> Bool) -> (ModuleInfo -> Bool) -> ModuleInfo -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ident -> Map Ident Info -> Bool
forall k a. Ord k => k -> Map k a -> Bool
Map.member Ident
c (Map Ident Info -> Bool)
-> (ModuleInfo -> Map Ident Info) -> ModuleInfo -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ModuleInfo -> Map Ident Info
jments) [ModuleInfo]
m0s
                let js2 :: Map Ident Info
js2 = (Ident -> Info -> Bool) -> Map Ident Info -> Map Ident Info
forall k a. (k -> a -> Bool) -> Map k a -> Map k a
Map.filterWithKey Ident -> Info -> Bool
forall p. Ident -> p -> Bool
notInM0 Map Ident Info
js'
                ModuleInfo -> Check ModuleInfo
forall (m :: * -> *) a. Monad m => a -> m a
return ModuleInfo
mi{jments :: Map Ident Info
jments=Map Ident Info
js2}
        ModuleType
_ -> ModuleInfo -> Check ModuleInfo
forall (m :: * -> *) a. Monad m => a -> m a
return ModuleInfo
mi

    -- add the instance opens to an incomplete module "with" instances
    Just (ModuleName
ext,MInclude
incl,[(ModuleName, ModuleName)]
ops) -> do
      let ([ModuleName]
infs,[ModuleName]
insts) = [(ModuleName, ModuleName)] -> ([ModuleName], [ModuleName])
forall a b. [(a, b)] -> ([a], [b])
unzip [(ModuleName, ModuleName)]
ops
      let stat' :: ModuleStatus
stat' = if (ModuleName -> Bool) -> [ModuleName] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all ((ModuleName -> [ModuleName] -> Bool)
-> [ModuleName] -> ModuleName -> Bool
forall a b c. (a -> b -> c) -> b -> a -> c
flip ModuleName -> [ModuleName] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
elem [ModuleName]
infs) [ModuleName]
forall a. [a]
is
                    then ModuleStatus
MSComplete
                    else ModuleStatus
MSIncomplete
      Bool -> Check () -> Check ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (ModuleStatus
stat' ModuleStatus -> ModuleStatus -> Bool
forall a. Eq a => a -> a -> Bool
== ModuleStatus
MSComplete Bool -> Bool -> Bool
|| ModuleStatus
stat ModuleStatus -> ModuleStatus -> Bool
forall a. Eq a => a -> a -> Bool
== ModuleStatus
MSIncomplete)
             (Doc -> Check ()
forall a. Doc -> Check a
checkError (String
"module" String -> ModuleName -> Doc
forall a1 a2. (Pretty a1, Pretty a2) => a1 -> a2 -> Doc
<+> ModuleName
i Doc -> String -> Doc
forall a1 a2. (Pretty a1, Pretty a2) => a1 -> a2 -> Doc
<+> String
"remains incomplete"))
      ModInfo ModuleType
mt0 ModuleStatus
_ Options
fs [(ModuleName, MInclude)]
me' Maybe (ModuleName, MInclude, [(ModuleName, ModuleName)])
_ [OpenSpec]
ops0 [ModuleName]
_ String
fpath Maybe (Array Int Sequence)
_ Map Ident Info
js <- SourceGrammar -> ModuleName -> Check ModuleInfo
forall (m :: * -> *).
ErrorMonad m =>
SourceGrammar -> ModuleName -> m ModuleInfo
lookupModule SourceGrammar
gr ModuleName
ext
      let ops1 :: [OpenSpec]
ops1 = [OpenSpec] -> [OpenSpec]
forall a. Eq a => [a] -> [a]
nub ([OpenSpec] -> [OpenSpec]) -> [OpenSpec] -> [OpenSpec]
forall a b. (a -> b) -> a -> b
$
                   [OpenSpec]
ops_ [OpenSpec] -> [OpenSpec] -> [OpenSpec]
forall a. [a] -> [a] -> [a]
++ -- N.B. js has been name-resolved already
                   [ModuleName -> ModuleName -> OpenSpec
OQualif ModuleName
i ModuleName
j | (ModuleName
i,ModuleName
j) <- [(ModuleName, ModuleName)]
ops] [OpenSpec] -> [OpenSpec] -> [OpenSpec]
forall a. [a] -> [a] -> [a]
++
                   [OpenSpec
o | OpenSpec
o <- [OpenSpec]
ops0, ModuleName -> [ModuleName] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
notElem (OpenSpec -> ModuleName
openedModule OpenSpec
o) [ModuleName]
infs] [OpenSpec] -> [OpenSpec] -> [OpenSpec]
forall a. [a] -> [a] -> [a]
++
                   [ModuleName -> ModuleName -> OpenSpec
OQualif ModuleName
i ModuleName
i | ModuleName
i <- [ModuleName]
insts] [OpenSpec] -> [OpenSpec] -> [OpenSpec]
forall a. [a] -> [a] -> [a]
++
                   [ModuleName -> OpenSpec
OSimple ModuleName
i   | ModuleName
i <- [ModuleName]
insts]

      --- check if me is incomplete
      let fs1 :: Options
fs1 = Options
fs Options -> Options -> Options
`addOptions` Options
fs_                           -- new flags have priority
      let js0 :: Map Ident Info
js0 = (Ident -> Info -> Maybe Info) -> Map Ident Info -> Map Ident Info
forall k a b. (k -> a -> Maybe b) -> Map k a -> Map k b
Map.mapMaybeWithKey (\Ident
c Info
j -> if MInclude -> Ident -> Bool
isInherited MInclude
incl Ident
c
                                               then Info -> Maybe Info
forall a. a -> Maybe a
Just (String -> Info -> Info
globalizeLoc String
fpath Info
j)
                                               else Maybe Info
forall a. Maybe a
Nothing)
                                    Map Ident Info
js
      let js1 :: Map Ident Info
js1 = Map Ident Info -> Map Ident Info -> Map Ident Info
forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union Map Ident Info
js0 Map Ident Info
js_
      let med1 :: [ModuleName]
med1= [ModuleName] -> [ModuleName]
forall a. Eq a => [a] -> [a]
nub (ModuleName
ext ModuleName -> [ModuleName] -> [ModuleName]
forall a. a -> [a] -> [a]
: [ModuleName]
infs [ModuleName] -> [ModuleName] -> [ModuleName]
forall a. [a] -> [a] -> [a]
++ [ModuleName]
insts [ModuleName] -> [ModuleName] -> [ModuleName]
forall a. [a] -> [a] -> [a]
++ [ModuleName]
med_)
      ModuleInfo -> Check ModuleInfo
forall (m :: * -> *) a. Monad m => a -> m a
return (ModuleInfo -> Check ModuleInfo) -> ModuleInfo -> Check ModuleInfo
forall a b. (a -> b) -> a -> b
$ ModuleType
-> ModuleStatus
-> Options
-> [(ModuleName, MInclude)]
-> Maybe (ModuleName, MInclude, [(ModuleName, ModuleName)])
-> [OpenSpec]
-> [ModuleName]
-> String
-> Maybe (Array Int Sequence)
-> Map Ident Info
-> ModuleInfo
ModInfo ModuleType
mt0 ModuleStatus
stat' Options
fs1 [(ModuleName, MInclude)]
me Maybe (ModuleName, MInclude, [(ModuleName, ModuleName)])
forall a. Maybe a
Nothing [OpenSpec]
ops1 [ModuleName]
med1 String
msrc_ Maybe (Array Int Sequence)
env_ Map Ident Info
js1

  SourceModule -> Check SourceModule
forall (m :: * -> *) a. Monad m => a -> m a
return (ModuleName
i,ModuleInfo
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 :: Grammar ->
             Bool -> (Module,Ident -> Bool) -> ModuleName ->
             Map.Map Ident Info -> Check (Map.Map Ident Info)
extendMod :: SourceGrammar
-> Bool
-> (SourceModule, Ident -> Bool)
-> ModuleName
-> Map Ident Info
-> Check (Map Ident Info)
extendMod SourceGrammar
gr Bool
isCompl ((ModuleName
name,ModuleInfo
mi),Ident -> Bool
cond) ModuleName
base Map Ident Info
new = (Map Ident Info -> (Ident, Info) -> Check (Map Ident Info))
-> Map Ident Info -> [(Ident, Info)] -> Check (Map Ident Info)
forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldM Map Ident Info -> (Ident, Info) -> Check (Map Ident Info)
try Map Ident Info
new ([(Ident, Info)] -> Check (Map Ident Info))
-> [(Ident, Info)] -> Check (Map Ident Info)
forall a b. (a -> b) -> a -> b
$ Map Ident Info -> [(Ident, Info)]
forall k a. Map k a -> [(k, a)]
Map.toList (ModuleInfo -> Map Ident Info
jments ModuleInfo
mi)
  where
    try :: Map Ident Info -> (Ident, Info) -> Check (Map Ident Info)
try Map Ident Info
new (Ident
c,Info
i0)
      | Bool -> Bool
not (Ident -> Bool
cond Ident
c) = Map Ident Info -> Check (Map Ident Info)
forall (m :: * -> *) a. Monad m => a -> m a
return Map Ident Info
new
      | Bool
otherwise    = case Ident -> Map Ident Info -> Maybe Info
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Ident
c Map Ident Info
new of
                         Just Info
j -> case ModuleName -> Info -> Info -> Err Info
unifyAnyInfo ModuleName
name Info
i Info
j of
                                     Ok Info
k  -> Map Ident Info -> Check (Map Ident Info)
forall (m :: * -> *) a. Monad m => a -> m a
return (Map Ident Info -> Check (Map Ident Info))
-> Map Ident Info -> Check (Map Ident Info)
forall a b. (a -> b) -> a -> b
$ Ident -> Info -> Map Ident Info -> Map Ident Info
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert Ident
c Info
k Map Ident Info
new
                                     Bad String
_ -> do (ModuleName
base,Info
j) <- case Info
j of
                                                               AnyInd Bool
_ ModuleName
m -> SourceGrammar -> QIdent -> Check (ModuleName, Info)
forall (m :: * -> *).
ErrorMonad m =>
SourceGrammar -> QIdent -> m (ModuleName, Info)
lookupOrigInfo SourceGrammar
gr (ModuleName
m,Ident
c)
                                                               Info
_          -> (ModuleName, Info) -> Check (ModuleName, Info)
forall (m :: * -> *) a. Monad m => a -> m a
return (ModuleName
base,Info
j)
                                                 (ModuleName
name,Info
i) <- case Info
i of
                                                               AnyInd Bool
_ ModuleName
m -> SourceGrammar -> QIdent -> Check (ModuleName, Info)
forall (m :: * -> *).
ErrorMonad m =>
SourceGrammar -> QIdent -> m (ModuleName, Info)
lookupOrigInfo SourceGrammar
gr (ModuleName
m,Ident
c)
                                                               Info
_          -> (ModuleName, Info) -> Check (ModuleName, Info)
forall (m :: * -> *) a. Monad m => a -> m a
return (ModuleName
name,Info
i)
                                                 Doc -> Check (Map Ident Info)
forall a. Doc -> Check a
checkError (String
"cannot unify the information" String -> Doc -> Doc
forall a1 a2. (Pretty a1, Pretty a2) => a1 -> a2 -> Doc
$$
                                                             Int -> Doc -> Doc
forall a. Pretty a => Int -> a -> Doc
nest Int
4 (TermPrintQual -> (Ident, Info) -> Doc
forall a2. Pretty a2 => TermPrintQual -> (a2, Info) -> Doc
ppJudgement TermPrintQual
Qualified (Ident
c,Info
i)) Doc -> Doc -> Doc
forall a1 a2. (Pretty a1, Pretty a2) => a1 -> a2 -> Doc
$$
                                                             String
"in module" String -> ModuleName -> Doc
forall a1 a2. (Pretty a1, Pretty a2) => a1 -> a2 -> Doc
<+> ModuleName
name Doc -> String -> Doc
forall a1 a2. (Pretty a1, Pretty a2) => a1 -> a2 -> Doc
<+> String
"with" Doc -> Doc -> Doc
forall a1 a2. (Pretty a1, Pretty a2) => a1 -> a2 -> Doc
$$
                                                             Int -> Doc -> Doc
forall a. Pretty a => Int -> a -> Doc
nest Int
4 (TermPrintQual -> (Ident, Info) -> Doc
forall a2. Pretty a2 => TermPrintQual -> (a2, Info) -> Doc
ppJudgement TermPrintQual
Qualified (Ident
c,Info
j)) Doc -> Doc -> Doc
forall a1 a2. (Pretty a1, Pretty a2) => a1 -> a2 -> Doc
$$
                                                             String
"in module" String -> ModuleName -> Doc
forall a1 a2. (Pretty a1, Pretty a2) => a1 -> a2 -> Doc
<+> ModuleName
base)
                         Maybe Info
Nothing-> if Bool
isCompl
                                     then Map Ident Info -> Check (Map Ident Info)
forall (m :: * -> *) a. Monad m => a -> m a
return (Map Ident Info -> Check (Map Ident Info))
-> Map Ident Info -> Check (Map Ident Info)
forall a b. (a -> b) -> a -> b
$ Ident -> Info -> Map Ident Info -> Map Ident Info
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert Ident
c (ModuleName -> Info -> Info
indirInfo ModuleName
name Info
i) Map Ident Info
new
                                     else Map Ident Info -> Check (Map Ident Info)
forall (m :: * -> *) a. Monad m => a -> m a
return (Map Ident Info -> Check (Map Ident Info))
-> Map Ident Info -> Check (Map Ident Info)
forall a b. (a -> b) -> a -> b
$ Ident -> Info -> Map Ident Info -> Map Ident Info
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert Ident
c Info
i Map Ident Info
new
      where
        i :: Info
i = String -> Info -> Info
globalizeLoc (ModuleInfo -> String
msrc ModuleInfo
mi) Info
i0

    indirInfo :: ModuleName -> Info -> Info
    indirInfo :: ModuleName -> Info -> Info
indirInfo ModuleName
n Info
info = Bool -> ModuleName -> Info
AnyInd Bool
b ModuleName
n' where
      (Bool
b,ModuleName
n') = case Info
info of
        ResValue L Type
_ -> (Bool
True,ModuleName
n)
        ResParam Maybe (L [Param])
_ Maybe [Type]
_ -> (Bool
True,ModuleName
n)
        AbsFun Maybe (L Type)
_ Maybe Int
_ Maybe [L Equation]
Nothing Maybe Bool
_ -> (Bool
True,ModuleName
n)
        AnyInd Bool
b ModuleName
k -> (Bool
b,ModuleName
k)
        Info
_ -> (Bool
False,ModuleName
n) ---- canonical in Abs

globalizeLoc :: String -> Info -> Info
globalizeLoc String
fpath Info
i =
  case Info
i of
    AbsCat Maybe (L Context)
mc             -> Maybe (L Context) -> Info
AbsCat ((L Context -> L Context) -> Maybe (L Context) -> Maybe (L Context)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap L Context -> L Context
forall a. L a -> L a
gl Maybe (L Context)
mc)
    AbsFun Maybe (L Type)
mt Maybe Int
ma Maybe [L Equation]
md Maybe Bool
moper -> Maybe (L Type)
-> Maybe Int -> Maybe [L Equation] -> Maybe Bool -> Info
AbsFun ((L Type -> L Type) -> Maybe (L Type) -> Maybe (L Type)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap L Type -> L Type
forall a. L a -> L a
gl Maybe (L Type)
mt) Maybe Int
ma (([L Equation] -> [L Equation])
-> Maybe [L Equation] -> Maybe [L Equation]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((L Equation -> L Equation) -> [L Equation] -> [L Equation]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap L Equation -> L Equation
forall a. L a -> L a
gl) Maybe [L Equation]
md) Maybe Bool
moper
    ResParam Maybe (L [Param])
mt Maybe [Type]
mv        -> Maybe (L [Param]) -> Maybe [Type] -> Info
ResParam ((L [Param] -> L [Param]) -> Maybe (L [Param]) -> Maybe (L [Param])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap L [Param] -> L [Param]
forall a. L a -> L a
gl Maybe (L [Param])
mt) Maybe [Type]
mv
    ResValue L Type
t            -> L Type -> Info
ResValue (L Type -> L Type
forall a. L a -> L a
gl L Type
t)
    ResOper Maybe (L Type)
mt Maybe (L Type)
m          -> Maybe (L Type) -> Maybe (L Type) -> Info
ResOper ((L Type -> L Type) -> Maybe (L Type) -> Maybe (L Type)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap L Type -> L Type
forall a. L a -> L a
gl Maybe (L Type)
mt) ((L Type -> L Type) -> Maybe (L Type) -> Maybe (L Type)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap L Type -> L Type
forall a. L a -> L a
gl Maybe (L Type)
m)
    ResOverload [ModuleName]
ms [(L Type, L Type)]
os     -> [ModuleName] -> [(L Type, L Type)] -> Info
ResOverload [ModuleName]
ms (((L Type, L Type) -> (L Type, L Type))
-> [(L Type, L Type)] -> [(L Type, L Type)]
forall a b. (a -> b) -> [a] -> [b]
map (\(L Type
x,L Type
y) -> (L Type -> L Type
forall a. L a -> L a
gl L Type
x,L Type -> L Type
forall a. L a -> L a
gl L Type
y)) [(L Type, L Type)]
os)
    CncCat Maybe (L Type)
mc Maybe (L Type)
md Maybe (L Type)
mr Maybe (L Type)
mp Maybe PMCFG
mpmcfg-> Maybe (L Type)
-> Maybe (L Type)
-> Maybe (L Type)
-> Maybe (L Type)
-> Maybe PMCFG
-> Info
CncCat ((L Type -> L Type) -> Maybe (L Type) -> Maybe (L Type)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap L Type -> L Type
forall a. L a -> L a
gl Maybe (L Type)
mc) ((L Type -> L Type) -> Maybe (L Type) -> Maybe (L Type)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap L Type -> L Type
forall a. L a -> L a
gl Maybe (L Type)
md) ((L Type -> L Type) -> Maybe (L Type) -> Maybe (L Type)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap L Type -> L Type
forall a. L a -> L a
gl Maybe (L Type)
mr) ((L Type -> L Type) -> Maybe (L Type) -> Maybe (L Type)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap L Type -> L Type
forall a. L a -> L a
gl Maybe (L Type)
mp) Maybe PMCFG
mpmcfg
    CncFun Maybe (Ident, Context, Type)
m  Maybe (L Type)
mt Maybe (L Type)
md Maybe PMCFG
mpmcfg-> Maybe (Ident, Context, Type)
-> Maybe (L Type) -> Maybe (L Type) -> Maybe PMCFG -> Info
CncFun Maybe (Ident, Context, Type)
m ((L Type -> L Type) -> Maybe (L Type) -> Maybe (L Type)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap L Type -> L Type
forall a. L a -> L a
gl Maybe (L Type)
mt) ((L Type -> L Type) -> Maybe (L Type) -> Maybe (L Type)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap L Type -> L Type
forall a. L a -> L a
gl Maybe (L Type)
md) Maybe PMCFG
mpmcfg
    AnyInd Bool
b ModuleName
m            -> Bool -> ModuleName -> Info
AnyInd Bool
b ModuleName
m
  where
    gl :: L a -> L a
gl (L Location
loc0 a
x) = Location
loc Location -> L a -> L a
`seq` Location -> a -> L a
forall a. Location -> a -> L a
L (String -> Location -> Location
External String
fpath Location
loc) a
x
      where
        loc :: Location
loc = case Location
loc0 of
                External String
_ Location
loc -> Location
loc
                Location
loc            -> Location
loc

unifyAnyInfo :: ModuleName -> Info -> Info -> Err Info
unifyAnyInfo :: ModuleName -> Info -> Info -> Err Info
unifyAnyInfo ModuleName
m Info
i Info
j = case (Info
i,Info
j) of
  (AbsCat Maybe (L Context)
mc1, AbsCat Maybe (L Context)
mc2) ->
    (Maybe (L Context) -> Info) -> Err (Maybe (L Context)) -> Err Info
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM Maybe (L Context) -> Info
AbsCat (Maybe (L Context) -> Maybe (L Context) -> Err (Maybe (L Context))
forall a. Eq a => Maybe (L a) -> Maybe (L a) -> Err (Maybe (L a))
unifyMaybeL Maybe (L Context)
mc1 Maybe (L Context)
mc2)
  (AbsFun Maybe (L Type)
mt1 Maybe Int
ma1 Maybe [L Equation]
md1 Maybe Bool
moper1, AbsFun Maybe (L Type)
mt2 Maybe Int
ma2 Maybe [L Equation]
md2 Maybe Bool
moper2) ->
    (Maybe (L Type)
 -> Maybe Int -> Maybe [L Equation] -> Maybe Bool -> Info)
-> Err (Maybe (L Type))
-> Err (Maybe Int)
-> Err (Maybe [L Equation])
-> Err (Maybe Bool)
-> Err Info
forall (m :: * -> *) a1 a2 a3 a4 r.
Monad m =>
(a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r
liftM4 Maybe (L Type)
-> Maybe Int -> Maybe [L Equation] -> Maybe Bool -> Info
AbsFun (Maybe (L Type) -> Maybe (L Type) -> Err (Maybe (L Type))
forall a. Eq a => Maybe (L a) -> Maybe (L a) -> Err (Maybe (L a))
unifyMaybeL Maybe (L Type)
mt1 Maybe (L Type)
mt2) (Maybe Int -> Maybe Int -> Err (Maybe Int)
unifAbsArrity Maybe Int
ma1 Maybe Int
ma2) (Maybe [L Equation]
-> Maybe [L Equation] -> Err (Maybe [L Equation])
unifAbsDefs Maybe [L Equation]
md1 Maybe [L Equation]
md2) (Maybe Bool -> Maybe Bool -> Err (Maybe Bool)
forall a (m :: * -> *).
(Eq a, MonadFail m) =>
Maybe a -> Maybe a -> m (Maybe a)
unifyMaybe Maybe Bool
moper1 Maybe Bool
moper2) -- adding defs

  (ResParam Maybe (L [Param])
mt1 Maybe [Type]
mv1, ResParam Maybe (L [Param])
mt2 Maybe [Type]
mv2) ->
    (Maybe (L [Param]) -> Maybe [Type] -> Info)
-> Err (Maybe (L [Param])) -> Err (Maybe [Type]) -> Err Info
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 Maybe (L [Param]) -> Maybe [Type] -> Info
ResParam (Maybe (L [Param]) -> Maybe (L [Param]) -> Err (Maybe (L [Param]))
forall a. Eq a => Maybe (L a) -> Maybe (L a) -> Err (Maybe (L a))
unifyMaybeL Maybe (L [Param])
mt1 Maybe (L [Param])
mt2) (Maybe [Type] -> Maybe [Type] -> Err (Maybe [Type])
forall a (m :: * -> *).
(Eq a, MonadFail m) =>
Maybe a -> Maybe a -> m (Maybe a)
unifyMaybe Maybe [Type]
mv1 Maybe [Type]
mv2)
  (ResValue (L Location
l1 Type
t1), ResValue (L Location
l2 Type
t2))
      | Type
t1Type -> Type -> Bool
forall a. Eq a => a -> a -> Bool
==Type
t2    -> Info -> Err Info
forall (m :: * -> *) a. Monad m => a -> m a
return (L Type -> Info
ResValue (Location -> Type -> L Type
forall a. Location -> a -> L a
L Location
l1 Type
t1))
      | Bool
otherwise -> String -> Err Info
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
""
  (Info
_, ResOverload [ModuleName]
ms [(L Type, L Type)]
t) | ModuleName -> [ModuleName] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
elem ModuleName
m [ModuleName]
ms ->
    Info -> Err Info
forall (m :: * -> *) a. Monad m => a -> m a
return (Info -> Err Info) -> Info -> Err Info
forall a b. (a -> b) -> a -> b
$ [ModuleName] -> [(L Type, L Type)] -> Info
ResOverload [ModuleName]
ms [(L Type, L Type)]
t
  (ResOper Maybe (L Type)
mt1 Maybe (L Type)
m1, ResOper Maybe (L Type)
mt2 Maybe (L Type)
m2) ->
    (Maybe (L Type) -> Maybe (L Type) -> Info)
-> Err (Maybe (L Type)) -> Err (Maybe (L Type)) -> Err Info
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 Maybe (L Type) -> Maybe (L Type) -> Info
ResOper (Maybe (L Type) -> Maybe (L Type) -> Err (Maybe (L Type))
forall a. Eq a => Maybe (L a) -> Maybe (L a) -> Err (Maybe (L a))
unifyMaybeL Maybe (L Type)
mt1 Maybe (L Type)
mt2) (Maybe (L Type) -> Maybe (L Type) -> Err (Maybe (L Type))
forall a. Eq a => Maybe (L a) -> Maybe (L a) -> Err (Maybe (L a))
unifyMaybeL Maybe (L Type)
m1 Maybe (L Type)
m2)

  (CncCat Maybe (L Type)
mc1 Maybe (L Type)
md1 Maybe (L Type)
mr1 Maybe (L Type)
mp1 Maybe PMCFG
mpmcfg1, CncCat Maybe (L Type)
mc2 Maybe (L Type)
md2 Maybe (L Type)
mr2 Maybe (L Type)
mp2 Maybe PMCFG
mpmcfg2) ->
    (Maybe (L Type)
 -> Maybe (L Type)
 -> Maybe (L Type)
 -> Maybe (L Type)
 -> Maybe PMCFG
 -> Info)
-> Err (Maybe (L Type))
-> Err (Maybe (L Type))
-> Err (Maybe (L Type))
-> Err (Maybe (L Type))
-> Err (Maybe PMCFG)
-> Err Info
forall (m :: * -> *) a1 a2 a3 a4 a5 r.
Monad m =>
(a1 -> a2 -> a3 -> a4 -> a5 -> r)
-> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r
liftM5 Maybe (L Type)
-> Maybe (L Type)
-> Maybe (L Type)
-> Maybe (L Type)
-> Maybe PMCFG
-> Info
CncCat (Maybe (L Type) -> Maybe (L Type) -> Err (Maybe (L Type))
forall a. Eq a => Maybe (L a) -> Maybe (L a) -> Err (Maybe (L a))
unifyMaybeL Maybe (L Type)
mc1 Maybe (L Type)
mc2) (Maybe (L Type) -> Maybe (L Type) -> Err (Maybe (L Type))
forall a. Eq a => Maybe (L a) -> Maybe (L a) -> Err (Maybe (L a))
unifyMaybeL Maybe (L Type)
md1 Maybe (L Type)
md2) (Maybe (L Type) -> Maybe (L Type) -> Err (Maybe (L Type))
forall a. Eq a => Maybe (L a) -> Maybe (L a) -> Err (Maybe (L a))
unifyMaybeL Maybe (L Type)
mr1 Maybe (L Type)
mr2) (Maybe (L Type) -> Maybe (L Type) -> Err (Maybe (L Type))
forall a. Eq a => Maybe (L a) -> Maybe (L a) -> Err (Maybe (L a))
unifyMaybeL Maybe (L Type)
mp1 Maybe (L Type)
mp2)  (Maybe PMCFG -> Maybe PMCFG -> Err (Maybe PMCFG)
forall a (m :: * -> *).
(Eq a, MonadFail m) =>
Maybe a -> Maybe a -> m (Maybe a)
unifyMaybe Maybe PMCFG
mpmcfg1 Maybe PMCFG
mpmcfg2)
  (CncFun Maybe (Ident, Context, Type)
m Maybe (L Type)
mt1 Maybe (L Type)
md1 Maybe PMCFG
mpmcfg1, CncFun Maybe (Ident, Context, Type)
_ Maybe (L Type)
mt2 Maybe (L Type)
md2 Maybe PMCFG
mpmcfg2) ->
    (Maybe (L Type) -> Maybe (L Type) -> Maybe PMCFG -> Info)
-> Err (Maybe (L Type))
-> Err (Maybe (L Type))
-> Err (Maybe PMCFG)
-> Err Info
forall (m :: * -> *) a1 a2 a3 r.
Monad m =>
(a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
liftM3 (Maybe (Ident, Context, Type)
-> Maybe (L Type) -> Maybe (L Type) -> Maybe PMCFG -> Info
CncFun Maybe (Ident, Context, Type)
m) (Maybe (L Type) -> Maybe (L Type) -> Err (Maybe (L Type))
forall a. Eq a => Maybe (L a) -> Maybe (L a) -> Err (Maybe (L a))
unifyMaybeL Maybe (L Type)
mt1 Maybe (L Type)
mt2) (Maybe (L Type) -> Maybe (L Type) -> Err (Maybe (L Type))
forall a. Eq a => Maybe (L a) -> Maybe (L a) -> Err (Maybe (L a))
unifyMaybeL Maybe (L Type)
md1 Maybe (L Type)
md2) (Maybe PMCFG -> Maybe PMCFG -> Err (Maybe PMCFG)
forall a (m :: * -> *).
(Eq a, MonadFail m) =>
Maybe a -> Maybe a -> m (Maybe a)
unifyMaybe Maybe PMCFG
mpmcfg1 Maybe PMCFG
mpmcfg2)

  (AnyInd Bool
b1 ModuleName
m1, AnyInd Bool
b2 ModuleName
m2) -> do
    Bool -> String -> Err ()
forall (m :: * -> *). ErrorMonad m => Bool -> String -> m ()
testErr (Bool
b1 Bool -> Bool -> Bool
forall a. Eq a => a -> a -> Bool
== Bool
b2) (String -> Err ()) -> String -> Err ()
forall a b. (a -> b) -> a -> b
$ String
"indirection status"
    Bool -> String -> Err ()
forall (m :: * -> *). ErrorMonad m => Bool -> String -> m ()
testErr (ModuleName
m1 ModuleName -> ModuleName -> Bool
forall a. Eq a => a -> a -> Bool
== ModuleName
m2) (String -> Err ()) -> String -> Err ()
forall a b. (a -> b) -> a -> b
$ String
"different sources of indirection"
    Info -> Err Info
forall (m :: * -> *) a. Monad m => a -> m a
return Info
i

  (Info, Info)
_ -> String -> Err Info
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"informations"

-- | this is what happens when matching two values in the same module
unifyMaybeL :: Eq a => Maybe (L a) -> Maybe (L a) -> Err (Maybe (L a))
unifyMaybeL :: Maybe (L a) -> Maybe (L a) -> Err (Maybe (L a))
unifyMaybeL = (L a -> a) -> Maybe (L a) -> Maybe (L a) -> Err (Maybe (L a))
forall b (m :: * -> *) a.
(Eq b, MonadFail m) =>
(a -> b) -> Maybe a -> Maybe a -> m (Maybe a)
unifyMaybeBy L a -> a
forall a. L a -> a
unLoc

unifAbsArrity :: Maybe Int -> Maybe Int -> Err (Maybe Int)
unifAbsArrity :: Maybe Int -> Maybe Int -> Err (Maybe Int)
unifAbsArrity = Maybe Int -> Maybe Int -> Err (Maybe Int)
forall a (m :: * -> *).
(Eq a, MonadFail m) =>
Maybe a -> Maybe a -> m (Maybe a)
unifyMaybe

unifAbsDefs :: Maybe [L Equation] -> Maybe [L Equation] -> Err (Maybe [L Equation])
unifAbsDefs :: Maybe [L Equation]
-> Maybe [L Equation] -> Err (Maybe [L Equation])
unifAbsDefs (Just [L Equation]
xs) (Just [L Equation]
ys) = Maybe [L Equation] -> Err (Maybe [L Equation])
forall (m :: * -> *) a. Monad m => a -> m a
return ([L Equation] -> Maybe [L Equation]
forall a. a -> Maybe a
Just ([L Equation]
xs [L Equation] -> [L Equation] -> [L Equation]
forall a. [a] -> [a] -> [a]
++ [L Equation]
ys))
unifAbsDefs Maybe [L Equation]
Nothing   Maybe [L Equation]
Nothing   = Maybe [L Equation] -> Err (Maybe [L Equation])
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe [L Equation]
forall a. Maybe a
Nothing
unifAbsDefs Maybe [L Equation]
_         Maybe [L Equation]
_         = String -> Err (Maybe [L Equation])
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
""