unliftio 0.2.4.0 → 0.2.5.0

raw patch · 6 files changed

+1680/−22 lines, 6 filesdep +processPVP ok

version bump matches the API change (PVP)

Dependencies added: process

API changes (from Hackage documentation)

Files

• ChangeLog.md +5/−1
• src/UnliftIO/Environment.hs +88/−0
• src/UnliftIO/Foreign.hs +1348/−0
• src/UnliftIO/Process.hs +213/−0
• src/UnliftIO/Temporary.hs +1/−1
• unliftio.cabal +25/−20

@@ -1,4 +1,8 @@-## 0.2.3.0+## 0.2.5.0++* Add `UnliftIO.Environment`/`UnliftIO.Foreign`/`UnliftIO.Process`++## 0.2.4.0  * Use more generalized `withRunInIO` in `unliftio-core-0.1.1.0` * Add `getMonotonicTime` function

@@ -0,0 +1,88 @@+-- | Unlifted "System.Environment".+--+-- @since 0.2.5.0+module UnliftIO.Environment+  ( getArgs+  , getProgName+  , getExecutablePath+  , getEnv+  , lookupEnv+  , setEnv+  , unsetEnv+  , withArgs+  , withProgName+  , getEnvironment+  ) where++import Control.Monad.IO.Unlift+import qualified System.Environment as E++-- | Lifted 'E.getArgs'.+--+-- @since 0.2.5.0+{-# INLINE getArgs #-}+getArgs :: MonadIO m => m [String]+getArgs = liftIO E.getArgs++-- | Lifted 'E.getProgName'.+--+-- @since 0.2.5.0+{-# INLINE getProgName #-}+getProgName :: MonadIO m => m String+getProgName = liftIO E.getProgName++-- | Lifted 'E.getExecutablePath'.+--+-- @since 0.2.5.0+{-# INLINE getExecutablePath #-}+getExecutablePath :: MonadIO m => m FilePath+getExecutablePath = liftIO E.getExecutablePath++-- | Lifted 'E.getEnv'.+--+-- @since 0.2.5.0+{-# INLINE getEnv #-}+getEnv :: MonadIO m => String -> m String+getEnv = liftIO . E.getEnv++-- | Lifted 'E.lookupEnv'.+--+-- @since 0.2.5.0+{-# INLINE lookupEnv #-}+lookupEnv :: MonadIO m => String -> m (Maybe String)+lookupEnv = liftIO . E.lookupEnv++-- | Lifted 'E.setEnv'.+--+-- @since 0.2.5.0+{-# INLINE setEnv #-}+setEnv :: MonadIO m => String -> String -> m ()+setEnv key_ value_ = liftIO (E.setEnv key_ value_)++-- | Lifted 'E.unsetEnv'.+--+-- @since 0.2.5.0+{-# INLINE unsetEnv #-}+unsetEnv :: MonadIO m => String -> m ()+unsetEnv = liftIO . E.unsetEnv++-- | Unlifted 'E.withArgs'.+--+-- @since 0.2.5.0+{-# INLINE withArgs #-}+withArgs :: MonadUnliftIO m => [String] -> m a -> m a+withArgs xs act = withRunInIO (\u -> E.withArgs xs (u act))++-- | Unlifted 'E.withProgName'.+--+-- @since 0.2.5.0+{-# INLINE withProgName #-}+withProgName :: MonadUnliftIO m => String -> m a -> m a+withProgName nm act = withRunInIO (\u -> E.withProgName nm (u act))++-- | Lifted 'E.getEnvironment'.+--+-- @since 0.2.5.0+{-# INLINE getEnvironment #-}+getEnvironment :: MonadIO m => m [(String, String)]+getEnvironment = liftIO E.getEnvironment

@@ -0,0 +1,1348 @@+{-# LANGUAGE CPP #-}+-- | Unlifted "Foreign".+--+-- @since 0.2.5.0++module UnliftIO.Foreign (+  -- * Re-exported modules+    module Data.Bits+  , module Data.Int+  , module Data.Word+  , module Foreign.C.Types++  -- * Unlifted "Foreign.C.String"+  , CString+  , CStringLen+  , peekCString+  , peekCStringLen+  , newCString+  , newCStringLen+  , withCString+  , withCStringLen+  , charIsRepresentable+  , castCharToCChar+  , castCCharToChar+  , castCharToCUChar+  , castCUCharToChar+  , castCharToCSChar+  , castCSCharToChar+  , peekCAString+  , peekCAStringLen+  , newCAString+  , newCAStringLen+  , withCAString+  , withCAStringLen+  , CWString+  , CWStringLen+  , peekCWString+  , peekCWStringLen+  , newCWString+  , newCWStringLen+  , withCWString+  , withCWStringLen++  -- * Unlifted "Foreign.C.Error"+  , Errno(..)+  , eOK+  , e2BIG+  , eACCES+  , eADDRINUSE+  , eADDRNOTAVAIL+  , eADV+  , eAFNOSUPPORT+  , eAGAIN+  , eALREADY+  , eBADF+  , eBADMSG+  , eBADRPC+  , eBUSY+  , eCHILD+  , eCOMM+  , eCONNABORTED+  , eCONNREFUSED+  , eCONNRESET+  , eDEADLK+  , eDESTADDRREQ+  , eDIRTY+  , eDOM+  , eDQUOT+  , eEXIST+  , eFAULT+  , eFBIG+  , eFTYPE+  , eHOSTDOWN+  , eHOSTUNREACH+  , eIDRM+  , eILSEQ+  , eINPROGRESS+  , eINTR+  , eINVAL+  , eIO+  , eISCONN+  , eISDIR+  , eLOOP+  , eMFILE+  , eMLINK+  , eMSGSIZE+  , eMULTIHOP+  , eNAMETOOLONG+  , eNETDOWN+  , eNETRESET+  , eNETUNREACH+  , eNFILE+  , eNOBUFS+  , eNODATA+  , eNODEV+  , eNOENT+  , eNOEXEC+  , eNOLCK+  , eNOLINK+  , eNOMEM+  , eNOMSG+  , eNONET+  , eNOPROTOOPT+  , eNOSPC+  , eNOSR+  , eNOSTR+  , eNOSYS+  , eNOTBLK+  , eNOTCONN+  , eNOTDIR+  , eNOTEMPTY+  , eNOTSOCK+  , eNOTSUP+  , eNOTTY+  , eNXIO+  , eOPNOTSUPP+  , ePERM+  , ePFNOSUPPORT+  , ePIPE+  , ePROCLIM+  , ePROCUNAVAIL+  , ePROGMISMATCH+  , ePROGUNAVAIL+  , ePROTO+  , ePROTONOSUPPORT+  , ePROTOTYPE+  , eRANGE+  , eREMCHG+  , eREMOTE+  , eROFS+  , eRPCMISMATCH+  , eRREMOTE+  , eSHUTDOWN+  , eSOCKTNOSUPPORT+  , eSPIPE+  , eSRCH+  , eSRMNT+  , eSTALE+  , eTIME+  , eTIMEDOUT+  , eTOOMANYREFS+  , eTXTBSY+  , eUSERS+  , eWOULDBLOCK+  , eXDEV+  , isValidErrno+  , getErrno+  , resetErrno+  , errnoToIOError+  , throwErrno+  , throwErrnoIf+  , throwErrnoIf_+  , throwErrnoIfRetry+  , throwErrnoIfRetry_+  , throwErrnoIfMinus1+  , throwErrnoIfMinus1_+  , throwErrnoIfMinus1Retry+  , throwErrnoIfMinus1Retry_+  , throwErrnoIfNull+  , throwErrnoIfNullRetry+  , throwErrnoIfRetryMayBlock+  , throwErrnoIfRetryMayBlock_+  , throwErrnoIfMinus1RetryMayBlock+  , throwErrnoIfMinus1RetryMayBlock_+  , throwErrnoIfNullRetryMayBlock+  , throwErrnoPath+  , throwErrnoPathIf+  , throwErrnoPathIf_+  , throwErrnoPathIfNull+  , throwErrnoPathIfMinus1+  , throwErrnoPathIfMinus1_++  -- * Unlifted "Foreign.Ptr"+  , Ptr+  , nullPtr+  , castPtr+  , plusPtr+  , alignPtr+  , minusPtr+  , FunPtr+  , nullFunPtr+  , castFunPtr+  , castFunPtrToPtr+  , castPtrToFunPtr+  , freeHaskellFunPtr+  , IntPtr(..)+  , ptrToIntPtr+  , intPtrToPtr+  , WordPtr(..)+  , ptrToWordPtr+  , wordPtrToPtr++  -- * Unlifted "Foreign.ForeignPtr"+  , ForeignPtr+  , FinalizerPtr+  , FinalizerEnvPtr+  , newForeignPtr+  , newForeignPtr_+  , addForeignPtrFinalizer+  , newForeignPtrEnv+  , addForeignPtrFinalizerEnv+  , withForeignPtr+  , finalizeForeignPtr+  , touchForeignPtr+  , castForeignPtr+#if MIN_VERSION_base(4,10,0)+  , plusForeignPtr+#endif+  , mallocForeignPtr+  , mallocForeignPtrBytes+  , mallocForeignPtrArray+  , mallocForeignPtrArray0+  , newGHCForeignPtr+  , addGHCForeignPtrFinalizer+  , unsafeForeignPtrToPtr++  -- * Unlifted "Foreign.StablePtr"+  , StablePtr+  , newStablePtr+  , deRefStablePtr+  , freeStablePtr+  , castStablePtrToPtr+  , castPtrToStablePtr++  -- * Unlifted "Foreign.Storable"+  , Storable(..)++  -- * Unlifted "Foreign.Marshal.Alloc"+  , alloca+  , allocaBytes+  , allocaBytesAligned+  , malloc+  , mallocBytes+#if MIN_VERSION_base(4,8,0)+  , calloc+  , callocBytes+#endif+  , realloc+  , reallocBytes+  , free+  , finalizerFree++  -- * Unlifted "Foreign.Marshal.Array"+  , mallocArray+  , mallocArray0+  , allocaArray+  , allocaArray0+  , reallocArray+  , reallocArray0+#if MIN_VERSION_base(4,8,0)+  , callocArray+  , callocArray0+#endif+  , peekArray+  , peekArray0+  , pokeArray+  , pokeArray0+  , newArray+  , newArray0+  , withArray+  , withArray0+  , withArrayLen+  , withArrayLen0+  , copyArray+  , moveArray+  , lengthArray0+  , advancePtr++  -- * Unlifted "Foreign.Marshal.Error"+  , throwIf+  , throwIf_+  , throwIfNeg+  , throwIfNeg_+  , throwIfNull++  -- * Unlifted "Foreign.Marshal.Pool"+  , Pool+  , newPool+  , freePool+  , withPool+  , pooledMalloc+  , pooledMallocBytes+  , pooledRealloc+  , pooledReallocBytes+  , pooledMallocArray+  , pooledMallocArray0+  , pooledReallocArray+  , pooledReallocArray0+  , pooledNew+  , pooledNewArray+  , pooledNewArray0++  -- * Unlifted "Foreign.Marshal.Utils"+  , with+  , new+  , fromBool+  , toBool+  , maybeNew+  , maybeWith+  , maybePeek+  , withMany+  , copyBytes+  , moveBytes+#if MIN_VERSION_base(4,8,0)+  , fillBytes+#endif+  ) where++import Control.Monad.IO.Unlift+import Data.Bits+import Data.Int+import Data.Word+import qualified Foreign as F+import Foreign+  ( FinalizerEnvPtr+  , FinalizerPtr+  , ForeignPtr+  , FunPtr+  , IntPtr(..)+  , Pool+  , Ptr+  , StablePtr+  , Storable(..)+  , WordPtr(..)+  , advancePtr+  , alignPtr+  , castForeignPtr+  , castFunPtr+  , castFunPtrToPtr+  , castPtr+  , castPtrToFunPtr+  , castPtrToStablePtr+  , castStablePtrToPtr+  , finalizerFree+  , fromBool+  , intPtrToPtr+  , minusPtr+  , nullFunPtr+  , nullPtr+#if MIN_VERSION_base(4,10,0)+  , plusForeignPtr+#endif+  , plusPtr+  , ptrToIntPtr+  , ptrToWordPtr+  , toBool+  , withMany+  , wordPtrToPtr+  )++import qualified Foreign.C as F+import Foreign.C+  ( CString+  , CStringLen+  , CWString+  , CWStringLen+  , Errno(..)+  , castCCharToChar+  , castCSCharToChar+  , castCUCharToChar+  , castCharToCChar+  , castCharToCSChar+  , castCharToCSChar+  , castCharToCUChar+  , charIsRepresentable+  , e2BIG+  , eACCES+  , eADDRINUSE+  , eADDRNOTAVAIL+  , eADV+  , eAFNOSUPPORT+  , eAGAIN+  , eALREADY+  , eBADF+  , eBADMSG+  , eBADRPC+  , eBUSY+  , eCHILD+  , eCOMM+  , eCONNABORTED+  , eCONNREFUSED+  , eCONNRESET+  , eDEADLK+  , eDESTADDRREQ+  , eDIRTY+  , eDOM+  , eDQUOT+  , eEXIST+  , eFAULT+  , eFBIG+  , eFTYPE+  , eHOSTDOWN+  , eHOSTUNREACH+  , eIDRM+  , eILSEQ+  , eINPROGRESS+  , eINTR+  , eINVAL+  , eIO+  , eISCONN+  , eISDIR+  , eLOOP+  , eMFILE+  , eMLINK+  , eMSGSIZE+  , eMULTIHOP+  , eNAMETOOLONG+  , eNETDOWN+  , eNETRESET+  , eNETUNREACH+  , eNFILE+  , eNOBUFS+  , eNODATA+  , eNODEV+  , eNOENT+  , eNOEXEC+  , eNOLCK+  , eNOLINK+  , eNOMEM+  , eNOMSG+  , eNONET+  , eNOPROTOOPT+  , eNOSPC+  , eNOSR+  , eNOSTR+  , eNOSYS+  , eNOTBLK+  , eNOTCONN+  , eNOTDIR+  , eNOTEMPTY+  , eNOTSOCK+  , eNOTSUP+  , eNOTTY+  , eNXIO+  , eOK+  , eOPNOTSUPP+  , ePERM+  , ePFNOSUPPORT+  , ePIPE+  , ePROCLIM+  , ePROCUNAVAIL+  , ePROGMISMATCH+  , ePROGUNAVAIL+  , ePROTO+  , ePROTONOSUPPORT+  , ePROTOTYPE+  , eRANGE+  , eREMCHG+  , eREMOTE+  , eROFS+  , eRPCMISMATCH+  , eRREMOTE+  , eSHUTDOWN+  , eSOCKTNOSUPPORT+  , eSPIPE+  , eSRCH+  , eSRMNT+  , eSTALE+  , eTIME+  , eTIMEDOUT+  , eTOOMANYREFS+  , eTXTBSY+  , eUSERS+  , eWOULDBLOCK+  , eXDEV+  , errnoToIOError+  , isValidErrno+  )+import Foreign.C.Types+import qualified Foreign.Concurrent as FC+import Foreign.ForeignPtr.Unsafe++-- | Lifted 'F.peekCString'.+--+-- @since 0.2.5.0+{-# INLINE peekCString #-}+peekCString :: MonadIO m => CString -> m String+peekCString = liftIO . F.peekCString++-- | Lifted 'F.peekCStringLen'.+--+-- @since 0.2.5.0+{-# INLINE peekCStringLen #-}+peekCStringLen :: MonadIO m => CStringLen -> m String+peekCStringLen = liftIO . F.peekCStringLen++-- | Lifted 'F.newCString'.+--+-- @since 0.2.5.0+{-# INLINE newCString #-}+newCString :: MonadIO m => String -> m CString+newCString = liftIO . F.newCString++-- | Lifted 'F.newCStringLen'.+--+-- @since 0.2.5.0+{-# INLINE newCStringLen #-}+newCStringLen :: MonadIO m => String -> m CStringLen+newCStringLen = liftIO . F.newCStringLen++-- | Unlifted 'F.withCString'.+--+-- @since 0.2.5.0+{-# INLINE withCString #-}+withCString :: MonadUnliftIO m => String -> (CString -> m a) -> m a+withCString s f = withRunInIO (\u -> F.withCString s (u . f))++-- | Unlifted 'F.withCStringLen'.+--+-- @since 0.2.5.0+{-# INLINE withCStringLen #-}+withCStringLen :: MonadUnliftIO m => String -> (CStringLen -> m a) -> m a+withCStringLen s f = withRunInIO (\u -> F.withCStringLen s (u . f))++-- | Lifted 'F.peekCAString'.+--+-- @since 0.2.5.0+{-# INLINE peekCAString #-}+peekCAString :: MonadIO m => CString -> m String+peekCAString = liftIO . F.peekCAString++-- | Lifted 'F.peekCAStringLen'.+--+-- @since 0.2.5.0+{-# INLINE peekCAStringLen #-}+peekCAStringLen :: MonadIO m => CStringLen -> m String+peekCAStringLen = liftIO . F.peekCAStringLen++-- | Lifted 'F.newCAString'.+--+-- @since 0.2.5.0+{-# INLINE newCAString #-}+newCAString :: MonadIO m => String -> m CString+newCAString = liftIO . F.newCAString++-- | Lifted 'F.newCAStringLen'.+--+-- @since 0.2.5.0+{-# INLINE newCAStringLen #-}+newCAStringLen :: MonadIO m => String -> m CStringLen+newCAStringLen = liftIO . F.newCAStringLen++-- | Unlifted 'F.withCAString'.+--+-- @since 0.2.5.0+{-# INLINE withCAString #-}+withCAString :: MonadUnliftIO m => String -> (CString -> m a) -> m a+withCAString str f = withRunInIO (\u -> F.withCAString str (u . f))++-- | Unlifted 'F.withCAStringLen'.+--+-- @since 0.2.5.0+{-# INLINE withCAStringLen #-}+withCAStringLen :: MonadUnliftIO m => String -> (CStringLen -> m a) -> m a+withCAStringLen str f = withRunInIO (\u -> F.withCAStringLen str (u . f))++-- | Lifted 'F.peekCWString'.+--+-- @since 0.2.5.0+{-# INLINE peekCWString #-}+peekCWString :: MonadIO m => CWString -> m String+peekCWString = liftIO . F.peekCWString++-- | Lifted 'F.peekCWStringLen'.+--+-- @since 0.2.5.0+{-# INLINE peekCWStringLen #-}+peekCWStringLen :: MonadIO m => CWStringLen -> m String+peekCWStringLen = liftIO . F.peekCWStringLen++-- | Lifted 'F.newCWString'.+--+-- @since 0.2.5.0+{-# INLINE newCWString #-}+newCWString :: MonadIO m => String -> m CWString+newCWString = liftIO . F.newCWString++-- | Lifted 'F.newCWStringLen'.+--+-- @since 0.2.5.0+{-# INLINE newCWStringLen #-}+newCWStringLen :: MonadIO m => String -> m CWStringLen+newCWStringLen = liftIO . F.newCWStringLen++-- | Unlifted 'F.withCWString'.+--+-- @since 0.2.5.0+{-# INLINE withCWString #-}+withCWString :: MonadUnliftIO m => String -> (CWString -> m a) -> m a+withCWString str f = withRunInIO (\u -> F.withCWString str (u . f))++-- | Unlifted 'F.withCWStringLen'.+--+-- @since 0.2.5.0+{-# INLINE withCWStringLen #-}+withCWStringLen :: MonadUnliftIO m => String -> (CWStringLen -> m a) -> m a+withCWStringLen str f = withRunInIO (\u -> F.withCWStringLen str (u . f))++-- | Lifted 'F.getErrno'.+--+-- @since 0.2.5.0+{-# INLINE getErrno #-}+getErrno :: MonadIO m => m Errno+getErrno = liftIO F.getErrno++-- | Lifted 'F.resetErrno'.+--+-- @since 0.2.5.0+{-# INLINE resetErrno #-}+resetErrno :: MonadIO m => m ()+resetErrno = liftIO F.resetErrno++-- | Lifted 'F.throwErrno'.+--+-- @since 0.2.5.0+{-# INLINE throwErrno #-}+throwErrno :: MonadIO m => String -> m a+throwErrno = liftIO . F.throwErrno++-- | Unlifted 'F.throwErrnoIf'.+--+-- @since 0.2.5.0+{-# INLINE throwErrnoIf #-}+throwErrnoIf :: MonadUnliftIO m => (a -> Bool) -> String -> m a -> m a+throwErrnoIf pred_ loc f = withRunInIO (\u -> F.throwErrnoIf pred_ loc (u f))++-- | Unlifted 'F.throwErrnoIf_'.+--+-- @since 0.2.5.0+{-# INLINE throwErrnoIf_ #-}+throwErrnoIf_ :: MonadUnliftIO m => (a -> Bool) -> String -> m a -> m ()+throwErrnoIf_ pred_ loc f = withRunInIO (\u -> F.throwErrnoIf_ pred_ loc (u f))++-- | Unlifted 'F.throwErrnoIfRetry'.+--+-- @since 0.2.5.0+{-# INLINE throwErrnoIfRetry #-}+throwErrnoIfRetry :: MonadUnliftIO m => (a -> Bool) -> String -> m a -> m a+throwErrnoIfRetry pred_ loc f =+  withRunInIO (\u -> F.throwErrnoIfRetry pred_ loc (u f))++-- | Unlifted 'F.throwErrnoIfRetry_'.+--+-- @since 0.2.5.0+{-# INLINE throwErrnoIfRetry_ #-}+throwErrnoIfRetry_ :: MonadUnliftIO m => (a -> Bool) -> String -> m a -> m ()+throwErrnoIfRetry_ pred_ loc f =+  withRunInIO (\u -> F.throwErrnoIfRetry_ pred_ loc (u f))++-- | Unlifted 'F.throwErrnoIfMinus1'.+--+-- @since 0.2.5.0+{-# INLINE throwErrnoIfMinus1 #-}+throwErrnoIfMinus1 :: (MonadUnliftIO m, Eq a, Num a) => String -> m a -> m a+throwErrnoIfMinus1 loc f = withRunInIO (\u -> F.throwErrnoIfMinus1 loc (u f))++-- | Unlifted 'F.throwErrnoIfMinus1_'+--+-- @since 0.2.5.0+{-# INLINE throwErrnoIfMinus1_ #-}+throwErrnoIfMinus1_ :: (MonadUnliftIO m, Eq a, Num a) => String -> m a -> m ()+throwErrnoIfMinus1_ loc f = withRunInIO (\u -> F.throwErrnoIfMinus1_ loc (u f))++-- | Unlifted 'F.throwErrnoIfMinus1Retry'.+--+-- @since 0.2.5.0+{-# INLINE throwErrnoIfMinus1Retry #-}+throwErrnoIfMinus1Retry ::+     (MonadUnliftIO m, Eq a, Num a) => String -> m a -> m a+throwErrnoIfMinus1Retry loc f =+  withRunInIO (\u -> F.throwErrnoIfMinus1Retry loc (u f))++-- | Unlifted 'F.throwErrnoIfMinus1Retry_'.+--+-- @since 0.2.5.0+{-# INLINE throwErrnoIfMinus1Retry_ #-}+throwErrnoIfMinus1Retry_ ::+     (MonadUnliftIO m, Eq a, Num a) => String -> m a -> m ()+throwErrnoIfMinus1Retry_ loc f =+  withRunInIO (\u -> F.throwErrnoIfMinus1Retry_ loc (u f))++-- | Unlifted 'F.throwErrnoIfNull'.+--+-- @since 0.2.5.0+{-# INLINE throwErrnoIfNull #-}+throwErrnoIfNull :: MonadUnliftIO m => String -> m (Ptr a) -> m (Ptr a)+throwErrnoIfNull loc f = withRunInIO (\u -> F.throwErrnoIfNull loc (u f))++-- | Unlifted 'F.throwErrnoIfNullRetry'.+--+-- @since 0.2.5.0+{-# INLINE throwErrnoIfNullRetry #-}+throwErrnoIfNullRetry :: MonadUnliftIO m => String -> m (Ptr a) -> m (Ptr a)+throwErrnoIfNullRetry loc f =+  withRunInIO (\u -> F.throwErrnoIfNullRetry loc (u f))++-- | Unlifted 'F.throwErrnoIfRetryMayBlock'.+--+-- @since 0.2.5.0+{-# INLINE throwErrnoIfRetryMayBlock #-}+throwErrnoIfRetryMayBlock ::+     MonadUnliftIO m => (a -> Bool) -> String -> m a -> m b -> m a+throwErrnoIfRetryMayBlock pred_ loc f on_block =+  withRunInIO (\u -> F.throwErrnoIfRetryMayBlock pred_ loc (u f) (u on_block))++-- | Unlifted 'F.throwErrnoIfRetryMayBlock_'.+--+-- @since 0.2.5.0+{-# INLINE throwErrnoIfRetryMayBlock_ #-}+throwErrnoIfRetryMayBlock_ ::+     MonadUnliftIO m => (a -> Bool) -> String -> m a -> m b -> m ()+throwErrnoIfRetryMayBlock_ pred_ loc f on_block =+  withRunInIO (\u -> F.throwErrnoIfRetryMayBlock_ pred_ loc (u f) (u on_block))++-- | Unlifted 'F.throwErrnoIfMinus1RetryMayBlock'.+--+-- @since 0.2.5.0+{-# INLINE throwErrnoIfMinus1RetryMayBlock #-}+throwErrnoIfMinus1RetryMayBlock ::+     (MonadUnliftIO m, Eq a, Num a) => String -> m a -> m b -> m a+throwErrnoIfMinus1RetryMayBlock loc f on_block =+  withRunInIO (\u -> F.throwErrnoIfMinus1RetryMayBlock loc (u f) (u on_block))++-- | Unlifted 'F.throwErrnoIfMinus1RetryMayBlock_'+--+-- @since 0.2.5.0+{-# INLINE throwErrnoIfMinus1RetryMayBlock_ #-}+throwErrnoIfMinus1RetryMayBlock_ ::+     (MonadUnliftIO m, Eq a, Num a) => String -> m a -> m b -> m ()+throwErrnoIfMinus1RetryMayBlock_ loc f on_block =+  withRunInIO (\u -> F.throwErrnoIfMinus1RetryMayBlock_ loc (u f) (u on_block))++-- | Unlifted 'F.throwErrnoIfNullRetryMayBlock'.+--+-- @since 0.2.5.0+{-# INLINE throwErrnoIfNullRetryMayBlock #-}+throwErrnoIfNullRetryMayBlock ::+     MonadUnliftIO m => String -> m (Ptr a) -> m b -> m (Ptr a)+throwErrnoIfNullRetryMayBlock loc f on_block =+  withRunInIO (\u -> F.throwErrnoIfNullRetryMayBlock loc (u f) (u on_block))++-- | Lifted 'F.throwErrnoPath'.+--+-- @since 0.2.5.0+{-# INLINE throwErrnoPath #-}+throwErrnoPath :: MonadIO m => String -> FilePath -> m a+throwErrnoPath loc path = liftIO (F.throwErrnoPath loc path)++-- | Unlifted 'F.throwErrnoPathIf'.+--+-- @since 0.2.5.0+{-# INLINE throwErrnoPathIf #-}+throwErrnoPathIf ::+     MonadUnliftIO m => (a -> Bool) -> String -> FilePath -> m a -> m a+throwErrnoPathIf pred_ loc path f =+  withRunInIO (\u -> F.throwErrnoPathIf pred_ loc path (u f))++-- | Unlifted 'F.throwErrnoPathIf_'.+--+-- @since 0.2.5.0+{-# INLINE throwErrnoPathIf_ #-}+throwErrnoPathIf_ ::+     MonadUnliftIO m => (a -> Bool) -> String -> FilePath -> m a -> m ()+throwErrnoPathIf_ pred_ loc path f =+  withRunInIO (\u -> F.throwErrnoPathIf_ pred_ loc path (u f))++-- | Unlifted 'F.throwErrnoPathIfNull'.+--+-- @since 0.2.5.0+{-# INLINE throwErrnoPathIfNull #-}+throwErrnoPathIfNull ::+     MonadUnliftIO m => String -> FilePath -> m (Ptr a) -> m (Ptr a)+throwErrnoPathIfNull loc path f =+  withRunInIO (\u -> F.throwErrnoPathIfNull loc path (u f))++-- | Unlifted 'F.throwErrnoPathIfMinus1'.+--+-- @since 0.2.5.0+{-# INLINE throwErrnoPathIfMinus1 #-}+throwErrnoPathIfMinus1 ::+     (MonadUnliftIO m, Eq a, Num a) => String -> FilePath -> m a -> m a+throwErrnoPathIfMinus1 loc path f =+  withRunInIO (\u -> F.throwErrnoPathIfMinus1 loc path (u f))++-- | Unlifted 'F.throwErrnoPathIfMinus1_'.+--+-- @since 0.2.5.0+{-# INLINE throwErrnoPathIfMinus1_ #-}+throwErrnoPathIfMinus1_ ::+     (MonadUnliftIO m, Eq a, Num a) => String -> FilePath -> m a -> m ()+throwErrnoPathIfMinus1_ loc path f =+  withRunInIO (\u -> F.throwErrnoPathIfMinus1_ loc path (u f))++-- | Lifted 'F.freeHaskellFunPtr'.+--+-- @since 0.2.5.0+{-# INLINE freeHaskellFunPtr #-}+freeHaskellFunPtr :: MonadIO m => FunPtr a -> m ()+freeHaskellFunPtr = liftIO . F.freeHaskellFunPtr++-- | Lifted 'F.newForeignPtr'.+--+-- @since 0.2.5.0+{-# INLINE newForeignPtr #-}+newForeignPtr :: MonadIO m => FinalizerPtr a -> Ptr a -> m (ForeignPtr a)+newForeignPtr finalizer p = liftIO (F.newForeignPtr finalizer p)++-- | Lifted 'F.newForeignPtr_'.+--+-- @since 0.2.5.0+{-# INLINE newForeignPtr_ #-}+newForeignPtr_ :: MonadIO m => Ptr a -> m (ForeignPtr a)+newForeignPtr_ = liftIO . F.newForeignPtr_++-- | Lifted 'F.addForeignPtrFinalizer'.+--+-- @since 0.2.5.0+{-# INLINE addForeignPtrFinalizer #-}+addForeignPtrFinalizer :: MonadIO m => FinalizerPtr a -> ForeignPtr a -> m ()+addForeignPtrFinalizer finalizer_ptr foreign_ptr =+  liftIO (F.addForeignPtrFinalizer finalizer_ptr foreign_ptr)++-- | Lifted 'F.newForeignPtrEnv'.+--+-- @since 0.2.5.0+{-# INLINE newForeignPtrEnv #-}+newForeignPtrEnv ::+     MonadIO m => FinalizerEnvPtr env a -> Ptr env -> Ptr a -> m (ForeignPtr a)+newForeignPtrEnv finalizer env p = liftIO (F.newForeignPtrEnv finalizer env p)++-- | Lifted 'F.addForeignPtrFinalizerEnv'.+--+-- @since 0.2.5.0+{-# INLINE addForeignPtrFinalizerEnv #-}+addForeignPtrFinalizerEnv ::+     MonadIO m => FinalizerEnvPtr env a -> Ptr env -> ForeignPtr a -> m ()+addForeignPtrFinalizerEnv finalizer env fp =+  liftIO (F.addForeignPtrFinalizerEnv finalizer env fp)++-- | Unlifted 'F.withForeignPtr'.+--+-- @since 0.2.5.0+{-# INLINE withForeignPtr #-}+withForeignPtr :: MonadUnliftIO m => ForeignPtr a -> (Ptr a -> m b) -> m b+withForeignPtr fo io = withRunInIO (\u -> F.withForeignPtr fo (u . io))++-- | Lifted 'F.finalizeForeignPtr'.+--+-- @since 0.2.5.0+{-# INLINE finalizeForeignPtr #-}+finalizeForeignPtr :: MonadIO m => ForeignPtr a -> m ()+finalizeForeignPtr = liftIO . F.finalizeForeignPtr++-- | Lifted 'F.touchForeignPtr'.+--+-- @since 0.2.5.0+{-# INLINE touchForeignPtr #-}+touchForeignPtr :: MonadIO m => ForeignPtr a -> m ()+touchForeignPtr = liftIO . F.touchForeignPtr++-- | Lifted 'F.mallocForeignPtr'.+--+-- @since 0.2.5.0+{-# INLINE mallocForeignPtr #-}+mallocForeignPtr :: (MonadIO m, Storable a) => m (ForeignPtr a)+mallocForeignPtr = liftIO F.mallocForeignPtr++-- | Lifted 'F.mallocForeignPtrBytes'.+--+-- @since 0.2.5.0+{-# INLINE mallocForeignPtrBytes #-}+mallocForeignPtrBytes :: MonadIO m => Int -> m (ForeignPtr a)+mallocForeignPtrBytes = liftIO . F.mallocForeignPtrBytes++-- | Lifted 'F.mallocForeignPtrArray'.+--+-- @since 0.2.5.0+{-# INLINE mallocForeignPtrArray #-}+mallocForeignPtrArray :: (MonadIO m, Storable a) => Int -> m (ForeignPtr a)+mallocForeignPtrArray = liftIO . F.mallocForeignPtrArray++-- | Lifted 'F.mallocForeignPtrArray0'.+--+-- @since 0.2.5.0+{-# INLINE mallocForeignPtrArray0 #-}+mallocForeignPtrArray0 :: (MonadIO m, Storable a) => Int -> m (ForeignPtr a)+mallocForeignPtrArray0 = liftIO . F.mallocForeignPtrArray0++-- | Unlifted 'FC.newForeignPtr'.+--+-- @since 0.2.5.0+{-# INLINE newGHCForeignPtr #-}+newGHCForeignPtr :: MonadUnliftIO m => Ptr a -> m () -> m (ForeignPtr a)+newGHCForeignPtr ptr f = withRunInIO (\u -> FC.newForeignPtr ptr (u f))++-- | Unlifted 'FC.addForeignPtrFinalizer'.+--+-- @since 0.2.5.0+{-# INLINE addGHCForeignPtrFinalizer #-}+addGHCForeignPtrFinalizer :: MonadUnliftIO m => ForeignPtr a -> m () -> m ()+addGHCForeignPtrFinalizer fptr f =+  withRunInIO (\u -> FC.addForeignPtrFinalizer fptr (u f))++-- | Lifted 'F.newStablePtr'.+--+-- @since 0.2.5.0+{-# INLINE newStablePtr #-}+newStablePtr :: MonadIO m => a -> m (StablePtr a)+newStablePtr = liftIO . F.newStablePtr++-- | Lifted 'F.deRefStablePtr'.+--+-- @since 0.2.5.0+{-# INLINE deRefStablePtr #-}+deRefStablePtr :: MonadIO m => StablePtr a -> m a+deRefStablePtr = liftIO . F.deRefStablePtr++-- | Lifted 'F.freeStablePtr'.+--+-- @since 0.2.5.0+{-# INLINE freeStablePtr #-}+freeStablePtr :: MonadIO m => StablePtr a -> m ()+freeStablePtr = liftIO . F.freeStablePtr++-- | Unlifted 'F.alloca'.+--+-- @since 0.2.5.0+{-# INLINE alloca #-}+alloca :: (MonadUnliftIO m, Storable a) => (Ptr a -> m b) -> m b+alloca action = withRunInIO (\u -> F.alloca (u . action))++-- | Unlifted 'F.allocaBytes'.+--+-- @since 0.2.5.0+{-# INLINE allocaBytes #-}+allocaBytes :: MonadUnliftIO m => Int -> (Ptr a -> m b) -> m b+allocaBytes size action = withRunInIO (\u -> F.allocaBytes size (u . action))++-- | Unlifted 'F.allocaBytesAligned'.+--+-- @since 0.2.5.0+{-# INLINE allocaBytesAligned #-}+allocaBytesAligned :: MonadUnliftIO m => Int -> Int -> (Ptr a -> m b) -> m b+allocaBytesAligned size align action =+  withRunInIO (\u -> F.allocaBytesAligned size align (u . action))++-- | Lifted 'F.malloc'.+--+-- @since 0.2.5.0+{-# INLINE malloc #-}+malloc :: (MonadIO m, Storable a) => m (Ptr a)+malloc = liftIO F.malloc++-- | Lifted 'F.mallocBytes'.+--+-- @since 0.2.5.0+{-# INLINE mallocBytes #-}+mallocBytes :: MonadIO m => Int -> m (Ptr a)+mallocBytes = liftIO . F.mallocBytes++#if MIN_VERSION_base(4,8,0)+-- | Lifted 'F.calloc'.+--+-- @since 0.2.5.0+{-# INLINE calloc #-}+calloc :: (MonadIO m, Storable a) => m (Ptr a)+calloc = liftIO F.calloc++-- | Lifted 'F.callocBytes'.+--+-- @since 0.2.5.0+{-# INLINE callocBytes #-}+callocBytes :: MonadIO m => Int -> m (Ptr a)+callocBytes = liftIO . F.callocBytes+#endif++-- | Lifted 'F.realloc'.+--+-- @since 0.2.5.0+{-# INLINE realloc #-}+realloc :: (MonadIO m, Storable b) => Ptr a -> m (Ptr b)+realloc = liftIO . F.realloc++-- | Lifted 'F.reallocBytes'.+--+-- @since 0.2.5.0+{-# INLINE reallocBytes #-}+reallocBytes :: MonadIO m => Ptr a -> Int -> m (Ptr a)+reallocBytes ptr size = liftIO (F.reallocBytes ptr size)++-- | Lifted 'F.free'.+--+-- @since 0.2.5.0+{-# INLINE free #-}+free :: MonadIO m => Ptr a -> m ()+free = liftIO . F.free++-- | Lifted 'F.mallocArray'.+--+-- @since 0.2.5.0+{-# INLINE mallocArray #-}+mallocArray :: (MonadIO m, Storable a) => Int -> m (Ptr a)+mallocArray = liftIO . F.mallocArray++-- | Lifted 'F.mallocArray0'.+--+-- @since 0.2.5.0+{-# INLINE mallocArray0 #-}+mallocArray0 :: (MonadIO m, Storable a) => Int -> m (Ptr a)+mallocArray0 = liftIO . F.mallocArray++-- | Unlifted 'F.allocaArray'.+--+-- @since 0.2.5.0+{-# INLINE allocaArray #-}+allocaArray :: (MonadUnliftIO m, Storable a) => Int -> (Ptr a -> m b) -> m b+allocaArray size action = withRunInIO (\u -> F.allocaArray size (u . action))++-- | Unlifted 'F.allocaArray0'.+--+-- @since 0.2.5.0+{-# INLINE allocaArray0 #-}+allocaArray0 :: (MonadUnliftIO m, Storable a) => Int -> (Ptr a -> m b) -> m b+allocaArray0 size action = withRunInIO (\u -> F.allocaArray0 size (u . action))++-- | Lifted 'F.reallocArray'.+--+-- @since 0.2.5.0+{-# INLINE reallocArray #-}+reallocArray :: (MonadIO m, Storable a) => Ptr a -> Int -> m (Ptr a)+reallocArray ptr size = liftIO (F.reallocArray ptr size)++-- | Lifted 'F.reallocArray0'.+--+-- @since 0.2.5.0+{-# INLINE reallocArray0 #-}+reallocArray0 :: (MonadIO m, Storable a) => Ptr a -> Int -> m (Ptr a)+reallocArray0 ptr size = liftIO (F.reallocArray0 ptr size)++#if MIN_VERSION_base(4,8,0)+-- | Lifted 'F.callocArray'.+--+-- @since 0.2.5.0+{-# INLINE callocArray #-}+callocArray :: (MonadIO m, Storable a) => Int -> m (Ptr a)+callocArray = liftIO . F.callocArray++-- | Lifted 'F.callocArray0'.+--+-- @since 0.2.5.0+{-# INLINE callocArray0 #-}+callocArray0 :: (MonadIO m, Storable a) => Int -> m (Ptr a)+callocArray0 = liftIO . F.callocArray0+#endif++-- | Lifted 'F.peekArray'.+--+-- @since 0.2.5.0+{-# INLINE peekArray #-}+peekArray :: (MonadIO m, Storable a) => Int -> Ptr a -> m [a]+peekArray size ptr = liftIO (F.peekArray size ptr)++-- | Lifted 'F.peekArray0'.+--+-- @since 0.2.5.0+{-# INLINE peekArray0 #-}+peekArray0 :: (MonadIO m, Storable a, Eq a) => a -> Ptr a -> m [a]+peekArray0 marker ptr = liftIO (F.peekArray0 marker ptr)++-- | Lifted 'F.pokeArray'.+--+-- @since 0.2.5.0+{-# INLINE pokeArray #-}+pokeArray :: (MonadIO m, Storable a) => Ptr a -> [a] -> m ()+pokeArray ptr vals0 = liftIO (F.pokeArray ptr vals0)++-- | Lifted 'F.pokeArray0'.+--+-- @since 0.2.5.0+{-# INLINE pokeArray0 #-}+pokeArray0 :: (MonadIO m, Storable a) => a -> Ptr a -> [a] -> m ()+pokeArray0 marker ptr vals0 = liftIO (F.pokeArray0 marker ptr vals0)++-- | Lifted 'F.newArray'.+--+-- @since 0.2.5.0+{-# INLINE newArray #-}+newArray :: (MonadIO m, Storable a) => [a] -> m (Ptr a)+newArray = liftIO . F.newArray++-- | Lifted 'F.newArray0'+--+-- @since 0.2.5.0+{-# INLINE newArray0 #-}+newArray0 :: (MonadIO m, Storable a) => a -> [a] -> m (Ptr a)+newArray0 marker vals = liftIO (F.newArray0 marker vals)++-- | Unlifted 'F.withArray'.+--+-- @since 0.2.5.0+{-# INLINE withArray #-}+withArray :: (MonadUnliftIO m, Storable a) => [a] -> (Ptr a -> m b) -> m b+withArray vals action = withRunInIO (\u -> F.withArray vals (u . action))++-- | Unlifted 'F.withArray0'.+--+-- @since 0.2.5.0+{-# INLINE withArray0 #-}+withArray0 :: (MonadUnliftIO m, Storable a) => a -> [a] -> (Ptr a -> m b) -> m b+withArray0 marker vals action =+  withRunInIO (\u -> F.withArray0 marker vals (u . action))++-- | Unlifted 'F.withArrayLen'.+--+-- @since 0.2.5.0+{-# INLINE withArrayLen #-}+withArrayLen ::+     (MonadUnliftIO m, Storable a) => [a] -> (Int -> Ptr a -> m b) -> m b+withArrayLen vals f =+  withRunInIO (\u -> F.withArrayLen vals (\s p -> u (f s p)))++-- | Unlifted 'F.withArrayLen0'.+--+-- @since 0.2.5.0+{-# INLINE withArrayLen0 #-}+withArrayLen0 ::+     (MonadUnliftIO m, Storable a) => a -> [a] -> (Int -> Ptr a -> m b) -> m b+withArrayLen0 marker vals f =+  withRunInIO (\u -> F.withArrayLen0 marker vals (\s p -> u (f s p)))++-- | Lifted 'F.copyArray'.+--+-- @since 0.2.5.0+{-# INLINE copyArray #-}+copyArray :: (MonadIO m, Storable a) => Ptr a -> Ptr a -> Int -> m ()+copyArray dest src size = liftIO (F.copyArray dest src size)++-- | Lifted 'F.moveArray'.+--+-- @since 0.2.5.0+{-# INLINE moveArray #-}+moveArray :: (MonadIO m, Storable a) => Ptr a -> Ptr a -> Int -> m ()+moveArray dest src size = liftIO (F.moveArray dest src size)++-- | Lifted 'F.lengthArray0'.+--+-- @since 0.2.5.0+{-# INLINE lengthArray0 #-}+lengthArray0 :: (MonadIO m, Storable a, Eq a) => a -> Ptr a -> m Int+lengthArray0 marker ptr = liftIO (F.lengthArray0 marker ptr)++-- | Unlifted 'F.throwIf'.+--+-- @since 0.2.5.0+{-# INLINE throwIf #-}+throwIf :: MonadUnliftIO m => (a -> Bool) -> (a -> String) -> m a -> m a+throwIf pred_ msgfct act = withRunInIO (\u -> F.throwIf pred_ msgfct (u act))++-- | Unlifted 'F.throwIf_'.+--+-- @since 0.2.5.0+{-# INLINE throwIf_ #-}+throwIf_ :: MonadUnliftIO m => (a -> Bool) -> (a -> String) -> m a -> m ()+throwIf_ pred_ msgfct act = withRunInIO (\u -> F.throwIf_ pred_ msgfct (u act))++-- | Unlifted 'F.throwIfNeg'.+--+-- @since 0.2.5.0+{-# INLINE throwIfNeg #-}+throwIfNeg :: (MonadUnliftIO m, Ord a, Num a) => (a -> String) -> m a -> m a+throwIfNeg msgfct act = withRunInIO (\u -> F.throwIfNeg msgfct (u act))++-- | Unlifted 'F.throwIfNeg_'.+--+-- @since 0.2.5.0+{-# INLINE throwIfNeg_ #-}+throwIfNeg_ :: (MonadUnliftIO m, Ord a, Num a) => (a -> String) -> m a -> m ()+throwIfNeg_ msgfct act = withRunInIO (\u -> F.throwIfNeg_ msgfct (u act))++-- | Unlifted 'F.throwIfNull'.+--+-- @since 0.2.5.0+{-# INLINE throwIfNull #-}+throwIfNull :: MonadUnliftIO m => String -> m (Ptr a) -> m (Ptr a)+throwIfNull msg act = withRunInIO (\u -> F.throwIfNull msg (u act))++-- | Lifted 'F.newPool'.+--+-- @since 0.2.5.0+{-# INLINE newPool #-}+newPool :: MonadIO m => m Pool+newPool = liftIO F.newPool++-- | Lifted 'F.freePool'.+--+-- @since 0.2.5.0+{-# INLINE freePool #-}+freePool :: MonadIO m => Pool -> m ()+freePool = liftIO . F.freePool++-- | Unlifted 'F.withPool'.+--+-- @since 0.2.5.0+{-# INLINE withPool #-}+withPool :: MonadUnliftIO m => (Pool -> m b) -> m b+withPool act = withRunInIO (\u -> F.withPool (u . act))++-- | Lifted 'F.pooledMalloc'.+--+-- @since 0.2.5.0+{-# INLINE pooledMalloc #-}+pooledMalloc :: (MonadIO m, Storable a) => Pool -> m (Ptr a)+pooledMalloc = liftIO . F.pooledMalloc++-- | Lifted 'F.pooledMallocBytes'.+--+-- @since 0.2.5.0+{-# INLINE pooledMallocBytes #-}+pooledMallocBytes :: MonadIO m => Pool -> Int -> m (Ptr a)+pooledMallocBytes pool size = liftIO (F.pooledMallocBytes pool size)++-- | Lifted 'F.pooledRealloc'.+--+-- @since 0.2.5.0+{-# INLINE pooledRealloc #-}+pooledRealloc :: (MonadIO m, Storable a) => Pool -> Ptr a -> m (Ptr a)+pooledRealloc pool ptr = liftIO (F.pooledRealloc pool ptr)++-- | Lifted 'F.pooledReallocBytes'.+--+-- @since 0.2.5.0+{-# INLINE pooledReallocBytes #-}+pooledReallocBytes :: MonadIO m => Pool -> Ptr a -> Int -> m (Ptr a)+pooledReallocBytes pool ptr size = liftIO (F.pooledReallocBytes pool ptr size)++-- | Lifted 'F.pooledMallocArray'.+--+-- @since 0.2.5.0+{-# INLINE pooledMallocArray #-}+pooledMallocArray :: (MonadIO m, Storable a) => Pool -> Int -> m (Ptr a)+pooledMallocArray pool size = liftIO (F.pooledMallocArray pool size)++-- | Lifted 'F.pooledMallocArray0'.+--+-- @since 0.2.5.0+{-# INLINE pooledMallocArray0 #-}+pooledMallocArray0 :: (MonadIO m, Storable a) => Pool -> Int -> m (Ptr a)+pooledMallocArray0 pool size = liftIO (F.pooledMallocArray0 pool size)++-- | Lifted 'F.pooledReallocArray'.+--+-- @since 0.2.5.0+{-# INLINE pooledReallocArray #-}+pooledReallocArray ::+     (MonadIO m, Storable a) => Pool -> Ptr a -> Int -> m (Ptr a)+pooledReallocArray pool ptr size = liftIO (F.pooledReallocArray pool ptr size)++-- | Lifted 'F.pooledReallocArray0'.+--+-- @since 0.2.5.0+{-# INLINE pooledReallocArray0 #-}+pooledReallocArray0 ::+     (MonadIO m, Storable a) => Pool -> Ptr a -> Int -> m (Ptr a)+pooledReallocArray0 pool ptr size = liftIO (F.pooledReallocArray0 pool ptr size)++-- | Lifted 'F.pooledNew'.+--+-- @since 0.2.5.0+{-# INLINE pooledNew #-}+pooledNew :: (MonadIO m, Storable a) => Pool -> a -> m (Ptr a)+pooledNew pool val = liftIO (F.pooledNew pool val)++-- | Lifted 'F.pooledNewArray'.+--+-- @since 0.2.5.0+{-# INLINE pooledNewArray #-}+pooledNewArray :: (MonadIO m, Storable a) => Pool -> [a] -> m (Ptr a)+pooledNewArray pool vals = liftIO (F.pooledNewArray pool vals)++-- | Lifted 'F.pooledNewArray0'.+--+-- @since 0.2.5.0+{-# INLINE pooledNewArray0 #-}+pooledNewArray0 :: (MonadIO m, Storable a) => Pool -> a -> [a] -> m (Ptr a)+pooledNewArray0 pool marker vals = liftIO (F.pooledNewArray0 pool marker vals)++-- | Unlifted 'F.with'.+--+-- @since 0.2.5.0+{-# INLINE with #-}+with :: (MonadUnliftIO m, Storable a) => a -> (Ptr a -> m b) -> m b+with val f = withRunInIO (\u -> F.with val (u . f))++-- | Lifted 'F.new'.+--+-- @since 0.2.5.0+{-# INLINE new #-}+new :: (MonadIO m, Storable a) => a -> m (Ptr a)+new = liftIO . F.new++-- | Lifted 'F.maybeNew'.+--+-- @since 0.2.5.0+{-# INLINE maybeNew #-}+maybeNew :: MonadIO m => (a -> m (Ptr b)) -> Maybe a -> m (Ptr b)+maybeNew = maybe (return nullPtr)++-- | Lifted 'F.maybeWith'.+--+-- @since 0.2.5.0+{-# INLINE maybeWith #-}+maybeWith ::+     MonadIO m+  => (a -> (Ptr b -> m c) -> m c)+  -> Maybe a+  -> (Ptr b -> m c)+  -> m c+maybeWith = maybe ($ nullPtr)++-- | Unlifted 'F.maybePeek'.+--+-- @since 0.2.5.0+{-# INLINE maybePeek #-}+maybePeek :: MonadUnliftIO m => (Ptr a -> m b) -> Ptr a -> m (Maybe b)+maybePeek peek_ ptr = withRunInIO (\u -> F.maybePeek (u . peek_) ptr)++-- | Lifted 'F.copyBytes'.+--+-- @since 0.2.5.0+{-# INLINE copyBytes #-}+copyBytes :: MonadIO m => Ptr a -> Ptr a -> Int -> m ()+copyBytes dest src size = liftIO (F.copyBytes dest src size)++-- | Lifted 'F.moveBytes'.+--+-- @since 0.2.5.0+{-# INLINE moveBytes #-}+moveBytes :: MonadIO m => Ptr a -> Ptr a -> Int -> m ()+moveBytes dest src size = liftIO (F.moveBytes dest src size)++#if MIN_VERSION_base(4,8,0)+-- | Lifted 'F.fillBytes'.+--+-- @since 0.2.5.0+{-# INLINE fillBytes #-}+fillBytes :: MonadIO m => Ptr a -> Word8 -> Int -> m ()+fillBytes dest char size = liftIO (F.fillBytes dest char size)+#endif

@@ -0,0 +1,213 @@+{-# LANGUAGE CPP #-}+-- | Unlifted "System.Process".+--+-- @since 0.2.5.0++module UnliftIO.Process (+  -- * Running sub-processes+  CreateProcess(..), CmdSpec(..), StdStream(..), ProcessHandle, createProcess++#if MIN_VERSION_process(1,2,1)+  , createProcess_+#endif++  , P.shell, P.proc++  -- ** Simpler functions for common tasks+  , callProcess, callCommand, spawnProcess, spawnCommand++#if MIN_VERSION_process(1,2,3)+  , readCreateProcess+#endif++  , readProcess++#if MIN_VERSION_process(1,2,3)+  , readCreateProcessWithExitCode+#endif++  , readProcessWithExitCode++#if MIN_VERSION_process(1,4,3)+  , withCreateProcess+#endif++  -- ** Related utilities+  , P.showCommandForUser++  -- * Process completion+  , waitForProcess, getProcessExitCode, terminateProcess, interruptProcessGroupOf++#if MIN_VERSION_process(1,2,1)+  -- * Interprocess communication+  , createPipe+#endif++#if MIN_VERSION_process(1,4,2)+  , createPipeFd+#endif+  ) where++import Control.Monad.IO.Unlift+import System.Exit+import System.IO+import System.Posix.Internals+import System.Process+  ( CmdSpec(..)+  , CreateProcess(..)+  , ProcessHandle+  , StdStream(..)+  )+import qualified System.Process as P++-- | Lifted 'P.createProcess'.+--+-- @since 0.2.5.0+{-# INLINE createProcess #-}+createProcess ::+     MonadIO m+  => CreateProcess+  -> m (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)+createProcess = liftIO . P.createProcess++#if MIN_VERSION_process(1,2,1)+-- | Lifted 'P.createProcess_'.+--+-- @since 0.2.5.0+{-# INLINE createProcess_ #-}+createProcess_ ::+     MonadIO m+  => String+  -> CreateProcess+  -> m (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)+createProcess_ msg proc_ = liftIO (P.createProcess_ msg proc_)+#endif++-- | Lifted 'P.callProcess'.+--+-- @since 0.2.5.0+{-# INLINE callProcess #-}+callProcess :: MonadIO m => FilePath -> [String] -> m ()+callProcess cmd args = liftIO (P.callProcess cmd args)++-- | Lifted 'P.callCommand'.+--+-- @since 0.2.5.0+{-# INLINE callCommand #-}+callCommand :: MonadIO m => String -> m ()+callCommand = liftIO . P.callCommand++-- | Lifted 'P.spawnProcess'.+--+-- @since 0.2.5.0+{-# INLINE spawnProcess #-}+spawnProcess :: MonadIO m => FilePath -> [String] -> m ProcessHandle+spawnProcess cmd args = liftIO (P.spawnProcess cmd args)++-- | Lifted 'P.spawnCommand'.+--+-- @since 0.2.5.0+{-# INLINE spawnCommand #-}+spawnCommand :: MonadIO m => String -> m ProcessHandle+spawnCommand = liftIO . P.spawnCommand++#if MIN_VERSION_process(1,2,3)+-- | Lifted 'P.readCreateProcess'.+--+-- @since 0.2.5.0+{-# INLINE readCreateProcess #-}+readCreateProcess :: MonadIO m => CreateProcess -> String -> m String+readCreateProcess cp input = liftIO (P.readCreateProcess cp input)+#endif++-- | Lifted 'P.readProcess'.+--+-- @since 0.2.5.0+{-# INLINE readProcess #-}+readProcess :: MonadIO m => FilePath -> [String] -> String -> m String+readProcess cmd args input = liftIO (P.readProcess cmd args input)++#if MIN_VERSION_process(1,2,3)+-- | Lifted 'P.readCreateProcessWithExitCode'.+--+-- @since 0.2.5.0+{-# INLINE readCreateProcessWithExitCode #-}+readCreateProcessWithExitCode ::+     MonadIO m => CreateProcess -> String -> m (ExitCode, String, String)+readCreateProcessWithExitCode cp input =+  liftIO (P.readCreateProcessWithExitCode cp input)+#endif++-- | Lifted 'P.readProcessWithExitCode'.+--+-- @since 0.2.5.0+{-# INLINE readProcessWithExitCode #-}+readProcessWithExitCode ::+     MonadIO m => FilePath -> [String] -> String -> m (ExitCode, String, String)+readProcessWithExitCode cmd args input =+  liftIO (P.readProcessWithExitCode cmd args input)++#if MIN_VERSION_process(1,4,3)+-- | Unlifted 'P.withCreateProcess'.+--+-- @since 0.2.5.0+{-# INLINE withCreateProcess #-}+withCreateProcess ::+     MonadUnliftIO m+  => CreateProcess+  -> (Maybe Handle -> Maybe Handle -> Maybe Handle -> ProcessHandle -> m a)+  -> m a+withCreateProcess c action =+  withRunInIO+    (\u ->+       P.withCreateProcess+         c+         (\stdin_h stdout_h stderr_h proc_h ->+            u (action stdin_h stdout_h stderr_h proc_h)))+#endif++-- | Lifted 'P.waitForProcess'.+--+-- @since 0.2.5.0+{-# INLINE waitForProcess #-}+waitForProcess :: MonadIO m => ProcessHandle -> m ExitCode+waitForProcess = liftIO . P.waitForProcess++-- | Lifted 'P.getProcessExitCode'.+--+-- @since 0.2.5.0+{-# INLINE getProcessExitCode #-}+getProcessExitCode :: MonadIO m => ProcessHandle -> m (Maybe ExitCode)+getProcessExitCode = liftIO . P.getProcessExitCode++-- | Lifted 'P.terminateProcess'.+--+-- @since 0.2.5.0+{-# INLINE terminateProcess #-}+terminateProcess :: MonadIO m => ProcessHandle -> m ()+terminateProcess = liftIO . P.terminateProcess++-- | Lifted 'P.interruptProcessGroupOf'.+--+-- @since 0.2.5.0+{-# INLINE interruptProcessGroupOf #-}+interruptProcessGroupOf :: MonadIO m => ProcessHandle -> m ()+interruptProcessGroupOf = liftIO . P.interruptProcessGroupOf++#if MIN_VERSION_process(1,2,1)+-- | Lifted 'P.createPipe'.+--+-- @since 0.2.5.0+{-# INLINE createPipe #-}+createPipe :: MonadIO m => m (Handle, Handle)+createPipe = liftIO P.createPipe+#endif++#if MIN_VERSION_process(1,4,2)+-- | Lifted 'P.createPipeFd'.+--+-- @since 0.2.5.0+{-# INLINE createPipeFd #-}+createPipeFd :: MonadIO m => m (FD, FD)+createPipeFd = liftIO P.createPipeFd+#endif

@@ -70,7 +70,7 @@ withTempFile tmpDir template action =   bracket     (liftIO (openTempFile tmpDir template))-    (\(name, handle) -> liftIO (hClose handle >> ignoringIOErrors (removeFile name)))+    (\(name, handle') -> liftIO (hClose handle' >> ignoringIOErrors (removeFile name)))     (uncurry action)  -- | Create and use a temporary directory.

@@ -2,10 +2,10 @@ -- -- see: https://github.com/sol/hpack ----- hash: 1bad09ed70712d36c4a392da05c02952b932befd883b7013501c876023f34cf2+-- hash: 7eb86a47bfc4a1463d455dd356bf07f248d867021c31a7f0ab4382936315e0ac  name:           unliftio-version:        0.2.4.0+version:        0.2.5.0 synopsis:       The MonadUnliftIO typeclass for unlifting monads to IO (batteries included) description:    Please see the documentation and README at <https://www.stackage.org/package/unliftio> category:       Control@@ -23,20 +23,6 @@     README.md  library-  exposed-modules:-      UnliftIO-      UnliftIO.Async-      UnliftIO.Chan-      UnliftIO.Concurrent-      UnliftIO.Exception-      UnliftIO.IO-      UnliftIO.IORef-      UnliftIO.MVar-      UnliftIO.STM-      UnliftIO.Temporary-      UnliftIO.Timeout-  other-modules:-      Paths_unliftio   hs-source-dirs:       src   build-depends:@@ -45,6 +31,7 @@     , deepseq     , directory     , filepath+    , process >=1.2.0.0     , stm >=2.4.3     , transformers     , unliftio-core >=0.1.1.0@@ -61,15 +48,28 @@     else       c-sources:           cbits/time-posix.c+  exposed-modules:+      UnliftIO+      UnliftIO.Async+      UnliftIO.Chan+      UnliftIO.Concurrent+      UnliftIO.Environment+      UnliftIO.Exception+      UnliftIO.Foreign+      UnliftIO.IO+      UnliftIO.IORef+      UnliftIO.MVar+      UnliftIO.Process+      UnliftIO.STM+      UnliftIO.Temporary+      UnliftIO.Timeout+  other-modules:+      Paths_unliftio   default-language: Haskell2010  test-suite unliftio-spec   type: exitcode-stdio-1.0   main-is: Spec.hs-  other-modules:-      UnliftIO.ExceptionSpec-      UnliftIO.IOSpec-      Paths_unliftio   hs-source-dirs:       test   build-depends:@@ -79,6 +79,7 @@     , directory     , filepath     , hspec+    , process >=1.2.0.0     , stm >=2.4.3     , transformers     , unliftio@@ -86,4 +87,8 @@   if !os(Windows)     build-depends:         unix+  other-modules:+      UnliftIO.ExceptionSpec+      UnliftIO.IOSpec+      Paths_unliftio   default-language: Haskell2010