Disciple Core is an explicitly typed language based on System-F2, intended as an intermediate representation for a compiler. In addition to the polymorphism of System-F2 it supports region, effect and closure typing. Evaluation order is left-to-right call-by-value by default. There is a capability system to track whether objects are mutable or constant, and to ensure that computations that perform visible side effects are not reordered inappropriately. See the ddc-tools package for a user-facing interpreter and compiler.

This package implements a client library for interacting with the Nakadi event broker system developed by Zalando.

Simple audio library for SDL. Supports PCM, Ogg and Wav playback and multichannel mixing.

Orphan Serial instances and utilities to create and manipulate Series for common types.

Quiver combinators for cellular data processing

A logging framework written with flexibility and performance in mind. This Version is yet a preview The logging system consists of four main parts: The logging front-end are those types and functions that are used to produce log messages in the code. This includes the LogLevel type, the LogPolicy type, the LogLabel and LogScope types, the LogFunction type, and the MonadLog type class. The abstract LoggerCtx is the context through which the LogFunction delivers log messages to the logger back-end. The formatter is a function for serializing log messages. The logger back-end is a callback that is invoked by Logger on each log messages. The logger back-end applies the formatting function and delivers the log messages to some sink. The framework allows to combine this components in a modular way. The front-end types, the Logger, and the back-end callback are represented by types or type classes. The formatter exists only as a concept in the implementation of back-ends. These types and concepts together form the abstract logger interface that is defined in the module System.Logger.Types. The package also provides a concrete Logger that implements these components in the module System.Logger.Logger and System.Logger.Backend.Handle

Mustache templates for Haskell.

Generic generation of HXT XmlPickler instances using GHC Generics.

Companion executable to puzzle-draw. Separate to keep the dependency on diagrams-cairo out of the library.

Utility functions for use with WAI that haven't found another home yet.

Provides a Haskell interface to the Go package importer, enabling querying Go packages for definitions and their types.

Brainh*ck interpreter written in haskell and taking advantage of several advanced libraries

Build AWS Lambda's with Haskell

Hieraclus is a library that supports clustering of arbitrary elements in haskell. The difference to the already existing cluster library hierarchical-clustering is the ability to work with abort criterias which allow an intelligent clustering. With the help of abort criterias the user can specify conditions that must be fulfilled in order to stop the clustering process.

[Index] For package maintainers and hackage trustees Bamboo is a port of Panda, but runs on top of Hack. It's an experimental project but quite portable. The Bamboo codebase is a mess!!! But Haskell is so reliable that left me no incentive to do a rewrite. So just use it, build middleware for it, or better yet write a new blog engine so everyone can benefit :) By it's middleware nature, bamboo could be used with other hack middleware to achieve extensibility; Bamboo plugins are also middleware, so they can be used not only in bamboo, but any other CMS like web application. bamboo can be customized in 3 ways: Theme is separated from the bamboo's controller, connected through an interface and a state. Though theme could be pure, it has the type of This makes theme creation a relatively complex task, since a theme author basically has to do everything: from html construction to model manipulation. But since state is passed purely and return type is in IO, it also provides the ultimate safety and flexibility to theme construction, something unmatched by any main stream web frameworks. Integrating twitter? no problem, do them in IO. Plugin is a proper hack middleware, so it works on an upper layer of the blog engine. It has all the power of a middleware, i.e. intercept request and response, and also the limitation, e.g. no idea of the underlying data structure of the app. Plugin can be used to to do customization on the env object, or transformation to the response body. An example plugin is syntax highlighting, which could be done in the core, but would be more lightweight ( in terms of architecture design ) to be separated into a plugin. You are hence not limited to use just bamboo-plugins to customize your blog, any hack-middleware which suite your need will do. In db/config/theme, you can customize precisely which js / css files to use, this allows client side customization and also lightweight configuration without compilation. 郑板桥（1693~1765） 修竹幽兰图 <a href="http://github.com/nfjinjing/bamboo/raw/master/bamboo.jpg"> <img src="http://github.com/nfjinjing/bamboo/raw/master/bamboo-thumb.jpg" /> </a>

PureScript is an awesome statically typed language that compiles to JS and runs in your browser, and this module makes it easier to use PureScript in Yesod.

Please see README.md

Read and write uncompressed BMP image files. 100% robust Haskell implementation.

sched_yield is useful, when starting many processes, and waiting for them to complete. It yields CPU time (forces context switch.)

Memory efficient JSON parser. Please see README.md

KMP implemented on haskell's built-in cons-cell-based lists.

Check that your parsers cover all the cases.

