Ref

package Ref
package
Ref is a generic layer over mutable references, currently only IO and ST refs. Future extensions may include a generic api for shared state concurrency. Version 0.1.1.0
ReflectionMap :: TextureGenMode
OpenGL Graphics.Rendering.OpenGL.GL.CoordTrans
type RefreshRate = Int
GLUT Graphics.UI.GLUT.GameMode
The refresh rate of the screen, measured in Hertz (e.g. 60, 75, 100, ...)
package RefSerialize
package
Read, Show and Binary instances do not check for internal data references to the same address. As a result, the data is duplicated when serialized. This is a waste of space in the filesystem and also a waste of serialization time. but the worst consequence is that, when the serialized data is read, it allocates multiple copies for the same object when referenced multiple times. Because multiple referenced data is very typical in a pure language such is Haskell, this means that the resulting data loose the beatiful economy of space and processing time that referential transparency permits. In this release the default "(Read a, Show a) => Refserialize a" has been removed. See Data.RefSerialize for details Version 0.3.1.0
package ref
package
Ref is a generic layer over mutable references, currently only IO and ST refs. Future extensions may include a generic api for shared state concurrency. Version 0.1.1.2
package ref-fd
package
Contains a MonadRef type class that abstracts over the details of manipulating references, allowing one to write code that can operate in either the ST monad or the IO monad. Version 0.3.0.3
package ref-mtl
package
Contains a MonadRef type class that abstracts over the details of manipulating references, allowing one to write code that can operate in either the ST monad or the IO monad. Version 0.3
package ref-tf
package
Contains a MonadRef type class that abstracts over the details of manipulating references, allowing one to write code that can operate in either the ST monad or the IO monad. Version 0.3.0.2
package reference
package
Reference is class which generalizes references and monads   they exists in. It means that IORef, STRef and others can be accessed by common interface. Version 0.1
package refh
package
package reflection
package
This package provides an implementation of the ideas presented in the paper "Functional Pearl: Implicit Configurations" by Oleg Kiselyov and Chung-chieh Shan. However, the API has been streamlined to improve performance. The original paper can be obtained from http://www.cs.rutgers.edu/~ccshan/prepose/prepose.pdf. Version 1.3.2
package reform
package
reform follows in the footsteps of formlets and digestive-functors <= 0.2. It provides a type-safe and composable method for generating an HTML form that includes validation. Version 0.2.1
package reform-blaze
package
Reform is a library for building and validating forms using applicative functors. This package add support for using reform with blaze-html. Version 0.2.0
package reform-hamlet
package
Reform is a library for building and validating forms using applicative functors. This package add support for using reform with Hamlet. Version 0.0
package reform-happstack
package
Reform is a library for building and validating forms using applicative functors. This package add support for using reform with Happstack. Version 0.2.0
package reform-hsp
package
Reform is a library for building and validating forms using applicative functors. This package add support for using reform with HSP. Version 0.2.2
atomicModifyIORef :: IORef a -> (a -> (a, b)) -> IO b
base Data.IORef
Atomically modifies the contents of an IORef. This function is useful for using IORef in a safe way in a multithreaded program. If you only have one IORef, then using atomicModifyIORef to access and modify it will prevent race conditions. Extending the atomicity to multiple IORefs is problematic, so it is recommended that if you need to do anything more complicated then using Control.Concurrent.MVar.MVar instead is a good idea.
module Data.IORef
base Data.IORef
Mutable references in the IO monad.
module Data.STRef
base Data.STRef
Mutable references in the (strict) ST monad.
deRefStablePtr :: StablePtr a -> IO a
base Foreign.StablePtr
Obtain the Haskell value referenced by a stable pointer, i.e., the same value that was passed to the corresponding call to makeStablePtr. If the argument to deRefStablePtr has already been freed using freeStablePtr, the behaviour of deRefStablePtr is undefined.

Show more results