:black_nib: Jekyll in Haskell (feat. LaTeX)

lifted-base exports IO operations from the base library lifted to any instance of MonadBase or MonadBaseControl. Note that not all modules from base are converted yet. If you need a lifted version of a function from base, just ask me to add it or send me a patch. The package includes a copy of the monad-peel testsuite written by Anders Kaseorg The tests can be performed using cabal test.

Upload Emacs packages to the Marmalade ELPA archive.

Haskell bindings for Advent of Code REST API and a servant API. Please use responsibly! See README.md or Advent module for an introduction and tutorial.

This library provides a pure Haskell complex-to-complex Fast Fourier Transform implementation for arbitrary length input vectors, using a mixed-radix decimation-in-time algorithm with specialised straight-line code for a range of base transform sizes, Rader's algorithm for prime length base transforms, and an empirical optimisation scheme to select a good problem decomposition. This package is probably primarily of pedagogical interest (FFTW is about five times faster for most input sizes). There is a long series of blog articles describing the development of the package, indexed at http://www.skybluetrades.net/haskell-fft-index.html.

Manage lists of TODO items for private branches from the command line. No configuration required and fast to learn, with human-editable storage format and comprehensive help information.

WARNING: Project in alpha. Call python from haskell with ease.

Functions for working with Jalaali (Jalali, Persian, Khayyami, Khorshidi, Shamsi) calendar systems. Please see the README on GitHub at https://github.com/jalaali/jalaali-hs#readme

A module to manage payroll books for Japanese companies. This enable to export data to tax withholding book, etc...

Based on the article Better Yaml Parsing.

pvd, Photo Viewer Daemon, is an image viewer application that displays a fullscreen X11 window and listens for remote commands over TCP. The project also includes pvc, a simple command line client application you can use to control pvd. pvc has commands for setting the current photo playlist, jumping between photos, etc. pvd implements caching in the background which makes it possible to quickly switch between photos even if the files are fetched over network or if pvd runs on a slow computer. pvd uses the DevIL image library for loading photo files, which supports a large number of image formats.

Fast heterogeneous data structures

