SafeHaskell introduced the notion of safe and unsafe modules. In order to make as many as possible modules "safe", the well-known unsafe functions were moved to distinguished modules. This makes it hard to write packages that work with both old and new versions of GHC. This package provides a single module System.Unsafe that exports the unsafe functions from the base package. It provides them in a style ready for qualification, that is, you should import them by
> import qualified System.Unsafe as Unsafe
The package also contains a script called rename-unsafe.sh. It replaces all occurrences of the original identifiers with the qualified identifiers from this package. You still have to adapt the import commands. It uses the darcs-replace-rec script from the darcs-scripts package.
An experimental library for creating promises that can be evaluated in pure code.
O(n) Copy a Text to an array. The array is assumed to be big enough to hold the contents of the entire Text.
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.
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.
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.
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.
Freeze a mutable array. Do not mutate the MArray afterwards!
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
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.
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.
Unchecked read of an immutable array. May return garbage or crash on an out-of-bounds access.
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.
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.
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.
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.
> 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).
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.
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.
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.
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.
Show more results