The String representations provided by this package are generally longer than show's output, which constructs the shortest string that is parsed as the original number by read. This requires some time-consuming checks, so show is slow for floating-point numbers. By producing a digit-string guaranteed to be long enough to uniquely determine the number without caring whether there's a shorter representation, the display functions of this package can be faster, sometimes by a big margin. Text.FShow.Raw provides building blocks for representations of numeric types which don't belong to RealFloat but have some of its functionality. The bulk of the code is a minor modification of code from the base package, whence the GHC License is included as an extra-source-file.

Fast, pure and practical SHA-256 implementation

Implementation of the model described in Grzegorz Chrupała and Afra Alishahi, Online Entropy-based Model of Lexical Category Acquisition, CoNLL 2010 http://www.lsv.uni-saarland.de/personalPages/gchrupala/papers/conll-2010.pdf

[Index] For package maintainers and hackage trustees

This package provides a shim for haskell-src-exts (HSE), exposing the same AST but without annotations, using ghc's pattern synonyms. See README.md for further information and compatibility considerations.

Purely-functional, coordinate-free linear algebra

Reflex-DOM is a Functional Reactive web framework based on the Reflex FRP engine

Please see the README and docs at https://www.stackage.org/package/fsnotify-conduit

Kansas Lava is a Domain Specific Language (DSL) for expressing hardware-oriented descriptions of computations, and is hosted inside the language Haskell. Kansas Lava programs are descriptions of specific hardware entities, the connections between them, and other computational abstractions that can compile down to these entities.

Write blog posts in Markdown format, then use BlogLiterately to do syntax highlighting, format ghci sessions, and upload to any blog supporting the metaWeblog API (such as Wordpress): http://codex.wordpress.org/XML-RPC_MetaWeblog_API. To get started, use the provided executable BlogLiterately; see http://byorgey.wordpress.com/blogliterately/ for complete documentation. To make further customization possible, the internals of the executable are made available as a library. In particular, it is easy to create your own executable which adds extra custom transformations; see Text.BlogLiterately.Run.

A Haskell binding for the OpenGL graphics system (GL, version 4.6) and its accompanying utility library (GLU, version 1.3). OpenGL is the industry's most widely used and supported 2D and 3D graphics application programming interface (API), incorporating a broad set of rendering, texture mapping, special effects, and other powerful visualization functions. For more information about OpenGL and its various extensions, please see http://www.opengl.org/ and http://www.opengl.org/registry/.

This is a base library for bioinformatics with emphasis on RNA and DNA primary structure as well as amino acid sequences. Provided are efficient encodings for short (limited by the amount of RAM) sequences, as required by RNA folding tools. Extended RNA secondary structures can be represented as well. Contains data from: http://dx.crossref.org/10.1093%2Fnar%2Fgkp011

Painless general-purpose sampling.

See README.md. Documentation maintained at https://mstksg.github.io/uncertain

An in-memory key/value store with expiration support

Like `Control.Concurrent.forkIO`, but uses remote machines instead of local threads.

Scotty server add-on for Fluid

Profunctors.

Provides QuickCheck implementations for common types distributed with GHC and in the Haskell Platform. The implementations are NOT provided through the QuickCheck Arbitrary and CoArbitrary typeclasses; instead, they are provided through ordinary, non-overloaded functions. This avoids problems with orphan instances. Implementations are provided through child modules of the module that provides the original type. For example, for Data.Map, look under Data.Map.Generators, Data.Map.Shrinkers, and Data.Map.Coarbitrary. For instance, a function that generates a Map is at Data.Map.Generators.map, while a function providing a coarbitrary implementation is at Data.Map.Coarbitrary.map. Obviously this can lead to name conflicts, both between modules provided in this package and with other standard modules, so keep this in mind when you do your imports.

Fairly complete high-level binding to LAME encoder.

Types and low level operations for rfc1413

Plot-ho-matic provides real-time plotting of time-series data with a simple interface (addHistoryChannel). There is also a more general interface to plot arbitrary data (addChannel). See the example on http://www.github.com/ghorn/Plot-ho-matic to help get started.

Pencil is a static site generator. Use Pencil to build a personal website, a blog, and more. Pencil comes pre-loaded with goodies such as Markdown and Sass/Scss support, templating, blogging, and tagging. Designed with the Haskell beginner in mind, but flexible enough to extend for your own needs.

This library contains high through put sequencing and Ensembl-related functionality: - Datastructures to query Ensembl REST interface Parser for GFF3 Datastructure for GFF3

A yesod subsite serving a wiki.

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. Solutions 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.

Supplements the Statistics.Distribution.Hypergeometric module from the excellent statistics package. Implements the interfaces ContGen and DiscreteGen for HypergeometricDistribution. Provides it's own function genVar generalised over Integral.

Please see the README on GitHub at https://github.com/akshaymankar/jsonpath-hs#readme

High level APIs for leaveraging neural networks with MXNet in Haskell

