Please see the README on Github at https://github.com/lpeterse/haskell-ssh#readme

Open witnesses are witnesses that can witness to any type. However, they cannot be constructed, they can only be generated in the IO monad. See the paper Witnesses and Open Witnesses (http://semantic.org/stuff/Open-Witnesses.pdf).

High and low-level interface to the Novation Launchpad midi controller. Allows to make Launchpad apps easily, or to access the controller in a more low-level way. Some example apps are included. Presently only Mac OSX and Windows is supported (because we rely on hmidi).

This packages provides a library for rate limiting activities with a persistent backend.

PYthon Function Interface: Wrap python functions with haskell.

Please see the README on GitHub at https://github.com/nshimaza/bitset-word8#readme

Provides combinators for the optics-based manipulation of state and context types provided by the fused-effects library, similar to those provided by optics-extra for mtl-based monad transformers.

gnome-desktop is a program for displaying random pictures on your GNOME desktop background. It reads a sub-directory of $HOME (by default: Pictures) every n minutes (default: 1440 = once/per day) and every s seconds (default: 50) picks a random file and sets the gconf key desktopgnomebackgroundpicture_filename to the absolute path to that file.

Join- and meet-semilattices, with optional upper and lower bounds, and a variety of instances for each.

[Index] For package maintainers and hackage trustees

A Haskell implementation of JSON Web Token (JWT) Above Haskell standard type-safety, the library keeps track of public and private claim names and types. There are no user-facing HashMaps in this library! A type of a JWT token might be: Jwt '["user_name" ->> Text, "is_root" ->> Bool, "user_id" ->> UUID, "created" ->> UTCTime, "accounts" ->> NonEmpty (UUID, Text)] ('SomeNs "https://example.com"). From information encoded with precise types, it automatically derives encoders and decoders. It can also work with generic representations such as records. libjwt-typed uses libjwt for low-level functionality. libjwt delegates cryptographic work to either GnuTLS or OpenSSL. This way, not only the most performance-sensitive features work lightning fast, they are also extremely reliable. Besides, the library does not depend on any JSON library like aeson, but it implements the necessary JSON processing in C via jsmn - which makes it even faster. Benchmarking shows that it can be over 10 times faster than other Haskell JWT libraries. The library is designed for frictionless use. It can be easily extended, e.g. to add support for new types or to use custom JSON encodings compatible with other libraries you may already use in your project. Most instances can be derived automatically. The compilation errors are designed to be informational, i.e. you get Claim "user_name" does not exist in this claim set from GHC, not some 3 page long instance resolution output. You must have libjwt (preferrably the latest version) installed on your system and visible to the linker. libjwt-typed links to it at compile time. You can configure libjwt with GnuTLS or OpenSSL Please see the full README or browse the docs for more details.

Image thumbnail creation with cropping, upscaling, aspect ratio preservation and nonce suffixing

Build virtual machine images for vm-deployments; resize, un-partition, create from scratch or convert disk image files in a variety of formats; assemble and generate all associated files from templates and regular files. VM images can further be modifed through scripts, which are executed in LXC containers into which the vm-images as well as arbitrary directories from the host are mounted. All assembled files can also be accessed by vm build scripts through a special directory mounted in the build container, and/or can be written to directories, ISO- or VFAT-images. The ISO/VFAT images that B9 creates are compatible to cloud-inits NoCloud data source; B9 is also very well suited for compiling in a containerized environment. For these applications, the images can be marked as Transient to indicate no further interest in the VM-image itself, and B9 will discard them after the build. B9 will never over-write source files, not even large vm-image files - there is no intended way to modify a source vm-image file in-place. B9 operates in random build directories, which are discarded when the build exists.

The supervisors package provides a useful abstraction for managing the groups of Haskell threads, which may not have a strictly hierarchical structure to their lifetimes. Concretely, the library provides a Supervisor construct, which can be used to safely spawn threads while guaranteeing that: When the supervisor is killed, all of the threads it supervises will be killed. Child threads can terminate in any order, and memory usage will always be proportional to the number of *live* supervised threads. One way to think of it is that supervisors is to async as resourcet is to bracket. Note that this package is EXPERIMENTAL; it needs more careful testing before I can earnestly recommend relying on it. See the README and module documentation for more information.

Library provides the functions to find unique and duplicate elements in the list

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

Elo Ratings

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

An audio file compressor / limiter. This program will adjust the dynamic range of a WAVE file.

Sext (static text) provides type-level safety for basic operations on string-like types (finite lists of elements). Use it when you need static guarantee on lengths of strings produced in your code.

