all +base

all :: (a -> Bool) -> [a] -> Bool
base Prelude, base Data.List
Applied to a predicate and a list, all determines if all elements of the list satisfy the predicate. For the result to be True, the list must be finite; False, however, results from a False value for the predicate applied to an element at a finite index of a finite or infinite list.
all :: Foldable t => (a -> Bool) -> t a -> Bool
base Data.Foldable
Determines whether all elements of the structure satisfy the predicate.
alloca :: Storable a => (Ptr a -> IO b) -> IO b
base Foreign.Marshal.Alloc
alloca f executes the computation f, passing as argument a pointer to a temporarily allocated block of memory sufficient to hold values of type a. The memory is freed when f terminates (either normally or via an exception), so the pointer passed to f must not be used after this.
allocaArray :: Storable a => Int -> (Ptr a -> IO b) -> IO b
base Foreign.Marshal.Array
Temporarily allocate space for the given number of elements (like Foreign.Marshal.Alloc.alloca, but for multiple elements).
allocaArray0 :: Storable a => Int -> (Ptr a -> IO b) -> IO b
base Foreign.Marshal.Array
Like allocaArray, but add an extra position to hold a special termination element.
allocaBytes :: Int -> (Ptr a -> IO b) -> IO b
base Foreign.Marshal.Alloc
allocaBytes n f executes the computation f, passing as argument a pointer to a temporarily allocated block of memory of n bytes. The block of memory is sufficiently aligned for any of the basic foreign types that fits into a memory block of the allocated size. The memory is freed when f terminates (either normally or via an exception), so the pointer passed to f must not be used after this.
allocaBytesAligned :: Int -> Int -> (Ptr a -> IO b) -> IO b
base Foreign.Marshal.Alloc
All :: Bool -> All
base Data.Monoid
newtype All
base Data.Monoid
Boolean monoid under conjunction.
module Foreign.Marshal.Alloc
base Foreign.Marshal.Alloc
The module Foreign.Marshal.Alloc provides operations to allocate and deallocate blocks of raw memory (i.e., unstructured chunks of memory outside of the area maintained by the Haskell storage manager). These memory blocks are commonly used to pass compound data structures to foreign functions or to provide space in which compound result values are obtained from foreign functions. If any of the allocation functions fails, a value of nullPtr is produced. If free or reallocBytes is applied to a memory area that has been allocated with alloca or allocaBytes, the behaviour is undefined. Any further access to memory areas allocated with alloca or allocaBytes, after the computation that was passed to the allocation function has terminated, leads to undefined behaviour. Any further access to the memory area referenced by a pointer passed to realloc, reallocBytes, or free entails undefined behaviour. All storage allocated by functions that allocate based on a size in bytes must be sufficiently aligned for any of the basic foreign types that fits into the newly allocated storage. All storage allocated by functions that allocate based on a specific type must be sufficiently aligned for that type. Array allocation routines need to obey the same alignment constraints for each array element.
ErrorCall :: String -> ErrorCall
base Control.Exception.Base, base Control.Exception
ErrorCall :: String -> Exception
base Control.OldException
The ErrorCall exception is thrown by error. The String argument of ErrorCall is the string passed to error when it was called.
data ErrorCall
base Control.Exception.Base, base Control.Exception
This is thrown when the user calls error. The String is the argument given to error.
errorCalls :: Exception -> Maybe String
base Control.OldException
finally :: IO a -> IO b -> IO a
base Control.Exception.Base, base Control.Exception, base Control.OldException
A specialised variant of bracket with just a computation to run afterward.
getAll :: All -> Bool
base Data.Monoid
type IOCallback = FdKey -> Event -> IO ()
base System.Event
Callback invoked on I/O events.
malloc :: Storable a => IO (Ptr a)
base Foreign.Marshal.Alloc
Allocate a block of memory that is sufficient to hold values of type a. The size of the area allocated is determined by the sizeOf method from the instance of Storable for the appropriate type. The memory may be deallocated using free or finalizerFree when no longer required.
mallocArray :: Storable a => Int -> IO (Ptr a)
base Foreign.Marshal.Array
Allocate storage for the given number of elements of a storable type (like Foreign.Marshal.Alloc.malloc, but for multiple elements).
mallocArray0 :: Storable a => Int -> IO (Ptr a)
base Foreign.Marshal.Array
Like mallocArray, but add an extra position to hold a special termination element.
mallocBytes :: Int -> IO (Ptr a)
base Foreign.Marshal.Alloc
Allocate a block of memory of the given number of bytes. The block of memory is sufficiently aligned for any of the basic foreign types that fits into a memory block of the allocated size. The memory may be deallocated using free or finalizerFree when no longer required.
mallocForeignPtr :: Storable a => IO (ForeignPtr a)
base Foreign.ForeignPtr
Allocate some memory and return a ForeignPtr to it. The memory will be released automatically when the ForeignPtr is discarded. mallocForeignPtr is equivalent to > do { p <- malloc; newForeignPtr finalizerFree p } although it may be implemented differently internally: you may not assume that the memory returned by mallocForeignPtr has been allocated with Foreign.Marshal.Alloc.malloc. GHC notes: mallocForeignPtr has a heavily optimised implementation in GHC. It uses pinned memory in the garbage collected heap, so the ForeignPtr does not require a finalizer to free the memory. Use of mallocForeignPtr and associated functions is strongly recommended in preference to newForeignPtr with a finalizer.
mallocForeignPtrArray :: Storable a => Int -> IO (ForeignPtr a)
base Foreign.ForeignPtr
This function is similar to Foreign.Marshal.Array.mallocArray, but yields a memory area that has a finalizer attached that releases the memory area. As with mallocForeignPtr, it is not guaranteed that the block of memory was allocated by Foreign.Marshal.Alloc.malloc.
mallocForeignPtrArray0 :: Storable a => Int -> IO (ForeignPtr a)
base Foreign.ForeignPtr
This function is similar to Foreign.Marshal.Array.mallocArray0, but yields a memory area that has a finalizer attached that releases the memory area. As with mallocForeignPtr, it is not guaranteed that the block of memory was allocated by Foreign.Marshal.Alloc.malloc.
mallocForeignPtrBytes :: Int -> IO (ForeignPtr a)
base Foreign.ForeignPtr
This function is similar to mallocForeignPtr, except that the size of the memory required is given explicitly as a number of bytes.
NestedAtomically :: Exception
base Control.OldException
The runtime detected an attempt to nest one STM transaction inside another one, presumably due to the use of unsafePeformIO with atomically.
NestedAtomically :: NestedAtomically
base Control.Exception.Base, base Control.Exception
data NestedAtomically
base Control.Exception.Base, base Control.Exception
Thrown when the program attempts to call atomically, from the stm package, inside another call to atomically.
nestedAtomically :: SomeException
base Control.Exception.Base
pooledMalloc :: Storable a => Pool -> IO (Ptr a)
base Foreign.Marshal.Pool
Allocate space for storable type in the given pool. The size of the area allocated is determined by the sizeOf method from the instance of Storable for the appropriate type.
pooledMallocArray :: Storable a => Pool -> Int -> IO (Ptr a)
base Foreign.Marshal.Pool
Allocate storage for the given number of elements of a storable type in the pool.
pooledMallocArray0 :: Storable a => Pool -> Int -> IO (Ptr a)
base Foreign.Marshal.Pool
Allocate storage for the given number of elements of a storable type in the pool, but leave room for an extra element to signal the end of the array.
pooledMallocBytes :: Pool -> Int -> IO (Ptr a)
base Foreign.Marshal.Pool
Allocate the given number of bytes of storage in the pool.
pooledRealloc :: Storable a => Pool -> Ptr a -> IO (Ptr a)
base Foreign.Marshal.Pool
Adjust the storage area for an element in the pool to the given size of the required type.
pooledReallocArray :: Storable a => Pool -> Ptr a -> Int -> IO (Ptr a)
base Foreign.Marshal.Pool
Adjust the size of an array in the given pool.
pooledReallocArray0 :: Storable a => Pool -> Ptr a -> Int -> IO (Ptr a)
base Foreign.Marshal.Pool
Adjust the size of an array with an end marker in the given pool.
pooledReallocBytes :: Pool -> Ptr a -> Int -> IO (Ptr a)
base Foreign.Marshal.Pool
Adjust the storage area for an element in the pool to the given size.
realloc :: Storable b => Ptr a -> IO (Ptr b)
base Foreign.Marshal.Alloc
Resize a memory area that was allocated with malloc or mallocBytes to the size needed to store values of type b. The returned pointer may refer to an entirely different memory area, but will be suitably aligned to hold values of type b. The contents of the referenced memory area will be the same as of the original pointer up to the minimum of the original size and the size of values of type b. If the argument to realloc is nullPtr, realloc behaves like malloc.
reallocArray :: Storable a => Ptr a -> Int -> IO (Ptr a)
base Foreign.Marshal.Array
Adjust the size of an array
reallocArray0 :: Storable a => Ptr a -> Int -> IO (Ptr a)
base Foreign.Marshal.Array
Adjust the size of an array including an extra position for the end marker.

Show more results