mask

mask :: ((forall a. IO a -> IO a) -> IO b) -> IO b
base Control.Exception.Base, base Control.Exception
Executes an IO computation with asynchronous exceptions masked. That is, any thread which attempts to raise an exception in the current thread with Control.Exception.throwTo will be blocked until asynchronous exceptions are unmasked again. The argument passed to mask is a function that takes as its argument another function, which can be used to restore the prevailing masking state within the context of the masked computation. For example, a common way to use mask is to protect the acquisition of a resource: > mask $ \restore -> do > x <- acquire > restore (do_something_with x) `onException` release > release This code guarantees that acquire is paired with release, by masking asynchronous exceptions for the critical parts. (Rather than write this code yourself, it would be better to use Control.Exception.bracket which abstracts the general pattern). Note that the restore action passed to the argument to mask does not necessarily unmask asynchronous exceptions, it just restores the masking state to that of the enclosing context. Thus if asynchronous exceptions are already masked, mask cannot be used to unmask exceptions again. This is so that if you call a library function with exceptions masked, you can be sure that the library call will not be able to unmask exceptions again. If you are writing library code and need to use asynchronous exceptions, the only way is to create a new thread; see Control.Concurrent.forkIOUnmasked. Asynchronous exceptions may still be received while in the masked state if the masked thread blocks in certain ways; see Control.Exception#interruptible. Threads created by Control.Concurrent.forkIO inherit the masked state from the parent; that is, to start a thread in blocked mode, use mask_ $ forkIO .... This is particularly useful if you need to establish an exception handler in the forked thread before any asynchronous exceptions are received. To create a a new thread in an unmasked state use Control.Concurrent.forkIOUnmasked.
mask_ :: IO a -> IO a
base Control.Exception.Base, base Control.Exception
Like mask, but does not pass a restore action to the argument.
MaskedInterruptible :: MaskingState
base Control.Exception.Base, base Control.Exception
the state during mask: asynchronous exceptions are masked, but blocking operations may still be interrupted
MaskedUninterruptible :: MaskingState
base Control.Exception.Base, base Control.Exception
the state during uninterruptibleMask: asynchronous exceptions are masked, and blocking operations may not be interrupted
data MaskingState
base Control.Exception.Base, base Control.Exception
Describes the behaviour of a thread when an asynchronous exception is received.
forkIOUnmasked :: IO () -> IO ThreadId
base Control.Concurrent, base GHC.Conc.Sync, base GHC.Conc
Like forkIO, but the child thread is created with asynchronous exceptions unmasked (see Control.Exception.mask).
getMaskingState :: IO MaskingState
base Control.Exception.Base, base Control.Exception
Returns the MaskingState for the current thread.
uninterruptibleMask :: ((forall a. IO a -> IO a) -> IO b) -> IO b
base Control.Exception.Base, base Control.Exception
Like mask, but the masked computation is not interruptible (see Control.Exception#interruptible). THIS SHOULD BE USED WITH GREAT CARE, because if a thread executing in uninterruptibleMask blocks for any reason, then the thread (and possibly the program, if this is the main thread) will be unresponsive and unkillable. This function should only be necessary if you need to mask exceptions around an interruptible operation, and you can guarantee that the interruptible operation will only block for a short period of time.
uninterruptibleMask_ :: IO a -> IO a
base Control.Exception.Base, base Control.Exception
Like uninterruptibleMask, but does not pass a restore action to the argument.
Unmasked :: MaskingState
base Control.Exception.Base, base Control.Exception
asynchronous exceptions are unmasked (the normal state)
colorMask :: StateVar (Color4 Capability)
OpenGL Graphics.Rendering.OpenGL.GL.Framebuffer
Controls whether the individual color components in the framebuffer can or cannot be written. If the red flag is Disabled, for example, no change is made to the red component of any pixel in any of the color buffers, regardless of the drawing operation attempted. Initially, all color components can be written. Changes to individual bits of components cannot be controlled. Rather, changes are either enabled or disabled for entire color components. Furthermore, this mask is used only in RGBA mode.
colorMaski :: DrawBufferIndex -> StateVar (Color4 Capability)
OpenGL Graphics.Rendering.OpenGL.GL.Framebuffer
colorMaski is a version of colorMask that only applies to the specified drawbuffer
depthMask :: StateVar Capability
OpenGL Graphics.Rendering.OpenGL.GL.Framebuffer
Controls whether the depth buffer is enabled for writing. The initial state is Enabled.
forkOnIOUnmasked :: Int -> IO () -> IO ThreadId
base GHC.Conc.Sync, base GHC.Conc
Like forkOnIO, but the child thread is created with asynchronous exceptions unmasked (see Control.Exception.mask).
getSignalMask :: IO SignalSet
unix System.Posix.Signals
getSignalMask calls sigprocmask to determine the set of interrupts which are currently being blocked.
indexMask :: StateVar GLuint
OpenGL Graphics.Rendering.OpenGL.GL.Framebuffer
Controls the writing of individual bits in the color index buffers. The least significant n bits of its value, the number of bits in a color index buffer, specify a mask. Where a 1 appears in the mask, it is possible to write to the corresponding bit in the color index buffer (or buffers). Where a 0 appears, the corresponding bit is write-protected. This mask is used only in color index mode, and it affects only the buffers currently selected for writing (see drawBuffer). Initially, all bits are enabled for writing.
maxSampleMaskWords :: GettableStateVar GLsizei
OpenGL Graphics.Rendering.OpenGL.GL.Texturing.Specification
setFileCreationMask :: FileMode -> IO FileMode
unix System.Posix.Files.ByteString, unix System.Posix.Files
setFileCreationMask mode sets the file mode creation mask to mode. Modes set by this operation are subtracted from files and directories upon creation. The previous file creation mask is returned. Note: calls umask.
setSignalMask :: SignalSet -> IO ()
unix System.Posix.Signals
setSignalMask mask calls sigprocmask with SIG_SETMASK to block all interrupts in mask.
stencilMask :: StateVar GLuint
OpenGL Graphics.Rendering.OpenGL.GL.Framebuffer
Controls the writing of individual bits in the stencil planes. The least significant n bits of its value, number of bits in the stencil buffer, specify a mask. Where a 1 appears in the mask, it is possible to write to the corresponding bit in the stencil buffer. Where a 0 appears, the corresponding bit is write-protected. Initially, all bits are enabled for writing.

Show more results