unsafe -package

unsafeCoerce :: a -> b
base Unsafe.Coerce
unsafeForeignPtrToPtr :: ForeignPtr a -> Ptr a
base Foreign.ForeignPtr
This function extracts the pointer component of a foreign pointer. This is a potentially dangerous operations, as if the argument to unsafeForeignPtrToPtr is the last usage occurrence of the given foreign pointer, then its finalizer(s) will be run, which potentially invalidates the plain pointer just obtained. Hence, touchForeignPtr must be used wherever it has to be guaranteed that the pointer lives on - i.e., has another usage occurrence. To avoid subtle coding errors, hand written marshalling code should preferably use Foreign.ForeignPtr.withForeignPtr rather than combinations of unsafeForeignPtrToPtr and touchForeignPtr. However, the latter routines are occasionally preferred in tool generated marshalling code.
unsafeInterleaveIO :: IO a -> IO a
base System.IO.Unsafe
unsafeInterleaveIO allows IO computation to be deferred lazily. When passed a value of type IO a, the IO will only be performed when the value of the a is demanded. This is used to implement lazy file reading, see System.IO.hGetContents.
unsafeInterleaveST :: ST s a -> ST s a
base Control.Monad.ST, base Control.Monad.ST.Lazy
unsafeIOToST :: IO a -> ST s a
base Control.Monad.ST, base Control.Monad.ST.Lazy
unsafeLocalState :: IO a -> a
base Foreign.Marshal
Sometimes an external entity is a pure function, except that it passes arguments and/or results via pointers. The function unsafeLocalState permits the packaging of such entities as pure functions. The only IO operations allowed in the IO action passed to unsafeLocalState are (a) local allocation (alloca, allocaBytes and derived operations such as withArray and withCString), and (b) pointer operations (Foreign.Storable and Foreign.Ptr) on the pointers to local storage, and (c) foreign functions whose only observable effect is to read and/or write the locally allocated memory. Passing an IO operation that does not obey these rules results in undefined behaviour. It is expected that this operation will be replaced in a future revision of Haskell.
unsafePerformIO :: IO a -> a
base System.IO.Unsafe, base Foreign
This is the "back door" into the IO monad, allowing IO computation to be performed at any time. For this to be safe, the IO computation should be free of side effects and independent of its environment. If the I/O computation wrapped in unsafePerformIO performs side effects, then the relative order in which those side effects take place (relative to the main I/O trunk, or other calls to unsafePerformIO) is indeterminate. Furthermore, when using unsafePerformIO to cause side-effects, you should take the following precautions to ensure the side effects are performed as many times as you expect them to be. Note that these precautions are necessary for GHC, but may not be sufficient, and other compilers may require different precautions: * Use {-# NOINLINE foo #-} as a pragma on any function foo that calls unsafePerformIO. If the call is inlined, the I/O may be performed more than once. * Use the compiler flag -fno-cse to prevent common sub-expression elimination being performed on the module, which might combine two side effects that were meant to be separate. A good example is using multiple global variables (like test in the example below). * Make sure that the either you switch off let-floating (-fno-full-laziness), or that the call to unsafePerformIO cannot float outside a lambda. For example, if you say:  f x = unsafePerformIO (newIORef [])  you may get only one reference cell shared between all calls to f. Better would be  f x = unsafePerformIO (newIORef [x])  because now it can't float outside the lambda. It is less well known that unsafePerformIO is not type safe. For example: > test :: IORef [a] > test = unsafePerformIO $ newIORef [] > > main = do > writeIORef test [42] > bang <- readIORef test > print (bang :: [Char]) This program will core dump. This problem with polymorphic references is well known in the ML community, and does not arise with normal monadic use of references. There is no easy way to make it impossible once you use unsafePerformIO. Indeed, it is possible to write coerce :: a -> b with the help of unsafePerformIO. So be careful!
unsafeSTToIO :: ST s a -> IO a
base Control.Monad.ST
unsafeCopyToPtr :: Text -> Ptr Word16 -> IO ()
text Data.Text.Foreign
O(n) Copy a Text to an array. The array is assumed to be big enough to hold the contents of the entire Text.
unsafeDrop :: Int -> ByteString -> ByteString
bytestring Data.ByteString.Unsafe
A variety of drop which omits the checks on n so there is an obligation on the programmer to provide a proof that 0 <= n <= length xs.
unsafeDupablePerformIO :: IO a -> a
text Data.Text.Unsafe
This version of unsafePerformIO is more efficient because it omits the check that the IO is only being performed by a single thread. Hence, when you use unsafeDupablePerformIO, there is a possibility that the IO action may be performed multiple times (on a multiprocessor), and you should therefore ensure that it gives the same results each time.
unsafeFinalize :: ByteString -> IO ()
bytestring Data.ByteString.Unsafe
Explicitly run the finaliser associated with a ByteString. References to this value after finalisation may generate invalid memory references. This function is unsafe, as there may be other ByteStrings referring to the same underlying pages. If you use this, you need to have a proof of some kind that all ByteStrings ever generated from the underlying byte array are no longer live.
unsafeForeignPtrToStorableArray :: Ix i => ForeignPtr e -> (i, i) -> IO (StorableArray i e)
array Data.Array.Unsafe, array Data.Array.Storable
Construct a StorableArray from an arbitrary ForeignPtr. It is the caller's responsibility to ensure that the ForeignPtr points to an area of memory sufficient for the specified bounds.
unsafeFreeze :: MArray s -> ST s Array
text Data.Text.Array
Freeze a mutable array. Do not mutate the MArray afterwards!
unsafeFreeze :: (Ix i, MArray a e m, IArray b e) => a i e -> m (b i e)
array Data.Array.MArray, array Data.Array.Unsafe
Converts an mutable array into an immutable array. The implementation may either simply cast the array from one type to the other without copying the array, or it may take a full copy of the array. Note that because the array is possibly not copied, any subsequent modifications made to the mutable version of the array may be shared with the immutable version. It is safe to use, therefore, if the mutable version is never modified after the freeze operation. The non-copying implementation is supported between certain pairs of array types only; one constraint is that the array types must have identical representations. In GHC, The following pairs of array types have a non-copying O(1) implementation of unsafeFreeze. Because the optimised versions are enabled by specialisations, you will need to compile with optimisation (-O) to get them. * IOUArray -> UArray * STUArray -> UArray * IOArray -> Array * STArray -> Array
unsafeHead :: ByteString -> Word8
bytestring Data.ByteString.Unsafe
A variety of head for non-empty ByteStrings. unsafeHead omits the check for the empty case, so there is an obligation on the programmer to provide a proof that the ByteString is non-empty.
unsafeHead :: Text -> Char
text Data.Text.Unsafe
O(1) A variant of head for non-empty Text. unsafeHead omits the check for the empty case, so there is an obligation on the programmer to provide a proof that the Text is non-empty.
unsafeIndex :: Array -> Int -> Word16
text Data.Text.Array
Unchecked read of an immutable array. May return garbage or crash on an out-of-bounds access.
unsafeIndex :: ByteString -> Int -> Word8
bytestring Data.ByteString.Unsafe
Unsafe ByteString index (subscript) operator, starting from 0, returning a Word8 This omits the bounds check, which means there is an accompanying obligation on the programmer to ensure the bounds are checked in some other way.
unsafeInit :: ByteString -> ByteString
bytestring Data.ByteString.Unsafe
A variety of init for non-empty ByteStrings. unsafeInit omits the check for the empty case. As with unsafeHead, the programmer must provide a separate proof that the ByteString is non-empty.
unsafeIOToSTM :: IO a -> STM a
base GHC.Conc.Sync, base GHC.Conc
Unsafely performs IO in the STM monad. Beware: this is a highly dangerous thing to do. * The STM implementation will often run transactions multiple times, so you need to be prepared for this if your IO has any side effects. * The STM implementation will abort transactions that are known to be invalid and need to be restarted. This may happen in the middle of unsafeIOToSTM, so make sure you don't acquire any resources that need releasing (exception handlers are ignored when aborting the transaction). That includes doing any IO using Handles, for example. Getting this wrong will probably lead to random deadlocks. * The transaction may have seen an inconsistent view of memory when the IO runs. Invariants that you expect to be true throughout your program may not be true inside a transaction, due to the way transactions are implemented. Normally this wouldn't be visible to the programmer, but using unsafeIOToSTM can expose it.
unsafeLast :: ByteString -> Word8
bytestring Data.ByteString.Unsafe
A variety of last for non-empty ByteStrings. unsafeLast omits the check for the empty case. As with unsafeHead, the programmer must provide a separate proof that the ByteString is non-empty.
unsafePackAddress :: Addr# -> IO ByteString
bytestring Data.ByteString.Unsafe
O(n) Pack a null-terminated sequence of bytes, pointed to by an Addr# (an arbitrary machine address assumed to point outside the garbage-collected heap) into a ByteString. A much faster way to create an Addr# is with an unboxed string literal, than to pack a boxed string. A unboxed string literal is compiled to a static char [] by GHC. Establishing the length of the string requires a call to strlen(3), so the Addr# must point to a null-terminated buffer (as is the case with string# literals in GHC). Use unsafePackAddressLen if you know the length of the string statically. An example: > literalFS = unsafePackAddress "literal"# This function is unsafe. If you modify the buffer pointed to by the original Addr# this modification will be reflected in the resulting ByteString, breaking referential transparency. Note this also won't work if you Add# has embedded '\0' characters in the string (strlen will fail).
unsafePackAddressLen :: Int -> Addr# -> IO ByteString
bytestring Data.ByteString.Unsafe
O(1) unsafePackAddressLen provides constant-time construction of ByteStrings which is ideal for string literals. It packs a sequence of bytes into a ByteString, given a raw Addr# to the string, and the length of the string. This function is unsafe in two ways: * the length argument is assumed to be correct. If the length argument is incorrect, it is possible to overstep the end of the byte array. * if the underying Addr# is later modified, this change will be reflected in resulting ByteString, breaking referential transparency. If in doubt, don't use these functions.
unsafePackCString :: CString -> IO ByteString
bytestring Data.ByteString.Unsafe
O(n) Build a ByteString from a CString. This value will have no finalizer associated to it, and will not be garbage collected by Haskell. The ByteString length is calculated using strlen(3), and thus the complexity is a O(n). This function is unsafe. If the CString is later modified, this change will be reflected in the resulting ByteString, breaking referential transparency.
unsafePackCStringFinalizer :: Ptr Word8 -> Int -> IO () -> IO ByteString
bytestring Data.ByteString.Unsafe
O(1) Construct a ByteString given a Ptr Word8 to a buffer, a length, and an IO action representing a finalizer. This function is not available on Hugs. This function is unsafe, it is possible to break referential transparency by modifying the underlying buffer pointed to by the first argument. Any changes to the original buffer will be reflected in the resulting ByteString.
unsafePackCStringLen :: CStringLen -> IO ByteString
bytestring Data.ByteString.Unsafe
O(1) Build a ByteString from a CStringLen. This value will have no finalizer associated with it, and will not be garbage collected by Haskell. This operation has O(1) complexity as we already know the final size, so no strlen(3) is required. This funtion is unsafe. If the original CStringLen is later modified, this change will be reflected in the resulting ByteString, breaking referential transparency.
unsafePackMallocCString :: CString -> IO ByteString
bytestring Data.ByteString.Unsafe
O(n) Build a ByteString from a malloced CString. This value will have a free(3) finalizer associated to it. This funtion is unsafe. If the original CString is later modified, this change will be reflected in the resulting ByteString, breaking referential transparency. This function is also unsafe if you call its finalizer twice, which will result in a double free error, or if you pass it a CString not allocated with malloc.
unsafePackMallocCStringLen :: CStringLen -> IO ByteString
bytestring Data.ByteString.Unsafe
O(n) Build a ByteString from a malloced CStringLen. This value will have a free(3) finalizer associated to it. This funtion is unsafe. If the original CString is later modified, this change will be reflected in the resulting ByteString, breaking referential transparency. This function is also unsafe if you call its finalizer twice, which will result in a double free error, or if you pass it a CString not allocated with malloc.
unsafePreservingMatrix :: IO a -> IO a
OpenGL Graphics.Rendering.OpenGL.GL.CoordTrans
A more efficient, but potentially dangerous version of preservingMatrix: The given action is not allowed to throw an exception or change the current matrix mode permanently.
unsafeRenderPrimitive :: PrimitiveMode -> IO a -> IO a
OpenGL Graphics.Rendering.OpenGL.GL.BeginEnd
A more efficient, but potentially dangerous version of renderPrimitive: The given action is not allowed to throw an exception.
unsafeTail :: ByteString -> ByteString
bytestring Data.ByteString.Unsafe
A variety of tail for non-empty ByteStrings. unsafeTail omits the check for the empty case. As with unsafeHead, the programmer must provide a separate proof that the ByteString is non-empty.
unsafeTail :: Text -> Text
text Data.Text.Unsafe
O(1) A variant of tail for non-empty Text. unsafeHead omits the check for the empty case, so there is an obligation on the programmer to provide a proof that the Text is non-empty.
unsafeTake :: Int -> ByteString -> ByteString
bytestring Data.ByteString.Unsafe
A variety of take which omits the checks on n so there is an obligation on the programmer to provide a proof that 0 <= n <= length xs.
unsafeThaw :: (Ix i, IArray a e, MArray b e m) => a i e -> m (b i e)
array Data.Array.MArray, array Data.Array.Unsafe
Converts an immutable array into a mutable array. The implementation may either simply cast the array from one type to the other without copying the array, or it may take a full copy of the array. Note that because the array is possibly not copied, any subsequent modifications made to the mutable version of the array may be shared with the immutable version. It is only safe to use, therefore, if the immutable array is never referenced again in this thread, and there is no possibility that it can be also referenced in another thread. If you use an unsafeThawwriteunsafeFreeze sequence in a multi-threaded setting, then you must ensure that this sequence is atomic with respect to other threads, or a garbage collector crash may result (because the write may be writing to a frozen array). The non-copying implementation is supported between certain pairs of array types only; one constraint is that the array types must have identical representations. In GHC, The following pairs of array types have a non-copying O(1) implementation of unsafeThaw. Because the optimised versions are enabled by specialisations, you will need to compile with optimisation (-O) to get them. * UArray -> IOUArray * UArray -> STUArray * Array -> IOArray * Array -> STArray
unsafeUseAsCString :: ByteString -> (CString -> IO a) -> IO a
bytestring Data.ByteString.Unsafe
O(1) construction Use a ByteString with a function requiring a CString. This function does zero copying, and merely unwraps a ByteString to appear as a CString. It is unsafe in two ways: * After calling this function the CString shares the underlying byte buffer with the original ByteString. Thus modifying the CString, either in C, or using poke, will cause the contents of the ByteString to change, breaking referential transparency. Other ByteStrings created by sharing (such as those produced via take or drop) will also reflect these changes. Modifying the CString will break referential transparency. To avoid this, use useAsCString, which makes a copy of the original ByteString. * CStrings are often passed to functions that require them to be null-terminated. If the original ByteString wasn't null terminated, neither will the CString be. It is the programmers responsibility to guarantee that the ByteString is indeed null terminated. If in doubt, use useAsCString.
unsafeUseAsCStringLen :: ByteString -> (CStringLen -> IO a) -> IO a
bytestring Data.ByteString.Unsafe
O(1) construction Use a ByteString with a function requiring a CStringLen. This function does zero copying, and merely unwraps a ByteString to appear as a CStringLen. It is unsafe: * After calling this function the CStringLen shares the underlying byte buffer with the original ByteString. Thus modifying the CStringLen, either in C, or using poke, will cause the contents of the ByteString to change, breaking referential transparency. Other ByteStrings created by sharing (such as those produced via take or drop) will also reflect these changes. Modifying the CStringLen will break referential transparency. To avoid this, use useAsCStringLen, which makes a copy of the original ByteString.
unsafeWrite :: MArray s -> Int -> Word16 -> ST s ()
text Data.Text.Array
Unchecked write of a mutable array. May return garbage or crash on an out-of-bounds access.
module System.IO.Unsafe
base System.IO.Unsafe
"Unsafe" IO operations.
module Data.Array.Unsafe
array Data.Array.Unsafe
Contains the various unsafe operations that can be performed on arrays.

Show more results