Adds MonadThrow runners for PandocPure and PandocIO.

Abstract data types and type classes for Haskell to MessagePack value converters

A circular buffer built on shared memory

A mid-level client library for the PostgreSQL database, intended to be fast and easy to use.

Formats marked code fragments, and allows pandoc to safely process rest of your literate program: Usage: > stack install pandoc-filter-indent > pandoc --filter pandoc-filter-indent -f input.md -o output.pdf > pandoc --filter pandoc-filter-indent -f input.md -o output.html Using lhs2TeX is somewhat inconvenient on large Markdown documents processed with pandoc, since it assumes that it can freely redefine everything. It is also pretty heavy on learning. So instead we have a simple Pandoc filter that is only applied to CodeFragments and creates tabular code structures from indentation. It uses GHC lexer to assure that latest features are always parsed correctly. Please see the README on GitHub at https://github.com/mjgajda/pandoc-filter-indent#readme

A gallery of Csound instruments.

This package is about incremental computing.

CHANGES -- 0.0.0.2 added "anti" expressions for the quasiquoter to capture variables from the environment. Also added a pattern quasiquoter.

SASS support for Shakespeare and Yesod

[Index] For package maintainers and hackage trustees Sends a message to the given destination. If there is no consumer then the message stays in the queue until somebody consumes it. Sends a message to the given destination. If nobody consumes the message in timeoutInMs milliseconds then the message is discarded. This is useful for showing notifications that must happen in a certain timeframe but guaranteed delivery is not a strict requirement. Sends a message to the given destination. Has a default timeout of 3 seconds and discards the message from the queue if a response hasn't been returned in that time. Listens for messages on a given destination or destinations without consuming them. Examples: receives messages that are delivered to "i.want.to.break.free" receives messages that are delivered to somebody.to.love but doesn't receive messages delivered to someboy.not.to.love

Alternative pretty-printing functions for Data.Tree.

Plus, OpT, Yoneda, CoYoneda, Free, Cofree, Density, Codensity, CoT, CodensityAsk, Initialize, Finalize, Decompose, Recompose

Support library for Hubris, the Ruby to Haskell bridge more info at http://github.com/mwotton/Hubris-Haskell Anyway, this version strips the boilerplate that used to be necessary, and is intended to be used in conjunction with http://github.com/mwotton/Hubris.

Helper for the Major System

For package maintainers and hackage trustees Create ctags compatible tags files for Haskell programs Similar programs are hasktags, gasbag, hothasktags, and GHC's builtin ctags generation. lushtags differs from these by being designed to have smooth integration with the Vim Tagbar plugin. Tagbar is nice because it deals with creating tags automatically. There is no need to manually run commands or keep track of tag files. Just open any Haskell file in Vim and the Tagbar window will instantly show an interactive browsable list of all the functions and declarations in the file. This window also updates automatically as you edit the file. The tags created by lushtags are marked with several extensions, so that when used with Tagbar you get these features: Build and install the lushtags executable $ cabal configure $ cabal build $ cabal install Install the Tagbar plugin. Tagbar can be found at http://www.vim.org/scripts/script.php?script_id=3465 http://majutsushi.github.com/tagbar/ Install the included Haskell Tagbar configuration: $ cp util/tagbar-haskell.vim ~/.vim/plugin/ Try it out: $ vim Hello.hs Now open the Tagbar with the command :TagbarOpen. An interactive sidebar will appear with all of the tags in your Haskell source file.

Seekable sources and efficient incremental sinks

This module provides instances for the monads-tf classes for AbortT.