Implementation of the "Monads, Zippers and Views" (Schrijvers and Oliveira, ICFP'11)

BCrypt salted and hashed passwords in a database as auth for yesod

A generic interface for cryptographic operations (hashes, ciphers, randomness). Maintainers of hash and cipher implementations are encouraged to add instances for the classes defined in Crypto.Classes. Crypto users are similarly encouraged to use the interfaces defined in the Classes module. Any concepts or functions of general use to more than one cryptographic algorithm (ex: padding) is within scope of this package.

Semantic Editor Combinators as described by Conal Elliott (See: http://conal.net/blog/posts/semantic-editor-combinators/) and Template Haskell support for automatically creating semantic editor combinators from Algebraic Data Types.

Library and command line REPL with plotting to do simple inviscid hess-smith panel code. Features include: Cheap and shameless xfoil ripoff for relp/plotting interface Naca 4-series support with Gauss-Newton paneling Broken UIUC database integration (type "uiuc [foilname]") Haskeline interface with tab-completion (oooh) Single and multi-element airfoils Inviscid, incompressible, 2-dimensional flow only To get started, do cabal install or whatever, then run the "hfoil" binary. Things to try: "naca 2412", "alfa 4", (hit enter before entering another airfoil), "load [filename]", "uiuc e330"

Please see README.md

Tahin Password Generator

Building the bridge from Haskell to Elm and back. Define types once, and derive the aeson and elm functions at the same time, using any aeson option you like. Cheers!

Receiver Policy Framework (RPF) is a Milter program to change actions of e-mail receiver side according to results of the anti-spam technologies.

A simple Breakout game implementation.

EMGM is a general-purpose library for datatype-generic programming. The design is based on the idea of modeling algebraic datatypes as sum-of-product structures. Many datatypes can be modeled this way, and because they all share a common structure, we can write generic functions that work on this structure. The primary features of the library are: A foundation for building generic functions. EMGM includes a collection of datatypes (e.g. sum, product, and unit) and type classes (e.g. Generic and Rep). Everything you need for defining generic functions and supporting datatypes can be found here. Many useful generic functions. These provide a wide range of functionality. For example, there is crush, a generalization of the foldl/foldr functions, that allows you to flexibly extract the elements of a polymorphic container. Now, you can do many of the operations with your container that were previously only available for lists. Support for standard datatypes. EMGM supports standard types: primitives (e.g. Int and Float), Bool, lists, tuples, Maybe, etc. NOTE: As of version 0.4, this library does not have Template Haskell for generating the representation. We are working on another library for a solution to this problem.

wallpaper provides the tools needed to make your own wallpapers, friezes and rosettes as described in Frank A. Farris's beuatiful book Creating Symmetry. Following Farris we use the domain coloring algorithm to create recipes that convert an arbitrary image to a pattern. For example, using the this image We can make For maximum flexibily the wallpaper library provides an EDSL for their creation, alternatively the wallpaper and rosette executables can be used with a yaml file to create a large variety of patterns.

scope-cairo is a Cairo rendering backend for scope, which is a a framework for plotting time-series data using zoom-cache files. For more information on scope and zoom-cache, see their packages: http://hackage.haskell.org/package/scope http://hackage.haskell.org/package/zoom-cache This package includes a Gtk/Cairo application. It's a desktop application with a File menu; remember those? wow! This will probably be split out into a separate package later, and there'll be a webby javascripty version too, but for now there's this desktop app. To run it, simply: Then, select File->Open from the menubar, with your mouse: there's no swiping gestures back here, baby! Four (yes, 4) demo files are included in this version of the package. Choose one, and it will be drawn in the window. Amazing! It should look something like what you saw in the post you read about this in, but more personal because now it's happening to you. Zoom in with the scroll wheel on your mouse. If you don't have a scroll wheel, use the Up and Down arrow keys on your keyboard. If you don't have up and down arrows you are elite! Pan around by dragging it. There's a scrollbar too if you're into that. Load up another file! It will also be drawn. Zoom in and out and pan around, yay! Life is gooood!

A tutorial program for the Egison programming language. Egison is the programming langugage that realized non-linear pattern-matching against unfree data types. With Egison, we can represent pattern-matching with unfree data types intuitively, especially for collection data, such as lists, multisets, sets. Please try Egison with this tutorial program!

Please see the README on Github at https://git.localcooking.com/tooling/wai-middleware-content-type#readme

A fork of resource-pool using MonadIO and exceptions. The library also contains a number of fixes and enhancements which are not yet included in a Hackage release of the original library. Apart from that, this library is a drop-in replacement for resource-pool, useful in cases where a more general monadic type is desirable.

WeightedT monad transformer.

A library to facilitate rebinding of Haskell syntax

This package provides two representations for linear programs: Numeric.Limp.Program, which is what I expect end-users to use, and Numeric.Limp.Canon, which is simpler, but would be less nice for writing linear programs. You can convert programs from the Program representation to the Canon representation using Numeric.Limp.Canon.Convert, and then pretty-print the program using Numeric.Limp.Canon.Pretty. There is a very simple branch-and-bound solver in Numeric.Limp.Solve.Branch.Simple, and a simplex solver for relaxed (real only) programs in Numeric.Limp.Solve.Simplex.Maps. See the limp-cbc package for a simple external solver.

A fast, SMP parallel random data generator To generate 10G of high quality pseudorandom data, using 4 processors to fill the file: $ randomgen data 10 +RTS -N4

PostgreSQL SQL syntax utilities

Enables let-binding and let-expansion for https://github.com/aisamanra/s-cargot defined S-expressions

[Index] For package maintainers and hackage trustees

Tired of accidentally calling length on tuples? Relief at last!

tiny utility for collapsing adjacent writes

Geodetic calculations including Vincenty and Great Circle using a Latitude and Longitude pair [Index] Choose the new, split-up base package. Use -f <flag> to enable a flag, or -f -<flag> to disable that flag. More info For package maintainers and hackage trustees

Core components of "strelka"

PLY is a lightweight file format for representing 3D geometry. The library includes support for placing mesh data into a consistent coordinate frame using Stanford's .conf file format. See The Stanford 3D Scanning Repository http://graphics.stanford.edu/data/3Dscanrep/ for more information. This package provides a library for loading PLY data, and an executable, ply2bin, for dumping all vertex data referenced by a .conf file to a flat binary file comprising an array of single precision float triples. Usage: ply2bin confFile outputFile.

ByteStrings as type synonyms of Storable Vectors of Word8s

Simple helper to generate and parse Mac OS X plist format. Currently it supports only xml1 format. It is based on Haskell XML Toolbox. See http://developer.apple.com/mac/library/documentation/Darwin/Reference/ManPages/man5/plist.5.html for details about plist format.

Deprecated in favor of layers WARNING: THIS PACKAGE IS EVIL. DO NOT USE IT! It is common when defining a monad transformer to define instances for that transformer for each class in the mtl library, to allow easy composition with the existing standard monad transformers. However, doing this is very tedious, and actually unnecessary, given that most of these instances across different transformers are identical, and can actually be expressed purely in terms of MonadTrans, or MonadTransControl (from the monad-control package) for the more complicated classes. The reason this is not generally done is because it requires the OverlappingInstances extension, which is generally considered evil. However, it does actually work. If you define a monad transformer, and instances for MonadTrans and MonadTransControl, and import Control.Monad.Instances.Overlapping, your monad transformer will magically have sensible instances for all the mtl type classes. And if you don't like one of the instances provided, you can always define your own instance, which will override the "default" one provided by this package, because by the rules for OverlappingInstances, your instance is more "specific" than the one exported by Control.Monad.Instances.Overlapping. The main disadvantage of this is that errors in code using OverlappingInstances can result in some really strange error messages that are not very helpful. The reason this is evil is because this places an additional burden (of dealing with confusing error messages) not just on those who use this package directly, but anybody who indirectly uses any code that, somewhere down the line, imported Control.Monad.Instances.Overlapping, due to the "viral" nature of instances. Also, if another person were to make a package very similar to this one, and somebody ended up importing both code that used this package, and code that used the other package, than neither of them would work anymore. This is the problem with orphan instances. If you absolutely insist on using this code, you should probably define manual instances for the mtl classes the hard way as well, to avoid this kind of breakage (thus defeating the purpose of this package). Of course, realistically, this package is for everyone who wishes to ignore all such advice and do bad things anyway (including myself). This is my gift to you!

Catchy combinators for HUnit: https://github.com/sol/hspec-expectations#readme

WAI based library for web api

[Index] For package maintainers and hackage trustees

Data structures for describing changes to other data structures. In this library, a patch is something which can be applied, analogous to a function, and which distinguishes returning the argument it was provided from returning something else.

Combine multiple Quivers into one. Useful when merging values from multiple source.

An optional add-on to the diagrams-cairo package which allows rendering diagrams directly to GTK windows.

Find declarations.

Web frontend for managing sproxy. See https:hackage.haskell.orgpackagesproxy

This package introduces split and replace like functions using PCRE regexps.

command-line HUD for your git repo

time-recurrence is a library for generating recurring dates. It is based on the iCalendar spec (RFC 5545). However it makes no attempt to strictly follow the spec.

A CellRenderer instance that allows for arbitrary Cairo rendering functions to render each item in a TreeView.

Bridge between pipe and iteratee paradigms

Declarative command-line parser with type-driven pattern matching.

Separated Time module from HQuantlib

A library for monads with constraints over the types they contain

[Index] For package maintainers and hackage trustees

RELP (Reliable Event Logging Protocol) server implementation

ZipFold is a small package zipping folds, as described in a collection of blog posts, http://conal.net/blog/tag/zip, inspired by a post by Max Rabkin http://squing.blogspot.com/2008/11/beautiful-folding.html. Project wiki page: http://haskell.org/haskellwiki/ZipFold © 2008 by Conal Elliott; BSD3 license.

[Index] For package maintainers and hackage trustees

urbit-api is a Haskell library that helps you connect to the Urbit API. Built on req, conduit, and aeson for stability and simplicity.

Dynamic configurable warp HTTP server

An implementation of multi-prompt delimited continuations based on the paper, A Monadic Framework for Delimited Continuations, by R. Kent Dybvig, Simon Peyton Jones and Amr Sabry (http://www.cs.indiana.edu/~sabry/papers/monadicDC.pdf). It also includes a corresponding implementation of dynamically scoped variables, as implemented in the paper, Delimited Dynamic Binding, by Oleg Kiselyov, Chung-chieh Shan and Amr Sabry (http://okmij.org/ftp/papers/DDBinding.pdf), adapted from the original haskell code, (http://okmij.org/ftp/packages/DBplusDC.tar.gz).

Comonads.

[Index] For package maintainers and hackage trustees

Please see README.md.

Provides an interface for converting any object that has a Binary instance to and from a base-32 Text representation.

Webmachine-style REST library for scotty inspired by cowboy

A Nomic game in Haskell, with a dedicated language to create new rules. Nomyx is a fabulous and strange game where you have the right to change the rules in the middle of the game! Indeed, changing the rules is the goal of the game. Changing a rule is considered as a move. Of course even that could be changed!

Network server library to handle over 10,000 connections. Since GHC 6.12 or earlier uses select(), it cannot handle connections over 1,024. This library uses the prefork technique to get over the barrier. Programs complied by GHC 6.10 or earlier with the -threaded option kill the IO thread when forkProcess is used. So, don't specify the -threaded option to use this library.

Pretty printing for Generic value. For more detail, please refer to https://github.com/tanakh/generic-pretty.

A Haskell implementation of semibounded lattices

Please see the README on GitLab at https://gitlab.com/igrep/deriveJsonNoPrefix#readme

This package provides a partial binding to the Win32 System Services API. It makes it easy to write Windows service applications using Haskell. _Only 32-bit versions of GHC are supported at this time._ The binding is partial. Here are a few ways in which it differs from the official API: Only services running within their own process are supported. These are processes of the WIN32_OWN_PROCESS type. In cases where multiple versions of the same function exist (for compatibility), this binding only offers one of them. None of the extended control codes are supported. Handlers you write will automatically report this to the operating system when such controls are received. Only facilities for writing services are supported; not controlling them. Effort has been made to simplify using the API without hiding what is happening behind the scenes. Users are encouraged to read Microsoft's documentation under 'Dev Center - Desktop > Docs > Desktop app development documentation > System Services > Services'. The official example has been ported to Haskell. This can be found in the examples directory of the source tree. Simple Example and Usage Execute the following from an elevated command prompt to register the service: The service can now be started and stopped from the services console. Installation Notes: Depending on which version of Windows and the Windows SDK you are using the .cabal file will need to be modified before installing. A simple `cabal install Win32-services` may not work. For example, If you are building on Windows 8 64-bit with the Windows 8 SDK the extra-lib-dirs field will need to be changed to read as follows:

Parse the Yesod routes data structure and generate routes that can be used with Flow.

Locale-stuff

Extends safer-file-handles with ByteString operations

text-json-qq provides json quasiquatation for Haskell. This package expose the function jsonQQ that compile time converts json code into a Text.JSON.JSValue. jsonQQ got the signature Consult documentation in the module Text.JSON.QQ.

An older binary serialization library used by a number of projects. For new projects consider an alternative such as binary.

Gipeda is a a tool that presents data from your program’s benchmark suite (or any other source), with nice tables and shiny graphs. So it is up to you whether you have a polling shell script loop, a post-commit hook or an elaborate jenkins setup. As long as the performance data ends up in the logs/ directory, gipeda is happy. Gipeda produces static pages. In fact, the (single) html file and the accompanying JavaScript code is completely static. Giepda just generates a large number of json files. This has the advantage of easy deployment: Just put gipeda in your webspace or copy the files to some static web hosting and you are done. This puts very little load on your server, is cache-friendly and has no security problems. Do you want to see it live? Check out these: Demo page, visualizing fairly boring stuff about gipedia itself: http://nomeata.github.io/gipeda/ GHC’s gipeda installation: https://perf.haskell.org/

This library is a conversion of GHC's internal Common Subexpression Elimination pass for Core to a compiler plugin. See the included test for an example of how to enable it.

A simple command based code editor being developed for the mouse-free workflow.

Binary manipulation modules

Simple Workpools

GF, Grammatical Framework, is a programming language for multilingual grammar applications. GF grammars are compiled into Portable Grammar Format (PGF) which can be used with the PGF runtime, written in C. This package provides Haskell bindings to that runtime.

Run and interact with system processes from within a Reflex FRP application. https://reflex-frp.org

The goal of this library is to simplify implementation and use of state-space estimation algorithms, such as Kalman Filters. The interface for constructing models is isolated as much as possible from the specifics of a given algorithm, so swapping out a Kalman Filter for a Bayesian Particle Filter should involve a minimum of effort. This implementation is designed to support symbolic types, such as from sbv or ivory. As a result you can generate code in another language, such as C, from a model written using this package; or run static analyses on your model. Also included is a sophisticated sensor fusion example in Numeric.Estimator.Model.SensorFusion, which may be useful in its own right.

A library for working with URLs.

TagSoup is a library for parsing HTML/XML. It supports the HTML 5 specification, and can be used to parse either well-formed XML, or unstructured and malformed HTML from the web. The library also provides useful functions to extract information from an HTML document, making it ideal for screen-scraping. Users should start from the Text.HTML.TagSoup module.

SIMD (Single Instruction Multiple Data) CPU instructions provide a simple and fast way to parallelize numeric computations. GHC 7.8 provides primops that let us access these instructions. This package wraps thos primops in a more user friendly form. The github repository contains an example usage of the library and runtime performance graphs. The README.md file there is the best place to start, then check the examples folder, then this haddock documentation.

A combinator library for asynchronous waitfree computation among forkIO threads.

See README.

Lenses for zlib