module Queue (Queue, empty, isEmpty, enqueue, dequeue) where
import Test.QuickCheck
import Test.QuickCheck.Poly (A)

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

empty :: Queue a
empty = Queue []

isEmpty :: Queue a -> Bool
isEmpty (Queue []) = True
isEmpty _ = False

enqueue :: a -> Queue a -> Queue a
enqueue x (Queue xs) = Queue (xs ++ [x])

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

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


{- 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'