io-sim: remove dependency on deque package

It doesn't seem to be well maintained.

Author: coot

io-sim/io-sim.cabal

@@ -56,7 +56,8 @@ library
                        Control.Monad.IOSimPOR.Internal,
                        Control.Monad.IOSimPOR.Types,
                        Control.Monad.IOSimPOR.QuickCheckUtils,
-                       Control.Monad.IOSimPOR.Timeout
+                       Control.Monad.IOSimPOR.Timeout,
+                       Data.Deque.Strict
   default-language:    Haskell2010
   other-extensions:    BangPatterns,
                        CPP,
@@ -79,7 +80,6 @@ library
                        io-classes       ^>=1.0,
                        exceptions        >=0.10,
                        containers,
-                       deque,
                        nothunks,
                        parallel,
                        psqueues          >=0.2 && <0.3,

io-sim/src/Control/Monad/IOSim/Internal.hs

@@ -55,10 +55,8 @@ import qualified Data.OrdPSQ as PSQ
 import           Data.Set (Set)
 import qualified Data.Set as Set
 import           Data.Time (UTCTime (..), fromGregorian)
-import           Deque.Strict (Deque)
-import qualified Deque.Strict as Deque
-
-import           GHC.Exts (fromList)
+import           Data.Deque.Strict (Deque)
+import qualified Data.Deque.Strict as Deque
 
 import           Control.Exception (NonTermination (..), assert, throw)
 import           Control.Monad (join, when)
@@ -828,7 +826,7 @@ unblockThreads !onlySTM !wakeup !simstate@SimState {runqueue, threads} =
     -- To preserve our invariants (that threadBlocked is correct)
     -- we update the runqueue and threads together here
     (unblocked, simstate {
-                  runqueue = runqueue <> fromList unblocked,
+                  runqueue = runqueue <> Deque.fromList unblocked,
                   threads  = threads'
                 })
   where

io-sim/src/Control/Monad/IOSim/STM.hs

@@ -21,8 +21,8 @@ import           Control.Monad.Class.MonadThrow
 
 import           Numeric.Natural (Natural)
 
-import           Deque.Strict (Deque)
-import qualified Deque.Strict as Deque
+import           Data.Deque.Strict (Deque)
+import qualified Data.Deque.Strict as Deque
 
 --
 -- Default TQueue implementation in terms of a 'TVar' (used by sim)

io-sim/src/Data/Deque/Strict.hs

@@ -0,0 +1,41 @@
+{-# LANGUAGE LambdaCase #-}
+
+-- | A minimal implementation of a strict deque.
+--
+module Data.Deque.Strict where
+
+import           Prelude hiding (head, init, tail)
+import           Data.Foldable (foldl', foldr')
+import qualified Data.List as List
+
+data Deque a = Deque ![a] ![a]
+
+instance Semigroup (Deque a) where
+    Deque as bs <> Deque as' bs' =
+      Deque as (bs' ++ reverse as' ++ bs)
+
+instance Monoid (Deque a) where
+    mempty = Deque [] []
+
+instance Foldable Deque where
+    foldr step init (Deque head tail) =
+      foldr step (foldl' (flip step) init tail) head
+    foldl' step init (Deque head tail) =
+      foldr' (flip step) (foldl' step init head) tail
+
+fromList :: [a] -> Deque a
+fromList as = Deque as []
+
+snoc :: a -> Deque a -> Deque a
+snoc a (Deque as bs) = Deque as (a : bs)
+
+uncons :: Deque a -> Maybe (a, Deque a)
+uncons = \case
+    Deque (a : head') tail -> Just (a, Deque head' tail)
+    Deque [] tail ->
+      case reverse tail of
+        (a : head') -> Just (a, Deque head' [])
+        []          -> Nothing
+
+filter :: (a -> Bool) -> Deque a -> Deque a
+filter f (Deque head tail) = Deque (List.filter f head) (List.filter f tail)