Makes it easy to write Mathematica packages in Haskell. Just write some functions and provide a package specification in a simple DSL that mimics that of Mathematica's mprep utility. Data marshaling is accomplished via the MLGet and MLPut classes, which specify types that that can be read from or written to the MathLink connection. Instances of these classes are provided for the obvious standard data types, including tuples, lists, and UArrays. A Haskell function that is to be exposed to Mathematica has the type signature (MLGet a, MLPut b) => a -> ML b. The ML monad provides single-threaded access to the MathLink connection. A simple example of a Mathematica package:

Arithmetic circuits for zkSNARKs

Please see the README on Github at https://github.com/masterdezign/rc#readme

Convenient wrapper over xrandr for setting up monitors

A library of extra functions for the standard Haskell libraries. Most functions are simple additions, filling out missing functionality. A few functions are available in later versions of GHC, but this package makes them available back to GHC 7.2. The module Extra documents all functions provided by this library. Modules such as Data.List.Extra provide extra functions over Data.List and also reexport Data.List. Users are recommended to replace Data.List imports with Data.List.Extra if they need the extra functionality.

Without operation transform - WOOT.

This library provides the same functionality as the bitcoin-tx command line utility, which was introduced in Bitcoin Core v0.10. These functions are pure and require no communication with a bitcoin daemon.

Most data types in the haskell platform do not have Lift instances. This package provides orphan instances for containers, text, bytestring and vector. It also provides compat instances for older versions of template-haskell Note that th-lift package provides Template Haskell based derivation of Lift instances (when you cannot use DeriveLift extension), and th-orphans package provides instances for TH datatypes.

This is a library for reading ARPA n-gram models.

A program to learn how to implement basic text editing functionality with wxHaskell. It's not useful itself, the point is to read the code and learn from it ;) The program is divided in 6 steps, each one corresponding to a window and a haskell module. Each step includes what was learnt in the previous one, so Step6 is an almost complete basic text editor.

Functions to convert between tuples and HLists, overloaded on tuple size.

This is an FRP wrapper for SDL using Elerea.

This package gives access to certain POSIX-based Filepath/Directory services. The package is not supported under Windows (except under Cygwin).

Use the generic representation of an ADT to get a higher-kinded data-style interface automatically.

Simplified interface to the GHC API

The Edge has always been a rough patch of interstellar space filled with innumerable bad guys of every nefarious sort, and dangerous debris flying in every direction at high speeds. But now it has grown out of control and is threatening to overflow into colonial space. Central command has decided to send in their newest super weapon, the Mark II Lance fighter, piloted by their top ace pilot. Good luck commander!

[Index] For package maintainers and hackage trustees Num instance for Applicatives provided via the ANum newtype

HSX (Haskell Source with XML) allows literal XML syntax in Haskell source code. The trhsx preprocessor translates .hsx source files into ordinary .hs files. Literal XML syntax is translated into function calls for creating XML values of the appropriate forms. trhsx transforms literal XML syntax into a series of function calls. Any project can make use of the syntax by providing definitions for those functions, and the XML values produced will be of the types specified. This works for any types, since trhsx doesn't make any assumptions, or inserts any information depending on types. XMLGenerator defines a few typeclasses that together cover the functions injected by the preprocessor. A project that uses these classes to provide the semantics for the injected syntax will be able to use any functions written in terms of these, allowing better code reusability than if each project defines its own semantics for the XML syntax. Also, the classes makes it possible to use the literal syntax at different types within the same module. Achieving that is not as simple as it may seem, but the XMLGenerator module provides all the necessary machinery.

See README for details.

Please see the README on Github at https://github.com/evuez/slate#readme

A .authinfo querier

The OptDir type for representing optimization directions (i.e. minimization and maximization).

The monad provided in this package provides an easy way to implement servers and clients which exchange messages (types which are instances of Data.Binary.Binary) over ZeroMQ sockets. This is heavily based on the Control.Monad.BinaryProtocol package by Gregory Crosswhite.

Lifted versions of functions provided in System.Directory, System.Environment and others. User can derive instances for EitherT, ErrorT, MaybeT, etc.

A multi expression programming implementation with focus on speed. https://en.wikipedia.org/wiki/Multi_expression_programming

Tiny, declarative wrapper around ncurses

