removing unliftio

Network/QUIC/Client/Reader.hs

@@ -9,11 +9,11 @@ module Network.QUIC.Client.Reader (
     clientSocket,
 ) where
 
+import Control.Concurrent
+import qualified Control.Exception as E
 import Data.List (intersect)
 import Network.Socket (Socket, close, getSocketName)
 import qualified Network.Socket.ByteString as NSB
-import UnliftIO.Concurrent
-import qualified UnliftIO.Exception as E
 
 import Network.QUIC.Connection
 import Network.QUIC.Connector
@@ -34,7 +34,7 @@ readerClient s0 conn = handleLogUnit logAction $ do
     loop
   where
     wait = do
-        bound <- E.handleAny (\_ -> return False) $ do
+        bound <- E.handle (\(E.SomeException _) -> return False) $ do
             _ <- getSocketName s0
             return True
         unless bound $ do

Network/QUIC/Client/Run.hs

@@ -7,10 +7,10 @@ module Network.QUIC.Client.Run (
     migrate,
 ) where
 
+import Control.Concurrent
+import Control.Concurrent.Async
+import qualified Control.Exception as E
 import qualified Network.Socket as NS
-import UnliftIO.Async
-import UnliftIO.Concurrent
-import qualified UnliftIO.Exception as E
 
 import Network.QUIC.Client.Reader
 import Network.QUIC.Closer
@@ -92,7 +92,7 @@ runClient conf client0 isICVN verInfo = do
                 case er of
                     Left () -> E.throwIO MustNotReached
                     Right r -> return r
-        ex <- E.trySyncOrAsync runThreads
+        ex <- E.try runThreads
         sendFinal conn
         closure conn ldcc ex
   where

Network/QUIC/Closer.hs

@@ -2,11 +2,11 @@
 
 module Network.QUIC.Closer (closure) where
 
+import Control.Concurrent
+import qualified Control.Exception as E
 import Foreign.Marshal.Alloc
 import Foreign.Ptr
 import qualified Network.Socket as NS
-import UnliftIO.Concurrent
-import qualified UnliftIO.Exception as E
 
 import Network.QUIC.Config
 import Network.QUIC.Connection

Network/QUIC/Connection/Crypto.hs

@@ -24,8 +24,8 @@ module Network.QUIC.Connection.Crypto (
     setCurrentKeyPhase,
 ) where
 
+import Control.Concurrent.STM
 import Network.TLS.QUIC
-import UnliftIO.STM
 
 import Network.QUIC.Connection.Misc
 import Network.QUIC.Connection.Types
@@ -63,7 +63,7 @@ putOffCrypto Connection{..} lvl rpkt =
 waitEncryptionLevel :: Connection -> EncryptionLevel -> IO ()
 waitEncryptionLevel Connection{..} lvl = atomically $ do
     l <- readTVar $ encryptionLevel connState
-    checkSTM (l >= lvl)
+    check (l >= lvl)
 
 ----------------------------------------------------------------
 

Network/QUIC/Connection/Migration.hs

@@ -26,9 +26,9 @@ module Network.QUIC.Connection.Migration (
     validatePath,
 ) where
 
+import Control.Concurrent.STM
 import qualified Data.IntMap.Strict as IntMap
 import qualified Data.Map.Strict as Map
-import UnliftIO.STM
 
 import Network.QUIC.Connection.Misc
 import Network.QUIC.Connection.Queue
@@ -123,7 +123,7 @@ waitPeerCID conn@Connection{..} = do
         let ref = peerCIDDB
         db <- readTVar ref
         mncid <- pickPeerCID conn
-        checkSTM $ isJust mncid
+        check $ isJust mncid
         let u = usedCIDInfo db
         setPeerCID conn (fromJust mncid) True
         return u
@@ -313,7 +313,7 @@ isPathValidating Connection{..} = do
 waitResponse :: Connection -> IO ()
 waitResponse Connection{..} = atomically $ do
     state <- readTVar migrationState
