Hackage: Package candidates

Package candidates

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

Allure: 0.4.12. This is an alpha release of Allure of the Stars, a near-future Sci-Fi roguelike and tactical squad game. The game is barely fun at this stage and not yet really Sci-Fi. See the wiki for design notes and contribute. Please see the changelog file for recent improvements and the issue tracker for short-term plans. Long term goals are high replayability and auto-balancing through procedural content generation and persistent content modification based on player behaviour. The game is written using the LambdaHack roguelike game engine available at <http://hackage.haskell.org/package/LambdaHack>.
BlastHTTP: 1.0.0, 1.0.1. Searches for a provided nucleotide or protein sequence with the NCBI Blast REST service and returns a blast result in xml format as BlastResult datatype. For more information on BLAST refer to: <http://blast.ncbi.nlm.nih.gov/Blast.cgi>. Information on the webservice can be found at: <http://www.ncbi.nlm.nih.gov/BLAST/developer.shtml>. If you plan to submit more than 20 searches in one session, please look up the Usage Guidelines in the webservice information.
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.
Condor: 0.1, 0.2, 0.3. An Information Retrieval (IR) library which consists of the following components: * Search - for indexing and searching text documents. Check "Condor.Search.Index" for API information * Readers for reading documents from disk. Check "Condor.Reader.Text" folder text reader.
Decimal: 0.4.1. A decimal number has an integer mantissa and a negative exponent. The exponent can be interpreted as the number of decimal places in the value.
Dish: 0.0.0.1. A group of Hash related utilities (currently wraps MurmurHash3 C implementation)
Dust: 2.2, 2.2.1. Dust is a polymorphic protocol engine designed to circumvent Internet filtering based on protocol identification
EtaMOO: 0.1.0.0. LambdaMOO is a network-accessible, multi-user, programmable, interactive system well-suited to the construction of text-based adventure games, conferencing systems, and other collaborative software. EtaMOO is an experimental multithreaded implementation of LambdaMOO in Haskell with anticipated ready support for 64-bit MOO integers and Unicode MOO strings. The implementation follows the specifications of the LambdaMOO Programmer's Manual, and should be compatible with most LambdaMOO databases as of about version 1.8.3 of the LambdaMOO server code. /N.B./ This is (currently) incomplete software. It is not yet usable, although with further development it is hoped that it soon will be.
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
HEigs: 0.0.1. The aim of this package is to emulate MATLAB and SciPy's 'eigs' routines for finding a small number of eigenvalues from large sparse linear systems. Currently only supports a limited subset of ARPACK's functionality. I plan to add more in the future but if there's a specific type of eigenvalue problem you need solved please email and I'll make supporting that a priority.
HSlippyMap: 0.1.0.0, 1.0, 1.2, 1.4, 1.6, 1.8, 2.0, 2.1, 2.2.
HaRe: 0.7.0.6, 0.7.0.8, 0.7.0.9, 0.7.1.0, 0.7.1.1, 0.7.1.2, 0.7.1.3, 0.7.1.4, 0.7.1.5, 0.7.1.6, 0.7.1.7, 0.7.2.0, 0.7.2.1, 0.7.2.2. 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 (via travis-ci.org) 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. Despite the disclaimer, HaRe attempts to operate in a safe way, by first writing new files with proposed changes, and only swapping these with the originals when the change is accepted. In the process the original file is renamed to have the current date/time as a suffix. Thus it should be possible to (manually) undo changes. The renaming refactoring seems reasonably reliable, as does lifting and demoting At the moment parsing of any file with FFI exports will fail.
LambdaHack: 0.2.12. This is an alpha release of LambdaHack, a game engine library for roguelike games of arbitrary theme, size and complexity, packaged together with a small example dungeon crawler. When completed, the engine will let you specify content to be procedurally generated, define the AI behaviour on top of the generic content-independent rules and compile a ready-to-play game binary, using either the supplied or a custom-made main loop. Several frontends are available (GTK is the default) and many other generic engine components are easily overridden, but the fundamental source of flexibility lies in the strict and type-safe separation of code and content and of clients (human and AI-controlled) and server. Please see the changelog file for recent improvements and the issue tracker for short-term plans. Long term vision revolves around procedural content generation and includes in-game content creation, auto-balancing and persistent content modification based on player behaviour. A larger game that depends on the LambdaHack library is Allure of the Stars, available from <http://hackage.haskell.org/package/Allure>. Note: All modules in this library are kept visible, to let games override and reuse them. OTOH, to reflect that some modules are implementation details relative to others, the source code adheres to the following convention. If a module has the same name as a directory, the module is the exclusive interface to the directory. No references to the modules in the directory are allowed except from the interface module. This policy is only binding inside the library --- users are free to do whatever they please, since the library authors are in no position to guess their particular needs.
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.
OpenVG: 0.7.0. A Haskell binding for the OpenVG vector graphics API version 1.0.1, specifically the ShivaVG-0.2.1 implementation. This version (0.7.0) should be compatible with the Haskell Platform (2013.2.0.0). \*\* WARNING - large parts of the API (particular the Paths module) are untested and may be revised in future. \*\*. Changelog 0.6.0 to 0.7.0 * Updated to work with GHC 7.6 and Platform 2013.2.0.0. * Updated Windows install instructions. 0.5.0 to 0.6.0 * Added an opaque matrix type to RenderingQuality. Acknowledgement - this was derived from the Matrix class in HOpenGL. * Revised Image module - PixelData is now an opaque type rather than a raw pointer. * Work on Path module - pathBounds implemented. This module is entirely untested and may change again in the future.
OpenVGRaw: 0.4.0. A raw Haskell binding to OpenVG vector graphics API version 1.0.1, specifically the ShivaVG-0.2.1 implementation. Following Sven Panne\'s OpenGL model this is essentially a 1:1 mapping between the OpenVG C API and Haskell and is expected to be used in concert with the higher-level @OpenVG@ pacakge. Detailed install instructions for Windows (MinGW/MSYS) are included in the @OpenVG@ package. Changelog v0.3.0 to v0.4.0 * Re-fixed imports to work with GHC 7.6. Seemingly I missed uploading V0.3.0 to Hackage in August 2012. v0.2.0 to v0.3.0 * Fixed imports v0.1.0 to v0.2.0 * Changed type of vgGetMatrix
Parry: 0.1.0.0. Parry is a scheduler for the exhaustive exploration of tree-like spaces. It is designed to be robust to client crashes and cluster walltimes, and is guaranteed to never \"forget about\" a job until it is done.
ParserFunction: 0.0.1. Parse mathematical expressions.
PasswordGenerator: 0.1.0.0. Simple library for generating passwords.
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.
RFC1751: 0.1.0.0. Convert 128-bit ByteString to/from 12 English words.
STL: 0.1.0.0, 0.2. STL is a simple file format for representing 3D objects as the triangles which form their surface. It is common in 3D printing workflows. This library provides parsing and serialization to and from both text and binary STL formats.
ShellCheck: 0.3.0, 0.3.1. The goals of ShellCheck are: * To point out and clarify typical beginner's syntax issues, that causes a shell to give cryptic error messages. * To point out and clarify typical intermediate level semantic problems, that causes a shell to behave strangely and counter-intuitively. * To point out subtle caveats, corner cases and pitfalls, that may cause an advanced user's otherwise working script to fail under future circumstances.
Stasis: 0.0.1. Multi-version concurrency control
StateVar-transformer: 1.0.0.0. StateVar with monad transformer
Thriftier: 0.0.1.0. `Thriftier` is a command-line tool which wraps a bit of Apache Thrift and makes it a bit easier to use. NOTE: This package isn't even alpha yet. You probably don't want to use it.
WeberLogic: 0.1.0.0, 0.1.1, 0.1.2. Logic interpreter
Wheb: 0.0.1.1. Wheb aims at providing a simple simple and straightforward web server. > import Web.Wheb > import Data.Text.Lazy (pack) > > main :: IO () > main = do > opts <- generateOptions $ addGET (pack ".") rootPat $ (text (pack "Hi!")) > runWhebServer (opts :: MinOpts) Wheb makes it easy to share a global context and handle requests statefully > > import Control.Concurrent.STM > import Control.Monad.IO.Class > import Data.Monoid > import Data.Text.Lazy (Text, pack) > import Web.Wheb > > data MyApp = MyApp Text (TVar Int) > data MyHandlerData = MyHandlerData Int > > instance Default MyHandlerData where > def = MyHandlerData 0 > > counterMw :: MonadIO m => WhebMiddleware MyApp MyHandlerData m > counterMw = do > (MyApp _ ctr) <- getApp > number <- liftIO $ readTVarIO ctr > liftIO $ atomically $ writeTVar ctr (succ number) > putReqState (MyHandlerData number) > return Nothing > > homePage :: WhebHandler MyApp MyHandlerData > homePage = do > (MyApp appName _) <- getApp > (MyHandlerData num) <- getReqState > html $ ("<h1>Welcome to" <> appName <> > "</h1><h2>You are visitor #" <> (pack $ show num) <> "</h2>") > > main :: IO () > main = do > opts <- generateOptions $ do > startingCounter <- liftIO $ newTVarIO 0 > addWhebMiddleware counterMw > addGET (pack ".") rootPat $ homePage > return $ MyApp "AwesomeApp" startingCounter > runWhebServer opts Wheb allows you to write robust high concurrency web applications simply and effectively. * The core datatype will allow you to build anything from a read-only server to a fully interactive web application with hundreds of routes without needing to define MonadTransformers. * Minimal boilerplate to start your application. * Plugin system
acme-basic: 0.1.0.0.
acme-cutegirl: 0.1.0.0. A package which exists solely to try and give the user a cute girl. Executable and library are both available.
aivika: 1.0, 1.1. Aivika is a multi-paradigm simulation library with a strong emphasis on the Discrete Event Simulation (DES) in the first order and System Dynamics (SD) in the second one. The library has the following features: * allows defining recursive stochastic differential equations of System Dynamics (unordered as in maths via the recursive do-notation); * supports the event-driven paradigm of DES as a basic core for implementing other paradigms; * supports extensively the process-oriented paradigm of DES with an ability to resume, suspend and cancel the discontinuous processes; * allows working with the resources (you can define your own behaviour or use the predefined queue strategies); * allows customizing the queues (you can define your own behaviour or use the predefined queue strategies); * allows defining an infinite stream of data based on the process-oriented computation, where we can define a complex enough behaviour just in a few lines of code; * allows defining processors (actually, the Haskell arrows) that operate on the infinite streams of data, because of which some models can remind of their high-level graphical representation on the diagram used by visual simulation software tools; * supports the activity-oriented paradigm of DES; * supports the basic constructs for the agent-based modeling; * allows creating combined discrete-continuous models as all parts of the library are very well integrated and this is reflected directly in the type system; * the arrays of simulation variables are inherently supported (this is mostly a feature of Haskell itself); * supports the Monte-Carlo simulation; * the simulation model can depend on external parameters; * uses extensively the signals to notify the model about changing the reference and variable values; * allows gathering statistics in time points; * hides the technical details in high-level simulation monads and even one arrow (some of these monads support the recursive do-notation). Aivika itself is a light-weight engine with minimal dependencies. However, it has additional packages Aivika Experiment [1] and Aivika Experiment Chart [2] that offer the following features: * automating the simulation experiments; * saving the results in CSV files; * plotting the deviation chart by rule 3-sigma, histogram, time series, XY chart; * collecting the summary of statistical data; * parallel execution of the Monte-Carlo simulation; * have an extensible architecture. All three libraries were tested on Linux, Windows and OS X. Please read the PDF document An Introduction to Aivika Simulation Library [3] for more details, although it is outdated and contains a very basic description only. The most powerful features of Aivika are not yet described in this PDF document. \[1] <http://hackage.haskell.org/package/aivika-experiment> \[2] <http://hackage.haskell.org/package/aivika-experiment-chart> \[3] <https://github.com/dsorokin/aivika/blob/master/doc/aivika.pdf>
aivika-experiment: 1.0, 1.1. This package allows defining simulation experiments for the Aivika package. Such experiments define in declarative manner what should be simulated and in which view the simulation results should be generated. It can be charts, tables and so on. The library is extensible and you can add new views for the results.
aivika-experiment-chart: 1.0, 1.1. This package complements the Aivika and Aivika Experiment packages with charting capabilites. Now the simulation results can be represented as charts. It was intentionally made a separate package as it has heavy dependencies on Haskell Charts, Cairo and GTK.
alfred: 0.1. A utility library for writing workflows for Alfred version 2.
angel: 0.5.0. @angel@ is a daemon that runs and monitors other processes. It is similar to djb's `daemontools` or the Ruby project `god`. It's goals are to keep a set of services running, and to facilitate the easy configuration and restart of those services. See the homepage for documentation.
apotiki: 0.5.1, 0.5.2. apotiki generates debian repositories fast. its goal is to be a great companion to fpm and jenkins. apotiki operates with the following features and constraints: - Supports a single debian release - Supports a single debian component - Supports an arbitrary number of architectures which need to be preprovisionned - Requires a valid PGP private key for signing
arb-fft: 0.1.0.0, 0.2.0.2. This library provides a pure Haskell complex-to-complex Fast Fourier Transform implementation for arbitrary length input vectors, using a mixed-radix decimation-in-time algorithm with specialised straight-line code for a range of base transform sizes, Rader's algorithm for prime length base transforms, and an empirical optimisation scheme to select a good problem decomposition. This package is probably primarily of pedagogical interest (FFTW is about five times faster for most input sizes). There is a long series of blog articles describing the development of the package, indexed at <http://www.skybluetrades.net/haskell-fft-index.html>.
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.
arrow-improve: 0.1.0.0. Optimisations to arrows.
assert-failure: 0.1.1.0. This library contains syntactic sugar that improves the usability of 'assert' and 'error'. This is actually a bunch of hacks wrapping the original 'assert' function, see inside. See also <http://hackage.haskell.org/package/loch>, <http://hackage.haskell.org/package/assert> and <https://ghc.haskell.org/trac/ghc/ticket/5273>.
avl-static: 0.1.0.0. A compile-time balanced AVL tree.
aws-sdk: 0.12.1. AWS (Amazon Web Services) sdk for Haskell. This library closesly follows the official sdk. To find more documentation, you can lookup functions in the official sdk docs for other languages: <http://docs.amazonwebservices.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/ec2/model/DescribeInstancesRequest.html>
aws-sdk-text-converter: 0.1.0.0, 0.2.0.0, 0.3. The text converter for aws-sdk.
base: 4.7.0.0. This package contains the "Prelude" and its support libraries, and a large collection of useful libraries ranging from data structures to parsing combinators and debugging utilities.
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)
bff-mono: 0.2.0, 0.2.1. This package provides a way to make a bidirectional transformation (a getter/setter pair, or so-called lens) from a description of unidirectional transformation. Like 'bff' package, the package constructs bidirectional transformations based on the free theorem. Unlike 'bff' package, the package supports some of monomorphic transformations.
bigdecimal: 0.1.0.0. Haskell library for arbitrary-precision floating-point arithmetic which is based on Data.Ratio Integer (i.e., Rational).
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.
blink1: 0.3.1. Provides an interface to the ThingM blink(1) LED <http://thingm.com/products/blink-1.html> similar to (but not dependent on) <http://github.com/todbot/blink1> via Linux hidraw or the libusb-based usb package.
bool-extras: 0.4.0. The `bool' function allows folding over boolean values. This is comparable to the `maybe' or `either' functions on their respective types. The `bool' function is a replacement for the build-in @if then else@-syntax. However, since it is a function, it can be partially applied and passed around to higher order functions, like so: > ghci> :m + Data.Bool.Extras > ghci> let yesOrNo = bool "no" "yes" > ghci> map yesOrNo [True, False, True] > ["yes", "no", "yes"] Note that the arguments to `bool' are in the opposite order of the @if then else@-syntax; First the false value, then the true value, and finally the boolean.
bytestring-from: 0.1, 0.1.1, 0.2, 0.2.1. Defines the type-class 'FromByteString' to convert values from ByteString.
c-dsl: 0.1.0.0, 0.2, 0.3. This DSL is meant to make it easier to write language-c's DSL by providing simple functions/operators for writing C AST's in Haskell.
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 @
cabal-dir: 0.1.0.0, 0.1.0.2, 0.1.0.3, 0.1.0.4. show dist dir of 'cabal copy/install' > % cabal configure > % cabal-dir > prefix : /usr/local/ > bindir : bin > libdir : lib/foo-0.1.2.3/ghc-8.8.8 > datadir: share/foo-0.1.2.3 > htmldir: share/doc/foo-0.1.2.3/html
cabal2ebuild: 0.0.15.1, 0.0.15.3, 0.0.15.4. > % ls > hoge.cabal ... > % cabal2ebuild > % ls > % hoge.cabal hoge-0.1.2.3.ebuild ...
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.
cantor: 0.1, 0.2, 0.3. Application for analyzing Java source code. Currently implemented: * Package dependency analysis * Line Of Code metric.
cao: 0.1.1. CAO Compiler
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.
check-pvp: 0.0. Check whether the version ranges used in the @Build-Depends@ field matches the style of module imports according to the Package Versioning Policy (PVP). See <http://www.haskell.org/haskellwiki/Package_versioning_policy>. The tool essentially looks for any dependency like @containers >=0.5 && <0.6@ that allows the addition of identifiers to modules within the version range. Then it checks whether all module imports from @containers@ are protected against name clashes that could be caused by addition of identifiers. You must run the tool in a directory containing a Cabal package. > $ check-pvp This requires that the package is configured, since only then the association of packages to modules is known. If you want to run the tool on a non-configured package you may just check all imports for addition-proof style. > $ check-pvp --include-all It follows a detailed description of the procedure and the rationale behind it. First the program classifies all dependencies in the Cabal file of the package. You can show all classifications with the @--classify-dependencies@ option, otherwise only problematic dependencies are shown. A dependency like @containers >=0.5.0.3 && <0.5.1@ does not allow changes of the API of @containers@ and thus the program does not check its imports. Clashing import abbreviations are an exception. The dependency @containers >=0.5.1 && <0.6@ requires more care when importing modules from @containers@ and this is what the program is going to check next. This is the main purpose of the program! I warmly recommend this kind of dependency range since it greatly reduces the work to keep your package going together with its imported packages. Dependencies like @containers >=0.5@ or @containers >=0.5 && <1@ are always problematic, since within the specified version ranges identifier can disappear. There is no import style that protects against removed identifiers. An inclusive upper bound as in @containers >=0.5 && <=0.6@ will also cause a warning, because it is unnecessarily strict. If you know that @containers-0.6@ works for you, then @containers-0.6.0.1@ or @containers-0.6.1@ will also work, depending on your import style. A special case of inclusive upper bounds are specific versions like in @containers ==0.6@. The argument for the warning remains the same. Please note that the check of ranges is performed entirely on the package description. The program will not inspect the imported module contents. E.g. if you depend on @containers >=0.5 && <0.6@ but import in a way that risks name clashes, then you may just extend the dependency to @containers >=0.5 && <0.6.1@ in order to let the checker fall silent. If you use the dependency @containers >=0.5 && <0.6.1@ then the checker expects that you have verified that your package works with all versions of kind @0.5.x@ and the version @0.6.0@. Other versions would then work, too, due to the constraints imposed by package versioning policy. Let us now look at imports that must be protected against identifier additions. The program may complain about a lax import. This means you have imported like > import Data.Map as Map Additions to @Data.Map@ may clash with other identifiers, thus you must import either > import qualified Data.Map as Map or > import Data.Map (Map) The program may complain about an open list of constructors as in > import Data.Sequence (ViewL(..)) Additions of constructors to @ViewL@ may also conflict with other identifiers. You must instead import like > import Data.Sequence (ViewL(EmptyL, (:<))) or > import qualified Data.Sequence as Seq The program emits an error on clashing module abbreviations like > import qualified Data.Map.Lazy as Map > import qualified Data.Map.Strict as Map This error is raised whenever multiple modules are imported with the same abbreviation, where at least one module is open for additions. Our test is overly strict in the sense that it also blames > import qualified Data.Map as Map > import qualified Data.Map as Map but I think it is good idea to avoid redundant imports anyway. Additionally you can enable a test for hiding imports with the @--pedantic@ option. The import > import Data.Map hiding (insert) is not bad in the sense of the PVP, but this way you depend on the existence of the identifier @insert@ although you do not need it. If it is removed in a later version of @containers@, then your import breaks although you did not use the identifier. Finally you can control what items are checked. First of all you can select the imports that are checked. Normally the imports are checked that belong to lax dependencies like @containers >=0.5 && <0.6@. However this requires the package to be configured in order to know which import belongs to which dependency. E.g. @Data.Map@ belongs to @containers@. You can just check all imports for being addition-proof using the @--include-all@ option. Following you can write the options @--include-import@, @--exclude-import@, @--include-dependency@, @--exclude-dependency@ that allow to additionally check or ignore imports from certain modules or packages. These modifiers are applied from left to right. E.g. @--exclude-import=Prelude@ will accept any import style for @Prelude@ and @--exclude-dependency=foobar@ will ignore the package @foobar@, say, because it does not conform to the PVP. Secondly, you may ignore certain modules or components of the package using the options @--exclude-module@, @--exclude-library@, @--exclude-executables@, @--exclude-testsuites@, @--exclude-benchmarks@. E.g. @--exclude-module=Paths_PKG@ will exclude the Paths module that is generated by Cabal. I assume that it will always be free of name clashes. Known problems: * The program cannot automatically filter out the @Paths@ module. * The program cannot find and check preprocessed modules. * The program may yield wrong results in the presence of Cabal conditions. If this program proves to be useful it might eventually be integrated in the @check@ command of @cabal-install@. See <https://github.com/haskell/cabal/issues/1703>. Alternative: If you want to allow exclusively large version ranges, i.e. @>=x.y && <x.y+1@, then you may also add the option @-fwarn-missing-import-lists@ to the @GHC-Options@ fields of your Cabal file. See <https://ghc.haskell.org/trac/ghc/ticket/4977>. Unfortunately there is no GHC warning on clashing module abbreviations. See <https://ghc.haskell.org/trac/ghc/ticket/4980>.
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".
clafer: 0.3.5, 0.3.5.1. Clafer is a general purpose, lightweight, structural modeling language developed at GSD Lab, University of Waterloo. Lightweight modeling aims at improving the understanding of the problem domain in the early stages of software development and determining the requirements with fewer defects. Clafer's goal is to make modeling more accessible to a wider range of users and domains. The tool provides a reference language implementation. It translates models to other formats (e.g. Alloy, XML) to allow for reasoning with existing tools.
claferIG: 0.3.5, 0.3.5.1. Clafer is a powerful (equivalent to first-order predicate logic) yet lightweight structural modeling language. Despite simplicity and conciseness of Clafer, writing correct models remains challenging due to hard-to-predict interactions among all constraints expressed in the model. Clafer instance generator (ClaferIG) is an interactive tool that generates instances and counter examples of concrete clafers in a Clafer model. If the concrete clafers do not have contradicting constraints, the generator produces valid instance data. Otherwise, the generator produces an unsatisfiable core which included all contradicting constraints and generates a counter example by removing one constraint from the core. The generator can potentially produce many instances if the concrete clafers are not fully specialized. The generator produces different instances on-demand. With these capabilities, the instance generator can be used for debugging models: checking the consistency of the model and detecting under- and overconstraining of the model. The instance generator can also be used programmatically via API (the command line and interactive session interfaces only use the API).
claferwiki: 0.3.5, 0.3.5.1. A wiki-based IDE for literate modeling with Clafer. A Plugin for the Gitit wiki which collects code blocks written in Clafer (.clafer), compiles them, renders into HTML and Dot, and replaces the code blocks with the results.
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.
coltrane: 0.1.0.0. Coltrane is a minimal web framework for Haskell, inspired by Ruby's Sinatra framework. Coltrane lets you write simple web applications in just a few lines of Haskell code.
command-qq: 0.2.0.0. Features: * Quasiquotation syntax for external interpreters > >>> [sh_| echo hello world! |] > hello world! * Custom quasiquoters > ghci = quoter $ callCommand "ghc" ["-ignore-dot-ghci", "-e"] Then you can use @ghci@ in ghci! > >>> [ghci| putStrLn "hello world!" |] :: IO () > hello world! For more examples, see @examples/CustomQQ.hs@ * Haskell values embedding See README.md for an example * DSLs See @examples/CommandT.hs@
condor: 0.3. An Information Retrieval (IR) library which consists of the following components: * Search - for indexing and searching text documents. Check "Condor.Search.Index" for API information * Readers for reading documents from disk. Check "Condor.Reader.Text" folder text reader.
conduit: 1.1.0. @conduit@ is a solution to the streaming data problem, allowing for production, transformation, and consumption of streams of data in constant memory. It is an alternative to lazy I\/O which guarantees deterministic resource handling, and fits in the same general solution space as @enumerator@\/@iteratee@ and @pipes@. For a tutorial, please visit <https://haskell.fpcomplete.com/user/snoyberg/library-documentation/conduit-overview>.
confsolve: 0.4. A command line tool for resolving conflicts of file synchronizers.
copr: 1.0.0. This provides a Haskell interface to the Fedora Copr public build system.
core-haskell: 0.6, 0.6.1, 0.6.2, 0.6.3, 0.6.4. A subset of Haskell using in UCC for teaching purpose. It enables a tiny subset of Haskell default, but the syntax can be customized, teacher can enable more syntax along with the teaching progress.
cpphs: 1.18. Cpphs is a re-implementation of the C pre-processor that is both more compatible with Haskell, and itself written in Haskell so that it can be distributed with compilers. This version of the C pre-processor is pretty-much feature-complete and compatible with traditional (K&R) pre-processors. Additional features include: a plain-text mode; an option to unlit literate code files; and an option to turn off macro-expansion.
cric: 0.1.0.0. A simple server confguration management tool
cron: 0.2.0. Cron data structure and Attoparsec parser. The idea is to embed it in larger systems which want to roll their own scheduled tasks in a format that people are used to. 'System.Cron' is where all the interesting datatypes live. You will also find 'scheduleMatches', which you can use to compare a time against a 'CronSchedule' to see if an action needs to be performed. System.Cron.Parser is where you will find the parsers `cronSchedule`, `crontabEntry` and `cronTab`. To parse individual schedules up to full crontab files.
cruncher-types: 1.0.0. You are not likely to find this useful unless you are building a library for accessing Eval.so's new API, or working on the "Cruncher" backend.
cryptsy-api: 0.1. Bindings for Cryptsy cryptocurrency exchange API.
cubical: 0.1.0, 0.1.1, 0.1.2. Cubical implements an experimental simple type checker for type theory with univalence with an evaluator for closed terms.
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-default-generics: 0.3. A class for types with a default value. Features generics support to add defaults to records.
data-interval: 0.4.0, 0.5.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.5.0 * fix dependency issue with QuickCheck and test-framework-quickcheck2 Changes in 0.4.0 * add simplestRationalWithin :: RealFrac r => Interval r -> Maybe Rational
data-lens-template: 2.1.8. Automatically derive @Lens@es for your data type for use with @Data.Lens@. Note: the code is derived from data-accessor-template <http://hackage.haskell.org/package/data-accessor-template> by Luke Palmer and Henning Thielemann.
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.
diagrams-contrib: 1.1.1.2. A collection of user contributions for diagrams, an embedded domain-specific language for generation of vector graphics.
diagrams-core: 1.1.0.1. The core modules underlying diagrams, an embedded domain-specific language for compositional, declarative drawing.
diagrams-haddock: 0.2.2.4. diagrams-haddock is a tool for compiling embedded inline diagrams code in Haddock documentation, for an easy way to spice up your documentation with diagrams. Just create some diagrams code using special markup, run diagrams-haddock, and ensure the resulting image files are installed along with your documentation. For complete documentation and examples, see <https://github.com/diagrams/diagrams-haddock/blob/master/README.md>. For a good example of a package making use of diagrams-haddock, see the diagrams-contrib package (<http://hackage.haskell.org/package/diagrams%2Dcontrib>).
diagrams-lib: 1.1.0.3. Diagrams is a flexible, extensible EDSL for creating graphics of many types. Graphics can be created in arbitrary vector spaces and rendered with multiple backends. diagrams-lib provides a standard library of primitives and operations for creating diagrams. To get started using it, see "Diagrams.Prelude".
diophantine: 0.1.0.0, 0.2.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.
directory: 1.2.1.0. This package provides a library for handling directories.
disk-free-space: 0.1.0.0. Retrieve information about disk space usage.
easyrender: 0.1.0.0. This module provides efficient functions for rendering vector graphics to a number of formats, including EPS, PostScript, and PDF. It provides an abstraction for multi-page documents, as well as a set of graphics primitives for page descriptions. The graphics model is similar to that of the PostScript and PDF languages, but we only implement a subset of their functionality. Care has been taken that graphics rendering is done efficiently and as lazily as possible; documents are rendered \"on the fly\", without the need to store the whole document in memory. The provided document description model consists of two separate layers of abstraction: * /drawing/ is concerned with placing marks on a fixed surface, and takes place in the 'Draw' monad; * /document structure/ is concerned with a sequence of pages, their bounding boxes, and other meta-data. It takes place in the 'Document' monad. In principle, the functionality provided by EasyRender is similar to a subset of Cairo; however, EasyRender is lightweight and at least an order of magnitude faster.
ec2-signature: 2.0, 3.0, 3.1. The Amazon EC2 style signature calculator. <http://docs.aws.amazon.com/general/latest/gr/signature-version-2.html>
edenskel: 2.0.0.0, 2.0.0.1. This package provides a skeleton library for semi-explicit parallel programming with Eden. Eden and the skeleton library depend on GHC, and should normally use a GHC extension to support parallel execution using message passing. This modified GHC-Eden compiler is available from the <http://www.mathematik.uni-marburg.de/~eden Eden homepage>. When built using a standard GHC, this package will use a threaded simulation of Eden. The <http://www.mathematik.uni-marburg.de/~eden Eden homepage> provides more documentation and a tutorial.
edentv: 4.3.0. The Eden Trace Viewer is a tool designed to help programmers optimize Eden programs by visualising traces (eventlog files) of Eden program runs. It is similar to (and precedes) threadscope. However, it has been designed to visualize not just threads, but also different machines, processes, and messages between processes. EdenTV can show you what has happened during the execution of your program. This is very helpful to optimize parallel programs.
effective-aspects: 0.1.0.0. A monadic embedding of aspect oriented programming, similar to AspectJ
egison: 3.2.15. An interpreter for Egison, the programming langugage that realized non-linear pattern-matching against unfree data types. With Egison, you can represent pattern-matching against unfree data types intuitively, especially for collection data, such as lists, multisets, sets. We can find Egison programs in @lib@ and @sample@ directories. This package also include Emacs Lisp file @egison-mode.el@ in @elisp@ directory. The following code is the program that determins poker-hands written in Egison. All hands are expressed in a single pattern. You can run this code online at <http://www.egison.org/demonstrations/poker-hands.html>. <<http://www.egison.org/images/poker-hands.png>> The pattern-matching of Egison is very powerful. We can use it for pattern-matching against graphs, too. Egison is not popular at all now. Please help us to make Egison popular.
elm-build-lib: 0.0.1, 0.1. Wrappers around the Elm binary to compile elm source strings into Javascript within Haskell
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.
enclosed-exceptions: 1.0.0. Catching all exceptions raised within an enclosed computation, while remaining responsive to (external) asynchronous exceptions.
enummapmap: 0.6.0. This package provides 'maps of maps' using Enum types as keys. The code is based upon Data.IntMap in containers 5.0.
etcd: 0.1.0.1, 0.1.0.2. See <https://coreos.com/using-coreos/etcd/>
ewe: 0.1.0.38. Another implemention of the EWE programming language originally created and developed by Kent D. Lee. EWE is an extension of the RAM programming language. RAM was created by Sethi.
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.
filepath: 1.3.0.2. A library for 'FilePath' manipulations, using Posix or Windows filepaths depending on the platform. Both "System.FilePath.Posix" and "System.FilePath.Windows" provide the same interface. See either for examples and a list of the available functions.
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, 0.2.1.1. 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.
flaccuraterip: 0.2.1. /flAccurateRip/ is a command line tool to verify the accuracy of FLAC files ripped form CD, using the information contained in the AccurateRip™ database about other rips of the same CD. Usage: suppose you ripped a CD into @track01.flac@, @track02.flac@, ..., @trackNN.flac@. Open a shell in the directory containing the FLAC files, and run: >$ flaccuraterip track01.flac track02.flac ... trackNN.flac If a pressing of this CD is present in the AccurateRip™ database, @flaccuraterip@ will output the ripping accuracy for each track. If the CD was ripped without setting the drive offset, you should use the flag @--sample-offset=N@, where N is the offset indicated in <http://accuraterip.com/driveoffsets.htm> for your drive.
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>
foldl-incremental: 0.1.0.0, 0.1.0.1, 0.1.0.2. `foldl-incremental` allows you to create incremental folds and scans such as moving averages or moving deviations. It supplies `Incremental` which represents a state of an exponential moving average calculation, and `incrementalize`, which turns functions into suitable step functions.
full-text-search: 0.2.1.0. An in-memory full text search engine library. It lets you run full-text queries on a collection of your documents. Features: * Keyword queries and auto-complete\/auto-suggest queries. * Can search over any type of \"document\". (You explain how to extract search terms from them.) * Supports documents with multiple fields (e.g. title, body) * Supports documents with non-term features (e.g. quality score, page rank) * Uses the state of the art BM25F ranking function * Adjustable ranking parameters (including field weights and non-term feature scores) * In-memory but quite compact. It does not keep a copy of your original documents. * Quick incremental index updates, making it possible to keep your text search in-sync with your data. It is independent of the document type, so you have to write the document-specific parts: extracting search terms and any stop words, case-normalisation or stemming. This is quite easy using libraries such as <http://hackage.haskell.org/package/tokenize tokenize> and <http://hackage.haskell.org/package/snowball snowball>. The source package includes a demo to illustrate how to use the library. The demo is a simplified version of how the library is used in the <http://hackage.haskell.org/package/hackage-server hackage-server> where it provides the backend for the package search feature.
generic-church: 0.1.0.0, 0.1.0.1. This package provides a type to generically construct the type of the church representation. Additionally, it provides a type class @ChurchRep@ which contains a pair of functions for mapping back and forth betweeen the two representations. Both the type and the @ChurchRep@ instance are be automatically constructed for all types with a @Generic@ instance.
ggtsTC: 0.5. A type checker and runtime system of rCOS/g following the definitions in the /ggts-FCS/ article. * Title: A graph-based generic type system for object-oriented programs * Authors: Wei Ke, Zhiming Liu, Shuling Wang and Liang Zhao * Accepted by: Frontier of Computer Science * Year: 2012 Programmed by: Wei Ke (c) 2012 Wei Ke License: GPL-3 License file: <LICENSE> Source package download: <ggtsTC-0.5.tar.gz> rCOS/g grammar: <grammar>
ghc-events-analyze: 0.2.0. ghc-events-analyze is a simple Haskell profiling tool that uses GHC's eventlog system. It helps with some profiling use cases that are not covered by the existing GHC profiling modes or tools. It has two major features: 1. While ThreadScope shows CPU activity across all your cores, ghc-events-analyze shows CPU activity across all your Haskell threads. 2. It lets you label periods of time during program execution (by instrumenting your code with special trace calls) and then lets you visualize those time periods or get statistics on them. It is very useful for profiling code when ghc's normal profiling mode is not available, or when using profiling mode would perturb the code too much. It is also useful when you want time-profiling information with a breakdown over time rather than totals for the whole run.
ghc-events-parallel: 0.4.2.0. Parses .eventlog files emitted by parallel GHC versions (6.12.3 and later). This package can replace the original ghc-events package and defines a superset of functions and types. Includes the ghc-events tool permitting, in particular, to dump an event log file as text.
ghc-prim: 0.3.1.0. GHC primitives.
ghcjs-websockets: 0.2.0.0. 'ghcjs-websockets' aims to provide an clean, idiomatic Haskell interface abstracting over the Javascript Websockets API, targeting 'ghcjs' for receiving serialized tagged and untagged data. The interface abstracts websockets as raw data streams and is designed to allow multiple styles of usage; in particular, is adapted for 'io-stream'-style usage and 'distributed-process'-style usage. It is designed to fit in unintrusively in larger frameworks, and adaptable for other interfaces (like 'pipes'). This library provides both /tagged/ and /untagged/ communication channels, using 'tagged-binary' <http://hackage.haskell.org/package/tagged-binary>. * /Untagged/ channels will throw away incoming binary data of unexpected type. * /Tagged/ channels will queue up binary data of unexpected type to be accessed later when data of that type is requested. Tagged channels mimic the behavior of Cloud Haskell <http://www.haskell.org/haskellwiki/Cloud_Haskell> and 'distributed-process' <http://hackage.haskell.org/package/distributed-process>, with their dynamic communication channels. You can use the same channel to send in polymorphic, typed data and deal with it at the time you wish. Some examples: * 'io-stream'-style usage. > -- Echoes input from the server. > main :: IO () > main = do > c <- openConnection "ws://server-url.com" > forever $ do > d <- withConn c expectText > putStrLn d > withConn c (sendText d) > closeConnection c * Commands involving connections can be sequenced with a monadic interface > -- Echoes input from the server. > main :: IO () > main = withUrl "ws://server-url.com" . forever $ do > d <- expectText > liftIO $ putStrLn d > sendText d * Wait for incoming data only decodable as a desired type, and skip over undecodable data. > -- Keep on printing all `Just` values, and stop at the > -- first `Nothing`. > whileJust :: ConnectionProcess () > whileJust = do > d <- expect > case d of > Just d' -> do > liftIO $ putStrLn d' > whileJust > Nothing -> > return () * Typed dynamic communication channels with 'tagged-binary' <http://hackage.haskell.org/package/tagged-binary>; channels looking for a specific type skip over input of the wrong type, and channels looking for the other type can pick them up later or in parallel. > -- Server emits `Int`s or `String`s randomly; launch > -- two parallel threads to catch the data as it comes > -- in, one watching for `Int`s and one watching for > -- `String`s. > main :: IO () > main = do > c <- openTaggedConnection "ws://server-url.com" > t1 <- forkIO . withConn c . forever $ do > n <- expectTagged > replicateM n . liftIO . putStrLn $ "got a number! " ++ show n > t2 <- forkIO . withConn c . forever $ do > s <- expectTagged > liftIO $ putStrN s > await t1 > await t2 > closeConnection c See the 'JavaScript.WebSockets' module for a more detailed introduction. There is still some functionality left to be desired; feel free to open a ticket and send in suggestions or bugs, and all pull requests are welcomed!
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.
glider-nlp: 0.1. Natural Language Processing (NLP) library. Check module in folder "Glider.NLP.Statistics" for universal functions and Glider.NLP.Language.language for functions designed for specific language.
gloss-banana: 0.1.0.0. This package exports a simple wrapper, in terms of Graphics.Gloss.Interface.IO.Game, that allows full control of the picture generated by Gloss as a Behavior, as well as providing access to Gloss' clock and input-handling functionality as Events.
gpah: 0.0.2. Generic Programming Use in Hackage:
group-with: 0.1.0.0, 0.2.0.0. A library to classify objects into multimaps by using a function generating keys for any object in the list. This allows an approach similar to SQL GROUP BY. Provides a more flexible approach to `GHC.Exts.groupWith`.
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.
h2048: 0.1.0.0, 0.1.0.1. a haskell implementation of Game 2048, based on <https://github.com/gabrielecirulli/2048>.
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.
haddock: 2.14.1, 2.14.2. Haddock is a documentation-generation tool for Haskell libraries
hake: 1.3.8.1. Like ruby's rake, hake have Hakefile which is Haskell source. And Hakefile is like rake's Rakefile, and make's Makefile. Hakefile is just Haskell source code, then you can use all Haskell features. New: > deps :: [ String ] -> [ String] -> Rule > deps trgts srcs == file trgts srcs $ \_ _ -> [] Use 'deps' if you want to define no command rule for new Targets. Please use addDeps if you will add dependencies to already existing targets. Hakefile example: > import Development.Hake > import Development.Hake.FunSetRaw > hake_rules = [ > > dflt [ "greeting" ] > , > file [ "greeting", "greeting.log" ] [ "hello.o", "good-bye.o" ] $ > const2 [ [ "linker", "-o", "greeting", "hello.o", "good-bye.o" ] ] > , > rule ".o" ".sfx1" $ > \t (s:_) -> [ [ "compiler1", s, "-o", t ] ] > , > rule ".o" ".sfx2" $ > \t (s:_) -> [ [ "compiler2", s, "-o", t ] ] > , > task "clean" > [ [ "rm", "-f", "hello.o", "good-by.o", "greeting", "greeting.log" ] ] > , > mkfl "script.sh" [ "#!/bin/sh", "echo This is script", "echo made by Hakefile" ] > , > ruleSS "" ".o" $ \t (s:_) -> [ (".c", [ [ "gcc", s, "-o", t ] ] ) , > (".cc", [ [ "g++", s, "-o", t ] ] ) ] ) > , > rule ".o" ".c" $ \_ (s:_) -> [ [ "gcc", "-c", s ] ] > , > rule ".o" ".cc" $ \_ (s:_) -> [ [ "g++", "-c", s ] ] > , > base (=="foo") (const [ "foo.gen", "Hakefile" ]) $ \t (s:_) _ _ -> do > gen <- readFile s > writeFile t $ unlines $ > [ "#!/bin/sh", "echo This is script" ] ++ lines gen > return ExitSuccess > > ] > > main = hake hake_rules
hakyll-elm: 0.1, 0.2, 0.2.1. A wrapper for compiling Elm (<http://elm-lang.org>) programs to html/javascript in a Hakyll project. Currently supports single-module programs that only import from an Elm runtime that's manually included.
happstack-fastcgi: 0.1.5. This library lets you write FastCGI programs with Happstack. This package reuses the SimpleHTTP API, making it very easy to port stand-alone HTTP programs to FastCGI.
happybara: 0.0.1. /About/ Happybara is an acceptance test framework inspired by the popular Ruby library \"Capybara\". A short example of Happybara's expressive DSL: >visit "http://happybara-is-awesome.com" >within $ xpath "//form[@id='vote-for-happybara']" $ do > fillIn (fillableField "First Name" [ ]) "Bob" > fillIn (fillableField "Last Name" [ ]) "Smith" > > click $ button "Vote!" [ disabled False ] /Learning Happybara/ I would suggest start with these resources (in order): * <https://github.com/cstrahan/happybara/ The Happybara Readme> * <http://hackage.haskell.org/package/happybara/docs/Happybara.html The Happybara Module docs> Happy web testing!
haskell-awk: 1.0, 1.0.1. Hawk is a command line utility to process streams of text using Haskell code. It is intended to be used in a UNIX pipeline. It offers a configuration system to personalize imported modules and a way to represent values on the console.
haskell-pdf-presenter: 0.2.5. The Haskell Pdf Presenter ("hpdfp") is a tool for presenting PDF-based slide shows. It has many features and niceties that make delivering a presentation easier. For example, as a presenter, it is useful to see the next slide before it is shown to the audience as well as how much allotted time remains. There are a lot of features that may not be immediately obvious so please be sure to look at the documentation. For help with the command line, use the "--help" flag. For help with the GUI, press the "?" key when the program is running. The "README" contains a terse summary of all the features. For more information and example uses, please visit the project home page.
haskell-plot: 0.1.0.0. Built on top of Chart (<http://hackage.haskell.org/package/Chart>).
haskell-starter: 0.1.0.0.
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.
haskell2010: 1.1.1.1, 1.1.2.0. This package provides exactly the library modules defined by the <http://www.haskell.org/onlinereport/haskell2010/ Haskell 2010 standard>.
haskell98: 2.0.0.3. This package provides compatibility with the modules of Haskell 98 and the FFI addendum, by means of wrappers around modules from the base package (which in many cases have additional features). However "Prelude", "Numeric" and "Foreign" are provided directly by the @base@ package.
haskelm: 0.0.2, 0.0.3, 0.0.4, 0.0.5, 0.1.12.0. Library and binary to translate Haskell code into Elm code
hastache: 0.6.0. Haskell implementation of Mustache templates (<http://mustache.github.com/>). See homepage for examples of usage: <http://github.com/lymar/hastache>
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.
hblas: 0.1.0.0. User friendly, simple bindings to BLAS and Lapack, favoring OpenBLAS as the substrate.
hchesslib: 0.1.0.0. Library implementing chess rules.
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.
heist-async: 0.6.0.0. This package provides six splices and some accompanying javascript to allow declarative ajax programming that involves no javascript programming.
helm: 0.5.0. A functionally reactive game engine, with headgear to protect you from the headache of game development provided.
herringbone: 0.0.1, 0.0.2, 0.0.3, 0.0.4, 0.0.5, 0.0.6, 0.0.7, 0.0.8. A library for compiling and serving static web assets. For more information, please see <https://github.com/hdgarrood/herringbone>.
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.
himpy: 0.5.0. Himpy provides a multi-threaded snmp poller which reports to riemann. Polled MIBs are grouped in recipes and produce relative results whereever possible (for instance, the storage recipe reports percents).
hjsmin: 0.1.4.2, 0.1.4.3, 0.1.4.5. Reduces size of javascript files by stripping out extraneous whitespace and other syntactic elements, without changing the semantics.
hmatrix: 0.15.2.1. Purely functional interface to basic linear algebra and other numerical computations, internally implemented using GSL, BLAS and LAPACK. The Linear Algebra API is organized as follows: - "Data.Packed": structure manipulation - "Numeric.Container": simple numeric functions - "Numeric.LinearAlgebra.Algorithms": matrix computations - "Numeric.LinearAlgebra": everything + instances of standard Haskell numeric classes
hobbits: 1.1.1. A library for canonically representing terms with binding via a constructor for introducing fresh names and a restricted API that avoids the need for alpha-equivalence.
holy-project: 0.1.0.0, 0.1.0.1. 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, 3.10.0.0. Higher-order optimization library See /Norman Ramsey, João Dias, and Simon Peyton Jones./ <http://research.microsoft.com/en-us/um/people/simonpj/Papers/c--/hoopl-haskell10.pdf "Hoopl: A Modular, Reusable Library for Dataflow Analysis and Transformation"> /(2010)/ for more details.
hopfli: 0.1.0.0. Hopfli provides a pure interface to compress data using Zopfli algorithm.
hpc: 0.6.0.1. This package provides the code coverage library for Haskell. See <http://www.haskell.org/haskellwiki/Haskell_program_coverage> for more information.
hs2048: 0.1.0. A <https://github.com/gabrielecirulli/2048 2048> clone in Haskell. This implements the game logic as well as a console interface for playing it.
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, 0.2.0.0, 0.2.1.0, 0.2.1.1, 0.3.0.0. Package adds hspec expectations (@\`shouldX\`@ things) that work nicely with the "lens" library
hsqml: 0.2.0.2, 0.2.0.3. 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
hssqlppp: 0.4.1. SQL parser and type checker, targets PostgreSQL SQL and PL/pgSQL. Documentation, examples on the homepage: <http://jakewheat.github.com/hssqlppp/>. Changes here: <https://github.com/JakeWheat/hssqlppp/blob/master/CHANGES>
hstradeking: 0.1.0. This is a Haskell binding for the TradeKing developers API (https://developers.tradeking.com/). It currently supports retrieving quotes and stock information, as well as the quote and trade streaming API. Support for the other TradeKing API endpoints is forthcoming. To use, install the package via cabal. This will create an executable called `tradeking`. To connect to the TradeKing API, you will need to create a new personal application from the TradeKing developers site. This should give you four strings: an OAuth consumer key, an OAuth consumer secret, an OAuth Token, and an OAuth Token Secret. You supply these into the `tradeking` application using a configuration file (either `$(HOME)/.tradeking` or `/etc/tradeking.conf`). This configuration file should look like: > consumer-key = <tradeking consumer key> > consumer-secret = <tradeking consumer secret> > oauth-token = <tradeking oauth token> > oauth-token-secret = <tradeking oauth token secret> Now you can run `tradeking quote SPY` to have it return the current quote for the S&P 500 ETF. `tradeking info MSFT` will provide information on Microsoft, and `tradeking stream MSFT` will provide a live stream of `MSFT` quotes. All commands accept more than one stock, so `tradeking quote MSFT AAPL`, `tradeking info MSFT SPY`, and `tradeking stream SPY AAPL` work as expected (subject to TradeKing) limits. You can also request quotes programmatically, using the API described here.
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.
httpd-shed: 0.4.0.1. This web server promotes a Request to IO Response function into a local web server. The user can decide how to interpret the requests, and the library is intended for implementing Ajax APIs.
hums: 0.6.0. A simple UPnP Media Server. Currently this has only been tested with a PlayStation 3 client. Any help/patches for getting it to work with other clients would be much appreciated.
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.
hwall-auth-iitk: 0.1.0.0, 0.1.0.1. Firewall Authentication script for IITK network in haskell.
hzk: 0.0.2. A haskell binding to Apache Zookeeper C library
idempotent: 0.1.0. A typeclass, and instances, for monoids that are idempotent.
identifiers: 0.2.0.1, 0.2.1.0, 0.3.0.0, 0.3.1.0, 0.4.0.0. Useful for situations where repeated-storage requirements of values become too costly.
idna: 0.3.0. Implements IDNA - Internationalized Domain Names in Applications (RFC 3490).
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
ihaskell: 0.2.0.0. IHaskell is a Haskell backend kernel for the IPython project. This allows using Haskell via a console or notebook interface. Additional packages may be installed to provide richer data visualizations.
inquire: 0.1. A console (text/terminal) based client for online encyclopedias such as Wikipedia.
int-cast: 0.1.0.0, 0.1.1.0. Provides statically or dynamically checked conversions between integral types.
integer-gmp: 0.5.1.0. This package provides the low-level implementation of the standard 'Integer' type based on the <http://gmplib.org/ GNU Multiple Precision Arithmetic Library (GMP)>. This package provides access to the internal representation of 'Integer' as well as primitive operations with no proper error handling, and should only be used directly with the utmost care. For more details about the design of @integer-gmp@, see <https://ghc.haskell.org/trac/ghc/wiki/Commentary/Libraries/Integer GHC Commentary: Libraries/Integer>.
jespresso: 0.9, 1.0. 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.
json-rpc-server: 0.1.0.0, 0.1.1.0. An implementation of the server side of JSON RPC 2.0. See <http://www.jsonrpc.org/specification>. This library uses 'ByteString' for input and output, leaving the choice of transport up to the user. See the 'Network.JsonRpc.Server' module for an example.
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-bash: 0.2.0. A library for parsing and pretty-printing Bash shell scripts.
language-ecmascript: 0.15.3, 0.15.4, 0.16, 0.16.1, 0.16.2. 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
lazyio: 0.0.3.3, 0.1. Run IO actions lazily while respecting their order. Running a value of the LazyIO monad in the IO monad is like starting a thread which is however driven by its output. That is, the LazyIO action is only executed as far as necessary in order to provide the required data.
leo: 0.1.0.0. leo lets you query http://dict.leo.org from your program, or the command line.
leveldb-haskell: 0.3.0. From <http://leveldb.googlecode.com>: LevelDB is a fast key-value storage library written at Google that provides an ordered mapping from string keys to string values. This library provides a Haskell language binding to LeveldDB. It is in very early stage and has seen very limited testing. Note: as of v1.3, LevelDB can be built as a shared library. Thus, as of v0.1.0 of this library, LevelDB is no longer bundled and must be installed on the target system (version 1.7 or greater is required).
libjenkins: 0.1.0.0, 0.2.0.0, 0.3.0.0, 0.4.0.0, 0.4.1.0, 0.4.2.0. Jenkins API interface. It supports REST and Discovery APIs
liblastfm: 0.3.2.0. Provides interface to Lastfm REST API, supports XML and JSON formats.
libnotify: 0.1.0.0. The package provides a high level interface to libnotify API (see "Libnotify") "Libnotify.C.Notify" and "Libnotify.C.NotifyNotification" modules contain bindings to C-level functions if you're into that
libnvvm: 1.0.0. FFI binding to libNVVM, a compiler SDK component from NVIDIA
linebreak: 0.1.0.1, 0.1.0.2. Simple functions to break a String to fit a maximum text width, using Knuth-Liang hyphenation algorhitm.
linux-file-extents: 0.1.0.0, 0.2.0.0. This package provides a simple wrapper around the Linux FIEMAP ioctl. It can be used to retrieve the list of all the extents of any given file, i.e. the area of the disk where the file is actually stored. This is similar to the @filefrag@ command line tool provided by the @e2fsprogs@ package.
linux-mount: 0.1.0.2. This module provides an interface to the system mount and umount functions.
linux-xattr: 0.1.0.1. Bindings to the Linux syscalls for reading and manipulating extended attributes (@setxattr@, @getxattr@, @listxattr@, ...).
llvm-pkg-config: 0.0. Building the @llvm-base@ package is fragile due to its configuration process. It would be much simpler, if LLVM would support pkg-config since this is nicely integrated in Cabal. However, LLVM developers do not seem to care much about it: <http://llvm.org/bugs/show_bug.cgi?id=9405>. If we are lucky we get pkg-config support in Debian Linux. Until this comes true, you can use this program. It calls @llvm-config@ and writes its output to a PC file. > llvm-pkg-config calls default @llvm-config@ and writes the generated file to standard output. > sudo llvm-pkg-config --install installs the PC file at a default location. This should be the standard task to perform. > llvm-pkg-config --llvm-config=/custom/path/to/llvm-config if you have multiple versions of LLVM installed you may choose an @llvm-config@ other than the default one.
logict: 0.6.0.1, 0.6.0.2. A continuation-based, backtracking, logic programming monad. An adaptation of the two-continuation implementation found in the paper "Backtracking, Interleaving, and Terminating Monad Transformers" available here: <http://okmij.org/ftp/papers/LogicT.pdf>
lrucache: 1.1.1.4. This package contains a simple, pure LRU cache, implemented in terms of "Data.Map". It also contains a mutable IO wrapper providing atomic updates to an LRU cache.
meep: 0.1.0.0, 0.1.1.0. A @Map@-like structure that contains up to one key-value pair
melody: 0.2. A scripting language meant to replace shell modeled after Joy.
mi: 0.0.1. Library for Multiple Instance
midisurface: 0.1.0.0. A simple GTK2 UI to send midi control values.
miniutter: 0.4.3.0. This library helps in generating simple present tense English sentences from short, parametrized descriptions. In a typical use, the structure of a clause is fixed, but the particular words to be used vary in arbitrary ways. The main goal of the library is to minimize the API complexity and the code size of programs that use it. The library doesn't attempt to ban incorrect English sentences, but just make the creation of the simple correct ones easy and predictable.
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-journal: 0.1.0.0, 0.2.0.0, 0.2.1.0, 0.2.1.1. This package provides a typeclass for logging situations when you want to deal with the logs on-the-fly. It also exports a monad transformer that enables such a kind of logging in any monad.
monad-resumption: 0.1.0.0, 0.1.0.1. Resumption and reactive-resumption monads for Haskell.
monadiccp-gecode: 0.1.2. Gecode extension for the Monadic Constraint Programming Framework (code generator and runtime solver backend)
monoid-subclasses: 0.3.4, 0.3.4.1, 0.3.5, 0.3.6. 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.
nc-indicators: 0.1. @nc-indicators@ displays a CPU load and memory usage mini-graphs in your @i3bar@, much like Gnome's @indicator-multiload@ applet. To use @nc-indicators@ simply @exec@ it on startup: @ exec --no-startup-id nc-indicators @ You can turn off either indicator and change the update interval, eg.: @ exec --no-startup-id nc-indicators --show_mem=0 --update_interval=300 @ @nc-indicators@ uses the standard system tray icon protocol, so it can be used with any system tray-like application, not just @i3bar@. But it was originally created to be used with @i3bar@.
nettle: 0.1.0. safe binding for the nettle (<http://www.lysator.liu.se/~nisse/nettle/nettle.html>) library.
network-simple-sockaddr: 0.1. @<http://hackage.haskell.org/package/network-simple-0.3.0 network-simple>@ works by resolving 'HostName's. This packages offers a similar API but working with unresolved addresses in the form of 'SockAddr'. In addition to 'IPv4' addresses, 'IPv6' and @Unix Domain Sockets@ are also supported.
newsynth: 0.1.1.0, 0.2. A library of algorithms for exact and approximate synthesis of quantum circuits over the Clifford+T gate set. This includes, among other things: * "Quantum.Synthesis.GridSynth": an efficient single-qubit approximate synthesis algorithm. From N. J. Ross and P. Selinger, \"Optimal ancilla-free Clifford+/T/ approximation of /z/-rotations\", <http://arxiv.org/abs/1403.2975>. * "Quantum.Synthesis.MultiQubitSynthesis": multi-qubit exact synthesis algorithms. From B. Giles and P. Selinger, \"Exact synthesis of multiqubit Clifford+/T/ circuits\", Physical Review A 87, 032332, 2013, <http://arxiv.org/abs/1212.0506>. * "Quantum.Synthesis.CliffordT": the computation of Matsumoto-Amano normal forms. From K. Matsumoto and K. Amano, \"Representation of Quantum Circuits with Clifford and π\/8 Gates\", <http://arxiv.org/abs/0806.3834>. * "Quantum.Synthesis.RotationDecomposition": an algorithm for decomposing multi-qubit unitary operators into one- and two-level unitaries. See e.g. Section 4.5.1 of M. A. Nielsen and I. L. Chuang, \"Quantum Computation and Quantum Information\", Cambridge University Press, 2002. This package also provides an easy-to-use command line tool for single-qubit approximate synthesis.
newtype-generics: 0.4. Per Conor McBride, the Newtype typeclass represents the packing and unpacking of a newtype, and allows you to operatate under that newtype with functions such as ala. Generics support was added in version 0.4, making this package a full replacement for the original newtype package, and a better alternative to newtype-th.
nonlinear-optimization-ad: 0.1.0. Wrapper of nonlinear-optimization package for using with AD package
numerals: 0.4. Convert numbers to number words in a number of languages. Each language has its own module. The module name is based on one of the ISO 639 Alpha codes. Each module contains one or more 'cardinal' and 'ordinal' functions and a 'struct' function. The 'cardinal' functions directly convert cardinal numbers to a string-like representation of their spoken form. The 'ordinal' functions do the same but for ordinal numbers. The 'struct' functions convert numbers to a polymorphic representation of their grammatical structure. The use of this package is best understood with some examples. First some English number names, both British and US variants: >>> import qualified Text.Numeral.Language.EN as EN >>> EN.uk_cardinal defaultInflection 123 :: Maybe Text Just "one hundred and twenty-three" >>> EN.us_cardinal defaultInflection (10^50 + 42) :: Maybe Text Just "one hundred quindecillion forty-two" French, which contains some traces of a base 20 system: >>> import qualified Text.Numeral.Language.FR as FR >>> FR.cardinal defaultInflection (-99) :: Maybe Text Just "moins quatre-vingt-dix-neuf" Conversions can fail. Alamblak, a language spoken by a few people in Papua New Guinea, has no representation for negative numbers: >>> import qualified Text.Numeral.Language.AMP as AMP >>> AMP.cardinal defaultInflection (-3) :: Maybe Text Nothing Some languages have multiple scripts and methods for writing number names. Take Chinese for example, which can be written using Han characters or transcribed to the Latin script using Pinyin. Traditional Chinese characters: >>> import qualified Text.Numeral.Language.ZH as ZH >>> ZH.trad_cardinal defaultInflection 123456 :: Maybe Text Just "十二萬三千四百五十六" Simplified characters for use in financial contexts: >>> ZH.finance_simpl_cardinal defaultInflection 123456 :: Maybe Text Just "拾贰万参仟肆伯伍拾陆" Transcribed using Pinyin: >>> ZH.pinyin_cardinal defaultInflection 123456 :: Maybe Text Just "shíèrwàn sānqiān sìbǎi wǔshí liù" Using the 'struct' functions you can see the grammatical structure of number names. Because the results of these functions are polymorphic you need to specify a specific type. >>> import qualified Text.Numeral.Language.NL as NL >>> NL.struct 123 :: Integer 123 >>> import Text.Numeral >>> NL.struct 123 :: Exp Add (Lit 100) (Add (Lit 3) (Mul (Lit 2) (Lit 10))) Compare with: >>> NL.cardinal defaultInflection 123 :: Maybe Text Just "honderddrieëntwintig" 100 (honderd) + (3 (drie) + (ën) 2 (twin) * 10 (tig))
old-locale: 1.0.0.6. This package provides the ability to adapt to locale conventions such as date and time formats.
old-time: 1.1.0.2. This package provides the old time library. For new projects, the newer <http://hackage.haskell.org/package/time time library> is recommended.
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.
persistent-cereal: 0.1.0. Minor boilerplate for writing Persistance instances for values that are serializable with the 'cereal' library.
persistent-odbc: 0.1.2.0. This package contains backends for persistent using ODBC. It currently supports the following databases: MSSQL, MySql, Oracle, Sqlite, DB2, Postgres. Uses HDBC-ODBC for accessing ODBC.
phash: 0.0.1. See http://www.phash.org/ for more info. Note that you must have libphash installed on your system to use this library. Check your system library.
pipes-errors: 0.2. This package is analogous to the @<http://hackage.haskell.org/package/errors errors>@ package but for base monad manipulation in the presence of `Proxy` monad transformers. It also provides orphan `MFunctor` instances for `EitherT` and `EitherRT`.
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-p2p: 0.1, 0.2, 0.3. Toy library to facilitate the creation of custom P2P networks using `pipes`.
pipes-p2p-examples: 0.1, 0.2, 0.3. For now this package includes a dummy P2P network where nodes just exchange their network addresses. This can be used as boilerplate code for other P2P networks. Future releases may contain more examples.
pipes-rt: 0.3.0, 0.4.0, 0.4.1, 0.4.2. 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.
pipes-text: 0.0.0.0, 0.0.0.5, 0.0.0.7, 0.0.0.8, 0.0.0.9, 0.0.0.10, 0.0.1.0, 0.1.0.0. Many of the pipes and other operations defined here mirror those in the `pipes-bytestring` library. E.g., folds like `length` and grouping operations like `lines` simply adjust for the difference between strict `ByteString` and strict `Text`, and between `Word8` and `Char`. To this core are added some simple functions some akin to the `String` operations in `Pipes.Prelude`, some like the utilities in `Data.Text`. All of the `IO` operations defined here - e.g `readFile`, `stdout` etc. - are conveniences akin to those in `Data.Text.IO` which e.g. try to find the system encoding and use the exceptions defined in the `text` library. Proper `IO` in the sense of this library will employ `pipes-bytestring` in conjuntion with 'pure' operations like `decodeUtf8` and `encodeUtf8` that are defined here.
ponder: 0.0.1. Ponder is PEG parser combinator. This Library is experimental.
pontarius-xmpp: 0.3.0.3, 0.4.0.0, 0.4.0.1. Pontarius XMPP is a work in progress implementation of RFC 6120 ("XMPP CORE"), RFC 6121 ("XMPP IM"), and RFC 6122 ("XMPP ADDR"). While in alpha, Pontarius XMPP works quite well and fulfills most requirements of the RFCs.
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
prefork: 0.0.5, 0.0.6, 0.0.7. Prefork is a library for building a prefork-style server quickly.
pretty-show: 1.6.4, 1.6.5. We provide a library and an executable for working with derived 'Show' instances. By using the library, we can parse derived 'Show' instances into a generic data structure. The @ppsh@ tool uses the library to produce human-readable versions of 'Show' instances, which can be quite handy for debugging Haskell programs. We can also render complex generic values into an interactive Html page, for easier examination.
pubnub: 0.1.0.0.
puzzle-draw: 0.1.0.0. puzzle-draw is a library for drawing pencil puzzles using Diagrams. It aims to provide a utility layer on top of Diagrams to help with drawing arbitrary puzzles, as well as supporting several specific puzzle types directly. In addition, it includes functionality for parsing puzzle data from a YAML file format.
puzzle-draw-cmdline: 0.1.0.0. Companion executable to puzzle-draw. Separate to keep the dependency on diagrams-cairo out of the library.
quadratic-irrational: 0.0.1, 0.0.2, 0.0.3, 0.0.4, 0.0.5. A library for exact computation with <http://en.wikipedia.org/wiki/Quadratic_irrational quadratic irrationals> with support for exact conversion from and to <http://en.wikipedia.org/wiki/Periodic_continued_fraction (potentially periodic) simple continued fractions>. A quadratic irrational is a number that can be expressed in the form > (a + b √c) / d where @a@, @b@ and @d@ are integers and @c@ is a square-free natural number. Some examples of such numbers are * @7/2@, * @√2@, * @(1 + √5)\/2@ (<http://en.wikipedia.org/wiki/Golden_ratio the golden ratio>), * solutions to quadratic equations with rational constants – the <http://en.wikipedia.org/wiki/Quadratic_formula quadratic formula> has a familiar shape. A simple continued fraction is a number expressed in the form > a + 1/(b + 1/(c + 1/(d + 1/(e + …)))) or alternatively written as > [a; b, c, d, e, …] where @a@ is an integer and @b@, @c@, @d@, @e@, … are positive integers. Every finite SCF represents a rational number and every infinite, periodic SCF represents a quadratic irrational. > 3.5 = [3; 2] > (1+√5)/2 = [1; 1, 1, 1, …] > √2 = [1; 2, 2, 2, …]
quantities: 0.1.0, 0.2.0, 0.3.0. A library for creating and manipulating physical quantities, which are a numerical value associated with a unit of measurement. Included is an expression parser and a huge list of predefined quantities with which to parse strings into a Quantity datatype. Once created, a quantity can be converted to different units or queried for its dimensionality. A user can also operate on quantities arithmetically, and doing so uses automatic unit conversion and simplifcation.
quickcheck-property-comb: 0.1.0.0, 0.1.0.1, 0.1.0.2. These are simple monads that aim to reduce the pain of composing invariants/properties, and the documenting of those invariants for determining the cause of failure. Specifically, they provide a tool for effective diagnostic for invariants with changing post-conditions, leading to a faster cause-of-failure diagnosis. Example case for invariants on a data structure Consumers: > data (Ord l) => Consumers l = > Consumers > introduced :: S.Set l, > met :: M.Map (S.Set l) Bool, > disjoints :: Disjoints l > > > disjoints_odds :: Inv (Disjoints l) > disjoints_odds = do > doc "no odd sets in disjoints" > disjoint_sets <- cause > .. > return False > > disjoints_non_singletons :: Inv (Disjoints l) > disjoints_non_singletons = do > .. > return True > > disjoints_inv :: Invariants (Disjoints l) > disjoints_inv= do > sat disjoints_odds > sat disjoints_non_singletons > > introduced_in_disjoint :: Inv (Consumers l) > introduced_in_disjoint = do > doc "all at quantity are a singleton subset in disjoints" > subsets <- (map S.singleton) . S.toList . introduced <$> cause > disjoint_sets <- disjoints <$> cause > return . and . map ((flip S.member) disjoint_sets) $ subsets > > inv_consumers :: Invariants (Consumers l) > inv_consumers = do > satcomp disjoints disjoints_inv > satcomp met met_inv > sat introduced_in_disjoint And to run the invariants on generated cases: > prop_testedFunction :: Arg -> Property > prop_testedFunction arg = > let consumers = testedFunction arg in > runInvariants consumers inv_consumers
quickcheck-property-monad: 0.1. quickcheck-property-monad
rascal: 1.1.4, 1.1.5, 1.1.6. Rascal is a command-line client for Reddit with colors, configurable sorting, threaded comments, and some day most of Reddit's API available.
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.
rex: 0.4.3. Provides a quasi-quoter for regular expressions which yields a tuple, of appropriate arity and types, representing the results of the captures. Allows the user to specify parsers for captures as inline Haskell. Can also be used to provide typeful pattern matching in function definitions and pattern matches. Also, it precompiles the regular expressions into a PCRE compiled byte-array representation, at compile time.
riff: 0.1.0.0, 0.2.0.0, 0.3.0.0. This library provides a RIFF parser for Haskell for easy manipulation of common file formats like WAVE and RIFF container AVI files.
romkan: 0.1.0.0. Romkan is a library to convert from Japanese Romaji to Japanese Kana and vice versa. Homepage is at <https://github.com/karlvoigtland/romkan-hs>. This is a port of python-romkan: <http://www.soimort.org/python-romkan>.
sarasvati: 0.3.0.0. an audio library with portaudio.
science-constants: 0.1.0.0. This package provides constants and conversion factors commonly used in mathematics and physical sciences. The motivation is to make it easier to use ghci for quick scientific calculations [without the need to search for the constant values over the internet.] To make it even friendlier, if multiple conventional names of a constant exist, they all are provided by this package. Wherever possible, TeX-style named constants are also provided. This package utilizes untyped values (i.e. untyped in terms of @unittyped@, @dimensional@, and similar libraries); and unless otherwise specified, the constants are in SI units: mass in kilograms, length in meters, etc. Due to floating-point calculation errors and to improve accuracy, the package internally uses exact values even in cases where constants can be mathematically derived one from another. Most of the constants values were taken from the Fundamental Constants Data Center of the NIST Physical Measurement Laboratory (by Barry N. Taylor of the Data Center in close collaboration with Peter J. Mohr of the Physical Measurement Laboratory's Atomic Physics Division.) <http://physics.nist.gov/cuu/>
scotty-fay: 0.0.1, 0.0.2, 0.1.0, 0.1.1. Fay integration for Scotty. For more information, please see <https://github.com/hdgarrood/scotty-fay>.
scotty-hastache: 0.2.0. This library provides a small templating DSL extension for Scotty via the `hastache` library. [Scotty] is a light-weighted Web framework\/router <http://hackage.haskell.org/package/scotty> [Hashache] is a Haskell implementation of the Mustache templates: <http://mustache.github.io/>, <http://hackage.haskell.org/package/hastache>
scp-streams: 0.1.0. An SCP protocol implementation.
scrz: 0.0.0.1. @scrz@ is a daemon that runs and monitors other processes. It is similar to djb's `daemontools`, the Ruby project `god` or Haskell's `Angel`. It's goals are to keep a set of services running, and to facilitate the easy configuration and restart of those services.
sdl2-image: 0.1.0.1. Haskell binding to sdl2-image.
selectors: 0.1.0.0.
sha-streams: 0.1.0. SHA hashes for io-streams.
simple: 0.7.0.1. \Simple\ is \"framework-less\" web framework for Haskell web applications based on the WAI server interface (e.g. for use with the warp server). \Simple\ does not enforce a particular structure or paradigm for web applications. Rather, \Simple\ contains tools to help you create your own patterns (or re-create existing ones). \Simple\ is minimalist, providing a lightweight base - the most basic \Simple\ app is little more than a WAI `Application` with some routing logic. Everything else (e.g. authentication, controllers, persistence, caching etc\') is provided in composable units, so you can include only the ones you need in your app, and easily replace with your own components. To get started, create an app skeleton with the `smpl` utility: @ $ cabal install simple $ smpl create my_app_name $ cd my_app_name $ smpl @ See "Web.Simple" for a more detailed introduction.
simple-genetic-algorithm: 0.1.0.0. Simple parallel genetic algorithm implementation
simple-session: 0.8.0.1. Adds cookie-based session management to simple 'Controller's. To add to an application, declare the Controller setting\'s type an instance of 'HasSession', and wrap routes with 'withSession'. For example: > data AppSettings = ... > > instance HasSession AppSettings where > ... > controllerApp settings $ withSessions $ do > routeName \"posts\" $ ... Then, in your controllers you can seemlessly get and set keys from the session: > get "/profile" $ do > muserId <- sessionLookup "current_user_id" > case muserIf of > Nothing -> respond $ redirectTo "/login" > Just userId -> [handle request]
simple-sql-parser: 0.1.0.0, 0.2.0, 0.3.0, 0.3.1. A parser for SQL queries. Please see the homepage for more information <http://jakewheat.github.io/simple-sql-parser/>.
simpleirc: 0.3.0. Simple IRC Library. This IRC Library aims to be simple and lightweight.
simplessh: 0.1.0.0, 0.2.0.0, 0.2.0.1. 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.
skype4hs: 0.0.0.0. Skype Desktop API binding for Haskell
slidemews: 0.2, 0.3. Simple WebService to convert markdown to reveal-js | https://github.com/j4/slidemews
smallcaps: 0.4, 0.4.0.1, 0.4.1, 0.4.1.1, 0.4.1.2. smallcaps is a pre-processor library for LaTeX files. The library comes with an executable that makes most functionality accessible through a command line interface. The pre-processor formats sequences of uppercase letters with TeX's @\\small@ macro or whatever you configure. Uppercase letters at the beginning of sentences are not formatted. Other formatting conditions can be configured by the user. The executable can be configured through its command line arguments as well as through TeX comments. In the default configuration, lesscase does not change the content of any macro argument or environment (different from document). More and less restrictive configuration profiles can be activated and adapted. Configurations can be stored and restored at any time, even while processing the input file. ["Text.SmallCaps"] exports the main program as library. ["Text.SmallCaps.Config"] specifies the default configuration values for "Text.SmallCaps". ["Text.SmallCaps.TeXParser"] parses 'Text' to a 'TeXElement' token stream. ["Text.SmallCaps.TeXLaTeXParser"] parses a 'TeXElement' token stream and produces a 'LaTeXElement' token stream. ["Text.SmallCaps.DocumentParser"] replaces uppercase letters in 'LaTeXElement' token streams. A simple program can be defined as @ import Data.Default ( def ) import Text.SmallCaps ( smallcaps ) main = smallcaps def @
smtps-gmail: 1.0.0, 1.1.0, 1.1.1, 1.2.0. Send email from your Gmail account.
snap-testing: 0.2.0.0, 0.4.1.1.
snap-utils: 0.1.2. Snap.Utils provides helper modules for making web apps with Snap Framework. The underlying design goal is to rely on more traditional HTTP-based methods of stateless control flow instead of relying on cookies and server state continuations.
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-sqlite-simple: 0.4.6. This snaplet provides support for using the SQLite database with a Snap Framework application via the sqlite-simple package. It also includes an authentication backend. See <https://github.com/nurpax/snaplet-sqlite-simple/tree/master/example> for an example project that demonstrates the use of this snaplet. It implements a stand-alone application with a login screen that persists user information in a SQLite database and allows a logged in user to save comments. Querying and listing comments demonstrates how a user of snaplet-sqlite-simple might relate Snaplet.Auth based AuthUsers to his own tables.
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, 0.4.5.0, 0.4.5.2. Mid-level SQLite client library, based on postgresql-simple. Main documentation: <docs/Database-SQLite-Simple.html Database.SQLite.Simple> For more info, browse to <http://github.com/nurpax/sqlite-simple> for examples & more information.
ssv: 0.3. This modules provides conversion routines to and from "something-separated values", especially the infamous "comma separated value" (CSV) format. It attempts to adhere to the spirit and (mostly) to the letter of RFC 4180, which defines the 'text/csv' MIME type.
static-resources: 0.1.7. You need to add static resources to your web page. For production you want to decrease number of files. For development you need them separated. Support for distinct sets of JS, CSS and LESS files for different views.
statistics-incremental: 0.1.0.0. incremental staistics folds
stm: 2.4.3. A modular composable concurrency abstraction.
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
strict-identity: 0.1.0.0. strict Identity monad for writing strict performant code sanely
string-conversions: 0.3.0.1, 0.3.0.2. Provides a simple type class for converting values of different string types into values of other string types.
stringprep: 1.0.0. Implements the "StringPrep" algorithm
superdoc: 0.1.2.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".
tagged-binary: 0.1.0.0, 0.1.2.0. Very minimal library providing tools for serializing and decoding data into 'ByteString' tagged with information about its type, inspired by Cloud Haskell and distributed-process. Intended for use by libraries and frameworks in distributed contexts, such as distributed computation between native servers and communication between native servers and ghcjs/various front-ends, for behavior similar to the polymorphic communication channels of Cloud Haskell and distributed-process; servers can send tagged data, and clients can choose to selectively accept, ignore or queue incoming messages depending on their types. For basic encoding, decoding and categorization, only 'Data.Binary.Tagged' should be necessary. 'Data.Binary.Tagged.Internal' is exported in case you need it. Quick example: > > let x = encodeTagged (1 :: Int) > > decodeTagged x :: Maybe Bool > Nothing > > decodeTagged x :: Maybe Int > Just 1
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.
tasty-html: 0.1. A tasty ingredient to output test results in HTML5.
tasty-integrate: 0.0.1, 1.0.0.
tasty-program: 1.0.1. This package provides a function that extends <http://hackage.haskell.org/package/tasty tasty> testing framework with capability to test whether an external program runs successfully. This package is inspired by <http://hackage.haskell.org/package/test-framework-program test-framework-program> package by Adam Wick. tasty-program provides basic functionality of running a program with specified set of command line parameters, and optionally a working directory, and checking the exit code. Program's output and error streams are ignored.
template-haskell: 2.9.0.0. This package provides modules containing facilities for manipulating Haskell source code using Template Haskell. See <http://www.haskell.org/haskellwiki/Template_Haskell> for more information.
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, 1.1.0, 1.1.1, 1.1.2, 1.1.3, 2.0.0, 2.1.0. Haskell timestamps in various bit length and granularity.
time-patterns: 0.1.0.1, 0.1.0.2, 0.1.1.0, 0.1.2.0. This package contains a set of primitives and combinators for event patterns. Example: > >> import qualified Prelude as P > >> let sundays = every 2 sunday > >> let today = (YearMonthDay 2013 12 01)^.from gregorian > >> P.take 2 $ instancesFrom today sundays > [2013-12-08, 2013-12-22] See @Data.Time.Patterns@ for more examples.
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.
tracer: 0.1. Transformers for 'Functor', 'Applicative' and 'Monad' types that add tracing facilities for computation steps and applicative nesting. Simplifies print-based debugging.
twitter-feed: 0.1.0.1. Fetches a user timeline from Twitter, and optionally linkifies the results using the Twitter entity API.
tz: 0.0.0.1. This package has two main goals: * To distribute the standard time zone database in a cabal package, so that it can be used in Haskell programs uniformly on all platforms. * To provide a library that can read time zone info files (aka. Olson files), and does time zone conversions in a /pure/ and /efficient/ way. The current version ships the @2014b@ version of the time zone database. See: <http://www.iana.org/time-zones> for more info. The package is currently in a draft phase, I'm still experimenting with different ideas wrt. scope\/API\/implementation\/etc. All comments are welcome!
unix: 2.7.0.0, 2.7.0.1. 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).
uuid-aeson: 0.1.0.0. Instances of Aeson's ToJSON and FromJSON for UUIDs.
validations: 0.1.0.0, 0.1.0.1. See <https://github.com/mavenraven/validations> for description and tutorial. Code used in the tutorial can be found in src\/Validations\/Tutorial.lhs.
vector-algorithms: 0.6.0.1. Efficient algorithms for vector arrays
wai-cors: 0.1.0, 0.1.1. This package provides an implemenation of Cross-Origin resource sharing (CORS) for Wai that aims to be compliant with <http://www.w3.org/TR/cors>.
wai-middleware-etag: 0.1.0.0. WAI middleware that attaches ETags to responses for static files if they exist. Caveats: If caching is turned on, the middleware caches calculated checksums aggressively in a synchronized hashmap; checksums are calculated only once, so changes on the file-system are not reflected until the server is restarted. This middleware only calculates ETag checksums for file smaller than 1MB, otherwise it attaches a last-modified tag to the response. [WAI] <http://hackage.haskell.org/package/wai>
wai-predicates: 0.1, 0.2, 0.2.1, 0.3, 0.3.1, 0.3.2, 0.4. Evaluate predicate functions against WAI requests and receive metadata in addition to a success/failure indicator. Predicates can be combined using logical connectives and the metadata are passed on accordingly. <http://hackage.haskell.org/package/wai-routing wai-routing> extends the functionality of @wai-predicates@ with additional predicates and predicated request routing.
wai-route: 0.1.0, 0.1.1, 0.1.2. Simple routing for applications using the WAI, based on an efficient tree structure. Routes are defined as string literals and path segments prefixed with a ':' indicate captures. A sample is available at: <https://github.com/romanb/wai-route/blob/master/sample/Main.hs>.
wai-routing: 0.1, 0.2, 0.3, 0.3.1, 0.4, 0.4.1, 0.5, 0.5.1, 0.5.2, 0.5.3. Enables the declaration of \"routes\" which handle requests to a specific URL. The set of possible handlers can be restricted by \"predicates\", which operate on WAI requests and have to be true or else the handler will not be called. Example: >import Data.ByteString (ByteString) >import Data.Text (Text) >import Network.Wai >import Network.Wai.Predicate >import Network.Wai.Routing >import Network.Wai.Handler.Warp > >main :: IO () >main = run 8080 (route (prepare start)) > >start :: Monad m => Routes a m () >start = do > get "/user/:name" fetchUser $ > capture "name" > > get "/user/find" findUser $ > query "byName" ||| query "byId" > > delete "/user/:name" rmUser $ > capture "name" .&. opt (cookie "foo") > >fetchUser :: Monad m => Text -> m Response >fetchUser name = ... > >findUser :: Monad m => Either ByteString Word64 -> m Response >findUser (Left name) = ... >findUser (Right ident) = ... > >rmUser :: Monad m => Text ::: Maybe Int -> m Response >rmUser (name ::: foo) = ...
whois: 1.0.0, 1.1.0. Provides a simple client to return WHOIS information about IP addresses or hostnames.
wx: 0.90.1.0. wxHaskell is a portable and native GUI library for Haskell. It is built on top of wxWidgets - a comprehensive C++ library that is portable across all major GUI platforms; including GTK, Windows, X11, and MacOS X. This version works with wxWidgets 2.9 only.
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>
wxc: 0.90.1.0, 0.90.1.1. wxHaskell is a portable and native GUI library for Haskell. It is built on top of wxWidgets, a comprehensive C++ library that is portable across all major GUI platforms, including GTK, Windows, X11, and MacOS X. This version works with wxWidgets 2.9 only. Distributed under the WXWINDOWS LIBRARY LICENSE. Please see LICENSE file, but note that this is essentially LGPL with an exception allowing binary distribution of proprietary software. This is the same license as wxWidgets itself uses.
wxcore: 0.90.1.0, 0.90.1.1. wxHaskell is a portable and native GUI library for Haskell. It is built on top of wxWidgets, a comprehensive C++ library that is portable across all major GUI platforms, including GTK, Windows, X11, and MacOS X. This version works with wxWidgets 2.9 only. Distributed under the WXWINDOWS LIBRARY LICENSE. Please see LICENSE file, but note that this is essentially LGPL with an exception allowing binary distribution of proprietary software. This is the same license as wxWidgets itself uses.
wxdirect: 0.90.1.0, 0.90.1.1. wxHaskell is a portable and native GUI library for Haskell. It is built on top of wxWidgets, a comprehensive C++ library that is portable across all major GUI platforms, including GTK, Windows, X11, and MacOS X. This version works with wxWidgets 2.9 only.
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.
xhb: 0.5.2014.4.10. Provides low-level bindings to the X11 protocol. Similar to XCB - the X C Bindings. This library is based on version 1.6 of the xcb-proto package. See http:\/\/xcb.freedesktop.org\/XmlXcb\/ and http:\/\/xcb.freedesktop.org\/dist\/ .
xml-html-conduit-lens: 0.1.0.0, 0.1.0.1, 0.2.0.0. Optics for xml-conduit and html-conduit
yesod-auth-bcrypt: 0.1.0. BCrypt salted and hashed passwords in a database as auth for yesod
yesod-session-redis: 0.1.0.
yi-monokai: 0.1.0.0.
zasni-gerna: 0.0.1. lojban zasni gerna parser
zeromq3-haskell: 0.2.5, 0.5.1, 0.5.2. 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
zeromq4-haskell: 0.1, 0.2, 0.2.1, 0.3, 0.3.1, 0.3.2, 0.4, 0.4.1, 0.5. 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 >= 4.x
zmidi-core: 0.7.0. Minimalist library to read and write MIDI files, with dependencies only on ByteString, Containers and Data.Binary. Changelog: v0.6.0 to v0.7.0: * Changed @ChannelPrefix@ constructor to have a single argument - channel number (previously it stored a constant tag 0x01 as well as channel number). * Added @SysExCont@ and @SysExEscape@ constructors to the @MidiSysExEvent@ data type. * Added new pretty printers - @Csv@ based on @midicsv@ and @Ascii@ based on the ASCII MIDI representation in the book Beyond Midi (the zmidi ASCII representation is simplified). The demo application @MidiPrint@ now allows choice of pretty printer. * @printMidiHeader@ and @printMidiTrack@ from @Pretty@ changed to MidiFiles as arguments, @printMidi@ has now become @putMidi@. v0.5.0 to v0.6.0: * Extended the parser and changed the syntax tree to interpret MIDI Running Status. * Added a module @ZMidi.Core.Canonical@ to translate MidiFiles to a canonical form where any shorthand NoteOff introduced by Running Status is expanded to regular NoteOn and NoteOff events (with Running Status set, MidiFiles can signal NoteOff events as another NoteOn with 0 channel velocity). * Added a hack to the pretty printer to stop printing ASCII chars greater than 164 causing an error when printing to stdout. For older changes see - CHANGES file.