The supermonad library adds support for supermonads to GHC using a type checker plugin. Plugins are available from GHC 7.10 onwards. The base library containing the Haskell representation of super monads is also given by this package. Supermonads provide a unified representation of several monadic generalizations to remove the need for manual disambiguation between these notions and allow sharing of common functions between them. Additional information can be found in the README.

Parse ARFF files

Parse and display time according to some RFC's. Supported: RFC822 http://www.ietf.org/rfc/rfc0822.txt RFC2822 http://www.ietf.org/rfc/rfc2822.txt RFC3339 http://www.ietf.org/rfc/rfc3339.txt Special thanks to Koral for all the suggestions and help in solving some bugs.

An efficient packed, immutable Unicode text type (both strict and lazy), with a powerful loop fusion optimization framework. The Text type represents Unicode character strings, in a time and space-efficient manner. This package provides text processing capabilities that are optimized for performance critical use, both in terms of large data quantities and high speed. The Text type provides character-encoding, type-safe case conversion via whole-string case conversion functions (see Data.Text). It also provides a range of functions for converting Text values to and from ByteStrings, using several standard encodings (see Data.Text.Encoding). Efficient locale-sensitive support for text IO is also supported (see Data.Text.IO). These modules are intended to be imported qualified, to avoid name clashes with Prelude functions, e.g. To use an extended and very rich family of functions for working with Unicode text (including normalization, regular expressions, non-standard encodings, text breaking, and locales), see the text-icu package based on the well-respected and liberally licensed ICU library. Currently the text library uses UTF-16 as its internal representation which is neither a fixed-width nor always the most dense representation for Unicode text. We're currently investigating the feasibility of changing Text's internal representation to UTF-8 and if you need such a Text type right now you might be interested in using the spin-off packages text-utf8 and text-short.

A library that loops forever on an IO action, but executing no more than a certain number of times each period.

Deprecated

An MTL-style monad that can be used to perform requests. Using RequestT simplifies writing generic middleware.

Convert a Text object into a visually pleasant URL component.

The only command-line tool lets you search based on word patterns or line patterns like never before! Not only can you search with 'only -l patt' but you can select the n-th match with '-l n/patt/' and the next 3 lines with '-l /patt/0:3'.

simple-actors is an EDSL-style library for writing more structured concurrent programs, based on the Actor Model. Computations are structured as Behaviors which take a single input value, perform some Actions, and return the Behavior to process the next input message it receives. We also extend the strict actor model in various elegant ways. See source for this type of discussion. CHANGES: 0.3.0 - 0.4 extend Control.Concurrent.Actors.spawn to transparently support joined mailboxes, i.e. join-patterns, supporting synchronization between actors. Control.Concurrent.Actors.spawn becomes polymorphic in new Control.Concurrent.Actors.Sources class old spawn_ subsumed by polymorphic spawn, with () send and other send-like functions restricted to Mailboxes, use out to convert arbitrary chans to Mailboxes productMb, faninMb, and fanoutMb renamed Control.Concurrent.Actors.contraProduct, Control.Concurrent.Actors.contraFanin, and Control.Concurrent.Actors.contraFanout, and given more general types old spawnReading removed

Deprecated in favor of bson-generic This package offers easy conversion from and to BSON data type for most of user defined data types.

A container that always has no values - and the missing values can belong to any type

High level bindings to the LZ4 compression library. Currently based on lz4 r119. C sources are included and no external dependencies are needed other than cereal.

A simple Haskell program to provide tags for Haskell code completion in TextMate

Tiger compiler

The binary-conduit package. Allow binary serialization using iterative conduit interface.

Native Fast Fourier Transform and Inverse Fast Fourier Transform for vector, with minimal dependencies.

This library provides Hakyll compiler to automatically hyphenate each word in HTML output with Unicode SOFT-HYPHEN characters. It understands HTML markup and doesn't try, for example, to hyphenate tag names and attributes. It uses hyphenation package to do actual work of splitting words.

Type-safe LaTeX EDSL in Haskell

Preassembled tasty TestTrees for property testing Lenses, Setters, Traversals, Isos and Prisms laws.

This is a prototype implementation of the idea presented in Combining Syntactic and Semantic Bidirectionalization by Janis Voigtlaender, Zhenjiang Hu, Kazutaka Matsuda and Meng Wang. This package builds two executables to experiment with the system, a command line program "b18-combined" and a CGI based web interface "b18n-combined-cgi". The latter is also available online at http://www.kb.ecei.tohoku.ac.jp/~kztk/b18n-combined/

