Clean up module imports, split and merge modules.

A JoinList - a list type with with cheap catenation. Generally speaking, joinlists have cheap construction (cons, snoc and join aka. append) and expensive manipulation. For most use-cases Data.Sequence is a more appropriate data structure. Changelog 0.3.0 - Added views as per Data.Sequence and takes and drops. Changed show instance to mimic Data.Sequence. 0.2.0 - more operations and some bugfixes (toList...), wrap renamed to singleton.

A module for bookkeeping by double entry. This module provides a way to do bookkeeping programmatically.

GeoJSON data types including JSON/BSON conversion.

Hyakko is a Haskell port of Docco: the original quick-and-dirty, hundred-line-long, literate-programming-style documentation generator.

EventStore TCP Client https://eventstore.com

For package maintainers and hackage trustees Observable orphan instances for haskell-src-exts

A cross-platform library that tries to find a (reasonable) CA certificate bundle that can be used with HsOpenSSL to verify the certificates of remote peers. This package is for HsOpenSSL what x509-system is for the tls package. Additionally, it borrows some ideas from x509-system.

This package provides utility methods for writing Get and Put methods (in terms of Data.Binary) for parsing and merging ISO 8583-style bitmaps, and also parsing and merging most commonly used field formats (LLVAR/LLLVAR, ASCII numbers and so on). Moreover, this package provides TH quasiquoter for declarative specification of ISO 8583-based message formats.

Deprecated Typical buffer–based incremental I/O is based around a single loop, which reads data from some source (such as a socket or file), transforms it, and generates one or more outputs (such as a line count, HTTP responses, or modified file). Although efficient and safe, these loops are all single–purpose; it is difficult or impossible to compose buffer–based processing loops. Haskell’s concept of “lazy I/O” allows pure code to operate on data from an external source. However, lazy I/O has several shortcomings. Most notably, resources such as memory and file handles can be retained for arbitrarily long periods of time, causing unpredictable performance and error conditions. Enumerators are an efficient, predictable, and safe alternative to lazy I/O. Discovered by Oleg Kiselyov, they allow large datasets to be processed in near–constant space by pure code. Although somewhat more complex to write, using enumerators instead of lazy I/O produces more correct programs. This library contains an enumerator implementation for Haskell, designed to be both simple and efficient. Three core types are defined, along with numerous helper functions: Iteratee: Data sinks, analogous to left folds. Iteratees consume a sequence of input values, and generate a single output value. Many iteratees are designed to perform side effects (such as printing to stdout), so they can also be used as monad transformers. Enumerator: Data sources, which generate input sequences. Typical enumerators read from a file handle, socket, random number generator, or other external stream. To operate, enumerators are passed an iteratee, and provide that iteratee with input until either the iteratee has completed its computation, or EOF. Enumeratee: Data transformers, which operate as both enumerators and iteratees. Enumeratees read from an outer enumerator, and provide the transformed data to an inner iteratee.