The noodle Programming Language Interpreter Noodle is two things. It is a programming language, and it is this implementation of that programming language. Briefly... Noodle (the language) is functional, latently typed, and statically scoped. Noodle has no language level concept of mutable state. Data abstraction is handled with 'scope bound' wrappers that prevent pattern matching on some value outside of some mutually recursive scope. Numbers are arbitrary precision integer ratios. Operators are (possibly) high order functions with special application rules that omit evaluation of the right operand if their application to the left operand does not return a function. Modules are mutually recursive internally, are first class, and can be parameterized by constructing them with functions. Rather than arrays or linked lists, the most basic compound data structure in noodle is a binary tree, or product. the primary points of interest in this package are: You may also incorporate noodle into your own program as a library, but this is even less documented than the completely undocumented command line interface... so I don't know why you would want to do this.

A simple command-line XML pretty-printer which automatically handles indentation.

[Index] For package maintainers and hackage trustees

This executable aims to automate several typical steps when uploading a new package version to hackage. Steps currently include: Compilation and running tests using multiple compiler versions. Checking that the changelog mentions the latest version. Checking that the upper bounds of dependencies are up-to-date by making use of stackage snapshots. [git] Pushing and tagging the version to the commit. Uploading of both the package itself and the documentation. The program is configurable using a per-project .yaml file. See the README.

Vowpal Wabbit hash and utils

Closed frequent itemsets are patterns that occur more than a defined threshold in a transactional database. This program is a Haskell implementation of the LCM2 algorithm by Takeaki Uno and Hiroki Arimura, which is the fastest algorithm for this task. This implementation can make use of several threads.

Derive instances of Arbitrary for QuickCheck, with various options to customize implementations. For more information See the README Generic.Random.Tutorial http://blog.poisson.chat/posts/2018-01-05-generic-random-tour.html

This package complements the Aivika and Aivika Experiment packages with charting capabilites. Now the simulation results can be represented as charts. Nevertheless, to plot the charts, you hould use one of the rendering backends provided by packages Aivika Experiment Cairo or Aivika Experiment Diagrams. While the Cairo backend suits mostly to Linux and partially OS X, the Diagrams backend is mainly destined for MS Windows, although it should work on Linux and OS X too.

