Mapping of C types to corresponding Haskell types.
This package provides newtype wrappers for separating data with specified endianness from other data of the same type with normal, system-specific endianness. Since these wrappers are newtypes, no runtime overhead is incurred. Currently the underlying EndianSensitive typeclass its instances are taken directly from the 'data-endian' package. However, if Haskell or GHC ever gets a built-in equivalent, like as is proposed in 'http:ghc.haskell.orgtracghcticket7902', it should be trivial to update this to use that instead.
ASN.1 standard types
Provides an algebraic ring class and instances for Gibbs free energy, partition function probabilities, and scores. Conversion between different entities is provided by a convert function. All entities are ready for the vector library.
* Ignore everything except the Ring itself!
Collada is the standard graphics format for data exchange between 3d tools. As well as the file format also its representation as an algebraic data type could be used to make libraries more composable. Please propose changes.
Haskell implementation of the CQRS architectural pattern.
Generic cryptography public keys algorithm types
This package provides types to represent an XML Document Type Declaration (DTD) as defined in W3C specifications (http://www.w3.org/XML/Core/#Publications). It is intended to be compatible with and extend the set of types in Data.XML.Types provided by the xml-types package.
Following the philosophy of Data.XML.Types, the types in this module are not intended to be a strict and complete representation of the model in the W3C specifications; rather, they are intended to be convenient and type-safe for the kinds of processing of DTDs that are commonly done in practice. As such, this model is compatible with both Version 1.0 and Version 1.1 of the XML specification.
Therefore, these types are not suitable for type-level validation of the syntax of a DTD. For example: these types are more lenient than the specs about the characters that are allowed in various locations in a DTD; entities of various kinds only appear as distinct syntactic elements in places where they are commonly needed when processing DTDs; etc.
Conditional sections are not represented in these types. They should be handled directly by parsers and renderers, if needed.
The library provides a data type hierarchy which mirrors the hierarchy of elements present in the original, LMF representation of the historical dictionary of Polish.
Hoodle file format data type including generic interface
Generic HTTP types for Haskell (for both client and server code).
Basic mime-type handling types and functions
This package contains definitions for the Pandoc data structure, which is used by pandoc to represent structured documents. These definitions used to live in the pandoc package, but starting with pandoc 1.7, they have been split off, so that other packages can use them without drawing in all of pandoc's dependencies, and pandoc itself can depend on packages (like citeproc-hs) that use them.
Text.Pandoc.Builder provides functions for building up Pandoc structures programmatically.
Text.Pandoc.Generic provides generic functions for manipulating Pandoc documents.
Providing indices, matrixes, sparse matrixes, and signed and unsigned bit vectors.
It is common knowledge that lazy datastructures can lead to space-leaks. This problem is particularly prominent, when using lazy datastructures to store the state of a long-running application in memory. The easiest solution to this problem is to use fully strict types to store such state values. By "fully strict types" we mean types for whose values it holds that, if they are in weak-head normal form, then they are also in normal form. Intuitively, this means that values of fully strict types cannot contain unevaluated thunks.
To define a fully strict datatype, one typically uses the following recipe.
* Make all fields of every constructor strict; i.e., add a bang to all fields.
* Use only strict types for the fields of the constructors.
The second requirement is problematic as it rules out the use of the standard Haskell Maybe, Either, and pair types. This library solves this problem by providing strict variants of these types and their corresponding standard support functions and type-class instances.
Note that this library does currently not provide fully strict lists. They can be added if they are really required. However, in many cases one probably wants to use unboxed or strict boxed vectors from the vector library (http://hackage.haskell.org/package/vector) instead of strict lists. Moreover, instead of Strings one probably wants to use strict Text values from the text library (http://hackage.haskell.org/package/text).
This library comes with batteries included; i.e., missing instances for type-classes from the deepseq, binary, aeson, QuickCheck, and lens packages are included. Of particluar interest is the Strict type-class provided by the lens library (http://hackage.haskell.org/packages/archive/lens/126.96.36.199/doc/html/Control-Lens-Iso.html#t:Strict). It is used in the following example to simplify the modification of strict fields.
> (-# LANGUAGE TemplateHaskell #-) -- replace with curly braces,
> (-# LANGUAGE OverloadedStrings #-) -- the Haddock prologues are a P.I.T.A!
> import Control.Lens ( (.=), Strict(strict), from, Iso', makeLenses)
> import Control.Monad.State.Strict (State)
> import qualified Data.Map as M
> import qualified Data.Maybe.Strict as S
> import qualified Data.Text as T
> -- | An example of a state record as it could be used in a (very minimal)
> -- role-playing game.
> data GameState = GameState
> ( _gsCooldown :: !(S.Maybe Int)
> , _gsHealth :: !Int
> ) -- replace with curly braces, *grmbl*
> makeLenses ''GameState
> -- The isomorphism, which converts a strict field to its lazy variant
> lazy :: Strict lazy strict => Iso' strict lazy
> lazy = from strict
> type Game = State GameState
> cast :: T.Text -> Game ()
> cast spell =
> gsCooldown.lazy .= M.lookup spell spellDuration
> -- ... implement remainder of spell-casting ...
> spellDuration = M.fromList [("fireball", 5)]
See http://www.haskellforall.com/2013/05/program-imperatively-using-haskell.html for a gentle introduction to lenses and state manipulation.
Note that this package uses the types provided by the strict package (http://hackage.haskell.org/package/strict), but organizes them a bit differently. More precisely, the strict-base-types package
* only provides the fully strict variants of types from base,
* is in-sync with the current base library (base-4.6),
* provides the missing instances for (future) Haskell platform packages, and
* conforms to the standard policy that strictness variants of an existing datatype are identified by suffixing 'Strict' or 'Lazy' in the module hierarchy.
This package provides types which mirror the structures used in the XCB code generation XML files.
See project http:xcb.freedesktop.org/ for more information about the XCB project.
The XML files describe the data-types, events and requests used by the X Protocol, and are used to auto-generate large parts of the XCB project.
This package parses these XML files into Haskell data structures.
If you want to do something with these XML descriptions but don't want to learn XSLT, this package should help.
This version of xcb-types is intended to fully parse the X Protocol description version 1.4.
Show more results