-    checkSTM (state == RecvResponse)
+    check (state == RecvResponse)
     writeTVar migrationState NonMigration
 
 checkResponse :: Connection -> PathData -> IO ()

Network/QUIC/Connection/Misc.hs

@@ -33,10 +33,10 @@ module Network.QUIC.Connection.Misc (
     abortConnection,
 ) where
 
+import Control.Concurrent
+import qualified Control.Exception as E
 import Network.Socket (Socket)
 import System.Mem.Weak
-import UnliftIO.Concurrent
-import qualified UnliftIO.Exception as E
 
 import Network.QUIC.Connection.Queue
 import Network.QUIC.Connection.Timeout

Network/QUIC/Connection/Queue.hs

@@ -1,6 +1,6 @@
 module Network.QUIC.Connection.Queue where
 
-import UnliftIO.STM
+import Control.Concurrent.STM
 
 import Network.QUIC.Connection.Types
 import Network.QUIC.Imports

Network/QUIC/Connection/Role.hs

@@ -22,9 +22,9 @@ module Network.QUIC.Connection.Role (
     getCertificateChain,
 ) where
 
+import Control.Concurrent
 import qualified Crypto.Token as CT
 import Data.X509 (CertificateChain)
-import UnliftIO.Concurrent
 
 import Network.QUIC.Connection.Misc
 import Network.QUIC.Connection.Types

Network/QUIC/Connection/State.hs

@@ -24,8 +24,8 @@ module Network.QUIC.Connection.State (
     checkAntiAmplificationFree,
 ) where
 
+import Control.Concurrent.STM
 import Network.Control
-import UnliftIO.STM
 
 import Network.QUIC.Connection.Types
 import Network.QUIC.Connector
@@ -62,20 +62,20 @@ isConnection1RTTReady Connection{..} = atomically $ do
 wait0RTTReady :: Connection -> IO ()
 wait0RTTReady Connection{..} = atomically $ do
     cs <- readTVar $ connectionState connState
-    checkSTM (cs >= ReadyFor0RTT)
+    check (cs >= ReadyFor0RTT)
 
 -- | Waiting until 1-RTT data can be sent.
 wait1RTTReady :: Connection -> IO ()
 wait1RTTReady Connection{..} = atomically $ do
     cs <- readTVar $ connectionState connState
-    checkSTM (cs >= ReadyFor1RTT)
+    check (cs >= ReadyFor1RTT)
 
 -- | For clients, waiting until HANDSHAKE_DONE is received.
 --   For servers, waiting until a TLS stack reports that the handshake is complete.
 waitEstablished :: Connection -> IO ()
 waitEstablished Connection{..} = atomically $ do
     cs <- readTVar $ connectionState connState
-    checkSTM (cs >= Established)
+    check (cs >= Established)
 
 ----------------------------------------------------------------
 
@@ -134,7 +134,7 @@ waitAntiAmplificationFree conn@Connection{..} siz = do
     ok <- checkAntiAmplificationFree conn siz
     unless ok $ do
         beforeAntiAmp connLDCC
-        atomically (checkAntiAmplificationFreeSTM conn siz >>= checkSTM)
+        atomically (checkAntiAmplificationFreeSTM conn siz >>= check)
 
 -- setLossDetectionTimer is called eventually.
 

Network/QUIC/Connection/Stream.hs

@@ -14,7 +14,7 @@ module Network.QUIC.Connection.Stream (
     checkStreamIdRoom,
 ) where
 
-import UnliftIO.STM
+import Control.Concurrent.STM
 
 import Network.QUIC.Connection.Misc
 import Network.QUIC.Connection.Types
@@ -45,7 +45,7 @@ get tvar = atomically $ do
     conc@Concurrency{..} <- readTVar tvar
     let streamType = currentStream .&. 0b11
         StreamIdBase base = maxStreams
