module Queue where
import Test.QuickCheck
import Test.QuickCheck.Poly (A)

newtype Queue a = Queue [a]
  deriving (Eq, Show)

empty :: Queue a
empty = undefined

isEmpty :: Queue a -> Bool
isEmpty (Queue xs) = undefined

enqueue :: a -> Queue a -> Queue a
enqueue x (Queue xs) = undefined

dequeue :: Queue a -> (a, Queue a)
dequeue (Queue (x : xs)) = undefined

toList :: Queue a -> [a]
toList (Queue xs) = undefined


{- QuickCheck Tests -}

instance Arbitrary a => Arbitrary (Queue a) where
  arbitrary =
    do
      xs <- arbitrary
      return $ Queue xs

prop_isEmpty_empty = isEmpty empty

prop_isEmpty_enqueue x q = not (isEmpty (enqueue (x :: A) q))

prop_toList_enqueue x q = toList (enqueue x q) == toList q ++ [x :: A]

prop_toList_dequeue x q =
  not (isEmpty q) ==> (x :: A) : toList q' == toList q
  where (x, q') = dequeue q

prop_toList_ext q q' =
  toList q == toList q' ==> (q :: Queue A) == q'