Haskell bindings to the HIDAPI library (http://www.signal11.us/oss/hidapi/).

Please see README.md

The package is made for people who want to get the sentences in Hindi, Marathi, Kannada, Gujarati, Bengali, Telugu, Malayalam, Punjabi, Oriya font so that they don't need to remember keys on keyboards when they type these scripts. Or they don't need to waste time on virtual keyboards where everything works with a mouse.

Finds the project root, compiles your code and runs the first or set default executable. It's a shorthand for stack build && stack run executable, much like cabal run.

Bustle records and draws sequence diagrams of D-Bus activity, showing signal emissions, method calls and their corresponding returns, with timestamps for each individual event and the duration of each method call. This can help you check for unwanted D-Bus traffic, and pinpoint why your D-Bus-based application isn't performing as well as you like. It also provides statistics like signal frequencies and average method call times.

Demo of Liquid Haskell integration for Cabal and stack (see spinda/liquidhaskell-cabal)

Please see README.md

A simple library for parsing and generating URIs

ArguEdit is an argument transciption and editing software. It allows for rather objective argumentation by visualizing the elements of an argumentation. Argumentations may begin with definitions or a thesis. Then to support the thesis premises can be added with indentation, so that the relation of belonging is visible and spreading in a tree like manner. Thereafter conclusions can be drawns from what was given above. By making rather immaterial arguments perceivable the arguments gain persuasiveness. Circulations, undefined expressions or other flaws of argumentation can be pointed at. The element buttons change color on clicking so each element can be marked. For instance undiscussed elements could be colored gray, dismissed ones red, valid ones blue and so on. This way discussing in philosophical arguments as well as in any other subject becomes computer assisted and gains power over emotionally heated pitfalls.

Please see the README on GitHub at https://github.com/biocad/cobot-io#readme

See our README on GitHub at https://github.com/yamadapc/hscaffold

Language-Cil is a Haskell library for manipulating CIL abstract syntax and generating .il files. Common Intermediate Language (CIL), formerly known as Microsoft Intermediate Language (MSIL), is the lowest level language that runs on Microsoft .NET and Mono. This library is still under development, it only supports a small subset of the full CIL. See https://github.com/tomlokhorst/language-cil#readme for an example of how to quickly get started.

Extensions to Data.Map

Free monads are useful for many tree-like structures and domain specific languages. If f is a Functor then the free Monad on f is the type of trees whose nodes are labeled with the constructors of f. The word "free" is used in the sense of "unrestricted" rather than "zero-cost": Free f makes no constraining assumptions beyond those given by f and the definition of Monad. As used here it is a standard term from the mathematical theory of adjoint functors. Cofree comonads are dual to free monads. They provide convenient ways to talk about branching streams and rose-trees, and can be used to annotate syntax trees. The cofree comonad can be seen as a stream parameterized by a Functor that controls its branching factor. More information on free monads, including examples, can be found in the following blog posts: http://comonad.com/reader/2008/monads-for-free/ http://comonad.com/reader/2011/free-monads-for-less/

Read GPX files into simple Point types.

Helpers for performing text matches. For more information, please see the Github homepage at http://www.github.com/massysett/matchers

Backtracking mutable references in the ST and IO monads

Parse and write KiCad data (currently .kicad_mod files only).

Utilities for working with Aeson.

Manual migrations for the persistent library.

Please see the README on GitHub at https://github.com/ejconlon/climb#readme

A commandline Pagure client for querying projects and users.

This package provides a function fuseThis that can be wrapped around a flist. If that list is fused away, all is well. If not, a runtime error will occur.

Haskell interface to Zenity dialogs

A simple tile-based digital clock screen saver

text-utf7 provides encoding/decoding functions for UTF-7 encoded strings.

This library provides anonymous extensible records using GHC 8.0 features, with the following goals/features: The syntax should be very close to that of Haskell's record system. The library should be simple to use and requires no extra boilerplate to setup. There should be minimal runtime overhead and memory footprint. The library does not require TemplateHaskell to use. It should produce good error messages. Minimal dependencies. Currently, it only depends on packages that comes with GHC. See Data.Rawr for a tutorial of this library.

Unicode-aware string interpolation that handles all textual types. See the README at https://gitlab.com/williamyaoh/string-interpolate/blob/master/README.md for more info.

The library and the executable supports two versions of the Modula-2 programming language: as described by the orginal language report and as standardized by the ISO.

An mtl-style typeclass and transformer for persistent.

Push ekg stats to elasticsearch metricbeats index

Green Card is a foreign function interface preprocessor for Haskell, simplifying the task of interfacing Haskell programs to external libraries (which are normally exposed via C interfaces). This package provides the Foreign.GreenCard library; the greencard binary is packaged separately.

Serialisation to and deserialisation from S-expressions derived from a single grammar definition.

Command line interface to the MMark markdown processor.

[Index] For package maintainers and hackage trustees Slimmed down json schema language and validator quick-schema defines a format for describe a restricted set of JSON document structures. It is represented in JSON and has the added benefit that a JSON document can be it's own be it's own schema. quick-schema infers the structure of a JSON document by looking at the types of an example document. Consider the document When interpreted with quick-schema, this document describes a schema that expects a top level object with two keys, one named age that should have a number value and one named name that should have a text value. The actual values of the keys are used only to determine the type and to give an example of intended use, but do not have a specific meaning here. Multiple values in lists in quick-schema give the possibility for having different subvalues. Every item in the value list must match one of the of the schemas in the schema list. Optional values are specific by adding a ? to the end of a key, and exact values are specified by adding a =. For example, we could encode a tagged union type:

An IsXML class and GHC.Generics implementation for pickleable data types using hexpat.

The hs-ffeed API binding lets you access friendfeed.com's resources and methods from Haskell. Implements the full API, as specified at http://code.google.com/p/friendfeed-api/wiki/ApiDocumentation

The purpose of this package is to provide discrete region quadtrees that can be used as effective functional alternatives to 2D arrays, with lens support.

embeddock is a Haskell source-code preprocessor. It allows you to embed computer-generated values in the documentation.

A HTTP server for testing HTTP clients

WAI Request Spec is a declarative validation layer for HTTP requests. It aims to make error-handling for malformed requests as easy as taking the happy path. A brief summary of the core features: Can specify headers and query params as input sources Support for parsing ints, floats, text, bytes (with encodings), and bools A parser combinator interface for chaining together request requirements Support for Alternatives Support for optional parameters Convenient and informative default error messages that let service consumers know what went wrong It is built on WAI, so it is compatible with several Haskell web frameworks. All you need is the ability to access the Request object, and WAI Request Spec takes care of the rest!

Low-level bindings to sophia, an open source, modern, fast key/value store.

The opn command lets you open files and URLs with associated programs. It's intended to "just work" and to be trivial to configure. See the README at https://github.com/akc/opn for further info.

Sparklines implementation of smooth and bar graphs

Operations on records parametrized with various kinds of functors.

Orphan instances for binary

Type-safe, type-level and stateless Haskell graphics framework

this library has mwc-randomhttp://hackage.haskell.org/package/mwc-random like api.

See the online tutorial.

This package implements MessagePack on top of the Packer package.

[Index] For package maintainers and hackage trustees BOOP is Basic Object-Oriented Programming. Given just a few relatively simple primitives, BOOP enables fully fledged object-oriented programming in Haskell. For details, refer to https://programming.tobiasdammers.nl/blog/2017-10-17-object-oriented-haskell.

A blazingly fast HTML combinator library for the Haskell programming language. The Text.Blaze module is a good starting point, as well as this tutorial: http://jaspervdj.be/blaze/tutorial.html.

[Index] For package maintainers and hackage trustees

gopher-proxy allows to proxy gopher over HTTP, which is mainly useful for HTTP-ifying a specific gopher space. A simple invocation looks like this: In this particular example gopher-proxy does the following things: Takes HTTP requests on 127.0.0.1:8080 (to be used by a proxying web server, like nginx), converts those to gopher requests to example.org and returns the gopher responses as HTTP responses Links menu items pointing to external servers to gopher:// URLs (this ensures that only one gopher server is proxied) and recognizes URL links which are converted to normal HTML links Tries to guess the correct mime-type for every gopher-served file (as it is not included in the response) and wraps text files in a HTML container. And generally works hard to offer the best HTTP equivalent of a given gopher space :) To learn about the other parameters for tweaking the behavior of gopher-proxy see the readme.

Provides an unsafe API for inserting heterogeneous data in a collection keyed by StableNames and for later retrieving it.

This library includes definitions for common headers such as Ethernet, IPv4, IPv6, UDP, TCP, etc. This code is untested for any serious work - use at your own risk.

A tool for converting GHC heap-profiles to HTML.

Transformers for Functor, Applicative and Monad types that add tracing facilities for computation steps and applicative nesting. Simplifies print-based debugging.

Minimal dependency PostgreSQL notifications library. Please see README.md

A lightweight, structured-concurrency library. This package comes in two variants: Ki exposes the most stripped-down variant; start here. Ki.Implicit extends Ki with an implicit context that's used to propagate soft cancellation signals. Using this variant comes at a cost: You must manually add constraints to propagate the implicit context to where it's needed. To remain warning-free, you must delete the implicit context constraints where they are no longer needed. If you don't need soft-cancellation, there is no benefit to using this variant, and you should stick with Ki. Because you'll only ever need one variant at a time, I recommend using a mixin stanza to rename one module to Ki while hiding the others. This also simplifies the process of upgrading from Ki.Implicit to Ki if necessary.

Please see the README on GitHub at https://github.com/cdornan/no-value#readme

This package provides IO operations from async package lifted to any instance of MonadBase or MonadBaseControl.

A minimalistic, Mustache-like syntax, truly logic-less, pure Text template DSL library

A Haskell-only implementation of the zlib / DEFLATE protocol. Currently only implements the decompression algorithm.

An API for the Interactive Brokers Trader Workstation written in pure Haskell

A library to carry out homeomorphic embedding tests.

The text converter for aws-sdk.

Simple library for interacting with the IEX Trading API

TinyMesh are modules build on CC11xx TI MCU transceivers that allow for automatic meshing, and remote sensor reading. Whole sensor network may be orchestrated by a single *gateway* machine that is best connected to internet in order to submit the data to the cloud. This library is aimed to allow programming such a gateway machine in Haskell, so that it may be Raspberry Pi, or a similar networked ARM device. Current functionality of the module is limited to querying all the nodes within the mesh.

snaplet-mandrill is a snaplet for the Snap web framework providing convenience functions and state management for the Haskell Mandrill package. Please refer to the README for an example - Cabal descriptions don't make it easy to do so. [Index] For package maintainers and hackage trustees

Efficient parsing and serialisation of S-Expressions.

Tidy data in Haskell, via generics.