-    checkSTM (currentStream < base * 4 + streamType)
+    check (currentStream < base * 4 + streamType)
     let currentStream' = currentStream + 4
     writeTVar tvar conc{currentStream = currentStream'}
     return currentStream
@@ -68,15 +68,15 @@ updatePeerStreamId conn sid = do
             || (isServer conn && isClientInitiatedBidirectional sid)
         )
         $ do
-            atomicModifyIORef'' (peerStreamId conn) check
+            atomicModifyIORef'' (peerStreamId conn) checkConc
     when
         ( (isClient conn && isServerInitiatedUnidirectional sid)
             || (isServer conn && isClientInitiatedUnidirectional sid)
         )
         $ do
-            atomicModifyIORef'' (peerUniStreamId conn) check
+            atomicModifyIORef'' (peerUniStreamId conn) checkConc
   where
-    check conc@Concurrency{..}
+    checkConc conc@Concurrency{..}
         | currentStream < sid = conc{currentStream = sid}
         | otherwise = conc
 
@@ -106,9 +106,9 @@ checkStreamIdRoom conn dir = do
     let ref
             | dir == Bidirectional = peerStreamId conn
             | otherwise = peerUniStreamId conn
-    atomicModifyIORef' ref check
+    atomicModifyIORef' ref checkConc
   where
-    check conc@Concurrency{..} =
+    checkConc conc@Concurrency{..} =
         let StreamIdBase base = maxStreams
             initialStreams = initialMaxStreamsBidi $ getMyParameters conn
             cbase = currentStream !>>. 2

Network/QUIC/Connection/Timeout.hs

@@ -5,10 +5,10 @@ module Network.QUIC.Connection.Timeout (
     delay,
 ) where
 
+import Control.Concurrent
+import qualified Control.Exception as E
 import Network.QUIC.Event
 import qualified System.Timeout as ST
-import UnliftIO.Concurrent
-import qualified UnliftIO.Exception as E
 
 import Network.QUIC.Connection.Types
 import Network.QUIC.Connector
@@ -25,7 +25,7 @@ fire conn (Microseconds microseconds) action = do
   where
     action' = do
         alive <- getAlive conn
-        when alive action `E.catchSyncOrAsync` ignore
+        when alive action `E.catch` ignore
 
 cfire :: Connection -> Microseconds -> TimeoutCallback -> IO (IO ())
 cfire conn (Microseconds microseconds) action = do
@@ -36,7 +36,7 @@ cfire conn (Microseconds microseconds) action = do
   where
     action' = do
         alive <- getAlive conn
-        when alive action `E.catchSyncOrAsync` ignore
+        when alive action `E.catch` ignore
 
 delay :: Microseconds -> IO ()
 delay (Microseconds microseconds) = threadDelay microseconds

Network/QUIC/Connection/Types.hs

@@ -5,6 +5,8 @@
 
 module Network.QUIC.Connection.Types where
 
+import Control.Concurrent
+import Control.Concurrent.STM
 import qualified Crypto.Token as CT
 import Data.Array.IO
 import Data.ByteString.Internal
@@ -18,8 +20,6 @@ import Foreign.Ptr (nullPtr)
 import Network.Control (Rate, RxFlow, TxFlow, newRate, newRxFlow, newTxFlow)
 import Network.Socket (Cmsg, SockAddr, Socket)
 import Network.TLS.QUIC
-import UnliftIO.Concurrent
-import UnliftIO.STM
 
 import Network.QUIC.Config
 import Network.QUIC.Connector

Network/QUIC/Connector.hs

@@ -1,8 +1,8 @@
 module Network.QUIC.Connector where
 
+import Control.Concurrent.STM
 import Data.IORef
 import Network.QUIC.Types
-import UnliftIO.STM
 
 class Connector a where
     getRole :: a -> Role

Network/QUIC/Crypto/Keys.hs

@@ -12,10 +12,10 @@ module Network.QUIC.Crypto.Keys (
     headerProtectionKey,
 ) where
 
+import qualified Control.Exception as E
 import Network.TLS hiding (Version)
 import Network.TLS.Extra.Cipher
 import Network.TLS.QUIC
