content: module Database.Datalog.Relation (
    Relation(..)
    ) where
  
  import Data.Hashable
  import Data.Text ( Text, unpack )
  import Text.Printf
  
  import Database.Datalog.Adornment
  
  -- Let Relation be user exposed, use this for internal versions:
  --
  -- data InternalRelation = InternalRelation BindingPattern Text
  --                       | MagicRelation BindingPattern Text
  
  
  -- | A wrapper to expose the relation name to callers without
  -- revealing details of its implementation
  data Relation = Relation Text
                | MagicRelation BindingPattern Text
                deriving (Eq, Ord)
  
  instance Show Relation where
    show (Relation t) = unpack t
    show (MagicRelation bs t) = printf "Magic_%s[%s]" (unpack t) (show bs)
  
  -- FIXME: May need a new relation that tracks its binding pattern,
  -- too.  This is probably important for cases where the same relation
  -- appears in the same body literal with different binding patterns in
  -- a given rule.  These seem like they should be referencing different
  -- tables...
  --
  -- The transformRules step will have to be the one to do the
  -- translation
  
  instance Hashable Relation where
    hashWithSalt s (Relation t) =
      s `hashWithSalt` t `hashWithSalt` (99 :: Int)
    hashWithSalt s (MagicRelation p t) =
      s `hashWithSalt` p `hashWithSalt` t `hashWithSalt` (2 :: Int)
  