A native Haskell implementation of the Cap'N Proto cerialization format and RPC protocol. The library implements serialization and level 1 RPC. The Capnp.Tutorial module is the best place to start reading; the reference documentation can seem bewildering without that context.

digitalocean haskell api

A 2048 clone in Haskell. This implements the game logic as well as a console interface for playing it.

Elide the middle of your function! Make someone else do it later.

URN parsing and rendering according to RFC 2141. For more info see http://tools.ietf.org/html/rfc2141. If you need to represent both URLs and URIs then use Network.URI from the network package or Data.URI from the uri package.

This package complements the Aivika and Aivika Experiment packages and it allows rendering the charts using the Chart-diagrams library, i.e. without using Cairo, which can be suitable for MS Windows.

Haskell tool to generate expressions from types

Functional concurrency with unamb using a custom scheduler, which makes it practical to use in dense situations (eg. infinite folds on unamb).

hBDD provides a high-level API to some Boolean Decision Diagram libraries; this is the CUDD part of it.

Please see README.md

A type for representing polynomials, several functions for manipulating and evaluating them, and several interesting polynomial sequences.

A formatter for Haskell source code.

[Index] For package maintainers and hackage trustees

Bindings to sendmsg and recvmsg POSIX functions.

Fast, pure and practical MD5 implementation

This library provides machinery for types to specify how they can be serialized and deserialized into/from Thrift payloads. It makes no assumptions on how these payloads are sent or received and performs no code generation. Types may specify how to be serialized and deserialized by defining instances of the Pinchable typeclass by hand, or with automatically derived instances by using generics. Check the documentation in the Pinch module for more information. What is Thrift? Apache Thrift provides an interface description language, a set of communication protocols, and a code generator and libraries for various programming languages to interact with the generated code. Pinch aims to provide an alternative implementation of Thrift for Haskell.

Example programs examples/get.hs This is simple client. This send GET request and show page source. Run as following. extensions PackageImports examples/server.hs This is simple server. This recieve client's request. And send command line arguments as response. Run as following. If you want more examples. Please see examples directory.

Simple lexer based on applicative regular expressions

For package maintainers and hackage trustees

Alea is a utility that helps you generate diceware passphrases. You can choose to roll the dice on your own or let the program generates the words for you.

This package has been absorbed into semigroupoids 4.0

Serve files from the current path

Non Empty Text for Haskell

This packages provides a simple interface for mail over SMTP. PLease see the README for more information.

For package maintainers and hackage trustees

Pack some functions for Hipmunk using Linear package

Print file contents with syntax highlighting

For package maintainers and hackage trustees

The module defines a type constructor Traced, which allows evaluation of values to be traced. Instances for all numeric types make tracing numeric evaluation especially easy.

Store a stable pointer in a foreign context to be retrieved later. Persists through GHCi reloads.

a haskell binding to the nonlinear programming solver Ipopt. Bindings to NLopt are also included. A embedded language, similar to the one provided by glpk-hs, is defined in Ipopt.NLP. The goal is to define problems at a level similar to other algebraic modeling languages, but retain some of the safety and flexibility available in haskell. There is some overhead http://code.haskell.org/~aavogt/ipopt-hs/examples/bench.html but perhaps it is negligible for your uses. Current limitations include: copying in every iteration happens between between Data.Vector.Storable and Data.Vector might be avoidable somehow. Currently it is done because AD needs a Traversable structure, but Storable vectors are not traversable. Note that there is a Numeric.AD.Mode.Forward.Double but as yet none for Vectors of Double sparseness of derivatives isn't used no binding to sensitivity parts as-implemented in ipopt

Random number generation as an effect using fused-effects.

Pure IO monad.

This implementation is heavily inspired by the one described in "Rate Limiting at Webscale: Lazy Leaky Buckets"

Compatibility layer for aeson

Named and unnamed implicit parameters with defaults using type classes and constraint hacks. For examples, see Data.Implicit.

Naperian Functors for APL-like programming

Apecs stores that live in the STM monad, and other tools.

Please see the README on GitHub at https://github.com/kawu/data-named#readme

In the presence of GADTs, sometimes a proof is needed that two types are equal. This package contains an equality type for this purpose, plus its properties (reflexive, symmetric, transitive) and some useful operations (substitution, congruence, coercion/cast). It also contains a type class for producing equality proofs, providing some form of decidable equality on types.

Simple bindings to commonly used AWS services

yesod-form for bootstrap version 4

Please see README.md

