Copyright | (c) 2009 2010 2011 Bryan O'Sullivan |
---|---|
License | BSD-style |
Maintainer | bos@serpentine.com |
Portability | portable |
Safe Haskell | None |
Language | Haskell2010 |
A module containing unsafe
Text
operations, for very very careful
use in heavily tested code.
Synopsis
- inlineInterleaveST :: ST s a -> ST s a
- inlinePerformIO :: IO a -> a
- unsafeDupablePerformIO :: IO a -> a
- data Iter = Iter ! Char ! Int
- iter :: Text -> Int -> Iter
- iter_ :: Text -> Int -> Int
- reverseIter :: Text -> Int -> ( Char , Int )
- reverseIter_ :: Text -> Int -> Int
- unsafeHead :: Text -> Char
- unsafeTail :: Text -> Text
- lengthWord16 :: Text -> Int
- takeWord16 :: Int -> Text -> Text
- dropWord16 :: Int -> Text -> Text
Documentation
inlineInterleaveST :: ST s a -> ST s a Source #
Allow an
ST
computation to be deferred lazily. When passed an
action of type
ST
s
a
, the action will only be performed when
the value of
a
is demanded.
This function is identical to the normal unsafeInterleaveST, but is inlined and hence faster.
Note
: This operation is highly unsafe, as it can introduce
externally visible non-determinism into an
ST
action.
inlinePerformIO :: IO a -> a Source #
Just like unsafePerformIO, but we inline it. Big performance gains as
it exposes lots of things to further inlining.
Very unsafe
. In
particular, you should do no memory allocation inside an
inlinePerformIO
block. On Hugs this is just
unsafePerformIO
.
unsafeDupablePerformIO :: IO a -> a Source #
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. It may even happen that one
of the duplicated IO actions is only run partially, and then interrupted
in the middle without an exception being raised. Therefore, functions
like
bracket
cannot be used safely within
unsafeDupablePerformIO
.
Since: base-4.4.0.0
iter :: Text -> Int -> Iter Source #
O(1) Iterate (unsafely) one step forwards through a UTF-16 array, returning the current character and the delta to add to give the next offset to iterate at.
iter_ :: Text -> Int -> Int Source #
O(1) Iterate one step through a UTF-16 array, returning the delta to add to give the next offset to iterate at.
reverseIter :: Text -> Int -> ( Char , Int ) Source #
O(1) Iterate one step backwards through a UTF-16 array, returning the current character and the delta to add (i.e. a negative number) to give the next offset to iterate at.
reverseIter_ :: Text -> Int -> Int Source #
O(1) Iterate one step backwards through a UTF-16 array, returning the delta to add (i.e. a negative number) to give the next offset to iterate at.
Since: 1.1.1.0
unsafeHead :: Text -> Char Source #
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.
unsafeTail :: Text -> Text Source #
O(1)
A variant of
tail
for non-empty
Text
.
unsafeTail
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.
lengthWord16 :: Text -> Int Source #
O(1)
Return the length of a
Text
in units of
Word16
. This
is useful for sizing a target array appropriately before using
unsafeCopyToPtr
.