pack +bytestring

pack :: String -> ByteString
bytestring Data.ByteString.Char8
O(n) Convert a String into a ByteString For applications with large numbers of string literals, pack can be a bottleneck.
pack :: [Char] -> ByteString
bytestring Data.ByteString.Lazy.Char8
O(n) Convert a String into a ByteString.
pack :: [Word8] -> ByteString
bytestring Data.ByteString.Lazy
O(n) Convert a '[Word8]' into a ByteString.
pack :: [Word8] -> ByteString
bytestring Data.ByteString
O(n) Convert a '[Word8]' into a ByteString. For applications with large numbers of string literals, pack can be a bottleneck. In such cases, consider using packAddress (GHC only).
packCString :: CString -> IO ByteString
bytestring Data.ByteString, bytestring Data.ByteString.Char8
O(n). Construct a new ByteString from a CString. The resulting ByteString is an immutable copy of the original CString, and is managed on the Haskell heap. The original CString must be null terminated.
packCStringLen :: CStringLen -> IO ByteString
bytestring Data.ByteString, bytestring Data.ByteString.Char8
O(n). Construct a new ByteString from a CStringLen. The resulting ByteString is an immutable copy of the original CStringLen. The ByteString is a normal Haskell value and will be managed on the Haskell heap.
unpack :: ByteString -> [Char]
bytestring Data.ByteString.Char8, bytestring Data.ByteString.Lazy.Char8
O(n) Converts a ByteString to a String.
unpack :: ByteString -> [Word8]
bytestring Data.ByteString, bytestring Data.ByteString.Lazy
O(n) Converts a ByteString to a '[Word8]'.
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.