dozens(https://dozens.jp/) api library for haskell

Money.

This package provides functions for converting emoji names to emoji characters and vice versa. How does it differ from the emoji package? It supports a fuller range of emojis, including all those supported by GitHub It supports lookup of emoji aliases from emoji It uses Text rather than String It has a lighter dependency footprint: in particular, it does not require aeson It does not require TemplateHaskell

This library provides drawing and plotting datastructures and functions; it is aimed in particular at scientific visualization, but it also exposes its plotting primitives and a small but general purpose 2D geometry library.

Provides smbclient authentication module that simply lets a user specify his/her identifier.

turtle is a reimplementation of the Unix command line environment in Haskell so that you can use Haskell as both a shell and a scripting language. Features include: Batteries included: Command an extended suite of predefined utilities Interoperability: You can still run external shell commands Portability: Works on Windows, OS X, and Linux Exception safety: Safely acquire and release resources Streaming: Transform or fold command output in constant space Patterns: Use typed regular expressions that can parse structured values Formatting: Type-safe printf-style text formatting Modern: Supports text and system-filepath Read Turtle.Tutorial for a detailed tutorial or Turtle.Prelude for a quick-start guide turtle is designed to be beginner-friendly, but as a result lacks certain features, like tracing commands. If you feel comfortable using turtle then you should also check out the Shelly library which provides similar functionality.

Tools for specifying and parsing configurations This package provides a collection of utils on top of the packages optparse-applicative, aeson, and yaml for configuring libraries and applications in a convenient and composable way. The main features are configuration management through integration of command line option parsing and configuration files and a Setup.hs file that generates a PkgInfo module for each component of a package that provides information about the package and the build. Documentation on how to use this package can be found in the README and in the API documentation of the modules Configuration.Utils and Configuration.Utils.Setup.

Haskell interface for Bing Translator

MHask is the category where The objects are Haskell types of kind (* → *) that have an instance of Prelude.Monad An arrow from object m to object n is a Haskell function of the form (forall x. m x → n x) Arrow composition is merely a specialization of Haskell function composition The identity arrow for the object m is the Prelude.id function in Haskell, specialized to (forall x. m x → m x) It is assumed that any instances of the classes provided here also have an instance for Monad of the form instance (Monad m) ⇒ Monad (t m), thus guaranteeing that (t m) (or (t i j m) for the indexed types) is always a Monad. If it were valid Haskell, I'd write: MHask.Functor.Functor should actually be called Endofunctor, because if m is an object in MHask, then an instance t of Functor can map object m to object (t m), and arrows from m to n get mapped to arrows from (t m) to (t n).

This package provides 'maps of maps' using Enum types as keys. The code is based upon Data.IntMap in containers 5.0.

A library for communicating with JSON over HTTP connection. Supports rich set of HTTP connectivity features provided by libcurl combined to the performance and elegancy of aeson. All HTTP methods are supported. Instances of ToJSON and FromJSON typeclasses can be transferred via this library. Session cookies and other HTTP options may be passed to libcurl if needed. This library is at its best when communicating with simple, non-standardized JSON interfaces. If you are implementing JSON-RPC compliant client or server, take a look at http://hackage.haskell.org/package/jmacro-rpc.

Random access list with a list compatible interface. Random access list have same complexity as lists with some exceptions, the notable one being that (!!) is O(log n) instead of O(n). RALists have to be finite.

Verismith provides random verilog generation modules implementing functions to test supported simulators.

QuasiQuoter for Perl6-style multi-line interpolated strings with "q", "qq" and "qc" support.

A type to represent exact real numbers using fast binary Cauchy sequences.

Minimal binary serialization library with focus on performance

parsec-numbers provides the number parsers without the need to use a large (and unportable) token parser

Message Pack RPC over TCP

Mutable vector with efficient updates. Simple implementation on partially filled array with capacity tracking and resizing.

Domain Name Service (DNS) lookup via the Windows dnsapi standard library

See README at https://github.com/matsubara0507/servant-kotlin#readme

This package provides simple low-level bindings for Asterisk Manager Interface (AMI).

Deprecated in favor of bluetile This package is OBSOLETE. The contents of this package has been merged in with the package bluetile.

In the Unix shell there is no easy way to use a filter program to change the contents of a file in-place. For example, if you want to sort a file in place, this will not work: sort < myfile > myfile All that will get you is an empty myfile. This package gives you the rewrite program, so this will work: rewrite myfile sort

A tasty ingredient to output test results in TAP 13 format.

BLOSUM matrix generator with the addition of any generic characters for special amino acids

Please see README.md

A library providing one with a somewhat higher level interface to 9P2000 protocol than existing implementations. Designed to facilitate rapid development of synthetic filesystems.

Parse a filename of a Foscam camera

Devil is a small tool to make it easier to update programs managed by Angel (the excellent process monitor/management tool). Angel starts processes. Devil kills running processes when an update is detected.

A yesod goody, shorten strings

This package contains an adapter that connects OpenGL/GLUT to the FRP library "Yampa". © 2012 by Nikolay Orlyuk; GPL-3 license.

A collection of illustrative applications to show various Shpadoinkle utilities.

Directed acyclic word graphs

A PostgreSQL backed queue. Please see README.md

Some ode solvers, e.g., Störmer-Verlet

This package provides first class(†) functional references. In addition to the usual operations of getting, setting and composition, plus integration with the state monad, lens families provide some unique features: Polymorphic updating Traversals Cast projection functions to read-only lenses Cast "toList" functions to read-only traversals Cast semantic editor combinators to modify-only traversals. (†) For optimal first-class support use the lens-family package with rank 2 / rank N polymorphism. Lens.Family.Clone allows for first-class support of lenses and traversals for those who require Haskell 98.

Benchmark functions via GHC.Stats and keep a history of running time and allocation profiles.

This is an OpenPGP library inspired by my work on OpenPGP libraries in Ruby https://github.com/singpolyma/openpgp, PHP http://github.com/singpolyma/openpgp-php, and Python https://github.com/singpolyma/OpenPGP-Python. It defines types to represent OpenPGP messages as a series of packets and then defines instances of Data.Binary for each to facilitate encoding/decoding. For performing cryptography, see http://hackage.haskell.org/package/openpgp-crypto-api or http://hackage.haskell.org/package/openpgp-Crypto For dealing with ASCII armor, see http://hackage.haskell.org/package/openpgp-asciiarmor It is intended that you use qualified imports with this library.

This tool creates a graphviz dot file that represents build dependencies on a system built with scons.

snaplet-influxdb is a snaplet for the Snap web framework providing convenience functions and state management for the Haskell InfluxDB 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

A package for working with nullary type classes in Haskell.

This library implements the LaTeX syntax and provides some useful abstractions. Some of the things you can do with HaTeX are: Write LaTeX documents with all the advantages you already have in Haskell: recursion, type system, high order functions, ... Create a LaTeX backend for your own program. Parse a LaTeX file and obtain its Abstract Syntax Tree (AST). Pretty-print Haskell values in LaTeX. Generate TikZ scripts (images!) easily. Browse the examples directory in the source distribution to see some simple examples. It might help you to get started. The HaTeX User's Guide is available at https://github.com/Daniel-Diaz/hatex-guide/blob/master/README.md. If you prefer to write in LaTeX and all you want is to program some parts of the document, or if you already have the LaTeX document written and you just want to add some automatically generated LaTeX code somewhere, check haskintex: http://daniel-diaz.github.io/projects/haskintex. It allows you to embed Haskell in LaTeX. It also makes you easy to use HaTeX within a LaTeX document.

This package contains many subsets of the Prelude allowing you to take only what you need. Modules named Prelude.Source.* are organized by the location of the source code.

Define and combine materialized projections

GLURaw is a raw Haskell binding for the GLU 1.3 OpenGL utility library. It is basically a 1:1 mapping of GLU's C API, intended as a basis for a nicer interface. 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/.

If not configured correctly, it may be easy for attackers to gain access to a system. sshd-lint checks the sshd_config file for adherence to best practices.

This package provides a program for creating and managing a statically-generated, VCS-friendly, mathematically-inclined weblog. If you're interested in managing a blog with few moving parts and support for embedded LaTeX math, embedded function plotting, and the UNIX editor of your choice, then this is the blogging platform for you! For detailed information and a full feature list, please see the manual PDF in the doc directory.

Haskell binding to sdl2-image.

Type classes abstracting typical approximate real number arithmetic operations including rounded field operations and common elementary operations. Two kinds of rounding are supported: rounding up/down in the numerical order or rounding in/out in a refinement order. A concrete implementation of refinement order rounded operations is given for intervals in the package AERN-Real-Interval. Concrete implementations of up/down rounded operations is given in AERN-Real-Double for ordinary Double fixed-precision numbers. These can serve as interval endpoints. In a future release also MPFR arbitrary-precision numbers will be made available as interval endpoints. 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.

Please see the README on GitHub at https://github.com/lehins/Color#readme

ST2 monad as described in the functional pearl "Ghosts of Departed Proofs"

This package provides the ability to adapt to locale conventions such as date and time formats.

Coveralls support for Stack projects

Please see README.md

Please see README.md

This package provides data types for a Collada scene graph including geometries, cameras and lights that may be loaded from Collada (dae) files. Geometries are represented by GPipe PrimitiveStreams. A utility module is included that include traverse helpers and render functions.

For package maintainers and hackage trustees

When tracking down a problem it can often be useful to temporarily disable some or many of the tests in a suite so that one can focus on the problematic tests. Rather than using a mess of comments, this module provides a function skip (and a few variants) that causses a test or an entire test suite to be skipped - specifically, they will still show up in the suite as being skipped, but they will not be run.

Allows scheduling and canceling of IO actions to be executed at a specified future time.

A quasi quotes for using Egison expression in Haskell code. Egison is a purely functional language featured strong pattern matching faculty. This package enable us to use (restricted) Egison expression in Haskell source code.

This package is designed to provide an easy-to-use, typesafe interface to querying Bugzilla from Haskell. This is a friendly fork of Seth Fowler's library, with minor updates and API tweaks needed for bugzilla.redhat.com.

The country library provides a data type for dealing with the set of countries as defined by ISO 3166. The representation is compact and is well-suited to use with vectors and primitive arrays. Additionally, this library exports functions that provide the following encodings and decodings: ISO Alpha-2 (two-letter country code) ISO Alpha-3 (three-letter country code) ISO Numeric (three-digit country code) The main differences between this library and iso3166-country-codes are: it doesn't use an ADT to represent countries, instead it uses the country's three-digit country code. it doesn't use String for encoding/decoding it provides two-alpha and three-alpha country codes. it provides Prim instances from the primitive package to allow types to be used in unboxed vectors/arrays. BSD3 licence instead of LGPL Please open up an issue on github if there is anything you would like to see added.

Please see the README on Github at https://github.com/ChrisPenner/eve-cli#readme

For package maintainers and hackage trustees Techlab is a prelude aimed at maximising expressivity in Haskell. This is intended for serious Haskell power users who don't mind the ground moving under them. Techlab values expressivity above all other concerns. We want to see how convenient and natural domain modelling can be made in Haskell. That is, we don't know exactly what the final form of this toolkit might look like, and we make no guarantees that anything you might want in a prelude won't be sacrificed in pursuit of shinier language elements and ergonomics. Techlab currently contains re-exports of chassis, a wide range of polysemy libraries, dhall, formatting and optics. Hobbyists who like polysemy will probably feel right at home here, and contributions are welcome. Very early release - nothing is namespaced well or comprehensively re-exported.

Additional details about this protocol can be found at the official website: https://keybase.io/triplesec A tutorial for how to use this library can be found in Crypto.TripleSec.Tutorial

Simple bindings for libgssapi(SSO) and libkrb5(user/password) library.