Modulebase-4.23.0.0Haskell2010

System.IO.OS

This module bridges between Haskell handles and underlying operating-system features.

8 values

Packagebase-4.23.0.0
Exports8
LanguageHaskell2010
LicenceBSD-3-Clause
SourceOS.hs

Obtaining file descriptors and Windows handles

8 declarations

valuewithFileDescriptorReadingBiased :: Handle -> (CInt -> IO r) -> IO r

Executes a user-provided action on the POSIX file descriptor that underlies a handle or specifically on the POSIX file descriptor for reading if the handle uses different file descriptors for reading and writing. The Haskell-managed buffers related to the file descriptor are flushed before the user-provided action is run. While this action is executed, further operations on the handle are blocked to a degree that interference with this action is prevented.

If the handle does not use POSIX file descriptors, an exception is thrown.

See below for caveats regarding this operation.

valuewithFileDescriptorWritingBiased :: Handle -> (CInt -> IO r) -> IO r

Executes a user-provided action on the POSIX file descriptor that underlies a handle or specifically on the POSIX file descriptor for writing if the handle uses different file descriptors for reading and writing. The Haskell-managed buffers related to the file descriptor are flushed before the user-provided action is run. While this action is executed, further operations on the handle are blocked to a degree that interference with this action is prevented.

If the handle does not use POSIX file descriptors, an exception is thrown.

See below for caveats regarding this operation.

valuewithWindowsHandleReadingBiased :: Handle -> (Ptr () -> IO r) -> IO r

Executes a user-provided action on the Windows handle that underlies a Haskell handle or specifically on the Windows handle for reading if the Haskell handle uses different Windows handles for reading and writing. The Haskell-managed buffers related to the Windows handle are flushed before the user-provided action is run. While this action is executed, further operations on the Haskell handle are blocked to a degree that interference with this action is prevented.

If the Haskell handle does not use Windows handles, an exception is thrown.

See below for caveats regarding this operation.

valuewithWindowsHandleWritingBiased :: Handle -> (Ptr () -> IO r) -> IO r

Executes a user-provided action on the Windows handle that underlies a Haskell handle or specifically on the Windows handle for writing if the Haskell handle uses different Windows handles for reading and writing. The Haskell-managed buffers related to the Windows handle are flushed before the user-provided action is run. While this action is executed, further operations on the Haskell handle are blocked to a degree that interference with this action is prevented.

If the Haskell handle does not use Windows handles, an exception is thrown.

See below for caveats regarding this operation.

valuewithFileDescriptorReadingBiasedRaw :: Handle -> (CInt -> IO r) -> IO r

Like withFileDescriptorReadingBiased except that Haskell-managed buffers are not flushed.

valuewithFileDescriptorWritingBiasedRaw :: Handle -> (CInt -> IO r) -> IO r

Like withFileDescriptorWritingBiased except that Haskell-managed buffers are not flushed.

valuewithWindowsHandleReadingBiasedRaw :: Handle -> (Ptr () -> IO r) -> IO r

Like withWindowsHandleReadingBiased except that Haskell-managed buffers are not flushed.

valuewithWindowsHandleWritingBiasedRaw :: Handle -> (Ptr () -> IO r) -> IO r

Like withWindowsHandleWritingBiased except that Haskell-managed buffers are not flushed.

Caveats

There are the following caveats regarding the above operations:

Flushing of buffers can fail if the given handle is readable but not seekable.
If one of these operations is performed as part of an action executed by unsafePerformIO, unsafeInterleaveIO, or one of their “dupable” variants and the user-provided action receives an asychnchronous exception and does not catch it, then the following happens:
- Before the overall computation is suspended, the blocking of handle operations is removed.
- When the computation is later resumed due to another evaluation attempt, the blocking of handle operations is reinstantiated, the Haskell-managed buffers are flushed again, and the user-provided action is run from the beginning.

Repeating the previously executed part of the user-provided action cannot be avoided apparently. See the [async] note in the source code of GHC.Internal.IO.Handle.Internals for further explanation.