Haskell integration with Parrot virtual machine

A utility for determining which Git repositories need actions to be taken within them.

The Labeled IO (LIO) library is an information flow control (IFC) library. IFC is a mechanism that enforces security policies by tracking and controlling the flow of information within a system. Unlike discretionary access control (such as UNIX file permissions), IFC permits scenarios in which untrusted computation may have the ability to manipulate secret data without having the ability to further disclose that data. LIO is an IFC library that can be used to implement such untrusted computations. LIO provides combinators similar to those of IO for performing side-effecting computations (e.g., modifying mutable references, forking threads, throwing and catching exceptions, etc.) To track and control the flow of information, LIO associates a security policy, called a label, with every piece of data. A label may, for example, impose a restriction on who can observe, propagate, or modify the data to which it applies. Unlike standard IO operations, the LIO counterparts check the vailidity of labels before performing the (underlying IO) side-effecting computation. For example, before writing to a labeled variable, LIO asserts that the write will not violate any security policies associated with the data to be written. Most code should import module LIO and whichever label format the application is using (e.g., LIO.DCLabel to use the format that ships with the library). Side-effecting code should be specified as actions in the LIO monad. See LIO.Core for a description of the core library API, LIO.Label for a discussion of labels, and LIO.Run for functions allowing one to run an LIO computation from the IO monad. WARNING: For security, untrusted code must always be compiled with the -XSafe and -fpackage-trust SafeHaskell flags. See http://www.haskell.org/ghc/docs/latest/html/users_guide/safe-haskell.html for more details on the guarantees provided by SafeHaskell.

Opinionated use of Amazonka's SES for ease

This is a simple implementation of type-level natural numbers that only requires DeriveDataTypeable. Operations requiring more language extensions have been split into a separate package. The difference between this package and the many others on Hackage implementing type-level naturals is its emphasis on simplicity. It only supports non-negative natural numbers, and only the successor and predicessor operations. It represents natural numbers using a type-level linked list, so it is not intended to be used for representing large numbers. Pre-defined aliases for natural numbers up to 15 are provided. The code for this package was largely taken from the excellent Vec package; I created this package with the intent of making this functionality more widely available. Difference from 1.0: Added instances for Typeable, and word synonyms for N0...N15. Difference from 1.1: Performance enhancements for naturalNumberAsInt. Simplified Show implementation. Difference from 1.1.1: Gave up on Haskell 2010 compatibility since as of GHC 7.8 manually deriving from Typeable is no longer allowed; now I use DeriveDataTypeable to construct the instances.

This package provides a GHC.Generics-based genericLiftWithPkg function (intended for GHC 7.10 and earlier), as well as a genericLift function (only available on GHC 8.0 and later), both of which can be used for providing a Language.Haskell.TH.Syntax.lift implementation. See the documentation in the Language.Haskell.TH.Lift.Generics module to get started. Credit goes to Matthew Pickering for suggesting this idea. Note that due to API limitations, GHC.Generics wasn't powerful enough to come up with the entirety of a lift implementation prior to GHC 8.0. For this reason, genericLiftWithPkg requires you to produce the package name yourself, which proves to be no small feat (see the documentation for more info). Luckily, you don't have to jump through as many hoops on GHC 8.0 and later: simply use the genericLift function, and life is good.

[Index] For package maintainers and hackage trustees

For introduction and demo skip to Readme. For documentation and syntax reference see the Domain.Docs module. For API documentation refer to the Domain module, which exports the whole API of this package.

This package implements the phonetic coding algorithms Soundex and Phonix. A phonetic coding algorithm transforms a word into a similarity hash based on an approximation of its sounds. Thus, similar-sounding words tend to have the same hash.

Focuses are lists of numbers where longer lists are treated as focuses on their parent lists. As such, `Focus []` is considered unfocused (it is EQ to all focuses), `Focus [1, 1]` is EQ to `Focus [1, 1, 3]` because their roots are equal, and so on. This isn't useful for testing true equality, but it is quite useful for traversing and pruning indexed rose trees from one locus to another.