Manage multiple turned-based sessions

Convert stack.yaml files into Nix build instructions.

The goal of this package is to distribute the standard Time Zone Database in a cabal package, so that it can be used in Haskell programs uniformly on all platforms. This package currently ships the 2020d version of the time zone database. The version of the time zone database shipped is always reflected in the version of this package: x.y.YYYYMMDD.z, then YYYYMMDD is the official release date of time zone database. This version contains the "fat" variant of the time zone files (which is not the default for the upstream since 2020b) to facilitate the transition. The next minor version (0.3) will ship the "slim" variant. See: http://www.iana.org/time-zones for more info about the time zone database. See also the tz package http://hackage.haskell.org/package/tz or the timezone-olson and timezone-series packages that provide facilities to use the data shipped here. (The tz package automatically installs this package.)

Lexer and parser for Fortran roughly supporting standards from FORTRAN 77 to Fortran 2003 (but with some patches and rough edges). Also includes language extension support for units-of-measure typing.

[Index] For package maintainers and hackage trustees

It based on Data.Dynamic and tree container, so that Gene can represent both haskell functions and syntax trees by type connstructors. since it also supports higher order functions by multiple way type parsing, there's no need to have any variable in Gene's Tree structure. take a look at module AI.Heukarya.Center first AI.Heukarya.Gene : Abstract Gene manipulation and Typeclass for implementing data types under tree structure AI.Heukarya.Jungle : Operating Collections of Gene AI.Heukarya.Center : Module which wraps main functionality for library using AI.Heukarya.Gene.Dynamic : one of Gene's implementation. since it's impossible to save checkpoints if using Data.Dynamic directly, a symbolic wrapper around dynamic is provied inside AI.Heukarya.Gene.Dynamic.Double : a sample geneList of operators of Double precision numbers

A pure Haskell implementation of the Tokyo Tyrant binary protocol. Tokyo Tyrant is a database server for the Tokyo Cabinet database library. http://tokyocabinet.sourceforge.net/tyrantdoc/

An IRC client library built atop irc-conduit. Why another IRC client library, you cry? I didn't really find one that did what I wanted (specifically, handle connecting to servers and calling event handlers, possibly with TLS), but which didn't implement almost a full IRC bot for you. That takes out all the fun! irc-conduit and irc-ctcp are my solution to the first part of that, this is my solution to the latter. It's a simple IRC client library that does the basics for you, but isn't an all-singing, all-dancing, fully-featured IRC application. It is a merely a simple library.

Compatibility layer for "json-ast" and "QuickCheck"

We represent the target language itself as an ideal monad supplied by the user, and provide a Scope monad transformer for introducing bound variables in user supplied terms. Users supply a Monad and Traversable instance, and we traverse to find free variables, and use the Monad to perform substitution that avoids bound variables. Slides describing and motivating this approach to name binding are available online at: http://www.slideshare.net/ekmett/bound-making-de-bruijn-succ-less The goal of this package is to make it as easy as possible to deal with name binding without forcing an awkward monadic style on the user. With generalized de Bruijn term you can lift whole trees instead of just applying succ to individual variables, weakening the all variables bound by a scope and greatly speeding up instantiation. By giving binders more structure we permit easy simultaneous substitution and further speed up instantiation.

A better performance, lazy, powerful replacement of Text.Regex and JRegex

