Ref
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
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
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.1
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
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.
Changes in 1.1.6:
* Relaxed an unnecessary strictness annotation in the fast implementation
Changes in 1.1.5:
* Both implementations now work on Hugs; the fast implementation ascends from the ranks of completely unportable black magic to being merely mostly unportable black magic.
Changes from 0.5 to 1.1:
* Much faster implementation available that is about 50 times faster than 0.9 and which runs purely on black magic. This version is now used by default. To turn it off install with the slow flag. If you encounter a problem with the implementation, please contact the author.
* Removed ReifiedNum, reflectNum, and reifyIntegral; reify and reflect are about 3 orders of magnitude faster than the special case combinators were.
Changes in 0.5:
* Generalized the type signatures in reflect to allow you to pass any type with kind * -> * wrapped around the desired type as the phantom type argument rather than just a Proxy.
Changes in 0.4:
* Converted from `Data.Tagged` to using `Data.Proxy` for reflection. This reduces the need for helper functions and scoped type variables in user code.
Version 1.1.6
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.1.1
Reform is a library for building and validating forms using applicative functors. This package add support for using reform with blaze-html.
Version 0.1
Reform is a library for building and validating forms using applicative functors. This package add support for using reform with Happstack.
Version 0.1.1
Reform is a library for building and validating forms using applicative functors. This package add support for using reform with HSP.
Version 0.1.1
The refresh rate of the screen, measured in Hertz (e.g. 60, 75, 100, ...)
Read, Show and Data.Binary 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.
Every instance of Show/Read can be an instance of Data.RefSerialize.
This package allows the serialization and deserialization of large data structures without duplication of data, with the result of optimized performance and memory usage. Since the serialized data is also human readable, It is also useful for debugging purposes.
The deserializer contains a subset of Parsec.Token for defining deserializing parsers.
the serialized string has the form:
expr( var1, ...varn) where var1=value1,..valn=valueN
so that the string can agree with the haskell syntax.
See demo.hs and tutorial.
in this release:
* 0.2.8.1 fixed problem with showHex Show constraint in the latter version of Numeric
* Serialization instance now includes an internal wiriter
* Solved a criitical bug only appearing in structures with many references, when StableNames started to be freed by the gartbage colllector before serialization was completed, which gave erroneous references
* Bug in 0.2.5 fixed: empty lists were written with two indirections (insertVar . insertVar). That caused an error in readp
* Bug in 0.2.6 fixed for lists
* Added instances for standard datatypes. More "deeper" instances favouring more variable usage
* Instance of Serialize [a] changed
* Derived Serialize instances for Data.Binary instances: readpBinary, showpBinary
* - Serialization now is to/from ByteStings
Version 0.2.8.1
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.
Mutable references in the IO monad.
Mutable references in the (strict) ST monad.
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.
Dereferences a weak pointer. If the key is still alive, then Just v is returned (where v is the value in the weak pointer), otherwise Nothing is returned.
The return value of deRefWeak depends on when the garbage collector runs, hence it is in the IO monad.
A mutable variable in the IO monad
Show more results