Hackage: Package candidates

Package candidates

Here follow all the candidate package versions on Hackage. [upload]

CarneadesDSL: 1.2. An implementation and domain specific language for the Carneades argumentation model. See Haskell Gets Argumentative in the Proceedings of Symposium on Trends in Functional Programming (TFP 2012) by Bas van Gijzel and Henrik Nilsson or the package's homepage. Thanks to Stefan Sabev for providing initial code for the cyclicity check.
CarneadesIntoDung: 0.9. A translation from the Carneades argumentation model (http://hackage.haskell.org/package/CarneadesDSL) into Dung's argumentation frameworks (http://hackage.haskell.org/package/Dung). This package provides a translation function and correspondence properties. See "Towards a framework for the implementation and verification of translations between argumentation models" by Bas van Gijzel and Henrik Nilsson or the package's homepage.
Chart: 1.1. A library for generating 2D Charts and Plots, based upon the cairo graphics library.
Dust: 2.2, 2.2.1. Dust is a polymorphic protocol engine designed to circumvent Internet filtering based on protocol identification
FModExRaw: 0.1.0.0. Haskell FModEx raw API. It’s a 1:1 Haskell binding over the famous C API. For now, I use version 0.0.* for uncomplete API binding. The complete API will be released just in time.
FenwickTree: 0.1.1. Fenwick trees are a O(log N) data structure for updating cumulative sums. This implementation comes with an operation to find a least element for which real-valued cumulative sum reaches certain value, and allows for storage of arbitrary information in the nodes.
GeBoP: 1.7.3. The games: Ataxx, Bamp, Halma, Hez, Kram, Nim, Reversi, TicTacToe, and Zenix
HDBC-postgresql: 2.3.2.2. This package provides a PostgreSQL driver for HDBC
HaRe: 0.7.0.6. A Haskell 2010 refactoring tool. HaRe supports the full Haskell 2010 standard, through making use of the GHC API. It is tested against GHC 7.4.x and 7.6.x It currently only has emacs integration built in, community input welcome for others. Warning: This is alpha code. Always commit code to your version control system before refactoring. The developers make no warranties, use at your own risk. May frighten children and dogs. Current known defects: * After renaming, the layout of nested let/where clauses is not adjusted. This can cause problems if the new name is a different length from the old one. * liftToTopLevel of a recursive function may introduce parameter errors. e.g. lifting 'g' in the 'zmapQ' function from 'syz-0.2.0.0' 'Data.Generics.Zipper' results in the following > zmapQ f z = reverse $ downQ [] g z where > g z' = query f z' : leftQ [] g z' becomes > zmapQ f z = reverse $ downQ [] (g f g)z > > g f z'g= query f z' : leftQ [] (g f g)g f g)z'
Nutri: 0.1. This is the start of a library that helps to calculate with nutrition values of food items. There is a basic datatype for weight information and one for the nutrient information of food. One can combine variouse foods together and let the library calculate the overall protein, carbohydrate and fat percentages as well as the caloric value.
Octree: 0.5.2. Octree data structure is relatively shallow data structure for space partitioning.
PrimitiveArray: 0.5.2.0. This library provides efficient multidimensional arrays. In general all operations are (highly) unsafe, no bounds-checking or other sanity-checking is performed. Operations are aimed toward efficiency as much as possible.
array: 0.5.0.0. In addition to providing the "Data.Array" module <http://www.haskell.org/onlinereport/haskell2010/haskellch14.html as specified in the Haskell 2010 Language Report>, this package also defines the classes 'IArray' of immutable arrays and 'MArray' of arrays mutable within appropriate monads, as well as some instances of these classes.
aws-sdk-text-converter: 0.1.0.0, 0.2.0.0. The text converter for aws-sdk.
base32-bytestring: 0.1.0.0. base32 and base32hex codec according to RFC4648 <http://tools.ietf.org/html/rfc4648> The package API is similar to base64-bytestring. [/Release notes/] * /0.1.0.0:/ Initial version.
bencoding: 0.2.1.0. A library for encoding and decoding of BEncode data. [/Release notes/] * /0.1.0.0:/ Initial version. * /0.2.0.0:/ Added default decoders/encoders using GHC Generics. * /0.2.1.0:/ Arbitrary length integers. (by specification)
blank-canvas: 0.2.3.1, 0.3.1. A Haskell port of the HTML5 Canvas API. blank-canvas works by providing a web service that displays the users' Haskell commands inside a browser.
cabal-constraints: 0.0.0.1, 0.0.0.2. /Repeatable builds for cabalized Haskell projects/ \'cabal-constraints\' provides repeatable builds for cabalized Haskell projects by \"freezing\" the exact versions of the dependencies selected by \'cabal-install\'. All build environments for the project, such as the test or staging build environments, or other developers collaborating on the project, will then use the same dependency versions. It is designed to be used alongside \'cabal-install\' sandboxes, in which case isolated, repeatable builds can be achieved. /Using cabal-constraints/ \'cabal-constraints\' should be run from the root directory of a cabalized Haskell project and given the path to the `setup-config` file to use. It will print out all dependencies of the project in a format suitable for use in a `cabal-install` config file. For example, running \'cabal-constraints\' against itself produces the following: @ $ cabal-constraints dist\/dist-sandbox-500003c6\/setup-config constraints: Cabal == 1.19.0 , array == 0.4.0.1 , base == 4.6.0.1 , bytestring == 0.10.0.2 , containers == 0.5.0.0 , deepseq == 1.3.0.1 , directory == 1.2.0.1 , filepath == 1.3.0.1 , ghc-prim == 0.3.0.0 , integer-gmp == 0.5.0.0 , old-locale == 1.0.0.5 , pretty == 1.1.1.0 , process == 1.1.0.2 , rts == 1.0 , time == 1.4.0.1 , unix == 2.6.0.1 @ A single mandatory argument must be provided which is the path to the @setup-config@ file to use. The file will be located under the @dist@ directory. Usually there will be a single @setup-config@ file which can be found by running @find dist -name setup-config@ from the root directory of the project. If your project has more than one such file, it is likely because you have built it either with and without sandboxes or with multiple sandboxes. You probably want the most recently modified file which can be found with @ls -tr $( find dist -name setup-config ) | tail -n1@. To use these constraints for reproducible builds, one should make use of the new sandbox feature of @cabal-install@ 1.18. The constraints can be redirected to @cabal.config@ and committed to your code repository. When the project is built, the same set of dependency versions will be resolved by @cabal-install@ ensuring repeatable builds. If @cabal.config@ contains no other information the simplest solution is to overwrite it: @ $ cabal-constraints > cabal.config @ If @cabal.config@ contains information that needs to be preserved, the following will replace the @constraints@ section and everything following it with the new constraints. If you ensure that the @constraints@ section is the last section of the file, all other information in it will be kept. @ $ sed -i \/^constraints:\/,$d cabal.config && cabal-constraints >> cabal.config @
cake3: 0.2.1.0. Cake3 is a EDSL for building Makefiles, written in Haskell. With cake3, developer can write their build logic in Haskell, obtain clean and safe Makefile and distribute it among the non-Haskell-aware users. Currenly, GNU Make is the only backend supported. /Example program/ > module Cakefile where > > import Development.Cake3 > import Cakefile_P > > cs = map file ["main.c", "second.c"] > > main = writeMake (file "Makefile") $ do > selfUpdate > d <- rule $ do > shell [cmd|gcc -M $cs -MF @(file "depend.mk")|] > os <- forM cs $ \c -> do > rule $ do > shell [cmd| gcc -c $(extvar "CFLAGS") -o @(c.="o") $c |] > elf <- rule $ do > shell [cmd| gcc -o @(file "main.elf") $os |] > rule $ do > phony "clean" > unsafeShell [cmd|rm $elf $os $d|] > rule $ do > phony "all" > depend elf > includeMakefile d /Basic workflow/ * Install the cake3 * Create Cakefile.hs in the project root * Build the application using cake3 script provided * Execute the application to obtain the Makefile See the README on the GitHub <https://github.com/grwlf/cake3> for more information. /Changes/ * 0.1 - Initial release * 0.2 - Redesign (simplify) monadic interface, add support for prebuild/postbuild actions.
cblrepo: 0.9.3. Helper tool for people maintaining a set of CABAL packages for their distribution. It maintains a database of packages and verifies dependencies of the entire set as packages are added or updated. It also makes it trivial to track packages as new versions are released on Hackage. It can also be used to build source packages for the ArchLinux distribution.
cereal: 0.4.0.0, 0.4.0.1. A binary serialization library, similar to binary, that introduces an isolate primitive for parser isolation, and replaces the asynchronous errors with a user-handleable Either type. Similar to binary in performance, but uses a strict ByteString instead of a lazy ByteString, thus restricting it to operating on finite inputs.
citeproc-hs: 0.3.9. citeproc-hs is a library for rendering bibliographic reference citations into a variety of styles using a macro language called Citation Style Language (CSL). More details on CSL can be found here: <http://citationstyles.org/>. For the API documentation please see "Text.CSL".
clark: 0.1.
clash-lib: 0.2.0.1. CλaSH (pronounced ‘clash’) is a functional hardware description language that borrows both its syntax and semantics from the functional programming language Haskell. The merits of using a functional language to describe hardware comes from the fact that combinational circuits can be directly modeled as mathematical functions and that functional languages lend themselves very well at describing and (de-)composing mathematical functions. This package provides: * The CoreHW internal language: SystemF + Letrec + Case-decomposition * The normalisation process that brings CoreHW in a normal form that can be converted to a netlist * VHDL Backend * Blackbox/Primitive Handling Front-ends (for: parsing, typecheck, etc.) are provided by seperate packages: * <https://github.com/christiaanb/Idris-dev Idris Frontend> * <https://github.com/christiaanb/clash2 GHC/Haskell Frontend>
clock: 0.4, 0.4.0.1. A package for convenient access to high-resolution clock and timer functions of different operating systems via a unified API. POSIX code and surface API was developed by Cetin Sert in 2009. Windows code was contributed by Eugene Kirpichov in 2010. FreeBSD code was contributed by Finn Espen Gundersen on 2013-10-14. OS X code was contributed by Gerolf Seitz on 2013-10-15. [Version Scheme] Major-@/R/@-ewrite . New-@/F/@-unctionality . @/I/@-mprovementAndBugFixes . @/P/@-ackagingOnly * @PackagingOnly@ changes are made for quality assurance reasons.
confsolve: 0.4. A command line tool for resolving conflicts of file synchronizers.
cric: 0.1.0.0. A simple server confguration management tool
cryptsy-api: 0.1. Bindings for Cryptsy cryptocurrency exchange API.
cubicbezier: 0.2.0. This library supports efficient manipulating of 2D cubic bezier curves. The original goal is to support typography, but it is useful for general graphics. Supported features are: Evaluating bezier curves and derivatives, affine transformations on bezier curves, arclength and inverse arclength, intersections between two curves, intersection between a curve and a line, curvature and radius of curvature, finding tangents parallel to a vector, finding inflection points and cusps. It also supports polynomial root finding with Bernstein polynomials. The module "Geom2D.CubicBezier" exports all the cubic bezier functions. The module "Geom2D" contains general 2D geometry functions and transformations.
daemons: 0.2.1. "Control.Pipe.C3" provides simple RPC-like wrappers for pipes. "Control.Pipe.Serialize" provides serialization and incremental deserialization pipes. "Control.Pipe.Socket" provides functions to setup pipes around sockets. "System.Daemon" provides a high-level interface to starting daemonized programs that are controlled through sockets. "System.Posix.Daemon" provides a low-level interface to starting, and controlling detached jobs. See the @README.md@ file and the homepage for details.
data-interval: 0.4.0. Unlike the intervals package (<http://hackage.haskell.org/package/intervals>), this package provides both open and closed intervals and is intended to be used with Rational. Changes in 0.4.0 * add simplestRationalWithin :: RealFrac r => Interval r -> Maybe Rational
decoder-conduit: 0.0.1.0. Simple conduit for decoding ByteStrings into values using Data.Binary.Get
deepseq: 1.3.0.2. This package provides methods for fully evaluating data structures (\"deep evaluation\"). Deep evaluation is often used for adding strictness to a program, e.g. in order to force pending exceptions, remove space leaks, or force lazy I/O to happen. It is also useful in parallel programs, to ensure pending work does not migrate to the wrong thread. The primary use of this package is via the 'deepseq' function, a \"deep\" version of 'seq'. It is implemented on top of an 'NFData' typeclass (\"Normal Form Data\", data structures with no unevaluated components) which defines strategies for fully evaluating different data types. If you want to automatically derive 'NFData' instances via the "GHC.Generics" facility, there is a companion package <http://hackage.haskell.org/package/deepseq-generics deepseq-generics> which builds on top of this package.
deepseq-generics: 0.1.1.1. This package provides a "GHC.Generics"-based 'Control.DeepSeq.Generics.genericRnf' function which can be used for providing a 'rnf' implementation. See the documentation for the 'genericRnf' function in the "Control.DeepSeq.Generics" module to get started. The original idea was pioneered in the @generic-deepseq@ package (see <http://www.haskell.org/pipermail/haskell-cafe/2012-February/099551.html> for more information). This package differs from the @generic-deepseq@ package by working in combination with the existing @deepseq@ package as opposed to defining a conflicting drop-in replacement for @deepseq@'s @Control.Deepseq@ module.
diophantine: 0.1.0.0. A library for solving quadratic diophantine equations. This library is designed to solve for equations where: * the form is: ax^2 + bxy + cy^2 + dx + ey + f = 0 * a,b,c,d,e,f are integers. * soltutions are restricted to x and y are also integers. This library breaks down equations based on their type to solve them most efficiently. This library supports linear, simple hyperbolic, eliptical, and parabolic equations, with hyperbolics on the way. Please send feedback or bugs to joejev@gmail.com.
ec2-signature: 2.0, 3.0. The Amazon EC2 style signature calculator. <http://docs.aws.amazon.com/general/latest/gr/signature-version-2.html>
email-validator: 0.0.2. Validate an email address using three techniques: * Ensuring that the length of local and domain parts is within the RFC-specified limits. * A syntax check using a regular expression, or the full RFC 5322 grammar (see the @--rfc5322@ option). * Confirmation of the existence of an @MX@ record for the domain part of the address. This is not required; in fact many domains accept mail via an @A@ record for e.g. example.com which is used in lieu of an @MX@ record. This behavior can be controlled via the @--accept-a@ flag. These checks are performed in parallel using the number of available threads. To increase the number of threads, you can pass the appropriate flag to the GHC runtime. This will set the number of threads to 25: @ $ email-validator -i addresses.csv +RTS -N25 @ /Input/ The @input@ file (default: stdin) should be a list of email addresses, one per line. Empty lines will be ignored. /Output/ Valid email addresses will be written to the output file (default: stdout), one per line.
extensible-effects: 1.1.0. This package introduces datatypes for typeclass-constrained effects, as an alternative to monad-transformer based (datatype-constrained) approach of multi-layered effects. For more information, see the original paper at <http://okmij.org/ftp/Haskell/extensible/exteff.pdf>.
feed: 0.3.9.2. Interfacing with RSS (v 0.9x, 2.x, 1.0) + Atom feeds. To help working with the multiple feed formats we've ended up with, this set of modules provides parsers, pretty printers and some utility code for querying and just generally working with a concrete representation of feeds in Haskell.
fixed-vector: 0.5.1.1, 0.5.1.2. Generic library for vectors with statically known size. Implementation is based on <http://unlines.wordpress.com/2010/11/15/generics-for-small-fixed-size-vectors/> Same functions could be used to work with both ADT based vector like > data Vec3 a = a a a Tuples are vectors too: >>> sum (1,2,3) 6 Vectors which are represented internally by arrays are provided by library. Both boxed and unboxed arrays are supported. Library is structured as follows: [@Data.Vector.Fixed@] Generic API. It's suitable for both ADT-based vector like Complex and array-based ones. [@Data.Vector.Fixed.Cont@] Continuation based vectors. Internally all functions use them. [@Data.Vector.Fixed.Mutable@] Type classes for array-based implementation and API for working with mutable state. [@Data.Vector.Fixed.Unboxed@] Unboxed vectors. [@Data.Vector.Fixed.Boxed@] Boxed vector which can hold elements of any type. [@Data.Vector.Fixed.Storable@] Unboxed vectors of Storable types. [@Data.Vector.Fixed.Primitive@] Unboxed vectors based on pritimive package. [@Data.Vector.Fixed.Monomorphic@] Wrappers for monomorphic vectors
fixedprec: 0.2. A reasonably efficient implementation of arbitrary-but-fixed precision real numbers. This is inspired by, and partly based on, Data.Number.Fixed and Data.Number.CReal, but more efficient.
flexible-unlit: 0.2013.276.0.
flowdock-api: 0.1.0.0. This library uses the Network.HTTP.Client library to interact with the FlowDock chat service. * Push API - <https://www.flowdock.com/api/team-inbox> * Streaming API - <https://www.flowdock.com/api/streaming> * REST API - <https://www.flowdock.com/api/rest>
gitignore: 1.0.0. Apply GitHub .gitignore templates to already existing repositories.
glib: 0.12.5.0. The GNU Library is a collection of C data structures and utility function for dealing with Unicode. This package only binds as much functionality as required to support the packages that wrap libraries that are themselves based on GLib.
gpah: 0.0.2. Generic Programming Use in Hackage:
gtk2hs-buildtools: 0.12.5.0. This package provides a set of helper programs necessary to build the Gtk2Hs suite of libraries. These tools include a modified c2hs binding tool that is used to generate FFI declarations, a tool to build a type hierarchy that mirrors the C type hierarchy of GObjects found in glib, and a generator for signal declarations that are used to call back from C to Haskell. These tools are not needed to actually run Gtk2Hs programs.
hPDB: 1.1. Protein Data Bank file format is a most popular format for holding biological macromolecular data. This is a very fast sequential parser: * below 7s for the largest entry in PDB - 1HTQ which is over 70MB - as compared with * 11s of RASMOL 2.7.5, * or 2m15s of BioPython with Python 2.6 interpreter. In its parallel incarnation it is most probably the fastest parser for PDB format. It is aimed to not only deliver event-based interface, but also a high-level data structure for manipulating data in spirit of BioPython's PDB parser. <http://dx.doi.org/10.1186/1756-0500-6-483 hPDB - Haskell library for processing atomic biomolecular structures in Protein Data Bank format - Michal Jan Gajda. BMC Research Notes 2013, 6:483.>
hPDB-examples: 1.1.1. Examples for handling Protein Data Bank file format.
hS3: 0.5.8. This is the Haskell S3 library. It provides an interface to Amazon's Simple Storage Service (S3), allowing Haskell developers to reliably store and retrieve arbitrary amounts of data from anywhere on the Internet.
hTalos: 0.2. Protein Data Bank file format is a most popular format for holding biomolecule data. This is a very fast parser (below 7s for the largest entry in PDB - 1HTQ which is over 70MB - as compared with 11s of RASMOL 2.7.5, or 2m15s of BioPython with Python 2.6 interpreter.) It is aimed to not only deliver event-based interface, but also a high-level data structure for manipulating data in spirit of BioPython's PDB parser.
haskell-updater: 1.2.0.11. haskell-updater rebuilds Haskell packages on Gentoo after a GHC upgrade or a dependency upgrade. haskell-updater is written so as to use only GHC's boot libraries so as to have no external dependencies. This version is for: GHC-6.12 + Cabal-1.8, GHC-7.0 + Cabal-1.10, GHC-7.2 + Cabal-1.12, GHC-7.4 + Cabal-1.14, GHC-7.6 + Cabal-1.16, GHC-7.6 + Cabal-1.18.
haskoin-crypto: 0.0.1. This package provides the elliptic curve cryptography required for creating and validating bitcoin transactions. It also provides SHA-256 and RIPEMD-160 hashing functions.
haskoin-util: 0.0.1. This package contains utility functions used across the Network.Haskoin modules such as ByteString and Data.Binary helpers. It also defines a Build monad describing computations that can be Complete, Partial or Broken. Additionally, this package defines constants tied to specific Bitcoin networks such as prodnet and testnet.
hath: 0.1.0. Hath is a Haskell program for working with network blocks in CIDR notation. When dealing with blocks of network addresses, there are a few things that one usually wants to do with them: * Create a regular expression matching the CIDR block(s). This is because grep will throw up if you feed it CIDR. * Combine small blocks into larger ones. For example, if you have two consecutive \/24s, they might combine into a larger \/23. * View the result of block combination in a useful way. * List them. * Find their associated PTR records. Hath has several modes to perform these functions: [@Regexed@] This computes a (Perl-compatible) regular expression matching the input CIDR blocks. It's the default mode of operation. [@Reduced@] This combines small blocks into larger ones where possible, and eliminates redundant blocks. The output should be equivalent to the input, though. [@Duped@] Shows only the blocks that would be removed by reduce; that is, it shows the ones that would get combined into larger blocks or are simply redundant. [@Diffed@] Shows what would change if you used reduce. Uses diff-like notation. [@Listed@] List the IP addresses contained within the given CIDRs. [@Reversed@] Perform reverse DNS (PTR) lookups on the IP addresses contained within the given CIDRs. /Examples/: Compute a (Perl-compatible) regular expression matching the input CIDR blocks. It's the default mode of operation. @ $ hath <<< \"10.0.0.0\/29 10.0.0.8\/29\" ((10)\.(0)\.(0)\.(0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15)) @ Combine two \/24s into a \/23: @ $ hath reduced <<< \"10.0.0.0\/24 10.0.1.0\/24\" 10.0.0.0/23 @ List the addresses in 192.168.0.240\/29: @ $ hath listed <<< \"192.168.0.240\/29\" 192.168.0.240 192.168.0.241 192.168.0.242 192.168.0.243 192.168.0.244 192.168.0.245 192.168.0.246 192.168.0.247 @ Perform PTR lookups on all of 198.41.0.4\/30: @ $ hath reversed <<< \"198.41.0.4\/30\" 198.41.0.4: a.root-servers.net. 198.41.0.5: 198.41.0.6: rs.internic.net. 198.41.0.7: @ The DNS lookups are usually the bottleneck for this mode, but we can perform them in parallel. Simply pass the number of threads to the GHC runtime on the command line; for example, the following will perform 25 lookups in parallel: @ $ hath reversed +RTS -N25 <<< \"198.41.0.4\/24\" 198.41.0.4: a.root-servers.net. 198.41.0.5: 198.41.0.6: rs.internic.net. ... @ The command-line syntax and complete set of options are documented in the man page.
haxy: 0.9, 0.9.1. A library for writing HTTP proxy servers with the focus on simplicity, flexibility and modularity. Allows arbitrary transformations on requests and responses and custom caching methods. It's up to the user to make sure that the message transformations are consistent with the HTTP specification. The executable program is a simple non-caching identity proxy and is used for testing the library.
hecc: 0.4.1.0. Pure math & algorithms for Elliptic Curve Cryptography in Haskell. The implementation should be timing-attack resistant, pure Haskell and reasonably fast.
helm: 0.5.0. A functionally reactive game engine, with headgear to protect you from the headache of game development provided.
hexpat: 0.20.4. This package provides a general purpose Haskell XML library using Expat to do its parsing (<http://expat.sourceforge.net/> - a fast stream-oriented XML parser written in C). It is extensible to any string type, with @String@, @ByteString@ and @Text@ provided out of the box. Basic usage: Parsing a tree (/Tree/), formatting a tree (/Format/). Other features: Helpers for processing XML trees (/Proc/), trees annotated with XML source location (/Annotated/), extended XML trees with comments, processing instructions, etc (/Extended/), XML cursors (/Cursor/), SAX-style parse (/SAX/), and access to the low-level interface in case speed is paramount (/Internal.IO/). The design goals are speed, speed, speed, interface simplicity and modularity. For introduction and examples, see the /Text.XML.Expat.Tree/ module. For benchmarks, <http://haskell.org/haskellwiki/Hexpat/> If you want to do interactive I\/O, an obvious option is to use lazy parsing with one of the lazy I\/O functions such as hGetContents. However, this can be problematic in some applications because it doesn't handle I\/O errors properly and can give no guarantee of timely resource cleanup. Because of the generalized list, Hexpat is designed to allow for chunked I/O, but as of this writing I haven't done a nice integration with enumerator and friends. /IO/ is filed under /Internal/ because it's low-level and most users won't want it. The other /Internal/ modules are re-exported by /Annotated/, /Tree/ and /Extended/, so you won't need to import them directly. Credits to Iavor Diatchki and the @xml@ (XML.Light) package for /Proc/ and /Cursor/. Thanks to the many contributors. ChangeLog: 0.15 changes intended to fix a (rare) \"error: a C finalizer called back into Haskell.\" that seemed only to happen only on ghc6.12.X; 0.15.1 Fix broken Annotated parse; 0.16 switch from mtl to transformers; 0.17 fix mapNodeContainer & rename some things.; 0.18 rename defaultEncoding to overrideEncoding. 0.18.3 formatG and indent were demanding list items more than once (inefficient in chunked processing); 0.19 add Extended.hs; 0.19.1 fix a memory leak introduced in 0.19, delegate parsing to bound thread if unbound (see note above); 0.19.2 include expat source code so \'cabal install\' just works on Linux, Mac and Windows (thanks Jacob Stanley); 0.19.3 fix misconfiguration of expat which broke entity parsing; 0.19.4 bump version constraint for text; 0.19.5 bump text to < 0.12 and fix text-0.10.0.1 breakage; 0.19.6 dependency breakage with List; 0.19.7 ghc-7.2.1 compatibility; 0.19.8 fix space leak on lazy parse under ghc-7.2.1; 0.19.9 fix formatting of > character + improve performance; 0.19.10 ghc-7.4.x compatibility; 0.20.1 fix an unfortunate crash when used in parallel processing and greatly improve performance; 0.20.2 make parseSaxG lazier; 0.20.3 minor build issues; 0.20.4 remove dependency on extensible-exceptions.
higher-leveldb: 0.0.2.2, 0.1.0.0. A rich monadic API for working with leveldb databases.
hjsmin: 0.1.4.2, 0.1.4.3. Reduces size of javascript files by stripping out extraneous whitespace and other syntactic elements, without changing the semantics.
holy-project: 0.1.0.0. Holy Project is an application wich ask the user some questions and create files to help you starting a new Haskell project. There are example for tests using HUnit and SmallCheck It initialize git, use cabal sandboxes, and provide two useful scripts: \"auto-update\" and \"interact\".
hoopl: 3.9.0.0. Higher-order optimization library Changes in 3.9.0.0 * Lots of API changes; mainly a new API for working with Blocks
hsbencher: 1.4.2. Benchmark frameworks are usually very specific to the host language/environment. Hence they are usually about as reusable as compiler passes (that is, not). Nevertheless, `hsbencher` is an attempt at a reusable benchmark framework. It knows fairly little about what the benchmarks do, and is mostly concerned with defining and iterating through configuration spaces (e.g. varying the number of threads), and managing the data that results. Benchmark data is stored in simple text files, and optionally uploaded to Google Fusion Tables. `hsbencher` attempts to stradle the divide between language-specific and language-agnostic by having an extensible set of `BuildMethod`s. As shipped, `hsbencher` knows a little about cabal, ghc, and less about Make, but it can be taught more. The general philosophy is to have benchmarks follow a simple protocol, for example printing out a line "SELFTIMED: 3.3s" if they wish to report their own timing. The focus is on benchmarks that run long enough to run in their own process. This is typical of parallelism benchmarks and different than the fine grained benchmarks that are well supported by "Criterion". `hsbencher` is used by creating a script or executable that imports `HSBencher` and provides a list of benchmarks, each of which is decorated with its parameter space. Below is a minimal example that creates a two-configuration parameter space: @ import HSBencher main = defaultMainWithBechmarks . [ Benchmark \"bench1/bench1.cabal\" [\"1000\"] $ . Or [ Set NoMeaning (RuntimeParam \"+RTS -qa -RTS\") . , Set NoMeaning (RuntimeEnv \"HELLO\" \"yes\") ] ] @ The output would appear as in this gist: <https://gist.github.com/rrnewton/5667800> More examples can be found here: <https://github.com/rrnewton/HSBencher/tree/master/example> ChangesLog: * (1.3.8) Added @--skipto@ and @--runid@ arguments * (1.3.4) Added ability to prune benchmarks with patterns on command line. * (1.4.2) Breaking changes, don't use Benchmark constructor directly. Use mkBenchmark.
hspec-expectations-lens: 0.1.0.0. Package adds hspec expectations (@\`shouldX\`@ things) that work nicely with the "lens" library
hsqml: 0.2.0.0, 0.2.0.1. A Haskell binding for Qt Quick. General documentation is present in the 'Graphics.QML' module.
hsqml-morris: 0.2.0.0. HsQML-based implementation of Nine Men's Morris
http-encodings: 0.9, 0.9.1. A library for encoding and decoding bodies of HTTP messages, designed to work with the HTTP and http-server libraries. No heuristic encoding detection at this time. WANTED: a library implementing the Unix "compress" command encoding/decoding (or the LZW algorithm).
http-querystring: 1.0. The HTTP query builder.
husk-scheme: 3.13, 3.14. <<https://github.com/justinethier/husk-scheme/raw/master/docs/husk-scheme.png>> A dialect of R5RS Scheme written in Haskell. Advanced features are provided including: * First-class continuations of unlimited extent * Hygienic macros based on syntax-rules * Low-level explicit renaming macros * A foreign function interface (FFI) to Haskell * Full numeric tower providing support for real, rational, and complex numbers * Proper tail recursion and lexical scoping * Read-Eval-Print-Loop (REPL) interpreter, with input driven by Haskeline to provide a rich user experience * Standard library of Scheme functions, and support for many popular SRFI's Husk may be used as either a stand-alone interpreter or as an extension language within a larger Haskell application. By closely following the R5RS standard, the intent is to develop a Scheme that is as compatible as possible with other R5RS Schemes. Husk is mature enough for use in production, however it is not optimized for performance-critical applications. Scheme is one of two main dialects of Lisp. Scheme follows a minimalist design philosophy: the core language consists of a small number of fundamental forms which may be used to implement other built-in forms. Scheme is an excellent language for writing small, elegant programs, and may also be used to write scripts or embed scripting functionality within a larger application.
hzk: 0.0.2. A haskell binding to Apache Zookeeper C library
idris: 0.9.9.3, 0.9.10. Idris is a general purpose language with full dependent types. It is compiled, with eager evaluation. Dependent types allow types to be predicated on values, meaning that some aspects of a program's behaviour can be specified precisely in the type. The language is closely related to Epigram and Agda. There is a tutorial at <http://www.idris-lang.org/documentation>. Features include: * Full dependent types with dependent pattern matching * where clauses, with rule, simple case expressions, pattern matching let and lambda bindings * Type classes, monad comprehensions * do notation, idiom brackets, syntactic conveniences for lists, tuples, dependent pairs * Totality checking * Coinductive types * Indentation significant syntax, extensible syntax * Tactic based theorem proving (influenced by Coq) * Cumulative universes * Simple foreign function interface (to C) * Hugs style interactive environment
jespresso: 0.9. Allows extraction and consolidation of JavaScript code in an HTML page so that it behaves like the original. Consolidation is a process of transforming an HTML page into an equivalent, but containing JavaScript code only in one inlined script tag.
krpc: 0.2.2.0. KRPC remote procedure call protocol implementation. [/Release Notes/] * /0.1.0.0:/ Initial version. * /0.1.1.0:/ Allow passing raw argument\/result dictionaries. * /0.2.0.0:/ Async API have been removed, use /async/ package instead. Expose caller address in handlers.
lambda-devs: 0.3.1, 0.4.0. The Discrete Event System Sepcification (DEVS) formalism defines discrete event simulation models in a hierachical, modular manner.
language-ecmascript: 0.15.3, 0.15.4. Tools for working with ECMAScript 3 (popularly known as JavaScript). Includes a parser, pretty-printer, tools for working with source tree annotations and an arbitrary instance. See CHANGELOG for a summary of changes.
language-typescript: 0.0.1. A library for working with TypeScript Definition files
libjenkins: 0.1.0.0. Jenkins API interface. It supports REST and Discovery APIs
missing-py2: 1.0.0. A Haskell Interface into the standard Python Interpreter A fork of John Goerzen's MissingPy library, hlinted and updated to run with GHC 7.6.3, this is for legacy projects, for newer projects you might want to consider http://hackage.haskell.org/package/cpython instead Original Documentation: MissingPy is two things: A Haskell binding for many C and Python libraries for tasks such as data compression, databases, etc. This can be found in the MissingPy module tree. Also, it's a low-level Haskell binding to the Python interpreter to enable development of hybrid applications that use both environments. This can be found in the Python module tree. The Haskell bindings above use this environment. MissingPy permits you to call Python code from Haskell. It does NOT permit you to call Haskell code from Python. MissingPy is the companion to my MissingH library, and integrates with it.
monad-resumption: 0.1.0.0, 0.1.0.1. Resumption and reactive-resumption monads for Haskell.
monoid-subclasses: 0.3.4, 0.3.4.1. A hierarchy of subclasses of 'Monoid' together with their instances for all data structures from base, containers, and text packages.
murder: 1.3.4. The murder library is an EDSL for grammar fragments as first-class values. It provides combinators to define and extend grammars, and produce compilers out of them.
nanomsg-haskell: 0.1.0. This is a Haskell binding for the nanomsg library: <http://nanomsg.org/>. There's support for blocking send and recv, a non-blocking receive, and for all the socket types and the functions you need to wire them up and tear them down again. Most sockets options are available through accessor and mutator functions. Sockets are typed, transports are not.
nettle: 0.1.0. safe binding for the nettle (<http://www.lysator.liu.se/~nisse/nettle/nettle.html>) library.
newsynth: 0.1.0.0.
nonlinear-optimization-ad: 0.1.0. Wrapper of nonlinear-optimization package for using with AD package
packunused: 0.1.0.1. This simple CLI tool allows to find out which of the packages listed as @build-depends@ in a Cabal package description file are redundant. @packunused@ works by taking advantage of GHC's @-ddump-minimal-imports@ feature which creates @.import@ files for each compiled module containing a /minimal/ set of explicit import declarations. These @.import@ files together with Cabal's generated package configuration meta-data is analyzed by @packunused@ to detect potentially redundant package dependencies. In order to use @packunused@ you have to configure the package as usual. See the example session below: > cabal clean > rm *.imports > cabal configure -O0 --disable-library-profiling > cabal build --ghc-option=-ddump-minimal-imports > packunused The @-O0 --disable-library-profiling@ options are just to speed up compilation. In some cases you might want to pass additional options to the @configure@ step, such as @--enable-benchmark@ or @--enable-tests@. When run, @packunused@ prints a report to standard output listing its findings for each component built. The following is an example for the @packunused@ package itself, with a redundant dependency added for demonstration on purpose: > detected package components > ~~~~~~~~~~~~~~~~~~~~~~~~~~~ > > - executable(s): packunused > > (component names suffixed with '*' are not configured to be built) > > executable(packunused) > ~~~~~~~~~~~~~~~~~~~~~~ > > The following package depencencies seem redundant: > > - criterion-0.6.2.0-9dd4d764629a47662168743b2dfda9bc >
papillon: 0.0.82, 0.0.88. see examples directory
parallel: 3.2.0.4. This package provides a library for parallel programming.
parsestar: 1.4. Parser for NMR-STAR data used by BMRB databank repository of biological nuclear magnetic resonance data.
pbkdf: 1.1.1.0. The Password Based Key Derivation Functions described in RFC-2898 with a test suite to verify that it works with the test vectors published in RFC6070.
pipes-network: 0.6.1. Use network sockets together with the @pipes@ library. This package is organized using the following namespaces: * "Pipes.Network.TCP" exports pipes and utilities for using TCP connections in a streaming fashion. * "Pipes.Network.TCP.Safe" subsumes "Pipes.Network.TCP", exporting pipes and functions that allow you to safely establish new TCP connections within a pipeline using the @pipes-safe@ facilities. You only need to use this module if you want to safely acquire and release operating system resources within a pipeline. See the @NEWS@ file in the source distribution to learn about any important changes between version.
pipes-network-tls: 0.2.0. Use TLS-secured network connections together with the @pipes@ ecosystem. This package is organized using the following namespaces: * "Pipes.Network.TCP.TLS" exports pipes and utilities for using TLS-secured TCP connections in a streaming fashion. * "Pipes.Network.TCP.TLS.Safe" subsumes "Pipes.Network.TCP.TLS", exporting pipes and functions that allow you to safely establish new TCP connections within a pipeline using the @pipes-safe@ facilities. You only need to use this module if you want to acquire and release operating system resources within a pipeline. See the @NEWS@ file in the source distribution to learn about any important changes between version.
pipes-rt: 0.3.0, 0.4.0, 0.4.1. Use this library to yield values downstream according to different timing rules. For example, use the relTimeCat pipe, and your data will be yielded according to their timestamps. Or use poissonCat to yield values with poisson timing.
pipes-shell: 0.1.0. This package provide functions to build proper Pipes from Unix shell commands like /tr/, /ls/ or /echo/ in a concise way. Build with /cabal configure --enable-tests/ to build the little hspec test.
postcodes: 0.1.1. This library uses uk-postcodes.com to find the latitude and longitude of a postcode, postcodes in a certain area and the postcode that a location fits into
quickcheck-property-comb: 0.1.0.0. This project aims to reduce the pain of composing invariants/properties, and the documenting of those invariants for determining the cause of failure. Additionally, it intends to provide effective diagnostics for invariants with changing post-conditions, leading to faster cause-of-failure diagnosis.
reified-records: 0.1.0.0, 0.2.0.0. This package provides a series of functions to do introspect records and allow records to be manipulated dynamically as @Map@s. Currently this works using @Data.Data@ however in future this will likely change to @GHC.Generics@ and allow more user hooks into how types are reified and reflected.
sarasvati: 0.3.0.0. an audio library with portaudio.
scotty-fay: 0.0.1. Fay integration for Scotty. For more information, please see <https://github.com/hdgarrood/scotty-fay>.
simplessh: 0.1.0.0, 0.2.0.0. It supports authentication by password or keys. Everything is in the SimpleSSH monad which is ErrorT SimpleSSHError IO, allowing to manage errors in a "haskeller" way.
smtps-gmail: 1.0.0. Send email from your Gmail account using the simple message transfer protocol with transport layer security.
snaplet-postmark: 0.1.0. This snaplet contains support for using the Postmark email system with a Snap Framework application.
snaplet-redis: 0.1.3.1. This package provides a snaplet which exposes interface to Redis in-memory key-value storage as implemented by Hedis library. Inline documentation contains usage examples.
snaplet-stripe: 0.1.0. This snaplet contains support for using the Stripe payment platform with a Snap Framework application.
socket-activation: 0.1.0.0. a module for systemd socket activation. See <http://0pointer.de/blog/projects/socket-activation.html> and <http://www.freedesktop.org/software/systemd/man/systemd.socket.html> for more details.
socketio: 0.1.0.0. Socket.IO for Haskell folks. [Socket.IO] <http://socket.io/> [Protocol] <https://github.com/LearnBoost/socket.io-spec> @ {-# LANGUAGE OverloadedStrings #-} import Web.SocketIO \-\- listens to port 4000 main = server 4000 $ do     \-\- ping pong     on "ping" $ emit "pong" []     \-\- reply :: CallbackM [Text]     on "echo" $ reply >>= emit "pong"     \-\- do some IO     on "Kim Jong-Un" $ liftIO launchMissile @
sqlite-simple: 0.4.3.1, 0.4.4.0. Mid-level SQLite client library, based on postgresql-simple. Main documentation: "Database.SQLite.Simple" For more info, browse to <http://github.com/nurpax/sqlite-simple> for examples & more information.
stomp-queue: 0.0.5. The Stomp Protocol specifies message-oriented interoperability. Applications connect to a message broker to send (publish) or receive (subscribe) messages through queues. Interoperating applications do not know the location or internal structure of each other. They see only each other's interfaces, /i.e./ the messages published and subscribed through the broker. The Stomp Queue library provides a Stomp client, using abstractions like 'Connection', 'Transaction', 'Queue' and 'Message'. More information, examples and a test suite are available on <http://github.com/toschoo/mom>. The Stomp specification can be found at <http://stomp.github.com>. Release History: [0.0.5] Underline functions removed, with* functions: withWriter, withPair, new option for connection (ClientId), Headers for broker-specific options can be passed to connection, memory leaks solved. [0.0.3] New interface writeAdHoc [0.0.2] Minor corrections [0.0.1] Initial release
superdoc: 0.1.0.0. This package extends Cabal's documentation building capabilities. It extends the Haddock markup language with syntax for subscripts, superscripts, bold text, non-breaking spaces, and images. Moreover, it works around various bugs in Haddock's and HsColour's Unicode support, making it possible to use UTF8 encodings in both source code and documentation comments. This package is designed to work transparently. It provides a custom main function that package maintainers can use in their Setup.hs file. In most cases, this is as simple as setting the build-type to Custom, adding superdoc to the package dependencies, and putting the following two lines into Setup.hs: > import Distribution.Superdoc > main = superdocMain For more information on the available markup, see "Distribution.Superdoc".
takusen-oracle: 0.9.0. Takusen-Oracle is a Oracle access library. Like HSQL and HDBC, we support arbitrary SQL statements (currently strings, extensible to anything that can be converted to a string). It is based on original Takusen library. It was just upgraded to support Oracle 12c instant client and GHC 7.6.3.
tempodb: 0.1.0.0. TempoDB is a time-series database as-a-service with a robust REST API. This module provides a simple API wrapper to perform all of the primary requests to TempoDB.
th-orphans: 0.8. Orphan instances for TH datatypes. In particular, instances for Ord and Lift, as well as a few missing Show / Eq. These instances used to live in haskell-src-meta, and that's where the version number started.
thorn: 0.1, 0.1.0.1, 0.1.0.2, 0.1.0.3, 0.2. Thorn generates * functors from various kinds of datatypes, regardless of arity or variances. * folds and unfolds from various kinds of recursive datatypes, including mutually recursive ones. A single function of Thorn will give you a lot. Just try it. The haddock is here. <http://kinokkory.github.io/Thorn/>
time-exts: 1.0.0, 1.0.1, 1.0.2. Extensions to the Haskell time library, providing efficient Unix, UTC, and local timestamps.
time-series: 0.1.0.0. A package containing time series analysis prototyping. The analysis is for finding time-shifted correlations from multiple time series input data. In later phase, we might extend to do analysis of burst detection, but other analysis than for finding correlations are not considered yet.
unix: 2.7.0.0. This package gives you access to the set of operating system services standardised by POSIX 1003.1b (or the IEEE Portable Operating System Interface for Computing Environments - IEEE Std. 1003.1). The package is not supported under Windows (except under Cygwin).
vector-algorithms: 0.6.0.1. Efficient algorithms for vector arrays
whois: 1.0.0, 1.1.0. Provides a simple client to return WHOIS information about IP addresses or hostnames.
wxAsteroids: 1.1. The Asteroids game, using the wxHaskell GUI, as described in \"wxHaskell, A Portable and Concise GUI Library for Haskell\" <http://legacy.cs.uu.nl/daan/download/papers/wxhaskell.pdf>
xdot: 0.2.4. Parse Graphviz xdot files and interactively view them using GTK and Cairo. Currently not all xdot features are supported. Nodes and edges can be highlighted by hovering them and clicked. For an example of using this library try the accompanying @Demo.hs@ with the dot-files in @dot-examples/@. This library was originally written as part of ghc-vis, but is now a seperate project, in case anyone else may have a use for it.
zasni-gerna: 0.0.1. lojban zasni gerna parser
zeromq3-haskell: 0.2.5, 0.5.1. The 0MQ lightweight messaging kernel is a library which extends the standard socket interfaces with features traditionally provided by specialised messaging middleware products. 0MQ sockets provide an abstraction of asynchronous message queues, multiple messaging patterns, message filtering (subscriptions), seamless access to multiple transport protocols and more. This library provides the Haskell language binding to 0MQ >= 3.2.2