tdd-util is a small test framework for TDD (cf. https://en.wikipedia.org/wiki/Test-driven_development) that integrates three testing libraries, whose modules are all exported under Test.Util.Framework, while providing utilities based on each of these, exported under Test.Util, by wrapping the library test-framework. Getting Started To get started, an example that uses this library is this library's test suite itself and can be found at https://github.com/bairyn/tdd-util/tree/master/testsrc. Each module under src corresponds with a module under testsrc/Test that contains the tests for that module. (For example, this library currently exports two modules in src/Test/Util.hs and src/Test/Util/Framework.hs; their tests are located, respectively, in testsrc/Test/Test/Util.hs and testsrc/Test/Test/Util/Framework.hs; and a module in src/Data/Trie.hs would correspond with a test module in testsrc/Test/Trie.hs). This structure can be conveniently cargo culted from this library, but these conventions are not enforced. Test Modules Conventially, each module in src/X.hs corresponds with a module that contains tests for that module located at testsrc/Test/X.hs. None of these Test modules depend on each other by importing them. For a concrete example of such a test module, see https://github.com/bairyn/tdd-util/blob/master/testsrc/Test/Test/Util.hs. Each test module exports a list of test-framework's TTests (an alias to disambiguate between Test types from different libraries) named tests. This list of tests can either be run individually by importing the test module, and then running defaultMain tests; or be grouped together in the test-suite's Tests module (see below). In the tests themselves, very briefly, testGroup "Brief description of test" […] can be used to construct a single test-framework test (TTest) from a group of other tests, testProperty name prop_foo can be used to construct a TTest from a QuickCheck property, and testCase name $ do … can be used to construct a test from HUnit. See test-framework's documentation for more information about constructing QuickCheck and HUnit properties. Here is a segment of code from https://github.com/bairyn/tdd-util/blob/master/testsrc/Test/Test/Util.hs: Tests.hs Each test module is conventionally grouped into a single test module, at testsrc/Tests.hs (e.g. see https://github.com/bairyn/tdd-util/blob/master/testsrc/Tests.hs), that exports a list of TTests named tests. Interactively, this test module can be loaded in ghci, and the tests can be run as before, with defaultMain tests. These tests can also be specified in the project's cabal file, by invoking defaultMain on tests in an external Main.hs file under testsrc (e.g. see https://github.com/bairyn/tdd-util/blob/master/testsrc/Main.hs). Running this Main.hs will result in the test suite being run, so a test-suite section can be added to the cabal file as it is in https://github.com/bairyn/tdd-util/blob/master/tdd-util.cabal. When a test suite is specified, cabal will recognized it and, when configured to do so, will run it when installing your package, resulting in output that may look like this when it succeeds. This package's Tests.hs: Main.hs Example Main.hs conventially defines a simple program that invokes defaultMain tests from the test group that encapsulates the entire test suite in Tests.hs. Here is this package's Main.hs file: Cabal Configuration Your package's cabal configuration can be updated to point to testsrc/Main.hs/; here is a segment in this package's Cabal file that contains part of the specification for the package's test suite: Note that tdd-util is the only TDD library one needs to depend on, if one only uses QuickCheck, HUnit, and test-framework via Test.Util.Framework; this omission is strictly optional, of course. Test Running Example Here is the output of importing Test.Test.Util inside the testsrc directory and then running tests on my system (note this is not the result of running the entire test suite; to do that, either run Main.hs or run, with defaultMain, the tests exported from Tests.hs rather than Test.Test.Util), without the coloured formatting:

Flash debugger. You need debug flash player installed to use it.

Shadowsocks implemented in Haskell. Original python version: https://github.com/clowwindy/shadowsocks

Law-abiding lenses for aeson.

[Index] For package maintainers and hackage trustees

(see README.md)

binary-orphans defines orphan instances for types in some popular packages.

A toy C compiler.

The primary goal of x86-64bit is to provide a lightweight assembler for machine generated 64 bit x86 assembly instructions. See README.md for further details.

This package provides a very simple tool to download images from RSS feeds (e.g. the kind that Flickr and Picasa provide). Example usage: The tool will download the media:content images found in the RSS feed (it also supports some other formats) and place them in the current directory, naming them 01.extension, 02.extension, etc.

ClassyPrelude is a Prelude for people who know Haskell well. It re-exports some commonly imported modules, replaces Prelude functions with their type-class equivalents where reasonable, and removes some Prelude functions that in my opinion don't belong there. These modules are likely to be incomplete. Suggestions are greatly appreciated.

For package maintainers and hackage trustees

Chunk of memory, polymorphic byte array management and manipulation A polymorphic byte array abstraction and function similar to strict ByteString. Different type of byte array abstraction. Raw memory IO operations (memory set, memory copy, ..) Aliasing with endianness support. Encoding : Base16, Base32, Base64. Hashing : FNV, SipHash

Given a module name and a name, or just a name, it will find and display the documentation of that name. EXAMPLE USAGE INSTALLATION You should ensure that you have in your .cabal/config so that the necessary .haddock files are generated. Haddock is very sensitive to the GHC version. This program tries not to be. If you cannot install this package due to a version problem, open a Github issue. If the versions match up but the build fails, open a Github issue. Neither case should arise. USING WITH GHCI Add the above :def to your user .ghci to have it on start-up. CONTRIBUTION AND ISSUES Issues/ideas/contributions please make a Github issue: http://github.com/chrisdone/haskell-docs/issues

Library for logic programming based on haskell package logict

This library contains syntactic sugar that makes it easier to write simple contracts with assert and error and report the values that violate contracts.

[Index] For package maintainers and hackage trustees A simple wrapper of http-conduit for file download. It relies on tls instead of HsOpenSSL for HTTPS support, so portability is improved.

scope is a framework for plotting time-series data, using zoom-cache files. This package contains the core Scope library; to use it for interactive plotting, you need a rendering backend such as scope-cairo: http://hackage.haskell.org/package/scope-cairo For more information about zoom-cache files, see the zoom-cache package: http://hackage.haskell.org/package/zoom-cache

The haskell application server stack

Please see README.md

This packages provides iteratee enumerators for the usb package.

hspec-setup is a command-line tool for adding an hspec test-suite with minimal work. See the GitHub README for more information.

This library provides an easy way to define command line parsers. Most users will want to use the System.Console.CmdArgs.Implicit module, whose documentation contains an example. System.Console.CmdArgs.Explicit provides a way to write command line parsers for both single mode programs (most programs) and multiple mode programs (e.g. darcs or cabal). Parsers are defined by constructing a data structure. System.Console.CmdArgs.Implicit provides a way to concisely define command line parsers, up to three times shorter than getopt. These parsers are translated into the Explicit data type. System.Console.CmdArgs.GetOpt provides a wrapper allowing compatiblity with existing getopt parsers, mapping to the Explicit data type. For a general reference on what command line flags are commonly used, see http://www.faqs.org/docs/artu/ch10s05.html.

Create HTTP benchmarks from the HAR files

Towards Haskell in the Cloud (Epstein et al, Haskell Symposium 2011) introduces the concept of static values: values that are known at compile time. In a distributed setting where all nodes are running the same executable, static values can be serialized simply by transmitting a code pointer to the value. This however requires special compiler support, which is not yet available in ghc. We can mimick the behaviour by keeping an explicit mapping (RemoteTable) from labels to values (and making sure that all distributed nodes are using the same RemoteTable). In this module we implement this mimickry and various extensions: type safety (including for polymorphic static values) and compositionality.

A suite of preprocessor and quasiquoter to desugar arrow notation built on top of Ross Paterson's arrowp and the venerable haskell-src-exts.

A type checker plugin for GHC that can derive "complex" KnownNat constraints from other simple/variable KnownNat constraints. i.e. without this plugin, you must have both a KnownNat n and a KnownNat (n+2) constraint in the type signature of the following function: Using the plugin you can omit the KnownNat (n+2) constraint: The plugin can derive KnownNat constraints for types consisting of: Type variables, when there is a corresponding KnownNat constraint Type-level naturals Applications of the arithmetic expression: +,-,*,^ Type functions, when there is either: a matching given KnownNat constraint; or a corresponding KnownNat<N> instance for the type function To use the plugin, add the Pragma to the header of your file.

Serialize instance for Message Pack Object

This package implements a monad for non-deterministic computations with sharing.

implements ArchLinux AUR json API

Deprecated in favor of HGamer3D-SFML-Binding Library, to enable 3D game development for Haskell, based on bindings to 3D Graphics, Audio and GUI libraries. THIS MODULE: OIS Bindings List of features and modules: Data Module (Basic Data Types), OGRE Binding (3D Graphics Engine), OIS Binding (Input System), cAudio Binding (Audio), CEGUI Binding (GUI System), APIs (Haskell style APIs, different ways, to approach API) Platform: Windows only License: Apache License, Version 2.0 Install: see http:www.althainz.deHGamer3DDownload-and-Installation.html

Please see README.md

Jammit is a service and associated app for Windows/Mac/iOS that sells isolated instrument audio tracks from popular music, along with full transcriptions. This is a library and executable that allow you to export the sheet music (in PDF format) and audio (in WAV format) to tracks that you have purchased. Any sheet music or audio you export is solely for your own use, e.g. for use on Linux and Android devices that do not have the official app available. Please do not use this tool to share content with others who have not purchased it! Please see the README for usage information.

Foreign Binding to Jonny D's SDL Primitives Generator (SPriG) library, a fork of SGE. Haddock documentation is available from the homepage.

Writes to target file multiple times with random data, then erases it.

A graph database storing its data on disk. There is currently no transaction or even concurrent access support, this is not made for production. We try to store the data on disk efficiently, i.e. not rely on having the data in memory. There is a test suite and a benchmark, which would be the best way to get a feel for how the library works.

Translate comments (written in Japanese) on Nico Nico Douga (ニコニコ動画) to your language. See also README.md for more details.

Reenact is a reimplementation of the Reactive library by Conal Elliott. It preserves semantics and most operators of the original library. In particular the Monoid, Applicative and Monad instances for Events, Reactives and Behaviours are available and have the original semantics. The implementation however is completely different, based on asynchronous channels instead of the unamb operator.

Abstract data type for canonical file paths.

Very simple script to delete a cabal package.

Simplifies simple

Trace all HTTP redirections of an URL

Functions for finding prime numbers, checking whether a number is prime, finding the factors of a number etc.

This package only provides Artery type and associated operations.

[Index] For package maintainers and hackage trustees A web service framework for Haskell, similar in purpose to dropwizard.

Cabal 2.2 allows reexported modules, which will eventually allow us to consider splitting lens into smaller pieces. Cabal 3.4 allows multiple public sub-libraries in a package Which may be a better plan, to avoid hackage namespace pollution. I'm claiming this name to avoid rampant namespace confusion between lens:core and lens-core in the latter scenario and to allow progress on the former scenario. For now, use lens.

A free monad based on the Wadler/Leijen pretty printer

Common high-level tasks when processing MIDI files. Use tempos to translate between musical time (beats) and real time (seconds). Use time signatures to reference positions using measures instead of just beats. Find or change the names of MIDI tracks.

For package maintainers and hackage trustees goldplate is a cute and simple opaque golden test runner for CLI applications. You place your test cases in a directory, annotate them with .goldplate files, and that's it. It is completely language agnostic. And perhaps its best feature is that it can automatically✨🪄 fix your tests outputs! Give goldplate a try if: At Fugue, we've been using internal versions of this tool since 2016, so it should be pretty stable. Imagine we are up to testing the behaviour of echo command. In this very simple example, we run echo "Hello, world!" and expect it to print Hello, world! to the stdout stream as a result. Create a new file echo.goldplate and add the following content: Let's go through this bit by bit. The test invocation is specified by the command and arguments fields. We are invoking the echo process with a single argument, "Hello, world!". The expected results of our test live in the asserts field. This simple test has two asserts: We haven't created hello-world.txt yet, but that's not a problem. We can invoke goldplate --fix to create it: After hello-world.txt has been created with proper contents, subsequent goldplate invocations will pass: You can view the full example here: View example: You can pass one or multiple lines of input to the command by using the stdin field. View example: The environment field can be used to set environment variables for the program. goldplate also sets a number of environment variables. You can use these directly within the configuration JSON. In this example, we use: Rather than: We found this to be good practice, it makes mass-renaming of tests much easier. View example: .goldplate files are fairly small but if you have a whole directory of files that you just want to run the same command on, they can get very repetitive. This is why goldplate provides a simple way to pull in multiple input files. If the input_files field is set to a glob, all asserts will be ran for every matching input file. goldplate will set the following variables: View example: Sometimes you may want to do a find-and-replace on the actual output, for example to filter out timestamps or other information that you do not expect to match up against the expected output. View example: Many modern CLI tools output JSON. You can use the prettify_json post processor to make sure the JSON is converted to a normalized form with sorted keys and consistent indentation. View example: goldplate is geared towards checking the stdout and stderr outputs of a program, but you can also check that files were created with specific contents. If you do this, goldplate will remove these files and directories afterwards to leave a clean repository behind. Installation through source is done using standard Haskell tooling -- Cabal and stack both work well. Environment variables can be spliced into the configuration using ${VAR} syntax within strings. To escape this syntax, use $${VAR} to get a literal ${VAR}, $$${VAR} to get a literal $${VAR}, and so on. The test is always executed in the directory that holds the .goldplate file. goldplate will always set the following environment variables: When dealing with multiple input files, the following additional variables are set: Here is an example that outputs all of these environment variables: A similar project is smoke. I think goldplate has two major advantages over smoke:

Command-line tool to generate paths for moving upward in a file system.

A Haskell binding for the OpenGL Utility Toolkit, a window system independent toolkit for writing OpenGL programs. For more information about the C library on which this binding is based, please see: http://www.opengl.org/resources/libraries/glut/.

Partial isomorphisms as described in the paper: Tillmann Rendel and Klaus Ostermann. Invertible Syntax Descriptions: Unifying Parsing and Pretty Printing. In Proc. of Haskell Symposium, 2010. The paper also describes invertible syntax descriptions as a common interface for parsers and pretty printers. These are distributed separately in the invertible-syntax package.

Want to do dynamically typed programming in Haskell sometimes? Here you go!

Buster is best described by the following blog post: http://vis.renci.org/jeff/2009/03/31/almost-but-not-quite-entirely-like-frp/ It is an engine for orchestrating large, complex, and multifaceted applications by couching them in terms of time, events, a bus, behaviours, and widgets. Time is continuous and infininte. Events are discrete and exist for a particular time. The bus is a discrete sample of time made available to behaviours. Behaviours are continuous and exist for all time, but sample time via the bus. They filter Events to determine what is on the bus at future times. Widgets are input-only objects that sample the outside world and assign events to discrete portions of time. Buster is designed to be flexible, with a flexible event model and the ability to add custom data to events, and designed to be high performance. It is simple to integrate with Gtk while at the same time able to handle other kinds of resources, like files and sockets.

Library to authenticate with OAuth 2.0 for Yesod web applications.

Estimates the progress of a function as it executes, and displays a progress bar.

Bindings for AWS SNS API Version: 2013-03-31 http://docs.aws.amazon.com/sns/2010-03-31/APIReference/Welcome.html

Very Alpha. Minimal Testing.

a tiny PPM image generator

Various Haskell 2010 stream comonads. * Data.Stream.Future provides a coinductive anti-causal stream, or non-empty ZipList. The comonad provides access to only the tail of the stream. Like a conventional ZipList, this is not a monad. Data.Stream.Future.Skew provides a non-empty skew-binary random-access-list with the semantics of Data.Stream.Future. As with Data.Stream.Future this stream is not a Monad, since the Applicative instance zips streams of potentially differing lengths. The random-access-list structure provides a number of operations logarithmic access time, but makes Data.Stream.Future.Skew.cons less productive. Where applicable Data.Stream.Infinite.Skew may be more efficient, due to a lazier and more efficient Applicative instance. Data.Stream.Infinite provides a coinductive infinite anti-causal stream. The Comonad provides access to the tail of the stream and the Applicative zips streams together. Unlike Future, infinite stream form a Monad. The monad diagonalizes the Stream, which is consistent with the behavior of the Applicative, and the view of a Stream as a isomorphic to the reader monad from the natural numbers. Being infinite in length, there is no Alternative instance. Data.Stream.Infinite.Skew provides an infinite skew-binary random-access-list with the semantics of Data.Stream.Infinite Since every stream is infinite, the Applicative instance can be considerably less strict than the corresponding instance for Data.Stream.Future.Skew and performs asymptotically better. Data.Stream.Infinite.Functional.Zipper provides a bi-infinite sequence, represented as a pure function with an accumulating parameter added to optimize moving the current focus. Data.Stream.Supply provides a comonadic supply of unique values, which are generated impurely as the tree is explored.

[Index] For package maintainers and hackage trustees

Implementation of the Pusher WebSocket protocol in Haskell

Provides a simple means of reverse-proxying HTTP requests. The raw approach uses the same technique as leveraged by keter, whereas the WAI approach performs full request/response parsing via WAI and http-conduit.

Prelude with only useful functions

Mealstrom is a library that allows you to work with Mealy machines, a kind of finite-state machine, in Haskell using PostgreSQL for persistence.

The pdftotext package provides functions for extraction of plain text from PDF documents. It uses C++ library Poppler, which is required to be installed in the system. Output of Haskell pdftotext library is identical to output of Poppler's tool pdftotext.

We provide a library and an executable for working with derived Show instances. By using the library, we can parse derived Show instances into a generic data structure. The ppsh tool uses the library to produce human-readable versions of Show instances, which can be quite handy for debugging Haskell programs. We can also render complex generic values into an interactive Html page, for easier examination.

The objective is to completely isolate away the thrift layer, providing a more idiomatic and naruall Haskell experience working with Cassandra. Be sure to check out the README on Github for some more explanation and Release Notes, which is helpful in talking about what this library can do. Certain parts of the API was inspired by pycassa (Python client) and hscassandra (on Hackage). Please see the Github repository for more detailed documentation, release notes and examples. A brief explanation of modules: Database.Cassandra.Basic: Contains a low level, simple implementation of Cassandra interaction using the thrift API underneath. Database.Cassandra.Marshall: Intended to be the main high level module that you should use, Marshall allows you to pick the serialization strategy you would like to use at each function call. We recommend using casSafeCopy due to its support for evolving data types, although casJSON maybe another popular choice. Database.Cassandra.JSON: (Now deprecated; use Marshall instead) A higher level API that operates on values with ToJSON and FromJSON isntances from the aeson library. This module has in part been inspired by Bryan O'Sullivan's riak client for Haskell. Database.Cassandra.Pool: Handles a pool of connections to multiple servers in a cluster, splitting the load among them. Database.Cassandra.Pack: Handles column types that Cassandra recognizes and adds support for Composite Columns. Database.Cassandra.Types: A common set of types used everywhere. Potential TODOs include: Support for counters and batch mutators Support for database admin operations

Haskeline wrapper for GHCi-like REPL interfaces. Composable with normal mtl transformers.

This module implements the Knuth-Morris-Pratt algorithm. It can search a word in a text in O(m+n) time, where m and n are the length of the word and the text. This module can apply on any list of instance of Eq.

Please see README.md

Given a number of circles with their radii, this packags tries to arrange them tightly, without overlap and forming a large circle. Finding the optimal solution is NP hard, so only heuristics are feasible. This particular implementation is neither very good nor very fast, compared to the state of the art in research. Nevertheless it is simple to use and gives visually acceptable results. Contributions of better algorithms are welcome.

Please see README.md

Experimental Haskell machine learning library

Template Haskell utilities for Hasql

reCAPTCHA (http:recaptcha.net/) is a service that provides captchas for preventing automated spam in web applications. recaptcha-hs provides functions for using reCAPTCHA in Haskell web applications.

The units package provides a mechanism for compile-time dimensional analysis in Haskell programs. It defines an embedded type system based on units-of-measure. The units defined are fully extensible, and need not relate to physical properties. The package supports defining multiple inter-convertible units, such as Meter and Foot. When extracting a number from a dimensioned quantity, the desired unit must be specified, and the value is converted into that unit. If you are looking for specific systems of units (such as SI), please see the units-defs package. The Haddock documentation is insufficient for using the units package. Please see the README file, available from the package home page.

Monadic abstraction for computations that can be branched and run independently.

This program uses the xinput program to get a stream of key presses and uses the libnotify library to display them on-screen. Currently supported display notations are: Emacs

Prelude with only useful functions

Haskell channels with the forwarding primitive

Provides functions for reading in the signing keys from file and making up time-limited, signed URLS for accessing AWS CloudFront-hosted files.

Gloss rendering for apecs-physics

Fast live-reloading for yesod applications.