This library provides implementations of five different queues (binomial, pairing, skew, leftist, and Braun), each in two flavours: one verified, and one not. At the moment, only structural invariants are maintained. More information, and a walkthough of a couple implementations, can be found at this blog post. Comparisons of verified and unverified queues Both versions of each queue are provided for comparison: for instance, compare the standard leftist queue (in Data.Queue.Leftist): To its size-indexed counterpart (in Data.Queue.Indexed.Leftist): The invariant here (that the size of the left queue must always be less than that of the right) is encoded in the proof m <= n. With that in mind, compare the unverified and verified implementatons of merge: Verified: Using type families and typechecker plugins to encode the invariant The similarity is accomplished through overloading, and some handy functions. For instance, the second if-then-else works on boolean singletons, and the <=. function provides a proof of order along with its answer. The actual arithmetic is carried out at runtime on normal integers, rather than Peano numerals. These tricks are explained in more detail TypeLevel.Singletons and TypeLevel.Bool. A typechecker plugin does most of the heavy lifting, although there are some (small) manual proofs. Uses of verified queues The main interesting use of these sturctures is total traversable sorting (sort-traversable). An implementation of this is provided in Data.Traversable.Parts. I'm interested in finding out other uses for these kinds of structures.

This is cabal-install with bundled dependencies. Easier to bootstrap.

A library of combinators to build transition kernels, proposal distributions, target distributions, and stream operations for MCMC sampling.

Simple git wrapper to access common git functions in a simple haskell way.

A way to write XML and HTML with more efficient syntax.

An efficient strict bytestring builder

Types for offsets into unboxed arrays

Parser combinator framework specialized to lexical analysis. Tokens are specified via simple fold functions, and we include baked in source location handling. Comes with matchers for standard lexemes like integers, comments, and Haskell style strings with escape handling. No dependencies other than the Haskell base library. If you want to parse expressions instead of tokens then try try the parsec or attoparsec packages, which have more general purpose combinators.

Provides an EDSL with Orc primitives.

An application to help with scoring Cricket dart games.

This package is an experimental teaching tool that provides the foundation for presenting functional idioms with graphical metaphors. The OpenGL canvas boilerplate is abstracted away to a simple interface, which allows to focus on program logic instead of the graphics API. It's also arguably fun.

A small utility to declare type-safe static URIs

This package provides a straightforward port of monadLib's BaseM typeclass to transformers.

Haskell bindings to the Myo's armband

Please see the README on GitHub at https://github.com/andys8/git-brunch

Simple command-line tool to manage some key-value store in a single file.

string-combinators provides handy polymorphic functions to build and combine string-like values. All functions are polymorphic in their string-like type but usually have a Monoid or IsString constraint.

Extras for the "contravariant" package

Usage: Mailbox-count produces a simple count of mailboxes that exist per-domain in some SQL database. The default queries are compatible with the schema used by PostfixAdmin http://postfixadmin.sourceforge.net/, but it is possible to supply your own queries via the --summary-query and --detail-query options. The summary report lists each domain, along with the number of mailboxes owned by that domain. The order is determined by the summary query, which lists the domains alphabetically by default. The default detail report shows the same, but also contains a list of each individual mailbox (again in alphabetical order) belonging to the domains. Input: None. Output: Either a summary, or detailed report (with --detail) of the number of mailboxes per-domain contained in the database. Options: The name of the database (or file, if SQLite) to which we should connect. Default: The name of the current user (Postgres only). Produce a detailed report listing all mailboxes by domain. SQL query used to produce the detail report. This should return the set of all (domain, username) pairs. See the default value for an example. Default: "SELECT domain,username FROM mailbox ORDER BY domain;" Hostname where the database is located (Postgres-only). Default: None, a UNIX domain socket connection is attempted (Postgres only) Password used to connect to the database (Postgres-only). Default: None (assumes passwordless authentication) --port Port number used to connect to the database (Postgres-only). Default: None, a UNIX domain socket connection is attempted (Postgres only) SQL query used to produce the summary report. This should return (domain, user count) pairs. See the default value for an example. Default: "SELECT domain,COUNT(username) FROM mailbox GROUP BY domain ORDER BY domain;" Username used to connect to the database (Postgres-only). Default: The current user Examples: The default summary report: The more detailed report:

[Index] For package maintainers and hackage trustees

[Index] For package maintainers and hackage trustees

Please see the README on GitHub at https://github.com/schnecki/api-maker#readme

Provide a uniform interface over file archives and directories in Haskell

simple json-rpc client for PegNet integration

This package exports a function that lets you control shine's functionality through a Var that maps from inputs to a Picture plus a bunch of utility Vars, like the current time and the keypresses.

A heirarchy of classes for numbers and algebras that combine them: a numeric tower. Performance testing, notes and examples can be found in tower-dev. The tower looks something like:

a Haskell library built on top of WAI for processing and routing HTTP requests and generating responses. see the source repository for a simple example application.

Tool to download Fedora iso and image files

