unsafe -package:QuickCheck

Unified interface to unsafe functions 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.

This module presents an identical interface to Control.Monad.ST, except that the monad delays evaluation of ST operations until a value depending on them is required. Unsafe API.

This library provides support for strict state threads, as described in the PLDI '94 paper by John Launchbury and Simon Peyton Jones Lazy Functional State Threads. Unsafe API.

The ForeignPtr type and operations. This module is part of the Foreign Function Interface (FFI) and will usually be imported via the Foreign module. Unsafe API Only.

Marshalling support. Unsafe API.

"Unsafe" IO operations.

The representations of the types TyCon and TypeRep, and the function mkTyCon which is used by derived instances of Typeable to construct TyCons. Be warned, these functions can be used to construct ill-kinded type representations.

Unsafe IO operations

A module containing unsafe ByteString operations. While these functions have a stable API and you may use these functions in applications, do carefully consider the documented pre-conditions; incorrect use can break referential transparency or worse.

Warning: this is an internal module, and does not have a stable API or name. Functions in this module may not check or enforce preconditions expected by public modules. Use at your own risk! A module containing unsafe operations, for very very careful use in heavily tested code.

A module containing unsafe Text operations, for very very careful use in heavily tested code.

Contains the various unsafe operations that can be performed on arrays.

Provides an unsafe way to create a case insensitive string-like value.

For a good explanation of profunctors in Haskell see Dan Piponi's article: http://blog.sigfpe.com/2011/07/profunctors-in-haskell.html This module includes unsafe composition operators that are useful in practice when it comes to generating optimal core in GHC. If you import this module you are taking upon yourself the obligation that you will only call the operators with # in their names with functions that are operationally identity such as newtype constructors or the field accessor of a newtype. If you are ever in doubt, use rmap or lmap.

This is designed to be used as

import qualified Yesod.Core.Unsafe as Unsafe

This serves as a reminder that the functions are unsafe to use in many situations.

⚠️ Warning ⚠️ This module contains unsafe partial functions. They are unavoidable sometimes, but we encourage you to use safer analogues: TODO: table This module is intended to be imported qualified and it is not included in default prelude exports.

import qualified Relude.Unsafe as Unsafe

foo :: [a] -> a
foo = Unsafe.head

Boxed Vector unsafe functions. These perform no bounds checking, and may cause segmentation faults etc.! Import as:

import qualified RIO.Vector.Boxed.Unsafe as VB'

Storable Vector unsafe functions. These perform no bounds checking, and may cause segmentation faults etc.! Import as:

import qualified RIO.Vector.Storable.Unsafe as VS'