{-# LANGUAGE NoMonomorphismRestriction #-}

module Data.ChangeSet
    ( Set
    , changes
    , forget
    , insert
    , delete
    , size
    , empty
    , member
    , notMember
    , fromList
    , fromDistinctAscList
    , toList
    , (\\)
    ) where

import qualified Data.Set as S

import Data.Binary
import Data.Data

------------------------------

data Set k = ChangeSet
    { toSet   :: S.Set k 
    , changes :: [k]
    }
 deriving (Show, Read, Typeable, Data)

forget (ChangeSet m _) = ChangeSet m []

fromSet s = ChangeSet s (S.toList s)

----------------------

insert k (ChangeSet m c) = ChangeSet (S.insert k m) (k: c)

delete k (ChangeSet m c) = ChangeSet (S.delete k m) (k: c)


size        = S.size . toSet

member k    = S.member k . toSet

notMember k = S.notMember k . toSet

toList      = S.toList . toSet


empty       = fromSet $ S.empty

fromList    = fromSet . S.fromList

fromDistinctAscList = fromSet . S.fromDistinctAscList


a \\ b      = fromSet (toSet a S.\\ toSet b)


instance (Ord k, Binary k) => Binary (Set k) where
    put = put . toSet
    get = fmap fromSet get