Pixela (https://pixe.la/) client library.

Monadic Javascript Compiler.

You can find documentation at hackage

Prisms for haskell-src-exts

公司邮件协作系统

Haskell type conversions, another one.

An extensible library of elliptic curves used in cryptography research

This command-line utility is meant to be used by people maintaining Nix expressions that fetch files from Git repositories. It automates the process of keeping such expressions up-to-date with the latest upstream sources.

cassava-embed helps to embed CSV-file using TemplateHaskell.

Provides Template Haskell functions that mimic deriving extensions that were introduced or modified in recent versions of GHC. Currently, the following typeclasses/extensions are covered: Deriving Bounded Deriving Enum Deriving Ix Deriving Eq, Eq1, and Eq2 Deriving Ord, Ord1, and Ord2 Deriving Read, Read1, and Read2 Deriving Show, Show1, and Show2 GeneralizedNewtypeDeriving (with GHC 8.2 or later) DerivingVia (with GHC 8.2 or later) See the Data.Deriving module for a full list of backported changes. Note that some recent GHC typeclasses/extensions are not covered by this package: DeriveGeneric, which was introducted in GHC 7.2 for deriving Generic instances, and modified in GHC 7.6 to allow derivation of Generic1 instances. Use Generics.Deriving.TH from generic-deriving to derive Generic(1) using Template Haskell. DeriveLift, which was introduced in GHC 8.0 for deriving Lift instances. Use Language.Haskell.TH.Lift from th-lift to derive Lift using Template Haskell. The Bifunctor typeclass, which was introduced in GHC 7.10, as well as the Bifoldable and Bitraversable typeclasses, which were introduced in GHC 8.2. Use Data.Bifunctor.TH from bifunctors to derive these typeclasses using Template Haskell.

Auto-generate final encodings and their isomorphisms using Template Haskell

[Index] For package maintainers and hackage trustees

Haskell test framework for Tests defined by Search Using Golden Answer References

An imperative integer set written in Haskell. Read https://deliquus.com/posts/2018-07-30-imperative-programming-in-haskell.html for more information.

A library for communicating with RTorrent over its XML-RPC interface.

Creation and application of polyvariadic functions, see the docs for usage and examples

vector-space provides classes and generic operations for vector spaces and affine spaces. It also defines a type of infinite towers of generalized derivatives. A generalized derivative is a linear transformation rather than one of the common concrete representations (scalars, vectors, matrices, ...). Warning: this package depends on type families working fairly well, requiring GHC version at least 6.9. Project wiki page: http://haskell.org/haskellwiki/vector-space © 2008-2012 by Conal Elliott; BSD3 license.

This library provides a way to use Google API for server to server applications.

IPRoute instances and utility functions for use with Persistent

It can also generate a timbre for the notes. Uses SoX inside.

Haskell WebAssembly Toolkit

Application for managing playlist files on a music player

A desktop bar using WebKit for rendering as much as possible. Based on Taffybar.

Framework for accessing DynamoDB database. The majority of AWS API is available to the user in a convenient, simple and typesafe manner.

A YQL engine that provides a Haskell backbone library for the YQL specification, and a Javascript host environment to execute Open Data Tables.

This package provides a nix-diff executable which explains why two Nix derivations (i.e. *.drv files) differ

Haskell bindings to the Google Static Maps API

Please see README.md

A business-quality formatting package with reified formats for multiple data types

A Haskell chatbot framework

chart-unit is a native haskell charting library designed: as a chart DSL and algebra towards a minimalist look and feel to provide a set of default values that are robust across different data and physical chart scales around provision of a small but core set of chart types. See chart-unit for a chart gallery. [Index] For package maintainers and hackage trustees

Working with MIME types.

A Nock interpreter. From the shell, simply pipe Nock expressions into the hnock executable: For playing around in GHCi, import the Nock library and use hnock to parse and evaluate Nock expressions: To evaluate raw nock Nouns, i.e. to compute nock(a) for some noun a, use the nock function:

A pragmatic alternative Prelude for Haskell

yesod-test-json provides combinators for using the hspec and wai-test libraries together. It is meant to be used like yesod-test, but for web services as opposed to web applications.

Clash is a functional hardware description language that borrows both its syntax and semantics from the functional programming language Haskell. The Clash compiler transforms these high-level descriptions to low-level synthesizable VHDL, Verilog, or SystemVerilog. Features of Clash: Strongly typed, but with a very high degree of type inference, enabling both safe and fast prototyping using concise descriptions. Interactive REPL: load your designs in an interpreter and easily test all your component without needing to setup a test bench. Higher-order functions, with type inference, result in designs that are fully parametric by default. Synchronous sequential circuit design based on streams of values, called Signals, lead to natural descriptions of feedback loops. Support for multiple clock domains, with type safe clock domain crossing. This package provides: Prelude library containing datatypes and functions for circuit design To use the library: Import Clash.Prelude Alternatively, if you want to explicitly route clock and reset ports, for more straightforward multi-clock designs, you can import the Clash.Explicit.Prelude module. Note that you should not import Clash.Prelude and Clash.Explicit.Prelude at the same time as they have overlapping definitions. A preliminary version of a tutorial can be found in Clash.Tutorial, for a general overview of the library you should however check out Clash.Prelude. Some circuit examples can be found in Clash.Examples.

Tile/lonlat conversion utilities for slippy maps.