{-# LANGUAGE CPP, DeriveDataTypeable #-}
module Language.Java.Paragon.TypeCheck.Actors where

--import Data.List (intersect)

import Language.Java.Paragon.Syntax

#ifdef BASE4
import Data.Data
#else
import Data.Generics (Data(..),Typeable(..))
#endif


-- An actor id is either known and unique (Fresh), or
-- it is an alias of some actor. If we know statically
-- which actor(s) it can represent, we list that.
-- Otherwise an empty list means it could be an alias
-- of any other actor.
data ActorId = Fresh Int | Alias Int | ActorTPVar Ident
 deriving (Show, Eq, Ord, Data, Typeable)

infix 5 `unifies`, `unify`

-- Precondition: No ActorTPVars
unifies :: ActorId -> ActorId -> Bool
-- If we have the exact (fresh) ids, we can tell exactly
unifies (Fresh x) (Fresh y) = x == y 
unifies _ _ =  True
-- If either side is an alias, check if it could represent the fresh side.
--unifies (Alias x xs) (Fresh y) = null xs || y `elem` xs
--unifies (Fresh x) (Alias y ys) = null ys || x `elem` ys
-- If both are aliases, check if they could represent the same fresh actor.
--unifies (Alias x xs) (Alias y ys) = null xs || null ys || (not . null) (xs `intersect` ys)

unify :: [ActorId] -> [ActorId] -> Bool
unify xs ys = all (uncurry unifies) $ zip xs ys 

{-
equals :: ActorId -> ActorId -> Bool
equals (Fresh x)   (Fresh y)   = x == y
equals (Alias x _) (Alias y _) = x == y
equals _ _ = False

reprs :: ActorId -> [Int]
reprs (Fresh x) = [x]
reprs (Alias x xs) = x:xs
-}
getId :: ActorId -> Int
getId (Fresh x) = x
getId (Alias x) = x

{-
reprName :: ActorId -> Name
reprName (Fresh _ n)   = n
reprName (Alias _ _ n) = n
-}