{-# LANGUAGE NoImplicitPrelude #-}
module Control.Distributed.Process.Extras.Internal.Queue.SeqQ
  ( SeqQ
  , empty
  , isEmpty
  , singleton
  , enqueue
  , dequeue
  , peek
  , filter
  , size
  )
  where

-- A simple FIFO queue implementation backed by @Data.Sequence@.
import Prelude hiding (filter, length)
import Data.Sequence
  ( Seq
  , ViewR(..)
  , (<|)
  , viewr
  , length
  )
import qualified Data.Sequence as Seq (empty, singleton, null, filter)

newtype SeqQ a = SeqQ { forall a. SeqQ a -> Seq a
q :: Seq a }
  deriving (Int -> SeqQ a -> ShowS
[SeqQ a] -> ShowS
SeqQ a -> String
(Int -> SeqQ a -> ShowS)
-> (SeqQ a -> String) -> ([SeqQ a] -> ShowS) -> Show (SeqQ a)
forall a. Show a => Int -> SeqQ a -> ShowS
forall a. Show a => [SeqQ a] -> ShowS
forall a. Show a => SeqQ a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> SeqQ a -> ShowS
showsPrec :: Int -> SeqQ a -> ShowS
$cshow :: forall a. Show a => SeqQ a -> String
show :: SeqQ a -> String
$cshowList :: forall a. Show a => [SeqQ a] -> ShowS
showList :: [SeqQ a] -> ShowS
Show)

instance Eq a => Eq (SeqQ a) where
  SeqQ a
a == :: SeqQ a -> SeqQ a -> Bool
== SeqQ a
b = (SeqQ a -> Seq a
forall a. SeqQ a -> Seq a
q SeqQ a
a) Seq a -> Seq a -> Bool
forall a. Eq a => a -> a -> Bool
== (SeqQ a -> Seq a
forall a. SeqQ a -> Seq a
q SeqQ a
b)

{-# INLINE empty #-}
empty :: SeqQ a
empty :: forall a. SeqQ a
empty = Seq a -> SeqQ a
forall a. Seq a -> SeqQ a
SeqQ Seq a
forall a. Seq a
Seq.empty

isEmpty :: SeqQ a -> Bool
isEmpty :: forall a. SeqQ a -> Bool
isEmpty = Seq a -> Bool
forall a. Seq a -> Bool
Seq.null (Seq a -> Bool) -> (SeqQ a -> Seq a) -> SeqQ a -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SeqQ a -> Seq a
forall a. SeqQ a -> Seq a
q

{-# INLINE singleton #-}
singleton :: a -> SeqQ a
singleton :: forall a. a -> SeqQ a
singleton = Seq a -> SeqQ a
forall a. Seq a -> SeqQ a
SeqQ (Seq a -> SeqQ a) -> (a -> Seq a) -> a -> SeqQ a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Seq a
forall a. a -> Seq a
Seq.singleton

{-# INLINE enqueue #-}
enqueue :: SeqQ a -> a -> SeqQ a
enqueue :: forall a. SeqQ a -> a -> SeqQ a
enqueue SeqQ a
s a
a = Seq a -> SeqQ a
forall a. Seq a -> SeqQ a
SeqQ (Seq a -> SeqQ a) -> Seq a -> SeqQ a
forall a b. (a -> b) -> a -> b
$ a
a a -> Seq a -> Seq a
forall a. a -> Seq a -> Seq a
<| SeqQ a -> Seq a
forall a. SeqQ a -> Seq a
q SeqQ a
s

{-# INLINE dequeue #-}
dequeue :: SeqQ a -> Maybe (a, SeqQ a)
dequeue :: forall a. SeqQ a -> Maybe (a, SeqQ a)
dequeue SeqQ a
s = Maybe (a, SeqQ a)
-> (ViewR a -> Maybe (a, SeqQ a))
-> Maybe (ViewR a)
-> Maybe (a, SeqQ a)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Maybe (a, SeqQ a)
forall a. Maybe a
Nothing (\(Seq a
s' :> a
a) -> (a, SeqQ a) -> Maybe (a, SeqQ a)
forall a. a -> Maybe a
Just (a
a, Seq a -> SeqQ a
forall a. Seq a -> SeqQ a
SeqQ Seq a
s')) (Maybe (ViewR a) -> Maybe (a, SeqQ a))
-> Maybe (ViewR a) -> Maybe (a, SeqQ a)
forall a b. (a -> b) -> a -> b
$ SeqQ a -> Maybe (ViewR a)
forall a. SeqQ a -> Maybe (ViewR a)
getR SeqQ a
s

{-# INLINE peek #-}
peek :: SeqQ a -> Maybe a
peek :: forall a. SeqQ a -> Maybe a
peek SeqQ a
s = Maybe a -> (ViewR a -> Maybe a) -> Maybe (ViewR a) -> Maybe a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Maybe a
forall a. Maybe a
Nothing (\(Seq a
_ :> a
a) -> a -> Maybe a
forall a. a -> Maybe a
Just a
a) (Maybe (ViewR a) -> Maybe a) -> Maybe (ViewR a) -> Maybe a
forall a b. (a -> b) -> a -> b
$ SeqQ a -> Maybe (ViewR a)
forall a. SeqQ a -> Maybe (ViewR a)
getR SeqQ a
s

{-# INLINE size #-}
size :: SeqQ a -> Int
size :: forall a. SeqQ a -> Int
size = Seq a -> Int
forall a. Seq a -> Int
length (Seq a -> Int) -> (SeqQ a -> Seq a) -> SeqQ a -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SeqQ a -> Seq a
forall a. SeqQ a -> Seq a
q

filter :: (a -> Bool) -> SeqQ a -> SeqQ a
filter :: forall a. (a -> Bool) -> SeqQ a -> SeqQ a
filter a -> Bool
c SeqQ a
s = Seq a -> SeqQ a
forall a. Seq a -> SeqQ a
SeqQ (Seq a -> SeqQ a) -> Seq a -> SeqQ a
forall a b. (a -> b) -> a -> b
$ (a -> Bool) -> Seq a -> Seq a
forall a. (a -> Bool) -> Seq a -> Seq a
Seq.filter a -> Bool
c (SeqQ a -> Seq a
forall a. SeqQ a -> Seq a
q SeqQ a
s)

getR :: SeqQ a -> Maybe (ViewR a)
getR :: forall a. SeqQ a -> Maybe (ViewR a)
getR SeqQ a
s =
  case (Seq a -> ViewR a
forall a. Seq a -> ViewR a
viewr (SeqQ a -> Seq a
forall a. SeqQ a -> Seq a
q SeqQ a
s)) of
    ViewR a
EmptyR -> Maybe (ViewR a)
forall a. Maybe a
Nothing
    ViewR a
a      -> ViewR a -> Maybe (ViewR a)
forall a. a -> Maybe a
Just ViewR a
a