Hoogle Search

Within LTS Haskell 24.32 (ghc-9.10.3)

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

Exact lookup

1. setEnv :: String -> String -> Bool -> IO ()

   base	System.Environment.Blank

   Like setEnv, but allows blank environment values and mimics the function signature of setEnv from the unix package. Beware that this function must not be executed concurrently with getEnv, lookupEnv, getEnvironment and such. One thread reading environment variables at the same time with another one modifying them can result in a segfault, see Setenv is not Thread Safe for discussion.

2. setAllocationCounter :: Int64 -> IO ()

   base	System.Mem

   Every thread has an allocation counter that tracks how much memory has been allocated by the thread. The counter is initialized to zero, and setAllocationCounter sets the current value. The allocation counter counts *down*, so in the absence of a call to setAllocationCounter its value is the negation of the number of bytes of memory allocated by the thread. There are two things that you can do with this counter:

   • Use it as a simple profiling mechanism, with getAllocationCounter.
   • Use it as a resource limit. See enableAllocationLimit.
   Allocation accounting is accurate only to about 4Kbytes.

3. setFinalizerExceptionHandler :: (SomeException -> IO ()) -> IO ()

   base	System.Mem.Weak

   Set the global action called to report exceptions thrown by weak pointer finalizers to the user.

4. setAddrRange# :: Addr# -> Int# -> Int# -> State# RealWorld -> State# RealWorld

   base	GHC.Base

   setAddrRange# dest len c sets all of the bytes in [dest, dest+len) to the value c. Analogous to the standard C function memset, but with a different argument order. Warning: this can fail with an unchecked exception.

5. setByteArray# :: MutableByteArray# d -> Int# -> Int# -> Int# -> State# d -> State# d

   base	GHC.Base

   setByteArray# ba off len c sets the byte range [off, off+len) of the MutableByteArray# to the byte c. Warning: this can fail with an unchecked exception.

6. setThreadAllocationCounter# :: Int64# -> State# RealWorld -> State# RealWorld

   base	GHC.Base

   Sets the allocation counter for the current thread to the given value.

7. setBit :: Bits a => a -> Int -> a

   base	GHC.Bits

   x `setBit` i is the same as x .|. bit i

8. setAllocationCounter :: Int64 -> IO ()

   base	GHC.Conc

   Every thread has an allocation counter that tracks how much memory has been allocated by the thread. The counter is initialized to zero, and setAllocationCounter sets the current value. The allocation counter counts *down*, so in the absence of a call to setAllocationCounter its value is the negation of the number of bytes of memory allocated by the thread. There are two things that you can do with this counter:

   • Use it as a simple profiling mechanism, with getAllocationCounter.
   • Use it as a resource limit. See enableAllocationLimit.
   Allocation accounting is accurate only to about 4Kbytes.

9. setHandler :: Signal -> Maybe (HandlerFun, Dynamic) -> IO (Maybe (HandlerFun, Dynamic))

   base	GHC.Conc

   No documentation available.

10. setNumCapabilities :: Int -> IO ()

    base	GHC.Conc

    Set the number of Haskell threads that can run truly simultaneously (on separate physical processors) at any given time. The number passed to forkOn is interpreted modulo this value. The initial value is given by the +RTS -N runtime flag. This is also the number of threads that will participate in parallel garbage collection. It is strongly recommended that the number of capabilities is not set larger than the number of physical processor cores, and it may often be beneficial to leave one or more cores free to avoid contention with other processes in the machine.

Page 126 of many | Previous | Next