S-Cargot is a library for working with s-expressions in a modular and extensible way, opting for genericity and flexibility instead of speed. Instead of understanding one particular form of s-expression, the S-Cargot library exposes tools for parsing or emitting different kinds of s-expressions, including features not normally included in an s-expression library like reader macros or tight control over indentation in pretty-printing.

Print debugging with stack trace for Haskell (formatted for ease of use). See screenshot: http:i.imgur.com/KCXYHNk.png

This package is a Haskell binding to the "Mercury API" C API for ThingMagic RFID readers. It is especially geared toward the SparkFun Simultaneous RFID Reader, which uses ThingMagic's M6e Nano module, but it should work with other ThingMagic readers. (Though currently, only support for serial readers is compiled in.) Most of the function and type names are the same as their counterparts in the C API, with the TMR_ prefix dropped. For more in-depth, language-independent documentation of Mercury API, see Mercury API Programmers Guide.

HsHyperEstraier is a HyperEstraier binding for Haskell. HyperEstraier is an embeddable full text search engine which is supposed to be independent to any particular natural languages.

Please see README.md

HSlackBuilder automatically generates slackBuild scripts from a cabal package

Zenacy HTML is an HTML parsing and processing library that implements the WHATWG HTML parsing standard. The standard is described as a state machine that this library implements exactly as spelled out including all the error handling, recovery, and conformance checks that makes it robust in handling any HTML pulled from the web. In addition to parsing, the library provides many processing features to help extract information from web pages or rewrite them and render the modified results.

This is a game like Memory but with tones instead of images. There is a grid of buttons and each button plays a tone when pressed. Every tone is connected to two buttons. The players must find the pairs of buttons with equal tones. The two players alternatingly test pairs of buttons. If they select a pair of buttons with equal tones, there score is increased by one. In order to play the tones you must connect it to a hardware or software synthesizer like Timidity or FluidSynth. Then start the midimory game and connect the game to the synthesizer.

Examples for handling Protein Data Bank file format.

[Index] For package maintainers and hackage trustees

A dead simple networked key/value store

A nice way to build projects that is aware of both elm-compile and elm-package, so it can make the build process very smooth.

Manatee is Haskell integrated environment written in Haskell. The goal of the Manatee project is to provide a fast, safe and flexible integrated environment for haskell hacking. You can consider it is new environment mix Gnome and Emacs. Like Gnome to provide friendly graphics interface and work efficient like Emacs. Manatee use multi-processes framework, any sub-module running in separate process to protected core won't crash. So it minimize your losses when some unexpected exception throw in extension. Video (Select 720p HD) at : http://www.youtube.com/watch?v=weS6zys3U8k or http://www.youtube.com/watch?v=A3DgKDVkyeM You can find screenshots at : http://goo.gl/MkVw Below is build step for Manatee: 1) Install gold-linker to accelerate installation: I suggest use gold-linker instead ld to accelerate installation. In Debian system, you just need do below command: This step is optional, it's okay use ld link program, just much slow. :) 2) Install GHC compiler http://www.haskell.org/ghc/download_ghc_7_0_3: Download ghc package for your system, then do below command : 3) Install C library: In Debian use below command: 4) Install cabal: Download http://hackage.haskell.org/packages/archive/cabal-install/0.10.2/cabal-install-0.10.2.tar.gz Decompress cabal-install-0.10.2.tar.gz and do below command: 5) Install dependent Haskell library: First make sure HOME/.cabal/bin/ in your PATH Generic way is add PATH=$PATH:~\/.cabal\/bin in your ~/.bashrc Then do below command (NOTE: don't use root permission with cabal, otherwise Manatee can't work): 6) Install Manatee: Install all Manatee packages (same, don't use root permission): If you don't want install all Manatee packages, you can install basic package like below: Then choose extension package list in below to install: Note if you don't install any extension package, nothing will show in manatee, so you at least to choose one extension to install. That's all, then type command manatee to play it! :) I have test, Manatee can works well in Gnome, KDE, XMonad and XFCE Video (Select 720p HD) at : http://www.youtube.com/watch?v=weS6zys3U8k http://www.youtube.com/watch?v=A3DgKDVkyeM http://v.youku.com/v_show/id_XMjI2MDMzODI4.html Screenshots at : http://goo.gl/MkVw Manual at : http://haskell.org/haskellwiki/Manatee IRC channel: irc.freenode.net 6667 ##manatee Mailing-List: manatee-user@googlegroups.com manatee-develop@googlegroups.com Manatee is distributed framework, it allowed you install extension don't need depend each other, but it's easy to break if some package is older than core packages (manatee-core, manatee). So please make sure *all* packages has update to newest version before you report bug to manatee-user@googlegroups.com . Thanks! :)

