{-# 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
  ) 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)