-import qualified UnliftIO.Exception as E
 
 import Network.QUIC.Crypto.Types
 import Network.QUIC.Imports
@@ -35,7 +35,7 @@ initialSalt Version1 =
     "\x38\x76\x2c\xf7\xf5\x59\x34\xb3\x4d\x17\x9a\xe6\xa4\xc8\x0c\xad\xcc\xbb\x7f\x0a"
 initialSalt Version2 =
     "\x0d\xed\xe3\xde\xf7\x00\xa6\xdb\x81\x93\x81\xbe\x6e\x26\x9d\xcb\xf9\xbd\x2e\xd9"
-initialSalt (Version v) = E.impureThrow $ VersionIsUnknown v
+initialSalt (Version v) = E.throw $ VersionIsUnknown v
 
 initialSecrets :: Version -> CID -> TrafficSecrets InitialSecret
 initialSecrets v c = (clientInitialSecret v c, serverInitialSecret v c)

Network/QUIC/Exception.hs

@@ -5,15 +5,15 @@ module Network.QUIC.Exception (
     handleLogUnit,
 ) where
 
+import qualified Control.Exception as E
 import qualified GHC.IO.Exception as E
 import qualified System.IO.Error as E
-import qualified UnliftIO.Exception as E
 
 import Network.QUIC.Logger
 
 -- Catch all exceptions including asynchronous ones.
 handleLogUnit :: DebugLogger -> IO () -> IO ()
-handleLogUnit logAction action = action `E.catchSyncOrAsync` handler
+handleLogUnit logAction action = action `E.catch` handler
   where
     handler :: E.SomeException -> IO ()
     handler se = case E.fromException se of
@@ -25,7 +25,7 @@ handleLogUnit logAction action = action `E.catchSyncOrAsync` handler
 
 -- Log and throw an exception
 handleLogT :: DebugLogger -> IO a -> IO a
-handleLogT logAction action = action `E.catchAny` handler
+handleLogT logAction action = action `E.catch` handler
   where
     handler (E.SomeException e) = do
         logAction $ bhow e

Network/QUIC/Handshake.hs

@@ -3,10 +3,10 @@
 
 module Network.QUIC.Handshake where
 
+import qualified Control.Exception as E
 import Data.List (intersect)
 import qualified Network.TLS as TLS
 import Network.TLS.QUIC
-import qualified UnliftIO.Exception as E
 
 import Network.QUIC.Config
 import Network.QUIC.Connection

Network/QUIC/IO.hs

@@ -1,9 +1,9 @@
 module Network.QUIC.IO where
 
+import Control.Concurrent.STM
+import qualified Control.Exception as E
 import qualified Data.ByteString as BS
 import Network.Control
-import qualified UnliftIO.Exception as E
-import UnliftIO.STM
 
 import Network.QUIC.Connection
 import Network.QUIC.Connector
@@ -110,7 +110,7 @@ checkBlocked s len wait = atomically $ do
         connWindow = txWindowSize connFlow
         minFlow = min strmWindow connWindow
         n = min len minFlow
-    when wait $ checkSTM (n > 0)
+    when wait $ check (n > 0)
     if n > 0
         then return $ Right n
         else do

Network/QUIC/Packet/Decode.hs

@@ -7,9 +7,9 @@ module Network.QUIC.Packet.Decode (
     decodeStatelessResetToken,
 ) where
 
+import qualified Control.Exception as E
 import qualified Data.ByteString as BS
 import qualified Data.ByteString.Short as Short
-import qualified UnliftIO.Exception as E
 
 import Network.QUIC.Imports
 import Network.QUIC.Packet.Header

Network/QUIC/Receiver.hs

@@ -5,10 +5,10 @@ module Network.QUIC.Receiver (
     receiver,
 ) where
 
+import qualified Control.Exception as E
 import qualified Data.ByteString as BS
 import Network.Control
 import Network.TLS (AlertDescription (..))
-import qualified UnliftIO.Exception as E
 
 import Network.QUIC.Config
 import Network.QUIC.Connection