[Index] [Quick Jump] For package maintainers and hackage trustees Haskell bindings for duktape, a very compact embedded ECMAScript (JavaScript) engine. Here's a simple REPL example: Aeson's Value type is used for exchanging values between Haskell and ECMAScript. lens-aeson is a good library for working with Value, um, values. You can also call functions that are on the global object (or any object that's on the global object): And expose Haskell functions (same as with calls: set on global or a property of global): The functions must be of type IO (), IO Value, Value -> IO Value, Value -> Value -> IO Value... and so on. (Or with any ToJSON/FromJSON values instead of Value) Instead of createDuktapeCtx, you can use createGovernedHeap to enforce termination via a timeout: Note: The duktape configure script invoked by Cabal/Stack requires python 2 with the PyYAML library installed. pip install PyYAML is one way to achieve this. Use stack to build. Please feel free to submit pull requests! By participating in this project you agree to follow the Contributor Code of Conduct. The list of contributors is available on GitHub. Licensed under the MIT license (see to the LICENSE file). Haskell bindings: Copyright (c) 2015-2018 Greg V greg@unrelenting.technology Duktape: Copyright (c) 2013-2016 by Duktape authors (see duktape/AUTHORS.rst)

General permutation parser combinators that will work with any parser combinator library.

[Index] For package maintainers and hackage trustees Encoding-aware file I/O operations. Useful if you'd like to read/write a text file and stick to UTF-8 instead of using system's default locale.

Small library providing WebSocket endpoints for servant.

Ansigraph is an ultralightweight terminal-based graphing utility. It uses Unicode characters and ANSI escape codes to display and animate colored graphs of vectors/functions in real and complex variables. This functionality is provided by a Graphable type class, whose method graphWith draws a graph at the terminal. Another function animateWith takes a list of Graphable elements and displays an animation by rendering them in sequence. Both of these functions take an options record as an argument. The graph and animate functions are defined to use the default options, and the user can define similar functions based on their own settings. There are two main ways to use the package. Importing System.Console.Ansigraph provides all the functionality we typically use. This includes the FlexibleInstances extension, which makes it marginally more convenient to use graphing functions by allowing instances like 'Graphable [Double]'. If you want to use the package without activating FlexibleInstances then you can import System.Console.Ansigraph.Core, which provides everything except these instances. Then you must use one of a few newtype wrappers, namely: Graph, PosGraph, CGraph, Mat, CMat. These wrappers are also available from the standard Ansigraph module. The System.Console.Ansigraph.Examples module contains examples of all the graph types, and also shows the available ANSI colors.

The motivation for this package was to run computations on multiple cores that need to write intermediate results to disk. The functions restrict the number of simultaneously running jobs to a user given number or to the number of capabilities the Haskell program was started with, i.e. the number after the RTS option -N. There are some flavors of this functionality: Control.Concurrent.PooledIO.Independent: run independent actions without results in parallel Control.Concurrent.PooledIO.Final: run independent actions with a final result in parallel Control.Concurrent.PooledIO.InOrder: run jobs in parallel with data dependencies like make -j n Additionally there is the module Control.Concurrent.PooledIO.Sequence that helps to serialize I/O actions from multiple threads. It is certainly most useful in connection with Control.Concurrent.PooledIO.Independent. Related packages: lazyio: interleave IO actions in a single thread async: start threads and wait for their results, forward exceptions, but do not throttle concurrency with respect to number of available cores parallel-tasks:

This package is meant to implement the constraint machinary for the reflection package. It has been primarly ripped from the Constraint example of the reflection package with some extension. The implementation is also influenced by Austin Seipp's article on the reflection package

For package maintainers and hackage trustees

This package provides a couple of different implementations of mutable hash tables in the ST monad, as well as a typeclass abstracting their common operations, and a set of wrappers to use the hash tables in the IO monad. QUICK START: documentation for the hash table operations is provided in the Data.HashTable.Class module, and the IO wrappers (which most users will probably prefer) are located in the Data.HashTable.IO module. This package currently contains three hash table implementations: Data.HashTable.ST.Cuckoo contains an implementation of "cuckoo hashing" as introduced by Pagh and Rodler in 2001 (see http://en.wikipedia.org/wiki/Cuckoo_hashing). Cuckoo hashing has worst-case O(1) lookups and can reach a high "load factor", in which the table can perform acceptably well even when approaching 90% full. Randomized testing shows this implementation of cuckoo hashing to be slightly faster on insert and slightly slower on lookup than Data.HashTable.ST.Basic, while being more space efficient by about a half-word per key-value mapping. Cuckoo hashing, like the basic hash table implementation using linear probing, can suffer from long delays when the table is resized. Data.HashTable.ST.Basic contains a basic open-addressing hash table using linear probing as the collision strategy. On a pure speed basis it should currently be the fastest available Haskell hash table implementation for lookups, although it has a higher memory overhead than the other tables and can suffer from long delays when the table is resized because all of the elements in the table need to be rehashed. Data.HashTable.ST.Linear contains a linear hash table (see http://en.wikipedia.org/wiki/Linear_hashing), which trades some insert and lookup performance for higher space efficiency and much shorter delays when expanding the table. In most cases, benchmarks show this table to be currently slightly faster than Data.HashTable from the Haskell base library. It is recommended to create a concrete type alias in your code when using this package, i.e.: Firstly, this makes it easy to switch to a different hash table implementation, and secondly, using a concrete type rather than leaving your functions abstract in the HashTable class should allow GHC to optimize away the typeclass dictionaries. This package accepts a couple of different cabal flags: unsafe-tricks, default ON. If this flag is enabled, we use some unsafe GHC-specific tricks to save indirections (namely unsafeCoerce# and reallyUnsafePtrEquality#. These techniques rely on assumptions about the behaviour of the GHC runtime system and, although they've been tested and should be safe under normal conditions, are slightly dangerous. Caveat emptor. In particular, these techniques are incompatible with HPC code coverage reports. sse42, default OFF. If this flag is enabled, we use some SSE 4.2 instructions (see http://en.wikipedia.org/wiki/SSE4, first available on Intel Core 2 processors) to speed up cache-line searches for cuckoo hashing. bounds-checking, default OFF. If this flag is enabled, array accesses are bounds-checked. debug, default OFF. If turned on, we'll rudely spew debug output to stdout. portable, default OFF. If this flag is enabled, we use only pure Haskell code and try not to use unportable GHC extensions. Turning this flag on forces unsafe-tricks and sse42 OFF. Please send bug reports to https://github.com/gregorycollins/hashtables/issues.

Websockets FFI library for Fay

A collection of JSON tools

Associative containers retaining insertion order for traversals. The implementation is based on unordered-containers.

This package contains the debugger for the Curry to Haskell compiler kics.

Yoda is a small parser combinator library. It is not efficient, nor beautiful, but it hopes to teach young padawans to use the source and learn to write a parser.

Multiplicity is a configuration file driven wrapper around duplicity. It allows you to easily define backup sets as config files and avoid long, repetitive command lines.

Please see README.md

Please see the README on GitHub at https://github.com/cyberbotics/HsWebots#readme

In many cases, it is useful, necessary, or simply nice to limit how frequently you perform some action. For example, you may want to limit how often your program makes a request of some web site. This library is intended as a general-purpose mechanism for rate-limiting IO actions.

Stop execution with rage.

A monad for expressing SAT or QSAT problems using observable sharing. For example, we can express a full-adder with: Longer Examples Included are a couple of examples included with the distribution. Neither are as fast as a dedicated solver for their respective domains, but they showcase how you can solve real world problems involving 10s or 100s of thousands of variables and constraints with ersatz. This solves the "regular crossword puzzle" (grid.pdf) from the 2013 MIT mystery hunt. SPOILER

HaskellDirect is an IDL compiler for Haskell, which offers a helping hand to the Haskell programmer that wants to better interact with and reuse external code. Interfacing Haskell code to external code involves the conversion of values between the Haskell world and the outside, as data representations and details of how memory is managed, are worlds apart at times. Manually writing the boilerplate code that takes care of this conversion is about as exciting as watching grass grow and, as a result, error prone. Using an Interface Definition Language (IDL) as basis, HaskellDirect automates the generation of such impedance matching code, generating all the necessary marshaling code for you. With IDL, the functionality provided by a programming interface is specified in a programming language neutral framework. The HaskellDirect IDL compiler converts this specification into a set of method stubs. Depending on how the compiler is invoked, these stubs can be used to: Call upon external functions from within Haskell, HaskellDirect creates bindings to external (C-callable) libraries. Let external code call upon Haskell functions, HaskellDirect creates foreign/external language interfaces to Haskell libraries. Call COM (Microsoft's Component Object Model) methods from Haskell, HaskellDirect helps you use Microsoft COM components from within Haskell. The generated stubs can be used with Hugs98 or GHC. Create COM method wrappers, HaskellDirect packages up Haskell code as COM components. The HaskellDirect IDL compiler currently groks both the OSF DCE dialect of IDL (including the various extensions introduced by the Microsoft IDL compiler) and the OMG IIOP/CORBA dialect. (Only the former can be used for describing COM interfaces.)

The Dao modules and interactive program is a meta programming language intended for artificial intelligence uses. It is very much like the classic UNIX AWK scripting language, but instead of using POSIX-style regular epxressions, the patterns used in Dao are designed to more easily match natural language input.

A library to mock the current time and relevant IO functions by using a type class. You can get the great command of the current time in UTC, time zones, and the speed of time.

A local version of sqsd, the daemon that runs in Elastic Beanstalk's Worker Environments.

Various unrelated utility modules.

Please see the README on Github at https://github.com/nshimaza/thread-supervisor#readme

Monad Transformers and Classes

This package provides support for «golden testing». A golden test is an IO action that writes its result to a file. To pass the test, this output file should be identical to the corresponding «golden» file, which contains the correct result for the test.

A multiplayer game where you blend in as an NPC while trying to visit all of the ancient pillars. Press A to attack, S to drop smoke, N for new game, ESC to quit, click with your mouse to move.

A Haskell library for CEF (Commont Event Format)

This library has everything you need to create your dzen's bar input strings using powerful combinators in a type-safe way. It can be used to create standalone "scripts" with runhaskell or it can be used inside xmonad's main function. To see what can be done, please read the documentation of the toplevel module System.Dzen.

Doubly linked lists are often used in imperative languages to maintain a collection of objects such that an object can remove itself easily. The same idea applies here. Thanks to STM, these lists can be shared among threads with little effort. Suppose you have a thread listening for events. You want to dispatch events to any thread that opts in. You could write a function that installs an event handler, performs an action, and removes the handler: Then, you could have your listener thread dispatch events using a function like this:

A very general logging effect for Haskell

Haskell bindings to ReviewBoard (http://code.google.com/p/reviewboard/).

MonadThrow behaviour for composite-aeson.

The Acme.LookOfDisapproval module provides one function ಠ_ಠ, which lets you to express your profound disapproval.

An eDSL for writing 65(C)02 bytecode. Please see the README on GitHub at https://github.com/aearnus/sixty-five-oh-two#readme

Client API for Mattermost chat system. Mattermost is a flexible, open source messaging platform that meets even the most demanding privacy and security standards. This library provides network API interaction with the Mattermost server.

co-log-polysemy-formatting builds on the co-log-polysemy package, adding terminal colours, log severity, timestamps, callers, thread ids, and a flexible log format with good defaults. It also allows you to use the formatting library for formatting your log messages.

This simple tool will repeatedly query CloudFormation stacks for outputs, and see if any other stacks are importing those. This is to make it easier to tear down CFn stacks which have many other stacks depending on their outputs.

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

This library provides a timelike interface to the clock library.

[Index] For package maintainers and hackage trustees

An XML DOM-style parser, that only parses a subset of XML, but is designed to be fast.

A simple and modern, type safe, performance focused, idiomatic Haskell client for Prometheus monitoring. Specifically there is no use of unsafe IO or manual ByteString construction from lists of bytes. Batteries-included web server. A key design element of this library is that the RegistryT monad transformer is only required for registering new time series. Once the time series is registered, new data samples may just be added in the IO monad. Note: Version 0.* supports Prometheus v1.0 and version 2.* supports Prometheus v2.0. A Registry and StateT-based RegistryT are available for unit testing or generating lists of `[IO a]` actions that can be sequenced and returned from pure code to be applied.

thimk (an old joke) is a command-line spelling word suggestion tool. You give it a possibly-misspelled word, and it spits out one or more properly-spelled words in order of likelihood of similarity. The latest change to the implementation is an addition of an optional precompiled SQlite database of phonetic codes for the entire dictionary, created with thimk-makedb. This greatly speeds lookup, permitting reasonable performance on enormous dictionaries.

Extension of real numbers with positive/negative infinities (±∞). It is useful for describing various limiting behaviors in mathematics.

Get all your structure and rip it apart.

Transform data types before passing them to generic functions.

Torsor Typeclass

Graphs toolkit

Customisable Quiver grouping and chunking functions.

This library contains a JSON Schema generator.

A basic lambda calculator with beta reduction and a REPL

[Index] Use -f <flag> to enable a flag, or -f -<flag> to disable that flag. More info For package maintainers and hackage trustees A Prelude that exports much of the standard library (more then Prelude), without conflicts. If for example you were to import Prelude and Data.List or Data.Foldable you will run into ambiguous imports (regarding foldr for example). This Prelude aims at exporting the most general functions (in this case foldr from Data.Foldable). It also pulls in some default packages like cereal for serialization and containers for data types like Map and Set. Every datatype exported by this Prelude comes with instances for Serialize. Longs story short, instead of: it suffices to: Beyond existing functions from well-known standard packages, this prelude defines a few utilities (mostly aimed at unifying functionality across different packages, like containers and array). (!) is provided for several data types which associate a key and a value. Instances are defined for Check whether the element on the right is contained in the collection on the left. Instances are defined for A little bit like fmap but defined differently on some datatypes (applies e.g. to both components of a tuple). Instances are defined for Hydrogen Prelude exports fmap as map - the way it ought to be. A handy shortcut for undefined. Use it to pipe things from one function to the other, left to right: The head of the list, or the default given as first argument. Wrap anything that is showable (can be used to build heterogeneous lists). Combines predicates. A longhand for the type of lists, if you prefer this more wordy version. A class that provides the def function for default values for types. Instances of MonadPlus automatically have an instance where def = mzero. Default instances for most primitive types are also provided. Provides the *$* operator which is your all-purpose application operator. It does uncurrying (if you want to apply a tupel result of a function to a function that is curryied, works with tupels of up to 5 components) and also works with Applicative, i.e. it also does fmap . uncurry: The Hydrogen Prelude offers you the functions and datatypes from these modules, all with one import: from base from array from cereal from containers from hashable form hydrogen-multimap from hydrogen-version from regex-tdfa from time from transformers from uuid from base from strict from base from directory from filepath from process from random Mostly with XTypeFamilies and XStandaloneDeriving. Yes, for now at least. https://www.youtube.com/watch?v=rbBX6aEzEz8

Rendering from and scanning to simple format strings

This library uses the haveibeenpwned database to check for weak or compromised passwords.

Generic interface for incremental updates

hledger-interest is a small command-line utility based on Simon Michael's hleder library. Its purpose is to compute interest for a given ledger account. Using command line flags, the program can be configured to use various schemes for day-counting, such as act/act, 30/360, 30E/360, and 30/360isda. Furthermore, it supports a (small) number of interest schemes, i.e. annual interest with a fixed rate and the scheme mandated by the German BGB288 (Basiszins fuer Verbrauchergeschaefte). Extending support for other schemes is fairly easy, but currently requires changes to the source code. As an example, consider the following loan, stored in a file called test.ledger: Suppose that loan earns 5% interest per year, and payments amortize interest before amortizing the principal claim, then the resulting ledger would look like this: Running the utility with --help gives a brief overview over the available options:

Please see the README on GitHub at https://github.com/minoki/unboxing-vector#readme

A convenient command line wrapper for GHC that displays GHC's optimised core and assembly output in a human readable, colourised manner, in a pager. Unix systems only, currently. Usage:

This package provides utilities for converting between computations parameterized via two different typeclasses MonadIO and MonadBase, both of which can be used to abstract over monad transformer stacks with IO at the base. Unfortunately, both classes are frequently used in the Haskell ecosystem, since they have minor differences. Due to these typeclasses being unrelated, it’s not entirely uncommon to end up with type signatures like (MonadIO m, MonadBaseControl IO m) => ..., which are a little silly, since MonadBaseControl IO really includes all the power of MonadIO. To help alleviate this problem, this package provides a set of utilities for converting between the two constraints in situations where possible.

For package maintainers and hackage trustees

This package provides a parser and a printer for so-called .netrc files. See netrc(5) manual page for more information about .netrc files.

Natural numbers.

Yesod LDAP authentication plugin using native Haskell Ldap.Client

[Index] For package maintainers and hackage trustees

The lensref package provides and interface an two implementation for references which can be joined and on which lenses can be applied. The pure implementation is slow and has memory leaks but probably easier to follow. This is the reference implementation, so if the the other implementation differs this has the right behaviour. The fast implementation is intended for real usage. Status: The interface is getting stable. You can expect more functionality and minor changes on current functionality. There are test cases for the first half of the interface. Both implementations fulfil the test cases. The pure implementation is ready. The fast implementation is much faster than the pure implementation, but it is far from being as fast as possible. Probably it also leaks memory. To see what is possible to do with lens references, look at the test cases in Data.LensRef.Test For more information visit the following links: haskell.org wiki page Wordpress blog GitHub repository Haddock documentation (this page)

Compiler preprocessor introducing a syntactic extension for anonymous records

Importer and Exporter for Vienna energy files. Allows converting Turner parameter files to Vienna parameter files.

Construct, combine and query OBDDs; an efficient representation for formulas in propositional logic

A HERMIT plugin for GHC which optimizes SYB generic traversals to achieve equivalent performance to hand-written traversals. Details can be found in the paper: http://michaeldadams.org/papers/syb-opt/ Note: This compiler plugin requires GHC 7.8 (or HEAD) and specially compiled copies of base, ghc-prim, and syb. Up-to-date instructions can be found at: https://github.com/ku-fpg/hermit/wiki/GHC-HEAD. We are working to lift these requirements. As an example, we apply the optimization to Foo.hs, which contains the following code: Note that importing HERMIT.Optimization.SYB.Prelude is required in any module targeted for optimization. To compile Foo.hs with the optimization: This invokes GHC with a specific set of flags. These flags may be used instead of the hermit program itself, or placed in a cabal file. The first argument to HERMIT is the target file. Next is the -opt flag, which specifies the plugin name. Then follows one or more target module names, each beginning with a plus sign. After each target module is a list of targeted functions. The distinguished interactive target will run the optimization on any other targets and then enter the HERMIT interactive shell. The distinguished interactive-only target will open the HERMIT shell before optimization. HERMIT commands specific to this optimization are available for interactive use.

base-orphans defines orphan instances that mimic instances available in later versions of base to a wider (older) range of compilers. base-orphans does not export anything except the orphan instances themselves and complements <http://hackage.haskell.org/package/base-compat base-compat>. See the README for what instances are covered: https://github.com/haskell-compat/base-orphans#readme. See also the what is not covered section.

Parser for small simple language for big data Gimlh (https:github.comgazaygimlh)

s3-signer creates cryptographically secure Amazon S3 URLs that expire within a user-defined period. It allows uploading and downloading of content from Amazon S3. Ideal for AJAX direct-to-s3 uploads via CORS and secure downloads. Web framework agnostic with minimal dependencies. Result

[Index] For package maintainers and hackage trustees

Trivial monad transformer that allows identical monad stacks have different types.

Everything Data.Text related in one package

This package provides utilities for serving Elm programs directly from your Haskell binary. It uses TemplateHaskell to compile your Elm program at build time, and construct a WAI Middleware which intercepts requests appropriate to the Elm program, and passing other requests to a downstream WAI Application. It is useful for bundling the browser side of a web application with its backing web services implementation.

[Index] For package maintainers and hackage trustees