Clickhouse-Haskell is a library for making connection with the server of column-oriented DBMS, Clickhouse. This library supports SELECT, INSERT and other query commands. Clickhouse-Haskell is also implemented with Haxl, an concurrent data accessing API developed by Facebook, for efficient interaction with the server. For more detail, see: https://github.com/2049foundation/clickhouse-haskell#readme

Collection of algorithms in Computational Geometry.

A parser for JVM bytecode (.class and .jar) files

Foreign-function bindings to the OpenSSL library http://www.openssl.org/. Currently provides access to the messages digests MD5, DSS, DSS1, RIPEMD160, and several variants of SHA through the EVP digest interface.

When your data has many invariants, it's often difficult to write Arbitrary instances for QuickCheck. This library attempts to solve that problem by providing a nice interface to write QuickCheck tests without using Arbitrary instances. It aims to be somewhere in the middle between HUnit and QuickCheck: Use the random test case generation of QuickCheck, but write HUnit like assertions.

elsa is a small proof checker for verifying sequences of reductions of lambda-calculus terms. The goal is to help students build up intuition about lambda-terms, alpha-equivalence, beta-reduction, and in general, the notion of computation by substitution.

A simple custom form widget for gtk which allows single LOC creation/updating of toggle button lists.

Bindings to Miniball, a C++ library (http://www.inf.ethz.ch/personal/gaertner/miniball.html) for computing the smallest enclosing ball of a set of points in Euclidean space. The Miniball library itself is not included, as I consider it a dependency. It consists of only a header file, and can be retrieved from http://www.inf.ethz.ch/personal/gaertner/miniball.html. To build this package, simply have miniball.hpp in GCC's include path. The standard C++ library and GCC with C++ support are also needed. Hackage probably fails to build the Haddock documentation since Miniball itself is missing. The documentation can be viewed at http://nonempty.org/software/haskell-miniball/. Miniball itself is copyright 1999-2013, Bernd Gärtner. The current version has only been tested with version 3.0 of Miniball. Changes in version 0.1.0.2: Improve allocation before FFI call. Good speedup for short calls (factor 3 for 100000 points in R^3).

This is a modified version of xmonad-contrib used by Bluetile.

Wraper to GHC debugger API allowing debugging throught socket. Used in haskell-idea-plugin.

A library of functions for vector calculus, calculation of electric field, electric flux, magnetic field, and other quantities in mechanics and electromagnetic theory.

A CLI tool for creating bugzilla queries for bugzilla.redhat.com.

Haskell implementation of MessagePack / msgpack.org[Haskell]

A parser-agnostic declarative API for querying XML-documents

A micro-library for racing HTTP GET requests

Alternative interface for total versions of partial Prelude functions

Type level membership

This package provides various functions and classes for dealing with things which are like Boolean values. It also defines a few useful instances. The main benefit is the ability to use the usual &&, etc. operators without having to invent new operator names for every kind of Bool-like thing. Changes: Increase efficiency of Boolean instance for Bool. Shorten source code. Remove function instance. (Control.Monad.Instances provides an equivilent Monad instance.)

This package adds some combinators that can be used with any type constructor that has an instance for both Alternative and Monad. The rationale, design and implementation are all explained in an article in The Monad Reader issue 17, which will appear on http://themonadreader.wordpress.com/ imminently.

Simplify managing Haskell projects by generating files like README.md, .travis.yml, etc.

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.

Do you remember the convenient command ren in MSDOS? When you want to change all your .mp3 files to .mp4. Simply type "ren *.mp3 *.mp4.". I really like this. But in linux/Mac world, people keep asking how.(http://bit.ly/2cIskUu) So maybe this little tool can help you a lot.

A typed template engine, subset of jinja2

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 changelog file in the source distribution to learn about any important changes between version.

A tasty ingredient to output test results in XML, using the Ant schema. This XML can be consumed by the Jenkins continuous integration framework.

Please visit the README at https://github.com/mbj/source-constraints#readme for usage information.

This package provides 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.

[Index] For package maintainers and hackage trustees Indexed type classes that track operations performed on them. The index parameter then models control flow. Implements graph-indexed type classes for: May implement in the future, or may not make sense. (Essentially: category-extras.)

[Index] For package maintainers and hackage trustees Cartesian ========= Functions and types for working with three-dimensional coordinate systems. For now, all functions assume a coordinate system where right is +X, up is +Y and forwards is +Z, unless otherwise stated. Contributors ------------ Jonatan H Sundqvist TODO ----

Traditional buffer-overflow attacks work by filling a data buffer with exploit code and then redirecting execution to that buffer. As a countermeasure, modern operating systems will forbid (by default) the execution of writable memory regions. Return-oriented programming [1] is an alternative exploitation strategy that works around this restriction. The exploit payload is built by chaining together short code sequences ("gadgets") which are already present in the exploited program, and thus are allowed to be executed. dewdrop is a Haskell library for finding useful gadgets in 32- and 64-bit x86 ELF binaries. You can describe the desired gadget properties with a Haskell function, and use the Dewdrop module to make a customized gadget-finder program. Or you can import Dewdrop.Analyze and integrate this functionality into a larger program. [1] Shacham, Hovav. The Geometry of Innocent Flesh on the Bone: Return-into-libc without Function Calls (on the x86). CCS 2007, pages 552-561.

Please see the README on Github at https://github.com/ChaosGroup/system-info#readme

Lenses, folds, traversals and prisms for taggy. This greatly simplifies your life when dealing with the ugly world of Real Life HTML. Here's an example. It lists the date, author and package name of all the recent package uploads entries from the hackage page of the same name. Note that it uses wreq to fetch the Hackage page. Report any problem on our issues page on github.

A simple formlet library with named formlets (e.g. username, email, password, etc.).

Often we need an efficient way to generate high quality pseudo-random numbers in Haskell. We have good generators themselves (for example, the mersenne-random-pure64 package), however, users are often tempted to store the generator in a lazy state monad. This causes performance problems. This package provides an optimized Rand monad for monadic generation of random numbers from a state, with close attention to performance. You may have results an order of magnitude or more better than using Control.Monad.State to store your generator.

A library which reexports all non-conflicting and most general definitions from the "base" package. This includes APIs for applicatives, arrows, monoids, foldables, traversables, exceptions, generics, ST, MVars and STM. This package will never have any dependencies other than "base".

Automatically derive javascript functions to query servant webservices. Supports deriving functions using vanilla javascript AJAX requests, Angulari, Axios or JQuery. You can find an example here which serves the generated javascript to a webpage that allows you to trigger webservice calls. CHANGELOG

This package contains the test adapter for SmallCheck tests to use it with MuCheck

[Index] For package maintainers and hackage trustees instant-deepseq allows you to generically derive Control.DeepSeq.NFData instances (from the deepseq package) for your types using instant-generics, which in particular, supports deriving generic representations for GADTs.

hs2dot can generate graphviz code by analyzing Haskell source code. Usage (to generate a pdf from a source code file Hack.hs) You can analyze multiple modules together: Changelog: 0.1.3: Updated dependencies to be less picky. 0.1.4: Included Hs2Dot.Internals in sdist

Please see the README on GitHub at https://github.com/githubuser/wordify#readme

This package implements the following: Deterministic Finite State Automata (DFSA) Non-Deterministic Finite State Automata (NFSA) Deterministic Finite State Transducers (DFST) Non-Deterministic Finite State Transducers (NFST)

For package maintainers and hackage trustees

The Hypergeometric distribution. This is the discrete probability distribution that measures the probability of k successes in l trials, without replacement, from a finite population.

Please see the README on GitHub at https://github.com/riottracker/RtMidi#readme

Haskell library. Alternative to Show data printing utility.

Lucid support for Skylighting

tiny validation library

This package provides support for encoding and decoding binary data according to base16 (see also RFC 4648) for strict (see Data.ByteString.Base16) and lazy ByteStrings (see Data.ByteString.Base16.Lazy). See the base16 package which provides superior encoding and decoding performance as well as support for lazy, short, and strict variants of Text and ByteString values. Additionally, see the base-encoding package which provides an uniform API providing conversion paths between more binary and textual types.

PowerOff Tray Icon

Release notes are here https://github.com/23prime/oeis2/releases

Please see README.md.

Memory map immutable and mutable vectors.

Rose (n-ary) trees with both upwards- (i.e. cached) and downwards-traveling (i.e. accumulating) monoidal annotations. This is used as the core data structure underlying the diagrams framework (http://projects.haskell.org/diagrams), but potentially has other applications as well. Abstractly, a DUALTree is a rose (n-ary) tree with data (of type l) at leaves, data (of type a) at internal nodes, and two types of monoidal annotations, one (of type u) travelling "up" the tree and one (of type d) traveling "down". See Data.Tree.DUAL for full documentation. Data.Tree.DUAL provides a public API which should suffice for most purposes. Data.Tree.DUAL.Internal exports more of the internal implementation---use it at your own risk.

A library for writing https://slack.com/ Slack chat bots. Tutorial: https://github.com/hlian/linklater/wiki/Tutorial Features you could take advantage of right now, should you choose: Uses Text for state-of-the-art Unicode support; Lovely documentation with no misspelllllings to be found; Supports Slack's formatting syntax Comes with a fast mode (slashSimple) and a power mode (slash) A warm, receptive maintainer with beautiful brown eyes; Fully Haddock'd methods and module; Open source (BSD3). Shamelessly cute example:

Allows users to directly access Amazon Products API, without having to work with the underlying REST and authentication layers.

This package provides an interface for converting between data and its (human-friendly) textual representation.

This package provides facilities for parsing and unparsing URIs, and creating and resolving relative URI references, closely following the URI spec, IETF RFC 3986. In network-2.6 the Network.URI module was split off from the network package into this package. If you're using the Network.URI module you can be backward compatible and automatically get it from the right package by using the network-uri-flag pseudo-package in your .cabal file's build-depends (along with dependencies for both network-uri and network): Or you can do the same manually by adding this boilerplate to your .cabal file: That is, get the module from either network < 2.6 or from network-uri >= 2.6.

The provided types that might be useful in symbolic manipulation of propositional logic expressions.

A library for reading CDB (Constant Database) files. CDB files are immutable key-value stores, designed for extremely fast and memory-efficient construction and lookup. They can be as large as 4GB, and at no point in their construction or use must all data be loaded into memory. CDB files can contain multiple values for a given key. For more information on the CDB file format, please see: http://cr.yp.to/cdb.html

HQuantLib is intended to be a functional style port of QuantLib (http:quantlib.org)

[Index] For package maintainers and hackage trustees

text-show-instances is a supplemental library to text-show that provides additional Show instances for data types in common Haskell libraries and GHC dependencies that are not encompassed by text-show. Currently, text-show-instances covers these libraries: One can use these instances by importing TextShow.Instances. Alternatively, there are monomorphic versions of the showb function available in the other submodules of TextShow.

Numbers that represent ranges of all sorts.

This package provides an interface to Windows and Unix file locking functionalities.

numhask-space provides support for spaces where space is defined as a set of numbers with a lower and upper bound.

Library for working with commoditized amounts and price histories

A simple interactive lambda cube type checker and evaluator.

The Haskell XML Toolbox bases on the ideas of HaXml and HXML. This package is a compatibitlity package for old software working with the filter approach like in HaXml. For new projects it's recomended to use the arrow based library (hxt).

A simple abstration over the Cassandra Thrift bindings designed to make working with Cassandra's thrift API easier, without removing the ability to use it directly. A Cassandra monad is presented for mannaging the connection to the Cassandra server, and the calculation of cassandra timestams (in microseconds).

HERMIT is a Haskell-specific toolkit designed to mechanize equational reasoning and program transformation during compilation in GHC. Examples can be found in the examples sub-directory. Example of running a script. Example of interactive use. To resume compilation, use resume.

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

Arithmetic over signs (i.e. -, 0, +) and sets of signs

Please see README.md

An automatic way of adding instances to monad classes.

This package exports bindings to Facebook's APIs (see http://developers.facebook.com/). Does not have any external dependencies and tries to use as little resources (such as memory, sockets and CPU) as possible by using packages such as aeson, attoparsec, bytestring, conduit, http-conduit, text and others. While we would like to have a complete binding to Facebook's API, this package is being developed on demand. If you need something that has not been implemented yet, please send a pull request or file an issue on GitHub (https://github.com/psibi/fb/issues).

The concrete syntax for Copilot. 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, examples, and other information are available at https://copilot-language.github.io.

This is a package for working with arrayForth. This is a variant of Forth used by GreenArrays chips. This package contains an arrayForth simulator, two different representations of arrayForth programs and some utilities like parsing. It also supports synthesizing arrayForth programs using MCMC. The basic idea is to find arrayForth programs by taking a simple prior distribution of programs and using a randomized hill-climbing algorithm to find a program fulfilling certain tests.

Please see README.md

Time to manipulate time

A binding to libnm-glib.

LambdaCube is a 3D rendering engine written entirely in Haskell. It targets newer graphics hardware. The engine uses Ogre3D's mesh and material file format. The main goal of this project is to provide a modern and feature rich graphical backend for various Haskell projects (e.g. FRP libraries). While the interface looks huge on the surface, the only part of interest to application developers is the Graphics.LambdaCube module, and possibly Graphics.LambdaCube.Loader.StbImage. The rest is only exposed to make low-level interfacing possible.

A transport-level remote JavaScript RESTful push mechanism.

Provides a combinator library for defining a command line parser.

This package provides client support for the POP3, SMTP, and IMAP protocols. Full examples can be found in the repository. Additional documentation on the major updates can be found in the Updating.md file

A tool to quickly switch between directories Please see README.md for more details

Provides a simple type class for converting values of different string types into values of other string types.

TrailDB is a library, implemented in C, which allows you to query series of events at blazing speed. TrailDB is also optimized for speed of development: Use its simple API with your favorite language, in your favorite environment.

[Index] [Quick Jump] For package maintainers and hackage trustees

DCPU-16 Emulator & Assembler

Extrapolate is a tool able to provide generalized counter-examples of test properties where irrelevant sub-expressions are replaces with variables. For the incorrect property \xs -> nub xs == (xs::[Int]): [0,0] is a counter-example; x:x:_ is a generalized counter-example.

Generic programming library providing structural polymorphism and other features.

Statistical data visualization