{-# LANGUAGE CPP #-}
{-# LANGUAGE PatternSynonyms #-}
module Foreign.C.Error.Pattern
( pattern EOK
, pattern E2BIG
, pattern EACCES
, pattern EADDRINUSE
, pattern EADDRNOTAVAIL
, pattern EADV
, pattern EAFNOSUPPORT
, pattern EAGAIN
, pattern EALREADY
, pattern EBADF
, pattern EBADMSG
, pattern EBADRPC
, pattern EBUSY
, pattern ECHILD
, pattern ECOMM
, pattern ECONNABORTED
, pattern ECONNREFUSED
, pattern ECONNRESET
, pattern EDEADLK
, pattern EDESTADDRREQ
, pattern EDIRTY
, pattern EDOM
, pattern EDQUOT
, pattern EEXIST
, pattern EFAULT
, pattern EFBIG
, pattern EFTYPE
, pattern EHOSTDOWN
, pattern EHOSTUNREACH
, pattern EIDRM
, pattern EILSEQ
, pattern EINPROGRESS
, pattern EINTR
, pattern EINVAL
, pattern EIO
, pattern EISCONN
, pattern EISDIR
, pattern ELOOP
, pattern EMFILE
, pattern EMLINK
, pattern EMSGSIZE
, pattern EMULTIHOP
, pattern ENAMETOOLONG
, pattern ENETDOWN
, pattern ENETRESET
, pattern ENETUNREACH
, pattern ENFILE
, pattern ENOBUFS
, pattern ENODATA
, pattern ENODEV
, pattern ENOENT
, pattern ENOEXEC
, pattern ENOLCK
, pattern ENOLINK
, pattern ENOMEM
, pattern ENOMSG
, pattern ENONET
, pattern ENOPROTOOPT
, pattern ENOSPC
, pattern ENOSR
, pattern ENOSTR
, pattern ENOSYS
, pattern ENOTBLK
, pattern ENOTCONN
, pattern ENOTDIR
, pattern ENOTEMPTY
, pattern ENOTSOCK
, pattern ENOTSUP
, pattern ENOTTY
, pattern ENXIO
, pattern EOPNOTSUPP
, pattern EPERM
, pattern EPFNOSUPPORT
, pattern EPIPE
, pattern EPROCLIM
, pattern EPROCUNAVAIL
, pattern EPROGMISMATCH
, pattern EPROGUNAVAIL
, pattern EPROTO
, pattern EPROTONOSUPPORT
, pattern EPROTOTYPE
, pattern ERANGE
, pattern EREMCHG
, pattern EREMOTE
, pattern EROFS
, pattern ERPCMISMATCH
, pattern ERREMOTE
, pattern ESHUTDOWN
, pattern ESOCKTNOSUPPORT
, pattern ESPIPE
, pattern ESRCH
, pattern ESRMNT
, pattern ESTALE
, pattern ETIME
, pattern ETIMEDOUT
, pattern ETOOMANYREFS
, pattern ETXTBSY
, pattern EUSERS
, pattern EWOULDBLOCK
, pattern EXDEV
, pattern EEOI
) where
import Foreign.C.Error (Errno(Errno))
#include "HsBaseConfig.h"
pattern EOK :: Errno
pattern $bEOK :: Errno
$mEOK :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EOK = Errno 0
pattern E2BIG :: Errno
pattern $bE2BIG :: Errno
$mE2BIG :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
E2BIG = Errno (CONST_E2BIG)
pattern EACCES :: Errno
pattern $bEACCES :: Errno
$mEACCES :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EACCES = Errno (CONST_EACCES)
pattern EADDRINUSE :: Errno
pattern $bEADDRINUSE :: Errno
$mEADDRINUSE :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EADDRINUSE = Errno (CONST_EADDRINUSE)
pattern EADDRNOTAVAIL :: Errno
pattern $bEADDRNOTAVAIL :: Errno
$mEADDRNOTAVAIL :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EADDRNOTAVAIL = Errno (CONST_EADDRNOTAVAIL)
pattern EADV :: Errno
pattern $bEADV :: Errno
$mEADV :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EADV = Errno (CONST_EADV)
pattern EAFNOSUPPORT :: Errno
pattern $bEAFNOSUPPORT :: Errno
$mEAFNOSUPPORT :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EAFNOSUPPORT = Errno (CONST_EAFNOSUPPORT)
pattern EAGAIN :: Errno
pattern $bEAGAIN :: Errno
$mEAGAIN :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EAGAIN = Errno (CONST_EAGAIN)
pattern EALREADY :: Errno
pattern $bEALREADY :: Errno
$mEALREADY :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EALREADY = Errno (CONST_EALREADY)
pattern EBADF :: Errno
pattern $bEBADF :: Errno
$mEBADF :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EBADF = Errno (CONST_EBADF)
pattern EBADMSG :: Errno
pattern $bEBADMSG :: Errno
$mEBADMSG :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EBADMSG = Errno (CONST_EBADMSG)
pattern EBADRPC :: Errno
pattern $bEBADRPC :: Errno
$mEBADRPC :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EBADRPC = Errno (CONST_EBADRPC)
pattern EBUSY :: Errno
pattern $bEBUSY :: Errno
$mEBUSY :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EBUSY = Errno (CONST_EBUSY)
pattern ECHILD :: Errno
pattern $bECHILD :: Errno
$mECHILD :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ECHILD = Errno (CONST_ECHILD)
pattern ECOMM :: Errno
pattern $bECOMM :: Errno
$mECOMM :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ECOMM = Errno (CONST_ECOMM)
pattern ECONNABORTED :: Errno
pattern $bECONNABORTED :: Errno
$mECONNABORTED :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ECONNABORTED = Errno (CONST_ECONNABORTED)
pattern ECONNREFUSED :: Errno
pattern $bECONNREFUSED :: Errno
$mECONNREFUSED :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ECONNREFUSED = Errno (CONST_ECONNREFUSED)
pattern ECONNRESET :: Errno
pattern $bECONNRESET :: Errno
$mECONNRESET :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ECONNRESET = Errno (CONST_ECONNRESET)
pattern EDEADLK :: Errno
pattern $bEDEADLK :: Errno
$mEDEADLK :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EDEADLK = Errno (CONST_EDEADLK)
pattern EDESTADDRREQ :: Errno
pattern $bEDESTADDRREQ :: Errno
$mEDESTADDRREQ :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EDESTADDRREQ = Errno (CONST_EDESTADDRREQ)
pattern EDIRTY :: Errno
pattern $bEDIRTY :: Errno
$mEDIRTY :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EDIRTY = Errno (CONST_EDIRTY)
pattern EDOM :: Errno
pattern $bEDOM :: Errno
$mEDOM :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EDOM = Errno (CONST_EDOM)
pattern EDQUOT :: Errno
pattern $bEDQUOT :: Errno
$mEDQUOT :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EDQUOT = Errno (CONST_EDQUOT)
pattern EEXIST :: Errno
pattern $bEEXIST :: Errno
$mEEXIST :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EEXIST = Errno (CONST_EEXIST)
pattern EFAULT :: Errno
pattern $bEFAULT :: Errno
$mEFAULT :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EFAULT = Errno (CONST_EFAULT)
pattern EFBIG :: Errno
pattern $bEFBIG :: Errno
$mEFBIG :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EFBIG = Errno (CONST_EFBIG)
pattern EFTYPE :: Errno
pattern $bEFTYPE :: Errno
$mEFTYPE :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EFTYPE = Errno (CONST_EFTYPE)
pattern EHOSTDOWN :: Errno
pattern $bEHOSTDOWN :: Errno
$mEHOSTDOWN :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EHOSTDOWN = Errno (CONST_EHOSTDOWN)
pattern EHOSTUNREACH :: Errno
pattern $bEHOSTUNREACH :: Errno
$mEHOSTUNREACH :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EHOSTUNREACH = Errno (CONST_EHOSTUNREACH)
pattern EIDRM :: Errno
pattern $bEIDRM :: Errno
$mEIDRM :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EIDRM = Errno (CONST_EIDRM)
pattern EILSEQ :: Errno
pattern $bEILSEQ :: Errno
$mEILSEQ :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EILSEQ = Errno (CONST_EILSEQ)
pattern EINPROGRESS :: Errno
pattern $bEINPROGRESS :: Errno
$mEINPROGRESS :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EINPROGRESS = Errno (CONST_EINPROGRESS)
pattern EINTR :: Errno
pattern $bEINTR :: Errno
$mEINTR :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EINTR = Errno (CONST_EINTR)
pattern EINVAL :: Errno
pattern $bEINVAL :: Errno
$mEINVAL :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EINVAL = Errno (CONST_EINVAL)
pattern EIO :: Errno
pattern $bEIO :: Errno
$mEIO :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EIO = Errno (CONST_EIO)
pattern EISCONN :: Errno
pattern $bEISCONN :: Errno
$mEISCONN :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EISCONN = Errno (CONST_EISCONN)
pattern EISDIR :: Errno
pattern $bEISDIR :: Errno
$mEISDIR :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EISDIR = Errno (CONST_EISDIR)
pattern ELOOP :: Errno
pattern $bELOOP :: Errno
$mELOOP :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ELOOP = Errno (CONST_ELOOP)
pattern EMFILE :: Errno
pattern $bEMFILE :: Errno
$mEMFILE :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EMFILE = Errno (CONST_EMFILE)
pattern EMLINK :: Errno
pattern $bEMLINK :: Errno
$mEMLINK :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EMLINK = Errno (CONST_EMLINK)
pattern EMSGSIZE :: Errno
pattern $bEMSGSIZE :: Errno
$mEMSGSIZE :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EMSGSIZE = Errno (CONST_EMSGSIZE)
pattern EMULTIHOP :: Errno
pattern $bEMULTIHOP :: Errno
$mEMULTIHOP :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EMULTIHOP = Errno (CONST_EMULTIHOP)
pattern ENAMETOOLONG :: Errno
pattern $bENAMETOOLONG :: Errno
$mENAMETOOLONG :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ENAMETOOLONG = Errno (CONST_ENAMETOOLONG)
pattern ENETDOWN :: Errno
pattern $bENETDOWN :: Errno
$mENETDOWN :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ENETDOWN = Errno (CONST_ENETDOWN)
pattern ENETRESET :: Errno
pattern $bENETRESET :: Errno
$mENETRESET :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ENETRESET = Errno (CONST_ENETRESET)
pattern ENETUNREACH :: Errno
pattern $bENETUNREACH :: Errno
$mENETUNREACH :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ENETUNREACH = Errno (CONST_ENETUNREACH)
pattern ENFILE :: Errno
pattern $bENFILE :: Errno
$mENFILE :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ENFILE = Errno (CONST_ENFILE)
pattern ENOBUFS :: Errno
pattern $bENOBUFS :: Errno
$mENOBUFS :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ENOBUFS = Errno (CONST_ENOBUFS)
pattern ENODATA :: Errno
pattern $bENODATA :: Errno
$mENODATA :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ENODATA = Errno (CONST_ENODATA)
pattern ENODEV :: Errno
pattern $bENODEV :: Errno
$mENODEV :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ENODEV = Errno (CONST_ENODEV)
pattern ENOENT :: Errno
pattern $bENOENT :: Errno
$mENOENT :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ENOENT = Errno (CONST_ENOENT)
pattern ENOEXEC :: Errno
pattern $bENOEXEC :: Errno
$mENOEXEC :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ENOEXEC = Errno (CONST_ENOEXEC)
pattern ENOLCK :: Errno
pattern $bENOLCK :: Errno
$mENOLCK :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ENOLCK = Errno (CONST_ENOLCK)
pattern ENOLINK :: Errno
pattern $bENOLINK :: Errno
$mENOLINK :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ENOLINK = Errno (CONST_ENOLINK)
pattern ENOMEM :: Errno
pattern $bENOMEM :: Errno
$mENOMEM :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ENOMEM = Errno (CONST_ENOMEM)
pattern ENOMSG :: Errno
pattern $bENOMSG :: Errno
$mENOMSG :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ENOMSG = Errno (CONST_ENOMSG)
pattern ENONET :: Errno
pattern $bENONET :: Errno
$mENONET :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ENONET = Errno (CONST_ENONET)
pattern ENOPROTOOPT :: Errno
pattern $bENOPROTOOPT :: Errno
$mENOPROTOOPT :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ENOPROTOOPT = Errno (CONST_ENOPROTOOPT)
pattern ENOSPC :: Errno
pattern $bENOSPC :: Errno
$mENOSPC :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ENOSPC = Errno (CONST_ENOSPC)
pattern ENOSR :: Errno
pattern $bENOSR :: Errno
$mENOSR :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ENOSR = Errno (CONST_ENOSR)
pattern ENOSTR :: Errno
pattern $bENOSTR :: Errno
$mENOSTR :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ENOSTR = Errno (CONST_ENOSTR)
pattern ENOSYS :: Errno
pattern $bENOSYS :: Errno
$mENOSYS :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ENOSYS = Errno (CONST_ENOSYS)
pattern ENOTBLK :: Errno
pattern $bENOTBLK :: Errno
$mENOTBLK :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ENOTBLK = Errno (CONST_ENOTBLK)
pattern ENOTCONN :: Errno
pattern $bENOTCONN :: Errno
$mENOTCONN :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ENOTCONN = Errno (CONST_ENOTCONN)
pattern ENOTDIR :: Errno
pattern $bENOTDIR :: Errno
$mENOTDIR :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ENOTDIR = Errno (CONST_ENOTDIR)
pattern ENOTEMPTY :: Errno
pattern $bENOTEMPTY :: Errno
$mENOTEMPTY :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ENOTEMPTY = Errno (CONST_ENOTEMPTY)
pattern ENOTSOCK :: Errno
pattern $bENOTSOCK :: Errno
$mENOTSOCK :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ENOTSOCK = Errno (CONST_ENOTSOCK)
pattern ENOTSUP :: Errno
pattern $bENOTSUP :: Errno
$mENOTSUP :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ENOTSUP = Errno (CONST_ENOTSUP)
pattern ENOTTY :: Errno
pattern $bENOTTY :: Errno
$mENOTTY :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ENOTTY = Errno (CONST_ENOTTY)
pattern ENXIO :: Errno
pattern $bENXIO :: Errno
$mENXIO :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ENXIO = Errno (CONST_ENXIO)
pattern EOPNOTSUPP :: Errno
pattern $bEOPNOTSUPP :: Errno
$mEOPNOTSUPP :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EOPNOTSUPP = Errno (CONST_EOPNOTSUPP)
pattern EPERM :: Errno
pattern $bEPERM :: Errno
$mEPERM :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EPERM = Errno (CONST_EPERM)
pattern EPFNOSUPPORT :: Errno
pattern $bEPFNOSUPPORT :: Errno
$mEPFNOSUPPORT :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EPFNOSUPPORT = Errno (CONST_EPFNOSUPPORT)
pattern EPIPE :: Errno
pattern $bEPIPE :: Errno
$mEPIPE :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EPIPE = Errno (CONST_EPIPE)
pattern EPROCLIM :: Errno
pattern $bEPROCLIM :: Errno
$mEPROCLIM :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EPROCLIM = Errno (CONST_EPROCLIM)
pattern EPROCUNAVAIL :: Errno
pattern $bEPROCUNAVAIL :: Errno
$mEPROCUNAVAIL :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EPROCUNAVAIL = Errno (CONST_EPROCUNAVAIL)
pattern EPROGMISMATCH :: Errno
pattern $bEPROGMISMATCH :: Errno
$mEPROGMISMATCH :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EPROGMISMATCH = Errno (CONST_EPROGMISMATCH)
pattern EPROGUNAVAIL :: Errno
pattern $bEPROGUNAVAIL :: Errno
$mEPROGUNAVAIL :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EPROGUNAVAIL = Errno (CONST_EPROGUNAVAIL)
pattern EPROTO :: Errno
pattern $bEPROTO :: Errno
$mEPROTO :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EPROTO = Errno (CONST_EPROTO)
pattern EPROTONOSUPPORT :: Errno
pattern $bEPROTONOSUPPORT :: Errno
$mEPROTONOSUPPORT :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EPROTONOSUPPORT=Errno (CONST_EPROTONOSUPPORT)
pattern EPROTOTYPE :: Errno
pattern $bEPROTOTYPE :: Errno
$mEPROTOTYPE :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EPROTOTYPE = Errno (CONST_EPROTOTYPE)
pattern ERANGE :: Errno
pattern $bERANGE :: Errno
$mERANGE :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ERANGE = Errno (CONST_ERANGE)
pattern EREMCHG :: Errno
pattern $bEREMCHG :: Errno
$mEREMCHG :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EREMCHG = Errno (CONST_EREMCHG)
pattern EREMOTE :: Errno
pattern $bEREMOTE :: Errno
$mEREMOTE :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EREMOTE = Errno (CONST_EREMOTE)
pattern EROFS :: Errno
pattern $bEROFS :: Errno
$mEROFS :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EROFS = Errno (CONST_EROFS)
pattern ERPCMISMATCH :: Errno
pattern $bERPCMISMATCH :: Errno
$mERPCMISMATCH :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ERPCMISMATCH = Errno (CONST_ERPCMISMATCH)
pattern ERREMOTE :: Errno
pattern $bERREMOTE :: Errno
$mERREMOTE :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ERREMOTE = Errno (CONST_ERREMOTE)
pattern ESHUTDOWN :: Errno
pattern $bESHUTDOWN :: Errno
$mESHUTDOWN :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ESHUTDOWN = Errno (CONST_ESHUTDOWN)
pattern ESOCKTNOSUPPORT :: Errno
pattern $bESOCKTNOSUPPORT :: Errno
$mESOCKTNOSUPPORT :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ESOCKTNOSUPPORT=Errno (CONST_ESOCKTNOSUPPORT)
pattern ESPIPE :: Errno
pattern $bESPIPE :: Errno
$mESPIPE :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ESPIPE = Errno (CONST_ESPIPE)
pattern ESRCH :: Errno
pattern $bESRCH :: Errno
$mESRCH :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ESRCH = Errno (CONST_ESRCH)
pattern ESRMNT :: Errno
pattern $bESRMNT :: Errno
$mESRMNT :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ESRMNT = Errno (CONST_ESRMNT)
pattern ESTALE :: Errno
pattern $bESTALE :: Errno
$mESTALE :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ESTALE = Errno (CONST_ESTALE)
pattern ETIME :: Errno
pattern $bETIME :: Errno
$mETIME :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ETIME = Errno (CONST_ETIME)
pattern ETIMEDOUT :: Errno
pattern $bETIMEDOUT :: Errno
$mETIMEDOUT :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ETIMEDOUT = Errno (CONST_ETIMEDOUT)
pattern ETOOMANYREFS :: Errno
pattern $bETOOMANYREFS :: Errno
$mETOOMANYREFS :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ETOOMANYREFS = Errno (CONST_ETOOMANYREFS)
pattern ETXTBSY :: Errno
pattern $bETXTBSY :: Errno
$mETXTBSY :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
ETXTBSY = Errno (CONST_ETXTBSY)
pattern EUSERS :: Errno
pattern $bEUSERS :: Errno
$mEUSERS :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EUSERS = Errno (CONST_EUSERS)
pattern EWOULDBLOCK :: Errno
pattern $bEWOULDBLOCK :: Errno
$mEWOULDBLOCK :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EWOULDBLOCK = Errno (CONST_EWOULDBLOCK)
pattern EXDEV :: Errno
pattern $bEXDEV :: Errno
$mEXDEV :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EXDEV = Errno (CONST_EXDEV)
pattern EEOI :: Errno
pattern $bEEOI :: Errno
$mEEOI :: forall {r}. Errno -> ((# #) -> r) -> ((# #) -> r) -> r
EEOI = Errno 254