Given a GHC profile output, this tool generates alternative views on the data, which are typically more concise and may reveal new insights.

The Iteratee monad provides strict, safe, and functional I/O. In addition to pure Iteratee processors, file IO and combinator functions are provided. See Data.Iteratee for full documentation.

This is a simple OpenGL program that allows you to see some of Hipmunk's functions in action. New in version 5.2.1: Accept OpenGL 2.9. New in version 5.2.0.9: Accept OpenGL 2.8. Thanks, Leonardo Lessa! New in version 5.2.0.6: Accept OpenGL 2.5 as well. Thanks again, Sergei Trofimovich! New in version 5.2.0.5: Accept GLFW 0.5 as well. New in version 5.2.0.4: Now buildable on GHC 7.0. Thanks, Sergei Trofimovich. New in version 5.2.0.3: Correctly handle window resizes. New in version 5.2.0.2: Add repo URL to cabal file. New in version 5.2.0.1: Show collision points. Licensed under the MIT license (like Hipmunk itself).

A functional OpenGL [ES] wrapper library. Made complicated OpenGL APIs easy yet keep flexible enough. Resulting binary size is relatively small so that apps launches faster. Works on both desktop and mobile.

[Index] For package maintainers and hackage trustees

Roman Numerals for YOU

Please see the README on GitHub at https://github.com/opyapeus/jmonkey#readme

Please see the README on GitHub at https://github.com/athanclark/abides#readme

A tiny library for producing structured logs

Lighweight pure data validation based on Applicative and Selective functors. The library builds validation interface around the following data type:

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. A simple program can be defined as This is virtually all the code that is necessary to implement the executable lesscase. Have a look in the source of the executable twocase which only formats sequences of two or more uppercase letters. It is a good reference for understanding the API changes that took place between the revisions 0.5 and 0.6.

This is an implementation of the Nock 5K spec with an accompanying interpreter. Nock is a tiny stateless virtual machine that can be thought of as a functional assembly language. Nock is the lowest layer in the Urbit stack. On top of it rests the Hoon language, in which the Arvo OS is written. More on Urbit: http://www.urbit.org/ More on Nock: http://www.urbit.org/2013/08/22/Chapter-2-nock.html

Find sequences within lists.

Alternative generalization of NonEmpty lists.

This package provides LDAP interface code for Haskell programs, binding to the C LDAP API.

For package maintainers and hackage trustees

[DONE] A small pomodoro timer based on CLI usage and FreeDesktop.org notifications.

This package provides data types and functions for working with 64-bit timeouts of nanosecond precision.

The rise of web platforms and their associated apps represents a new way of developing and deploying software. Sites such as Facebook and Yammer are no longer written by a single entity, but rather are freely extended by third-party developers offering competing features to users. Allowing an app to access more user data allows developers to build more compelling products. It also opens the door to accidental or malicious breaches of user privacy. In the case of a website like Facebook, exposing access to a user's private messages would allow an external developer to build a search feature. Exciting! But, another developer can take advantage of this feature to build an app that mines private messages for credit card numbers, ad keywords, or other sensitive data. Frameworks such as Ruby on Rails, Django, Yesod, etc. are geared towards building monolithic web sites. And, they are great for this! However, they are not designed for websites that integrate third-party code, and thus lack a good mechanism for building such multi-app platforms without sacrificing a user's security or an app's functionality. Hails is explicitly designed for building web platforms, where it is expected that a site will comprise many mutually-distrustful components written by a variety of entities. We built Hails around two core design principles. Separation of policy: Data access policies should be concisely specified alongside data structures and schemas, rather than strewn throughout the codebase in a series of conditionals. Code that implements this is called a policy module in Hails (see Hails.PolicyModule). Mandatory access control (MAC): Data access policies should be mandatory even once code has obtained access to data. MAC lets platform components modules productively interact by sharing data, despite mutual distrust. Haskell lets us implement MAC at a fine grained level using the information flow control library LIO. A Hails platform hosts two types of code: apps and /policy modules/. Apps encompass what would traditionally be considered controller and view logic. Policy modules are libraries that implement both the model and the data security policy. They are invoked directly by apps or other policy modules, but run with different privileges from the invoking code. Both apps and policy modules can be implemented by untrusted third parties, with the user only needing to trust the policy module governing the data in question. Separating of policy code from app code allows users to inspect and more easily unserstand the overall security provided by the system, while MAC guarantees that these policies are enforced in an end-to-end fashion.

an audio library with portaudio.