empty

Type-classes abstracting various kinds of approximations for exact entities: those that are near to the exact value due to limited granularity (eg floating point numbers with fixed granularity (aka precision) approximating real numbers or bounded-degree polynomials with floating point coefficients approximating continuous functions) those that somehow enclose the exact entity, usually using a pair of endpoints Type classes are provided to capture: the partial, sometimes semi-decided, natural ordering (<=) used in relation to nearness the partial, sometimes semi-decided, refinement ordering (⊑) used in relation to enclosure This package does not compile with ghc 7.0.* due to a compiler bug that has been fixed for the 7.2.1 release. Haddock documentation can be found via http://code.google.com/p/aern/wiki/Main.

Typed type representations and equality proofs Project wiki page: http://haskell.org/haskellwiki/ty Copyright 2009-2012 Conal Elliott; BSD3 license.

A port of the Java library by Terrence Parr.

Framework for and a few implementations of (1-dimensional) numerical root-finding algorithms. Changes in 0.1.1.2: More type signature changes to build on GHC 7.6 Changes in 0.1.1.1: Added Eq contexts where necessary to build on GHC 7.4

A simple but practical HTTP server in Haskell. mighttpd should be called mighty.

Exports various functions on n-ary tuples. This library uses generics-sop to create a generic representation of n-ary product types. To regain type inference, the exported functions work only on tuples with at most 10 components.

Stalking HTTP Proxy server written in Haskell using wai/warp and http-client packages

Two utilities for working with logs: log-server and log-fetcher.

Using the API Annotations available from GHC 7.10 RC2, this library provides a means to round trip any* code that can be compiled by GHC any currently excludes anything using CPP or lhs. The dependency footprint is deliberately kept small so that it can easily be tested against GHC HEAD Note: requires GHC 7.10 RC2 or later

The classical game, implemented with wxHaskell

Facilities to help deliver WASM from a servant-server.

This library defines an Interpreter monad. It allows to load Haskell modules, browse them, type-check and evaluate strings with Haskell expressions and even coerce them into values. The library is thread-safe and type-safe (even the coercion of expressions to values). It is, essentially, a huge subset of the GHC API wrapped in a simpler API.

Use the system locale command to find out the current system locale in System.Locale format.

Please see README.md

[Index] For package maintainers and hackage trustees The command-line program yaml-union unions yaml-files recursively. When a key appears in multiple files, the values will be overridden with the order given on the command-line. If both values are hashes, the overrides will be done recursively. The program could be useful in conjunction with pandoc when passing in meta-data from external files. e.g.

A collection of tools to process mbox files

Law-abiding lenses for Aeson, using microlens.

Please see the README on Github at https://github.com/masterdezign/Learning#readme

See https://github.com/igrep/haskell-fakepull#readme.

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:

[Index] For package maintainers and hackage trustees

Depends on CBMC http://www.cprover.org/cbmc/. Generates a driver to prove the Atom and SBV backends generate equivalent code. Copilot is a stream (i.e., infinite lists) domain-specific language (DSL) in Haskell that compiles into embedded C. Copilot contains an interpreter, multiple back-end compilers, and other verification tools. A tutorial, bug reports, and todos are available at https://github.com/leepike/copilot-discussion. Examples are available at https://github.com/leepike/Copilot/tree/master/Examples.

Safe conversions between textual types

The package language-glsl is a Haskell library for the representation, the parsing, and the pretty-printing of GLSL 1.50 code.

Please see README.md

Monoidal, monadic and first-class events.

Ray Tracer capable of rendering a variety of primitives, with support for CSG (difference and intersection of solids), BIH-based acceleration structure, and ability to load NFF format files. The rendering algorithms have been abstracted to an external library, GlomeTrace. This is just a front-end to the library that renders scenes into an opengl window.

The JSON5 Data Interchange Format (JSON5) is a superset of JSON that aims to alleviate some of the limitations of JSON by expanding its syntax to include some productions from ECMAScript 5.1. This library provides a parser and pretty printer for converting between Haskell values and JSON5.

Please see the README on GitHub at https://github.com/ChrisPenner/mad-props#readme

Extends explicit-iomodes with ByteString operations

Parser for ELF object format.

Global or local sequence alignment, not exclusively for text.

A non-blocking concurrent map implementation based on lock-free concurrent hash tries (aka Ctries).

Please see the README on Github at https://github.com/minoki/purescript-tsd-gen#readme

Compile Fay code on cabal install, and ad-hoc recompile during development

A library providing tools and various schemes for encoding arbitrary datatypes as natural numbers. The underlying theory is that of isomorphisms with the natural numbers (known as Godel numbering). The library provides functionality for defining multiple such encodings for a given datatype, as well as a collection of stock encodings and combinators which can be used to build more complex encodings. This has various uses, among them binary serialization/deserialization and enumeration testing.

Library for generating hslogger functions using Template Haskell.

Text.XML.Generic can automatically serialize from the Data-type class to XML-strings.