Package candidates

Here follow all the candidate package versions on Hackage. [upload]

AFSM: 0.1.0.0. Arrowized functional state machines. This module is inspired by Yampa and the paper /Functional Reactive Programming, Continued*/ written by Henrik Nilsson, Antony Courtney and John Peterson.
Agda: 2.5.1. Agda is a dependently typed functional programming language: It has inductive families, which are similar to Haskell's GADTs, but they can be indexed by values and not just types. It also has parameterised modules, mixfix operators, Unicode characters, and an interactive Emacs interface (the type checker can assist in the development of your code). Agda is also a proof assistant: It is an interactive system for writing and checking proofs. Agda is based on intuitionistic type theory, a foundational system for constructive mathematics developed by the Swedish logician Per Martin-Löf. It has many similarities with other proof assistants based on dependent types, such as Coq, Epigram and NuPRL. This package includes both a command-line program (agda) and an Emacs mode. If you want to use the Emacs mode you can set it up by running @agda-mode setup@ (see the README). Note that the Agda library does not follow the package versioning policy, because it is not intended to be used by third-party packages.
AlgorithmW: 0.1.0.0. Complete implementation of the classic algorithm W for Hindley-Milner polymorphic type inference in Haskell.
ArrowVHDL: 1.0. This software is intended to help a developer designing electronic circuits by describing them with arrows. The arrow notation represents the according. From the netlist the developer can generate various other formats by "compiling" the arrow into them. With this software three basic compilers are shipped. One generates a simple textual representation that helps debugging the actual circuit. Another generates VHDL representations of the circuit. The third one generates DOT syntax for visualization of circuits.
BNFC: 2.7.0.0, 2.8. The BNF Converter is a compiler construction tool generating a compiler front-end from a Labelled BNF grammar. It was originally written to generate Haskell, but starting from Version 2.0, it can also be used for generating Java, C++, and C. Given a Labelled BNF grammar the tool produces: an abstract syntax as a Haskell/C++/C module or Java directory, a case skeleton for the abstract syntax in the same language, an Alex, JLex, or Flex lexer generator file, a Happy, CUP, or Bison parser generator file, a pretty-printer as a Haskell/Java/C++/C module, a Latex file containing a readable specification of the language.
BNFC-meta: 0.4.0.2, 0.4.0.3. This package provides a very simple way of defining a compiler front-end for a language by embedding a BNF grammar directly into a Haskell source file. Specifically, given a quasi-quoted LBNF grammar (as used by the BNF Converter) it generates (using Template Haskell) a LALR parser and pretty pretty printer for the language. The parser is then used to automatically define a quasi-quoter for the defined language so it can also be seamlessly embedded in Haskell source code. With a simple addition to the gramwmar, the user can define a universal syntax for anti-quoting. This means that any grammar non-terminal can be replaced by a quoted Haskell expression of the appropriate type. A few example languages are included in the source tarball. The LBNF grammar formalism is described thoroughly in the BNF Converter documentation: <http://bnfc.digitalgrammars.com/> This library and the additions it makes to LBNF is described in a 2011 Haskell Symposium paper titled \"Embedded Parser Generators\": <http://wiki.portal.chalmers.se/cse/pmwiki.php/FP/EmbeddedParserGenerators>
Bang: 0.1.0.4, 0.1.0.5. This library consists of a DSL for piecing together drum compositions. It uses a MIDI backend and is only currently available for use on Mac OSX. Much of the library was inspired by previous work done by Yale's @<http://haskell.cs.yale.edu/euterpea/ Euterpea>@ project and Paul Hudak\'s @<http://cpsc.yale.edu/sites/default/files/files/tr1259.pdf paper>@.
BiGUL: 0.9.0.0. Putback-based bidirectional programming allows the programmer to write only one putback transformation, from which the unique corresponding forward transformation is derived for free. BiGUL, short for the Bidirectional Generic Update Language, is designed to be a minimalist putback-based bidirectional programming language. BiGUL was originally developed in the dependently typed programming language Agda, and its well-behavedness has been completely formally verified; this package is the Haskell port of BiGUL. For more detail, see the following paper: * Hsiang-Shang Ko, Tao Zan, and Zhenjiang Hu. BiGUL: A formally verified core language for putback-based bidirectional programming. In /Partial Evaluation and Program Manipulation/, PEPM’16, pages 61–72. ACM, 2016. <http://dx.doi.org/10.1145/2847538.2847544>.
BlastHTTP: 1.0.0, 1.0.1. Searches for a provided nucleotide or protein sequence with the NCBI Blast REST service and returns a blast result in xml format as BlastResult datatype. For more information on BLAST refer to: <http://blast.ncbi.nlm.nih.gov/Blast.cgi>. Information on the webservice can be found at: <http://www.ncbi.nlm.nih.gov/BLAST/developer.shtml>. If you plan to submit more than 20 searches in one session, please look up the Usage Guidelines in the webservice information.
BufferedSocket: 0.2.1.0. The idea of a "BufferedSocket" is that reading from a network socket should be really easy and handy. BufferedSockets is an attempt to do just that whilst beeing space-time efficient. Having "in app" buffers also makes it easy for the buffered socket to read data without taking the data out of the buffer thus giving us the ability to look for patterns and read exess data without having to "take out of the reading queue".
CC-delcont: 0.2.1.0. 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>).
CPL: 0.0.7. An interpreter of Hagino's Categorical Programming Language (CPL).
Cabal: 1.23.1.0, 1.24.0.0. The Haskell Common Architecture for Building Applications and Libraries: a framework defining a common interface for authors to more easily build their Haskell applications in a portable way. The Haskell Cabal is part of a larger infrastructure for distributing, organizing, and cataloging Haskell libraries and tools.
Cabal-solver: 0.
CarneadesDSL: 1.2, 1.3. An implementation and domain specific language for the Carneades argumentation model. See "Haskell Gets Argumentative" in the Proceedings of Symposium on Trends in Functional Programming (TFP 2012) by Bas van Gijzel and Henrik Nilsson or the package's homepage. Thanks to Stefan Sabev for providing initial code for the cyclicity check.
CarneadesIntoDung: 0.9, 1.0. A translation from the Carneades argumentation model (<http://hackage.haskell.org/package/CarneadesDSL>) into Dung's argumentation frameworks (<http://hackage.haskell.org/package/Dung>). This package provides a translation function and correspondence properties. For the papers accompanying this library see \"Towards a framework for the implementation and verification of translations between argumentation models\" and \"A principled approach to the implementation of argumentation models\", available at <http://www.cs.nott.ac.uk/~bmv/CarneadesIntoDung/>.
Chart: 1.1. A library for generating 2D Charts and Plots, based upon the cairo graphics library.
ClustalParser: 1.0.0, 1.0.1, 1.0.3. Currently contains parsers and datatypes for: clustalw2, clustalo For more information on clustal Tools refer to <http://www.clustal.org/> ClustalW2 is a general purpose DNA or protein multiple sequence alignment program for three or more sequences. Clustal Omega is a new multiple sequence alignment program that uses seeded guide trees and HMM profile-profile techniques to generate alignments between three or more sequences.
ComonadSheet: 0.3.0.0. @ComonadSheet@ is a library for expressing spreadsheet-like computations with absolute and relative references, using fixed-points of n-dimensional comonads. For examples of use, see the <https://github.com/kwf/ComonadSheet GitHub page> for the library.
Concurrent-Cache: 0.1.0.0. This package allows for caching IO functions, either on a timeout or designed to only fetch once.
Condor: 0.1, 0.2, 0.3. An Information Retrieval (IR) library which consists of the following components: * Search - for indexing and searching text documents. Check "Condor.Search.Index" for API information * Readers for reading documents from disk. Check "Condor.Reader.Text" folder text reader.
CoreErlang: 0.0.3. Facilities for manipulating Core Erlang source code: an abstract syntax, parser and pretty-printer.
DCFL: 0.1.0.0. A serialized and centralized implementation of Communication Free Learning, a technique used to solve Constraint Satisfcation Problems (CSPs) in a parallelizable manner.
DPutils: 0.0.0.2. Small set of utility functions
Decimal: 0.4.1. A decimal number has an integer mantissa and a negative exponent. The exponent can be interpreted as the number of decimal places in the value.
Dish: 0.0.0.1. A group of Hash related utilities (currently wraps MurmurHash3 C implementation)
Dung: 1.0, 1.0.0.1. An implementation of Dung's argumentation frameworks, an abstract argumentation model used to either directly represent conflicting information, or used as a translation target for more complex (structured) argumentation models. For an introduction to Dung's frameworks see <http://en.wikipedia.org/wiki/Argumentation_framework> and Dung's paper from 1995: \"On the acceptability of arguments and its fundamental role in nonmonotonic reasoning, logic programming, and n-person games\", Artificial Intelligence 77: 321-357. For the papers accompanying this library see \"Towards a framework for the implementation and verification of translations between argumentation models\" and \"A principled approach to the implementation of argumentation models\", available at <http://www.cs.nott.ac.uk/~bmv/Dung/>.
Dust: 2.2, 2.2.1. Dust is a polymorphic protocol engine designed to circumvent Internet filtering based on protocol identification
DynamicTimeWarp: 0.1.1.0.
Earley: 0.6.0. See <https://www.github.com/ollef/Earley> for more information and <https://github.com/ollef/Earley/tree/master/examples> for examples.
EdisonAPI: 1.2.2.1, 1.3, 1.3.1. Edison is a library of purely functional data structures written by Chris Okasaki. It is named after Thomas Alva Edison and for the mnemonic value EDiSon (Efficient Data Structures). Edison provides several families of abstractions, each with multiple implementations. The main abstractions provided by Edison are: Sequences such as stacks, queues, and dequeues; Collections such as sets, bags and heaps; and Associative Collections such as finite maps and priority queues where the priority and element are distinct.
EdisonCore: 1.2.2.1, 1.3, 1.3.1, 1.3.1.1. This package provides the core Edison data structure implementations, including multiple sequence, set, bag, and finite map concrete implementations with various performance characteristics. The implementations in this package have no dependencies other than those commonly bundled with Haskell compilers.
EitherProjections: 0.1.0.0. Permits to handle each side of 'Either' separately. Provides separate ‘Functor’ interfaces for both sides, recombining the result.
EntrezHTTP: 1.0.1. EntrezHTTP provides functions to query the NCBI entrez REST interface. There are multiple different databases and tools, so called eutils, provided by the service. For more information on Entrez refer to: <http://www.ncbi.nlm.nih.gov/gquery/>. Information on the webservice can be found at: <http://www.ncbi.nlm.nih.gov/books/NBK25497/>. If you plan to include the library in a tool, register it as explained <http://www.ncbi.nlm.nih.gov/books/NBK25497/#chapter2.Usage_Guidelines_and_Requiremen here>.
EtaMOO: 0.1.0.0. LambdaMOO is a network-accessible, multi-user, programmable, interactive system well-suited to the construction of text-based adventure games, conferencing systems, and other collaborative software. EtaMOO is an experimental multithreaded implementation of LambdaMOO in Haskell with anticipated ready support for 64-bit MOO integers and Unicode MOO strings. The implementation follows the specifications of the LambdaMOO Programmer's Manual, and should be compatible with most LambdaMOO databases as of about version 1.8.3 of the LambdaMOO server code. /N.B./ This is (currently) incomplete software. It is not yet usable, although with further development it is hoped that it soon will be.
FModExRaw: 0.1.0.0. Haskell FModEx raw API. It’s a 1:1 Haskell binding over the famous C API. For now, I use version 0.0.* for uncomplete API binding. The complete API will be released just in time.
FPretty: 1.1. A pretty printer turns a tree structure into indented text, such that the indentation reflects the tree structure. To keep text short, substructures are put into a single line as far as possible. The library provides combinators for building pretty printers. It emphasizes simplicity and efficiency.
FenwickTree: 0.1.1. Fenwick trees are a O(log N) data structure for updating cumulative sums. This implementation comes with an operation to find a least element for which real-valued cumulative sum reaches certain value, and allows for storage of arbitrary information in the nodes.
ForkableT: 0.1.0.1, 0.1.0.2. Provides two classes for modular handling of forking
GLURaw: 1.4.0.1. 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/>.
GLUT: 2.5.1.1. 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/>.
GPipe-GLFW: 1.0, 1.1. A utility library to enable the use of GLFW as the OpenGL window and context handler for GPipe. GPipe is a typesafe functional API based on the conceptual model of OpenGL, but without the imperative state machine. See the GPipe package and resources for more information.
Genbank: 1.0.0, 1.0.1, 1.0.2, 1.0.3. Haskell cabal Genbank libary contains tools, parser and datastructures for the NCBI (National Center for Biotechnology Information) Genbank format. For more information on genbank refer to: <http://www.ncbi.nlm.nih.gov/genbank/> For a sample genbank record see: <http://www.ncbi.nlm.nih.gov/Sitemap/samplerecord.html> "Bio.GenbankData" - Datastructures for Genbank format Contains Haskell datastructures for Genbank format and for contained features, subfeatures "Bio.GenbankParser" - Parse Genbank format Contains Haskell functions to parse Genbank format from files or internal Strings. "Bio.GenbankTools" - Tools for processing Genbank Contains Haskell functions to extract nucleotide sequences for features
GeocoderOpenCage: 0.1. uses the OpenCage REST API to geocode and reverse geocode
Gifcurry: 0.1.0.0, 0.1.0.1, 0.1.0.2, 0.1.0.3, 0.1.0.4, 0.1.0.5, 0.1.0.6, 0.1.1.0, 2.0.0.0, 2.0.0.2. GIF creation utility.
Guguk: 0.0.0.1.
HDBC-odbc: 2.4.0.0. This package provides an ODBC database backend for HDBC. It is cross-platform and supports unixODBC on Unix/Linux/POSIX platforms and Microsoft ODBC on Windows. It is also the preferred way to access MySQL databases from Haskell.
HDBC-postgresql: 2.3.2.2. This package provides a PostgreSQL driver for HDBC
HEigs: 0.0.1. The aim of this package is to emulate MATLAB and SciPy's 'eigs' routines for finding a small number of eigenvalues from large sparse linear systems. Currently only supports a limited subset of ARPACK's functionality. I plan to add more in the future but if there's a specific type of eigenvalue problem you need solved please email and I'll make supporting that a priority.
HFrequencyQueue: 0.1.0.0. This package provide a queue that use an internal random generator to return a random element. The probability that a certain element come out is controlled by an Int that is the relative probability of that element. IT USE GCC WITH C++11!
HGE2D: 0.1.6.2. See README and examples/ for further information
HSlippyMap: 0.1.0.0, 1.0, 1.2, 1.4, 1.6, 1.8, 2.0, 2.1, 2.2.
HUnit-Plus: 0.3.0. HUnit-Plus is a testing framework for Haskell that builds on the HUnit test framework. HUnit-Plus provides functions and operators for creating assertions and tests similar to those provided by the HUnit framework. Unlike HUnit, HUnit-Plus uses the same data structures as cabal's "Distribution.TestSuite" framework, allowing full compatibility with cabal's testing facilities. HUnit-Plus also provides expanded reporting capabilities, including the ability to generate JUnit-style XML reports, along with a very flexible mechanism for selecting which tests to be executed. Lastly, HUnit-Plus provides a wrapper which generates standalone test-execution programs from a set of test suites.
HaRe: 0.7.0.6, 0.7.0.8, 0.7.0.9, 0.7.1.0, 0.7.1.1, 0.7.1.2, 0.7.1.3, 0.7.1.4, 0.7.1.5, 0.7.1.6, 0.7.1.7, 0.7.2.0, 0.7.2.1, 0.7.2.2, 0.8.3.0. A Haskell 2010 refactoring tool. HaRe supports the full Haskell 2010 standard, through making use of the GHC API. Version 0.7.2.8 supports up to GHC 7.6.3. There is no support for GHC 7.8.x. There will never be support for GHC 7.8.x From version 0.8.0.0, GHC 7.10.2 is supported. From version 0.8.3.0, GHC 8.0.1 is supported. It is tested against GHC 7.10.3 and GHC 8.0.1 (via travis-ci.org) It currently only has emacs integration built in, community input welcome for others. HaRe attempts to operate in a safe way, by first writing new files with proposed changes, and only swapping these with the originals when the change is accepted. In the process the original file is renamed to have the current date/time as a suffix. Thus it should be possible to (manually) undo changes. Even so, it is strongly advised to back up any source files before refactoring, as we can make no promises as to the reliability of this tool. Use at your own risk. At the moment parsing of any file with FFI exports will fail. See Language.Haskell.Refact.HaRe for the current list of refactorings supported
Haggressive: 0.1.0.2, 0.1.0.3. Aggression analysis for Tweets on Twitter
Happstack-session: 0.0.0.1. Serverside sessions for Happstack. Should be used with a storage backend, however the Memory works for testing. See github page for example.
HarmTrace-Base: 1.4.0.1. HarmTrace: Harmony Analysis and Retrieval of Music with Type-level Representations of Abstract Chords Entities We present HarmTrace-Base, a library for parsing and unambiguously representing musical chords.
HaskRel: 0.1.0.0. HaskRel aims to define the elements of the relational theory of database management as first-class Haskell objects, thus enabling Haskell in its own right as a DBMS with first-class support for the relational algebra. It does not qualify as a proper RDBMS since it as-is only defines the relational algebra, relational variables and relational assignment. It does not define the relational calculus, views, constraints and transactions (beyond the fundamental requirement that the tuples of relations are to be unique), certain operators like relation valued aggregate operators, nor a few minor or even deprecated operators such as DIVIDE. The implemented parts are decently complete even if there are major implementation shortcomings that prevent this from being practically usable as an actual DBMS. I refer to it as "/first-class/" since the types of the relational model are first-class types to Haskell, and the Haskell type system is able to induce the type resulting of relational expressions (for instance that a natural join of two relations results in a relation with a heading that is the setwise union of the headings of the original relations). == Model HaskRel is based on the relational model of database management, as defined by Chris Date and Hugh Darwen today. Is is not based on SQL in any way. SQL and Relational Theory, 2nd ed. [1] has been the principal guide in this endeavor (I have plenty of SQL in my background so a book on SQL and the relational model has been a good introduction to the latter). See also The Third Manifesto [2], and the additional material on http://www.thethirdmanifesto.com/ (this might be better to start with for those mathematically inclined but not steeped in SQL). In addition to naming certain other aspects of Tutorial D has been adopted, such as argument order. Such aspects may be changed in the future if HaskRel is found to be solid enough to stand on its own, particularly if there are ways to express this that are more idiomatic vis-a-vis Haskell (Tutorial D is, after all, not a definition of the relational model, but vehicle for understanding it). == Implementation HaskRel is developed and tested with GHC 7.10.2. It builds upon HList (at least version 0.4.0.0). Separately from this library there is also an optional variant that builds on TIPs instead of records, which additionally relies on Lens (tested with version 4.12.3). = Examples The examples in this documentation are based on "the old warhorse" that is the suppliers-parts database (see [1] for more). This gives a body of relational expressions with known results to base examples upon. See also examples\/SuppliersPartsExamples.hs (not visible from this documentation) for Haskell versions of a selection of the Tutorial D expressions given as examples in chapters 6 and 7 of [1]. These can be run by starting examples\/suppliersPartsDB.sh and then running @snrt2ndExamples@. While most Tutorial D expressions translate fairly verbatim to Haskell there are a few where one must be a bit more explicit. While most Tutorial D expressions translate fairly verbatim to Haskell there are a few where Haskell is stricter than Tutorial D and one must be a bit more explicit. $ is always used after `p`\/`rPrint` or `pt`\/`rPrintTyped` in the examples to keep them uniform (and so it kinda looks like a prompt), even when not required. The short forms `p` and `pt` are used whenever there isn't a conflict with other identifiers, whereas for the SuppliersPartsExample, which has a relvar "@p@", `rPrint` is used instead of `p` for presentation of relational objects without type information. = Terminology Since this builds on both Haskell and relational theory this documentation uses terms as they have been established in material related to either. Several terms of Haskell and HList have been redefined in terms of relational theory in this library, mostly to illustrate how terms and concepts have been mapped from the latter to the former. (I'm trying to keep this open to change later if it turns out to be an unhelpful crutch.) The following table gives a quick overview of either terms or concepts as found in Haskell, the relational model (as presented in [1]), HaskRel and SQL, and how they are mapped from the second to the first: @ ┌───────────────────────────┬────────────────────┬────────────┬────────────────────────────────────────────────┐ │ haskell │ relModel │ haskRel │ sql │ ╞═══════════════════════════╪════════════════════╪════════════╪════════════════════════════════════════════════╡ │ <https://hackage.haskell.org/package/tagged/docs/Data-Tagged.html Data.Tagged.Tagged> │ attribute │ Attr │ field, column │ │ <https://hackage.haskell.org/package/HList/docs/Data-HList-Record.html Data.HList.Record.Record> │ tuple │ RTuple │ row │ │ ( <https://hackage.haskell.org/package/containers/docs/Data-Set.html Set> (<https://hackage.haskell.org/package/HList/docs/Data-HList-Record.html Record> a) ) │ relation │ Relation a │ table │ │ <https://hackage.haskell.org/package/filepath/docs/System-FilePath.html FilePath> (<https://hackage.haskell.org/package/containers/docs/Data-Set.html Set> (<https://hackage.haskell.org/package/HList/docs/Data-HList-Record.html Record> a)) │ relvar │ Relvar a │ table │ │ <https://hackage.haskell.org/package/HList/docs/Data-HList-FakePrelude.html#t:Label Data.HList.Record.Label> │ attribute name │ Label │ field name, column name │ │ <https://hackage.haskell.org/package/HList/docs/Data-HList-Record.html#t:Labels Data.HList.Record.Labels> │ attribute name set │ Labels │ list of field/column names │ │ function, operator │ operator │ function │ operator, function, procedure, routine, method │ └───────────────────────────┴────────────────────┴────────────┴────────────────────────────────────────────────┘ @ Found in "example\/Terminology.hs". Note that this is just an overview, study of [1] or [2], Haskell itself, HList and HaskRel is required to see how terms and concepts correlate. The term \"RTuple\", or "r-tuple", is chosen to simultaneously distinguish the concept from Haskell tuples while relating it to tuples of the relational model. For the type of either "Record a" or "Set ( Record a )" in Haskell the term "heading" is used in relational theory, and "row type" or "composite type" in SQL. In relational theory the term "scalar" is used to refer to data types that are neither tuples nor relations, which corresponds to everything but "Record a" or "Set ( Record a )" in Haskell. Note also that HaskRel /does/ use the term "table", but then only in the sense of "presentation of a relation value" (see above). == The HaskRel library Not all modules of this library are relevant to gain an understanding of how it functions, the next part to go to at this point is "Database.HaskRel.RDBMS", and the modules it reexports. [1] <http://shop.oreilly.com/product/0636920022879.do SQL and Relational Theory, 2nd ed. (2011), C.J. Date> [2] <http://www.dcs.warwick.ac.uk/~hugh/TTM/TTM-2013-02-07.pdf The Third Manifesto, C. J. Date and Hugh Darwen, February 7th, 2013>
HaskellNet: 0.4.1, 0.4.2, 0.4.3, 0.4.4. This package provides client support for the POP3, SMTP, and IMAP protocols. NOTE: this package will be split into smaller, protocol-specific packages in the future.
HaskellNet-SSL: 0.3.3.0. This package ties together the HaskellNet and connection packages to make it easy to open IMAP and SMTP connections over SSL.
Hate: 0.1.4.1, 0.1.4.2. A small 2D game framework.
Hish: 0.0.1. Prompt program for Fish shell written in Haskell
HsOpenSSL-x509-system: 0.1.0.0, 0.1.0.1, 0.1.0.2. A cross-platform library that tries to find a (reasonable) CA certificate bundle that can be used with @HsOpenSSL@ to verify the certificates of remote peers. This package is for @HsOpenSSL@ what @x509-system@ is for the @tls@ package. Additionally, it borrows some ideas from @x509-system@.
Hsmtlib: 0.2.0.6, 2.8.8.8. Hsmtl provides functions to interact with several smt solvers using SMT-LIB 2. The current suported solvers are Alt-Ergo, Cvc4, MathSat, Yices, Z3. Additional solvers can be used if they are SMT-LIB 2 compliant. More information and tutorials can be found in <https://github.com/MfesGA/Hsmtlib>
Irc: 0.1.0.1, 0.1.0.2. Irc is a monadic DSL and library for writing Irc bots. It conveniently utilizes 'do' notation in the style similar to Shake
IsNull: 0.3.0.0. A typeclass to determine if a given foldable type (or other) is empty ~ null ~ invalid. The definition is intentionally vague, to cover types from Either to Text and Sets.
JustParse: 2.0. A simple and comprehensive Haskell parsing library
KSP: 0.1. This library is intended to help the haskell affine ksp player to calculations within the ksp universe.
Kriens: 0.1.0.0, 0.1.0.1. Provides a type for Continuation Passing Style development
LambdaShell: 0.9.3. The lambda shell is a feature-rich shell environment and command-line tool for evaluating terms of the pure, untyped lambda calculus. The Lambda Shell builds on the shell creation framework Shellac, and showcases most of Shellac's features.
Lambdajudge: 0.1.0.0, 1.0.0.0. A library to easily host Haskell based programming competitions
LibZip: 1.0.1. libzip is a C library for reading, creating, and modifying zip archives. This package allows to use it from Haskell code.
List: 0.5.2. A List monad transformer and a List class. With standard list operations for Lists
MASMGen: 0.1.0.0. Please see README.md
MRoute: 0.1.0.0. Simple matrix routing HTTP API.
MagicHaskeller: 0.9.6.5. MagicHaskeller is an inductive functional programming system for Haskell. This package contains the MagicHaskeller library, which can be used within GHCi or as an API for inductive program synthesis. It also contains the MagicHaskeller executable that is a standalone synthesis program which can be used interactively or as a backend server, and the MagicHaskeller.cgi executable that is a CGI frontend for providing the Web interface.
MailchimpSimple: 0.1.0.0, 0.2.0.0. This package contains the basic functions supported by Mailchimp JSON API. For HTTP Authentication, it uses Basic HTTP Authentication.
MetaHDBC: 0.1.4. Using Template Haskell and HDBC to do statically checked database access.
MissingH: 1.3.0.2. MissingH is a library of all sorts of utility functions for Haskell programmers. It is written in pure Haskell and thus should be extremely portable and easy to use.
MyPrimes: 0.1.0.0.
NTRU: 0.1.0.0, 1.0.0.0. A Haskell implementation of the NTRU cryptographic system, following the IEEE Standard Specification for Public Key Crpytographic Techniques Based on Hard Problems over Lattices (IEEE Std 1363.1-2008)
NestedFunctor: 0.2.0.1. This package implements something akin to 'Data.Compose', but with a type index that tracks the order in which things are nested. This makes it possible to write code using polymorphic recursion over the levels of the structure contained in a 'Nested' value.
NetSNMP: 0.3.1.0, 0.3.2.0. Network.Protocol.NetSNMP is a partial binding to the library portion of the net-snmp package. It uses the 'single-session api', which is claimed to be thread-safe. Not all operations are supported yet; please contact the maintainer if you're in need of expanded functionality, and especially if you would like to contribute.
NumberTheory: 0.1.0.1. This is a toy library that implements number theoretic functions in Z, Z mod m, the Gaussian Integers, some combinatorics functions, and functions for manipulating continued fractions.
Nutri: 0.1. This is the start of a library that helps to calculate with nutrition values of food items. There is a basic datatype for weight information and one for the nutrient information of food. One can combine variouse foods together and let the library calculate the overall protein, carbohydrate and fat percentages as well as the caloric value.
Object: 1.0. Read the homepage or Object.Example for more information.
Obsidian: 0.4.0.0. Obsidian is an embedded language for general purpose programming targeting GPU's.
Octree: 0.5.2. Octree data structure is relatively shallow data structure for space partitioning.
Omega: 1.0.3. Sets of integer tuples and relations on integer tuples. Sets and relations are represented compactly by storing their characteristic function as a Presburger arithmetic formula. Formulae are simplified and solved by the Omega Library. The primary interface can be found in "Data.Presburger.Omega.Set" and "Data.Presburger.Omega.Rel".
OpenCLWrappers: 0.1.0.3. Light opencl wrappers, a fork of the OpenCLRaw package.
OpenGL: 2.9.2.0. A Haskell binding for the OpenGL graphics system (GL, version 4.4) and its accompanying utility library (GLU, version 1.3). 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/>.
OpenGLRaw: 1.5.0.0. OpenGLRaw is a raw Haskell binding for the OpenGL 3.2 graphics system and lots of OpenGL extensions. It is basically a 1:1 mapping of OpenGL's C API, intended as a basis for a nicer interface. OpenGLRaw offers access to all necessary functions, tokens and types plus a general facility for loading extension entries. The module hierarchy closely mirrors the naming structure of the OpenGL extensions, making it easy to find the right module to import. All API entries are loaded dynamically, so no special C header files are needed for building this package. If an API entry is not found at runtime, a userError is thrown. 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/>.
OpenVG: 0.7.0. A Haskell binding for the OpenVG vector graphics API version 1.0.1, specifically the ShivaVG-0.2.1 implementation. This version (0.7.0) should be compatible with the Haskell Platform (2013.2.0.0). \*\* WARNING - large parts of the API (particular the Paths module) are untested and may be revised in future. \*\*. Changelog 0.6.0 to 0.7.0 * Updated to work with GHC 7.6 and Platform 2013.2.0.0. * Updated Windows install instructions. 0.5.0 to 0.6.0 * Added an opaque matrix type to RenderingQuality. Acknowledgement - this was derived from the Matrix class in HOpenGL. * Revised Image module - PixelData is now an opaque type rather than a raw pointer. * Work on Path module - pathBounds implemented. This module is entirely untested and may change again in the future.
OpenVGRaw: 0.4.0. A raw Haskell binding to OpenVG vector graphics API version 1.0.1, specifically the ShivaVG-0.2.1 implementation. Following Sven Panne\'s OpenGL model this is essentially a 1:1 mapping between the OpenVG C API and Haskell and is expected to be used in concert with the higher-level @OpenVG@ pacakge. Detailed install instructions for Windows (MinGW/MSYS) are included in the @OpenVG@ package. Changelog v0.3.0 to v0.4.0 * Re-fixed imports to work with GHC 7.6. Seemingly I missed uploading V0.3.0 to Hackage in August 2012. v0.2.0 to v0.3.0 * Fixed imports v0.1.0 to v0.2.0 * Changed type of vgGetMatrix
OrchestrateDB: 1.0.0.0. An implementation of most of the functions of the Orchestrate.io REST API in Haskell. To get started, see the documentation for the Orchestrate and Orchestrate.REST module below. Because this module does use 'Data.Aeson' for parsing and encoding JSON you might want to take a look at it's docs too. For some working examples check out the "examples/Test.hs" file and the documentation.
OrderedBits: 0.0.1.1. This library provides efficient methods to enumerate all elements of a set in order of the population count, or the ordered enumerations of the elements of the powerset of a set. First, the empty set, then all 1-element sets, all 2-element sets, etc. Such enumerations are important for algorithms over unordered data sets. Examples include the travelling salesman problem and the closely related Hamiltonian path problem.
PPrinter: 0.0.1, 0.0.2, 0.0.4. A library that supports deriving of pretty printing functions on data types. The interfaces of pretty printer used are based on that introduced in the paper: Philip Wadler, A Prettier Printer, The Fun of Programming, Cornerstones of Computing (2003): 223-243. <http://homepages.inf.ed.ac.uk/wadler/papers/prettier/prettier.pdf original paper> The form of generic feature used is based on that introduced in the paper: Magalhaes, et al., A Generic Deriving Mechanism for Haskell, 3'rd ACM Symposium on Haskell, pp. 37-48, September 2010, <http://dx.doi.org/10.1145/1863523.1863529>. The necessary information of implementation of GHC.Generics is described here: <https://hackage.haskell.org/package/base-4.9.0.0/docs/GHC-Generics.html#g:1>. The implementation of deriving part of API is based on that designed in the library: GenericPretty, the details are introduced here: <https://hackage.haskell.org/package/GenericPretty>
PTQ: 0.0.6, 0.0.7. An implementation of Montague's PTQ (Proper Treatment of Quantification). It translates simple plain English sentences into formulas of intentional logic.
PUH-Project: 0.1.0.0.
Parry: 0.1.0.0. Parry is a scheduler for the exhaustive exploration of tree-like spaces. It is designed to be robust to client crashes and cluster walltimes, and is guaranteed to never \"forget about\" a job until it is done.
ParserFunction: 0.0.1, 0.1.0. Parse and evaluate mathematical expressions.
PasswordGenerator: 0.1.0.0. Simple library for generating passwords.
PeanoWitnesses: 0.1.0.0. Witnesses for Peano naturals are unary natural numbers paired with a natural number type index. These terms act as witnesses of a particular natural; we can recover the type information by examining the terms.
Prelude: 0. placeholder - talk to hackage admin/trusteess if you want to claim this package name
PrimitiveArray: 0.5.2.0, 0.7.1.0. <http://www.bioinf.uni-leipzig.de/Software/gADP/ generalized Algebraic Dynamic Programming> This library provides efficient multidimensional arrays. Import @Data.PrimitiveArray@ for indices, lenses, and arrays. For <http://www.bioinf.uni-leipzig.de/Software/gADP/ generalized ADP> users, the library also provides the machinary to fill tables in the correct order required by usual CYK-style parsers, or regular grammars (used e.g. in alignment algorithms). This means that unless your grammar require a strange order in which parsing is to be performed, it will mostly "just work". In general all operations are (highly) unsafe, no bounds-checking or other sanity-checking is performed. Operations are aimed toward efficiency as much as possible.
QuadTree: 0.10.1, 0.11.0. The purpose of this package is to provide discrete region quadtrees that can be used as effective functional alternatives to 2D arrays, with lens support.
Quelea: 1.0.0. Quelea is a Haskell library that helps programmers develop highly scalable applications on the top of eventually consistent NoSQL stores, such as Cassandra. You can think of Quelea as a mediator between the application programmer and the underlying NoSQL store. It understands both the application requirements and the store semantics, and helps programmers use NoSQL stores in such a way so as to maximize performance and ensure correct application behaviour, both at the same time! Among other things, Quelea library implements: A Domain-Specific Language (DSL) that lets NoSQL application programmers declare the consistency requirements of their applications as contracts (also called specifications) A static contract classification procedure that maps high-level application contracts to appropriate low-level consistency guarantees provided by the underlying NoSQL store, and A run-time that runs application operations after tuning the store consistency to appropriate levels as determined by the contract classification procedure. While the implementations of DSL and the static contract classification components are largely independent of the actual NoSQL store used, the current implementation of run-time component is tailor-made to work with the Cassandra data store.
QuickCheckVariant: 0.1.0.0, 0.1.0.3, 0.1.0.4, 0.1.1.0. Generator of "valid" and "invalid" data in a type class
RFC1751: 0.1.0.0, 0.2.0.0, 0.3.0.0, 0.3.0.1. Convert 128-bit ByteString to/from 12 English words.
RNAlien: 1.0.0. RNAlien is a tool for automatic construction of RNAfamily models from a single sequence. It is available as a commandline tool, for testing or construction of few sequences the webservice can be used. The source code of RNAlien, as well as the webserver is open source and available via GitHub (License GPL-3): * <https://github.com/eggzilla/RNAlien RNAlien> * <https://github.com/eggzilla/AlienServer AlienServer> TaxonomyTools which can be used to visualise the organisms included in a RNAlien result can be found here (License GPL-3): * <https://github.com/eggzilla/TaxonomyTools TaxonomyTools-Github> * <https://hackage.haskell.org/package/Taxonomy TaxonomyTools-Hackage> For instruction how to use RNAlien please see the <http://rna.tbi.univie.ac.at/rnalien/help Help page>. Dependencies: * <http://infernal.janelia.org/ Infernal> * <http://www.clustal.org/omega/#Download clustal-omega> * <http://www.bioinf.uni-freiburg.de/Software/LocARNA/#download Locarna> * <https://www.tbi.univie.ac.at/~wash/RNAz/ RNAz> * <http://www.tbi.univie.ac.at/RNA/index.html#download ViennaRNA package> Installation via cabal-install: > cabal install RNAlien
RandomNumber: 0.1.0.0. Please see README.md
Rasenschach: 0.1.2, 0.1.3. Soccer simulation with simple graphics and highly configurable AI
Redmine: 0.0.1, 0.0.7. Library to access Redmine's REST services
Referees: 0.0.0. A utility for computing distributions of material to review among reviewers. @Referees@ takes into consideration the areas of expertise of the referees, the number of items that they accept for review, the languages they understand, and the minimum and maximum number of copies we may want to distribute per each item to review.
RepLib: 0.5.4. Generic programming library providing structural polymorphism and other features.
SConfig: 0.1.0.0, 0.1.0.1. A simple config library.
SGplus: 1.1. Updated original SG to work with modern GHC. A small geometry library for dealing with vectors, points, lines, simple shapes, and their various intersection tests. See also the SGdemo project (<http://hackage.haskell.org/cgi-bin/hackage-scripts/package/SGdemo>) for an example of using the module.
STL: 0.1.0.0, 0.2, 0.2.0.1, 0.3.0.1. STL is a simple file format for representing 3D objects as the triangles which form their surface. It is common in 3D printing workflows. This library provides parsing and serialization to and from both text and binary STL formats.
ShellCheck: 0.3.0, 0.3.1. The goals of ShellCheck are: * To point out and clarify typical beginner's syntax issues, that causes a shell to give cryptic error messages. * To point out and clarify typical intermediate level semantic problems, that causes a shell to behave strangely and counter-intuitively. * To point out subtle caveats, corner cases and pitfalls, that may cause an advanced user's otherwise working script to fail under future circumstances.
Shellac: 0.9.5.2, 0.9.9. Shellac is a framework for building read-eval-print style shells. Shells are created by declaratively defining a set of shell commands and an evaluation function. Shellac supports multiple shell backends, including a 'basic' backend which uses only Haskell IO primitives and a full featured 'readline' backend based on the the Haskell readline bindings found in the standard libraries. This library attempts to allow users to write shells at a high level and still enjoy the advanced features that may be available from a powerful line editing package like readline.
Shellac-compatline: 0.9.5.2, 0.9.9. This package provides a Shellac backend which acts a thin interface for the Shellac-readline or Shellac-editline packages, depending on avaliability. Note that this package may be compiled against readline, which is licended under the GPL.
Shellac-editline: 0.9.5.2, 0.9.9. This package provides a Shellac backend based on the editline library. editline provides a subset of the functionality provided by the GNU readline library. However, it is licenced with a BSD-style license and is therefore suitable for some situations where GNU readline is not. This backend features all the line editing capabilities provided by editline.
Shellac-haskeline: 0.2.1. This module provides a backend for Shellac using the Haskeline library. It provides rich line editing capabilities, command completion and command history features.
Shellac-readline: 0.9.5.2, 0.9.9. This package provides a Shellac backend based on the GNU readline library. This backend features all the line editing capabilities provided by readline, as well as command completion and command history features.
Stasis: 0.0.1. Multi-version concurrency control
StateVar-transformer: 1.0.0.0. StateVar with monad transformer
Strafunski-StrategyLib: 5.0.0.5. This is a version of the StrategyLib library originally shipped with Strafunski, Cabalized and updated to newer versions of GHC. A description of much of StrategyLib can be found in the paper "Design Patterns for Functional Strategic Programming."
StrappedTemplates: 0.1.0.0, 0.1.1.0. Easy templating in haskell. > import Control.Monad.IO.Class > import qualified Blaze.ByteString.Builder as B > import qualified Data.Text.Lazy as T > import Data.Time > > import Text.Strapped > > makeBucket :: Integer -> InputBucket IO > makeBucket i = bucketFromList > [ ("is", List $ map (LitVal . LitInteger) [1..i]) > , ("is_truthy", LitVal $ LitInteger i) > , ("ioTime", Func (\_ -> (liftIO $ getCurrentTime) >>= (\c -> return $ LitText $ T.pack $ show c))) > ] > > main :: IO () > main = do > tmpls <- templateStoreFromDirectory "examples/templates" ".strp" > case tmpls of > Left err -> print err > Right store -> do > rendered <- render (putStore store defaultConfig) (makeBucket 2) "base_simple.strp" > either (print) (print . B.toByteString) rendered @  {$ inherits base.strp $}    {$ isblock body $}    An IO function to find the current time: ${ ioTime }    {$ if is_truthy $}   {$ inherits base.strp $}   {$ isblock body $}   Any block level can inherit from another template and override blocks.   {$ endisblock $}  {$ else $}   Don't show me.  {$ endif $}    Taken from an includes:  {$ include includes/includes.strp $}    Lets count...  {$ for i in is $}   ${ i }  {$ endfor $}    {$ endisblock $} @
TBit: 0.4.2.0. TBit provides tools for parameterizing and computing condensed matter physics quantities based on tight-binding models. It provides utitilies for computing Chern numbers and Berry curvatures of electronic band structure, generating gnuplot-readable dispersion plots, and calculating assorted quantities such as orbital magnetization and Nernst conductivity.
THEff: 0.1.0.1, 0.1.1.0. This package implements effects, as alternative to monad transformers. Actually, the effects themselves are created without the use of TH, but the binding of nested effects described by mkEff splice. For example. > mkEff "MyReader" ''Reader ''Int ''Lift > mkEff "SomeState" ''State ''Bool ''MyReader > mkEff "OtherRdr" ''Reader ''Float ''SomeState > > main:: IO () > main = do > r <- runMyReader 100 > $ runSomeState False > $ runOtherRdr pi $ do > i :: Int <- ask -- MyReader > f :: Float <- ask -- OtherRdr > b <- get -- SomeState > put $ not b -- SomeState > lift $ putStrLn "print from effect!" -- Lift > return $ show $ fromIntegral i * f > print r For more information about extensible effects , see the original paper at <http://okmij.org/ftp/Haskell/extensible/exteff.pdf>. But, this package is significantly different from the original. It uses a chains of ordinary GADTs created by TH. No Typeable, unsafe... , ExistentialQuantification ...
Tahin: 0.1.2. Please see README.md
Tainted: 0.0.1. Tainted type, and associated operations
Tape: 0.4.0.0. This module implements two-way infinite streams with a focused element, akin to a Turing machine's tape. This structure is also known by the name of a list zipper (although in this case it's a list zipper with the additional criterion that the list is infinite in both directions).
Thriftier: 0.0.1.0. `Thriftier` is a command-line tool which wraps a bit of Apache Thrift and makes it a bit easier to use. NOTE: This package isn't even alpha yet. You probably don't want to use it.
Tic-Tac-Toe: 0.1.0.0. Bored, tired, or just need a break? Play a quick game of tic tac toe against your computer in the command line!
UTFTConverter: 0.1.0.1. /About:/ This package was created because I could not find a tool that can be used on UNIX systems to parse a picture into an array of 'RGB565' values and save them to a '.c' or '.raw' file. Both formats are used by the <http://www.rinkydinkelectronics.com/library.php?id=51 UTFT library> to display pictures on to a TFT display. This package includes, but not limited to, an executable which is made to be as identical as possible to the corresponding tool that is also downloaded with the <http://www.rinkydinkelectronics.com/library.php?id=51 UTFT library>. /Usage:/ > ./UTFTConverter <filespec> /c|r [/o <path>] [/t AVR|ARM|PIC32] > > <filespec>: File(s) to convert > parameters: /c - Create output as .c array files > /r - Create output as .raw files > /o <path> - Set the output directory to <path> > /t <platform> - Select target plaform > AVR : Most Arduinos, Bobuion > ARM : Arduino Due, Teensy, TI CC3200 LaunchPad > PIC32 : All chipKit boards > > You must specify either /c or /r. All other parameters are optional. > If /o is ommited the current directory will be used for output. > If /t is ommited the target platform will be set to AVR.' /Supported formats:/ The binary tests if the pictures are encoded correctly via magic bytes using <http://hackage.haskell.org/package/image-type ImageType>. If the extention is wrong, but the encoding is correct, it will still try to convert the picture. The exported library is using <http://hackage.haskell.org/package/JuicyPixels JuicyPixels> to convert incoming * '.gif' * '.png' * '.jpg' \/\ '.jpe' \/\ '.jpeg' * '.bmp' * '.tga' and translates every pixel to a 'RGB565' format, which is a 4 digit hex number. /Library:/ The only really reusable library is the 'Format.RGB565'. It support the conversion from * 'RGB' to 'RGB565' as ('Word8', 'Word8', 'Word8') -> 'Int' * 'Int' to 'Hex' as 'Int' -> 'String' /Example usage:/ > >>> toRGB565 (0, 0, 255) > 31 > >>> toRGB565Hex (0, 0, 255) > "001F" > >>> toHex 100 > 64 > >>> toNHex 6 100 > "0064"
Updater: 0.1, 0.2, 0.3. Read the homepage for more information.
VKHS: 1.7.1. Provides access to Vkontakte API methods. Library requires no interaction with the user during Implicit-flow authentication.
Vec: 1.0.5. Vectors are represented by lists with type-encoded lengths. The constructor is @:.@, which acts like a cons both at the value and type levels, with @()@ taking the place of nil. So @x:.y:.z:.()@ is a 3d vector. The library provides a set of common list-like functions (map, fold, etc) for working with vectors. Built up from these functions are a small but useful set of linear algebra operations: matrix multiplication, determinants, solving linear systems, inverting matrices.
ViennaRNAParser: 1.2.7. Currently contains parsers and datatypes for: RNAalifold, RNAcode, RNAdistance, RNAcofold, RNAfold, RNAplex, RNAup, RNAz. For more information on the ViennaRNA package refer to <http://www.tbi.univie.ac.at/RNA/>. The libary is tested with Version 2.1.9 of the ViennaRNA package.
WMSigner: 0.1.0.0. Pure haskell implementation WMSigner authentication module. Simple examples: > import Data.Digest.Webmoney > > signer = newSigner (exponent :: [Word8) (modulus :: [Word8]) > > main = do > putStrLn $ signUnsafe signer "message" -- static version > sign signer "message" >>= putStrLn -- randomized version
Weather: 0.1.0.0, 0.1.0.1, 0.1.0.2, 0.1.0.3, 0.1.0.4. Weather is a simple library for interacting with the Weather Underground JSON API. It is not complete, but it may be useful still.
WeberLogic: 0.1.0.0, 0.1.1, 0.1.2. Logic interpreter
Wheb: 0.0.1.1, 0.2.0.0, 0.2.1.0. Wheb's a framework for building robust, high-concurrency web applications simply and effectively. * The core datatype will let you build anything from a read-only server to a fully interactive web application with basic Haskell. * Minimal boilerplate to start your application. * Named routes and URL generation (though it was a trade-off between named and type-safe urls). * Easy to use for REST APIs * Fully database and template agnostic * Easy handler debugging. * Middleware * Fast. It deploys on warp. /Plugins:/ Wheb makes it easy to write plugins. Plugins can add routes, middlware, settings and even handle resource cleanup on server shutdown. Named routes allow plugins to dynamically generate their routes at runtime based on settings. Examples of plugins: * Sessions * Auth * <http://hackage.haskell.org/package/wheb-mongo Wheb-Mongo> /Wheb in action:/ > import Web.Wheb > import Data.Text.Lazy (pack) > > main :: IO () > main = do > opts <- genMinOpts $ do > addGET "home" rootPat $ (text (pack "Hi!")) > addGET "about" ("about" </> "something") $ html (pack "<html><body><h1>About!</h1></body></html>") > runWhebServer opts /Bigger example (Stateful.hs):/ Wheb makes it easy to share a global context and handle requests statefully. The Wheb monad is both a Reader and a State Monad allowing you to seperate thread-safe resources. Below is an example of site that naively counts the non-unique hits across all pages. MyApp is our Reader's type and MyHandlerData is our State's type. MyApp is shared across requests while MyHandlerData is thread specific with a starting state given in options. We have a middleware that intercepts the request, safely increments the shared resource TVar and sets our MyHandlerData to the correct count before it reaches our handler. We use a TVar in the Global context because any state changes to the handler state will not affect other requests. > import Control.Concurrent.STM > import Control.Monad.IO.Class > import Data.Monoid > import Data.Text.Lazy (Text, pack) > import Web.Wheb > > data MyApp = MyApp Text (TVar Int) > data MyHandlerData = MyHandlerData Int > > counterMw :: MonadIO m => WhebMiddleware MyApp MyHandlerData m > counterMw = do > (MyApp _ ctr) <- getApp > number <- liftIO $ atomically $ do > num <- readTVar ctr > writeTVar ctr (succ num) > return num > putHandlerState (MyHandlerData number) > return Nothing > > homePage :: WhebHandler MyApp MyHandlerData > homePage = do > (MyApp appName _) <- getApp > (MyHandlerData num) <- getHandlerState > html $ ("<h1>Welcome to" <> appName <> > "</h1><h2>You are visitor #" <> (spack num) <> "</h2>") > > main :: IO () > main = do > opts <- generateOptions $ do > startingCounter <- liftIO $ newTVarIO 0 > addWhebMiddleware counterMw > addGET (pack ".") rootPat $ homePage > return $ (MyApp "AwesomeApp" startingCounter, MyHandlerData 0) > runWhebServer opts
Win32-dhcp-server: 0.3.2. This package provides a partial binding to the Win32 DHCP Server Management API. Its purpose is to query and control a Microsoft DHCP server. Enough functionality is defined so so that Ipv4 client lease and reservation records can be manipulated programmatically._Only 32-bit versions of GHC are supported at this time._ Here are a few notes on the required environment: * Only 32-bit executables are supported. This is mainly because pointers are assumed to be 4 bytes wide in a few places. Support for 64-bit executables may be added in the future. * All library calls should be supported on Windows 7 or above. /Simple Example and Usage/ @ \-\- Print all MAC addresses with an active client lease module Main where import Data.Ip import Data.Mac import qualified Data.Text.IO as T import System.Win32.DHCP main :: IO () main = do   api <- loadDHCP   clients <- enumClients api context   let macs = map (showMac \":\" . clientHardwareAddress) clients   mapM_ T.putStrLn macs   where   Right subnet = readIp \"192.168.1.0\"   context = Context \"192.168.1.5\" subnet @
Win32-security: 0.1. This package contains bindings for security-related functions of the Windows API. Its main features are account name/SID lookup and editing securable objects access control lists.
Wordlint: 0.2.1.0. Wordlint locates matching pairs of words repeated within a user-defined distance. Text may be linted by distance between words (that is, by word count), by line count, and/or by percentage of the total words in the file. For details on running the program, see README or the included man page. Internally, Wordlint separates a text file (or stdin) into a list of "Words", after processing user flags. An instance of the "Word" datatype consisting of a String that contains a lemma; its line and column coordinates; and its "position": an Int or Float depending on the type of check invoked by the user. This list is first filtered by the user-defined minimum length of the lemma. Next, items are matched by their lemma and exclusive coordinates before being added to a list of "Wordpairs", a data structure containing two Words and the difference between their respective "positions". If multiple types are specified, all Int positions are converted to the Double type and the resulting lists are intersected to produce the final results. Finally, these Wordpairs are optionally filtered by the difference in their positions (another user-specified option). All remaining Wordpairs are processed for printing to stdout in machine-readable (default) or human-readable format. Plugins exist for integration with Vim (https:\/\/github.com\/gbgar\/Wordlint.vim) and Emacs (https:\/\/github.com\/gbgar\/wordlint.el).
XSaiga: 1.0.0.0. This package contains a Haskell implementation of the X-SAIGA project’s parser combinators. The combinators enable fully-general attribute grammars to be implemented as executable specifications. Although the parser is top-down, and therefore highly modular, left-recursive productions are allowed and fully-general synthesized and inherited attribute dependencies are also allowed. The parse tree, which is decorated with attribute values, is built as a compact Tomita-style graph. Lazy evaluation enables attribute values to be evaluated only as needed. Time and space complexity are both O(n^4) where n is the length of the input. An example natural-language interface (called Solarman) to a semantic-web style RDF triplestore with approximately 3,000 facts about the solar system has been built as an executable specification of an attribute grammar. Solarman is included in this archive. Solarman computes answers to queries using an event-based denotational semantics which is based on Montague and Davidsonian semantics. A web site [4] has been created so that readers can enter queries and find out more about Solarman. \[2] <http://cs.uwindsor.ca/~richard/PUBLICATIONS/PADL_08.pdf> \[1] <http://cs.uwindsor.ca/~richard/PUBLICATIONS/PADL_10.pdf> \[3] <http://cs.uwindsor.ca/~richard/PUBLICATIONS/ESWC_DEMO.pdf> \[4] <http://speechweb2.cs.uwindsor.ca/solarman/demo_instore.html>
Xorshift128Plus: 0.1.0.0, 0.1.0.1. This package contains pure haskell implementation of xorshift128+ random number generator which is extremely fast. The random number generator's inner state is just 128bit memory block so that which is not encapusulated for simplicity. Please see <http://xorshift.di.unimi.it/xorshift128plus.c original C implementation> and <http://xorshift.di.unimi.it/ comparison of other algorithms>.
Zora: 1.1.6. A library of assorted useful functions and data types and classes.
abcBridge: 0.10.0.0, 0.11, 0.12, 0.14, 0.15. Bindings for ABC focused on creating And-Inverter Graphs (AIG) and then performing synthesis and equivalence checking.
abnf: 0.1.0.0. You can use this library to parse an ABNF document and generate a parser from that ABNF to read a document described by the ABNF.
accelerate-typelits: 0.1.0.0. a small wrapper plus convenience functions on top of accelerate to represent matrices with their dimensions
acid-state-dist: 0.1.0.0.
acme-basic: 0.1.0.0.
acme-cadre: 0.1. Powerful and compositional tuple processing, informed by classic functional programming principles.
acme-cutegirl: 0.1.0.0. A package which exists solely to try and give the user a cute girl. Executable and library are both available.
acme-everything: 2015.4.15, 2015.4.15.1, 2015.5.4, 2015.5.4.1. This package requires the entirety of Hackage to be built. The joke started when a colleague liked the @leftToMaybe :: Either a b -> Maybe a@ function from @either@, which has a *huge* footprint compared to the utility it provides. This got us thinking about seemingly small packages that have lots of hidden transitive dependencies, e.g. "only" @base@, @lens@ and @yesod@. And that's where `acme-everything` was born, which (transitively) depends on the entirety of Hackage.
acme-iot: 0.1.0.0. IO transformer capable of adding IO capabilities to any monad.
acme-left-pad: 3.0. free your haskell from the tyranny of npm!
acme-memorandom: 0.0.1, 0.0.2, 0.0.3. A library for generating random numbers in a memoized manner. Implemented as a lazy table indexed by serialized 'StdGen'. Monomorphism is used to facilitate memoization, users should adapt their design to work with random 'Int' values only. In a benchmark, the initial generation of 100000 random 'Int's took 10.30 seconds and consumed 2.5 gigabytes of memory. Generating the 100000 'Int's again from the same seed only took 2.06 seconds, a 5-fold speedup thanks to memoization! Incidentally, generating the 100000 'Int's with the non-memoized function took 0.12 seconds, but that of course lacks all the benefits of memoization.
acme-one: 0.0.1, 0.0.2. <https://www.haskell.org/cabal/users-guide/developing-packages.html Cabal> package dependencies form a commutative monoid with an absorbing element. They satisfy the following axioms: [Associativity] For all dependencies @a@, @b@ and @c@, @ (a , b) , c = a , (b , c) @ In fact, the Cabal syntax does not even allow you to use the parentheses for this reason. [Commutativity] For all dependencies @a@ and @b@, @ a , b = b , a @ [Identity element] For all dependencies @a@, @ acme-one , a = a a , acme-one = a @ Depending on @<https://hackage.haskell.org/package/acme-one acme-one>@ has no additional effect. [Absorbing element] For all dependencies @a@, @ acme-zero , a = acme-zero a , acme-zero = acme-zero @ Depending on @<https://hackage.haskell.org/package/acme-zero acme-zero>@ in addition has the same effect as /only/ depending on @acme-zero@.
acme-php: 0.0.4, 0.0.5. At last, a module that combines the dynamic flexibility of Haskell with the strong design principles of PHP!
acme-pointful-numbers: 0.1.2.3. Allows use to write more pointful than usual numbers. Example: @3.14.159@. This is very useful for various obvious undisclosed reasons.
acme-stringly-typed: 1.0.0.0. All the benefits of stringly typed programming at all of the costs.
acme-strtok: 0.1.0.3. This package provides a Haskell version of the strtok function from C/PHP. Successive calls of this function return tokens (delimited by given delimiting characters) from a string (or a list), one by one.
acme-timemachine: 0.0.0.0. When doing some side-effectful computations, one might regret the decision to change the state. This package provides an 'undo' function for such cases, and universe suspension/resuming functions for finer control.
acme-zero: 0.0.1, 0.0.2. <https://www.haskell.org/cabal/users-guide/developing-packages.html Cabal> package dependencies form a commutative monoid with an absorbing element. They satisfy the following axioms: [Associativity] For all dependencies @a@, @b@ and @c@, @ (a , b) , c = a , (b , c) @ In fact, the Cabal syntax does not even allow you to use the parentheses for this reason. [Commutativity] For all dependencies @a@ and @b@, @ a , b = b , a @ [Identity element] For all dependencies @a@, @ acme-one , a = a a , acme-one = a @ Depending on @<https://hackage.haskell.org/package/acme-one acme-one>@ has no additional effect. [Absorbing element] For all dependencies @a@, @ acme-zero , a = acme-zero a , acme-zero = acme-zero @ Depending on @<https://hackage.haskell.org/package/acme-zero acme-zero>@ in addition has the same effect as /only/ depending on @acme-zero@.
active: 0.1.0.14. "Active" abstraction for animated things with finite start and end times.
activitystreams-aeson: 0.2.0.2. An interface to the <http://activitystrea.ms/ Activity Streams> specifications, using an @aeson@-based representation of the underlying ActivityStream structures. An ActivityStream is a representation of social activities in JSON format, using a standard set of structures. The specification is very flexible in allowing most fields to be omitted, while also allowing arbitrary new fields to be created when necessary. This library attempts to maximize type safety while retaining the flexibility present in the specification.
aeson-better-errors: 0.1.0.0, 0.1.0.1, 0.2.0.0, 0.3.0.0, 0.4.0.0, 0.4.0.1. A small package which gives you the tools to build parsers to decode JSON values, and gives good error messages when parsing fails. See also <http://harry.garrood.me/blog/aeson-better-errors/>.
aeson-diff: 0.1.1.1, 0.1.1.2, 0.1.1.3, 1.0.0.0, 1.0.0.1, 1.1.0.0. This is a small library for working with changes to JSON documents. It includes a library and two command-line executables in the style of the diff(1) and patch(1) commands available on many systems.
aeson-filthy: 0.0. A little library of newtypes to help with parsing indiscriminately encoded JSON.
aeson-flatten: 0.1.0.0, 0.1.0.1, 0.1.0.2. Please see README.md
aeson-parsec-picky: 0.1.0.0, 0.1.0.1. JSON parser with nice error messages and little more strict syntax (whitespace-wise).
aeson-prefix: 0.1.0.0. Please see README.md
aeson-schema: 0.4.1.0. This library provides validation of JSON values against schemata. Given a schema, it can also produce data types corresponding to the schema and a parser.
aeson-t: 0.0.0, 0.0.1, 0.0.2. Provides a succinct DSL to transform one JSON document to another.
ai-vs-ai-common: 0.0.3. Common libs for an upcoming AI based game
aig: 0.1.0.0, 0.2, 0.2.1, 0.2.3, 0.2.4. This package provides a generic interfaces for working with And-Inverter graphs (AIGs) in Haskell. And-Inverter graphs are a useful format for representing combinatorial and sequential boolean circuits in a way that is amenable to simulation and analysis. These interfaces allow clients to write code that can create and use AIGs without depending on a particular AIG package.
airship: 0.1.0.0. A Webmachine-inspired HTTP library
aivika: 1.0, 1.1, 1.2, 1.2.1, 1.3, 1.4, 2.0, 2.1, 3.0, 3.1, 4.0, 4.0.1, 4.0.3, 4.1, 4.1.1, 4.2, 4.3, 4.3.1, 4.3.2, 4.3.3, 4.3.4, 4.3.5, 4.5. Aivika is a multi-method simulation library focused on discrete event simulation (DES) with partial support of system dynamics and agent-based modeling. The library has the following features: * allows defining recursive stochastic differential equations of system dynamics (unordered as in maths via the recursive do-notation); * supports the event-driven paradigm of DES as a basic core for implementing other paradigms; * supports extensively the process-oriented paradigm of DES with an ability to resume, suspend and cancel the discontinuous processes; * allows working with the resources based on specified queue strategies (FCFS\/FIFO, LCFS\/LIFO, SIRO, static priorities and so on); * allows customizing the infinite and finite queues based on strategies too; * supports the resource preemption; * allows defining a queue network based on streams of data (transacts) and their processors; * allows simulating circuits with recursive links and delays; * supports the activity-oriented paradigm of DES; * supports basic constructs for the agent-based modeling such as agents, states, timeout and timer handlers; * allows creating combined discrete-continuous models as all parts of the library are well integrated and this is reflected directly in the type system; * the arrays of simulation variables are inherently supported; * supports the Monte-Carlo simulation; * the simulation model can depend on external parameters; * uses extensively signals for notification; * allows gathering statistics in time points; * hides technical details in high-level simulation computations (monads, streams and arrows). Aivika itself is a light-weight engine with minimal dependencies. However, it has additional packages [1, 2] that offer the following features: * automating simulation experiments; * saving the results in CSV files; * plotting the deviation chart by rule 3-sigma, histogram, time series, XY chart; * collecting the summary of statistical data; * parallel execution of the Monte-Carlo simulation; * has an extensible architecture. The charting package has two interchangeable back-ends [3, 4], where one of them uses Cairo and it is more preferable. The PDF documentation and installation instructions are available on the Aivika Wiki website [5]. Moreover, the method was generalized [6] and applied to nested simulation [7] and parallel distributed simulation [8]. The libraries were tested on Linux, Windows and OS X. A more full information about Aivika is available on the project website [9]. \[1] <http://hackage.haskell.org/package/aivika-experiment> \[2] <http://hackage.haskell.org/package/aivika-experiment-chart> \[3] <http://hackage.haskell.org/package/aivika-experiment-cairo> \[4] <http://hackage.haskell.org/package/aivika-experiment-diagrams> \[5] <https://github.com/dsorokin/aivika/wiki> \[6] <http://hackage.haskell.org/package/aivika-transformers> \[7] <http://hackage.haskell.org/package/aivika-branches> \[8] <http://hackage.haskell.org/package/aivika-distributed> \[9] <http://www.aivikasoft.com/en/products/aivika.html> P.S. Aivika is actually a genuine female Mari name which is pronounced with stress on the last syllable.
aivika-branches: 0.1, 0.1.1, 0.1.2, 0.1.3. This package extends the aivika-transformers [1] library with facilities for creating branches to run nested simulations within simulation. For example, it can be useful for financial modeling. \[1] <http://hackage.haskell.org/package/aivika-transformers>
aivika-distributed: 0.1, 0.1.1, 0.1.3, 0.2. This package extends the aivika-transformers [1] package with facilities for running parallel distributed simulations. It uses an optimistic strategy known as the Time Warp method. \[1] <http://hackage.haskell.org/package/aivika-transformers>
aivika-experiment: 1.0, 1.1, 1.3, 1.3.1, 1.4, 2.1, 3.1, 4.0.3. This package allows defining simulation experiments for the Aivika package. Such experiments define in declarative manner what should be simulated and in which view the simulation results should be generated. It can be charts, tables and so on. The library is extensible and you can add new views for the results.
aivika-experiment-cairo: 1.3, 1.3.1, 1.4, 2.1, 3.1, 4.3.1. This package complements the Aivika and Aivika Experiment packages and it allows rendering the charts using the Chart-cairo library.
aivika-experiment-chart: 1.0, 1.1, 1.3, 1.4, 2.1, 3.1, 4.0.3, 4.2, 4.3, 4.3.1, 4.3.2. This package complements the aivika [1] and aivika-experiment [2] 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 [3] or aivika-experiment-diagrams [4]. While the Cairo-based backend suits mostly to Linux and partially OS X, the Diagrams-based backend is mainly destined for MS Windows, although it should work on Linux and OS X too. \[1] <http://hackage.haskell.org/package/aivika> \[2] <http://hackage.haskell.org/package/aivika-experiment> \[3] <http://hackage.haskell.org/package/aivika-experiment-cairo> \[4] <http://hackage.haskell.org/package/aivika-experiment-diagrams>
aivika-experiment-diagrams: 1.3, 1.3.1, 1.4, 2.1, 3.1, 4.3.1. This package complements the Aivika and Aivika Experiment packages and it allows rendering the charts using the Chart-diagrams library, i.e. without using Cairo, which can be suitable for MS Windows.
aivika-lattice: 0.1, 0.1.1. This experimental package extends the aivika-transformers [1] library with facilities for running nested discrete event simulations within lattice nodes. \[1] <http://hackage.haskell.org/package/aivika-transformers>
aivika-transformers: 2.0, 2.1, 4.3.1, 4.3.2, 4.3.3, 4.3.4, 4.3.5, 4.5. This package is a generalization of the aivika [1] simulation library with extensive use of monad transformers and type families. \[1] <http://hackage.haskell.org/package/aivika>
al: 0.1.0.0, 0.1.1.3. OpenAL is a minimalistic sound API that aims to provide bare features for /spacialized audio/. The API looks like the OpenGL one, thus the libs are pretty great together. Up to now, no OpenAL extension is supported. You're highly invited to contribute ;). EAX is not supported yet eiher. It'll be embedded in future releases, soon. IMPORTANT: In order to build and install "al", you'll need to pass the path of the /include/ and /libs/ directory of your OpenAL installation. Then use this to install: @ cabal install --extra-include-dirs=path_to_include --extra-lib-dirs=path_to_libs @
alarmclock: 0.1.0.2, 0.2.0.1. Wake up and perform an action at a certain time.
alex-meta: 0.3.0.6, 0.3.0.7, 0.3.0.8. A Template-Haskell based version of the Alex lexer generator. It is used by BNFC-meta to generate lexers and currently this is the only feature known to be working.
alfred: 0.1. A utility library for writing workflows for Alfred version 2.
all: 0.
ampersand: 3.0.2. You can define your business processes by means of rules, written in Relation Algebra.
amqp-conduit: 0.2.0.0. Conduit bindings for AMQP (see amqp package)
angel: 0.5.0, 0.5.2. @angel@ is a daemon that runs and monitors other processes. It is similar to djb's `daemontools` or the Ruby project `god`. It's goals are to keep a set of services running, and to facilitate the easy configuration and restart of those services. See the homepage for documentation.
angle: 0.8.1.0. An implementation of a small, weak and dynamically typed, interpreted, functional programming language.
annotated-wl-pprint: 0.6.0. This is a modified version of wl-pprint, which was based on Wadler's paper "A Prettier Printer". See the haddocks for full info. This version allows the library user to annotate the text with semantic information, which can later be rendered in a variety of ways.
ansi-wl-pprint: 0.6.7.2. This is a pretty printing library based on Wadler's paper "A Prettier Printer". It has been enhanced with support for ANSI terminal colored output using the ansi-terminal package.
ansigraph: 0.1.0.0. Ansigraph is an ultralightweight terminal-based graphing utility. It uses unicode characters and ANSI escape codes to display and animate colored graphs of vectors/functions in real and complex variables. This functionality is provided by a 'Graphable' type class, whose method 'graphWith' draws a graph at the terminal. Another function 'animateWith' takes a list of Graphable elements and displays an animation by rendering them in sequence. Both of these functions take an options record as an argument. The 'graph' and 'animate' functions are defined to use the default options, and the user can define similar functions based on their own settings. There are two main ways to use the package. Importing "System.Console.Ansigraph" provides all the functionality we typically use. This includes the /FlexibleInstances/ extension, which makes it marginally more convenient to use graphing functions by allowing instances like 'Graphable [Double]'. If you want to use the package without activating /FlexibleInstances/ then you can import "System.Console.Ansigraph.Core", which provides everything except these instances. To graph you must use one of a handful of newtype wrappers, namely: 'Graph', 'PosGraph', 'CGraph', 'Mat', 'CMat'. These wrappers are also available from the standard 'Ansigraph' module. The "System.Console.Ansigraph.Examples" module contains examples of all the graph types with animations of various plane waves, and also shows the available ANSI colors.
ap-reflect: 0.2. The library provides a simple reflection technique, substituting functions like @fmap@ and @\<*\>@ with reflection-aware analogues. This library can be used with <http://hackage.haskell.org/package/simple-reflect simple-reflect package>.
apache-md5: 0.6.0.0, 0.6.1.0, 0.6.1.1, 0.6.1.4. Haskell implementation of Apache HTTP server specific MD5 digest algorithm that uses OpenSSL @MD5()@ function. For usage example see "Data.Digest.ApacheMD5" module or <readme README> file.
apis: 0.0.0. A library that uses Open Data Tables and JSON Schemas to generate Haskell types and API calls.
apotiki: 0.5.1, 0.5.2. apotiki generates debian repositories fast. its goal is to be a great companion to fpm and jenkins. apotiki operates with the following features and constraints: - Supports a single debian release - Supports a single debian component - Supports an arbitrary number of architectures which need to be preprovisionned - Requires a valid PGP private key for signing
app-lens: 0.1.0.0, 0.1.0.1, 0.1.0.3. A bidirectional transformation connects data in difference formats, maintaining consistency amid separate updates. The "lens" programming language---with Kmett's Haskell lens package being one of the most influentials---is a solution to this problem. Many lens implementations (including Kmett's Haskell library) only support the point-free style of programming. Though concise at times, this style becomes less handy when programs get more complicated. This module provides the infrastructure for programming complex bidirectional transformations, by representing lenses as functions that are subject to the normal applicative-style programming. For example, let us consider the 'unlines' functions and to define a lens version of it. In our framework we can program through pattern matching and explicit recursion as in normal functional programming. > unlinesF :: [L s String] -> L s String > unlinesF [] = new "" > unlinesF (x:xs) = catLineF x (unlinesF xs) > where catLineF = lift2 catLineL Here, @lift2 :: Lens' (a,b) c -> (forall s. L s a -> L s b -> L s c)@ and @new :: a -> (forall s. L s a)@ lift lenses to functions. The former is for binary lenses and the latter is for constant lenses. We can then apply lenses as functions, alleviating the need of specialized combinators. In the above, we omitted the definition of a primitive lens @catLineL :: Lens' (String, String) String@ that concatenates two strings with a newline in between. Simply unlifting ('unlift', 'unlift2', 'unliftT') such "lens functions" gives us the desired lenses. > unlinesL :: Lens' [String] String > unlinesL = unliftT unlinesF The obtained lens works as expected. > >>> ["banana", "orange", "apple"] ^. unlinesL > "banana\norange\napple\n" > >>> ["banana", "orange", "apple"] & unlinesL .~ "Banana\nOrange\nApple\n" > ["Banana","Orange","Apple"] One may prefer to define @unlinesF@ with 'foldr'. Indeed, we can use 'foldr' as below because @catLineF@ and @unlinesF@ are simply Haskell functions. > unlinesF = foldr (lift2 catLineL) (new "") Here, the program is written in a point-free manner similar to that of the other lens frameworks. But note that this 'foldr' is just Haskell's 'foldr', instead of a special combinator for lenses. More examples can be found at \"Examples\" in the source code <https://bitbucket.org/kztk/app-lens/downloads>. /Remark/. The applicative-style programming is possible in our implementation because a function representation different from Kmett's is used for lenses. As a result, when we program record-field access chains such as > src .^ l1 . l2 > src & l1 . l2 .~ tgt' The order of composition is inverted in our implementation. > src .^ unlift (lift l2 . lift l1) > src & unlift (lift l2 . lift l1) .~ tgt' This difference causes slight inconvenience for record updates, but is crucial in allowing the applicative-style lens programming we aim for.
apply-refact: 0.1.0.0. Perform refactorings specified by the refact library.
arb-fft: 0.1.0.0, 0.2.0.2. 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>.
arena: 0.1. @arena@ provides durable storage of data and summaries of that data. On insert, data is written to a journal. Each piece of data is added to a running summary of the current journal. When the summary indicates the correct amount of data has accumulated, the journal data is moved, as a block accompanied by its summary, to long-term storage. The data type, summary type, and accumulation policy are configurable.
argparser: 0.3.3. Provides a combinator library for defining a command line parser.
args-generics: 0.1. "args-generics" tries to make it very simple to create command line interfaces. Users just specify a simple data type (and derive some type classes for that type) and "args-generics" creates a command line argument parser.
arithmoi: 0.4.1.3. A library of basic functionality needed for number-theoretic calculations. The aim of this library is to provide efficient implementations of the functions. Primes and related things (totients, factorisation), powers (integer roots and tests, modular exponentiation), integer logarithms. Note: Requires GHC >= 6.12 with the integer-gmp package for efficiency. Portability is on the to-do list (with low priority, however).
array: 0.5.1.1. In addition to providing the "Data.Array" module <http://www.haskell.org/onlinereport/haskell2010/haskellch14.html as specified in the Haskell 2010 Language Report>, this package also defines the classes 'IArray' of immutable arrays and 'MArray' of arrays mutable within appropriate monads, as well as some instances of these classes.
array-forth: 0.2.1.4. This is a package for working with arrayForth. This is a variant of Forth used by GreenArrays chips. This package contains an arrayForth simulator, two different representations of arrayForth programs and some utilities like parsing. It also supports synthesizing arrayForth programs using MCMC. The basic idea is to find arrayForth programs by taking a simple prior distribution of programs and using a randomized hill-climbing algorithm to find a program fulfilling certain tests.
arrow-improve: 0.1.0.0. Optimisations to arrows.
arrowVHDL: 1.0. This software is intended to help a developer designing electronic circuits by describing them with arrows. The arrow notation represents the according. From the netlist the developer can generate various other formats by "compiling" the arrow into them. With this software three basic compilers are shipped. One generates a simple textual representation that helps debugging the actual circuit. Another generates VHDL representations of the circuit. The third one generates DOT syntax for visualization of circuits.
ascetic: 0.0.0.4. Module for assembling/emitting files in any XML-like language.
assert-failure: 0.1.1.0. This library contains syntactic sugar that improves the usability of 'assert' and 'error'. This is actually a bunch of hacks wrapping the original 'assert' function, see inside. See also <http://hackage.haskell.org/package/loch>, <http://hackage.haskell.org/package/assert> and <https://ghc.haskell.org/trac/ghc/ticket/5273>.
async-extras: 0.1.3.1.
authinfo-hs: 0.1.0.0. A .authinfo querier
auto: 0.2.0.2, 0.2.0.3, 0.2.0.4, 0.2.0.5, 0.2.0.6, 0.3.0.0, 0.4.0.0, 0.4.1.0. (Up to date documentation is maintained at <https://mstksg.github.com/auto>) Read the README first! <https://github.com/mstksg/auto/blob/master/README.md> , for motivating examples, and concrete explanations of things described here. /auto/ is a Haskell DSL and platform providing declarative, compositional, denotative semantics for discrete-step, locally stateful, interactive programs, games, and automations, with implicitly derived serialization. It is suited for any domain where either the input or the output can be described as a stream of values: a stream of input events, output views, etc. /auto/ works by providing a type that encapsulates "value stream transformers", or locally stateful functions; by specifying your program as a (potentially cyclic) graph of relationships between value streams, you create a way of "declaring" a system based simply on static relationships between quantities. Instead of a "state monad" type solution, where all functions have access to a rigid global state, /auto/ works by specifying relationships which each exist independently and on their own, without any global state. A more fuller exposition is in the `README.md`, in this project directory and also online at <https://github.com/mstksg/auto/blob/master/README.md>; you can get started by reading the tutorial, which is also in this project directory in the `tutorial` directory, and also incidentally online at <https://github.com/mstksg/auto/blob/master/tutorial/tutorial.md>. Also, check out the <https://github.com/mstksg/auto-examples auto-examples> repository on github for plenty of real-world and toy examples to learn from; I've also done a <blog.jle.im/entries/series/+all-about-auto blog series> on this library, for examples and full tutorials! Support available on freenode's #haskell-auto, #haskell-game, and also on the github issue tracker for the source repository. Import "Control.Auto" to begin!
avl-static: 0.1.0.0. A compile-time balanced AVL tree.
aws-general: 0.1, 0.1.1, 0.2.0, 0.2.1, 0.2.2. Bindings for Amazon Web Services (AWS) General Reference including AWS Signature V4. /API Version: 1.0/ <http://docs.aws.amazon.com/general/latest/gr/>
aws-kinesis: 0.1, 0.1.1, 0.1.2, 0.1.3, 0.1.4, 0.1.5. Bindings for <http://aws.amazon.com/kinesis/ Amazon Kinesis> Amazon Kinesis is an AWS service for real-time processing of streaming data at massive scale. /API Version: 2013-12-02/ <http://docs.aws.amazon.com/kinesis/2013-12-02/APIReference>
aws-performance-tests: 0.1, 0.1.1. Performance Tests for the Haskell bindings for <http://hackage.haskell.org/package/aws Amazon Web Services (AWS)>. At the current stage this package only has tests for the DynamoDb bindings. /IMPORTANT NOTE/ By using the dynamo-performace application from this package with your AWS API credentials costs will incure to your AWS account. Depending on the provisioned test table read and write throughput these costs can be in the order of several dollars per hour. Also be aware that there is an option to keep the table after the tests are finished (for example for usage with successive test runs). If you use that option you have to make sure that you delete the table yourself when you don't need it any more.
aws-sdk: 0.12.1. AWS (Amazon Web Services) sdk for Haskell. This library closesly follows the official sdk. To find more documentation, you can lookup functions in the official sdk docs for other languages: <http://docs.amazonwebservices.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/ec2/model/DescribeInstancesRequest.html>
aws-sdk-text-converter: 0.1.0.0, 0.2.0.0, 0.3. The text converter for aws-sdk.
aws-sns: 0.1. Bindings for AWS SNS /API Version: 2013-03-31/ <http://docs.aws.amazon.com/sns/2010-03-31/APIReference/Welcome.html>
azure-acs: 0.0.1.0, 0.0.1.1. Haskell wrappers over REST API for <http://msdn.microsoft.com/en-us/library/hh147631.aspx Windows Azure Active Directory Access Control>. Currently only API that is supported is the one to request a password token from ACS via the <http://msdn.microsoft.com/en-us/library/hh674475.aspx OAuth WRAP protocol>
azure-servicebus: 0.1.0.0, 0.1.0.1, 0.1.1.0, 0.1.5.0, 0.1.6.0. /Overview/ This library provides haskell wrappers over Microsoft Azure ServiceBus REST API. The current version provides Runtime API for <http://msdn.microsoft.com/en-us/library/hh780762.aspx queues and topics>. The following functionality is covered: * Send bytestring (lazy as well as strict) to a Queue. * Send bytestring (lazy as well as strict) to a topic. * Destructively read data from a queue or topic into a lazy bytestring * acquire peek-locks on messages on Queues and Subscriptions * renew lock * delete a locked message * unlock a locked message
b9: 0.2.0, 0.2.1, 0.2.3, 0.2.4, 0.2.5, 0.3.0, 0.3.1, 0.4.0, 0.4.1, 0.5.5, 0.5.15. 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-init's '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.
backtracking-exceptions: 0.1.0.0. A monad transformer that adds backtracking exceptions to its base monad.
base: 4.9.0.0. This package contains the "Prelude" and its support libraries, and a large collection of useful libraries ranging from data structures to parsing combinators and debugging utilities.
base-generics: 0.1.0.0, 0.1.0.1. This package provides Generic instance for Int8 and WOrd primitive types.
base-noprelude: 4.3.0.0, 4.3.1.0, 4.5.0.0, 4.5.1.0, 4.6.0.0, 4.6.0.1, 4.7.0.0, 4.7.0.1, 4.7.0.2, 4.8.0.0, 4.8.1.0, 4.8.2.0, 4.9.0.0. This package simplifies defining custom "Prelude"s without having to use @-XNoImplicitPrelude@ by re-exporting the full module-hierarchy of the <http://hackage.haskell.org/package/base-4.9.0.0 base-4.9.0.0> package /except/ for the "Prelude" module. Starting with GHC 7.10 & Cabal-1.22 this package makes use of the package-level @reexported-modules@ feature. Each version of @base-noprelude@ depends on a specific @base@-version and thus mirrors @base@'s versioning (with the exception that @base-noprelude@ needs to add an /additional/ 5th version component in case of bug-fix releases). See <https://github.com/hvr/base-noprelude> for more information.
base-orphans: 0. @base-orphans@ defines orphan instances that mimic instances available in later versions of @base@ to a wider (older) range of compilers. @base-orphans@ does not export anything except the orphan instances themselves and complements @<http://hackage.haskell.org/package/base-compat base-compat>@. `base-orphans-0` is an intentional empty release. For an explanation as to why it exists, see the <https://github.com/haskell-compat/base-orphans/tree/base-orphans-0#readme README>.
base32-bytestring: 0.1.0.0. base32 and base32hex codec according to RFC4648 <http://tools.ietf.org/html/rfc4648> The package API is similar to base64-bytestring. [/Release notes/] * /0.1.0.0:/ Initial version.
basex-client: 0.2.0.0. A BaseX client library for Haskell that connects to the BaseX server using a socket. BaseX is a light-weight, high-performance and scalable XML Database written in Java.
batch-rename: 0.1.0.1. Do you remember the convenient command `rn' in MSDOS ? When you want to change all your .mp3 files to .mp4 Simply type "rn *.mp3 *.mp4." I really like this. But in linux/Mac world, people keep asking how.(http://bit.ly/2cIskUu) So maybe this little tool can help you a lot.
bbdb: 0.5. BBDB (http://sourceforge.bbdb.net) is a contact management utility that can be used with emacs. It stores its data internally as a lisp expression. This module parses the lisp and provides some convenience functions to get at and manipulate the data all from within Haskell. See the hackage docs for usage and examples.
bdd: 0.1.0.0, 0.2.0.0. An internal domain-specific language for testing programs using Behavior-Driven Development (BDD) process. It helps arranging your tests in "given" \/ "when" \/ "then" parts. For a more detailed description please refer to <https://github.com/humane-software/haskell-bdd/>
bencoding: 0.2.1.0. A library for encoding and decoding of BEncode data. [/Release notes/] * /0.1.0.0:/ Initial version. * /0.2.0.0:/ Added default decoders/encoders using GHC Generics. * /0.2.1.0:/ Arbitrary length integers. (by specification)
besout: 0.2.0.1.
between: 0.11.0.0. It turns out that this combinator > f ~@~ g = (f .) . (. g) is a powerful thing. It was abstracted from following (commonly used) pattern @f . h . g@ where @f@ and @g@ are fixed. This library not only defines @~\@~@ combinator, but also some derived combinators that can help us easily define a lot of things including lenses. See <http://hackage.haskell.org/package/lens lens package> for detais on what lenses are. Function @Data.Function.on@ can be implemented using @~\@~@ as: > on :: (b -> b -> c) -> (a -> b) -> a -> a -> c > on f g = (id ~@~ g ~@~ g) f If function @on3@ existed in /base/ then it could be defined as: > on3 :: (b -> b -> b -> d) -> (a -> b) -> a -> a -> a -> d > on3 f g = (id ~@~ g ~@~ g ~@~ g) f Other usage examples and documentation can be found in "Data.Function.Between" module.
bff-mono: 0.2.0, 0.2.1, 0.2.2, 0.2.3. This package provides a way to make a bidirectional transformation (a getter/setter pair, or so-called lens) from a description of unidirectional transformation. Like 'bff' package, the package constructs bidirectional transformations based on the free theorem. Unlike 'bff' package, the package supports some of monomorphic transformations.
bgmax: 0.1.0.0. A low-level parser for <http://www.bgc.se/upload/Gemensamt/Trycksaker/Manualer/BG6040.pdf BgMax> -files from <http://www.bgc.se Bankgirocentralen> (BGC). It is able to parse all of the <http://www.bgc.se/templates/Iframe____3125.aspx example files> from BGC.
bimap: 0.3.0. A data structure representing a bidirectional mapping between two key types. Each value in the bimap is associated with exactly one value of the opposite type.
bimaps: 0.1.0.0. Bijections between sets of values.
binary-conduit: 1.2.4. The binary-conduit package. Allow binary serialization using iterative conduit interface.
binary-streams: 0.1.0.0, 0.1.0.1. Allow binary serialization/deserialization using io-streams
binary-typed: 0.1.0.0, 0.1.0.1, 0.2.0.0, 0.2.0.1, 0.2.1.0, 0.2.2, 0.2.3, 0.3, 1.0. `Binary` serialization tagged with type information, allowing for typechecking and useful error messages at the receiving site. This package serves the same purpose as tagged-binary, with a couple of key differences: * Support of different kinds of serialized type annotations, each with specific strengths and weaknesses. * Error messages can provide details on type errors at the cost of longer message lengths to include the necessary information. * Very small performance overhead compared to using standard `Binary` due to caching when using hashed type information. Since shown and full types are not cached, decoding them has a significant performance hit (ballpark: factor of two). * No depencency on @Internal@ modules of other libraries, and a very small dependency footprint in general. For information about usage, see the "Data.Binary.Typed.Tutorial" module. Performance-wise, here is a value @Right (Left \<100 chars lipsum\>)@ of type @Either (Char, Int) (Either String (Maybe Integer))@ benchmarked using the @Hashed64@ type representation: <<http://i.imgur.com/UMPUpp4.png>> <doc/bench-overview.png (local copy)>
bindings-lxc: 0.1, 0.2, 0.2.0.1. The package provides direct bindings to LXC C API through @bindings-dsl@. For high-level Haskell LXC API see <http://hackage.haskell.org/package/lxc lxc package>.
biohazard: 0.6.2, 0.6.3, 0.6.5, 0.6.6, 0.6.6.1. This is a collection of modules I separated from various bioinformatics tools. The hope is to make them reusable and easier to maintain. Also includes some of these tools and a bunch that work on mitochondrial sequences.
biophd: 0.0.7, 0.0.8. Library for reading phd sequence files
bitcoin-payment-channel: 0.1.0.0. A Bitcoin payment channel allows two parties two send value to each other very rapidly. The speed of the value transfer is limited primarily by network latency, and payments cannot be double spent, as the receiver of funds is defined during channel setup. The channel setup procedure is trustless, in that the funding party is able to retrieve the funds, after a chosen expiration date, in case the receiving party goes missing. This library implements a type of payment channel (CHECKLOCKTIMEVERIFY-style) where channel setup is safe from transaction ID malleability, and value transfer is uni-directional (one party sends and the other party receives).
bitx-bitcoin: 0.1.0.0, 0.2.0.0, 0.2.0.2, 0.4.0.1, 0.5.0.0, 0.6.0.0. Haskell bindings to the BitX REST API, as described here: <https://bitx.co/api>. Note that since this library interfaces directly with a financial API, great care must be taken in its use. In particular, the author cannot be held accountable for any financial losses as a result of programming error, whether that error is in your code, the code of the author of this library, or BitX's code. This is just common sense. If you need to make sure that nothing funny happens in the code, apart from reading the source yourself, you should also perform a few test transations with very small denominations, as I will strive to do every time before releasing a new version. For a very small usage example, see "Network.Bitcoin.BitX.Public".
blank-canvas: 0.2.3.1, 0.3.1, 0.4.0, 0.5, 0.6. @blank-canvas@ is a Haskell binding to the complete <https://developer.mozilla.org/en-US/docs/Web/API/Canvas_API HTML5 Canvas API>. @blank-canvas@ allows Haskell users to write, in Haskell, interactive images onto their web browsers. @blank-canvas@ gives the user a single full-window canvas, and provides many well-documented functions for rendering images. @ {-# LANGUAGE OverloadedStrings #-} module Main where import Graphics.Blank -- import the blank canvas main = blankCanvas 3000 $ \\ context -> do -- start blank canvas on port 3000   send context $ do -- send commands to this specific context     moveTo(50,50)     lineTo(200,100)     lineWidth 10     strokeStyle \"red\"     stroke() -- this draws the ink into the canvas @ <<https://github.com/ku-fpg/blank-canvas/wiki/images/Red_Line.png>> For more details, read the <https://github.com/ku-fpg/blank-canvas/wiki blank-canvas wiki>.
blatex: 0.1.0.0. Markdown and HTML are the standard tools used to write your every day tech blog with. But they have pretty weak support for embedding mathematical formulas, and are not conducive to writing for an extended period of time. Plus, they aren't even Turing complete! So use BlaTeX to start blogging in LaTeX! BlaTeX is basically a static site generator (like Jekyll) that lets you write your blog in LaTeX, specify a layout file for the homepage, and publish it to github pages. To get started, check out <https://github.com/2016rshah/BlaTeX#how-to>
blaze: 0.0.2. None
blazeMarker: 0.1.0.0.
blink1: 0.3.1, 0.4. Provides an interface to the ThingM blink(1) LED <http://thingm.com/products/blink-1.html> similar to (but not dependent on) <http://github.com/todbot/blink1> via Linux hidraw or the libusb-based usb package.
bloc: 0.1.0.0. The name bloc stands for Binary Large Objects with Concurrency and is inspired from blob (Binary Large OBject). As evident from the name, bloc provides a concurrent interface for handling blobs. We provide methods for incremental writes, incremental reads and garbage collection of the deleted blobs. This package is not supported under Windows.
bloodhound: 0.1.0.0, 0.1.0.1. ElasticSearch made awesome for Haskell hackers
blunt: 0.0.10, 0.0.12. <https://github.com/tfausak/blunt>
bond: 0.4.0.1. Bond is a cross-platform framework for handling schematized data. It supports cross-language de/serialization and powerful generic mechanisms for efficiently manipulating data. This package contains a library for parsing the Bond schema definition language and performing template-based code generation. The library includes built-in templates for generating standard Bond C++ and C# code, as well as utilities for writing custom codegen templates. The package also contains a command-line compiler/codegen tool, named gbc, which is primarily used to generate code for C++ and C# programs using Bond.
bool-extras: 0.4.0. The `bool' function allows folding over boolean values. This is comparable to the `maybe' or `either' functions on their respective types. The `bool' function is a replacement for the build-in @if then else@-syntax. However, since it is a function, it can be partially applied and passed around to higher order functions, like so: > ghci> :m + Data.Bool.Extras > ghci> let yesOrNo = bool "no" "yes" > ghci> map yesOrNo [True, False, True] > ["yes", "no", "yes"] Note that the arguments to `bool' are in the opposite order of the @if then else@-syntax; First the false value, then the true value, and finally the boolean.
borel: 0.18.0. Leverages Ceilometer, Chevalier and Marquise to meter OpenStack data.
bound-gen: 0.1.0.0, 0.1.0.1, 0.1.0.2. It's quite common when working with bound to need to unwrap a @Scope@. In order to ensure that this can be done safely, without shadowing any existing free variables, @bound-gen@ glues @monad-gen@'s fresh value monad into @bound@.
bower-json: 0.1.0.0, 0.2.0.0, 0.3.0.0, 0.4.0.0, 0.5.0.0, 0.6.0.0. Bower is a package manager for the web (see <http://bower.io>). This package provides a data type and ToJSON/FromJSON instances for Bower's package manifest file, bower.json.
box-tuples: 0.1.0.0. As of now, the GHCi interactive runtime is incapable of working on unboxed tuples. In particular, it is unable to fully apply any function returning an unboxed tuple, create a function that takes a non-nullary unboxed tuple as argument, or pass a non-nullary tuple to some other function. The usual solution is to enable object code generation with @-fobject-code@. This package serves as a workaround for the cases where @-fobject-code@ is undesiable.
boxes: 0.1.4. A pretty-printing library for laying out text in two dimensions, using a simple box model.
broadcast-chan: 0.1.0. A variation of "Control.Concurrent.Chan" from base, which allows to the easy creation of broadcast channels without the space-leaks that may arise from using 'Control.Concurrent.Chan.dupChan'. The 'Control.Concurrent.Chan.Chan' type from "Control.Concurrent.Chan" consists of both a read and write end. This presents a problem when one wants to have a broadcast channel that, at times, has zero listeners. To write to a 'Control.Concurrent.Chan.Chan' there must always be a read end and this read end will hold ALL messages alive until read. The simple solution applied in this module is to separate read and write ends. As a result, any messages written to the write end can be immediately garbage collected if there are no active read ends, avoding space leaks.
bson: 0.3.2, 0.3.2.3, 0.3.2.4. A BSON Document is an untyped (dynamically type-checked) record. I.e. it is a list of name-value pairs, where a Value is a single sum type with constructors for basic types (Bool, Int, Float, String, and Time), compound types (List, and (embedded) Document), and special types (Binary, Javascript, ObjectId, RegEx, and a few others). A BSON Document is serialized to a standard binary encoding defined at <http://bsonspec.org>. This implements version 1 of that spec.
btrfs: 0.1.0.0, 0.1.0.1, 0.1.1.0, 0.1.1.1. This package provides low-level bindings to the btrfs API (i.e. the @BTRFS_IOC_@* @ioctl@s). Currently, only a subset of the API is supported, including functions needed to work with subvolumes/snapshots as well as file cloning. In order to build this package, @linux-headers@ need to be installed. Warning: btrfs is still considered experimental. This module is also experimental and may contain serious bugs that may result in data loss. Do not use it on data that has not been backed up yet.
buffer-builder: 0.1.0.0, 0.2.0.0, 0.2.0.1, 0.2.0.3, 0.2.1.0. "Data.BufferBuilder" is an efficient library for incrementally building up 'ByteString's, one chunk at a time. Early benchmarks show it is over twice as fast as ByteString Builder, primarily because 'BufferBuilder' is built upon an ST-style restricted monad and mutable state instead of ByteString Builder's monoidal AST. Internally, BufferBuilder is backed by a few C functions. Examination of GHC's output shows nearly optimal code generation with no intermediate thunks -- and thus, continuation passing and its associated indirect jumps and stack traffic only occur when BufferBuilder is asked to append a non-strict ByteString. I benchmarked four approaches with a URL encoding benchmark: * State monad, concatenating ByteStrings: 6.98 us * State monad, ByteString Builder: 2.48 us * Crazy explicit RealWorld baton passing with unboxed state: 28.94 us (GHC generated really awful code for this, but see the revision history for the technique) * C + FFI + ReaderT: 1.11 us Using BufferBuilder is very simple: > import qualified Data.BufferBuilder as BB > > let byteString = BB.runBufferBuilder $ do > BB.appendBS "http" > BB.appendChar8 '/' > BB.appendBS "//" This package also provides "Data.BufferBuilder.Utf8" for generating UTF-8 buffers and "Data.BufferBuilder.Json" for encoding data structures into JSON.
buffer-builder-aeson: 0.2.0.0, 0.2.0.3. A very fast BufferBuilder-based JSON encoder for Aeson. The whole library is a a single orphan instance for Aeson.Value. > import Data.Aeson (object, (.=), Value (..)) > import Data.BufferBuilder.Json (encodeJson) > import Data.BufferBuilder.Aeson () > import qualified Data.ByteString as BS > > stuff :: Value > stuff = Array > [ object > [ "name" .= ("eggs" :: String) > , "price" .= (3.141592 :: Double) > ] > , object > [ "name" .= ("cheese" :: String) > , "price" .= (0.57721 :: Double) > ] > ] > > main :: IO () > main = do > BS.putStrLn $ encodeJson stuff
buffon: 0.1.0.0. An implementation of everything in "On Buffon Machines and Numbers".
bug: 0.
bv: 0.3.0. Bit-vectors implemented as a wrapper over integers.
bytable: 0.0.0.0, 0.0.0.1, 0.0.0.2, 0.0.0.9, 0.0.0.10. You can read data from ByteString. > some = do > x <- take 4 > y <- take 8 > return (x :: Int, y :: Integer)
bytestring: 0.10.6.0. An efficient compact, immutable byte string type (both strict and lazy) suitable for binary or 8-bit character data. The 'ByteString' type represents sequences of bytes or 8-bit characters. It is suitable for high performance use, both in terms of large data quantities, or high speed requirements. The 'ByteString' functions follow the same style as Haskell\'s ordinary lists, so it is easy to convert code from using 'String' to 'ByteString'. Two 'ByteString' variants are provided: * Strict 'ByteString's keep the string as a single large array. This makes them convenient for passing data between C and Haskell. * Lazy 'ByteString's use a lazy list of strict chunks which makes it suitable for I\/O streaming tasks. The @Char8@ modules provide a character-based view of the same underlying 'ByteString' types. This makes it convenient to handle mixed binary and 8-bit character content (which is common in many file formats and network protocols). The 'Builder' module provides an efficient way to build up 'ByteString's in an ad-hoc way by repeated concatenation. This is ideal for fast serialisation or pretty printing. There is also a 'ShortByteString' type which has a lower memory overhead and can can be converted to or from a 'ByteString', but supports very few other operations. It is suitable for keeping many short strings in memory. 'ByteString's are not designed for Unicode. For Unicode strings you should use the 'Text' type from the @text@ package. These modules are intended to be imported qualified, to avoid name clashes with "Prelude" functions, e.g. > import qualified Data.ByteString as BS
bytestring-conversion: 0.1, 0.1.1, 0.2, 0.2.1, 0.3.0, 0.3.1. Defines the type-classes 'ToByteString' and 'FromByteString' to convert values to and from ByteString.
bytestring-from: 0.1, 0.1.1, 0.2, 0.2.1, 0.3. Defines the type-class 'FromByteString' to convert values from ByteString.
bytestring-plain: 0.1.0.2. More compact representation for strict 'ByteString's avoiding the overhead and indirection caused by 'ForeignPtr'. This representation is useful to reduce the incurred memory overhead when operating with many small, long-lived, distinct byte strings (such as keys for containers). See documentation in "Data.ByteString.Plain" for more details about this representation. As an alternative, recent `bytestring` versions provide "Data.ByteString.Short" which has a similiar overhead but uses unpinned memory instead (and thus requires an additional string data copy in contrast to "Data.ByteString.Plain" which allows to share the string data with the associated "Data.ByteString" value).
c-dsl: 0.1.0.0, 0.2, 0.3, 0.3.1. This DSL is meant to make it easier to write language-c's DSL by providing simple functions/operators for writing C AST's in Haskell.
cabal-constraints: 0.0.0.1, 0.0.0.2. /Repeatable builds for cabalized Haskell projects/ \'cabal-constraints\' provides repeatable builds for cabalized Haskell projects by \"freezing\" the exact versions of the dependencies selected by \'cabal-install\'. All build environments for the project, such as the test or staging build environments, or other developers collaborating on the project, will then use the same dependency versions. It is designed to be used alongside \'cabal-install\' sandboxes, in which case isolated, repeatable builds can be achieved. /Using cabal-constraints/ \'cabal-constraints\' should be run from the root directory of a cabalized Haskell project and given the path to the `setup-config` file to use. It will print out all dependencies of the project in a format suitable for use in a `cabal-install` config file. For example, running \'cabal-constraints\' against itself produces the following: @ $ cabal-constraints dist\/dist-sandbox-500003c6\/setup-config constraints: Cabal == 1.19.0 , array == 0.4.0.1 , base == 4.6.0.1 , bytestring == 0.10.0.2 , containers == 0.5.0.0 , deepseq == 1.3.0.1 , directory == 1.2.0.1 , filepath == 1.3.0.1 , ghc-prim == 0.3.0.0 , integer-gmp == 0.5.0.0 , old-locale == 1.0.0.5 , pretty == 1.1.1.0 , process == 1.1.0.2 , rts == 1.0 , time == 1.4.0.1 , unix == 2.6.0.1 @ A single mandatory argument must be provided which is the path to the @setup-config@ file to use. The file will be located under the @dist@ directory. Usually there will be a single @setup-config@ file which can be found by running @find dist -name setup-config@ from the root directory of the project. If your project has more than one such file, it is likely because you have built it either with and without sandboxes or with multiple sandboxes. You probably want the most recently modified file which can be found with @ls -tr $( find dist -name setup-config ) | tail -n1@. To use these constraints for reproducible builds, one should make use of the new sandbox feature of @cabal-install@ 1.18. The constraints can be redirected to @cabal.config@ and committed to your code repository. When the project is built, the same set of dependency versions will be resolved by @cabal-install@ ensuring repeatable builds. If @cabal.config@ contains no other information the simplest solution is to overwrite it: @ $ cabal-constraints > cabal.config @ If @cabal.config@ contains information that needs to be preserved, the following will replace the @constraints@ section and everything following it with the new constraints. If you ensure that the @constraints@ section is the last section of the file, all other information in it will be kept. @ $ sed -i \/^constraints:\/,$d cabal.config && cabal-constraints >> cabal.config @
cabal-dir: 0.1.0.0, 0.1.0.2, 0.1.0.3, 0.1.0.4. show dist dir of 'cabal copy/install' > % cabal configure > % cabal-dir > prefix : /usr/local/ > bindir : bin > libdir : lib/foo-0.1.2.3/ghc-8.8.8 > datadir: share/foo-0.1.2.3 > htmldir: share/doc/foo-0.1.2.3/html
cabal-install: 1.23.0.0, 1.24.0.0. The \'cabal\' command-line program simplifies the process of managing Haskell software by automating the fetching, configuration, compilation and installation of Haskell libraries and programs.
cabal-solver: 0.
cabal2ebuild: 0.0.15.1, 0.0.15.3, 0.0.15.4. > % ls > hoge.cabal ... > % cabal2ebuild > % ls > % hoge.cabal hoge-0.1.2.3.ebuild ...
cabin: 0.1.0.0, 0.1.0.1, 0.1.0.2. A simple package manager for cabal binary packages. Each binary package is installed to a separate sandbox and can be loaded into the users profile individually.
cabocha: 0.1.0.0. A Haskell binding to CaboCha <http://taku910.github.io/cabocha>
cached-io: 0.1.0.1.
cake3: 0.2.1.0. Cake3 is a EDSL for building Makefiles, written in Haskell. With cake3, developer can write their build logic in Haskell, obtain clean and safe Makefile and distribute it among the non-Haskell-aware users. Currenly, GNU Make is the only backend supported. /Example program/ > module Cakefile where > > import Development.Cake3 > import Cakefile_P > > cs = map file ["main.c", "second.c"] > > main = writeMake (file "Makefile") $ do > selfUpdate > d <- rule $ do > shell [cmd|gcc -M $cs -MF @(file "depend.mk")|] > os <- forM cs $ \c -> do > rule $ do > shell [cmd| gcc -c $(extvar "CFLAGS") -o @(c.="o") $c |] > elf <- rule $ do > shell [cmd| gcc -o @(file "main.elf") $os |] > rule $ do > phony "clean" > unsafeShell [cmd|rm $elf $os $d|] > rule $ do > phony "all" > depend elf > includeMakefile d /Basic workflow/ * Install the cake3 * Create Cakefile.hs in the project root * Build the application using cake3 script provided * Execute the application to obtain the Makefile See the README on the GitHub <https://github.com/grwlf/cake3> for more information. /Changes/ * 0.1 - Initial release * 0.2 - Redesign (simplify) monadic interface, add support for prebuild/postbuild actions.
caledon: 3.2.2.0. a dependently typed, polymorphic, higher order logic programming language based on the calculus of constructions designed for easier metaprogramming capabilities.
camfort: 0.800, 0.802, 0.804, 0.900. CamFort is a tool for the analysis, transformation, verification of Fortran code.
cantor: 0.1, 0.2, 0.3, 0.4. Cantor is application for analyzing software projects. The goal of this application is to help developer understand source code of unknown project. Currently implemented: * Find language the application is written in * Line Of Code metric.
cao: 0.1.1. CAO Compiler
cassandra-cql: 0.5.0.2. Haskell client for Cassandra's CQL protocol.
catamorphism: 0.3.0.0. A package exposing a helper function for generating catamorphisms.
cblrepo: 0.9.3. Helper tool for people maintaining a set of CABAL packages for their distribution. It maintains a database of packages and verifies dependencies of the entire set as packages are added or updated. It also makes it trivial to track packages as new versions are released on Hackage. It can also be used to build source packages for the ArchLinux distribution.
cborg: 0.1.0.0. reserved for https://github.com/well-typed/binary-serialise-cbor/
ceilometer-common: 0.2.2, 0.2.3. This package defines a library with two interfaces: one for working with the data producers (e.g. the collector for OpenStack Ceilometer) and one for the consumers (e.g. the Borel metering and billing system).
cereal: 0.4.0.0, 0.4.0.1, 0.4.1.0. A binary serialization library, similar to binary, that introduces an isolate primitive for parser isolation, and labeled blocks for better error messages.
cereal-text: 0.1.0.0. Data.Text instances for the cereal serialization library. Provides instances for Text and lazy Text. Uses UTF-8 encoding for serialization. Use @import Data.Serialize.Text ()@ to import instances.
cgrep: 6.6.5. Cgrep: a context-aware grep for source codes
chalk: 0.1.0.1.
check-pvp: 0.0. Check whether the version ranges used in the @Build-Depends@ field matches the style of module imports according to the Package Versioning Policy (PVP). See <http://www.haskell.org/haskellwiki/Package_versioning_policy>. The tool essentially looks for any dependency like @containers >=0.5 && <0.6@ that allows the addition of identifiers to modules within the version range. Then it checks whether all module imports from @containers@ are protected against name clashes that could be caused by addition of identifiers. You must run the tool in a directory containing a Cabal package. > $ check-pvp This requires that the package is configured, since only then the association of packages to modules is known. If you want to run the tool on a non-configured package you may just check all imports for addition-proof style. > $ check-pvp --include-all It follows a detailed description of the procedure and the rationale behind it. First the program classifies all dependencies in the Cabal file of the package. You can show all classifications with the @--classify-dependencies@ option, otherwise only problematic dependencies are shown. A dependency like @containers >=0.5.0.3 && <0.5.1@ does not allow changes of the API of @containers@ and thus the program does not check its imports. Clashing import abbreviations are an exception. The dependency @containers >=0.5.1 && <0.6@ requires more care when importing modules from @containers@ and this is what the program is going to check next. This is the main purpose of the program! I warmly recommend this kind of dependency range since it greatly reduces the work to keep your package going together with its imported packages. Dependencies like @containers >=0.5@ or @containers >=0.5 && <1@ are always problematic, since within the specified version ranges identifier can disappear. There is no import style that protects against removed identifiers. An inclusive upper bound as in @containers >=0.5 && <=0.6@ will also cause a warning, because it is unnecessarily strict. If you know that @containers-0.6@ works for you, then @containers-0.6.0.1@ or @containers-0.6.1@ will also work, depending on your import style. A special case of inclusive upper bounds are specific versions like in @containers ==0.6@. The argument for the warning remains the same. Please note that the check of ranges is performed entirely on the package description. The program will not inspect the imported module contents. E.g. if you depend on @containers >=0.5 && <0.6@ but import in a way that risks name clashes, then you may just extend the dependency to @containers >=0.5 && <0.6.1@ in order to let the checker fall silent. If you use the dependency @containers >=0.5 && <0.6.1@ then the checker expects that you have verified that your package works with all versions of kind @0.5.x@ and the version @0.6.0@. Other versions would then work, too, due to the constraints imposed by package versioning policy. Let us now look at imports that must be protected against identifier additions. The program may complain about a lax import. This means you have imported like > import Data.Map as Map Additions to @Data.Map@ may clash with other identifiers, thus you must import either > import qualified Data.Map as Map or > import Data.Map (Map) The program may complain about an open list of constructors as in > import Data.Sequence (ViewL(..)) Additions of constructors to @ViewL@ may also conflict with other identifiers. You must instead import like > import Data.Sequence (ViewL(EmptyL, (:<))) or > import qualified Data.Sequence as Seq The program emits an error on clashing module abbreviations like > import qualified Data.Map.Lazy as Map > import qualified Data.Map.Strict as Map This error is raised whenever multiple modules are imported with the same abbreviation, where at least one module is open for additions. Our test is overly strict in the sense that it also blames > import qualified Data.Map as Map > import qualified Data.Map as Map but I think it is good idea to avoid redundant imports anyway. Additionally you can enable a test for hiding imports with the @--pedantic@ option. The import > import Data.Map hiding (insert) is not bad in the sense of the PVP, but this way you depend on the existence of the identifier @insert@ although you do not need it. If it is removed in a later version of @containers@, then your import breaks although you did not use the identifier. Finally you can control what items are checked. First of all you can select the imports that are checked. Normally the imports are checked that belong to lax dependencies like @containers >=0.5 && <0.6@. However this requires the package to be configured in order to know which import belongs to which dependency. E.g. @Data.Map@ belongs to @containers@. You can just check all imports for being addition-proof using the @--include-all@ option. Following you can write the options @--include-import@, @--exclude-import@, @--include-dependency@, @--exclude-dependency@ that allow to additionally check or ignore imports from certain modules or packages. These modifiers are applied from left to right. E.g. @--exclude-import=Prelude@ will accept any import style for @Prelude@ and @--exclude-dependency=foobar@ will ignore the package @foobar@, say, because it does not conform to the PVP. Secondly, you may ignore certain modules or components of the package using the options @--exclude-module@, @--exclude-library@, @--exclude-executables@, @--exclude-testsuites@, @--exclude-benchmarks@. E.g. @--exclude-module=Paths_PKG@ will exclude the Paths module that is generated by Cabal. I assume that it will always be free of name clashes. Known problems: * The program cannot automatically filter out the @Paths@ module. * The program cannot find and check preprocessed modules. * The program may yield wrong results in the presence of Cabal conditions. If this program proves to be useful it might eventually be integrated in the @check@ command of @cabal-install@. See <https://github.com/haskell/cabal/issues/1703>. Alternative: If you want to allow exclusively large version ranges, i.e. @>=x.y && <x.y+1@, then you may also add the option @-fwarn-missing-import-lists@ to the @GHC-Options@ fields of your Cabal file. See <https://ghc.haskell.org/trac/ghc/ticket/4977>. Unfortunately there is no GHC warning on clashing module abbreviations. See <https://ghc.haskell.org/trac/ghc/ticket/4980>.
chevalier-common: 0.6.0. Provides common types and a ZeroMQ query interface for Chevalier.
chewie: 0.1.0.
chorale: 0.1.1. Chorale is a Haskell module that contains basic functions that the prelude does not offer. The prelude is traditionally followed by a chorale ...
circlehs: 0.0.1, 0.0.2, 0.0.3. The CircleCI REST API implementation in Haskell. For more info please see <https://circleci.com/docs/api/ official API reference>. Built with <http://hackage.haskell.org/package/servant Servant>. /Please note that implementation is incomplete yet./
citeproc-hs: 0.3.9, 0.3.10. citeproc-hs is a library for rendering bibliographic reference citations into a variety of styles using a macro language called Citation Style Language (CSL). More details on CSL can be found here: <http://citationstyles.org/>. For the API documentation please see "Text.CSL".
citeproc-hs-pandoc-filter: 0.1. citeproc-hs is a library for rendering bibliographic reference citations into a variety of styles using a macro language called Citation Style Language (CSL). More details on CSL can be found here: <http://citationstyles.org/>. citeproc-hs-pandoc-filter is a replacement of citeproc-pandoc which uses citeproc-hs for processing citations.
clafer: 0.3.5, 0.3.5.1, 0.3.6, 0.3.6.1, 0.3.7, 0.3.8, 0.3.9, 0.4.3. Clafer is a general purpose, lightweight, structural modeling language developed at GSD Lab, University of Waterloo, and MODELS group at IT University of Copenhagen. Lightweight modeling aims at improving the understanding of the problem domain in the early stages of software development and determining the requirements with fewer defects. Clafer's goal is to make modeling more accessible to a wider range of users and domains. The tool provides a reference language implementation. It translates models to other formats (e.g. Alloy, JavaScript, JSON) to allow for reasoning with existing tools.
claferIG: 0.3.5, 0.3.5.1, 0.3.6, 0.3.6.1, 0.3.7, 0.3.8, 0.3.9, 0.4.3. Clafer is a powerful (equivalent to first-order predicate logic) yet lightweight structural modeling language. Despite simplicity and conciseness of Clafer, writing correct models remains challenging due to hard-to-predict interactions among all constraints expressed in the model. Clafer instance generator (ClaferIG) is an interactive tool that generates instances and counter examples of concrete clafers in a Clafer model. If the concrete clafers do not have contradicting constraints, the generator produces valid instance data. Otherwise, the generator produces an unsatisfiable core which included all contradicting constraints and generates a counter example by removing one constraint from the core. The generator can potentially produce many instances if the concrete clafers are not fully specialized. The generator produces different instances on-demand. With these capabilities, the instance generator can be used for debugging models: checking the consistency of the model and detecting under- and overconstraining of the model. The instance generator can also be used programmatically via API (the command line and interactive session interfaces only use the API).
claferwiki: 0.3.5, 0.3.5.1, 0.3.6, 0.3.6.1, 0.3.7, 0.3.8, 0.3.9, 0.4.0, 0.4.3. A wiki-based IDE for literate modeling with Clafer. A Plugin for the Gitit wiki which collects code blocks written in Clafer (.clafer), compiles them, renders into HTML and Dot, and replaces the code blocks with the results.
clang-pure: 0.1.0.0, 0.1.0.2, 0.1.0.3, 0.2.0.0. Pure C++ code analysis with libclang. Refer to <http://clang.llvm.org/doxygen/group__CINDEX.html libclang's documentation> for usage. In general, the naming scheme is @clang_getCursorType -> cursorType@, @CXCursor -> `Cursor`@.
clark: 0.1.
clash-lib: 0.2.0.1. CλaSH (pronounced ‘clash’) is a functional hardware description language that borrows both its syntax and semantics from the functional programming language Haskell. The merits of using a functional language to describe hardware comes from the fact that combinational circuits can be directly modeled as mathematical functions and that functional languages lend themselves very well at describing and (de-)composing mathematical functions. This package provides: * The CoreHW internal language: SystemF + Letrec + Case-decomposition * The normalisation process that brings CoreHW in a normal form that can be converted to a netlist * VHDL Backend * Blackbox/Primitive Handling Front-ends (for: parsing, typecheck, etc.) are provided by seperate packages: * <https://github.com/christiaanb/Idris-dev Idris Frontend> * <https://github.com/christiaanb/clash2 GHC/Haskell Frontend>
cloben: 0.1.0.0. @cloben@ is a Haskell shell script transforms @cabal bench@/@stack bench@ results into a CSV file readable by @gipeda@ for visualization. Prior to that, it optionally clones a specific commit of a given git repository into a temporary folder in which it then performs the benchmarking. Example run of some default @fib@ benchmarks: @ $ cloben https:\/\/github.com\/sgraf812\/benchmark-test 9982583 build\/warnings;1.0 benchmarks\/fib\/10;487.7 benchmarks\/fib\/35;81910000.0 benchmarks\/fib\/37;215200000.0 @
clock: 0.4, 0.4.0.1, 0.4.1.1, 0.4.1.2, 0.4.1.3, 0.4.2.0. A package for convenient access to high-resolution clock and timer functions of different operating systems via a unified API. POSIX code and surface API was developed by Cetin Sert in 2009. Windows code was contributed by Eugene Kirpichov in 2010. FreeBSD code was contributed by Finn Espen Gundersen on 2013-10-14. OS X code was contributed by Gerolf Seitz on 2013-10-15. Derived @Generic@, @Typeable@ and other instances for @Clock@ and @TimeSpec@ was contributed by Mathieu Boespflug on 2014-09-17. Corrected dependency listing for @GHC < 7.6@ was contributed by Brian McKenna on 2014-09-30. Windows code corrected by Dimitri Sabadie on 2015-02-09. [Version Scheme] Major-@/R/@-ewrite . New-@/F/@-unctionality . @/I/@-mprovementAndBugFixes . @/P/@-ackagingOnly * @PackagingOnly@ changes are made for quality assurance reasons.
cloud-haskell: 0.0.1.0. Cloud Haskell is a set of libraries that bring Erlang-style concurrency and distribution to Haskell programs. This project is an implementation of that distributed computing interface, where processes communicate with one another through explicit message passing rather than shared memory. This package is just a convenient wrapper around the @distributed-process-platform@, @distributed-process@ and @network-transport@ packages, so they can be installed with a single @cabal install cloud-haskell@ command. The package also comes with flags to enable different @Network.Transport@ and /Cloud Haskell/ (network topology) backends.
codec: 0.1. Tired of writing complementary @parseJSON@\/@toJSON@, @peek@\/@poke@ or Binary @get@\/@put@ functions? @codec@ provides easy bidirectional serialization of plain Haskell records in any Applicative context. All you need to do is provide a de\/serializer for every record field in any order you like, and you get a de\/serializer for the whole structure. The type system ensures that you provide every record exactly once. It also includes a library for general record construction in an Applicative context, of which creating codecs is just one application. JSON! > userCodec :: JSONCodec User > userCodec = obj "user object" $ > User > $>> f_username >-< "user" > >>> f_userEmail >-< "email" > >>> f_userLanguages >-< "languages" > >>> f_userReferrer >-< opt "referrer" > > instance FromJSON User where > parseJSON = parseVal userCodec > > instance ToJSON User where > toJSON = produceVal userCodec Bit fields! > ipv4Codec :: BinaryCodec IPv4 > ipv4Codec = toBytes $ > IPv4 > $>> f_version >-< word8 4 > >>> f_ihl >-< word8 4 > >>> f_dscp >-< word8 6 > >>> f_ecn >-< word8 2 > >>> f_totalLength >-< word16be 16 > >>> f_identification >-< word16be 16 > >>> f_flags >-< word8 3 > >>> f_fragmentOffset >-< word16be 13 > >>> f_timeToLive >-< word8 8 > >>> f_protocol >-< word8 8 > >>> f_headerChecksum >-< word16be 16 > >>> f_sourceIP >-< word32be 32 > >>> f_destIP >-< word32be 32 > > instance Binary IPv4 where > get = parse ipv4Codec > put = produce ipv4Codec Storable! > timeSpecCodec :: ForeignCodec TimeSpec > timeSpecCodec = > TimeSpec > $>> f_seconds >-< field (#offset struct timespec, tv_sec) cInt > >>> f_nanoseconds >-< field (#offset struct timespec, tv_nsec) cInt > > instance Storable TimeSpec where > peek = peekWith timeSpecCodec > poke = pokeWith timeSpecCodec > ... All of these examples use the same types and logic for constructing Codecs, and it\'s very easy to create Codecs for any parsing\/serialization library. See "Data.Codec" for an introduction.
codeworld-api: 0.1.0.1. This module provides the drawing code for CodeWorld. It is heavily inspired by Gloss, but modified for consistency and pedagogical reasons. It comes with two backends. When compiled with GHCJS, it uses the JavaScript FFI to run on <http://code.world/>. When compiled with GHC, it uses the blank-canvas package to provide a webpage consisting of just a panel locally. This way, the same program that runs on the CodeWorld server can also be run locally.
coltrane: 0.1.0.0. Coltrane is a minimal web framework for Haskell, inspired by Ruby's Sinatra framework. Coltrane lets you write simple web applications in just a few lines of Haskell code.
command-qq: 0.2.0.0, 0.2.1.0, 0.2.2.0. Features: * Quasiquotation syntax for external interpreters > >>> [sh_| echo hello world! |] > hello world! * Custom quasiquoters > ghci = quoter $ callCommand "ghc" ["-ignore-dot-ghci", "-e"] Then you can use @ghci@ in ghci! > >>> [ghci| putStrLn "hello world!" |] :: IO () > hello world! For more examples, see "System.Command.QQ.Predef" * Haskell values embedding See README.md for an example * DSLs See @examples/CommandT.hs@
commands: 0.0.0. control your computer by voice, with "grammar combinators"
compacts: 0.
cond: 0.4.1. This library provides: * Implementations of various overloaded conditional operations * Lifted monadic variants of those operations and common boolean operators * A typeclass for boolean algebras. Feel free to send ideas and suggestions for new conditional operators to the maintainer. Monadic looping constructs are not included as part of this package, since the monad-loops package has a fairly complete collection of them already.
condor: 0.3. An Information Retrieval (IR) library which consists of the following components: * Search - for indexing and searching text documents. Check "Condor.Search.Index" for API information * Readers for reading documents from disk. Check "Condor.Reader.Text" folder text reader.
conduit: 1.1.0, 1.2.3. FIXME FIXME FIXME @conduit@ is a solution to the streaming data problem, allowing for production, transformation, and consumption of streams of data in constant memory. It is an alternative to lazy I\/O which guarantees deterministic resource handling, and fits in the same general solution space as @enumerator@\/@iteratee@ and @pipes@. For a tutorial, please visit <https://haskell.fpcomplete.com/user/snoyberg/library-documentation/conduit-overview>.
conduit-audio: 0.1. @conduit-audio@ applies @conduit@'s streaming data abilities to efficiently manipulate audio files and streams. Simple combinator functions let you mix files together, cut and paste sections of audio, and apply more complicated transformations like resampling or timestretching, all with the following properties: * Tiny memory usage, proportional only to the number of simultaneous sources\/effects * Uses no temporary files; everything is done in one pass * Blazing fast! (for most uses)
conduit-audio-sndfile: 0.1. A wrapper around @hsndfile@ (binding to the @libsndfile@ library) for use with @conduit-audio@, to load a wide variety of audio files as streams.
config-manager: 0.3.0.1. A configuration management library which supports: * name-value bindings, * required or optional imports, * comments. For details of the configuration file format, see <http://hackage.haskell.org/packages/archive/config-manager/latest/doc/html/Data-ConfigManager.html>.
configifier: 0.0.2. WARNING NOT READY FOR USE YET. JUST PUTTING IT OUT THERE TO HAVE A DISCUSSION. Read runtime configuration from files, command line, and shell environment in a uniform, canonical, and flexible way. Inspired by, among others, Configurator, cmdargs, optparse-applicative.
configuration-tools: 0.2, 0.2.1, 0.2.2, 0.2.3, 0.2.4, 0.2.4.1, 0.2.5, 0.2.6, 0.2.7, 0.2.8, 0.2.9, 0.2.10, 0.2.11, 0.2.12, 0.2.13, 0.2.14, 0.2.15. Tools for specifying and parsing configurations This package provides a collection of utils on top of the packages <http://hackage.haskell.org/package/optparse-applicative optparse-applicative>, <http://hackage.haskell.org/package/aeson aeson>, and <http://hackage.haskell.org/package/yaml yaml> for configuring libraries and applications in a convenient and composable way. The main features are 1. configuration management through integration of command line option parsing and configuration files and 2. 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 <https://github.com/alephcloud/hs-configuration-tools/blob/master/README.md README> and in the API documentation of the modules "Configuration.Utils" and "Configuration.Utils.Setup".
confsolve: 0.4. A command line tool for resolving conflicts of file synchronizers.
connection-pool: 0.1.0.0, 0.1.1.0, 0.1.2.0, 0.1.2.1, 0.1.3, 0.2, 0.2.1. Connection poll is a family specialised resource pools. Currently package provides two variants: 1. pool for TCP client connections, 2. and pool for UNIX Sockets client connections. In addition it can be used to build your own connection pool using provided primitives. This package is built on top of <http://hackage.haskell.org/package/resource-pool resource-pool> and <http://hackage.haskell.org/package/streaming-commons streaming-commons>. The later allows us to use <http://hackage.haskell.org/package/conduit-extra conduit-extra> package for implementation of TCP or UNIX Sockets clients. For examples and other details see documentation in "Data.ConnectionPool" module.
constrained-dynamic: 0.1.0.0. Like Data.Dynamic, but extended to allow the specification of arbitrary constraints using ConstraintKinds.
consul-haskell: 0.1. A consul client for Haskell Requires consul 0.5 or later.
containers: 0.5.8.1. This package contains efficient general-purpose implementations of various basic immutable container types. The declared cost of each operation is either worst-case or amortized, but remains valid even if structures are shared.
context-free-grammar: 0.0.1. Basic algorithms on context-free grammars: * augmenting a grammar * calculating nullability * calculating reachability * calculating productivity * calculating first sets * calculating follow sets * calculating predict sets You may define your context-free grammar textually using 'parse' or with the quasiquoter 'bnf' (both in "Data.Cfg.Bnf"), or you may use any data structure you like after making it an instance of 'Cfg' (found in "Data.Cfg.Cfg"). Testing is very thin in this version; basically just sanity-checking.
convertible: 1.1.1.0. convertible provides a typeclass with a single function that is designed to help convert between different types: numeric values, dates and times, and the like. The conversions perform bounds checking and return a pure Either value. This means that you need not remember which specific function performs the conversion you desire. Also included in the package are optional instances that provide conversion for various numeric and time types, as well as utilities for writing your own instances. Finally, there is a function that will raise an exception on bounds-checking violation, or return a bare value otherwise, implemented in terms of the safer function described above. Convertible is also used by HDBC 2.0 for handling marshalling of data to and from databases. Convertible is backed by an extensive test suite and passes tests on GHC and Hugs.
copr: 1.0.0. This provides a Haskell interface to the Fedora Copr public build system.
core-compiler: 0.1.0.0. This package doubles as a compiler and as a module with which anyone can compile their own functional programming language by parsing into the 'CoreExpr' datatype
core-haskell: 0.6, 0.6.1, 0.6.2, 0.6.3, 0.6.4. A subset of Haskell using in UCC for teaching purpose. It enables a tiny subset of Haskell default, but the syntax can be customized, teacher can enable more syntax along with the teaching progress.
count: 0.0.1. Combinators and a class for creating bijective functions between conceivably any countable sets and prefixes of the list of natural numbers.
court: 0.1.0.0. Simple and flexible CI system.
coverage: 0.1.0.4. A library for exhaustivity and redundancy checking.
cpio-conduit: 0.7.0. This is a native Haskell implementation of the CPIO protocol over the Conduit library. See <http://www.gnu.org/software/cpio/>. Only the commonly used CPIO formats are supported (crc and newc).
cpphs: 1.18. Cpphs is a re-implementation of the C pre-processor that is both more compatible with Haskell, and itself written in Haskell so that it can be distributed with compilers. This version of the C pre-processor is pretty-much feature-complete and compatible with traditional (K&R) pre-processors. Additional features include: a plain-text mode; an option to unlit literate code files; and an option to turn off macro-expansion.
cql: 3.0.1, 3.0.2, 3.0.3, 3.0.4, 3.0.5, 3.0.6, 3.0.7, 3.1.0, 3.1.1. Implementation of Cassandra's CQL Binary Protocol <https://github.com/apache/cassandra/blob/trunk/doc/native_protocol_v2.spec Version 2> and <https://github.com/apache/cassandra/blob/trunk/doc/native_protocol_v3.spec Version 3>. It provides encoding and decoding functionality as well as representations of the various protocol related types. Thus it can serve as a building block for writing Cassandra drivers, such as <http://hackage.haskell.org/package/cql-io cql-io>.
cql-io: 0.9.6, 0.9.7, 0.10.1, 0.12.0, 0.12.1, 0.12.2, 0.13.0, 0.13.1, 0.13.2, 0.14.1, 0.14.2, 0.14.3, 0.14.4, 0.14.5, 0.15.2, 0.16.0. CQL Cassandra driver supporting native protocol versions 2 and 3. This library uses the <http://hackage.haskell.org/package/cql cql> library which implements Cassandra's CQL protocol and complements it with the neccessary I/O operations. The feature-set includes: * /Node discovery/. The driver discovers nodes automatically from a small set of bootstrap nodes. * /Customisable load-balancing policies/. In addition to pre-built LB policies such as round-robin, users of this library can provide their own policies if desired. * /Support for connection streams/. Requests can be multiplexed over a few connections. * /Customisable retry settings/. Support for default retry settings as well as local overrides per query. * /Prepared queries/. Prepared queries are an optimisation which parse and prepare a query only once on Cassandra nodes but execute it many times with different concrete values. * /TLS support/. Client to node communication can optionally use transport layer security (using HsOpenSSL).
crawlchain: 0.1.0.7. Warning: experimental
cric: 0.1.0.0. A simple server confguration management tool
cron: 0.2.0, 0.2.2. Cron data structure and Attoparsec parser. The idea is to embed it in larger systems which want to roll their own scheduled tasks in a format that people are used to. 'System.Cron' is where all the interesting datatypes live. You will also find 'scheduleMatches', which you can use to compare a time against a 'CronSchedule' to see if an action needs to be performed. System.Cron.Parser is where you will find the parsers `cronSchedule`, `crontabEntry` and `cronTab`. To parse individual schedules up to full crontab files.
cruncher-types: 1.0.0. You are not likely to find this useful unless you are building a library for accessing Eval.so's new API, or working on the "Cruncher" backend.
cryptohash-md5: 0.11.7.1, 0.11.7.2, 0.11.100.0, 0.11.100.1. A practical incremental and one-pass, pure API to the <https://en.wikipedia.org/wiki/MD5 MD5 hash algorithm> (including <https://en.wikipedia.org/wiki/HMAC HMAC> support) with performance close to the fastest implementations available in other languages. The implementation is made in C with a haskell FFI wrapper that hides the C implementation. NOTE: This package has been forked off @cryptohash-0.11.7@ because the @cryptohash@ package has been deprecated and so this package continues to satisfy the need for a lightweight package providing the MD5 hash algorithm without any dependencies on packages other than @base@ and @bytestring@. Consequently, this package can be used as a drop-in replacement for @cryptohash@'s "Crypto.Hash.MD5" module, though with a clearly smaller footprint.
cryptohash-sha1: 0.11.7.1, 0.11.7.2, 0.11.100.0, 0.11.100.1. A practical incremental and one-pass, pure API to the <https://en.wikipedia.org/wiki/SHA-1 SHA-1 hash algorithm> (including <https://en.wikipedia.org/wiki/HMAC HMAC> support) with performance close to the fastest implementations available in other languages. The implementation is made in C with a haskell FFI wrapper that hides the C implementation. NOTE: This package has been forked off @cryptohash-0.11.7@ because the @cryptohash@ package has been deprecated and so this package continues to satisfy the need for a lightweight package providing the SHA1 hash algorithm without any dependencies on packages other than @base@ and @bytestring@. Consequently, this package can be used as a drop-in replacement for @cryptohash@'s "Crypto.Hash.SHA1" module, though with a clearly smaller footprint.
cryptohash-sha512: 0.11.100.1. A practical incremental and one-pass, pure API to the <https://en.wikipedia.org/wiki/SHA-2 SHA-512 hash algorithm> (including <https://en.wikipedia.org/wiki/HMAC HMAC> support) with performance close to the fastest implementations available in other languages. The implementation is made in C with a haskell FFI wrapper that hides the C implementation. NOTE: This package has been forked off @cryptohash-0.11.7@ because the @cryptohash@ package has been deprecated and so this package continues to satisfy the need for a lightweight package providing the SHA512 hash algorithm without any dependencies on packages other than @base@ and @bytestring@. Consequently, this package can be used as a drop-in replacement for @cryptohash@'s "Crypto.Hash.SHA512" module, though with a clearly smaller footprint.
cryptsy-api: 0.1, 0.2.1. Bindings for Cryptsy cryptocurrency exchange API.
cubical: 0.1.0, 0.1.1, 0.1.2, 0.2.0. Cubical implements an experimental simple type checker for type theory with univalence with an evaluator for closed terms.
cubicbezier: 0.2.0. This library supports efficient manipulating of 2D cubic bezier curves. The original goal is to support typography, but it is useful for general graphics. Supported features are: Evaluating bezier curves and derivatives, affine transformations on bezier curves, arclength and inverse arclength, intersections between two curves, intersection between a curve and a line, curvature and radius of curvature, finding tangents parallel to a vector, finding inflection points and cusps. It also supports polynomial root finding with Bernstein polynomials. The module "Geom2D.CubicBezier" exports all the cubic bezier functions. The module "Geom2D" contains general 2D geometry functions and transformations.
cublas: 0.2.0.0, 0.2.0.2, 0.2.1.0. This package provides FFI bindings to the NVIDIA CUDA CUBLAS and CUSPARSE linear algebra GPU BLAS implementations. The modules @Foreign.CUDA.Cublas@ and @Foreign.CUDA.Cusparse@ are probably the most useful. Requires CUDA version 6.5. If you have trouble installing this package, it may help to view the Github page: <http://github.com/bmsherman/cublas>
daemon: 0.1.0.0. TODO: Longer description
daemons: 0.2.1. "Control.Pipe.C3" provides simple RPC-like wrappers for pipes. "Control.Pipe.Serialize" provides serialization and incremental deserialization pipes. "Control.Pipe.Socket" provides functions to setup pipes around sockets. "System.Daemon" provides a high-level interface to starting daemonized programs that are controlled through sockets. "System.Posix.Daemon" provides a low-level interface to starting, and controlling detached jobs. See the @README.md@ file and the homepage for details.
damage-patterns: 0.27. This diagramming tool was used in number of ancient DNA analyses. It has now being separated and somewhat cleaned up, since apparently it will not be thrown away soon.
dash-haskell: 1.0.0.0, 1.0.0.1, 1.0.0.2, 1.0.0.3, 1.0.0.4, 1.1.0.0, 1.1.0.1. A Dash.app docset is a file-layout for allowing easy lookup and indexing of programming docs, e.g. API functions and modules. A number of plugins offer docset lookup in editors such as Emacs and Vim. By using this tool, one can convert haskell package haddock(s) to docsets. The major benefit of dash-haskell, is that once these docsets are built, dash tools provide one of the few, if only solutions for offline, contextual, and project dependency approximate IDE documentation for Haskell. Usage Examples: >$ dash-haskell parsec-3.1.5 builds: >./docsets/parsec-3.1.5.docset >$ dash-haskell -c foo.cabal -s builds all packages listed as dependencies in the cabal file, using the default db ordering (global, sandbox, user). Note: haddock documentation for the package must first be built prior to calling dash-haskell on it, e.g. >$ cabal install --only-dependencies --enable-documentation Versions: The version numbering scheme for this package is defined as follows, given: >dash-haskell-a.b.c.d a, b index interface or feature changes to the CLI c, d index bug-fix and documentation updates
data-default-extra: 0.0.1. An alternative to <https://hackage.haskell.org/package/data-default data-default> package, that provides a lot of additional instances for @Default@ type class. @Default@ type class provides a default value (@def@) of a type. In case when a particluar type has an instance for @Monoid@, then the default value should be @mempty@, otherwise it can cause a great deal of confusion. One must understand, that @Default@ type class, has no axioms associated with it. Its purpose is to minimize: * Number of imports. * Number of introduced definitions that are part of an API. * Complexity of building more complicated \"default values\" out of simpler \"default values\". * Cognitive overhead. (Reduction of cognitive overhead is partially a consequence of reducing above issues.) As one may notice, most of the listed problems, that @Default@ type class tries to solve, to various degrees of success, are for human benefit, and not theoretically founded. Because of this, please always try hard to define sensible instances of @Default@. Most importantly, document what @def@ means for particular type, and always check that @def@ is sensible, by testing it on a real world sample of human beings, one is not a big enough sample. That said, using @Default@ may not always be a good idea. If it breaks people's mental model, or theoretical models with real axioms, then just don't use it.
data-default-generics: 0.3. A class for types with a default value. Features generics support to add defaults to records.
data-default-instances-case-insensitive: 0.0.1. Orphan instances for @Default@ type class, which is defined in package <https://hackage.haskell.org/package/data-default-class data-default-class>. Following @Default@ instances are provided: > instance (Default s, FoldCase s) => Default (CI s) where > def = mk def
data-default-instances-text: 0.0.1. Orphan instances for @Default@ type class, which is defined in package <https://hackage.haskell.org/package/data-default-class data-default-class>. Following @Default@ instances are provided: > -- Strict Text: > instance Default Text where > def = empty > > -- Lazy Text: > instance Default Text where > def = empty Following instances are provided only for <https://hackage.haskell.org/package/text text> >=0.8, since that it the version that introduced @Builder@: > instance Default Builder where > def = mempty
data-default-instances-unordered-containers: 0.0.1. Orphan instances for @Default@ type class, which is defined in package <https://hackage.haskell.org/package/data-default-class data-default-class>. Following @Default@ instances are provided: > instance Default (HashMap k v) where > def = empty > > instance Default (HashSet a) where > def = empty
data-default-instances-vector: 0.0.1. Orphan instances for @Default@ type class, which is defined in package <https://hackage.haskell.org/package/data-default-class data-default-class>. Following @Default@ instances are provided: > instance Default (Vector a) where > def = empty > > -- Storable Vector: > instance Storable a => Default (Vector a) where > def = empty > > -- Unboxed Vector: > instance Unbox a => Default (Vector a) where > def = empty
data-dispersal: 1.0.0.0, 1.0.0.1, 1.0.0.2. Given a ByteString of length @D@, we encode the ByteString as a list of @n@ 'Fragment's, each containing a ByteString of length @O(D/m)@. Then, each fragment could be stored on a separate machine to obtain fault-tolerance: Even if all but @m@ of these machines crash, we can still reconstruct the original ByteString out of the remaining @m@ fragments. Note that the total space requirement of the @m@ fragments is @m * O(D/m)=O(D),@ which is clearly space-optimal. The total space required for the n fragments is @O((n/m)*D)@. Note that @m@ and @n@ can be chosen to be of the same order, so the asymptotic storage overhead for getting good fault-tolerance increases only by a constant factor. /GHCi Example:/ > > :m + Data.IDA > > let msg = Data.ByteString.Char8.pack "my really important data" > > let fragments = encode 5 15 msg > -- Now we could distributed the fragments on different sites to add some > -- fault-tolerance. > > let frags' = drop 5 $ take 10 fragments -- let's pretend that 10 machines crashed > -- Let's look at the 5 fragments that we have left: > > mapM_ (Prelude.putStrLn . show) frags' > (6,[273,771,899,737,285]) > (7,[289,939,612,285,936]) > (8,[424,781,1001,322,788]) > (9,[143,657,790,157,423]) > (10,[314,674,418,888,423]) > -- Space-efficiency: Note that the length of each of the 5 fragments is 5 > -- and our original message has length 24. > > decode frags' > "my really important data" /Encrypted Fragments:/ The module @Data.IDA@ contains an information dispersal algorithm that produces space-optimal fragments. However, the knowledge of 1 or more fragments might allow an adversary to deduce some information about the original data. The module @Crypto.IDA@ combines information dispersal with secret sharing: the knowledge of up to @m-1@ fragments does not leak any information about the original data. This could be useful in scenarios where we need to store data at untrusted storage sites: To this end, we store one encrypted fragment at each site. If at most @m-1@ of these untrusted sites collude, they will still be unable to obtain any information about the original data. The added security comes at the price of a slightly increased fragment size (by an additional constant 32 bytes) and an additional overhead in the running time of the encoding/decoding process. The algorithm is fully described in module "Crypto.IDA". /Fault-Tolerance:/ Suppose that we have @N@ machines and encode our data as @2log(N)@ fragments with reconstruction threshold m = @log(N)@. Let's assume that we store each fragment on a separate machine and each machine fails (independently) with probability at most 0.5. * What is the probability of our data being safe? @Pr[ at most n-m machines crash ] >= 1-0.5^(log(N)) = 1-N^(-1).@ * What is the overhead in terms of space that we pay for this level of fault-tolerance? We have n fragments, each of size @O(D\/m)@, so the total space is @O(n D\/ m) = 2D.@ In other words, we can guarantee that the data survives with high probability by increasing the required space by a constant factor. This library is based on the following works: * \"Efficient Dispersal of Information for Security, Load Balancing, and Fault Tolerance\", by Michael O. Rabin, JACM 1989. * \"How to share a secret.\" by Adi Shamir. In Communications of the ACM 22 (11): 612–613, 1979. * \"Secret Sharing Made Short\" Hugo Krawczyk. CRYPTO 1993: 136-146
data-interval: 0.5.0, 0.6.0, 1.0.0, 1.0.1, 1.1.0, 1.1.1, 1.2.0. Interval datatype and interval arithmetic for Haskell. Unlike the intervals package (<http://hackage.haskell.org/package/intervals>), this package provides both open and closed intervals and is intended to be used with exact number types such as Rational and Integer.
data-lens-template: 2.1.8. Automatically derive @Lens@es for your data type for use with @Data.Lens@. Note: the code is derived from data-accessor-template <http://hackage.haskell.org/package/data-accessor-template> by Luke Palmer and Henning Thielemann.
data-msgpack: 0.0.1, 0.0.2, 0.0.3, 0.0.4. A Haskell implementation of MessagePack <http://msgpack.org/> This is a fork of msgpack-haskell <https://github.com/msgpack/msgpack-haskell>, since the original author is unreachable. This fork incorporates a number of bugfixes and is actively being developed.
data-transform: 0.1.0.0. This library provides a simple way to transform parts of complex data structures. It is based on Data.Data.
decoder-conduit: 0.0.1.0. Simple conduit for decoding ByteStrings into values using Data.Binary.Get
deepseq: 1.4.0.0, 1.4.1.0, 1.4.1.1, 1.4.1.2, 1.4.2.0. This package provides methods for fully evaluating data structures (\"deep evaluation\"). Deep evaluation is often used for adding strictness to a program, e.g. in order to force pending exceptions, remove space leaks, or force lazy I/O to happen. It is also useful in parallel programs, to ensure pending work does not migrate to the wrong thread. The primary use of this package is via the 'deepseq' function, a \"deep\" version of 'seq'. It is implemented on top of an 'NFData' typeclass (\"Normal Form Data\", data structures with no unevaluated components) which defines strategies for fully evaluating different data types.
deepseq-generics: 0.1.1.1, 0.1.1.2, 0.2.0.0. This package provides a "GHC.Generics"-based 'Control.DeepSeq.Generics.genericRnf' function which can be used for providing a 'rnf' implementation. See the documentation for the 'genericRnf' function in the "Control.DeepSeq.Generics" module to get started. The original idea was pioneered in the @generic-deepseq@ package (see <http://www.haskell.org/pipermail/haskell-cafe/2012-February/099551.html> for more information). This package differs from the @generic-deepseq@ package by working in combination with the existing @deepseq@ package as opposed to defining a conflicting drop-in replacement for @deepseq@'s @Control.DeepSeq@ module. __Note__: The ability to auto-derive via "GHC.Generics" has been merged into @deepseq-1.4.0.0@. This package is now still useful for writing code that's also compatible with older @deepseq@ versions not yet providing "GHC.Generics"-support.
delay: 0. Functions to provide delays, timeouts, and callbacks where the target time is calculated either from a period as an offset from the initialization time, or at a specific 'UTCTime'. Most standard Haskell types are supported for periods, based on the second as the base unit quantity. For more complicated period calculations, 'Dimensional's 'Time' type is supported.
delta: 0.1.0.0, 0.2.1.2. Delta is a library for detecting file changes in any given directory. The package is written using the sodium FRP library but it also provides a callback based API. The project also contains an executable, delta-run, which allows you to run arbitrary shell commands when a file in a directory (recursively) changes. @ $> delta-run --help Usage: delta-run [-i|--interval INTERVAL] [-v|--verbose] FILE CMD Available options: -h,--help Show this help text -i,--interval INTERVAL Run at most every n seconds -v,--verbose Print extra output FILE The directory that is watched CMD The command to run @ For example you could use @delta-run@ to rebuild your project everytime the source changes like this: @ delta-run src "cabal build" @
derive-enumerable: 0.1.0.0. Generalized equivalent to doing `[minBound..maxBound]` but on complex types. > λ :m +Data.Enumerable.Generic > λ :set -XDeriveGeneric > λ data Flag = Flag Bool Word8 deriving (Show, Generic) > λ instance Enumerable Flag > λ instance Default Flag where def = Flag False 0 > λ allEnum :: [Flag] > [Flag False 0,Flag True 0,Flag False 1, (..snip..) Flag False 255,Flag True 255]
derive-monoid: 0.0.0. when your type can hold a list of itself, you can derive simple (but total\/lawful) Semigroup\/Monoid\/IsList instances with TemplateHaskell. see the <https://hackage.haskell.org/package/derive-monoid/docs/Derive-List.html Derive.List> for examples and documentation. browse the <https://github.com/sboosali/derive-monoid/tree/master/test/Build/Derive/List test suite> for more (buildable) examples: * <https://github.com/sboosali/derive-monoid/blob/master/test/Build/Derive/List/HigherKind.hs HigherKind> * <https://github.com/sboosali/derive-monoid/blob/master/test/Build/Derive/List/IsList.hs IsList> * <https://github.com/sboosali/derive-monoid/blob/master/test/Build/Derive/List/Monoid.hs Monoid> * <https://github.com/sboosali/derive-monoid/blob/master/test/Build/Derive/List/Semigroup.hs Semigroup>
dgim: 0.0.1, 0.0.2, 0.0.3. A basic implementation of the DGIM algorithm for counting the occurrence of certain elements in a fixed length prefix of a stream.
diagrams-contrib: 1.1.1.2, 1.1.1.5. A collection of user contributions for diagrams, an embedded domain-specific language for generation of vector graphics.
diagrams-core: 1.1.0.1, 1.1.0.3, 1.2.0.2. The core modules underlying diagrams, an embedded domain-specific language for compositional, declarative drawing.
diagrams-haddock: 0.2.2.4. diagrams-haddock is a tool for compiling embedded inline diagrams code in Haddock documentation, for an easy way to spice up your documentation with diagrams. Just create some diagrams code using special markup, run diagrams-haddock, and ensure the resulting image files are installed along with your documentation. For complete documentation and examples, see <https://github.com/diagrams/diagrams-haddock/blob/master/README.md>. For a good example of a package making use of diagrams-haddock, see the diagrams-contrib package (<http://hackage.haskell.org/package/diagrams%2Dcontrib>).
diagrams-hsqml: 0.0.0.0, 0.0.0.1, 0.0.0.2, 0.1.0.0. `diagrams-hsqml` is a `diagrams` backend painting on a QtQuick Canvas. To use the package, you only need the main module "Diagrams.Backend.HsQML" Example usage and QML scripts provided in "Diagrams.Backend.HsQML.Tutorial"
diagrams-lib: 1.1.0.3, 1.1.0.7. Diagrams is a flexible, extensible EDSL for creating graphics of many types. Graphics can be created in arbitrary vector spaces and rendered with multiple backends. diagrams-lib provides a standard library of primitives and operations for creating diagrams. To get started using it, see "Diagrams.Prelude".
diagrams-wx: 0.1.0.0, 0.1.1.0. An optional add-on to the diagrams-cairo package which allows rendering diagrams in wxWidgets (using wxHaskell).
dice-entropy-conduit: 1.0.0.0. This library uses rejection sampling to provide cryptographically secure @n@-sided dice rolls and random sampling (within a given range). The number of used random bits is close to the information-theoretic optimal bound. The API provides a conduit interface. See module "System.Random.Dice" for a more detailed description. Feedback is welcome!
diff-parse: 0.1.2. Parse output produced by git diff.
dimensional: 1.0.1.1. Dimensional is a library providing data types for performing arithmetic with physical quantities and units. Information about the physical dimensions of the quantities and units is embedded in their types and the validity of operations is verified by the type checker at compile time. The boxing and unboxing of numerical values as quantities is done by multiplication and division with units. The library is designed to, as far as is practical, enforce/encourage best practices of unit usage. Version 1 of the dimensional package differs from earlier version in that the dimension tracking is implemented using Closed Type Families and Data Kinds rather than functional dependencies. This enables a number of features, including improved support for unit names and quantities with statically-unknown dimensions. Requires GHC 7.8 or later.
diophantine: 0.1.0.0, 0.2.0.0, 0.2.1.0. A library for solving quadratic diophantine equations. This library is designed to solve for equations where: * The form is: ax^2 + bxy + cy^2 + dx + ey + f = 0 * a,b,c,d,e,f are integers. * Solutions are restricted to x and y are also integers. This library breaks down equations based on their type to solve them most efficiently. This library supports linear, simple hyperbolic, eliptical, and parabolic equations, with hyperbolics on the way. Please send feedback or bugs to joejev\@gmail.com.
directed-cubical: 0.1.2.0. Finite directed cubical complexes and associated algorithms
directory-layout: 0.6.0.0, 0.6.0.1, 0.6.1.0, 0.6.1.1, 0.7.0.0, 0.7.1.0, 0.7.2.0, 0.7.3.0. Making, fitting, printing directory layouts
discogs-haskell: 0.0.5.0. Please see README.md
disk-free-space: 0.1.0.0, 0.1.0.1. A cross-platform library retrieve information about disk space usage.
distributed-process: 0.5.0, 0.5.5.1. This is an implementation of Cloud Haskell, as described in /Towards Haskell in the Cloud/ by Jeff Epstein, Andrew Black, and Simon Peyton Jones (<http://research.microsoft.com/en-us/um/people/simonpj/papers/parallel/>), although some of the details are different. The precise message passing semantics are based on /A unified semantics for future Erlang/ by Hans Svensson, Lars-Åke Fredlund and Clara Benac Earle. You will probably also want to install a Cloud Haskell backend such as distributed-process-simplelocalnet.
distributed-process-client-server: 0.1.3.1. Modelled after Erlang OTP's gen_server, this framework provides similar facilities for Cloud Haskell, grouping essential practices for client/server development into a set of modules and standards designed to help you build concurrent, distributed applications with relative ease.
distributed-process-execution: 0.1.2.1. The Execution Framework provides tools for load regulation, workload shedding and remote hand-off. The currently implementation provides only a subset of the plumbing required, comprising tools for event management, mailbox buffering and message routing.
distributed-process-extras: 0.2.1.1. Supporting library, providing common types and utilities used by the various components that make up the distributed-process-platform package.
distributed-process-lifted: 0.1.0.0. This package provides typeclasses and functions for lifting functions and control operations (such as spawnLocal) from the @Process@ monad into transformer stacks based on the Process monad. It uses <http://hackage.haskell.org/package/monad-control-1.0.0.1/docs/Control-Monad-Trans-Control.html#t:MonadTransControl MonadTransControl> and a new typeclass 'Control.Distributed.Process.Lifted.Class.MonadProcessBase' which plays the same role as <http://hackage.haskell.org/package/monad-control-1.0.0.1/docs/Control-Monad-Trans-Control.html#t:MonadBaseControl MonadBaseControl>. Instances are provided for all the <http://hackage.haskell.org/package/transformers transformers> types - so stacks based on any of these (e.g. @ReaderT Config Process a@) can be used seamlessly. The Control.Distributed.Process.Lifted module exports all the same symbols as found in Control.Distributed.Process, but they are all generalized. Where appropriate it re-exports the more general functions from lifted-base (e.g. catch) rather than the versions re-implemented for @Process@.
distributed-process-monad-control: 0.5.0, 0.5.1, 0.5.1.1, 0.5.2. This module only exports instances for @'MonadBase' @'IO' and @'MonadBaseControl' @'IO' for the @'Process' monad. This is for use in conjunction with a library requiring these instances, such as the @<http://hackage.haskell.org/package/lifted-base lifted-base> package. A tutorial segment regarding use of this in distributed-process applications may be found <http://haskell-distributed.github.io/tutorials/3ch.html#monad-transformer-stacks here>. Please excercise caution in usage of this instance, as it can enable use of functions such as 'forkIO' (or, 'fork' from 'lifted-base') which compromise invariants in the Process monad and can lead to confusing and subtle issues. Always use the Cloud Haskell functions such as `spawnLocal` instead. example usage: >import Control.Distributed.Process.MonadBaseControl() >import Control.Concurrent.MVar.Lifted (withMVar) > >processWithMVar :: MVar a -> (a -> Process b) -> Process b >processWithMvar = withMVar
distributed-process-platform: 0.1.0. Modelled after Erlang's OTP, this framework provides similar facilities for Cloud Haskell, grouping essential practices into a set of modules and standards designed to help you build concurrent, distributed applications with relative ease.
distributed-process-registry: 0.1.0.1. This package provides an extended process registry.
distributed-process-simplelocalnet: 0.2.1.0, 0.2.3.1. Simple backend based on the TCP transport which offers node discovery based on UDP multicast. This is a zero-configuration backend designed to get you going with Cloud Haskell quickly without imposing any structure on your application.
distributed-process-supervisor: 0.1.3.1. A part of the Cloud Haskell framework This package implements a process which supervises a set of other processes, referred to as its children. These child processes can be either workers (i.e., processes that do something useful in your application) or other supervisors. In this way, supervisors may be used to build a hierarchical process structure called a supervision tree, which provides a convenient structure for building fault tolerant software. For detailed information see "Control.Distributed.Process.Supervisor"
distributed-process-task: 0.1.2.1. The Task Framework intends to provide tools for task management, work scheduling and distributed task coordination. These capabilities build on the Async Framework as well as other tools and libraries. The framework is currently a work in progress. The current release includes a simple bounded blocking queue implementation only, as an example of the kind of capability and API that we intend to produce.
distributed-process-tests: 0.4.3.1, 0.4.3.2. Tests and test suite for Cloud Haskell libraries.
distributed-process-zookeeper: 0.2.0.0. Provides service and node discovery for Cloud Haskell applications using a Zookeeper cluster for name registration, lookups and leader election. Uses the hzk bindings to the Zookeeper multi-threaded C library. Objectives and features: * Compatible with <http://hackage.haskell.org/package/distributed-process-p2p distributed-process-p2p> API - can work as a drop-in replacement. * No dependencies beyond those already included by distributed-process, hzk and network-transport-tcp. * Automatic registration of local names to Zookeeper. * Global singleton processes with leader election and re-elections on leader exit. Check out the <https://github.com/jeremyjh/distributed-process-zookeeper/blob/master/examples/Boss.hs example>.
distributed-static: 0.3.0.0. /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.
diversity: 0.2.0.5. Find the diversity of a collection of entities, mainly for use with fasta sequences. Produces a binary which works on fasta files to find the diversity of any order and rarefaction curves for a sliding window across all positions in the sequences. To analyze just a collection of entities, just use the whole sequences and list flag.
docvim: 0.1.0.0, 0.2.0.0, 0.3.0.0, 0.3.1.0, 0.3.1.1, 0.3.1.2, 0.3.1.3. Produces Vim help and HTML (via Markdown) documentation.
dozenal: 0.1.0.0. A Haskell library for using Dozenal (Duodecimal - Base 12) numbers.
ds-kanren: 0.2.0.0, 0.2.0.1. ds-kanren is an implementation of the <http://minikanren.org miniKanren> language.
dson-parsec: 0.4.0.0, 0.4.1.0. A parser for DSON strings built with parsec3.
dual-category: 0.0.1. A data type that is essentially a pair of categories, from a->b and b->a. However a whole bunch of instances are defined on such categories, which allow them to be used almost as arrows. One possible use case are composable reversible functions.
dual-tree: 0.2.0.3. Rose (n-ary) trees with both upwards- (/i.e./ cached) and downwards-traveling (/i.e./ accumulating) monoidal annotations. This is used as the core data structure underlying the @diagrams@ framework (<http://projects.haskell.org/diagrams>), but potentially has other applications as well. Abstractly, a DUALTree is a rose (n-ary) tree with data (of type @l@) at leaves, data (of type @a@) at internal nodes, and two types of monoidal annotations, one (of type @u@) travelling \"up\" the tree and one (of type @d@) traveling \"down\". See "Data.Tree.DUAL" for full documentation. "Data.Tree.DUAL" provides a public API which should suffice for most purposes. "Data.Tree.DUAL.Internal" exports more of the internal implementation---use it at your own risk.
dynamic-mvector: 0.1.0.1.
eager-sockets: 0.1. Socket operations such as connect\/receive\/send with timeouts.
easy-bitcoin: 0.0.0.1, 0.0.0.2. EasyBitcoin is a simple library providing types and class-instances for bitcoin related code; it also include an small set of functions to handle addresses, transactions and escrows.
easyrender: 0.1.0.0, 0.1.0.1, 0.1.1.0, 0.1.1.1, 0.1.1.2. This module provides efficient functions for rendering vector graphics to a number of formats, including EPS, PostScript, and PDF. It provides an abstraction for multi-page documents, as well as a set of graphics primitives for page descriptions. The graphics model is similar to that of the PostScript and PDF languages, but we only implement a subset of their functionality. Care has been taken that graphics rendering is done efficiently and as lazily as possible; documents are rendered \"on the fly\", without the need to store the whole document in memory. The provided document description model consists of two separate layers of abstraction: * /drawing/ is concerned with placing marks on a fixed surface, and takes place in the 'Draw' monad; * /document structure/ is concerned with a sequence of pages, their bounding boxes, and other meta-data. It takes place in the 'Document' monad. In principle, the functionality provided by EasyRender is similar to a subset of Cairo; however, EasyRender is lightweight and at least an order of magnitude faster.
ec2-signature: 2.0, 3.0, 3.1. The Amazon EC2 style signature calculator. <http://docs.aws.amazon.com/general/latest/gr/signature-version-2.html>
ecma262: 0.0.0. A library for iterpreting ECMA-262 code.
eden: 0.1.0.0. project Euler Development ENgine
edenskel: 2.0.0.0, 2.0.0.1, 2.0.0.2, 2.1.0.0. This package provides a skeleton library for semi-explicit parallel programming with Eden. Eden and the skeleton library depend on GHC, and should normally use a GHC extension to support parallel execution using message passing. This modified GHC-Eden compiler is available from the <http://www.mathematik.uni-marburg.de/~eden Eden homepage>. When built using a standard GHC, this package will use a threaded simulation of Eden. The <http://www.mathematik.uni-marburg.de/~eden Eden homepage> provides more documentation and a tutorial.
edentv: 4.3.0, 4.9.2. The Eden Trace Viewer is a tool designed to help programmers optimize Eden programs by visualising traces (eventlog files) of Eden program runs. It is similar to (and precedes) threadscope. However, it has been designed to visualize not just threads, but also different machines, processes, and messages between processes. EdenTV can show you what has happened during the execution of your program. This is very helpful to optimize parallel programs.
edge: 0.9.1.0, 0.9.1.1. 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!
edis: 0.0.1.0. Statically typechecked Redis
effect-monad: 0.6, 0.6.1. Provides the 'parametric effect monad' structure to Haskell with a number of analogous of familiar monads (Reader, Writer, State, Maybe, Counter, Update) and a wrapper over normal monads (Control.Effect.Monad). This provides a way to embed effect systems into Haskell. For more information see with paper \"Embedding effect systems in Haskell\" by Orchard and Petricek <http://www.cl.cam.ac.uk/~dao29/publ/haskell14-effects.pdf> (Haskell, 2014) and the examples in <https://github.com/dorchard/effect-monad/tree/master/examples>. (note, this package was previously called 'ixmonad' until September 2014).
effective-aspects: 0.1.0.0. A monadic embedding of aspect oriented programming, similar to AspectJ
egison: 3.2.15. An interpreter for Egison, the programming langugage that realized non-linear pattern-matching against unfree data types. With Egison, you can represent pattern-matching against unfree data types intuitively, especially for collection data, such as lists, multisets, sets. We can find Egison programs in @lib@ and @sample@ directories. This package also include Emacs Lisp file @egison-mode.el@ in @elisp@ directory. The following code is the program that determins poker-hands written in Egison. All hands are expressed in a single pattern. You can run this code online at <http://www.egison.org/demonstrations/poker-hands.html>. <<http://www.egison.org/images/poker-hands.png>> The pattern-matching of Egison is very powerful. We can use it for pattern-matching against graphs, too. Egison is not popular at all now. Please help us to make Egison popular.
eigen: 1.1.1, 1.1.3, 1.2.1, 2.1.0, 2.1.1, 2.1.2. This module provides Haskell binding for Eigen C++ library. Eigen is a C++ template library for linear algebra: matrices, vectors, numerical solvers, and related algorithms. Eigen home page is <http://eigen.tuxfamily.org/>. Eigen is licensed under the MPL2, which is a simple weak copyleft license. Common questions about the MPL2 are answered in the official MPL2 FAQ at <http://www.mozilla.org/MPL/2.0/FAQ.html>. Note that currently, a few features in Eigen rely on third-party code licensed under the LGPL: SimplicialCholesky, AMD ordering, and constrained_cg. Such features are explicitly disabled by compiling Eigen with the EIGEN_MPL2_ONLY preprocessor symbol defined. Virtually any software may use Eigen. For example, closed-source software may use Eigen without having to disclose its own source code. Many proprietary and closed-source software projects are using Eigen right now, as well as many BSD-licensed projects. Some parts of documentation strings are based or replicate original Eigen documentation which is available at <http://eigen.tuxfamily.org/dox/>.
ekg-push: 0.0.2. This library lets you push metric samples to a broadcast channel. Consumers can then persist the samples as they wish.
elm-build-lib: 0.0.1, 0.0.3, 0.1, 0.14.0.0. This library provides both runtime and Template Haskell functions which let you take multi-module Elm Programs and compile them to JavaScript. The main goal of this is to allow Elm to be used as a frontend for Haskell servers or Web apps. The library is independent of any specific framework, so it should work with Yesod, Snap, Happstack, Scotty, etc.
elm-core-sources: 1.0.0. Embeds the standard libraries and runtime files of the Elm language as Haskell strings, so that they can be used for compilation and served in a Haskell web server. For more information on the Elm language, see http://elm-lang.org.
elocrypt: 0.3.0, 0.3.1, 0.3.2. Generates pronounceable, hard-to-guess passwords.. as hard as Vince Carter's knee cartilage is.
email-validator: 0.0.2. Validate an email address using three techniques: * Ensuring that the length of local and domain parts is within the RFC-specified limits. * A syntax check using a regular expression, or the full RFC 5322 grammar (see the @--rfc5322@ option). * Confirmation of the existence of an @MX@ record for the domain part of the address. This is not required; in fact many domains accept mail via an @A@ record for e.g. example.com which is used in lieu of an @MX@ record. This behavior can be controlled via the @--accept-a@ flag. These checks are performed in parallel using the number of available threads. To increase the number of threads, you can pass the appropriate flag to the GHC runtime. This will set the number of threads to 25: @ $ email-validator -i addresses.csv +RTS -N25 @ /Input/ The @input@ file (default: stdin) should be a list of email addresses, one per line. Empty lines will be ignored. /Output/ Valid email addresses will be written to the output file (default: stdout), one per line.
enclosed-exceptions: 1.0.0. Catching all exceptions raised within an enclosed computation, while remaining responsive to (external) asynchronous exceptions.
endo: 0.1.0.0, 0.1.0.1, 0.1.0.2, 0.2.0.0, 0.2.0.1, 0.3.0.0, 0.3.0.1. Package defines extra functions for 'Data.Monoid.Endo' data type, and also generic endomorphism folding machinery. Generic endomorphism folding can be used for various purposes, including as a builder. Here is an example how to use it with <http://hackage.haskell.org/package/optparse-applicative optparse-applicative> package: > data Verbosity = Silent | Normal | Verbose | Annoying > deriving (Show) > data Config = Config Verbosity FilePath > deriving (Show) > options :: Parser Config > options = runIdentityT $ runEndo defaultConfig <$> options' > where > -- All this IdentityT clutter is here to avoid orphan instances. > options' :: IdentityT Parser (Endo Config) > options' = foldEndo > <*> outputOption -- :: IdentityT Parser (Maybe (E Config)) > <*> verbosityOption -- :: IdentityT Parser (Maybe (E Config)) > <*> annoyingFlag -- :: IdentityT Parser (E Config) > <*> silentFlag -- :: IdentityT Parser (E Config) > <*> verboseFlag -- :: IdentityT Parser (E Config) > > defaultConfig :: Config > defaultConfig = Config Normal "" > main :: IO () > main = execParser (info options fullDesc) >>= print > ghci> :main -o an.out.put --annoying > Config Annoying "an.out.put" For details how individual option parsers look like see module "Data.Monoid.Endo.Fold" which contains other examples as well as this one.
enummapmap: 0.6.0. This package provides 'maps of maps' using Enum types as keys. The code is based upon Data.IntMap in containers 5.0.
error-util: 0.0.0.1. Set of utils and operators for error handling
ersatz-toysat: 0.2.0.0. toysat driver as backend for ersatz
ert: 0.0.1.0.
estimator: 1.0.0. 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 <http://hackage.haskell.org/package/sbv sbv> or <http://hackage.haskell.org/package/ivory 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.
etcd: 0.1.0.1, 0.1.0.2. See <https://coreos.com/using-coreos/etcd/>
eventsourced: 0.1.0.0, 0.1.1.0, 0.1.1.2, 0.1.1.3, 0.1.1.4, 0.1.1.5, 0.1.1.6, 0.1.1.7. @eventsourced@ streams stdin to a TCP\/IP port as @text\/event-source@. On the server: > $ ping example.com | eventsourced --port=1337 --allow-origin=localhost In the browser: > new EventSource('http://0.0.0.0:1337').onmessage = e => console.log(e.data) > PING example.com (93.184.216.34): 56 data bytes > 64 bytes from 93.184.216.34: icmp_seq=0 ttl=50 time=86.586 ms > 64 bytes from 93.184.216.34: icmp_seq=1 ttl=50 time=89.107 ms > 64 bytes from 93.184.216.34: icmp_seq=2 ttl=50 time=88.805 ms > 64 bytes from 93.184.216.34: icmp_seq=3 ttl=50 time=88.843 ms > 64 bytes from 93.184.216.34: icmp_seq=4 ttl=50 time=89.181 ms > 64 bytes from 93.184.216.34: icmp_seq=5 ttl=50 time=89.159 ms > 64 bytes from 93.184.216.34: icmp_seq=6 ttl=50 time=87.214 ms > ...
evil: 0.
evil-cabal: 0.
ewe: 0.1.0.38. Another implemention of the EWE programming language originally created and developed by Kent D. Lee. EWE is an extension of the RAM programming language. RAM was created by Sethi.
exact-pi: 0.1.2.0, 0.4.1.1. Provides an exact representation for rational multiples of pi alongside an approximate representation of all reals. Useful for storing and computing with conversion factors between physical units.
exe: 0.
execs: 0.1.0.0. Tool to run stack exec prj-exe more easy
existential: 0.1.0.0. The library defines the type Cell and Cell1 uses Constraint kinds to so that it can stand for any existential type. Combinators and lenses of various types are built on top of 'Cell' and 'Cell1'
extended-categories: 0.1.0. An implementation of category theory which makes use of GHC's enriched kind system.
extended-reals: 0.1.0.0, 0.2.0.0. Extension of real numbers with positive/negative infinities (±∞). It is useful for describing various limiting behaviors in mathematics.
extensible-effects: 1.1.0, 1.7.1.0, 1.7.1.1. This package introduces datatypes for typeclass-constrained effects, as an alternative to monad-transformer based (datatype-constrained) approach of multi-layered effects. For more information, see the original paper at <http://okmij.org/ftp/Haskell/extensible/exteff.pdf>. Any help is appreciated!
factory: 0.2.1.1. A library of number-theory functions, for; factorials, square-roots, Pi and primes.
fail: 0, 4.9.0.0. This package contains the "Control.Monad.Fail" module providing the <https://prime.haskell.org/wiki/Libraries/Proposals/MonadFail MonadFail> class that became available in <https://hackage.haskell.org/package/base-4.9.0.0 base-4.9.0.0> for older @base@ package versions. This package turns into an empty package when used with GHC versions which already provide the "Control.Monad.Fail" module to make way for GHC's own "Control.Monad.Fail" module.
fasta: 0.5.1.3. The fasta type specifically split by String, Text, and Lazy Text for simplicity and ease of use, although lacking many features of other parsers. Mainly for use with bioinformatics applications which are very general and need no conversion overhead.
fathead-util: 0.1.0.0. Utilities for working with DuckDuckHack's FatHead Instant Answers
fcd: 1.0.0.0. Bookmark directories, then select a bookmark by fuzzy matching. You need to set up a small shell function for this to work properly (see the README).
feed: 0.3.9.2. Interfacing with RSS (v 0.9x, 2.x, 1.0) + Atom feeds. To help working with the multiple feed formats we've ended up with, this set of modules provides parsers, pretty printers and some utility code for querying and just generally working with a concrete representation of feeds in Haskell.
feed-gipeda: 0.1.0.0. A service for easy handling of multiple repositories with <https://hackage.haskell.org/package/gipeda gipeda>. See @--help@ for usage. Example invocation for benchmarking the whole of the @Pipes@ library: @ $ cat > feed-gipeda.yaml repositories: - https:\/\/github.com\/Gabriel439\/Haskell-Pipes-Library ^D $ feed-gipeda --config=.\/feed-gipeda.yaml --deploy-to=.\/website @
feldspar-compiler: 0.7. Feldspar (**F**unctional **E**mbedded **L**anguage for **DSP** and **PAR**allelism) is an embedded DSL for describing digital signal processing algorithms. This library (FeldsparCompiler) contains a prototype compiler that supports C code generation from programs written in this language both according to ANSI C and also targeted to a real DSP HW.
feldspar-language: 0.7. Feldspar (Functional Embedded Language for DSP and PARallelism) is an embedded DSL for describing digital signal processing algorithms. This package contains the language front-end and an interpreter.
fields-json: 0.3. Generation of big, complex JSON objects with 'Text.JSON' is painful. And autoderivation is not always possible. Check documentation of 'Text.JSON.Gen' for more info.
filepath: 1.4.0.0. This package provides functionality for manipulating @FilePath@ values, and is shipped with both <https://www.haskell.org/ghc/ GHC> and the <https://www.haskell.org/platform/ Haskell Platform>. It provides three modules: * "System.FilePath.Posix" manipulates POSIX\/Linux style @FilePath@ values (with @\/@ as the path separator). * "System.FilePath.Windows" manipulates Windows style @FilePath@ values (with either @\\@ or @\/@ as the path separator, and deals with drives). * "System.FilePath" is an alias for the module appropriate to your platform. All three modules provide the same API, and the same documentation (calling out differences in the different variants).
finite-typelits: 0.1.0.0. A type inhabited by finitely many values, indexed by type-level naturals.
fit: 0.5, 0.5.1. The FIT protocol is used by many sport and fitness devices made by companies like Garmin, for example running watches and bike computers. `fit` provides an API for parsing these files for analysis or conversion. Currently this package is a pretty low-level effort, and you'll need to be familiar with FIT to get much value from it. Specifically, the notion of the FIT \"profile\" is ignored entirely, so to make use of the decoded file you'll need to reference the \"Profile.xls\" spreadsheet in the <http://www.thisisant.com/resources/fit FIT SDK>. The "Fit" module exports a convenient set of data types for examining FIT files, as well as some lenses for extracting specific data. It's intended that the API in the "Fit" module should be sufficient and convenient for most uses, but if you need access to the exact structure of the file you can use the data types in "Fit.Internal.FitFile" and parsers in "Fit.Internal.Parse". Feel free to contact me if you have any questions, suggestions, or requests.
fitspec: 0.2.0, 0.2.1, 0.2.2, 0.3.0, 0.3.1. FitSpec provides automated assistance in the task of refining test properties for Haskell functions. FitSpec tests mutant variations of functions under test against a given property set, recording any surviving mutants that pass all tests. FitSpec then reports: * surviving mutants: indicating incompleteness of properties, prompting the user to amend a property or to add a new one; * conjectures: indicating redundancy in the property set, prompting the user to remove properties so to reduce the cost of testing.
fixed-vector: 0.5.1.1, 0.5.1.2. Generic library for vectors with statically known size. Implementation is based on <http://unlines.wordpress.com/2010/11/15/generics-for-small-fixed-size-vectors/> Same functions could be used to work with both ADT based vector like > data Vec3 a = a a a Tuples are vectors too: >>> sum (1,2,3) 6 Vectors which are represented internally by arrays are provided by library. Both boxed and unboxed arrays are supported. Library is structured as follows: [@Data.Vector.Fixed@] Generic API. It's suitable for both ADT-based vector like Complex and array-based ones. [@Data.Vector.Fixed.Cont@] Continuation based vectors. Internally all functions use them. [@Data.Vector.Fixed.Mutable@] Type classes for array-based implementation and API for working with mutable state. [@Data.Vector.Fixed.Unboxed@] Unboxed vectors. [@Data.Vector.Fixed.Boxed@] Boxed vector which can hold elements of any type. [@Data.Vector.Fixed.Storable@] Unboxed vectors of Storable types. [@Data.Vector.Fixed.Primitive@] Unboxed vectors based on pritimive package. [@Data.Vector.Fixed.Monomorphic@] Wrappers for monomorphic vectors
fixedprec: 0.2, 0.2.1.1, 0.2.2.1. A reasonably efficient implementation of arbitrary-but-fixed precision real numbers. This is inspired by, and partly based on, Data.Number.Fixed and Data.Number.CReal, but more efficient.
fixfile: 0.4.0.0, 0.5.0.0, 0.6.0.0. This package is a library for datatype-generic disk serialization. It provides a file abstraction that uses multi-version concurrency control to support transaction-aware isolation for multi-threaded access. The base library comes with a collection of datatypes to provide sets and key-value stores with different properties.
flaccuraterip: 0.2.1. /flAccurateRip/ is a command line tool to verify the accuracy of FLAC files ripped form CD, using the information contained in the AccurateRip™ database about other rips of the same CD. Usage: suppose you ripped a CD into @track01.flac@, @track02.flac@, ..., @trackNN.flac@. Open a shell in the directory containing the FLAC files, and run: >$ flaccuraterip track01.flac track02.flac ... trackNN.flac If a pressing of this CD is present in the AccurateRip™ database, @flaccuraterip@ will output the ripping accuracy for each track. If the CD was ripped without setting the drive offset, you should use the flag @--sample-offset=N@, where N is the offset indicated in <http://accuraterip.com/driveoffsets.htm> for your drive.
flamingra: 0.1.1.1. Hack to turn the profiling output into the format suitable for FlameGraph.
flexible-unlit: 0.2013.276.0.
floating-bits: 0.1.0.0, 0.2.0.0. A small library to cast floating point values to integral values and back preserving the bit-pattern.
flowdock-api: 0.1.0.0. This library uses the Network.HTTP.Client library to interact with the FlowDock chat service. * Push API - <https://www.flowdock.com/api/team-inbox> * Streaming API - <https://www.flowdock.com/api/streaming> * REST API - <https://www.flowdock.com/api/rest>
fltkhs: 0.1.0.0. Low level bindings for the FLTK GUI toolkit.
fn: 0.0.0.1, 0.1.0.0, 0.1.1.0, 0.1.3.0, 0.1.4.0, 0.2.0.0, 0.2.0.1, 0.2.0.2, 0.3.0.0. A Haskell web framework where you write plain old functions. /Provided you have/ <https://github.com/commercialhaskell/stack#readme stack> /installed, you can run this example like a shell script:/ @ #!\/usr\/bin\/env stack \-\- stack --resolver lts-3.10 --install-ghc runghc --package fn {-# LANGUAGE OverloadedStrings #-} import Data.Monoid ((<>)) import Data.Text (Text) import Network.Wai (Response) import Network.Wai.Handler.Warp (run) import Web.Fn data Ctxt = Ctxt { _req :: FnRequest } instance RequestContext Ctxt where   getRequest = _req   setRequest c r = c { _req = r } initializer :: IO Ctxt initializer = return (Ctxt defaultFnRequest) main :: IO () main = do ctxt <- initializer   run 3000 $ toWAI ctxt site site :: Ctxt -> IO Response site ctxt = route ctxt [ end ==> indexH   , path "echo" \/\/ param "msg" ==> echoH   , path "echo" \/\/ segment ==> echoH   ]   \`fallthrough\` notFoundText "Page not found." indexH :: Ctxt -> IO (Maybe Response) indexH _ = okText "Try visiting \/echo?msg='hello' or \/echo\/hello" echoH :: Ctxt -> Text -> IO (Maybe Response) echoH _ msg = okText $ "Echoing '" <> msg <> "'." @ Fn lets you write web code that just looks like normal Haskell code. * An application has some \"context\", which must contain a @Request@, but can contain other data as well, like database connection pools, etc. This context will be passed to each of your handlers, updated with the current HTTP Request. * Routes are declared to capture parameters and/or segments of the url, and then routed to handler functions that have the appropriate number and type of arguments. These functions return @IO (Maybe Response)@, where @Nothing@ indicates to Fn that you want it to keep looking for matching routes. * All handlers just use plain old @IO@, which means it is easy to call them from GHCi, @forkIO@, etc. * All of this is a small wrapper around the WAI interface, so you have the flexilibility to do anything you need to do with HTTP. The name comes from the fact that Fn emphasizes functions (over monads), where all necessary data is passed via function arguments, and control flow is mediated by return values.
fn-extra: 0.1.0.0, 0.1.1.0, 0.3.0.0. Please see README.
fold-debounce: 0.1.0.0. Fold multiple events that happen in a given period of time. See "Control.FoldDebounce".
foldl-incremental: 0.1.0.0, 0.1.0.1, 0.1.0.2, 0.1.1.0, 0.2.0.0. Incremental statistical folds based upon the <https://hackage.haskell.org/package/foldl foldl> libray. An incremental statistical fold can be thought of as exponentially-weighting statistics designed to be efficient computations over a Foldable. It supplies "incrementalize" which turns any unary function into a "Fold". As a reference, `incrementalize id` is an exponentially-weighted moving average.
foldl-transduce: 0.1.2.1. Stateful transducers and streaming-preserving grouping operations for the folds in the foldl package.
folds-common: 0.1.0.0, 0.1.1.0, 0.2.0.0. In an effort to make @folds@ a more usable package this package provides a battery of common folds. These can be plugged together easily and efficiently to cover many common usages.
force-layout: 0.3.0.6. Simulation engine for doing simple force-based layout, /e.g./ for trees or graphs. See the diagrams-contrib package for usage examples.
fortran-src: 0.1.0.0, 0.1.0.1, 0.1.0.2, 0.1.0.3. Provides lexing, parsing, and basic analyses of Fortran code covering standards: FORTRAN 66, FORTRAN 77, and Fortran 90. Includes data flow and basic block analysis, a renamer, and type analysis. For example usage, see the 'camfort' project, which uses fortran-src as its front end.
fractals: 0.1.0.0. A collection of efficient fractal curve encoders that are of general use for creating spatial data structures. Currently, the only encoder included is an implementation Butz's algorithm for generating N-dimensional space-filling Hilbert curves. An encoder for Morton (Z-order) curves is planned for a future release.
free-http: 0.1.0.0, 0.1.0.1, 0.1.0.2, 0.1.1.0, 0.1.1.3, 0.2.0. `free-http` is an http-client based on Free Monads. `free-http` exposes a Free Monad to express standard http verbs as well as several backends to interpet programs written in the free monad using various http clients (currently: a pure client, an `http-client`-backed client, and a random client). Please see the ReadMe for usage.
fresco-binding: 0.1.0. Fresco is a framwork for multi-language programming. This is the Haskell binding.
fswatcher: 0.1.2. A simple program that watches a file or a directory and runs a given command whenever the file or a file within the directory is changed.
full-text-search: 0.2.1.0. An in-memory full text search engine library. It lets you run full-text queries on a collection of your documents. Features: * Keyword queries and auto-complete\/auto-suggest queries. * Can search over any type of \"document\". (You explain how to extract search terms from them.) * Supports documents with multiple fields (e.g. title, body) * Supports documents with non-term features (e.g. quality score, page rank) * Uses the state of the art BM25F ranking function * Adjustable ranking parameters (including field weights and non-term feature scores) * In-memory but quite compact. It does not keep a copy of your original documents. * Quick incremental index updates, making it possible to keep your text search in-sync with your data. It is independent of the document type, so you have to write the document-specific parts: extracting search terms and any stop words, case-normalisation or stemming. This is quite easy using libraries such as <http://hackage.haskell.org/package/tokenize tokenize> and <http://hackage.haskell.org/package/snowball snowball>. The source package includes a demo to illustrate how to use the library. The demo is a simplified version of how the library is used in the <http://hackage.haskell.org/package/hackage-server hackage-server> where it provides the backend for the package search feature.
functional-kmp: 0.1.0.0. A few efficient list-processing functions using the prefix-function, which is defined as: > (prefixFun xs) !! i is the length of the largest proper substring of @xs@ ending at position @i@, such that it equals the beginning of @xs@. For example: > .-----. .-----. > a b a c a b a a a b a b a c d > 0 0 1 0 1 2 3 1 1 2 3 2 3 4 0 > ^ The marked substrings are equal, hence the value at the marked location is their length, 4.
functor-monadic: 0.1.0.0, 0.1.0.1, 0.1.0.2, 0.1.0.3. Monad's bind (>>=, >=>) allows the infix chaining of monadic functions, but no analogues exist for functors. This package provides a handful of handy operators that ease the piping together a functor- and monad-level functions.
fwgl: 0.1.0.0, 0.1.0.1, 0.1.0.2, 0.1.0.3, 0.1.3.1. FWGL is a library for interactive 2D and 3D applications and games. It provides a purely functional interface for advanced graphics programming, including a type safe embedded DSL for GPU programming. You are not required to know or use OpenGL directly to work with FWGL, you just need a basic knowledge of what vertex/fragment shaders, uniforms and attributes are (if you are going to make a more advanced use of it). FWGL is aimed at functional reactive programming (with Yampa), but provides a non-reactive interface as well. There are two backends: fwgl-glfw and fwgl-javascript.
fwgl-glfw: 0.1.0.2, 0.1.0.3. FWGL GLFW backend.
fwgl-javascript: 0.1.0.2. FWGL GHCJS backend
generalised-functor: 0.0.1, 0.0.2, 0.0.4. This package Generalises Functors so "functor like" types that are not exactly Functors can be used as Functor. It also includes Contravariant Functors. Examples of functors definable here: fmap :: (a -> b) -> (a, a, ... , a) -> (b, b, ... , b) fmap f (x1, x2, ... , xn) = (f x1, f x2, ... , f xn) contramap :: (a -> b) -> (b -> r) -> (a -> r) contramap = flip (.)
generic-church: 0.1.0.0, 0.1.0.1, 0.1.0.2, 0.2.0.0, 0.3.0.0. This package provides a type to generically construct the type of the church representation. Additionally, it provides a type class @ChurchRep@ which contains a pair of functions for mapping back and forth between the two representations. Both the type and the @ChurchRep@ instance are be automatically constructed for all types with a @Generic@ instance.
generic-lucid-scaffold: 0.0.1. This is a general organization scheme for web pages, implemented for Lucid. It's as easy as 1-2-3: > λ> renderText $ template mempty "some content" > > ↪ "<!DOCTYPE HTML><html><head><title></title><link href > rel="icon"></head><body>some content</body></html>" overload the particular areas with record syntax and stuff: > λ> let page = WebPage > "foo" > mempty > mempty > mempty > mempty > mempty > mempty > (script_ [src_ "jquery.js"] "") > > > λ> template page "some content" > > ↪ "<!DOCTYPE HTML><html><head><title>foo</title><link href > rel=\"icon\"></head><body>some content<script > src=\"jquery.js\"></script></body></html>"
generic-random: 0.1.0.0, 0.2.0.0. Please see the README.
geo-resolver: 0.1.0.1. Please see README.md
geos: 0.1.0.0. This is a Haskell binding to Geos, the open-source geometry library, which includes geometry types, predicate functions and other operations, spatially indexed geometries, and parsers for WKB and WKT formats.
getopt-generics: 0.1, 0.10. Create command line interfaces with ease
gf: 3.8. GF, Grammatical Framework, is a programming language for multilingual grammar applications
ggtsTC: 0.5. A type checker and runtime system of rCOS/g following the definitions in the /ggts-FCS/ article. * Title: A graph-based generic type system for object-oriented programs * Authors: Wei Ke, Zhiming Liu, Shuling Wang and Liang Zhao * Accepted by: Frontier of Computer Science * Year: 2012 Programmed by: Wei Ke (c) 2012 Wei Ke License: GPL-3 License file: <LICENSE> Source package download: <ggtsTC-0.5.tar.gz> rCOS/g grammar: <grammar>
ghc: 0.
ghc-boot: 0, 0.0.0.0, 8.0.0.20160111, 8.0.1. This library is shared between GHC, ghc-pkg, and other boot libraries. A note about "GHC.PackageDb": it only deals with the subset of the package database that the compiler cares about: modules paths etc and not package metadata like description, authors etc. It is thus not a library interface to ghc-pkg and is *not* suitable for modifying GHC package databases. The package database format and this library are constructed in such a way that while ghc-pkg depends on Cabal, the GHC library and program do not have to depend on Cabal.
ghc-boot-th: 8.0.1. This library contains various bits shared between the @ghc@ and @template-haskell@ libraries. This package exists to ensure that @template-haskell@ has a minimal set of transitive dependencies, since it is intended to be depended upon by user code.
ghc-events: 0.4.3.0, 0.4.4.0. Parses .eventlog files emitted by GHC 6.12.1 and later. Includes the ghc-events tool permitting, in particular, to dump an event log file as text.
ghc-events-analyze: 0.2.0. ghc-events-analyze is a simple Haskell profiling tool that uses GHC's eventlog system. It helps with some profiling use cases that are not covered by the existing GHC profiling modes or tools. It has two major features: 1. While ThreadScope shows CPU activity across all your cores, ghc-events-analyze shows CPU activity across all your Haskell threads. 2. It lets you label periods of time during program execution (by instrumenting your code with special trace calls) and then lets you visualize those time periods or get statistics on them. It is very useful for profiling code when ghc's normal profiling mode is not available, or when using profiling mode would perturb the code too much. It is also useful when you want time-profiling information with a breakdown over time rather than totals for the whole run.
ghc-events-parallel: 0.4.2.0, 0.4.3.1. Parses .eventlog files emitted by parallel GHC versions (6.12.3 and later). This package can replace the original ghc-events package and defines a superset of functions and types. Includes the ghc-events tool permitting, in particular, to dump an event log file as text.
ghc-exactprint: 0.2, 0.4.0.0, 0.5.0.0. Using the API Annotations available from GHC 7.10.2, this library provides a means to round trip any code that can be compiled by GHC, currently excluding lhs files. It does this with a phased approach * Delta - converts GHC API Annotations into relative offsets, indexed by SrcSpan * Transform - functions to facilitate changes to the AST, adjusting the annotations generated in the Delta phase to suit the changes. * Print - converts an AST and its annotations to properly formatted source text. Note: requires GHC 7.10.2 or later
ghc-mod: 5.6.0.0. ghc-mod is a backend program to enrich Haskell programming in editors. It strives to offer most of the features one has come to expect from modern IDEs in any editor. ghc-mod provides a library for other haskell programs to use as well as a standalone program for easy editor integration. All of the fundamental functionality of the frontend program can be accessed through the library however many implementation details are hidden and if you want to significantly extend ghc-mod you should submit these changes upstream instead of implementing them on top of the library. For more information, please see its home page.
ghc-prim: 0.3.1.0, 0.4.0.0, 0.5.0.0. This package contains the primitive types and operations supplied by GHC.
ghc-prof-flamegraph: 0.1.0.1. This is a small tool to convert GHC time profiling reports into a format understandable by the FlameGraph (<https://github.com/brendangregg/FlameGraph>) tool. To use, first convert a `.prof` file into the flame graph format using @ghc-prof-flamegraph@: > $ cat ~/src/packdeps/packdeps.prof | ghc-prof-flamegraph > packdeps.prof.folded Then you can use the file to produce an svg image, using the @flamegraph.pl@ script: > $ cat packdeps.prof.folded | ~/src/FlameGraph/flamegraph.pl > packdeps.prof.svg
ghc-session: 0.1.0.0. Simplified GHC API
ghci: 0, 8.0.0.20160111, 8.0.1. This library offers interfaces which mediate interactions between the @ghci@ interactive shell and @iserv@, GHC's out-of-process interpreter backend.
ghci-history-parser: 0.1.0.0. I couldn't see a simple parser for the output of the ghci @:history@ command, with few dependencies, so here is one. If Parsec is installed, this parser will use it, but if not, it will fall back on the parsers in "Text.ParserCombinators.ReadP", found in @base@. For an example of use, see "GHCi.History.Parse".
ghci-ng: 7.6.3.5. This provides an augmented version of @ghci-7.6.3@ installed under the name @ghci-ng@ containing backported, proposed and experimental features. Currently, @ghci-ng@ has the following additional features compared to the vanilla @ghci-7.6.3@ program: * backported @:complete@ command for non-interactive completion (see <http://ghc.haskell.org/trac/ghc/ticket/5687 GHC#5687>) * backported customizable continuation prompt (@:set prompt2@) and bugfix for @:set +m@-style completion (see <http://ghc.haskell.org/trac/ghc/ticket/8076 GHC#8076>) * Support for @%l@ line-number prompt substitution (proposed for GHC 7.8, <http://ghc.haskell.org/trac/ghc/ticket/8047 GHC#8047>) * Add @:show linker@ command to @:help@ output (<http://ghc.haskell.org/trac/ghc/ticket/8074 GHC#8074>) * Add missing @:show imports@ to completion table (<http://ghc.haskell.org/trac/ghc/ticket/8075 GHC#7075>) * Fix GHCi macros not shadowing builtins (<http://ghc.haskell.org/trac/ghc/ticket/8113 GHC#8113>) * Supports being used via @cabal repl --with-ghc=ghci-ng@ * backported @:show paths@ support (<http://ghc.haskell.org/trac/ghc/ticket/8172 GHC#8172>)
ghci-pretty: 0.0.1, 0.0.2. A tiny package that combines the ipprint package and the hscolour package to provide colored pretty-printing in ghci. /Usage/ Add the following lines to your @ghci.conf@ file: > -- Pretty printing of it > import IPPrint.Colored > :set -interactive-print=IPPrint.Colored.cpprint > :def cp (\_ -> return ":set -interactive-print=IPPrint.Colored.cpprint") > :def ncp (\_ -> return ":set -interactive-print=print") Now you can enable colored pretty-printing in ghci with the commmand > :cp The following command turns colored pretty-printing off again > :ncp
ghcjs-websockets: 0.2.0.0. 'ghcjs-websockets' aims to provide an clean, idiomatic Haskell interface abstracting over the Javascript Websockets API, targeting 'ghcjs' for receiving serialized tagged and untagged data. The interface abstracts websockets as raw data streams and is designed to allow multiple styles of usage; in particular, is adapted for 'io-stream'-style usage and 'distributed-process'-style usage. It is designed to fit in unintrusively in larger frameworks, and adaptable for other interfaces (like 'pipes'). This library provides both /tagged/ and /untagged/ communication channels, using 'tagged-binary' <http://hackage.haskell.org/package/tagged-binary>. * /Untagged/ channels will throw away incoming binary data of unexpected type. * /Tagged/ channels will queue up binary data of unexpected type to be accessed later when data of that type is requested. Tagged channels mimic the behavior of Cloud Haskell <http://www.haskell.org/haskellwiki/Cloud_Haskell> and 'distributed-process' <http://hackage.haskell.org/package/distributed-process>, with their dynamic communication channels. You can use the same channel to send in polymorphic, typed data and deal with it at the time you wish. Some examples: * 'io-stream'-style usage. > -- Echoes input from the server. > main :: IO () > main = do > c <- openConnection "ws://server-url.com" > forever $ do > d <- withConn c expectText > putStrLn d > withConn c (sendText d) > closeConnection c * Commands involving connections can be sequenced with a monadic interface > -- Echoes input from the server. > main :: IO () > main = withUrl "ws://server-url.com" . forever $ do > d <- expectText > liftIO $ putStrLn d > sendText d * Wait for incoming data only decodable as a desired type, and skip over undecodable data. > -- Keep on printing all `Just` values, and stop at the > -- first `Nothing`. > whileJust :: ConnectionProcess () > whileJust = do > d <- expect > case d of > Just d' -> do > liftIO $ putStrLn d' > whileJust > Nothing -> > return () * Typed dynamic communication channels with 'tagged-binary' <http://hackage.haskell.org/package/tagged-binary>; channels looking for a specific type skip over input of the wrong type, and channels looking for the other type can pick them up later or in parallel. > -- Server emits `Int`s or `String`s randomly; launch > -- two parallel threads to catch the data as it comes > -- in, one watching for `Int`s and one watching for > -- `String`s. > main :: IO () > main = do > c <- openTaggedConnection "ws://server-url.com" > t1 <- forkIO . withConn c . forever $ do > n <- expectTagged > replicateM n . liftIO . putStrLn $ "got a number! " ++ show n > t2 <- forkIO . withConn c . forever $ do > s <- expectTagged > liftIO $ putStrN s > await t1 > await t2 > closeConnection c See the 'JavaScript.WebSockets' module for a more detailed introduction. There is still some functionality left to be desired; feel free to open a ticket and send in suggestions or bugs, and all pull requests are welcomed!
gi-glib: 0.0.2. Bindings for GLib, autogenerated by haskell-gi.
girella: 1.0.0. Wrapper over Opaleye
git-embed: 0.0.1, 0.1.0. Use Template Haskell to embed Git revision, branch, and tag information.
github: 0.12, 0.14.0. The Github API provides programmatic access to the full Github Web site, from Issues to Gists to repos down to the underlying git data like references and trees. This library wraps all of that, exposing a basic but Haskell-friendly set of functions and data structures. For more of an overview please see the README: <https://github.com/phadej/github/blob/master/README.md>
github-types: 0.1.0.0, 0.1.0.1, 0.1.0.2, 0.1.0.3. This package includes (some) type definitions for objects which are consumed or produced by the GitHub v3 API.
gitignore: 1.0.0. Apply GitHub .gitignore templates to already existing repositories.
glib: 0.12.5.0, 0.13.0.0. The GNU Library is a collection of C data structures and utility function for dealing with Unicode. This package only binds as much functionality as required to support the packages that wrap libraries that are themselves based on GLib.
glicko: 0.1.0.0. Implementation of the rating algorithm Glicko-2 by Professor Mark E. Glickman <http://glicko.net/glicko/glicko2.pdf> For more info, see <https://github.com/Prillan/haskell-glicko>
glider-nlp: 0.1. Natural Language Processing (NLP) library. Check module in folder "Glider.NLP.Statistics" for universal functions and Glider.NLP.Language.language for functions designed for specific language.
gloss-banana: 0.1.0.0. This package exports a simple wrapper, in terms of Graphics.Gloss.Interface.IO.Game, that allows full control of the picture generated by Gloss as a Behavior, as well as providing access to Gloss' clock and input-handling functionality as Events.
gmndl: 0.4.0.2. A Mandelbrot Set explorer. Multiple render threads use higher precision maths at higher zoom levels. Suggested usage: @gmndl +RTS -N -qa -RTS --width=640 --height=480@ Left-click to zoom in, right-click to zoom out. The status bar shows where you are, and the entry field takes an angled internal address, try for example: @1\/3 1\/2 5 7@
godaddy: 0.1.0.0, 0.1.0.1, 0.1.0.2, 0.1.0.3. Please see README.md
gogol-core: 0.0.1. Core data types, functionality and serialisation primitives for Gogol related Google Services SDKs. The external interface of this library is stable with respect to the downstream Gogol libraries, only, and as such is not suitable for use in non-Gogol projects.
gore-and-ash: 1.1.0.1. Please see README.md
gpah: 0.0.2. Generic Programming Use in Hackage:
gpolyline: 0.1.0.1. Pure module for encoding/decoding Google Polyline
graph-generators: 0.1.0.0, 0.1.2.0, 0.1.2.1. Generators for graphs. Supports classic (constant-sized) graphs, deterministic Generators and different random graph generators, based on mwc-random. This library uses a library-agnostic and space-efficient graph representation. Combinators are provided to convert said representation to other graph representations (currently only FGL, see 'Data.Graph.Generators.FGL') Note that this library is in its early development stages. Don't use it for production code without checking the correctness of the algorithm implementation.
graph-matchings: 0.1.0.0. This package provides algorithms on matchings in graphs; in particular, determining whether a given set of edges is a (maximal/maximum) matching and finding maximal/maximum matchings.
grasp: 0.1.0.0. = Brief summary This is part of the final project for the AMMM (MIRI, FIB-UPC) subject. It contains the random instance generator plus all the GRASP part. It is hosted at https://bitbucket.org/janmasrovira/am3-project. This package includes: * A polymorphic GRASP implementation. * A random instance generator for the AM3 project. * The @AM3@ folder contains the code specific to the final project for the Algorithmic Methods for Mathematical Models subject (Master in Innovation and Research in Informatics, FIB-UPC). = Contents Make sure to read the documentation of all the modules listed below. Specifically, the contents of each module (sorted by relevance to the project) are: 1. "GRASP": A polymorphic parameterizable implementation of a Greedy Randomized Adaptive Search Procedure (GRASP). The idea is taken from this paper: http://www.optimization-online.org/DB_FILE/2001/09/371.pdf. It does not contain anything that is specific to the AM3 project. 2. "AM3.Solution": Contains all the specific functions to the solution of an instance of the AM3 project. 3. "AM3.RandomInstance": A parameterizable random generator of instances. 4. "AM3.Instance": An instance of the problem. It also provides useful functions that have to do with constructing, querying, importing, exporting... an instance.
gridfs: 0.1.0.0, 0.1.0.1. Please see README.md
group-with: 0.1.0.0, 0.2.0.0, 0.2.0.1, 0.2.0.2, 0.2.0.3. A library to classify objects into multimaps by using a function generating keys for any object in the list. This allows an approach similar to SQL GROUP BY. Provides a more flexible approach to `GHC.Exts.groupWith`.
gruff: 0.3.4. Mandelbrot Set fractal explorer using the ruff library. Requires GTK, OpenGL, and GLSL fragment shader support; lots of RAM and multiple CPU cores recommended. If you want to explore very deep zooms, you'll need hmpfr which currently requires GHC to be compiled with integer-simple instead of the default integer-gmp. To install with MPFR support, use @cabal install gruff -fmpfr@. Note that the default setting for this flag has changed since gruff-0.2. gruff-0.3.4 updates dependencies for ghc-7.8. Colouring is improved. gruff-0.3.3 relaxes dependencies for ghc-7.6. gruff-0.3.1 is a bugfix release, fixing a performance problem wherein offscreen tiles were needlessly calculated. The performance gain is much less (and in many cases is in fact a performance loss) when using integer-simple. gruff-0.3 includes a small library to allow external programs to create diagrams and animations with gruff. See the gruff-examples package. The interface has been remodelled to simplify it and add informative feature overlays. gruff-0.2.1 was a bugfix release. Changes since gruff-0.2: * Supersampling bugs are fixed (no more undocumented quantization leading to inconsistent appearance at different zoom levels). * Race condition bugs in cache management are fixed (no more incompletely rendered images). * Internal changes/refactoring to make future additions easier. Features in this version include: * Interactive fractal browser display with mouse controls: * Left click to zoom in (press shift for bigger jumps). * Right click to zoom out (press shift for bigger jumps). * Middle click to center. * Shift middle click to auto-focus. * Control left click to label with period. * Control right click to label with angled internal address (slow!). * Session persistance (stored in @~\/.gruff\/state.gruff@ - states can also be loaded from and saved to other files, including labels and rays). Note that the file format is incompatible with previous releases of gruff. * Tile cache (by default in @~\/.gruff\/cache@ - symlink it somewhere with a few GB of space if you plan on exploring a lot). * Can use MPFR if desired for higher precision, allowing deeper zooms and locating high period nucleii. * Limited amount of customizable colouring (colours for interior, border, and exterior points, as well as labels and rays). * Supersampling for more detailed images (useful range is 1 to 16). * Rudimentary scripting support (see the gruff-examples package). Future versions will focus on enhancing the scripting support.
gtk2hs-buildtools: 0.12.5.0. This package provides a set of helper programs necessary to build the Gtk2Hs suite of libraries. These tools include a modified c2hs binding tool that is used to generate FFI declarations, a tool to build a type hierarchy that mirrors the C type hierarchy of GObjects found in glib, and a generator for signal declarations that are used to call back from C to Haskell. These tools are not needed to actually run Gtk2Hs programs.
h-gpgme: 0.4.0.0. High Level Binding for GnuPG Made Easy (gpgme)
h2048: 0.1.0.0, 0.1.0.1, 0.2.0.0. A haskell implementation of Game 2048, based on <https://github.com/gabrielecirulli/2048>.
hPDB: 1.1. Protein Data Bank file format is a most popular format for holding biological macromolecular data. This is a very fast sequential parser: * below 7s for the largest entry in PDB - 1HTQ which is over 70MB - as compared with * 11s of RASMOL 2.7.5, * or 2m15s of BioPython with Python 2.6 interpreter. In its parallel incarnation it is most probably the fastest parser for PDB format. It is aimed to not only deliver event-based interface, but also a high-level data structure for manipulating data in spirit of BioPython's PDB parser. <http://dx.doi.org/10.1186/1756-0500-6-483 hPDB - Haskell library for processing atomic biomolecular structures in Protein Data Bank format - Michal Jan Gajda. BMC Research Notes 2013, 6:483.>
hPDB-examples: 1.1.1. Examples for handling Protein Data Bank file format.
hS3: 0.5.8, 0.5.9. This is the Haskell S3 library. It provides an interface to Amazon's Simple Storage Service (S3), allowing Haskell developers to reliably store and retrieve arbitrary amounts of data from anywhere on the Internet.
hTalos: 0.2. Protein Data Bank file format is a most popular format for holding biomolecule data. This is a very fast parser (below 7s for the largest entry in PDB - 1HTQ which is over 70MB - as compared with 11s of RASMOL 2.7.5, or 2m15s of BioPython with Python 2.6 interpreter.) It is aimed to not only deliver event-based interface, but also a high-level data structure for manipulating data in spirit of BioPython's PDB parser.
hTensor: 0.8.2, 0.9.0. This is an experimental library for multidimensional arrays, oriented to support simple tensor computations and multilinear algebra. Array dimensions have an \"identity\" which is preserved in data manipulation. Indices are explicitly selected by name in expressions, and Einstein's summation convention for repeated indices is automatically applied. The library has a purely functional interface: arrays are immutable, and operations typically work on whole structures which can be assembled and decomposed using simple primitives. Arguments are automatically made conformant by replicating them along extra dimensions appearing in an operation. There is preliminary support for Geometric Algebra and for solving multilinear systems. A tutorial can be found in the website of the project.
hackage-cli: 0.1.0.0.
hackage-diff: 0.1.0.0. Please see <https://github.com/blitzcode/hackage-diff github.com/blitzcode/hackage-diff> for a user's manual. Sample output > Downloading Hoogle DBs... > Parsing Hoogle DBs... > Comparing Hoogle DBs... > > --- Diff for | 0.2 → 0.3.5.2 | --- > > + Data.Serialize.IEEE754 > + getFloat32be :: Get Float > + getFloat32le :: Get Float > + getFloat64be :: Get Double > + getFloat64le :: Get Double > + putFloat32be :: Float -> Put > + putFloat32le :: Float -> Put > + putFloat64be :: Double -> Put > + putFloat64le :: Double -> Put > × Data.Serialize > + instance Serialize a => GSerialize (K1 i a) > + instance GSerialize a => GSerialize (M1 i c a) > + instance (GSerialize a, GSerialize b) => GSerialize (a :*: b) > + instance GSerialize U1 > + instance GSerialize a => GetSum (C1 c a) > + instance (GetSum a, GetSum b, GSerialize a, GSerialize b) => GetSum (a :+: b) > + instance GSerialize a => PutSum (C1 c a) > + instance (PutSum a, PutSum b, GSerialize a, GSerialize b) => PutSum (a :+: b) > + instance SumSize (C1 c a) > + instance (SumSize a, SumSize b) => SumSize (a :+: b) > + decodeLazy :: Serialize a => ByteString -> Either String a > + encodeLazy :: Serialize a => a -> ByteString > - data Get a > - type Put = PutM () > - type Putter a = a -> Put > - getWord8 :: Get Word8 > - putWord8 :: Putter Word8 > × Data.Serialize.Get > + Done :: r -> ByteString -> Result r > + instance Eq More > + Fail :: String -> Result r > + instance Functor Result > + Partial :: (ByteString -> Result r) -> Result r > + data Result r > + instance Show r => Show (Result r) > + ensure :: Int -> Get ByteString > + runGetLazy :: Get a -> ByteString -> Either String a > + runGetLazyState :: Get a -> ByteString -> Either String (a, ByteString) > + runGetPartial :: Get a -> ByteString -> Result a > × New: isolate :: Int -> Get a -> Get a > Old: isolate :: String -> Int -> Get a -> Get a > × Data.Serialize.Put > + runPutLazy :: Put -> ByteString > + runPutMLazy :: PutM a -> (a, ByteString) > · Data.Serialize.Builder > > [+ Added] [- Removed] [× Modified] [· Unmodified]
hackertyper: 0.1.0.0. Simply randomly mash your keyboard and code will display on your screen.
hactor: 1.1.0.0, 1.2.0.0. Hactor is a library which aims to provide lightweight Erlang-style actors for Haskell.
haddock: 2.14.1, 2.14.2. Haddock is a documentation-generation tool for Haskell libraries
haddock-library: 1.0.0, 2.15.0. Haddock is a documentation-generation tool for Haskell libraries. These modules expose some functionality of it without pulling in the GHC dependency.
haggressive: 0.1.0.0. Aggression analysis for Tweets on Twitter
hahp: 0.1.0. Analytic Hierarchy Process implementation.
hakaru: 0.1.2. Hakaru is an embedded DSL for performing probabilistic inference. It supports multiple inference backends.
hake: 1.3.8.1. Like ruby's rake, hake have Hakefile which is Haskell source. And Hakefile is like rake's Rakefile, and make's Makefile. Hakefile is just Haskell source code, then you can use all Haskell features. New: > deps :: [ String ] -> [ String] -> Rule > deps trgts srcs == file trgts srcs $ \_ _ -> [] Use 'deps' if you want to define no command rule for new Targets. Please use addDeps if you will add dependencies to already existing targets. Hakefile example: > import Development.Hake > import Development.Hake.FunSetRaw > hake_rules = [ > > dflt [ "greeting" ] > , > file [ "greeting", "greeting.log" ] [ "hello.o", "good-bye.o" ] $ > const2 [ [ "linker", "-o", "greeting", "hello.o", "good-bye.o" ] ] > , > rule ".o" ".sfx1" $ > \t (s:_) -> [ [ "compiler1", s, "-o", t ] ] > , > rule ".o" ".sfx2" $ > \t (s:_) -> [ [ "compiler2", s, "-o", t ] ] > , > task "clean" > [ [ "rm", "-f", "hello.o", "good-by.o", "greeting", "greeting.log" ] ] > , > mkfl "script.sh" [ "#!/bin/sh", "echo This is script", "echo made by Hakefile" ] > , > ruleSS "" ".o" $ \t (s:_) -> [ (".c", [ [ "gcc", s, "-o", t ] ] ) , > (".cc", [ [ "g++", s, "-o", t ] ] ) ] ) > , > rule ".o" ".c" $ \_ (s:_) -> [ [ "gcc", "-c", s ] ] > , > rule ".o" ".cc" $ \_ (s:_) -> [ [ "g++", "-c", s ] ] > , > base (=="foo") (const [ "foo.gen", "Hakefile" ]) $ \t (s:_) _ _ -> do > gen <- readFile s > writeFile t $ unlines $ > [ "#!/bin/sh", "echo This is script" ] ++ lines gen > return ExitSuccess > > ] > > main = hake hake_rules
hakyll-convert: 0.2.0.0. WordPress and Blogger only let one export posts in a limited number of formats, none of which are supported by Hakyll. @hakyll-convert@ is created to bridge this gap, providing a way to turn other platform's datadumps into a set of files Hakyll understands.
hakyll-elm: 0.1, 0.2, 0.2.1. A wrapper for compiling Elm (<http://elm-lang.org>) programs to html/javascript in a Hakyll project. Currently supports single-module programs that only import from an Elm runtime that's manually included.
hakyll-sass: 0.2.1. Hakyll compiler which indirectly uses libsass to compile SASS and SCSS to CSS. The Ruby SASS compiler is not required. For documentation, see the <https://github.com/meoblast001/hakyll-sass/blob/master/README.md README>.
handle-like: 0.0.0.0. A tiny package. It's contain the following class. > class HandleLike h where > hlPut :: h -> ByteString -> IO () > hlGet :: h -> Int -> IO ByteString > hlGetByte :: h -> IO Word8 > hlGetLine :: h -> IO ByteString > hlGetContent :: h -> IO ByteString > hlClose :: h -> IO ()
handsy: 0.0.1. A DSL to describe common shell operations and interpeters for running them locally and remotely.
hans: 2.4.0.0. HaNS is a lightweight, pure Haskell network stack that can be used for Haskell networking in the context of the HaLVM, or with a Linux tap device. Currently, HaNS supports 802.3, IPv4, ARP, DHCP (partially), ICMP, UDP, and TCP.
hans-pcap: 0.1.0.0. Network ethernet device for HaNS(Currently requires hans-2.4 from the github), which can tap into a real ethernet interface, all using pcap library and preform raw packet reads & writes. This is a very simple. But requires: root - to be able to use PCAP.
hapistrano: 0.1.0.0. Hapistrano makes it easy to reliably deploy Haskell applications.
happindicator3: 0.1.0, 0.2.0. libappindicator is a library for setting up indicator items and menus on indicator panels, as used in the Unity environment in Ubuntu. This binding allows libappindicator to be used from Haskell.
happstack-fastcgi: 0.1.5. This library lets you write FastCGI programs with Happstack. This package reuses the SimpleHTTP API, making it very easy to port stand-alone HTTP programs to FastCGI.
happstack-server-tls-cryptonite: 0.1.0, 0.1.1. Extend happstack-server with native HTTPS support (TLS/SSL)
happy-meta: 0.2.0.6, 0.2.0.7, 0.2.0.8. A Template-Haskell based version of the Happy parser generator. Used to generate parsers for BNFC-meta, currently this is the only use known to be working.
happybara: 0.0.1. /About/ Happybara is an acceptance test framework inspired by the popular Ruby library \"Capybara\". A short example of Happybara's expressive DSL: >visit "http://happybara-is-awesome.com" >within $ xpath "//form[@id='vote-for-happybara']" $ do > fillIn (fillableField "First Name" [ ]) "Bob" > fillIn (fillableField "Last Name" [ ]) "Smith" > > click $ button "Vote!" [ disabled False ] /Learning Happybara/ I would suggest start with these resources (in order): * <https://github.com/cstrahan/happybara/ The Happybara Readme> * <http://hackage.haskell.org/package/happybara/docs/Happybara.html The Happybara Module docs> Happy web testing!
harpy: 0.6.0.0. The package contains the following components: * An x86 assembler. We provide both low-level code generation in module "Harpy.X86CodeGen" as well as a (slightly) higher-level implementation in module "Harpy.X86Assembler", which figures out addressing modes based on an instruction's operand types. * An x86 disassembler which knows most of the opcodes available on modern x86 processors and can display its output both in the style used in Intel documents an in AT&T style, like the GNU tools. The disassembler can be found in module "Harpy.X86Disassembler". The disassembler is re-exported from the disassembler package for compatibility with earlier Harpy releases. * Some abstractions over the abovementioned code generation modules, such as automatic label management and code generation combinators (for if-then-else statements, while-loops, functions) (module "Harpy.X86CGCombinators"). * All the above modules use the code generation monad defined in module "Harpy.CodeGenMonad".
hashable-time: 0.1.0.0. Default Hashable and derived Generic instances for most of Data.Time types (and Fixed). Only DiffTime and NominalDiffTime are Hashable, but not Generic (due to private constructors).
hask-irc-core: 0.1.0.
haskbot-core: 0.0.1.0. Haskbot melds together the Slack /slash command/ and /incoming/ API integrations to create an easily-extensible platform for adding your own custom /slash commands/ with arbitrary responses to your team's Slack service. Sure, Hubot exists, but when I desire custom chatbot functionality, I'd rather write nice, clean Haskell than clunky Javascript any day of the week.
haskell: 98.
haskell-awk: 1.0, 1.0.1, 1.1, 1.1.1, 1.1.2. Hawk is a command line utility to process streams of text using Haskell code. It is intended to be used in a UNIX pipeline. It offers a configuration system to personalize imported modules and a way to represent values on the console.
haskell-brainfuck: 0.1.0.0, 0.1.0.1. BrainFuck language interpreter. Provides a library for evaluation and an executable to evaluate brainfuck files. Evaluation happens under an arbitrary monad so programn can be evaluated doing I/O to stdin/stdout or in memory using the State monad.
haskell-docs: 3.0.2. Given a module name and a name, it will find and display the documentation of that name. /EXAMPLE USAGE/ > $ haskell-docs Data.List.Split split > Split a list according to the given splitting strategy. This is > how to "run" a Splitter that has been built using the other > combinators. /INSTALLATION/ You should ensure that you have > documentation: True 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. Haddock's dependencies are useless, so here are recommended installation versions: * GHC 7.8: $ cabal install haskell-docs haddock==2.14.* * GHC 7.6: $ cabal install haskell-docs haddock==2.13.* * GHC 7.4: $ cabal install haskell-docs haddock==2.11.* * GHC 7.2: $ cabal install haskell-docs haddock==2.9.* /USING WITH GHCI/ > > :def doc \input -> return (":!haskell-docs " ++ input) > > :doc System.IO getContents base > The getContents operation returns all user input as a single string, > which is read lazily as it is needed > (same as hGetContents stdin). 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>
haskell-mpfr: 0.1. This package imports functions from MPFR to Haskell in the same way as GMP is alreay imported. This package should link correctly on either MacOS X or Linux with GHC 7.8.1 or later.
haskell-names: 0.5.0, 0.5.1, 0.6.0, 0.7.0, 0.8.0. This package takes modules parsed with `haskell-src-exts`, resolves used names and annotates the parsed module with scoping information.
haskell-neo4j-client: 0.1.5.0. Library to interact with Neo4j databases. For now, its API covers basic operations for nodes, relationships, labels and indexes and provides calls to use these in batch mode. Basic support for Cypher implemented All code has been tested with Neo4j version 2.0.3
haskell-otp: 0.1.0.0. Haskell single-node implementation of Erlang/OTP patterns
haskell-packages: 0.4. See <http://documentup.com/haskell-suite/haskell-packages>
haskell-pdf-presenter: 0.2.5. The Haskell Pdf Presenter ("hpdfp") is a tool for presenting PDF-based slide shows. It has many features and niceties that make delivering a presentation easier. For example, as a presenter, it is useful to see the next slide before it is shown to the audience as well as how much allotted time remains. There are a lot of features that may not be immediately obvious so please be sure to look at the documentation. For help with the command line, use the "--help" flag. For help with the GUI, press the "?" key when the program is running. The "README" contains a terse summary of all the features. For more information and example uses, please visit the project home page.
haskell-plot: 0.1.0.0. Built on top of Chart (<http://hackage.haskell.org/package/Chart>).
haskell-src: 1.0.2.0. The 'haskell-src' package provides support for manipulating Haskell source code. The package provides a lexer, parser and pretty-printer, and a definition of a Haskell abstract syntax tree (AST). Common uses of this package are to parse or generate Haskell 98 code.
haskell-src-exts: 1.17.0, 1.18.0. Haskell-Source with Extensions (HSE, haskell-src-exts) is a standalone parser for Haskell. In addition to standard Haskell, all extensions implemented in GHC are supported. Apart from these standard extensions, it also handles regular patterns as per the HaRP extension as well as HSX-style embedded XML syntax.
haskell-starter: 0.1.0.0.
haskell-updater: 1.2.0.11. haskell-updater rebuilds Haskell packages on Gentoo after a GHC upgrade or a dependency upgrade. haskell-updater is written so as to use only GHC's boot libraries so as to have no external dependencies. This version is for: GHC-6.12 + Cabal-1.8, GHC-7.0 + Cabal-1.10, GHC-7.2 + Cabal-1.12, GHC-7.4 + Cabal-1.14, GHC-7.6 + Cabal-1.16, GHC-7.6 + Cabal-1.18.
haskell2010: 1.1.1.1, 1.1.2.0. This package provides exactly the library modules defined by the <http://www.haskell.org/onlinereport/haskell2010/ Haskell 2010 standard>.
haskell98: 2.0.0.3. This package provides compatibility with the modules of Haskell 98 and the FFI addendum, by means of wrappers around modules from the base package (which in many cases have additional features). However "Prelude", "Numeric" and "Foreign" are provided directly by the @base@ package.
haskellscrabble: 0.1.0.0. A scrabble library which enforces legal transitions between moves. Intended to facilitate the development of a playable game.
haskelm: 0.0.2, 0.0.3, 0.0.4, 0.0.5, 0.1.12.0. Library and binary to translate Haskell code into Elm code
haskelzinc: 0.2.0.0, 0.2.0.1, 0.2.0.2, 0.2.0.3. This package was created in the context of the <https://www.graceful-project.eu/ GRACeFUL project>). The haskelzinc library defines an interface to the MiniZinc 2.0 constraint proramming language. It provides a Haskell abstract syntax tree for the MiniZinc language, with which one can represent MiniZinc models in Haskell, a pretty printer to print the representation of a MiniZinc model in MiniZinc and a parser that returns a representation of the solutions obtained by running the MiniZinc model. An additional module gives the possibility to directly get the solutions of a MiniZinc finite domain model. Option for interactive interface is provided, as well as choice between two solvers: the G12/FD built-in solver of FlatZinc and choco3.
hastache: 0.6.0. Haskell implementation of Mustache templates (<http://mustache.github.com/>). See homepage for examples of usage: <http://github.com/lymar/hastache>
hastily: 0.1.0.1, 0.1.0.2, 0.1.0.3, 0.1.0.4, 0.1.0.6. Please see README.md
hath: 0.1.0. Hath is a Haskell program for working with network blocks in CIDR notation. When dealing with blocks of network addresses, there are a few things that one usually wants to do with them: * Create a regular expression matching the CIDR block(s). This is because grep will throw up if you feed it CIDR. * Combine small blocks into larger ones. For example, if you have two consecutive \/24s, they might combine into a larger \/23. * View the result of block combination in a useful way. * List them. * Find their associated PTR records. Hath has several modes to perform these functions: [@Regexed@] This computes a (Perl-compatible) regular expression matching the input CIDR blocks. It's the default mode of operation. [@Reduced@] This combines small blocks into larger ones where possible, and eliminates redundant blocks. The output should be equivalent to the input, though. [@Duped@] Shows only the blocks that would be removed by reduce; that is, it shows the ones that would get combined into larger blocks or are simply redundant. [@Diffed@] Shows what would change if you used reduce. Uses diff-like notation. [@Listed@] List the IP addresses contained within the given CIDRs. [@Reversed@] Perform reverse DNS (PTR) lookups on the IP addresses contained within the given CIDRs. /Examples/: Compute a (Perl-compatible) regular expression matching the input CIDR blocks. It's the default mode of operation. @ $ hath <<< \"10.0.0.0\/29 10.0.0.8\/29\" ((10)\.(0)\.(0)\.(0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15)) @ Combine two \/24s into a \/23: @ $ hath reduced <<< \"10.0.0.0\/24 10.0.1.0\/24\" 10.0.0.0/23 @ List the addresses in 192.168.0.240\/29: @ $ hath listed <<< \"192.168.0.240\/29\" 192.168.0.240 192.168.0.241 192.168.0.242 192.168.0.243 192.168.0.244 192.168.0.245 192.168.0.246 192.168.0.247 @ Perform PTR lookups on all of 198.41.0.4\/30: @ $ hath reversed <<< \"198.41.0.4\/30\" 198.41.0.4: a.root-servers.net. 198.41.0.5: 198.41.0.6: rs.internic.net. 198.41.0.7: @ The DNS lookups are usually the bottleneck for this mode, but we can perform them in parallel. Simply pass the number of threads to the GHC runtime on the command line; for example, the following will perform 25 lookups in parallel: @ $ hath reversed +RTS -N25 <<< \"198.41.0.4\/24\" 198.41.0.4: a.root-servers.net. 198.41.0.5: 198.41.0.6: rs.internic.net. ... @ The command-line syntax and complete set of options are documented in the man page.
haxy: 0.9, 0.9.1, 1.0.1. A library for writing HTTP proxy servers with the focus on simplicity, flexibility and modularity. Allows arbitrary transformations on requests and responses and custom caching methods. It's up to the user to make sure that the message transformations are consistent with the HTTP specification. Note that the package versions follow Semantic Versioning model (semver.org).
hayoo-cli: 0.1.0.0. Simple console client for hayoo.
hblas: 0.1.0.0, 0.3.2.1. User friendly, simple bindings to BLAS and Lapack. Easy to extend and use. HBLAS assumes you have BLAS and LAPACK installed. Users on OSX already have a BLAS and LAPACK installed for them. Users on LINUX and similar platforms will need to do the system equivalent of @sudo apt-get install libblas liblapack@. HBLAS is not intended to be a library for end user array operations, but rather an easy adaptor for calling BLAS and LAPACK routines in their full generality from your end-user haskell linear algebra / array library of choice. HBLAS roughly mirrors the naming conventions and datatype names of the standard BLAS and LAPACK libraries. Those of you who are familiar with these conventions and moderately comfortable with haskell will feel right at home. If you are not familiar with the the operations and conventions of BLAS and Lapack, please read the <https://software.intel.com/sites/products/documentation/hpc/mkl/mklman/index.htm Intel MKL BLAS and LAPACK documention>, you'll learn a lot about what BLAS and LAPACK can do. HBLAS doesn't provide every BLAS and LAPACK operation currently, but is designed so that adding support for new operations is quite easy!
hchesslib: 0.1.0.0. Library implementing chess rules.
hcltest: 0.3.8. Allows to write tests for command line applications using haskell.
hdo: 0.1. HDO is a client to <https://www.digitalocean.com/ Digital Ocean> API. It can either be used as a library embedded in other tools or as a command-line client (@docean@).
heap: 1.0.1, 1.0.2. A flexible Haskell implementation of minimum, maximum, minimum-priority, maximum-priority and custom-ordered heaps.
hecc: 0.4.1.0. Pure math & algorithms for Elliptic Curve Cryptography in Haskell. The implementation should be timing-attack resistant, pure Haskell and reasonably fast.
hein: 0.1.0.0. A general build tool for haskell projects inspired by leiningen. It is intended to be useful for the automation of all project creation tedium, as well as eventually integrate with cloud deployments. It is intended that this will support arbitrary plugins in the future.
heist: 1.0.0.0. Heist is a powerful template system that supports both HTML5 and XML. Some of Heist's features are: * Designer-friendly HTML5 (or XML) syntax * Templates can be reloaded to make changes visible without recompiling your Haskell code * Enforces near-perfect separation of business logic and view * Powerful abstraction primitives allowing you to eliminate repetition * Easy creation of domain-specific markup languages * Built-in support for including JSON and Markdown content in templates * Simple mechanism for designer-specified template caching * Optional merging of multiple \<head\> tags defined anywhere in the document
heist-async: 0.6.0.0. This package provides six splices and some accompanying javascript to allow declarative ajax programming that involves no javascript programming.
helium: 1.8, 1.8.1. Helium is a compiler for a subset of Haskell that aims at delivering high quality type error messages particularly for beginner programmers. It also includes facilities for specializing type error diagnosis for embedded domain specific languages. The compiler supports Haskell 98, but without the ability to define new type classes and instances.
helm: 0.5.0. A functionally reactive game engine, with headgear to protect you from the headache of game development provided.
herringbone: 0.0.1, 0.0.2, 0.0.3, 0.0.4, 0.0.5, 0.0.6, 0.0.7, 0.1.0, 0.1.1. A library for compiling and serving static web assets. For more information, please see <https://github.com/hdgarrood/herringbone>.
herringbone-embed: 0.1.0, 0.1.1. Embed preprocessed web assets in your executable with Template Haskell.
herringbone-wai: 0.1.0, 0.1.1. Wai adapter for the Herringbone web asset preprocessor.
hesh: 1.0.0, 1.1.0, 1.2.0, 1.3.0, 1.4.0. Hesh makes writing scripts in Haskell easier by providing Bash-style syntax for running commands, implicit module imports, and automatic dependency inference and Cabal file generation. It allows shebang execution of scripts.
hexpat: 0.20.4. This package provides a general purpose Haskell XML library using Expat to do its parsing (<http://expat.sourceforge.net/> - a fast stream-oriented XML parser written in C). It is extensible to any string type, with @String@, @ByteString@ and @Text@ provided out of the box. Basic usage: Parsing a tree (/Tree/), formatting a tree (/Format/). Other features: Helpers for processing XML trees (/Proc/), trees annotated with XML source location (/Annotated/), extended XML trees with comments, processing instructions, etc (/Extended/), XML cursors (/Cursor/), SAX-style parse (/SAX/), and access to the low-level interface in case speed is paramount (/Internal.IO/). The design goals are speed, speed, speed, interface simplicity and modularity. For introduction and examples, see the /Text.XML.Expat.Tree/ module. For benchmarks, <http://haskell.org/haskellwiki/Hexpat/> If you want to do interactive I\/O, an obvious option is to use lazy parsing with one of the lazy I\/O functions such as hGetContents. However, this can be problematic in some applications because it doesn't handle I\/O errors properly and can give no guarantee of timely resource cleanup. Because of the generalized list, Hexpat is designed to allow for chunked I/O, but as of this writing I haven't done a nice integration with enumerator and friends. /IO/ is filed under /Internal/ because it's low-level and most users won't want it. The other /Internal/ modules are re-exported by /Annotated/, /Tree/ and /Extended/, so you won't need to import them directly. Credits to Iavor Diatchki and the @xml@ (XML.Light) package for /Proc/ and /Cursor/. Thanks to the many contributors. ChangeLog: 0.15 changes intended to fix a (rare) \"error: a C finalizer called back into Haskell.\" that seemed only to happen only on ghc6.12.X; 0.15.1 Fix broken Annotated parse; 0.16 switch from mtl to transformers; 0.17 fix mapNodeContainer & rename some things.; 0.18 rename defaultEncoding to overrideEncoding. 0.18.3 formatG and indent were demanding list items more than once (inefficient in chunked processing); 0.19 add Extended.hs; 0.19.1 fix a memory leak introduced in 0.19, delegate parsing to bound thread if unbound (see note above); 0.19.2 include expat source code so \'cabal install\' just works on Linux, Mac and Windows (thanks Jacob Stanley); 0.19.3 fix misconfiguration of expat which broke entity parsing; 0.19.4 bump version constraint for text; 0.19.5 bump text to < 0.12 and fix text-0.10.0.1 breakage; 0.19.6 dependency breakage with List; 0.19.7 ghc-7.2.1 compatibility; 0.19.8 fix space leak on lazy parse under ghc-7.2.1; 0.19.9 fix formatting of > character + improve performance; 0.19.10 ghc-7.4.x compatibility; 0.20.1 fix an unfortunate crash when used in parallel processing and greatly improve performance; 0.20.2 make parseSaxG lazier; 0.20.3 minor build issues; 0.20.4 remove dependency on extensible-exceptions.
hext: 0.1.0.0, 0.1.0.2, 0.1.0.3, 0.1.0.4. Please see README.md
hfmt: 0.0.2.3. Inspired by gofmt. Built using hlint, hindent, and stylish-haskell.
hgearman: 0.1.0.0. Gearman client for Haskell (not reccomended for production use).
hgeometry: 0.5.0.0. HGeometry provides some basic geometry types, and geometric algorithms and data structures for them. The main two focusses are: (1) Strong type safety, and (2) implementations of geometric algorithms and data structures with good asymptotic running time guarantees.
hgrev: 0.1.2. [Overview] `hgrev` provides two modules: - `Development.HgRev` - <https://mercurial.selenic.com Mercurial (hg)> Haskell API - `Development.HgRev.TH` - Template Haskell splice to compile version info into Haskell code Use @$(hgRevStateTH defFormat)@ with Template Haskell enabled to insert the formatted version string. [Requirements] `hgrev` requires the `hg` binary is installed and available on the system. `Development.HgRev.HgRev` and `Development.HgRev.HgState` are obtained via two separate calls to `hg` because working directory state isn't available programmatically. [Usage Example] > -# LANGUAGE OverloadedStrings #- > -# LANGUAGE TemplateHaskell #- > > module Example where > > import Data.Monoid ((<>)) > import Data.Text (Text, pack) > import Development.HgRev.TH (defFormat, hgRevStateTH, jsonFormat) > import Options.Applicative (Parser, ParserInfo, execParser, fullDesc, > help, helper, info, infoOption, long, > progDesc, short) > > main :: IO () > main = execParser parserInfo >> return () > > verSwitch :: Parser (a -> a) > verSwitch = > infoOption ("HG rev: " <> $(hgRevStateTH defFormat)) > $ long "version" > <> short 'v' > <> help "Display version information" > > jsonSwitch :: Parser (a -> a) > jsonSwitch = > infoOption $(hgRevStateTH jsonFormat) > $ long "json" > <> short 'J' > <> help "Display JSON version information" > > parserInfo :: ParserInfo (a -> a) > parserInfo = info (helper <*> verSwitch <* jsonSwitch) fullDesc > Check out the <https://hackage.haskell.org/package/gitrev gitrev> package for similar git functionality.
hgrib: 0.1.0.0, 0.2.0.0, 0.3.0.0, 0.3.1.0. Unofficial bindings to ECMWF's GRIB API library for reading WMO FM-92 GRIB edition 1 and edition 2 messages.
hharp: 0.1.0.0. Binding to the library libharp managing configurations for Harp.
higher-leveldb: 0.0.2.2, 0.1.0.0. A rich monadic API for working with leveldb databases.
hilbert: 0.0.0.1. Calculate the position of a point on an arbitrary Hilbert curve corresponding to a given input. Some key properties of this transformation are: (1) The transformation is a one-to-one mapping that can be reversed. (2) The transformation maps an integer to a multidimensional value, and vice-versa. (3) The transformation tends to preserve locality between its input an output. This implementation is based upon /Compact Hilbert Indices/ paper published by Chris Hamilton. The paper is available at: <https://www.cs.dal.ca/sites/default/files/technical_reports/CS-2006-07.pdf>.
himpy: 0.5.0. Himpy provides a multi-threaded snmp poller which reports to riemann. Polled MIBs are grouped in recipes and produce relative results whereever possible (for instance, the storage recipe reports percents).
hinotify-bytestring: 0.3.8.1. This library provides a wrapper to the Linux Kernel's inotify feature, allowing applications to subscribe to notifications when a file is accessed or modified. Filepaths are represented as ByteStrings.
hinterface: 0.1.0.0. Please see README.md
hip: 1.0.0.0, 1.0.1. Haskell Image Processing (HIP) Library provides an easy to use interface with a whole variaty of image manipulation capabilities. Processing can be done sequentially as well as in parallel, with an inherited fusion capabily, all through <https://hackage.haskell.org/package/repa repa> and <https://hackage.haskell.org/package/vector vector> packages. It is highly extendable, with an ability to add custom color spaces or use some other underlying data structure. It is capable of reading and writing a number of popular image formats by using <https://hackage.haskell.org/package/JuicyPixels JuciyPixels> and <https://hackage.haskell.org/package/netpbm netpbm> packages. Being a pure Haskell library it does not require any external programs, although it can display images using a program of your choice.
hjsmin: 0.1.4.2, 0.1.4.3, 0.1.4.5. Reduces size of javascript files by stripping out extraneous whitespace and other syntactic elements, without changing the semantics.
hkdf: 0.0.1.1. Please see README.md
hlibBladeRF: 0.1.0.1. IO Monadic binding for libbladeRF software defined radio.
hmatrix: 0.15.2.1, 0.16.0.2, 0.16.0.3, 0.16.0.4, 0.16.0.5, 0.16.0.6, 0.16.1.0, 0.16.1.1, 0.16.1.2, 0.16.1.3, 0.16.1.4, 0.16.1.5, 0.17.0.1, 0.17.0.2. Linear systems, matrix decompositions, and other numerical computations based on BLAS and LAPACK. Standard interface: "Numeric.LinearAlgebra". Safer interface with statically checked dimensions: "Numeric.LinearAlgebra.Static". Code examples: <http://dis.um.es/~alberto/hmatrix/hmatrix.html>
hmatrix-csv: 0.1.0.0. Aims to provide easy CSV encoding and decoding of matrices. Right now only matrices of type 'Double' are supported. Please feel free to report issues or possible improvements.
hmatrix-glpk: 0.4.0, 0.4.0.1, 0.4.0.2, 0.4.1.0, 0.5.0.0. Simple interface to linear programming functions provided by GLPK.
hmatrix-gsl: 0.16.0.0, 0.16.0.1, 0.16.0.2, 0.16.0.3, 0.17.0.0. Purely functional interface to selected numerical computations, internally implemented using GSL.
hmatrix-special: 0.3.0, 0.3.0.1, 0.4.0.0. Interface to GSL special functions.
hmatrix-tests: 0.4, 0.4.0.1, 0.4.1.0, 0.5.0.0. Tests for hmatrix
hoauth2: 0.4.1, 0.5.5.0. Haskell OAuth2 authentication client. Tested with the following services: * Google web: <https://developers.google.com/accounts/docs/OAuth2WebServer> * Github: <http://developer.github.com/v3/oauth/> * Facebook: <http://developers.facebook.com/docs/facebook-login/> * Fitbit: <http://dev.fitbit.com/docs/oauth2/> * Weibo: <http://open.weibo.com/wiki/Oauth2> * Douban: <http://developers.douban.com/wiki/?title=oauth2>
hobbits: 1.1.1. A library for canonically representing terms with binding via a constructor for introducing fresh names and a restricted API that avoids the need for alpha-equivalence.
hocilib: 0.0.0. A FFI Binding to OCILIB
hold-em: 0.1.0.0. This package contains a collection of essential data types and functions. Please note, that the @deal@ function imposes a range of 2-9 players.
holy-project: 0.1.0.0, 0.1.0.1, 0.1.1.0, 0.1.1.1. Holy Project is an application wich ask the user some questions and create files to help you starting a new Haskell project. There are example for tests using HUnit and SmallCheck It initializes git, use cabal sandboxes, and provide two useful scripts: \"auto-update\" and \"interact\".
honeybee: 0.1.0.0. Bencode parser, because reasons
hoobuddy: 0.1.0.0. Hoobuddy parses the specified cabal project file and invokes hoogle to fetch databases for all specified dependencies merging the result into a `default.hoo` file in the current directory.
hoopl: 3.9.0.0, 3.10.0.0, 3.10.0.2, 3.10.1.0, 3.10.2.0. Higher-order optimization library See /Norman Ramsey, Joao Dias, and Simon Peyton Jones./ <http://research.microsoft.com/en-us/um/people/simonpj/Papers/c--/hoopl-haskell10.pdf "Hoopl: A Modular, Reusable Library for Dataflow Analysis and Transformation"> /(2010)/ for more details.
hopfli: 0.1.0.0. Hopfli provides a pure interface to compress data using Zopfli algorithm.
horizon: 0.1.0, 0.1.1. Provides a basic implementation of the sunrise and sunset equations from <https://en.wikipedia.org/wiki/Sunrise_equation this wikipedia page>.
hourglass-fuzzy-parsing: 0.1.0.0. This package parses many different date/time formats. Both absolute and relative dates are supported. See the README for more.
hpio: 0.8.0.0, 0.8.0.3. This package provides an embedded DSL for writing cross-platform GPIO programs in Haskell. Currently only Linux is supported (via the @sysfs@ filesystem), but other Unix GPIO platforms will be supported in the future. Monads and low-level actions are also provided for each supported platform's native GPIO API, if you want to program directly to the platform API. Example programs are provided in the 'examples' directory of the source code distribution. There is also a "System.GPIO.Tutorial" module, which explains how to use the cross-platform DSL.
hpygments: 0.2.0. Highlight source code using Pygments <http://pygments.org>. This package depends on Pygments and its accompanying @pygmentize@ script.
hs-carbon: 0.1.1.0. Carbon is an open-source, Haskell framework aiming to provide easy access to parallel Monte Carlo simulations by providing a simple, but powerful compositional method for building simulations and high-level functions for running them. Examples can be found at <https://github.com/icasperzen/hs-carbon-examples>
hs-inspector: 0.1.0.0, 0.2.0.0, 0.2.1.0, 0.3.0.0, 0.4.0.0, 0.5.0.0, 0.5.1.0, 0.5.2.0. Simple package for detecting usage of certain Haskell features on a module source code
hs-pkg-config: 0.1.0.0, 0.2.0.0, 0.2.1.0. Create /pkg-config/ configuration file from Haskell code using combinators specialized for this purpose. One of the possible usage examples of this library is generating @.pc@ files from <http://shakebuild.com Shake build system>. For usage example see "Data.PkgConfig" module.
hs-scrape: 0.1.0.0. Shpider/mechanize inspired web automation with a focus on convenience for web scraping.
hs2048: 0.1.0. A <https://github.com/gabrielecirulli/2048 2048> clone in Haskell. This implements the game logic as well as a console interface for playing it.
hsbencher: 1.4.2. Benchmark frameworks are usually very specific to the host language/environment. Hence they are usually about as reusable as compiler passes (that is, not). Nevertheless, `hsbencher` is an attempt at a reusable benchmark framework. It knows fairly little about what the benchmarks do, and is mostly concerned with defining and iterating through configuration spaces (e.g. varying the number of threads), and managing the data that results. Benchmark data is stored in simple text files, and optionally uploaded to Google Fusion Tables. `hsbencher` attempts to stradle the divide between language-specific and language-agnostic by having an extensible set of `BuildMethod`s. As shipped, `hsbencher` knows a little about cabal, ghc, and less about Make, but it can be taught more. The general philosophy is to have benchmarks follow a simple protocol, for example printing out a line "SELFTIMED: 3.3s" if they wish to report their own timing. The focus is on benchmarks that run long enough to run in their own process. This is typical of parallelism benchmarks and different than the fine grained benchmarks that are well supported by "Criterion". `hsbencher` is used by creating a script or executable that imports `HSBencher` and provides a list of benchmarks, each of which is decorated with its parameter space. Below is a minimal example that creates a two-configuration parameter space: @ import HSBencher main = defaultMainWithBechmarks . [ Benchmark \"bench1/bench1.cabal\" [\"1000\"] $ . Or [ Set NoMeaning (RuntimeParam \"+RTS -qa -RTS\") . , Set NoMeaning (RuntimeEnv \"HELLO\" \"yes\") ] ] @ The output would appear as in this gist: <https://gist.github.com/rrnewton/5667800> More examples can be found here: <https://github.com/rrnewton/HSBencher/tree/master/example> ChangesLog: * (1.3.8) Added @--skipto@ and @--runid@ arguments * (1.3.4) Added ability to prune benchmarks with patterns on command line. * (1.4.2) Breaking changes, don't use Benchmark constructor directly. Use mkBenchmark.
hsc2hs: 0.68. The hsc2hs program can be used to automate some parts of the process of writing Haskell bindings to C code. It reads an almost-Haskell source file with embedded special constructs, and outputs a real Haskell file with these constructs processed, based on information taken from some C headers. The extra constructs provide Haskell counterparts of C types, values of C constants, including sizes of C types, and access to fields of C structs. For more details, see <http://www.haskell.org/ghc/docs/latest/html/users_guide/hsc2hs.html>.
hserv: 0.1.2.0. Simple http server in haskell, similar to as provided by `python -m SimpleHTTPServer`.
hslogger-reader: 1.0.0, 1.0.1. hslogger-reader provides a function to generate a parser for <http://hackage.haskell.org/package/hslogger hslogger>-produced logs from a hslogger format string (see "System.Log.Formatter"). The accompanying executable demonstrates parsing and computing with a log file in constant memory.
hsoptions: 1.0.0.0. Haskell library that supports command-line flag processing. Too see an user guide and list of features go to <https://github.com/josercruz01/hsoptions#table-of-contents>. Flags are declared in the code by using the 'make' function, which takes the flag's name, help text and type as arguments. The flags are parsed from the command line stream of from a file if the @--usingFile \<filename\>@ flag is sent to the program. Flags can be customized by calling configuration function, such as 'defaultIs' or 'aliasIs', that change how the flag behaves, how it is parsed and validated. The 'processMain' function needs to be called at the beginning of the 'main' function. This function takes as arguments: * The @program description@ * A list of @all declared flags@ * Three callbacks: * * @success@ * * @failure@ * * @display help@ If there is any kind of validation error @failure@ is called with the list of errors. If the @--help@ flag was sent by the user @display help@ is called. Otherwise if there are no problems the @success@ function is called. A default implementation of @failure@ and @display help@ is provided in the library ('defaultDisplayHelp', 'defaultDisplayErrors') with a basic bahavior. Basically @success@ becomes the \'real\' main function. It takes as argument a tuple ('FlagResults', 'ArgsResults'). 'FlagResults' is a data structure that can be used to query flags by using the 'get' function. 'ArgsResults' is just an array of 'String' containing the remaining not-flag arguments. A simple example (more in <https://github.com/josercruz01/hsoptions/tree/master/examples>) > import System.Console.HsOptions > > userName = make ( "user_name", > , "the user name of the app", > , [ parser stringParser, > , aliasIs ["u"] > ] > ) > userAge = make ("age", "the age of the user", [parser intParser]) > > flagData = combine [flagToData userName, flagToData userAge] > > main :: IO () > main = processMain "Simple example for HsOptions." > flagData > success > failure > defaultDisplayHelp > > success :: ProcessResults -> IO () > success (flags, args) = do let nextAge = (flags `get` userAge) + 5 > putStrLn ("Hello " ++ flags `get` userName) > putStrLn ("In 5 years you will be " ++ > show nextAge ++ > " years old!") > > failure :: [FlagError] -> IO () > failure errs = do putStrLn "Some errors occurred:" > mapM_ print errs At the 'processMain' function each of the input flags is validated against the declared flags. Within the @success@ function you can be sure that all required flags exist, all flag types are correct and all validation was successful.
hspec-expectations-lens: 0.1.0.0, 0.2.0.0, 0.2.1.0, 0.2.1.1, 0.3.0.0. Package adds hspec expectations (@\`shouldX\`@ things) that work nicely with the "lens" library
hspec-monad-control: 0.1.0.0. Orphan instances of MonadBase and MonadBaseControl for SpecM
hspec-structured-formatter: 0.1.0.0, 0.1.0.1, 0.1.0.3. Structured formatted for hspec
hspecVariant: 0.1.0.0. Spec for testing properties for variant types
hsqml: 0.2.0.2, 0.2.0.3, 0.3.0.0, 0.3.1.0, 0.3.1.1, 0.3.2.0, 0.3.3.0. A Haskell binding for Qt Quick, a cross-platform framework for creating graphical user interfaces. For further information on installing and using this library, please see the project's web site.
hsqml-datamodel: 0.0.0.0. HsQML (Qt5) data model. Use any collection (actually, any (Int -> IO a) action) of single constructor data types as a model for use with QML views.
hsqml-datamodel-vinyl: 0.0.0.0.
hsqml-demo-morris: 0.3.0.0, 0.3.1.0. HsQML-based implementation of Nine Men's Morris
hsqml-demo-samples: 0.3.2.0, 0.3.3.0. HsQML sample programs
hsqml-morris: 0.2.0.0. HsQML-based implementation of Nine Men's Morris
hsrelp: 0.1.0.0. The specification of the RELP protocol: <http://www.rsyslog.com/doc/relp.html>
hsseccomp: 0.1.0.0, 0.1.0.1, 0.2.0.1. Bindings to libseccomp. See "System.Linux.Seccomp" for docs.
hssqlppp: 0.4.1, 0.4.2, 0.6.0. SQL parser and type checker, targets PostgreSQL SQL and PL/pgSQL. Pre alpha: works well and is stable for a subset of SQL, but there are lots of unfinished areas and the api is likely to change a lot from release to release at this time. Documentation, examples on the homepage: <http://jakewheat.github.com/hssqlppp/>. Changes here: <https://github.com/JakeWheat/hssqlppp/blob/master/CHANGES>
hssqlppp-th: 0.6.0. hssqlppp extras which need template-haskell Documentation, examples on the homepage: <http://jakewheat.github.com/hssqlppp/>. Changes here: <https://github.com/JakeWheat/hssqlppp/blob/master/CHANGES>
hstats: 0.3.0.1. A library of commonly used statistical functions
hstorchat: 0.1.0.0, 0.1.1.0. A Distributed instant messaging application built on Tor Hidden Services. Compatible with the original TorChat client.
hstradeking: 0.1.0. This is a Haskell binding for the TradeKing developers API (https://developers.tradeking.com/). It currently supports retrieving quotes and stock information, as well as the quote and trade streaming API. Support for the other TradeKing API endpoints is forthcoming. To use, install the package via cabal. This will create an executable called `tradeking`. To connect to the TradeKing API, you will need to create a new personal application from the TradeKing developers site. This should give you four strings: an OAuth consumer key, an OAuth consumer secret, an OAuth Token, and an OAuth Token Secret. You supply these into the `tradeking` application using a configuration file (either `$(HOME)/.tradeking` or `/etc/tradeking.conf`). This configuration file should look like: > consumer-key = <tradeking consumer key> > consumer-secret = <tradeking consumer secret> > oauth-token = <tradeking oauth token> > oauth-token-secret = <tradeking oauth token secret> Now you can run `tradeking quote SPY` to have it return the current quote for the S&P 500 ETF. `tradeking info MSFT` will provide information on Microsoft, and `tradeking stream MSFT` will provide a live stream of `MSFT` quotes. All commands accept more than one stock, so `tradeking quote MSFT AAPL`, `tradeking info MSFT SPY`, and `tradeking stream SPY AAPL` work as expected (subject to TradeKing) limits. You can also request quotes programmatically, using the API described here.
htiled: 0.1.3.0. Import maps from the .tmx map format generated by Tiled, <http://www.mapeditor.org>.
html-email-validate: 0.1.0.0. The library allows to validate and parse an email address as it's defined in <https://html.spec.whatwg.org/multipage/forms.html#valid-e-mail-address HTML standard>. Note that HTML specification of a valid email address is a 'willful violation' of RFC 5322. If you want to validate an address against RFC 5322 you should use <https://hackage.haskell.org/package/email-validate email-validate>.
html5-entity: 0.1.0.0, 0.1.0.1, 0.1.0.2, 0.2.0.2, 0.2.0.3. A library for looking up and validating HTML5 entities. The <http://html.spec.whatwg.org/multipage/entities.json following> document is used as an authoritative source of the valid entity names and their corresponding codepoints. You can think of this library as about bindings to the data from that file. For usage see the 'Text.Html5.Entity' module.
http-encodings: 0.9, 0.9.1. A library for encoding and decoding bodies of HTTP messages, designed to work with the HTTP and http-server libraries. No heuristic encoding detection at this time. WANTED: a library implementing the Unix "compress" command encoding/decoding (or the LZW algorithm).
http-querystring: 1.0. The HTTP query builder.
httpd-shed: 0.4.0.1, 0.4.0.2, 0.4.0.3. This web server promotes a Request to IO Response function into a local web server. The user can decide how to interpret the requests, and the library is intended for implementing Ajax APIs.
hub: 1.4.0. This package provides a utility for multiplexing multiple GHC and Haskell Platform installations, each selected by an environment variable or a work-tree configuration file. The package also provides flexible development sandboxes (aka /hubs/) into which packages can be installed and subsequently erased. Commands are provided for (re)naming, annotating, replicating, swapping, archiving, locking and removing hubs. E.g., > hub init will create a hub based on the default GHC installation and associate the current directory with it. Any use of /cabal/ or the GHC tools within this directory or it's descendants will work with correct tool chain and the private user-package database belonging to the hub. The following would (i) download 'hexpat' (ii) install it in a named 'hexpat-test' hub connected to the /2011.2.0.1/ Haskell Platform, (iii) build the 'hexpat' test suite with the same hub, and (iv) finally run the test suite. >cabal unpack hexpat >cd hexpat-* >hub init -s 2011.2.0.1 hexpat-test >cabal install >cd test >cabal install --bindir=. >./testsuite This same 'hexpat-test' hub can be shared with other work trees. The tool is intended to be provided as part of a distribution (like the /JustHub/ Enterprise Linux distribution) but it can be configured with existing stock GHC installations without too much effort. Once installed and configured the hub command inter-operates seamlessly with the GHC tools (/ghc/, /ghci/, /ghc-pkg/, etc.) and /Cabal-install/. For installation instructions, introductory material, FAQs, etc., see the home page http:\/\/justhub.org.
huckleberry: 0.9.0.0. IchigoJam BASIC on haskell
hums: 0.6.0, 0.7.0. A simple UPnP Media Server. Currently this has only been tested with a PlayStation 3 client. Any help/patches for getting it to work with other clients would be much appreciated.
hunch: 0.1.0. Hunch is a command-line, system-agnostic application that allows quick creation of file system entries with a custom DSL resembling CSS selectors.
husk-scheme: 3.13, 3.14, 3.19.3. <<https://github.com/justinethier/husk-scheme/raw/master/docs/husk-scheme.png>> Husk is a dialect of Scheme written in Haskell that implements a superset of the R5RS standard. Advanced features are provided including: * First-class continuations of unlimited extent * Hygienic macros based on syntax-rules * Low-level explicit renaming macros * Library syntax from the R7RS standard * A foreign function interface (FFI) to Haskell * Full numeric tower providing support for real, rational, and complex numbers * Proper tail recursion and lexical scoping * Read-Eval-Print-Loop (REPL) interpreter, with input driven by Haskeline to provide a rich user experience * Standard library of Scheme functions, and support for many popular SRFI's Husk may be used as either a stand-alone interpreter or as an extension language within a larger Haskell application. By closely following the R5RS standard, the intent is to develop a Scheme that is as compatible as possible with other R5RS Schemes. Husk is mature enough for use in production, however it is not optimized for performance-critical applications. Scheme is one of two main dialects of Lisp. Scheme follows a minimalist design philosophy: the core language consists of a small number of fundamental forms which may be used to implement other built-in forms. Scheme is an excellent language for writing small, elegant programs, and may also be used to write scripts or embed scripting functionality within a larger application. For documentation and examples, see <http://justinethier.github.io/husk-scheme/documentation.html>. For detailed information on each release, see <http://justinethier.github.io/husk-scheme/news.html>.
hwall-auth-iitk: 0.1.0.0, 0.1.0.1. Firewall Authentication script for IITK network in haskell.
hworker: 0.1.0.0, 0.1.0.1. See README.
hworker-ses: 0.1.0.0. See README.
hwsl2: 0.1.0.0. An algebraic hash function, inspired by the paper "Hashing with SL2" by Tillich and Zemor. The hash function is based on matrix multiplication in the special linear group of degree 2, over a Galois field of order 2^127, with all computations modulo the polynomial x^127 + x^63 + 1. This construction gives some nice properties, which traditional "bit-scambling" hash functions don't possess, including it being composable. It holds: > hash (m1 <> m2) == hash m1 <> hash m2 All operations in this package are implemented in a very efficient manner using SSE instructions.
hxt-css: 0.1.0.0, 0.1.0.1. This package makes it possible to easily traverse (X)HTML/XML documents using CSS selectors. It supports all CSS level 3 selectors except the ones that do not make sense outside a web browser (e.g. such as @:hover@ or @::first-letter@). Also, there is no support for namespaced selectors.
hzk: 0.0.2. A haskell binding to Apache Zookeeper C library
ideas: 1.3, 1.3.1, 1.4, 1.5. Ideas (Interactive Domain-specific Exercise Assistants) is a joint research project between the Open University of the Netherlands and Utrecht University. The project's goal is to use software and compiler technology to build state-of-the-art components for intelligent tutoring systems (ITS) and learning environments. The 'ideas' software package provides a generic framework for constructing the expert knowledge module (also known as a domain reasoner) for an ITS or learning environment. Domain knowledge is offered as a set of feedback services that are used by external tools such as the digital mathematical environment (DME), MathDox, and the Math-Bridge system. We have developed several domain reasoners based on this framework, including reasoners for mathematics, linear algebra, logic, learning Haskell (the Ask-Elle programming tutor) and evaluating Haskell expressions, and for practicing communication skills (the serious game Communicate!).
ideas-math: 1.2. Interactive domain reasoner for logic and mathematics, based on the feedback services of the Ideas framework. Domains supported include propositional logic (disjunctive normal form and equivalence proofs), mathematics (fractions, polynomial equations, powers, derivatives), linear algebra (Gaussian elimination and linear systems), and relation algebra. The domain reasoner is used by learning environments such as the digital mathematical environment of the Freudenthal Institute, MathDox, ActiveMath, and the LogEx logic tool.
idempotent: 0.1.0. A typeclass, and instances, for monoids that are idempotent.
identifiers: 0.2.0.1, 0.2.1.0, 0.3.0.0, 0.3.1.0, 0.4.0.0. Useful for situations where repeated-storage requirements of values become too costly.
idna: 0.3.0. Implements IDNA - Internationalized Domain Names in Applications (RFC 3490).
idris: 0.9.9.3, 0.9.10, 0.9.17, 0.9.17.1, 0.9.18, 0.9.18.1, 0.9.19, 0.9.19.1, 0.9.20, 0.9.20.1, 0.10, 0.10.1, 0.10.2, 0.10.3, 0.11, 0.11.2, 0.12, 0.12.2, 0.12.3. Idris is a general purpose language with full dependent types. It is compiled, with eager evaluation. Dependent types allow types to be predicated on values, meaning that some aspects of a program's behaviour can be specified precisely in the type. The language is closely related to Epigram and Agda. There is a tutorial at <http://www.idris-lang.org/documentation>. Features include: * Full, first class, dependent types with dependent pattern matching * where clauses, with rule, case expressions, pattern matching let and lambda bindings * Interfaces (similar to type classes), monad comprehensions * do notation, idiom brackets, syntactic conveniences for lists, tuples, dependent pairs * Totality checking * Coinductive types * Indentation significant syntax, extensible syntax * Cumulative universes * Simple foreign function interface (to C) * Hugs style interactive environment
igrf: 0.1.0.0, 0.2.0.0. An implemetation of the Internation Geomagnetic Reference Field, a model of the Earth's magnetic field. Includes model coefficients from the 11th Edition of the IGRF.
ihaskell: 0.2.0.0. IHaskell is a Haskell backend kernel for the IPython project. This allows using Haskell via a console or notebook interface. Additional packages may be installed to provide richer data visualizations.
imagesize-conduit: 1.1. Currently supports PNG, GIF, and JPEG. This package provides a Sink that will consume the minimum number of bytes necessary to determine the image dimensions.
implicit: 0.0.4, 0.0.5. A math-inspired programmatic CAD library in haskell. Build objects with constructive solid geometry, bevels, shells and more in 2D & 3D. Then export to SVGs, STLs, or produce gcode directly!
implicit-logging: 0.1.0.0. This package provides a simple framework for adding logging to a program. It supports customizable line formatting and user-provided log contexts. Log configuration information is passed around via implicit parameters.
incremental-parser: 0.2.3.3. This package defines yet another parser library. This one is implemented using the concept of Brzozowski derivatives, tweaked and optimized to work with any monoidal input type. Lists, ByteString, and Text are supported out of the box, as well as any other data type for which the monoid-subclasses package defines instances. If the parser result is also a monoid, the parser can provide it incrementally, before the complete input is parsed.
inline-c-win32: 0.1. This is a little helper for the marvelous inline-c library. It provides a context with Win32 API data types so you can use DWORD, BOOL, UINT and other Win32 data types right in your inlined function types.
inquire: 0.1. A console (text/terminal) based client for online encyclopedias such as Wikipedia.
int-cast: 0.1.0.0, 0.1.1.0, 0.1.2.0. Provides statically or dynamically checked conversions between integral types.
integer: 0.
integer-gmp: 0.5.1.0, 1.0.0.1.
interruptible: 0.1.1.1. Given an inner monad @M@ and a transformer @T@, if T is an interruptible transformer, it becomes possible to intercalate functions over its context with functions over the inner monad. That is, code like this: @ runT (f 1 >>= g) where f :: Int -> T M a g :: a -> T M b @ Can be broken up like this: @ do let c0 = inTCtx 1 c1 <- resume f ct1 _ <- resume g ct2 @ That makes it possible to intercalate the execution of different contexts, and treat contexts like data, for iterating or returning them. As shown on the example, interruptible transformers are resumed with the @resume@ function. State may be managed by specialized functions usually named as @inTransfomerCtx@ and @peelTransformerCtx@ that enclose a value in an initial context and retrieve the value from a context. Interruptible transformers can be stacked. On this case, they must be resumed with a composition of @resume@ calls, and their contexts must be created and peeled on the inverse order that they appear on the stack. Like: @ do let c0 = inT2Ctx . inT1Ctx $ 1 c1 <- (resume . resume) f ct1 _ <- (resume . resume) g ct2 where f :: Monad m => Int -> T1 T2 M a g :: Monad m => a -> T1 T2 M b @ For convenience, the @Interruptible@ module exports the @resume2@ to @resume5@ functions as composotions of resume. They can be composed further as in @resume7 = resume3 . resume4@ if necessary. This package also contains the appliable instantiations of Interruptible for the mtl transformers, the @intercalateWith@ function, that intercalates calls of a function through a list of contexts and parameters, and the @SafeIO@ module that lifts IOException treatment from the base monad into the current resumed context.
invertible-syntax-poly: 0.1.0.1. Extends invertible-syntax library capable to use parameterized token type.
io-streams-haproxy: 1.0.0.0. HAProxy protocol version 1.5 support (see <http://haproxy.1wt.eu/download/1.5/doc/proxy-protocol.txt>) for applications using io-streams. The proxy protocol allows information about a networked peer (like remote address and port) to be propagated through a forwarding proxy that is configured to speak this protocol.
ion: 1.0.0.0. Ion is a Haskell EDSL for concurrent, realtime, embedded programming. It interfaces with the Ivory EDSL, <http://ivorylang.org/>, to perform code generation. It supports similar scheduling functionality to Atom (<https://hackage.haskell.org/package/atom>), and also accomodates asynchronous programming with continuation-passing style. Be forewarned that Ion is still heavily experimental. For some further explanation, see the write-up at HaskellEmbedded, <https://haskellembedded.github.io/posts/2016-09-23-introducing-ion.html>.
irc: 0.6.0.1. A set of combinators and types for parsing IRC messages.
irc-conduit: 0.1.0.0, 0.1.0.1. IRC messages consist of an optional identifying prefix, a command name, and a list of arguments. The <http://hackage.haskell.org/package/irc irc> package provides a low-level decoding and encoding scheme for messages in terms of ByteStrings, but using this relies on matching names of commands as strings, and unpacking this decoded structure yourself. This package takes it a little further, providing an ADT for IRC messages and sources, and conduits which attempt to decode and encode messages appropriately. In addition to providing conduits for automatically handling streaming messages, there are also helper functions for connecting to an IRC server and hooking up conduits to the socket.
irc-ctcp: 0.1.0.0, 0.1.1.0, 0.1.2.0, 0.1.2.1. CTCP (Client To Client Protocol) is a way of sending arbitrary data over an IRC network, which may include bytes not allowed in standard IRC messages. CTCPs are sent as a PRIVMSG or NOTICE, where the first and last characters as @\\001@ (SOH), and special bytes are escaped by encoding them into a two-byte sequence beginning with @\\020@ (DLE). CTCPs consist of command name (typically in upper-case) followed by list of space-separated arguments, which may be empty. One use of CTCPs supported by the vast majority of IRC clients today is the ACTION command, typically invoked with /me. For example, if the user @foo@ in the channel @#bar@ were to issue > /me dances everyone in the channel would receive the message > :foo PRIVMSG #bar :\001ACTION dances\001 Other common uses of CTCP include requesting the name and version of a user's IRC client, their local time, determining ping times, and initiating file transfers (DCC). Characters are escaped as follows: [@\\000@ (NUL)] @\\020 \\060@ ("0") [@\\012@ (NL)] @\\020 \\156@ ("n") [@\\015@ (CR)] @\\020 \\162@ ("r") [@\\020@ (DLE)] @\\020 \\020@ All other appearences of the escape character are errors, and are dropped. See <http://www.irchelp.org/irchelp/rfc/ctcpspec.html> for more details.
ireal: 0.1. This library provides a type IReal of real numbers and intervals with arbitrary precision arithmetic, instance declarations for the standard numeric classes, Eq and Ord (the two latter non-total for computability reasons). Reasonably efficient in comparison with other Haskell modules for exact real arithmetic. Does not depend on non-Haskell libraries. The package includes a QuickCheck test suite, documentation, and a number of small example applications in validated numerics.
iron-mq: 0.1.0.0, 0.1.1.0. A client library for communication with Iron.IO's message queueing service
is: 0.1, 0.2. Generate predicates of type (t → Bool) from patterns or constructors of type t.
iserv: 0.
iserv-bin: 0.
islink: 0.1.0.0. This package provides a function that checks whether a particular combination of an HTML tag name and an attribute corresponds to an HTML element that links to an external resource. For example, the combination of the tag @img@ and the attribute @src@ is an external link whereas the combination @div@ and @style@ is not. This is particularly useful for web scraping.
isobmff-builder: 0.1.0.0, 0.1.0.1, 0.2.0.0, 0.2.0.1, 0.9.0.0. Please see README.md
isotope: 0.1.0.0. Please see README.md
ixmonad: 0.55. Provides the 'parametric effect monad' structure to Haskell with a number of analogous of familiar monads (Reader, Writer, State, Maybe, Ticks) and a wrapper over normal monads (Control.Effect.Monad). This provides a way to embed effect systems into Haskell. For more information see <http://dorchard.co.uk/ixmonad> and the examples in <https://github.com/dorchard/effect-monad/tree/master/examples>.
jammittools: 0.2.0.1, 0.3, 0.3.2. <http://www.jammit.com/ 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! You must install ImageMagick and Sox for sheet music and audio export respectively, because they are used to do the actual conversion. Please see the <https://github.com/mtolly/jammittools/blob/master/README.md README> for usage information.
japanese-holidays: 0.1.0. Please see README.md
jcdecaux-vls: 0.1.0. The JCDecaux self-service bicycles API provides access to real-time informations on the stations & contracts of the service.
jespresso: 0.9, 1.0, 1.0.1. Allows extraction and consolidation of JavaScript code in an HTML page so that it behaves like the original. Consolidation is a process of transforming an HTML page into an equivalent, but containing JavaScript code only in one inlined script tag. Note that the package versions follow Semantic Versioning model (semver.org).
jobqueue: 0.0.15, 0.1.1, 0.1.2, 0.1.3. Haskell JobQueue is a library used for building a job scheduler with priority queues. The state of jobs is stored in a backend database such as Apache Zookeeper or other highly reliable message queue systems.
jose-jwt: 0.1, 0.2, 0.3, 0.3.1, 0.4, 0.4.1. Intended to provide support for the JOSE suite of IETF (draft) standards and the closely related JWT (JSON web token) spec (<http://tools.ietf.org/html/draft-ietf-oauth-json-web-token-32/>). Both signed and encrypted JWTs are supported, as well as simple JWK format keys. The library is currently intended to support work on an OpenID Connect implementation and the APIs should not be considered complete, stable or secure for all use cases.
joystick: 0.1.0.0.
json: 0.9. JSON (JavaScript Object Notation) is a lightweight data-interchange format. It is easy for humans to read and write. It is easy for machines to parse and generate. It is based on a subset of the JavaScript Programming Language, Standard ECMA-262 3rd Edition - December 1999. This library provides a parser and pretty printer for converting between Haskell values and JSON.
json-autotype: 0.2.0.0, 0.2.1.0, 0.2.1.2. Generates datatype declarations with Aeson's "FromJSON" instances from a set of example ".json" files. To get started you need to install the package, and run "json-autotype" binary on an input ".json" file. That will generate a new Aeson-based JSON parser. "$ json-autotype input.json -o JSONTypes.hs" Feel free to tweak the by changing types of the fields - any field type that is instance of "FromJSON" should work. You may immediately test the parser by calling it as a script: "$ runghc JSONTypes.hs input.json" See introduction on <https://github.com/mgajda/json-autotype> for details.
json-litobj: 0.1.0.0. This module extends Text.JSON to enable the decoding of strings containing literal JS objects.
json-python: 0.1.0.0, 0.3.0.1. WARNING: Project in alpha. Call python from haskell with ease.
json-rpc-client: 0.1.0.0, 0.1.2.0, 0.1.3.0, 0.1.4.0, 0.2.0.0, 0.2.1.0, 0.2.2.0, 0.2.3.0, 0.2.4.0. Functions for creating a JSON-RPC 2.0 client. See <http://www.jsonrpc.org/specification>. This library supports batch requests and notifications, as well as single method calls. It also provides a function for creating corresponding server-side methods with the package <http://hackage.haskell.org/package/json-rpc-server json-rpc-server>. This library does not handle transport, so a function for communicating with the server must be provided. The demo folder contains an example client and server that can be compiled with the demo flag. See "Network.JsonRpc.Client" for details.
json-rpc-server: 0.1.0.0, 0.1.1.0, 0.1.2.0, 0.1.3.0, 0.1.4.0, 0.1.5.0, 0.1.6.0, 0.2.0.0, 0.2.1.0, 0.2.2.0, 0.2.3.0, 0.2.4.0, 0.2.5.0. An implementation of the server side of JSON-RPC 2.0. See <http://www.jsonrpc.org/specification>. This library uses 'ByteString' for input and output, leaving the choice of transport up to the user. See the "Network.JsonRpc.Server" module for an example. json-rpc-server can be used with <http://hackage.haskell.org/package/json-rpc-client json-rpc-client> to create a client and server that communicate with the same methods.
jumpthefive: 0.0.1. Watch The Wire S01E05: The Pager
jvm-parser: 0.2.1. A parser for JVM bytecode (.class and .jar) files
kansas-comet: 0.3.0, 0.3.1, 0.4. A transport-level remote JavaScript RESTful push mechanism.
katt: 0.2.0.3. Unofficial CLI client for the Kattis online judge system (currently in BETA). Written in a git-like fashion, it supports automatic downloading of test cases, easy submissions, and more. Basically a problem is initialized as follows (creates a directory and downloads any available test cases): > > katt init hello > > cd hello Source files, problem names, and language identification is handled automatically when submitting solutions: > > vim hello.java > > katt submit > Made submission 4712 > Accepted: 1 of 1 test(s) passed There is also built-in support for problem sessions, which initalizes all problems in the problem list. Get started by downloading a /.kattisrc/ config from the official site, make sure you have the haskell platform installed, then run /cabal install katt/. Please note that the beta release is limited to C, C++, Java, and Haskell. It also only supports running on unix. Changes since last release: * Support for Haskell submissions * HTTP client replaced with wreq * Improved code readability
kawhi: 0.1.0, 0.2.0, 0.2.1. Functions and types for interacting with stats.NBA.com
kdesrc-build-extra: 0.1.0.1, 0.1.1. A tool that allows defining build profiles on top of the kdesrc-build system for building KDE packages.
keystore: 0.4.0.0, 0.5.0.0, 0.5.0.1, 0.5.0.2, 0.5.0.3, 0.6.3.0. Writing deployment scripts is a critical yet error-prone activity which we would rather do in Haskell. One of the most difficult aspect of deployment scripts is the management of credentials: they cannot be stored in the VCS like almost everything else, but need to be organised and accessed while under lock and key. This is the problem that keystore is trying to solve: flexible, secure and well-typed deployment scripts. /All Haskell/ This package is written purely in Haskell and all of the cryptographic packages it relies upon are written in Haskell. /JSON Format/ It stores everything in a JSON format that has proven to be stable. We can can use <http://hackage.haskell.org/package/api-tools migrations> in future should the store need to be reorganized. /Simple and Flexible Underlying Model/ * /Named Keys/: every key has an name within the store that is associated with some secret data. If the secret data for that key is to be stored then it must identify another key in the store that will be used to encrypt the data. (Some keys -- the passwords -- will typically be auto-loaded from environment variables.) * *Functional model*: keys can be deleted and added again but the design encourages the retention of the history. The old keys remain available but deployment scripts will naturally select the latest version of a key. When a key is rotated this merely loads a new generation for the rotated key. * /Simple Metadata/: oher information, such as the identity of the key with its originating system (e.g., the identifier of an AWS IAM key) and some arbitrary textual information (the 'comment') may be associated with a key and accessible without recourse to the key or password needed to access the secret information. * /PKS/: the seret may be a RSA provate key with the public key stored separately in the cler. * *MFA*: a secret may be protected with multiple named keys, all of which will be needed to recover the secret text. * /Hashing/: all keys can be hashed with an appropriate PBKDF-2 function and the hashes stored in the clear. These hashes may be sued to verify passwords but also can be inserted directly into configuration files for deployment. Precise control of the PBKDF-2 hash paramers is avaiable. * /Hierarchical Organization/: keys can be stored in different sections with each key being protected by a master key for that section. Sections can be configured to store the master keys of other sections thereby gaining acces to all of the keys in those sections and the keys they have access to. * /Systems Integration/: keys can automatically loaded from Environment variables. Typically a keystore session will start by settingb up an environment variable for the deployment section corresponding for the node that you need to deploy to. This will provide access to precisely the keys whose secrets you need to carry out the deployment and no more. It only needs access to the hashes of admin keys then they can be placed in separate higher-level @admin@ sections. Provided care is taken preparing the environment you will not deploy to the wrong host (e.g., a live server rather than a staging server, or the wrong live server) because those keys will not be accessible. * /Configuration Control/: the parameters controling the encryption and hashing functions can be set up independently in each section of the store, allowing for heavier hashing to be used on live servers and light hashing to be used on development and staging servers where authentication needs to be quick. * /Keystore Integrity/: the keystore can be signed and every operation made to check that the keystore matches its signature (and the public signing key matches an independent copy on the client). * /External Crypto Operations/: keys in the keystore can be used to sign or encrypt external obejcts (provided they can be loaded into memory). /The Layers/ The keystore package has several layers. Most users will probably need only the top "batteries-included" layer: * @Data.KeyStore.Sections@: this provides a high-level model that allows a flexible hierarchical keystore to be set up relatively easily. See the 'deploy' example for details. * @Data.KeyStore.CLI@ : This provides a stanalone program for inspecting and editing your keystores. It can also be embedded into your own deployment app. See the @deploy@ example for details. * @Data.KeyStore.PasswordManager@ provides a password manager which each user can use to setup their own local password store for holding the deployment passwords and session tokens used to autheticate the server. * @Data.KeyStore.IO@: this library provides general programatic access to a keystore through @IO@ primitives. See the source code for the @Sections@ for an example of this module in use. * @Data.KeyStore.KS@: this library provides general programatic access to a keystore through functional @KS@ primitives. See the source code for the @IO@ for an exteded example this system in action. * @Data.KeyStore.Types@: This provides access to keystores at the types level. /Launch Instructions/ See the bottom <https://github.com/cdornan/keystore#launch-instructions README> on GitHub home page for launch instructions for the deploy example.
kicad-data: 0.1.0.0, 0.2.0.0, 0.3.0.0.
krpc: 0.2.2.0. KRPC remote procedure call protocol implementation. [/Release Notes/] * /0.1.0.0:/ Initial version. * /0.1.1.0:/ Allow passing raw argument\/result dictionaries. * /0.2.0.0:/ Async API have been removed, use /async/ package instead. Expose caller address in handlers.
lambda-devs: 0.3.1, 0.4.0. The Discrete Event System Sepcification (DEVS) formalism defines discrete event simulation models in a hierachical, modular manner.
lambda-options: 0.1.0.0, 0.2.0.0, 0.3.0.0, 0.4.0.0, 0.9.0.0. A modern command-line parser for Haskell.
lambdaBase: 0.0.1.0, 0.0.2.0. LambdaBase is a lambda based language hosting an other language (defined by the person using it).
lambdaLit: 0.1.0.0, 0.1.0.1, 0.1.1.0. An repl using the lambdaBase package
lambdatwit: 0.1.0.0. A twitter bot using mueval to evaluate haskell tweets. Further info: <https://github.com/AshyIsMe/lambdatwit/blob/master/README.md>
language-bash: 0.2.0. A library for parsing and pretty-printing Bash shell scripts.
language-dart: 0.1.0.0. Please see README.md
language-ecmascript: 0.15.3, 0.15.4, 0.16, 0.16.1, 0.16.2, 0.17. Tools for working with ECMAScript 3 (popularly known as JavaScript). Includes a parser, pretty-printer, tools for working with source tree annotations and an arbitrary instance. See CHANGELOG for a summary of changes.
language-ecmascript-analysis: 0.9.1. JavaScript static analysis library. Includes label set and lexical environment analyses. The package versions follow Semantic Versioning model (semver.org).
language-fortran: 0.2.7, 0.5.1. 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.
language-gcl: 0.0.1. language-gcl provides the abstract syntax and parsers for basic building blocks for programming languages, based on Edsger W. Dijkstra's guarded command language.
language-glsl: 0.1.0, 0.2.0. The package language-glsl is a Haskell library for the representation, the parsing, and the pretty-printing of GLSL 1.50 code.
language-javascript: 0.5.13. Parses Javascript into an Abstract Syntax Tree (AST). Initially intended as frontend to hjsmin. Note: Version 0.5.0 breaks compatibility with prior versions, the AST has been reworked to allow round trip processing of JavaScript.
language-typescript: 0.0.1. A library for working with TypeScript Definition files
layout: 0.0.0.2. A library for turning values into text or markup. Flexibility is achieved by separating the semantics from the formatting implementation. This way, a function can output, for example, a table, which can then be rendered to any format. This library provides 'standard' objects that can be formatted, in module @Text.Layout.Objects@. It also provides data types for a few formats. These data types are glued together with instances of @Convertible@
lazy-search: 0.1.0.0, 0.1.1.0. This library can be used as a property based testing driver, and more generally to find values satisfying a predicate (@a -> Bool@). This is done by a size bounded search, and it uses the laziness of the predicate to speed up the search by avoiding isomorphic values. This is similar to "LazySmallCheck" but uses size instead of depth and a faster algorithm.
lazyio: 0.0.3.3, 0.1, 0.1.0.3. Run IO actions lazily while respecting their order. Running a value of the LazyIO monad in the IO monad is like starting a thread which is however driven by its output. That is, the LazyIO action is only executed as far as necessary in order to provide the required data.
lean-bindings: 0.1. This package contains Haskell bindings to the <http://leanprover.github.io/ Lean Theorem Prover>. To get started using this library, you should install Lean first, and then install this library, providing paths to the Lean header and library via @--extra-include-dirs@ and @--extra-lib-dirs@ repectively. To use this library, we recomend using a /qualified/ import, such as: @ import qualified Language.Lean as Lean @ The library currently is still a work in progress. To see the current interface, we recommend starting with the documentation for "Language.Lean", and consulting the individual module imports there.
leancheck: 0.3.0, 0.4.0, 0.4.1, 0.5.0. LeanCheck is a simple enumerative property-based testing library. Properties are defined as Haskell functions returning a boolean value which should be true for all possible choices of argument values. LeanCheck applies enumerated argument values to these properties in search for a counterexample. Properties can be viewed as parameterized unit tests. LeanCheck works by producing tiers of test values: a possibly infinite list of finite sublists of same-and-increasingly-sized values. LeanCheck has lean core with only 180 lines of Haskell code.
left-pad: 0.
leftpad: 0.
lens-family-simple: 0.1.0.0. This module, @Lens.Simple@, just re-exports the main modules from Russell O\'Connor's <http://hackage.haskell.org/package/lens-family-core lens-family-core> package, the original <http://r6.ca/blog/20120623T104901Z.html van Laarhoven lens> library. @Lens.Simple@ also re-exports @makeLenses@ and other TH incantations from Dan Burton's associated <http://hackage.haskell.org/package/lens-family-th lens-family-th>. All other dependencies are ghc boot libraries. The idea is just to make a lens-family equivalent of @import Control.Lens@ \-\- namely, @import Lens.Simple@. As an illustration, note that the exemplary <https://github.com/michaelt/lens-family-simple/blob/master/examples/Pong.hs pong> module from the @lens@ repository compiles with only this change of imports. When one day the need arises for the unfathomably more sophisticated material in @Control.Lens@, the opposite change of imports will tend be all that is necessary to begin using them. There are caveats, of course. The @zoom@ exported here does not use @MonadState@ from @mtl@ but is specialized to @Control.Monad.Trans.State.Strict@ Many of the other lenses and combinators are a bit more specialized than their @Control.Lens@ equivalents: for example, _1 and _2 are here familiarly specialized to act just on real Haskell pairs; with the loss of abstraction we also of course abbreviate the error messages.
lens-family-th: 0.4.0.0. Due to a cabal/hackage defect, curly braces cannot be adequately displayed here. Please see <http://github.com/DanBurton/lens-family-th#readme> for a proper description of this package. (See <https://github.com/haskell/cabal/issues/968> for the ticket I created regarding the defect.)
leo: 0.1.0.0. leo lets you query http://dict.leo.org from your program, or the command line.
leveldb-haskell: 0.3.0. From <http://leveldb.googlecode.com>: LevelDB is a fast key-value storage library written at Google that provides an ordered mapping from string keys to string values. This library provides a Haskell language binding to LeveldDB. It is in very early stage and has seen very limited testing. Note: as of v1.3, LevelDB can be built as a shared library. Thus, as of v0.1.0 of this library, LevelDB is no longer bundled and must be installed on the target system (version 1.7 or greater is required).
lib: 0.
libjenkins: 0.1.0.0, 0.2.0.0, 0.3.0.0, 0.4.0.0, 0.4.1.0, 0.4.2.0, 0.4.3.0. Jenkins API interface. It supports REST and Discovery APIs
liblastfm: 0.3.2.0, 0.4.0.0. Provides interface to Lastfm REST API, supports XML and JSON formats.
libnotify: 0.1.0.0, 0.1.1.0. The package provides a high level interface to libnotify API (see "Libnotify") "Libnotify.C.Notify" and "Libnotify.C.NotifyNotification" modules contain bindings to C-level functions if you're into that
libnvvm: 1.0.0. FFI binding to libNVVM, a compiler SDK component from NVIDIA
limp: 0.1.0.0. so far, this package just 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. see the limp-cbc package for a simple solver.
linebreak: 0.1.0.1, 0.1.0.2, 0.1.0.3. Simple functions to break a String to fit a maximum text width, using Knuth-Liang hyphenation algorhitm.
linklater: 1.0.0.0, 3.1.0.0. A library for writing <https://slack.com/> Slack chat bots. Tutorial: <https://github.com/hlian/linklater/wiki/Tutorial> Features you could take advantage of /right now, should you choose/: * Uses 'Text' for state-of-the-art Unicode support; * Lovely documentation with no misspelllllings to be found; * Supports <https://api.slack.com/docs/formatting Slack's formatting syntax> * Comes with a fast mode (@slashSimple@) and a power mode (@slash@) * A warm, receptive maintainer with beautiful brown eyes; * Fully Haddock'd methods and module; * Open source (BSD3). Shamelessly cute example: <<https://raw.githubusercontent.com/hlian/linklater/38536bebf00c60fb1214b2c3a741ce00485e87af/corgi.jpg>>
linux-file-extents: 0.1.0.0, 0.2.0.0. This package provides a simple wrapper around the Linux FIEMAP ioctl. It can be used to retrieve the list of all the extents of any given file, i.e. the area of the disk where the file is actually stored. This is similar to the @filefrag@ command line tool provided by the @e2fsprogs@ package.
linux-mount: 0.1.0.2. This module provides an interface to the system mount and umount functions.
linux-namespaces: 0.1.0.0, 0.1.1.0, 0.1.1.1, 0.1.2.0. This library provides bindings to the @unshare(2)@ and @setns(2)@ linux system calls.
linux-xattr: 0.1.0.1, 0.1.1.0. Bindings to the Linux syscalls for reading and manipulating extended attributes (@<http://man7.org/linux/man-pages/man2/setxattr.2.html setxattr>@, @<http://man7.org/linux/man-pages/man2/getxattr.2.html getxattr>@, @<http://man7.org/linux/man-pages/man2/listxattr.2.html listxattr>@ and @<http://man7.org/linux/man-pages/man2/removexattr.2.html removexattr>@).
lio: 0.11.6.0. 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.
liquid-fixpoint: 0.2.0.0. This package is a Haskell wrapper to the SMTLIB-based Horn-Clause/Logical Implication constraint solver used for Liquid Types. The solver itself is written in Ocaml. The package includes: 1. Types for Expressions, Predicates, Constraints, Solutions 2. Code for serializing the above 3. Code for parsing the results from the fixpoint.native binary 4. The Ocaml fixpoint code 5. (Deprecated) Z3 binaries if you want to link against the API. Requirements In addition to the .cabal dependencies you require - A Recent Ocaml compiler - A Z3 Binary (<http://z3.codeplex.com>)
liquidhaskell: 0.2.0.0. Liquid Types for Haskell.
liquidhaskell-cabal: 0.1.0.0, 0.1.1.0. Provides support for checking projects using Cabal and/or stack with LiquidHaskell. Please see the <https://github.com/spinda/liquidhaskell-cabal/blob/0.1.1.0/README.md README> on GitHub for setup and usage instructions.
liquidhaskell-cabal-demo: 0.1.0.0, 0.1.1.0. Please see the <https://github.com/spinda/liquidhaskell-cabal-demo/blob/0.1.1.0/README.md README> on GitHub for more information.
listsafe: 0.1.0.0, 0.1.0.1. Data.List includes a handful of partial functions that throw uncatchable exceptions when given empty lists. This package provides safe alternatives for such functions based on MonadThrow which can provide a variety of failure cases: Nothing, IOException, Left, etc.
lit: 0.1.0.2, 0.1.0.3, 0.1.0.4. lit has a minimal syntax for implementing literate programming. It generates both HTML and the native source code.
llvm-pkg-config: 0.0. Building the @llvm-base@ package is fragile due to its configuration process. It would be much simpler, if LLVM would support pkg-config since this is nicely integrated in Cabal. However, LLVM developers do not seem to care much about it: <http://llvm.org/bugs/show_bug.cgi?id=9405>. If we are lucky we get pkg-config support in Debian Linux. Until this comes true, you can use this program. It calls @llvm-config@ and writes its output to a PC file. > llvm-pkg-config calls default @llvm-config@ and writes the generated file to standard output. > sudo llvm-pkg-config --install installs the PC file at a default location. This should be the standard task to perform. > llvm-pkg-config --llvm-config=/custom/path/to/llvm-config if you have multiple versions of LLVM installed you may choose an @llvm-config@ other than the default one.
llvm-pretty: 0.2.0.0. A pretty printing library that was inspired by the LLVM binding by Lennart Augustsson. The library provides a monadic interface to a pretty printer, that allows functions to be defined and called, generating the corresponding LLVM assemblly when run.
llvm-pretty-bc-parser: 0.1.2.1, 0.1.2.2. A parser for the LLVM bitcode file format, yielding a Module from the llvm-pretty package.
lmdb: 0.1. LMDB is a read-optimized Berkeley DB replacement developed by Sysmas. It has impressive performance characteristics and a BSD-style license.
located-monad-logger: 0.1.0.0. This library builds on monad-logger to provide logging functions with automatic source locations. It does so using the GHC CallStack mechanism, instead of Template Haskell.
lock-file: 0.5.0.0, 0.5.0.1, 0.5.0.2. Provide exclusive access to a resource using lock file, which are files whose purpose is to signal by their presence that some resource is locked. Code example can be found in "System.IO.LockFile" module.
logger: 0.1.0.0. Logging is a fast and extensible Haskell logging framework. Logging allows you to log any kind of messages in both IO as well as pure code, depending on the informations you want to log. The framework bases on the idea of logger transformer stack defining the way it works. You can build your own stack to highly tailor the behaviour to your needs, starting with such simple things, like logging messages to a list, ending on logging compile-time, priority-filtered messages from different threads and gathering them in other logger thread. For detailed documentation and examples look at the ''System.Log'' module.
logging: 3.0.3. @logging@ is a wrapper around @fast-logger@ which makes it easy to log from 'IO'. It provides the following conveniences on top of those libraries: - A set of shorter functions to type: 'debug', 'log', 'warn', plus others that flush after each message, or which allow providing a message source string. - Logging variants of 'error', 'trace' and 'traceShow', called 'errorL', 'traceL' and 'traceShowL'. These use 'unsafePerformIO' in order to act as direct replacements, so the usual caveats apply. - A global function, 'setDebugLevel', which uses a global 'IORef' to record the logging level, saving you from having to carry around the notion of "verbosity level" in a Reader environment. - A set of "timed" variants, 'timedLog' and 'timedDebug', which report how long the specified action took to execute in wall-clock time.
logict: 0.6.0.1, 0.6.0.2. A continuation-based, backtracking, logic programming monad. An adaptation of the two-continuation implementation found in the paper "Backtracking, Interleaving, and Terminating Monad Transformers" available here: <http://okmij.org/ftp/papers/LogicT.pdf>
lol: 0.0.1.0, 0.1.0.0, 0.2.0.0. Λ ○ λ (Lol) is a general-purpose library for ring-based lattice cryptography. For a detailed description of interfaces and functionality, see <https://eprint.iacr.org/2015/1134 Λ ○ λ: A Functional Library for Lattice Cryptography>. For example cryptographic applications, see <https://hackage.haskell.org/package/lol-apps lol-apps>.
lol-calculus: 1.20160822. WARNING: this is a research program written as I learn and explore /lambda calculii/: please understand well by yourself whatever you may take from it; any question or contribution being welcome :-) This package implements an /explicitely typed/ (aka. /à la Church/) /lambda calculus/ with: /simples types/, /parametric polymorphism/, /higher-rank polymorphism/ and /constructors of types/ (I have no need for /dependent types/ so far, but it should be straightforward to add them to allow the full /Calculus of constructions/ (CoC)). This is mainly done by means of: a common /Algebraic Data Type/ (ADT) for terms and types to build a /Pure Type System/ (PTS), <https://www.schoolofhaskell.com/user/edwardk/bound generalized DeBruijn indices> to implement /capture-avoiding substitution/ of variables, and 'Typeable' axioms to embed Haskell types and terms (the most experimental and tricky part). The inspiring programs I studied which explore similar problems: Simon Peyton Jones and Erik Meijer's <https://research.microsoft.com/en-us/um/people/simonpj/papers/henk.ps.gz Henk>, Dan Doel's <http://hub.darcs.net/dolio/pts pts>, Gabriel Gonzalez's <https://hackage.haskell.org/package/morte morte>, Richard Eisenberg's <https://hackage.haskell.org/package/glambda glambda>, Edward Kmett's <https://hackage.haskell.org/package/bound bound>. See also: the <https://hackage.haskell.org/package/lol-typing lol-typing> package studying the /type inferencing/. NOTE: if you are just interested in building an /Embedded Domain Specific Language/ (EDSL) you may as well study Oleg Kiselyov, Jacques Carette and Chung-chieh Shan's <http://okmij.org/ftp/tagless-final Typed Tagless Final Interpreters>, which you may find being a much more simple, efficient and robust approach.
lol-typing: 1.20160822. WARNING: this is a research program written as I learn and explore /type inferencing/: please understand well by yourself whatever you may take from it; any question or contribution being welcome :-) This package implements /type inferencing/ by manipulating /type constraints/ through 3 successive phases: 1. the 'Collect' phase collects them from some expression, 2. the 'Order' phase modifies the order in which they will be solved, 3. the 'Solver' phase solves them according to the logic of some /type inference rules/. So far, the principles within these phases are mainly a rewrite of Bastiaan Heeren's <https://hackage.haskell.org/package/Top Top>, using my own code conventions and ideals of simplicity. The most notable change being the use of Roman Cheplyaka's <https://hackage.haskell.org/package/monad-classes monad-classes> (a little bit augmented): to handle the 'Monad' stack building a 'Solver' (instead of a homegrown machinery I could not understand well). At this point, only a /bottom-up/ 'Collect', a no-op 'Order' and a 'Greedy' 'Solver' are implemented, supporting: /monomorphic types/ ('Monotype'), /parametric polymorphism/ ('Polytype'), /type class polymorphism/ ('Class'), and /type synonyms/ ('Synotype'). The quite understandable thesis of Bastiaan Heeren explains a lot of this in details: <http://www.open.ou.nl/bhr/TopQuality.pdf Top Quality Type Error Messages>. The <https://hackage.haskell.org/package/uuagc Attribute Grammar System of Universiteit Utrecht> is used to demonstrate how to collect /type constraints/ from an expression ('Expr'), and then how to transform this /implicitely typed/ expression into an /explicitely typed/ <https://hackage.haskell.org/package/lol-calculus lol-calculus> expression See also: the <https://hackage.haskell.org/package/helium helium> compiler.
loops: 0.1.0.0, 0.1.0.1, 0.2.0.0, 0.2.0.1, 0.2.0.2. @loops@ is a library for fast, imperative-style loops with a clean syntax. Features * Fast, imperative-style loops with a clean syntax. Bind (`>>=`) nests loops, so in `do`-notation, each subsequent line is nested inside loops that appear above it. * Iteration over common data structures, like lists and vectors. * Robust performance because there is no reliance on fusion. * NEW! Loop-unrolling to arbitrary depth. Unrollable loop combinators are provided in `Control.Monad.Loop.Unroll`. (The simple, "rolled" interface is still provided in `Control.Monad.Loop`.) The unrolling depth set at the call site at compile time. My benchmarks show that folding over unrolled loops is up to 25% faster than folding over unboxed vectors! For best performance, please compile your code with @-O2@. You should also use GHC's LLVM backend if possible; it generally produces faster executables.
louse: 0.1.0.0. Louse is a program for tracking bugs. It's designed to fit into a git repository.
lrucache: 1.1.1.4. This package contains a simple, pure LRU cache, implemented in terms of "Data.Map". It also contains a mutable IO wrapper providing atomic updates to an LRU cache.
lvmlib: 1.1. The Lazy Virtual Machine (LVM) defines a portable instruction set and file format. It is specifically designed to execute languages with non-strict (or lazy) semantics. This cabal package defines the core assembler (coreasm) for compiling core programs into LVM instructions and a library. The LVM is used as a backend for the Helium compiler. At the moment, one LVM runtime implementation is available (written in C). More information about LVM can be found in Chapter 6 of Daan Leijen's PhD Thesis, The Lambda Abroad.
lvmrun: 1.0. The Lazy Virtual Machine (LVM) defines a portable instruction set and file format. It is specifically designed to execute languages with non-strict (or lazy) semantics. This cabal package defines an LVM runtime written in C. The core assembler (coreasm) for compiling core programs into LVM instructions and a library is defined in the lvmlib cabal package. The LVM is used as a backend for the Helium compiler. More information about LVM can be found in Chapter 6 of Daan Leijen's PhD Thesis, The Lambda Abroad. We use the Make build-type here. The dependencies are provided in the Cabal file, and their generation is not handled by Cabal. Instead, if you change dependencies please run `make depend'. This occurs extremely rarely, though, because we do not plan to evolve lvmrun. Fornothing.hs is only there to please Cabal.
lxc: 0.1, 0.1.1, 0.2, 0.3, 0.3.1, 0.3.1.1. The library provides Haskell LXC API, wrapping <http://hackage.haskell.org/package/bindings-lxc bindings-lxc package>.
lzma: 0.0.0.1, 0.0.0.2. This package provides a pure interface for compressing and decompressing <https://en.wikipedia.org/wiki/LZMA LZMA (Lempel–Ziv–Markov chain algorithm)> streams of data represented as lazy @ByteString@s. A monadic incremental interface is provided as well. This package relies on the <http://tukaani.org/xz/ liblzma C library>. The following packages are based on this package and provide API support for popular streaming frameworks: * </package/lzma-streams lzma-streams> (for </package/io-streams io-streams>) * </package/pipes-lzma pipes-lzma> (for </package/pipes pipes>)
lzma-clib: 5.2.1, 5.2.2. This package contains the @liblzma@ C library with headers for use by LZMA\/XZ bindings such as </package/lzma lzma>. The @liblzma@ code contained in this package version has been extracted from the <http://tukaani.org/xz/ XZ Utils> 5.2.2 release. NOTE: This package is only buildable on Windows.
lzma-streams: 0.0.0.0, 0.1.0.0. This package provides an IO-Streams interface for the LZMA compression algorithm used in the @.xz@ file format. Decompressing @.xz@ 'InputStreams' and compressing 'OutputStreams' to @.xz@ with tunable (de)compression parameters is supported. See also the XZ Utils home page: <http://tukaani.org/xz/>
mac: 0.1.3.0. The MAC library implements /Mandatory Access Control/ concepts in Haskell. It leverages Haskell type-system to restrict how data gets propagated within programs and ensures that sensitive data cannot be leaked by malicious or buggy code. The library enables untrusted code, i.e., code written by someone else, to securely manipulate sensitive data while preserving its confidentiality. The library provides secure versions of advance programming languages features like references, exceptions, and concurrency. This package is the accompanying code for the paper <http://www.cse.chalmers.se/~russo/publications_files/pearl-russo.pdf Functional Pearl: Two can keep a secret, if one of them uses Haskell>.
macbeth-lib: 0.0.12. A FICS client written with OSX in mind.
machinecell: 1.0.0, 1.0.1, 1.1.0, 1.3.0, 1.3.1. Stream processing library similar to pipes, couduit, or machines. Arrow combinatins are supported and can be used with the arrow notation. AFRP-like utilities are also available.
magma: 0.2.2.0. magma is an algebraic structure consisting a set together with an binary operation.
makefile: 0.1.0.0. This package provides a few @Attoparser@ parsers and convenience functions for parsing Makefiles. The datatypes used for describing Makefiles are located in 'Data.Makefile'. The parsers and parsing functions are located in 'Data.Makefile.Parse'. To parse a Makefile in the current folder, simply run 'parseMakefile'. To parse a Makefile located at @path@, run 'parseAsMakefile' @path@.
map: 0.
map-exts: 0.1.0.0, 0.1.0.1. Extensions to Data.Map
map-syntax: 0.2.0.1. Haskell's canonical list of tuples syntax for defining maps is not very convenient and also has ambiguous semantics. This package leverages do notation to create a lighter syntax that makes semantics explicit and also allows the option of fail-fast handling of duplicate keys.
mappy: 0.1.0.0, 0.1.0.1, 0.1.0.2, 0.1.1.0, 0.1.2.0, 0.1.2.1, 0.1.3.0, 0.1.3.1. Please see README.md
markup: 0.0.1, 0.0.2, 0.0.3, 0.0.4, 0.0.5, 0.0.6, 0.0.6.1. This library tries to make things more uniformly controlled when working with markup languages in haskell - namely /deployment/ of markup assets. Deployment, from this library's perspective, means /how/ something can be rendered to markup, yet still achieve the same "result" to the end user (namely the DOM). We use monad transformers to infer the deployment mechanism for a context of markup. The three deployment mechanisms provided include /inline/ (content is slapped between markup tags), /hosted/ (entirely external - uses raw text as a url), and /local/ (which uses the <hackage.haskell.org/package/urlpath urlpath> library to realize what kind of link to create). As an example, here is remotely hosted image: > image = deploy Image "foo.png" :: HostedMarkupM (Html ()) > > λ> renderMarkup image > > <img src="foo.png"> Here is the same example, going relative instead: > image :: LocalMarkupM (HtmlT AbsoluteUrl ()) > image = deploy Image $ "foo.png" <?> ("some","getparam") > > λ> (runUrlReader $ renderTextT $ renderMarkup image $ > ) "example.com" > > "<img src=\"example.com/foo.png?some=getparam\">"
marquise: 4.0.0. Marquise is a collection of a library and two executables for use with Vaultaire. 1. A client and server library for reading/writing to the vault and spool files. This provides streaming reads and writes to the vault using [pipes](https://hackage.haskell.org/package/pipes) as well as writing to spool files with automatic caching and rotation. 2. An executable `marquised`, a daemon which writes data to the vault from spool files generated from users of the marquise library. 3. An executable `data`, used for easily inspecting data in the vault as well as marquise cache files.
mars: 0.1.0.0, 0.1.0.2, 0.1.0.3, 0.1.0.4, 0.2.0.0. Provides functions for generating mountain-like terrain structure using a random walk algorithm. Inspired by Pickover's 1998 article \"Vacation on Mars\". The data can be output as an ascii-format PLY file, or viewed \"overhead\" as an intensity graph. The PLY file can be loaded into a 3D modeling program such as Blender.
matlab: 0.2.0.0. This package aims to provide a comprehensive interface to the MathWorks MATLAB(R) libraries and native data structures, including complete matrix access, MAT-format files, linking and execution of runtime libraries and engine. Requires MATLAB for full functionality or an installed Matlab Component Runtime (MCR). This has been tested with MATLAB R2014a and might work with others. [/Installation/] You will probably need add some arguments that point Cabal to your MATLAB installation. For example, on a Linux system, it may look like this: > cabal install --extra-lib-dirs="/usr/local/MATLAB/R2014a/bin/glnxa64/" --extra-include-dirs="/usr/local/MATLAB/R2014a/extern/include/"
maxBipartiteMatching: 0.1.0.0. Find a maximum cardinality matching on a bipartite graph, using an augmenting path algorithm. More efficient than using MaxFlow from FGL with constant weight and additional source and sink nodes.
mcm: 0.6.4.10. Machine Configuration Manager (MCM) manages the contents of files and directories. One or more of those files can be a script, enabling MCM to control anything. Typically MCM is used to manage the configurations of user profiles, machines, systems and systems of systems. * The declarative language is simple and easy on the eye yet very powerful. * MCM is simple, fast and transparent.
mdp: 0.1.0.0. A library for formulating and solving Markov decision problems. We currently only solve infinite horizon problems. We handle discounted and undiscounted problems, and can solve continuous- and discrete-time problems.
medium-sdk-haskell: 0.1.0.0. Haskell SDK for communicating with the Medium API
meep: 0.1.0.0, 0.1.1.0. A @Map@-like structure that contains up to one key-value pair
meid: 0.0.0. A module containing a Mobile Equipment Identifier data type and related utilities.
mellon-gpio: 0.7.0.1. @mellon-gpio@ provides a GPIO-driven @mellon-core@ @Device@. Currently, it provides support for Linux @sysfs@-based GPIO.
melody: 0.2. A scripting language meant to replace shell modeled after Joy.
merge-bash-history: 0.1.0.0. Please see README.md
messagepack: 0.1.0.0. Serialize instance for Message Pack Object
metadata: 0.3.0.0, 0.4.0.0.
mfsolve: 0.1.0. An equation solver and calculator in the spirit of Metafont. Like metafont, it can solve linear equations, and evaluate nonlinear expressions. In addition to metafont, it also solves for angles, and makes the solution independend of the order of the equations.
mi: 0.0.1. Library for Multiple Instance
midi-music-box: 0.0.0.1. Convert MIDI file to music box punch tape for this kind of music box: <http://www.amazon.de/Spieluhr-Lochstreifen/dp/B001WNZOVO/> Run it like so: > midi-music-box --output=song.ps song.mid @song.mid@ is the input file that must be a MIDI file. @song.ps@ is the output file, a PostScript file. You can print it with a printer or to a PDF document or convert it to many other formats. Currently, the output file must always have the @.ps@ filename extension. Other formats could be supported by adding more of the @diagrams-*@ packages. However, this means you have to alter the program. The program will print the following symbols to the stripe: * blue dot - correct note that should be punched * # - this is a semitone and cannot be played accurately (at least on the type of music box I refered to, above) * ! - the note is outside the range In case of notes outside the stripe you have to adapt the offset. You may write > midi-music-box --zerokey=72 --output=song.ps song.mid in order to make the MIDI note with number 72 the left-most note on the stripe. Default is @--zerokey=60@. The number of notes in an octave is 12. If you use a zerokey that is a multiple of 12 then white (piano) keys remain white, and black keys remain black, so to speak. If zerokey is not a multiple of 12 then white keys may become black an vice versa. Since the music box type considered here only supports white keys, I recommend the following: If the song is in key X major then lookup the MIDI note number for X and choose X plus or minus a multiple of 12 as zerokey. If the song has key Y minor, then X=Y+3.
midi-util: 0.1. 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.
midi-utils: 0.1.0.0. Utilities for working with MIDI data
midisurface: 0.1.0.0. A simple GTK2 UI to send midi control values.
miniutter: 0.4.3.0, 0.4.4.1. This library helps in generating simple present tense English sentences from short, parametrized descriptions. In a typical use, the structure of a clause is fixed, but the particular words to be used vary in arbitrary ways. The main goal of the library is to minimize the API complexity and the code size of programs that use it. The library doesn't attempt to ban incorrect English sentences, but just make the creation of the simple correct ones easy and predictable.
minst-idx: 0.1.0.0, 0.1.2.1. This package provides functionality to read and write data in the IDX binary format. This format is relevant for machine learning applications, like the MINST handwritten digit database.
missing-py2: 1.0.0. A Haskell Interface into the standard Python Interpreter A fork of John Goerzen's MissingPy library, hlinted and updated to run with GHC 7.6.3, this is for legacy projects, for newer projects you might want to consider http://hackage.haskell.org/package/cpython instead Original Documentation: MissingPy is two things: A Haskell binding for many C and Python libraries for tasks such as data compression, databases, etc. This can be found in the MissingPy module tree. Also, it's a low-level Haskell binding to the Python interpreter to enable development of hybrid applications that use both environments. This can be found in the Python module tree. The Haskell bindings above use this environment. MissingPy permits you to call Python code from Haskell. It does NOT permit you to call Haskell code from Python. MissingPy is the companion to my MissingH library, and integrates with it.
moan: 0.1.0.0. Implementation of a space-efficient morphosyntactic analyzer. It solves a problem of providing a set of possible tags for a given word.
modular-arithmetic: 1.2.1.0. A convenient type for working with integers modulo some constant. It saves you from manually wrapping numeric operations all over the place and prevents a range of simple mistakes. @Integer `Mod` 7@ is the type of integers (mod 7) backed by @Integer@. We also have some cute syntax for these types like @ℤ/7@ for integers modulo 7.
monad: 0.
monad-batch: 0.1.0.0. A monad transformer which adds a 'request' operation. Independent requests can be batched together using Applicative instance.
monad-coroutine: 0.8.0.1, 0.9. This package defines a monad transformer, applicable to any monad, that allows the monadic computation to suspend and to be later resumed. The transformer is parameterized by an arbitrary functor, used to store the suspended computation's resumption.
monad-gen: 0.1.0.0, 0.2.0.0, 0.2.0.1, 0.2.0.2, 0.2.0.3, 0.3.0.0, 0.3.0.1. This module provides a simple monad transformer @GenT@ to enumerate unique values within a monadic computation. It also plays nicely with everything in the MTL.
monad-journal: 0.1.0.0, 0.2.0.0, 0.2.1.0, 0.2.1.1. This package provides a typeclass for logging situations when you want to deal with the logs on-the-fly. It also exports a monad transformer that enables such a kind of logging in any monad.
monad-parallel: 0.7.1.3. This package defines classes of monads that can perform multiple executions in parallel and combine their results. For any monad that's an instance of the class, the package re-implements a subset of the Control.Monad interface, but with parallel execution.
monad-resumption: 0.1.0.0, 0.1.0.1, 0.1.1.3, 0.1.1.4. This package contains the definitions of Resumption and Reactive Resumption Monads.
monad-ste: 0.1.0.0. STE is a sibling to the ST monad that provides more efficient abortive errors than a standard EitherT or ExceptT monad stack.
monadIO: 0.10.1.4. MonadIO provides for many IO operations to be overloaded over other IO-like monads.
monadLib: 3.7.3. A collection of monad transformers.
monadfail: 0.
monadiccp-gecode: 0.1.2. Gecode extension for the Monadic Constraint Programming Framework (code generator and runtime solver backend)
mongoDB: 2.0.6, 2.0.7, 2.0.8, 2.0.9, 2.0.10, 2.1.0, 2.1.0.2, 2.1.1, 2.1.1.1. This package lets you connect to MongoDB servers and update/query their data. Please see the example in Database.MongoDB and the tutorial from the homepage. For information about MongoDB itself, see www.mongodb.org.
monoid-absorbing: 0.1.0.2. A library for (left, right) zero monoids, that is, monoids with (left, right) absorbing elements. Includes free constructions of those and a list monad transformer with Prolog's cut operator, which is related to the theory of right zero monoids.
monoid-extras: 0.3.3.3. Various extra monoid-related definitions and utilities, such as monoid actions, monoid coproducts, \"deletable\" monoids, \"split\" monoids, and \"cut\" monoids.
monoid-subclasses: 0.3.4, 0.3.4.1, 0.3.5, 0.3.6, 0.4, 0.4.0.3, 0.4.1. A hierarchy of subclasses of 'Monoid' together with their instances for all data structures from base, containers, and text packages.
morph: 0.1.0.0, 0.1.0.1. Morph is a tool to migrate your PostgreSQL databases safely which supports rollbacks.
mp: 0.2.0, 0.2.1, 0.2.2. Music player for linux.
mpris: 0.1.0.0. This package implements the Media Player Remote Interfacing Specification (MPRIS), a standard D-Bus interface which aims to provide a common programmatic API for controlling media players. The DBus specification consists of two main interfaces: @org.mpris.MediaPlayer2@ and @org.mpris.MediaPlayer2.Player@ which are implemented as modules "Mpris.MediaPlayer2" and "Mpris.MediaPlayer2.Player". The full specification can be found at: <http://specifications.freedesktop.org/mpris-spec/latest/index.html>
mqtt-hs: 1.0.0. A library to communicate with MQTT brokers. See the 'Network.MQTT' module for documentation and the project repository for some <https://github.com/k00mi/mqtt-hs/blob/master/examples examples>.
mtl: 2.0.1.1. Monad classes using functional dependencies, with instances for various monad transformers, inspired by the paper /Functional Programming with Overloading and Higher-Order Polymorphism/, by Mark P Jones, in /Advanced School of Functional Programming/, 1995 (<http://web.cecs.pdx.edu/~mpj/pubs/springschool.html>).
multiaddr: 0.1.0. Multiaddr is a self-describing network address format supporting a variety of protocols, with both string and binary representations.
multihash: 0.1.0, 0.1.1. Multihash is a protocol for encoding the hash algorithm and digest length at the start of the digest. More information available at the official <https://github.com/jbenet/multihash/ multihash github>. Base32 encoding, Blake hashing, and file checking still to be added.
multipart-names: 0.0.1. Basic utilities to handle multipart names with conversion between casing styles UpperCamelCase, lowerCamelCase, Case_insensitive_Underscored, UPPER_UNDERSCORED, lower_underscored and UPPER-HYPHENATED, Case-insensitive-Hyphenated, and lower-hyphenated.
multiplate: 0.0.3. Multiplate is an alternative extension of the Uniplate/Compos core library to support mutally recursive datatypes in a way that is as powerful as Compos, as easy to use as Biplate, and more portable than both of them. Multiplate does not require GADTs and does not require multi-parameter type classes. It only requires rank 3 polymorphism.
multistate: 0.1.1, 0.2.0.0, 0.6.0.0. When using multiple Read\/Write\/State transformers in the same monad stack, it becomes necessary to lift the operations in order to affect a specific transformer. Using heterogeneous lists (and all kinds of GHC extensions magic), this package provides transformers that remove that necessity: MultiReaderT\/MultiWriterT\/MultiStateT\/MultiRWST can contain a heterogeneous list of values. See the <https://github.com/lspitzner/multistate README> for a longer description. The latest published version contains some breaking changes. Please complain if this causes problems (for future consideration).
murder: 1.3.4. The murder library is an EDSL for grammar fragments as first-class values. It provides combinators to define and extend grammars, and produce compilers out of them.
murmur3: 1.0.0. MurmurHash3 is a non-cryptogrpahic hash function suitable for general hash-based lookup. We provide the x86_32 version which closely follows the following implementation: <https://code.google.com/p/smhasher/source/browse/trunk/MurmurHash3.cpp>
mysql-simple-typed: 0.1.0.0. Simplifies simple
mystem: 0.1.0.0. Bindings for Mystem morphological analyzer executabe
nagios-check: 0.1.0.0, 0.2.0, 0.2.1, 0.3.0, 0.3.1, 0.3.2. Implements Nagios plugin development guidelines within a Haskell framework for writing Nagios checks.
nagios-perfdata: 0.2.1, 0.2.2. Provides an interface for parsing Nagios performance data formatted according to the plugin development guidelines.
nagios-plugin-ekg: 0.1.0.0, 0.1.1.0. A generic Nagios plugin which retrieves metrics from an application which uses <http://hackage.haskell.org/package/ekg ekg>.
namegen-haskell: 0.1.0.0.
nanomsg-haskell: 0.1.0. This is a Haskell binding for the nanomsg library: <http://nanomsg.org/>. There's support for blocking send and recv, a non-blocking receive, and for all the socket types and the functions you need to wire them up and tear them down again. Most sockets options are available through accessor and mutator functions. Sockets are typed, transports are not.
nats-queue: 0.1.0.1. This library is a Haskell driver for NATS <http://nats.io>. NATS is a fast and lightweight publish-subscribe messaging system. This version supports authentication but does not support SSL as the current version of gnatsd (go server 0.5.6) does not support it either.
natural-transformation: 0.3, 0.3.1. A natural transformation transforms a container @f a@ into another container @g a@. Natural transformations act as functor morphisms in category theory. The naming of '~>', ':~>' and '$$' were taken, with permission, from Edward Kmett's @indexed@ package.
nc-indicators: 0.1. @nc-indicators@ displays a CPU load and memory usage mini-graphs in your @i3bar@, much like Gnome's @indicator-multiload@ applet. To use @nc-indicators@ simply @exec@ it on startup: @ exec --no-startup-id nc-indicators @ You can turn off either indicator and change the update interval, eg.: @ exec --no-startup-id nc-indicators --show_mem=0 --update_interval=300 @ @nc-indicators@ uses the standard system tray icon protocol, so it can be used with any system tray-like application, not just @i3bar@. But it was originally created to be used with @i3bar@.
needles: 0.1.0.0. This is a bot "library" that allows the user of this package to run a custom pokemon showdown bot.
neet: 0.1.0.0, 0.2.0.0, 0.4.0.0. This package provides functions for creating, training, and using NEAT neural networks.
nero: 0.1, 0.1.1, 0.2, 0.3, 0.3.1. This package provides the core functionality of the @Nero@ HTTP toolkit. Check the <https://github.com/plutonbrb/nero#nero README> for a more detailed explanation.
nero-wai: 0.3. Check the <https://github.com/plutonbrb/nero-wai#nero-wai README> for a more detailed explanation.
nero-warp: 0.3. Check the <https://github.com/plutonbrb/nero-warp#nero-warp README> for a more detailed explanation.
netlink: 1.0.0.4. Library to comminicate with Linux kernel via Netlink
netwire-input: 0.0.1, 0.0.2. This package contains a collection of Monad typeclasses that support interaction with input devices such as keyboard and mice. Moreover, these typeclasses are used to create wires from the netwire package the produce mouse and keyboard input values in a reactive way. This package cannot be used independently and must be used with another package that provides instantiation of these typeclasses such as netwire-input-glfw.
netwire-input-glfw: 0.0.1. This package contains the necessary glue to allow the use of wires from the netwire-input package. In general, the types associated here should be used only sparingly to plumb the input state through your netwire program. Otherwise, the state should not be modified directly.
network: 2.3.2.1, 2.6.3.0. This package provides a low-level networking interface. In network-2.6 the @Network.URI@ module was split off into its own package, network-uri-2.6. If you're using the @Network.URI@ module you can automatically get it from the right package by adding this to your .cabal file: > flag network-uri > description: Get Network.URI from the network-uri package > default: True > > library > -- ... > if flag(network-uri) > build-depends: network-uri >= 2.6, network >= 2.6 > else > build-depends: network-uri < 2.6, network < 2.6 That is, get the module from either network < 2.6 or from network-uri >= 2.6.
network-api-support: 0.2.0. Toolkit for building http client libraries over Network.Http.Conduit. /Note/: Examples of use can be found in the pin and postmark client libraries.
network-fancy: 0.1.5.2, 0.2.0. Networking support with a cleaner API
network-msgpack-rpc: 0.0.1. A MessagePack-RPC Implementation <http://msgpack.org/>
network-simple-sockaddr: 0.1, 0.2. @<http://hackage.haskell.org/package/network-simple-0.3.0 network-simple>@ works by resolving @HostName@s. This packages offers a similar API but working with unresolved addresses in the form of @SockAddr@. In addition to @IPv4@ addresses, @IPv6@ and @Unix Domain Sockets@ are also supported.
network-transport: 0.4.0.0. "Network.Transport" is a Network Abstraction Layer which provides the following high-level concepts: * Nodes in the network are represented by 'EndPoint's. These are heavyweight stateful objects. * Each 'EndPoint' has an 'EndPointAddress'. * Connections can be established from one 'EndPoint' to another using the 'EndPointAddress' of the remote end. * The 'EndPointAddress' can be serialised and sent over the network, where as 'EndPoint's and connections cannot. * Connections between 'EndPoint's are unidirectional and lightweight. * Outgoing messages are sent via a 'Connection' object that represents the sending end of the connection. * Incoming messages for /all/ of the incoming connections on an 'EndPoint' are collected via a shared receive queue. * In addition to incoming messages, 'EndPoint's are notified of other 'Event's such as new connections or broken connections. This design was heavily influenced by the design of the Common Communication Interface (<http://www.olcf.ornl.gov/center-projects/common-communication-interface>). Important design goals are: * Connections should be lightweight: it should be no problem to create thousands of connections between endpoints. * Error handling is explicit: every function declares as part of its type which errors it can return (no exceptions are thrown) * Error handling is "abstract": errors that originate from implementation specific problems (such as "no more sockets" in the TCP implementation) get mapped to generic errors ("insufficient resources") at the Transport level. This package provides the generic interface only; you will probably also want to install at least one transport implementation (network-transport-*).
network-transport-tcp: 0.4.0. TCP instantiation of Network.Transport
network-uri: 2.6.0.2. This package provides an URI manipulation inteface. In network-2.6 the @Network.URI@ module was split off from the network package into this package. If you're using the @Network.URI@ module you can automatically get it from the right package by adding this to your .cabal file: > flag network-uri > description: Get Network.URI from the network-uri package > default: True > > library > -- ... > if flag(network-uri) > build-depends: network-uri >= 2.6, network >= 2.6 > else > build-depends: network-uri < 2.6, network < 2.6 That is, get the module from either network < 2.6 or from network-uri >= 2.6.
network-uri-flag: 0.1. This empty package does not provide any modules; its sole purpose is to provide the @network-uri@ Cabal flag logic below so you don't have to include that boilerplate in your @.cabal@ file. > flag network-uri > description: Get Network.URI from the network-uri package > default: True > > library > if flag(network-uri) > build-depends: network-uri >= 2.6, network >= 2.6 > else > build-depends: network-uri < 2.6, network < 2.6 This avoids combining @network-uri >= 2.6@ with @network < 2.6@ which both export a name-clashing @Network.URI@ module, because in network-2.6 the @Network.URI@ module was split off from the network package into network-uri-2.6. In other words, the logic above makes sure that the @Network.URI@ module is provided by either @network-uri@ or by @network@ (in the <https://en.wikipedia.org/wiki/Exclusive_or XOR> sense). In order to benefit from this module, simply include it in your @build-depends@ declaration alongside @network@ and @network-uri@. > build-depends: > network >= 2.5 && < 2.7, > network-uri >= 2.7 && < 2.8, > network-uri-flag == 0.1.* /NOTE: It's almost always an error to list this package if network and network-uri aren't both listed as well!/
neural: 0.1.0.0, 0.1.0.1, 0.1.0.2, 0.1.1.0, 0.2.0.0, 0.3.0.0. The goal of `neural` is to provide a modular and flexible neural network library written in native Haskell. Features include * /composability/ via arrow-like instances and <https://hackage.haskell.org/package/pipes pipes>, * /automatic differentiation/ for automatic gradient descent/ backpropagation training (using Edward Kmett's fabulous <https://hackage.haskell.org/package/ad ad> library). The idea is to be able to easily define new components and wire them up in flexible, possibly complicated ways (convolutional deep networks etc.). Three examples are included as proof of concept: * A simple neural network that approximates the sqrt function on [0,4]. * A slightly more complicated neural network that solves the famous <https://en.wikipedia.org/wiki/Iris_flower_data_set Iris flower> problem. * A first (still simple) neural network for recognizing handwritten digits from the equally famous <https://en.wikipedia.org/wiki/MNIST_database MNIST> database. The library is still very much experimental at this point.
newsynth: 0.1.1.0, 0.2, 0.2.0.1, 0.3, 0.3.0.2, 0.3.0.3. A library of algorithms for exact and approximate synthesis of quantum circuits over the Clifford+T gate set. This includes, among other things: * "Quantum.Synthesis.GridSynth": an efficient single-qubit approximate synthesis algorithm. From N. J. Ross and P. Selinger, \"Optimal ancilla-free Clifford+/T/ approximation of /z/-rotations\", <http://arxiv.org/abs/1403.2975>. * "Quantum.Synthesis.MultiQubitSynthesis": multi-qubit exact synthesis algorithms. From B. Giles and P. Selinger, \"Exact synthesis of multiqubit Clifford+/T/ circuits\", Physical Review A 87, 032332, 2013, <http://arxiv.org/abs/1212.0506>. * "Quantum.Synthesis.CliffordT": the computation of Matsumoto-Amano normal forms. From K. Matsumoto and K. Amano, \"Representation of Quantum Circuits with Clifford and π\/8 Gates\", <http://arxiv.org/abs/0806.3834>. * "Quantum.Synthesis.RotationDecomposition": an algorithm for decomposing multi-qubit unitary operators into one- and two-level unitaries. See e.g. Section 4.5.1 of M. A. Nielsen and I. L. Chuang, \"Quantum Computation and Quantum Information\", Cambridge University Press, 2002. This package also provides an easy-to-use command line tool for single-qubit approximate synthesis.
newtype-generics: 0.4. Per Conor McBride, the Newtype typeclass represents the packing and unpacking of a newtype, and allows you to operatate under that newtype with functions such as ala. Generics support was added in version 0.4, making this package a full replacement for the original newtype package, and a better alternative to newtype-th.
niagra: 0.0.1, 0.0.2, 0.2.0, 0.2.1. CSS EDSL for Haskell
nix-eval: 0.1.0.0. Evaluate Haskell expressions using Nix to get packages
no-buffering-workaround: 0.1.0.0. This package exists as a workaround for GHC bug #2189, \"@hSetBuffering stdin NoBuffering@ doesn't work on Windows\". It provides functionality for reading from standard input without buffering, in a way that works under GHC on Windows as well as other configurations. This is useful for key-driven console applications such as roguelikes.
none: 0.
nonlinear-optimization-ad: 0.1.0, 0.2.0. Wrapper of nonlinear-optimization package for using with AD package
nullary: 0.1.0.0. Work with nullary type classes without orphan instances.
nullprogram: 0. The canonical null-program
number-length: 0.1.0.1. There are situations when it is necessary to know the length of a number in decimal or hexadecimal form. In example when allocating buffer while serializing a number in to binary or human readable format. @ λ> numberLength (123 :: Int) 3 @ @ λ> numberLengthHex (123 :: Int) -- 123 = 7b in hex 2 @
numerals: 0.4. Convert numbers to number words in a number of languages. Each language has its own module. The module name is based on one of the ISO 639 Alpha codes. Each module contains one or more 'cardinal' and 'ordinal' functions and a 'struct' function. The 'cardinal' functions directly convert cardinal numbers to a string-like representation of their spoken form. The 'ordinal' functions do the same but for ordinal numbers. The 'struct' functions convert numbers to a polymorphic representation of their grammatical structure. The use of this package is best understood with some examples. First some English number names, both British and US variants: >>> import qualified Text.Numeral.Language.EN as EN >>> EN.uk_cardinal defaultInflection 123 :: Maybe Text Just "one hundred and twenty-three" >>> EN.us_cardinal defaultInflection (10^50 + 42) :: Maybe Text Just "one hundred quindecillion forty-two" French, which contains some traces of a base 20 system: >>> import qualified Text.Numeral.Language.FR as FR >>> FR.cardinal defaultInflection (-99) :: Maybe Text Just "moins quatre-vingt-dix-neuf" Conversions can fail. Alamblak, a language spoken by a few people in Papua New Guinea, has no representation for negative numbers: >>> import qualified Text.Numeral.Language.AMP as AMP >>> AMP.cardinal defaultInflection (-3) :: Maybe Text Nothing Some languages have multiple scripts and methods for writing number names. Take Chinese for example, which can be written using Han characters or transcribed to the Latin script using Pinyin. Traditional Chinese characters: >>> import qualified Text.Numeral.Language.ZH as ZH >>> ZH.trad_cardinal defaultInflection 123456 :: Maybe Text Just "十二萬三千四百五十六" Simplified characters for use in financial contexts: >>> ZH.finance_simpl_cardinal defaultInflection 123456 :: Maybe Text Just "拾贰万参仟肆伯伍拾陆" Transcribed using Pinyin: >>> ZH.pinyin_cardinal defaultInflection 123456 :: Maybe Text Just "shíèrwàn sānqiān sìbǎi wǔshí liù" Using the 'struct' functions you can see the grammatical structure of number names. Because the results of these functions are polymorphic you need to specify a specific type. >>> import qualified Text.Numeral.Language.NL as NL >>> NL.struct 123 :: Integer 123 >>> import Text.Numeral >>> NL.struct 123 :: Exp Add (Lit 100) (Add (Lit 3) (Mul (Lit 2) (Lit 10))) Compare with: >>> NL.cardinal defaultInflection 123 :: Maybe Text Just "honderddrieëntwintig" 100 (honderd) + (3 (drie) + (ën) 2 (twin) * 10 (tig))
numericpeano: 0.1.0.0, 0.2.0.0. Value-level lazy Peano numbers for all your proof-theoretic and infinity-related needs. The features are: 1) natural and integral numbers (N and Z); 2) lazy infinities; and 3) instances for all relevant typeclasses, meaning that Peano arithmetic can be used in generic functions without extra hassle. The implementation is naive: a number of magnitude n may consume O(n) bytes of memory.
numtype-dk: 0.5. This package provides type level representations of the (positive and negative) integers and basic operations (addition, subtraction, multiplication, division, exponentiation) on these. The numtype-dk package differs from the numtype package in that the NumTypes are implemented using Data Kinds, TypeNats, and Closed Type Families rather than Functional Dependencies. Requires GHC 7.8 or later.
nvim-hs: 0.0.5. This package provides a plugin provider for neovim. It allows you to write plugins for one of the great editors of our time in the best programming language of our time! ;-) You should find all the documentation you need inside the "Neovim" module. Most other modules are considered internal, so don't be annoyed if using things from there may break your code! The following modules may also be of interest and they should not change their API: "Neovim.Quickfix" If you want to write unit tests that interact with neovim, "Neovim.Test" provides some useful functions for that. If you are keen to debug /nvim-hs/ or a module you are writing, take a look at the "Neovim.Debug" module. If you spot any errors or if you have great ideas, feel free to open an issue on github.
ockcal: 0.1.0.0. ockcal tries to be the simplest possible calendar that can work
oeis: 0.3.7. Interface to the <http://oeis.org/ Online Encyclopedia of Integer Sequences (OEIS)>.
oi: 0.4.0. This package implements a data structure and operations on it for writing interactive program with no imperative flavor of IO monads. [N.B.] At the moment, APIs maybe change.
oidc-client: 0.1.0.0, 0.1.0.1, 0.2.0.0. This package supports implementing of an OpenID Connect 1.0 Relying Party. Examples: <https://github.com/krdlab/haskell-oidc-client/tree/master/examples>
old-locale: 1.0.0.6, 1.0.0.7. This package provides the ability to adapt to locale conventions such as date and time formats.
old-time: 1.1.0.2, 1.1.0.3. This package provides the old time library. For new projects, the newer <http://hackage.haskell.org/package/time time library> is recommended.
on-demand-ssh-tunnel: 0.1.0.0, 0.1.0.1, 0.1.0.2, 0.1.0.3. Program that sends traffic through SSH tunnels on-demand
opaleye-classy: 0.1.0.0. Classy MTL extension of the lovely Opaleye library, which simply just wraps things up in a MonadReader , MonadError context where the config & error are constrained by Classy Lenses & Prisms rather than by concrete types More info on this pattern can be found in George Wilson's BFPG talk : <http://talks.bfpg.org/talks/2015-06-09.next_level_mtl.html> Note: This API may not be complete. If you need other functions exported then let me know or drop in a PR.
opaleye-trans: 0.3.2. A monad transformer for Opaleye
open-browser: 0.1.0.0. Open a web browser from Haskell. Currently only OS X is supported.
open-union: 0.1.0.0. Extensible, type-safe unions. This package is very new and likely to change. Basic usage example (language tags ommitted due to <https://github.com/haskell/cabal/issues/774>) > import Data.OpenUnion > type MyUnion = Union '[Char, Int, [()]] > showMyUnion :: MyUnion -> String > showMyUnion > = (\(c :: Char) -> "char: " ++ show c) > @> (\(i :: Int) -> "int: " ++ show i) > @> (\(l :: [()]) -> "list length: " ++ show (length l)) > @> (\(s :: String) -> "string: " ++ s) > @> typesExhausted > main :: IO () > main = do > putStrLn $ showMyUnion $ liftUnion (4 :: Int) > putStrLn $ showMyUnion $ liftUnion 'a' > putStrLn $ showMyUnion $ liftUnion [(), ()] which prints: > int: 4 > char: 'a' > list length: 2 Casting to an unrelated type does not cause errors; In the above example,`showMyUnion` contains a `String` case despite `MyUnion` not containing `String` - superfluous cases are ignored, for the time being. `typesExhausted` is NOT a catchall. It is a null case, and using it as a catchall (or forgetting to provide a certain case, for instance) will result in an error like: > example.hs:12:8: > Couldn't match type ‘Int : ('[] :\ [Char])’ with ‘'[]’ > Expected type: Union ('[Int] :\ String) -> String > Actual type: Union '[] -> String > In the second argument of ‘(@>)’, namely ‘typesExhausted’ > In the second argument of ‘(@>)’, namely > ‘(\ (s :: String) -> "string: " ++ s) @> typesExhausted’ The left-hand parts of the `':` (think type-level `(:)`) are the cases that still need to be satisfied. Trying to lift an incorrect type to a `Union` will cause an error resembling: > example.hs:20:30: > No instance for (Data.OpenUnion.Internal.LiftToUnion '[] [Char]) > arising from a use of ‘liftUnion’ > In the second argument of ‘($)’, namely ‘liftUnion "asdf"’ > In the second argument of ‘($)’, namely > ‘showMyUnion $ liftUnion "asdf"’ > In a stmt of a 'do' block: > putStrLn $ showMyUnion $ liftUnion "asdf" The original use case for this library was code like this (snipped from some record/playback logic): > type TrackStates = '[Stopped, Recording, Playing] > > startRecording > :: Union (TrackStates :\ Recording) > -> ([Note], Union '[Recording]) The `(:\)` type-level operator is for removal from a set, i.e. `startRecording` can be applied to a track in any state except the `Recording` state.
opendatatable: 0.0.0. Open Data Table definition, parser and pickler.
openflow: 0.3.0. This package implements the OpenFlow 1.0 and a large part of the OpenFlow 1.3 protocols. It defines a collection of data types representing the logical contents of OpenFlow messages, defines serialization and deserialization methods using the binary package, and provides some simple servers that can be used with these data types.
orc: 1.2.1.4. Provides an EDSL with Orc primitives.
orchestrate: 0.1.0.0.
order-statistic-tree: 0.1.0.0. This repository contains an implementation of order statistic tree in Haskell programming language. I could not find an order statistic tree at Hackage, so I have to develop one. This implementation uses weight-balanced trees which are desribed in - Hirai, Yoichi, and Kazuhiko Yamamoto. "Balancing weight-balanced trees." Journal of Functional Programming 21.03 (2011): 287-307. Also some code is based on containers package. Implementation of order statistic tree is described in - Cormen, T.H., Leiserson, Rivest, Stein. Introduction to algorithms. The MIT Press. 3rd ed. = Benchmarks I tried to make this tree as fast as possible. The results on my i7-4790 with 16Gb RAM are following: - OSTree was created from 1.000.000 random numbers in 2.087 ± 0.021 s (e.g. for Data.Map.Strict - 1.977 ± 0.016 s); - deletion from OSTree with 1.000.000 random numbers was made in 13.94 ± 0.93 ms; - lookup from OSTree with 1.000.000 random numbers was made in 208.2 ± 3.48 ns; - selection from OSTree with 1.000.000 random numbers was made in 92.72 ± 1.91 ns; - full testing protocol can be found in result-bench.txt.
origami: 0.0.1, 0.0.5, 0.0.6. The Origami package consists of a coding pattern for transforming heterogenously typed data and Template Haskell macros to support the pattern. It operates in the same problem space as SYB, but generates the boilerplate for the user. In the pattern, we focus on a specific set of types, the /fold/ /family/. For each constructor of each of those types, the user will define a function to "replace" the constructor when folding. These functions are collected together into a single record. (Its declaration is generated for the user.) Collecting the functions together forces the typing of all the functions to remain consistent and facilitates code reuse. For each datatype, a fold function is automatically generated that applies the fold record to values of that datatype. It decomposes the value into parts according to its constructor, recursively applies the fold to the parts, then puts them back together using the replacement constructor function from the record. As with SYB, Origami lets the user think on a higher-level of abstraction about data transformation and relieves her from the need to write boilerplate. See the website for more information and examples.
oscpacking: 0.2.0.0, 0.2.1.0, 0.2.1.1, 0.3.0.0. Implements the simple algorithm for packing an area with circles that are 'mutually tangent' as well as functions for displaying the image on-screen.
overloaded-records: 0.1.0.0, 0.2.0.0, 0.3.0.0, 0.4.0.0, 0.4.1.0, 0.4.2.0. Implementation of /Overloaded Record Fields/ based on current GHC proposal. It is built on top of functionality that is included in GHC 8.0.1, but it works on older GHC versions as well. Most importantly, this library provides Template Haskell functions for automatic deriving of instancess for @HasField@ and @ModifyField@ type classes. With these instances overloaded fields can be used directly as getters and lenses. See README for usage examples. More about the current status of OverloadedRecordFields language extension can be found on: <https://ghc.haskell.org/trac/ghc/wiki/Records/OverloadedRecordFields GHC Wiki: OverloadedRecordFields>.
packman: 0.3.0. This package provides Haskell data serialisation independent of evaluation, by accessing the Haskell heap using foreign primitive operations. Any Haskell data structure apart from mutable data structures (@MVar@s and @TVar@s) can be serialised and later deserialised during the same run, or loaded into a new run, of the same program (the same executable file). The library provides operations to @serialize@ Haskell heap data, and to @deserialize@ it: > trySerializeWith :: a -> Int -> IO (Serialized a) -- Int is maximum buffer size to use > trySerialize :: a -> IO (Serialized a) -- uses default (maximum) buffer size > deserialize :: Serialized a -> IO a The data type @Serialized a@ is an opaque representation of serialised Haskell data (it contains a @ByteArray@). A phantom type @a@ ensures type safety within the same program run. Type @a@ can be polymorphic (at compile time, that is) when @Serialized a@ is not used apart from being argument to @deserialize@. When data are externalised (written to disk or communicated over the network) using the provided instances of @Binary@ or @Read@ and @Show@, @a@ needs to be monomorphic because they require @Typeable@ context. The instances for @Show@ and @Read@ satisfy @read . show == id@. Packman serialisation is /orthogonal/ to evaluation, heap data are serialised /in their current state of evaluation/, they might be entirely unevaluated (a thunk) or only partially evaluated (containing thunks). Therefore, there can be cases where a mutable data structure is captured by a thunk, and lead to serialisation failures (typically related to lazy I/O). The serialisation routine will throw a @PackException@ if an error occurs inside the C code which accesses the Haskell heap, if a mutable data structure is serialised, or if the serialised data is too large. In presence of concurrent threads, another thread might be evaluating data /referred to/ by the data to be serialised. In this case, the calling thread will /block/ on the ongoing evaluation and continue when evaluated data is available. Internally, there is a @PackException@ @P_BLACKHOLE@ to signal the condition, but it is hidden inside the core library
packunused: 0.1.0.1, 0.1.1.0, 0.1.1.4. This simple CLI tool allows to find out which of the packages listed as @build-depends@ in a Cabal package description file are redundant. @packunused@ works by taking advantage of GHC's @-ddump-minimal-imports@ feature which creates @.import@ files for each compiled module containing a /minimal/ set of explicit import declarations. These @.import@ files together with Cabal's generated package configuration meta-data is analyzed by @packunused@ to detect potentially redundant package dependencies. In order to use @packunused@ you have to configure the package as usual. See the example session below: > cabal clean > rm *.imports > cabal configure -O0 --disable-library-profiling > cabal build --ghc-option=-ddump-minimal-imports > packunused The @-O0 --disable-library-profiling@ options are just to speed up compilation. In some cases you might want to pass additional options to the @configure@ step, such as @--enable-benchmark@ or @--enable-tests@. When run, @packunused@ prints a report to standard output listing its findings for each component built. The following is an example for the @packunused@ package itself, with a redundant dependency added for demonstration on purpose: > detected package components > ~~~~~~~~~~~~~~~~~~~~~~~~~~~ > > - executable(s): packunused > > (component names suffixed with '*' are not configured to be built) > > executable(packunused) > ~~~~~~~~~~~~~~~~~~~~~~ > > The following package dependencies seem redundant: > > - criterion-0.6.2.0-9dd4d764629a47662168743b2dfda9bc >
pagarme: 0.1.0.0. Pagarme API wrapper
pandoc-plantuml-diagrams: 0.1.0.1, 0.1.0.2. PlantUML renders different types of UML diagrams. This filter invokes plantuml.jar (which must be present in the current directory) for any yet unrendered diagrams. Diagrams are recognized in CodeBlocks that have the class "uml". It is advisable to also include an attribute "caption", which is rendered as alternate text for the image. If an ID is present, it is additionally appended compatible with pandoc-crossref.
papillon: 0.0.82, 0.0.88. see examples directory
parallel: 3.2.0.4, 3.2.0.5, 3.2.1.0. This package provides a library for parallel programming.
parsec-pratt: 0.1.1. A combinator to generate Pratt Parsers for expressions integrating with Parsec
parseerror-eq: 0.1.0.1. A library to help with compatibility against Parsec versions. Adds an instance of `Eq` to the `ParseError` data type, if it's missing from the version of Parsec that you're compiling against. To test Parsec's parsing, it's very useful to have an Eq instance for ParseError. This is included in Parsec versions >= 3.1.9, but you need to define it yourself in previous versions. This simple library conditionally adds an Eq instance for ParseError only if the Parsec version being used is < 3.1.9. To use it, just add parseerror-eq to your cabal dependencies, and in the module where you want to compare ParseErrors, > import Text.ParseErrorEq () The ParseError Eq instance will be imported if it is necessary, otherwise the ParseErrorEq module is empty, so nothing will happen. This ensures that your code that needs the ParseError Eq instance will work regardless of the Parsec version that it is compiled against.
parsestar: 1.4. Parser for NMR-STAR data used by BMRB databank repository of biological nuclear magnetic resonance data.
partial-order: 0.1.0, 0.1.2. This packages provides the PartialOrd typeclass suitable for types admitting a partial order. The only module exposed by this package is Data.PartialOrd. Along with the PartialOrd typeclass and some utility functions for working with partially ordered types, it exports instances for certain numeric types along with instances for lists and sets.
passman-core: 0.3.1. Generates unique passwords deterministically from a single master password. A hash of the master password is stored on disk to prevent accidentally generating a password from a mistyped master password.
passwords: 0.1.0.4.
pathtype: 0.5.4. This package provides type-safe access to filepath manipulations. "System.Path" is designed to be used instead of "System.FilePath". (It is intended to provide versions of functions from that module which have equivalent functionality but are more typesafe). "System.Path.Directory" is a companion module providing a type-safe alternative to "System.Directory". The heart of this module is the @'Path' ar fd@ abstract type which represents file and directory paths. The idea is that there are two phantom type parameters - the first should be 'Abs' or 'Rel', and the second 'File' or 'Dir'. A number of type synonyms are provided for common types: > type AbsFile = Path Abs File > type RelFile = Path Rel File > type AbsDir = Path Abs Dir > type RelDir = Path Rel Dir > > type AbsPath fd = Path Abs fd > type RelPath fd = Path Rel fd > type FilePath ar = Path ar File > type DirPath ar = Path ar Dir The type of the 'combine' (aka '</>') function gives the idea: > (</>) :: DirPath ar -> RelPath fd -> Path ar fd Together this enables us to give more meaningful types to a lot of the functions, and (hopefully) catch a bunch more errors at compile time. Overloaded string literals are supported, so with the @OverloadedStrings@ extension enabled, you can: > f :: FilePath ar > f = "tmp" </> "someFile" <.> "ext" If you don't want to use @OverloadedStrings@, you can use the construction fns: > f :: FilePath ar > f = asDirPath "tmp" </> asFilePath "someFile" <.> "ext" or... > f :: FilePath ar > f = asPath "tmp" </> asPath "someFile" <.> "ext" or just... > f :: FilePath ar > f = asPath "tmp/someFile.ext" One point to note is that whether one of these is interpreted as an absolute or a relative path depends on the type at which it is used: > *System.Path> f :: AbsFile > /tmp/someFile.ext > *System.Path> f :: RelFile > tmp/someFile.ext You will typically want to import as follows: > import Prelude hiding (FilePath) > import System.Path > import System.Path.Directory > import System.Path.IO The basic API (and properties satisfied) are heavily influenced by Neil Mitchell's "System.FilePath" module.
patronscraper: 0.0.0.1.
paymill: 0.0.0. This is an unofficial client for the Paymill API.
pbkdf: 1.1.1.0. The Password Based Key Derivation Functions described in RFC-2898 with a test suite to verify that it works with the test vectors published in RFC6070.
pcf: 0.1.0.0, 0.1.0.1. PCF is a small programming language with higher order functions, natural numbers, and recursion. It is statically tpyed and turing complete (general recursion and all that). This compiler transformers a PCF expression into a file of C code that when run outputs the answer. It is mostly intended as a demonstration of how to write such a compiler. The curious reader should look at the <http://jozefg.bitbucket.org/posts/2015-03-24-pcf.html writeup>.
pell: 0.1.0.0. Finds all solutions of the generalized Pell Equation.
persistent-cereal: 0.1.0. Minor boilerplate for writing Persistance instances for values that are serializable with the 'cereal' library.
persistent-odbc: 0.1.2.0. This package contains backends for persistent using ODBC. It currently supports the following databases: MSSQL, MySql, Oracle, Sqlite, DB2, Postgres. Uses HDBC-ODBC for accessing ODBC.
pg-harness: 0.1.0, 0.1.1. This is a REST service for conveniently creating temporary PostgreSQL databases. It is intended for use from tests. Simply install, update the configuration INI file to suit your setup, and run as a system service (e.g. via systemd, upstart or similar) -- see the @SETUP.txt@ file for details on what is required of the database setup. Once the service is running you can do a HTTP POST to it to create a temporary database. For example, > $ curl -d '' http://localhost:8900 > pg-harness-test:pg-harness-pass@db:5432/temp_ba36rk6rqvs92wbofk55sz5k3pcl0u74x The response indicates that the temporary database "@temp_ba36rk6rqvs92wbofk55sz5k3pcl0u74x@" has been created on the database server "@db@" (port 5432) and made available to the user "@pg-harness-test@" using the password "@pg-harness-pass@". The database will automatically be destroyed after a configurable duration, though any temporary databases that have not been destroyed when the service is stopped will stay around. __NOTE__: No attempt has been made to prevent DoS attacks, so you should __NOT__ run this on any network facing the public Internet. It is only meant for development LANs which are firewalled off.
pgdl: 6.2, 6.6. a terminal user interface program that downloads a video from html and plays immediately.(Calling vlc) Only for Linux and MACOSX. It parses a remote html file which has link tag & filename tag in the same line.
pgp-wordlist: 0.1, 0.1.0.1. Translate between binary data and a human-readable collection of words. The PGP Word List consists of two phonetic alphabets, each with one word per possible byte value. A string of bytes is translated with these alphabets, alternating between them at each byte. The PGP words corresponding to the bytes @5B 1D CA 6E@ are "erase breakaway spellbind headwaters", for example. For further information, see <http://en.wikipedia.org/wiki/PGP_word_list Wikipedia>.
phash: 0.0.1, 0.0.3. See http://www.phash.org/ for more info. Note that you must have libphash installed on your system to use this library. Check your system library.
phone-metadata: 0.0.1.0. Phonenumber Metadata based on Google's libphonenumber
pi-calculus: 0.0.1, 0.4.0. Phi - A compiler for the applied pi-calculus. Very rough around the edges.
picoparsec: 0.1, 0.1.2. A fast and flexible parser combinator library, accepting any input type that is an instance of an appropriate monoid subclass.
pipes-csv: 1.4.0. `pipes-csv` is a streaming csv parser built on top of `cassava` and `pipes`
pipes-errors: 0.2, 0.2.1. This package is analogous to the @<http://hackage.haskell.org/package/errors errors>@ package but for base monad manipulation in the presence of @Proxy@ monad transformers. It also provides orphan @MFunctor@ instances for @EitherT@ and @EitherRT@.
pipes-io: 0.1. `pipes-io` allows you to use pipes and `Parser`s more easily in the IO monad, providing a interface similar to that of `io-streams`.
pipes-mongodb: 0.1.0.0. Stream results from MongoDB
pipes-network: 0.6.1. Use network sockets together with the @pipes@ library. This package is organized using the following namespaces: * "Pipes.Network.TCP" exports pipes and utilities for using TCP connections in a streaming fashion. * "Pipes.Network.TCP.Safe" subsumes "Pipes.Network.TCP", exporting pipes and functions that allow you to safely establish new TCP connections within a pipeline using the @pipes-safe@ facilities. You only need to use this module if you want to safely acquire and release operating system resources within a pipeline. See the @NEWS@ file in the source distribution to learn about any important changes between version.
pipes-network-tls: 0.2.0. Use TLS-secured network connections together with the @pipes@ ecosystem. This package is organized using the following namespaces: * "Pipes.Network.TCP.TLS" exports pipes and utilities for using TLS-secured TCP connections in a streaming fashion. * "Pipes.Network.TCP.TLS.Safe" subsumes "Pipes.Network.TCP.TLS", exporting pipes and functions that allow you to safely establish new TCP connections within a pipeline using the @pipes-safe@ facilities. You only need to use this module if you want to acquire and release operating system resources within a pipeline. See the @NEWS@ file in the source distribution to learn about any important changes between version.
pipes-p2p: 0.1, 0.2, 0.3, 0.4. Toy library to facilitate the creation of custom P2P networks using `pipes`.
pipes-p2p-examples: 0.1, 0.2, 0.3. For now this package includes a dummy P2P network where nodes just exchange their network addresses. This can be used as boilerplate code for other P2P networks. Future releases may contain more examples.
pipes-rt: 0.3.0, 0.4.0, 0.4.1, 0.4.2, 0.5.0. Use this library to yield values downstream according to different timing rules. For example, use the relTimeCat pipe, and your data will be yielded according to their timestamps. Or use poissonCat to yield values with poisson timing.
pipes-s3: 0.2.0.0. This package provides a simple interface for streaming data to and from Amazon's S3 cloud storage service with the @pipes@ package.
pipes-shell: 0.1.0, 0.1.1, 0.1.2, 0.1.3. This package provides functions to build proper Pipes from Unix shell commands like /tr/, /ls/ or /echo/ in a concise way. Build with /cabal configure --enable-tests/ to build the little hspec test.
pipes-text: 0.0.0.0, 0.0.0.5, 0.0.0.7, 0.0.0.8, 0.0.0.9, 0.0.0.10, 0.0.0.11, 0.0.0.12, 0.0.0.16, 0.0.1.0, 0.1.0.0. Many of the pipes and other operations defined here mirror those in the `pipes-bytestring` library. E.g., folds like `length` and grouping operations like `lines` simply adjust for the difference between strict `ByteString` and strict `Text`, and between `Word8` and `Char`. To this core are added some simple functions some akin to the `String` operations in `Pipes.Prelude`, some like the utilities in `Data.Text`. All of the `IO` operations defined here - e.g `readFile`, `stdout` etc. - are conveniences akin to those in `Data.Text.IO` which e.g. try to find the system encoding and use the exceptions defined in the `text` library. Proper `IO` in the sense of this library will employ `pipes-bytestring` in conjuntion with 'pure' operations like `decodeUtf8` and `encodeUtf8` that are defined here.
pixelated-avatar-generator: 0.1.0, 0.1.1, 0.1.3. <<data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAA1AAAACABAMAAAD345WwAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH4AcREioaDb4fhAAAABVQTFRFKSkpaLb/lpaW0JT//4xB/+eU////Sm1svwAAAeBJREFUeNrt2bFxwzAQBEC2oBbUglpwC2zB/ZfgRHbwMzf/oKUAmr0M4IHg/IY87iXfz6zu13w1SefOZ9J62nuE1PdMezVHSde//TMHKFCgQIECBQoUKFCgQIECBQoUKFCgQIECBQrUh0GlpP4UZNpLEFPIlFWQCtNBJbg6+NV9UKBAgQIFChQoUKBAgQIFChQoUKBAgQIFChSo3aGmH1zBKkAHknod0BQywXRQHdyxmPSeVai/+0GBAgUKFChQoECBAgUKFChQoECBAgUKFChQoDaF6gC6/ZoOKIEliA6qA7qaV0N1QB0YKFCgQIECBQoUKFCgQIECBQoUKFCgQIECBQrUrlD3kg4i9evgp0B1XQd/NknnusF3sB3U6vMENu2BAgUKFChQoECBAgUKFChQoECBAgUKFChQoEB9CtRq6gV18Cmp1wFMe1OgBFYBrsLVwV8NKFCgQIECBQoUKFCgQIECBQoUKFCgQIECBQrU7lD1og4k7SeQKeBZcrX/CEkw7/5x+DvwtO56oECBAgUKFChQoECBAgUKFChQoECBAgUKFChQu0JNAVZhOqjpj8MpYAfbQaVzdfBHk3TuFpKgakCBAgUKFChQoECBAgUKFChQoECBAgUKFChQoDaF+gF8d9lnmZmUZAAAAABJRU5ErkJggg==>> Pixelated Avatar Generator is a library and application for generating pixelated avatar images from seed strings.
plailude: 0.2.0, 0.4.0, 0.4.1. The prelude used internally at plaimi. It does not make a whole lot of sense to use this unless you are hacking on a plaimi project. Arguably, it doesn't even make a little sense.
plist-buddy: 0.1.0.0. Remote monad wrapper around the plistbuddy shell command for editing plists
plotfont: 0.1.0.0. Crude fonts for XY plotting
pngload-fixed: 1.0. This package provides a simple PNG loader for PNG images. It currently supports 24bit RGB(A) images with no interlacing. This fixed version is the same as pngload-0.1, but without the haskell98 dependency.
point-octree: 0.5.5.3. Based on Michal J. Gajda's octree package, but with bounding boxes.
pointedalternative: 0.1.0.0. These combinators give an alternative approach to the Control.Monad.Loops library.
polar-shader: 0.1.0.0. A high-level generic shader compiler library built for the Polar Game Engine.
poly-graph: 0.1.0.0. Please see README.md
poly-graph-arbitrary: 0.1.0.0. Please see README.md
pomodoro: 0.1.0.0. A simple pomodoro timer. Features: task bar, popup and sound notifications, tracking to file, command line interface.
ponder: 0.0.1. Ponder is PEG parser combinator. This Library is experimental.
pontarius-xmpp: 0.3.0.3, 0.4.0.0, 0.4.0.1, 0.4.0.2. Pontarius XMPP is a work in progress implementation of RFC 6120 ("XMPP CORE"), RFC 6121 ("XMPP IM"), and RFC 6122 ("XMPP ADDR"). While in alpha, Pontarius XMPP works quite well and fulfills most requirements of the RFCs.
possible: 0.1.0.0. Maybe lacks the information if Nothing represents missing or empty value. The idea is to have http://en.wikipedia.org/wiki/Three-valued_logic for values. Depends on Aeson having "Missing" value.
postcodes: 0.1.1. This library uses uk-postcodes.com to find the latitude and longitude of a postcode, postcodes in a certain area and the postcode that a location fits into
postgresql-calcdb: 0.1.0.0. A simple DB calculator for PostgreSQL
postgresql-simple: 0.5.0.0. Mid-Level PostgreSQL client library, forked from mysql-simple.
postgresql-simple-bind: 0.1.0.0. For tutorial see here: https:\/\/github.com\/zohl\/postgresql-simple-bind\/blob\/master\/README.md
postgresql-simple-migration: 0.1.0.0, 0.1.1.0, 0.1.2.0, 0.1.3.0, 0.1.6.0. A PostgreSQL-simple schema migration utility
postgresql-simple-typed: 0.1.0.0. Simplifies simple
postgresql-typed: 0.3.0. Automatically type-check SQL statements at compile time. Uses Template Haskell and the raw PostgreSQL protocol to describe SQL statements at compile time and provide appropriate type marshalling for both parameters and results. Allows not only syntax verification of your SQL but also full type safety between your SQL and Haskell. Supports many built-in PostgreSQL types already, including arrays and ranges, and can be easily extended in user code to support any other types. Originally based on Chris Forno's templatepg library.
postgrest: 0.2.5.0, 0.3.0.2. Reads the schema of a PostgreSQL database and creates RESTful routes for the tables and views, supporting all HTTP verbs that security permits.
potato-tool: 0.1.0.2. A Portable command line toolset written in Haskell for interacting with the Dreamcast Virtual Memory Unit filesystem. Named after the 8-bit Sanyo LC8670 Potato CPU contained in the VMU. It allows for injecting, extracing, removing, and viewing files in a dreamcast VMU file.
prefork: 0.0.5, 0.0.6, 0.0.7. Prefork is a library for building a prefork-style server quickly.
prelude: 0. placeholder - talk to hackage admin/trusteess if you want to claim this package name
prelude-minimal: 0.1.0.0. An alternate @Prelude@ which removes cruft and exposes the core typeclass hierarchy of "base". Specifically: @Category@; @Monoid@; @Functor@; @Applicative@; @Monad@; @Alternative@; @MonadPlus@; @Foldable@; and @Traversable@ are exposed. More polymorphic functions from these typeclasses replace their less general counterparts in the default @Prelude@. Additionally, redundancy is avoided; for instance, @return@ and @(++)@ are not exported in favour of @pure@ and @(\<\>)@.
preprocess-haskell: 0.0.1.0. Do all of the dirty work required to get a Haskell repo ready for straightforward static-analysis.
pretty-error: 0.1.0.0. Sometimes you need to assume something at runtime that you can't prove in the type system. When you do that, you should make sure you get a good error message if ever your assumption turns out to be wrong. That's what this library is for. Use the functions in here to get high quality error messages for when your invariants don't hold at runtime. The functions all pretty print any Haskell values given to them, which makes it easier to understand what's going on when your code breaks.
pretty-show: 1.6.4, 1.6.5. 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.
prettyFunctionComposing: 1.0.1. Yes, I am afraid it is completely trivial and syntactic. However, the use of '.' is quite overloaded, so that e.g. character search becomes a problem. Pretty looking & generally available at the keyboard, '°' solves this. Possibly the most simple Hackage package ever. :-P
primitive: 0.5.4.0, 0.6, 0.6.1.0. This package provides various primitive memory-related operations.
print-debugger: 0.0. Print debugging with stack trace for Haskell (formatted for the IDE). See screenshot http://i.imgur.com/KCXYHNk.png
probability-test: 0.0.0.1. probability-test currently tests whether the confidence of an Approximate is accurate. It will be expanded to test a larger class of probabilistic assertions.
process: 1.2.1.0, 1.2.2.0, 1.2.3.0. This package contains libraries for dealing with system processes.
process-extras: 0.4.1.4. Extends <http://hackage.haskell.org/package/process>. Read process input and output as ByteStrings or Text, or write your own ProcessOutput instance. Lazy process input and output. ProcessMaker class for more flexibility in the process creation API.
processor-creative-kit: 0.1.0.1. You can create your processors with your own instruction set and cpu simulator and development tools. Feature: - easy try, easy modify - a purely functional CPU core (without IO) (you can embed it anywhere) - including a very simple prototype assembler - including a very simple prototype debugger - including a very simple prototype profiler
props: 0.1. Properties of functions and relations, perhaps for use with quickcheck
proto-lens: 0.1.0.0. The proto-lens library provides to protocol buffers using modern Haskell language and library patterns. Specifically, it provides: * Composable field accessors via lenses * Simple field name resolution/overloading via type-level literals * Type-safe reflection and encoding/decoding of messages via GADTs
proto-lens-combinators: 0.1.0.0. Useful things for working with protos.
proton-haskell: 0.2. Template library which uses three attributes (eid, aid, rid) in xml tags in order to add dynamic content to an xml/xhtml document.
pseudo-boolean: 0.1.0.1, 0.1.1.0, 0.1.2.0. Reading\/Writing OPB\/WBO files used in pseudo boolean competition
pseudomacros: 0.0.2. This package provides Template Haskell pseudo-constants describing the time and place of their use, similar to @__FILE__@, @__LINE__@, @__DATE__@, etc. in the C preprocessor.
psi: 0.1.0.0. `psi`/`ψ` is just another custom Haskell prelude. It is inspired by Ambiata's p and has the same focus on promoting use of safe constructs and avoidance of partial functions.
pstemmer: 0.1.0.0. A Haskell Implementation of the Porter Stemmer
pubnub: 0.1.0.0.
punkt: 0.1.0. Multilingual unsupervised sentence tokenization with Punkt.
purescript-bridge: 0.3.0.2.
purescript-bundle-fast: 0.1.0.0. See README.md
pursuit-client: 0.1.0. Please see README.md
pusher-haskell: 0.1.0.0. A server-side client for interacting with Pusher.com
puzzle-draw: 0.1.0.0. puzzle-draw is a library for drawing pencil puzzles using Diagrams. It aims to provide a utility layer on top of Diagrams to help with drawing arbitrary puzzles, as well as supporting several specific puzzle types directly. In addition, it includes functionality for parsing puzzle data from a YAML file format.
puzzle-draw-cmdline: 0.1.0.0. Companion executable to puzzle-draw. Separate to keep the dependency on diagrams-cairo out of the library.
qm: 0.1.0.0. Ported to Haskell from the Python qm Package (<http://pypi.python.org/pypi/qm>) and the improved qm (including Petrick's method) by George Prekas (<http://github.com/prekageo/optistate>).
quadratic-irrational: 0.0.1, 0.0.2, 0.0.3, 0.0.4, 0.0.5. A library for exact computation with <http://en.wikipedia.org/wiki/Quadratic_irrational quadratic irrationals> with support for exact conversion from and to <http://en.wikipedia.org/wiki/Periodic_continued_fraction (potentially periodic) simple continued fractions>. A quadratic irrational is a number that can be expressed in the form > (a + b √c) / d where @a@, @b@ and @d@ are integers and @c@ is a square-free natural number. Some examples of such numbers are * @7/2@, * @√2@, * @(1 + √5)\/2@ (<http://en.wikipedia.org/wiki/Golden_ratio the golden ratio>), * solutions to quadratic equations with rational constants – the <http://en.wikipedia.org/wiki/Quadratic_formula quadratic formula> has a familiar shape. A simple continued fraction is a number expressed in the form > a + 1/(b + 1/(c + 1/(d + 1/(e + …)))) or alternatively written as > [a; b, c, d, e, …] where @a@ is an integer and @b@, @c@, @d@, @e@, … are positive integers. Every finite SCF represents a rational number and every infinite, periodic SCF represents a quadratic irrational. > 3.5 = [3; 2] > (1+√5)/2 = [1; 1, 1, 1, …] > √2 = [1; 2, 2, 2, …]
quandl-api: 0.1.0.0, 0.2.0.0, 0.2.1.0. This library provides an easy way to download data from Quandl.com.
quantfin: 0.1.0.1, 0.1.0.2.
quantities: 0.1.0, 0.2.0, 0.3.0. A library for creating and manipulating physical quantities, which are a numerical value associated with a unit of measurement. Included is an expression parser and a huge list of predefined quantities with which to parse strings into a Quantity datatype. Once created, a quantity can be converted to different units or queried for its dimensionality. A user can also operate on quantities arithmetically, and doing so uses automatic unit conversion and simplifcation.
quickcheck-property-comb: 0.1.0.0, 0.1.0.1, 0.1.0.2. These are simple monads that aim to reduce the pain of composing invariants/properties, and the documenting of those invariants for determining the cause of failure. Specifically, they provide a tool for effective diagnostic for invariants with changing post-conditions, leading to a faster cause-of-failure diagnosis. Example case for invariants on a data structure Consumers: > data (Ord l) => Consumers l = > Consumers > introduced :: S.Set l, > met :: M.Map (S.Set l) Bool, > disjoints :: Disjoints l > > > disjoints_odds :: Inv (Disjoints l) > disjoints_odds = do > doc "no odd sets in disjoints" > disjoint_sets <- cause > .. > return False > > disjoints_non_singletons :: Inv (Disjoints l) > disjoints_non_singletons = do > .. > return True > > disjoints_inv :: Invariants (Disjoints l) > disjoints_inv= do > sat disjoints_odds > sat disjoints_non_singletons > > introduced_in_disjoint :: Inv (Consumers l) > introduced_in_disjoint = do > doc "all at quantity are a singleton subset in disjoints" > subsets <- (map S.singleton) . S.toList . introduced <$> cause > disjoint_sets <- disjoints <$> cause > return . and . map ((flip S.member) disjoint_sets) $ subsets > > inv_consumers :: Invariants (Consumers l) > inv_consumers = do > satcomp disjoints disjoints_inv > satcomp met met_inv > sat introduced_in_disjoint And to run the invariants on generated cases: > prop_testedFunction :: Arg -> Property > prop_testedFunction arg = > let consumers = testedFunction arg in > runInvariants consumers inv_consumers
quickcheck-property-monad: 0.1. quickcheck-property-monad
quickcheck-text: 0.1.0.0, 0.1.0.1, 0.1.1.0. The usual Arbitrary instance for Text (in <https://hackage.haskell.org/package/quickcheck-instances quickcheck-instances>) only has single-byte instances and so isn't an ideal representation of a valid UTF-8 character. This package has generators for one-, two- and three-byte UTF-8 characters (all that are currently in use).
quiver-binary: 0.1.0.0. Handling for the binary library within Quivers
quiver-instances: 0.1.0.0. Various extra instances for Quiver that aren't yet in the main library. Currently this provides instances for the 'MonadThrow', 'MonadCatch' and 'MonadMask' classes from the <http://hackage.haskell.org/package/exceptions exceptions> library.
radium: 0.1, 0.2, 0.3, 0.4, 0.4.1, 0.4.2. This library contains: * periodic table with information about elements * Readers and writers for different formula formats.
radium-formula-parser: 0.1, 0.2. Parser for chemical formulas
rail-compiler-editor: 0.2.0.0. A compiler and a graphical editor for the esoteric programming language rail.
random-strings: 0.1.0.0. Useful for generating test/benchmark data, the 'Test.RandomStrings' module provides functions for generating random character strings in the ASCII range. You can specify probabilities for the alphabet-range chars and capital case characters.
random-variates: 0.1.4.0. "Collection of transforms uniform random number generators (RNGs) into any of a dozen common RNGs. Each presenting several common interfaces. Additionally Empirical distributions can be sampled from and tested (chi-squared) against theoretical distributions."
range-set: 0.1.0. A set of elements represented as a list of ranges.
rank1dynamic: 0.2.0.0. "Data.Typeable" and "Data.Dynamic" only support monomorphic types. In this package we provide similar functionality but with support for rank-1 polymorphic types.
rascal: 1.1.4, 1.1.5, 1.1.6. Rascal is a command-line client for Reddit with colors, configurable sorting, threaded comments, and some day most of Reddit's API available.
rawr: 0.0.0.0, 0.0.0.1. This library provides anonymous extensible records using GHC 8.0 features, with the following goals/features: * The syntax should be very close to that of Haskell's record system. * The library should be simple to use and requires no extra boilerplate to setup. * There should be minimal runtime overhead and memory footprint. * The library does not require @TemplateHaskell@ to use. * It should produce good error messages. * Minimal dependencies. Currently, it only depends on packages that comes with GHC. See @<https://hackage.haskell.org/package/rawr/docs/Data-Rawr.html Data.Rawr>@ for a tutorial of this library.
rawstring-qm: 0.1.5. Supply a couple of usefull QuasiQuotes so we can use functions to lookup values This is an initial, and unstable package.
raz: 0.1.0.0. Please see README.md
rdf: 0.1.0.0. Data structures, parsers, and encoders for RDF data sets based on the RDF 1.1 abstract syntax and RFC 3987. The interface is intended to support incremental graph processing in constant space.
re2: 0.1. re2 is a regular expression library offering predictable run-time and memory consumption. This package is a binding to re2. Supported expression syntax is documented at <http://code.google.com/p/re2/wiki/Syntax>. >$ ghci -XOverloadedStrings >ghci> import Regex.RE2 > >ghci> find "\\w+" "hello world" >Just (Match [Just "hello"]) > >ghci> find "\\w+$" "hello world" >Just (Match [Just "world"]) > >ghci> find "^\\w+$" "hello world" >Nothing
react-haskell: 1.1.0.0, 1.2.0.0, 1.3.0.0, 2.0.0. This package provides high level bindings to Facebook's <http://facebook.github.io/react/ React> library, meant for use with GHCJS. React is a JavaScript library for building user interfaces. React (and React-Haskell) is focused on just UI - it's not a framework. Currently React-Haskell can render simple stateful components, but not what React calls classes. Put another way, React-Haskell doesn't support lifecycle methods yet. Here's a simple example which demonstrates basic elements, attributes, state, and handling events. > -- We're creating a class with JSString state > data Example > instance ReactKey Example where > type ClassState Example = JSString > type AnimationState Example = () > type Signal Example = JSString > > -- updating to the new state without animation > transition :: JSString -> JSString -> (JSString, [AnimConfig Example]) > transition oldState signal = (signal, []) > > view :: JSString -> React Example () > view str = div_ [ class_ "container" ] $ do > input_ [ value_ str, onChange (Just . value . target) ] > > main :: IO () > main = withElem "id" $ \elem -> > render elem =<< createClass view transition "" () []
read-bounded: 0.1.1.0. Class for reading bounded values from strings.
reasonable-lens: 0.2.0.0. Just size lens implementation.
redis-io: 0.2, 0.3, 0.3.1, 0.4.1, 0.5.0, 0.5.1, 0.5.2, 0.6.0, 0.7.0. Yet another redis client.
redis-resp: 0.2, 0.3, 0.3.1, 0.3.2, 0.4.0. REdis Serialization Protocol (RESP) implementation as specified in <http://redis.io/topics/protocol>. Additionally most Redis commands are declared as an GADT which enables different interpretations such as <http://hackage.haskell.org/package/redis-io redis-io>.
reflex: 0.0.1, 0.1.0, 0.2, 0.3, 0.3.1, 0.3.2, 0.4.0. Reflex is a high-performance, deterministic, higher-order Functional Reactive Programming system
reflex-dom: 0.1, 0.1.1, 0.2, 0.3. Reflex-DOM is a Functional Reactive web framework based on the Reflex FRP engine
reflex-jsx: 0.1.0.0. `reflex-jsx` is a library for writing jsx-like syntax in reflex code. This can be useful for situations where you have a large block of HTML with some styles, and it would be easier to read as actual HTML than various reflex functions. It's implemented as a "QuasiQuoter", so you just import the `jsx` function from ReflexJsx and generate the equivalent functions that would run inside of a "MonadWidget t m". Not only can you generate a block of static HTML/CSS, but you can also splice in your own nodes that implement "MonadWidget t m", string attribute values, or even entire dynamic attribute maps.
reflex-orphans: 0.1. This package provides additional instances missing from <https://hackage.haskell.org/package/reflex reflex>, specificly 'Functor' and 'Applicative' for 'Dynamic'. The inclusion of these instances facilitates easier, conventional Haskell style programming in reflex.
reflex-transformers: 0.1. This library provides a set of Monad transformers (and instances for common transformers) on top of widget switching primitives for reflex. For example ReaderT and WriterT which operate in the presence of widget switching, allowing you to pass inputs and outputs up and down the UI tree.
reified-records: 0.1.0.0, 0.2.0.0, 0.2.1, 0.2.2. This package provides a series of functions to do introspect records and allow records to be manipulated dynamically as @Map@s. Currently this works using @Data.Data@ however in future this will likely change to @GHC.Generics@ and allow more user hooks into how types are reified and reflected.
remote-debugger: 0.1.0, 0.1.1, 0.2.2. Wraper to GHC debugger API allowing debugging throught socket. Used in haskell-idea-plugin.
remote-json: 0.2. JSON RPC, where you can using monads and applicative functors to bundle JSON RPC methods and notifications. @ {-# LANGUAGE GADTs, OverloadedStrings, TypeOperators #-} module Main where import Control.Natural ((:~>), nat) import Control.Remote.Monad.JSON import Control.Remote.Monad.JSON.Router(transport,router,Call(..),methodNotFound) import Data.Aeson import Data.Text(Text) -- Our small DSL say :: Text -> RPC () say msg = notification "say" (List [String msg]) temperature :: RPC Int temperature = method "temperature" None -- Our remote program main :: IO () main = do   let s = weakSession network   t <- send s $ do     say "Hello, "     say "World!"     temperature   print t -- Simulate the JSON-RPC server network :: SendAPI :~> IO network = transport $ router sequence $ nat remote   where     remote :: Call a -> IO a     remote (CallMethod "temperature" _) = return $ Number 42     remote (CallNotification "say" (List [String msg])) = print msg     remote _ = methodNotFound @
remote-json-client: 0.2. Web client, using wreq, for the JSON RPC protcol.
remote-json-server: 0.2, 0.2.0.1. Web server, using scotty, for the JSON RPC protocol.
remote-monad: 0.1.0.0, 0.1.0.1, 0.2. An implementation of the concepts behind Remote Monads. There is support for various bundling strategies. @ {-# LANGUAGE GADTs #-} {-# LANGUAGE KindSignatures #-} module Main where import Control.Natural (nat, (#)) import Control.Remote.Monad import Control.Remote.Monad.Packet.Weak data Command :: * where   Say :: String -> Command data Procedure :: * -> * where   Temperature :: Procedure Int say :: String -> RemoteMonad Command Procedure () say s = command (Say s) temperature :: RemoteMonad Command Procedure Int temperature = procedure Temperature runWP :: WeakPacket Command Procedure a -> IO a runWP (Command (Say s)) = print s runWP (Procedure Temperature) = return 42 send :: RemoteMonad Command Procedure a -> IO a send = run $ runMonad $ nat runWP main = send $ do   say "Howdy doodly do"   say "How about a muffin?"   t <- temperature   say (show t ++ "F") @
repa-hmatrix: 0.0.0.0.
repa-linear-algebra: 0.0.0.0. HMatrix Vector and Matrix conversions to and from REPA Array F DIM1/2 (Complex) Double, together with a port of linear algebraic functions.
repl-toolkit: 0.1.0.0, 0.2.0.0, 0.3.0.0, 0.3.1.0, 0.4.0.0, 0.5.0.0, 1.0.0.1, 1.0.1.0, 1.1.0.0. A simple toolkit for quickly whipping up REPLs, input validation and sets of commands included.
reserve: 0.0.0. Universal and robust reloading of Haskell web applications
rethinkdb-client-driver: 0.0.0.1. This is an alternative client driver for RethinkDB. It is not complete yet, but the basic structure is in place and the driver can make simple queries. Its main focus is on type safety, which it achieves quite well. It also uses the new JSON protocol which should give it a speed boost (and make the driver compatible with GHC 7.8). Note that the driver is neither thread-safe nor reentrant. If you have a multi-threaded application, I recommend using 'resource-pool'.
rethinkdb-wereHamster: 1.8.0.5. RethinkDB is a distributed document store with a powerful query language.
retry: 0.7. This package exposes combinators that can wrap arbitrary monadic actions. They run the action and potentially retry running it with some configurable delay for a configurable number of times. The purpose is to make it easier to work with IO and especially network IO actions that often experience temporary failure and warrant retrying of the original action. For example, a database query may time out for a while, in which case we should hang back for a bit and retry the query instead of simply raising an exception.
reverse-geocoding: 0.1.0.0, 0.1.0.1, 0.1.0.2, 0.1.1.0, 0.1.1.1. Simple reverse geocoding using OpenStreeMap
rex: 0.4.3. Provides a quasi-quoter for regular expressions which yields a tuple, of appropriate arity and types, representing the results of the captures. Allows the user to specify parsers for captures as inline Haskell. Can also be used to provide typeful pattern matching in function definitions and pattern matches. Also, it precompiles the regular expressions into a PCRE compiled byte-array representation, at compile time.
riff: 0.1.0.0, 0.2.0.0, 0.3.0.0. This library provides a RIFF parser for Haskell for easy manipulation of common file formats like WAVE and RIFF container AVI files.
ringo: 0.1.0.0. Tool to transform OLTP schemas to OLAP star schemas automatically
rison: 0.1.0.0, 1.0.0.0. Rison gets parsed into and serialized from Aeson Valueobjects. Please see README.md for details.
roller: 0.1.4, 0.1.5. A basic library and program for simulated rolling of polyhedral dice, as would be used in pen and paper RPGs.
romkan: 0.1.0.0. Romkan is a library to convert from Japanese Romaji to Japanese Kana and vice versa. Homepage is at <https://github.com/karlvoigtland/romkan-hs>. This is a port of python-romkan: <http://www.soimort.org/python-romkan>.
rtlsdr: 0.1.0.0. Bindings to librtlsdr. Turns your Realtek RTL2832 based DVB dongle into a SDR receiver. For more information see: http://sdr.osmocom.org/trac/wiki/rtl-sdr
rts: 0.
rubberband: 0.1, 0.1.0.1. <http://breakfastquay.com/rubberband/ Rubber Band Library> is a high quality software library for audio time-stretching and pitch-shifting. It permits you to change the tempo and pitch of an audio stream or recording dynamically and independently of one another. Rubber Band Library is open source software under the GNU General Public License. If you want to distribute it in a proprietary commercial application, you need to <http://breakfastquay.com/rubberband/license.html buy a license>. This is a binding to Rubber Band Library v1.8.1.
ruby-marshal: 0.0.1, 0.1.0. Parse a subset of Ruby objects serialised with Marshal.dump.
safe-access: 0.1.0.0, 0.2.0.0. This is a small capability-based interface to check legitimacy of accesses in different parts of the program depending on the context in which the data is accessed. See the README.md in the repository for a longer explanation and an example.
sai-shape-syb: 0.2.0, 0.2.1, 0.2.2. This package provides SYB shape support: generic mapping to homogeneous types, and related features. Complements existing Uniplate and TH shape libraries. See <http://www.fremissant.net/shape-syb> for more information. Given a value of arbitrary complexity (mutually recursive heterogeneous constructor application), you can obtain a structure-preserving representation (homomorphism) as a homogeneous type @Homo a@, parameterised by any choice type @a@.
sandi: 0.3.0.1, 0.3.6. Reasonably fast data encoding library.
sarasvati: 0.3.0.0. an audio library with portaudio.
sasl: 0.0.0.0. Example programs SCRAM-SHA-1 Client sample scramSha1sv.txt > r=00DEADBEEF007658cddf-0e44-4de2-87df-4132bce97f4,s=cGVwcGVy,i=4492 > v=q0+IZgUtQTHYItaurlNyET1imLI= > success examples/clientS.hs extensions * OverloadedStrings * PackageImports > import "monads-tf" Control.Monad.State > import Data.Pipe > import Data.Pipe.ByteString > import System.IO > import Network.Sasl > import Network.Sasl.ScramSha1.Client > > import qualified Data.ByteString as BS > > data St = St [(BS.ByteString, BS.ByteString)] deriving Show > > instance SaslState St where > getSaslState (St s) = s > putSaslState s _ = St s > > serverFile :: String > serverFile = "examples/scramSha1sv.txt" > > main :: IO () > main = do > let (_, (_, p)) = sasl > r <- runPipe (fromFileLn serverFile =$= input =$= p =$= toHandleLn stdout) > `runStateT` St [ > ("username", "yoshikuni"), > ("password", "password"), > ("cnonce", "00DEADBEEF00") ] > print r > > input :: Pipe BS.ByteString (Either Success BS.ByteString) (StateT St IO) () > input = await >>= \mbs -> case mbs of > Just "success" -> yield . Left $ Success Nothing > Just ch -> yield (Right ch) >> input > _ -> return () SCRAM-SHA-1 Server sample scramSha1cl.txt > n,,n=yoshikuni,r=00DEADBEEF00 > c=biws,r=00DEADBEEF007658cddf-0e44-4de2-87df-4132bce97f4,p=zup7ghwpAW43cP4Xu3YZTNnHo0g= > examples/serverS.hs extensions * OverloadedStrings * PackageImports > import "monads-tf" Control.Monad.State > import Data.Pipe > import Data.Pipe.ByteString > import System.IO > import Network.Sasl > import Network.Sasl.ScramSha1.Server > > import qualified Data.ByteString as BS > > data St = St [(BS.ByteString, BS.ByteString)] deriving Show > > instance SaslState St where > getSaslState (St s) = s > putSaslState s _ = St s > > clientFile :: String > clientFile = "examples/scramSha1cl.txt" > > main :: IO () > main = do > let slt = "pepper" > i = 4492 > (stk, svk) = salt "password" slt i > (_, (_, p)) = sasl $ \"yoshikuni" -> return (slt, stk, svk, i) > r <- runPipe (fromFileLn clientFile =$= p =$= output =$= toHandleLn stdout) > `runStateT` St [("snonce", "7658cddf-0e44-4de2-87df-4132bce97f4")] > print r > > output :: Pipe (Either Success BS.ByteString) BS.ByteString (StateT St IO) () > output = await >>= \mch -> case mch of > Just (Left (Success Nothing)) -> yield "success" > Just (Left (Success (Just bs))) -> yield bs > Just (Right bs) -> yield bs >> output > _ -> return () See examples directory for more examples.
satchmo-toysat: 0.2.0.0, 0.2.1.0. toysat driver as backend for satchmo
scc: 0.8.2.1. SCC is a layered library of Streaming Component Combinators. The lowest layer in "Control.Concurent.SCC.Streams" defines stream abstractions and nested producer-consumer coroutine pairs based on the Coroutine monad transformer. On top of that are streaming component types, a number of primitive streaming components and a set of component combinators. Finally, there is an executable that exposes all the framework functionality in a command-line shell. The original library design is based on paper <http://conferences.idealliance.org/extreme/html/2006/Blazevic01/EML2006Blazevic01.html> Mario Blažević, Streaming component combinators, Extreme Markup Languages, 2006.
schedule: 0.0. See "Control.Monad.Trans.Schedule" for the main entry point into this library.
schedule-planner: 0.1.0.0. Executable program for calculating layouts for fixed grid schedules as are used in many universities and schools. The primary data format for in- and output is json, a deployable server instance of this software is planned.
scholdoc: 0.1.3. Scholdoc is a command-line utility that converts ScholarlyMarkdown documents into the HTML5, LaTeX, and Docx (OOML) formats. It is intended to facilitate academic writing in a cross-platform, semantic-aware, plaintext format that can be quickly used in modern publishing pipelines. Scholdoc is implemented as (rather crude) fork of @pandoc@, and the command-line executable mostly retains the same user interface (including the custom template and filter system). It essentially understands a new input format @markdown_scholarly@ (implemented in the markdown reader a superset of @markdown_pandoc@ features), and limits itself to HTML5, LaTeX, and Docx output. Unfortunately, currently Scholdoc occupies the @Pandoc@ namespace. This is done to avoid problems when merging in fixes and changes from the core Pandoc project, and to potentially allow enhancements from Scholdoc to be contributed back to Pandoc. It is thus not recommended to use the library directly, as Scholdoc is not backwards-compatible with Pandoc, to avoid confusion. For descriptions of the original @pandoc@ package, please visit <http://hackage.haskell.org/package/pandoc>
scholdoc-citeproc: 0.6. This package is a fork of @pandoc-citeproc@, intended to support the development of Scholdoc. It is currently just a trivial fork just so it can compile against @scholdoc-citeproc@ without polluting the @pandoc-citeproc@ package and executable namespace. This package is versioned identically to @pandoc-citeproc@. For descriptions of the original @pandoc-citeproc@ package, please visit <http://hackage.haskell.org/package/pandoc-citeproc>
scholdoc-texmath: 0.1. This package is a fork of @texmath@, intended to support the development of Scholdoc. It is currently just a trivial fork just so it can compile against @scholdoc-types@ without polluting the @texmath@ package namespace. This package is currently up to date with @taxmath@ version 0.8 The @texmath@ library provides functions to read and write TeX math, presentation MathML, and OMML (Office Math Markup Language, used in Microsoft Office). For descriptions of the original @texmath@ package, please visit <http://hackage.haskell.org/package/texmath>
scholdoc-types: 0.1.3. This package is a fork of @pandoc-types@ intended to support the development of Scholdoc. It includes some non-trivial extensions to the Pandoc types and builder functions that are not easily implemented by depending on and extending the @pandoc-types@ modules. This package is currently up to date with @pandoc-types@ version 1.12.4 For descriptions of the original @pandoc-types@ package, please visit <http://hackage.haskell.org/package/pandoc-types>
science-constants: 0.1.0.0, 0.1.0.1, 0.2.0.0. This package provides constants and conversion factors commonly used in mathematics and physical sciences. The motivation is to make it easier to use ghci for quick scientific calculations [without the need to search for the constant values over the internet.] To make it even friendlier, if multiple conventional names of a constant exist, they all are provided by this package. Wherever possible, TeX-style named constants are also provided. This package utilizes untyped values (i.e. untyped in terms of @unittyped@, @dimensional@, and similar libraries); and unless otherwise specified, the constants are in SI units: mass in kilograms, length in meters, etc. Due to floating-point calculation errors and to improve accuracy, the package internally uses exact values even in cases where constants can be mathematically derived one from another. Most of the constants values were taken from the Fundamental Constants Data Center of the NIST Physical Measurement Laboratory (by Barry N. Taylor of the Data Center in close collaboration with Peter J. Mohr of the Physical Measurement Laboratory's Atomic Physics Division.) <http://physics.nist.gov/cuu/>
science-constants-dimensional: 0.1.0.0, 0.1.0.1, 0.1.0.2. "Science.Constants.Dimensional" is a variant of "Science.Constants"[1] package, with the only difference is that that the dimensional flavor provides (where applicable) dimensionally-typed constants. The "Numeric.Units.Dimensional"[2] wrappers allow to write type-safe formulas, for example all of this will successfully type-check: > ~$ ghci -XNoImplicitPrelude > λ= import Numeric.Units.Dimensional.Prelude > > λ= import Science.Constants.Dimensional > > λ= massOfProton + massOfElectron > > 1.673532715291e-27 kg > λ= massOfProton / massOfElectron > > 1836.1526719486646 But this will not: > λ= massOfProton / massOfElectron + planckConstant > > <interactive>:10:14: > Couldn't match type `Numeric.NumType.Pos > (Numeric.NumType.Pos Numeric.NumType.Zero)' > with `Numeric.NumType.Zero' [1] <https://hackage.haskell.org/package/science-constants> [2] <https://hackage.haskell.org/package/dimensional>
scotty-binding-play: 1.0. The Play Framework style data binding in Scotty.
scotty-fay: 0.0.1, 0.0.2, 0.1.0, 0.1.1. Fay integration for Scotty. For more information, please see <https://github.com/hdgarrood/scotty-fay>.
scotty-hastache: 0.2.0. This library provides a small templating DSL extension for Scotty via the `hastache` library. [Scotty] is a light-weighted Web framework\/router <http://hackage.haskell.org/package/scotty> [Hashache] is a Haskell implementation of the Mustache templates: <http://mustache.github.io/>, <http://hackage.haskell.org/package/hastache>
scotty-login-session: 0.1.0.0. Simple library for session adding and checking, with automatic SQLite backup of session store. The store is stored in memory for fast access. Session cookie expiration and database syncing timing are configurable.
scp-streams: 0.1.0. An SCP protocol implementation.
scrz: 0.0.0.1. @scrz@ is a daemon that runs and monitors other processes. It is similar to djb's `daemontools`, the Ruby project `god` or Haskell's `Angel`. It's goals are to keep a set of services running, and to facilitate the easy configuration and restart of those services.
scurry: 0.1.0. A Haskell client for the <http://strava.github.io/api/ Strava V3 API>.
sdl2-image: 0.1.0.1, 0.1.1.0. Haskell binding to sdl2-image.
seacat: 1.0.0.0, 1.0.0.2. A small Haskell web framework using Warp and WAI that tries to get out of your way and let you do what you want, but also providing more advanced features like rate limiting and flood protection. [WAI] <http://hackage.haskell.org/package/wai> [Warp] <http://hackage.haskell.org/package/warp>
seclib: 1.1.0.1. This package presents a static library to enforce /Information-Flow Control/ (IFC) in Haskell. IFC allows untrusted code to manipulate sensitive data (i.e., secret information), while preserving its confidentiality. To illustrate the use case scenario for /SecLib/, let us consider two Haskell programmers , Alice and Bob, who do not trust each other. Image that Alice wishes to use Bob's code to check the strength of Alice's sensitive passwords. Clearly, Alice is concern that the passwords could be leaked if they are run with Bob's code. How could Alice be sure that Bob's code will preserve the confidentiality of Alice's password? One option is to do code review---a very time consuming approach. Instead, Alice demands that Bob's code uses the security monads provided by this library (i.e., 'Sec' and 'SecIO'). Now, Alice only requires, by using the type-system, that Bob's code is written using such monads. Importantly, Alice needs to use Safe Haskell to compile Bob's untrusted code using the flags @-XSafe@. This package provides the files @Alice.hs@ and @Bob.hs@. The former calls into functions provided by the latter and the library guarantees that secrets are not unintentionally or maliciously leaked. The library is a modern and simplified version (updated to exploit the last GHC type-system features) of the work presented in /A Library for Light-weight Information-Flow Security in Haskell/ by Alejandro Russo, Koen Claessen and John Hughes. In Proc. of the ACM SIGPLAN 2008 Haskell Symposium. With respect to the version 1.0.0.0, this version has less side-effectful features (e.g., no secure file handlers and sockets) as well as declassification combinators. However, it presents a simpler and more intuitive interface which can be easily extended to cover a rich-set of side-effects.
secret-sharing: 1.0.0.0, 1.0.0.3. Implementation of an (@m@,@n@)-threshold secret sharing scheme. A given ByteString @b@ (the secret) is split into @n@ shares, and any @m@ shares are sufficient to reconstruct @b@. The scheme preserves information-theoretic perfect secrecy in the sense that the knowledge of up to @m-1@ shares does not reveal any information about the secret @b@. /Example in GHCi:/ Suppose that you want to split the string \"my secret data\" into n=5 shares such that at least m=3 shares are necessary to reconstruct the secret. >> :m + Data.ByteString.Lazy.Char8 Crypto.SecretSharing >> let secret = pack "my secret message!" >> shares <- encode 3 5 secret >> mapM_ (Prelude.putStrLn . show) shares -- each share should be deposited at a different site. > (1,"\134\168\154\SUBV\248\CAN:\250y<\GS\EOT*\t\222_\140") > (2,"\225\206\241\136\SUBse\199r\169\162\131D4\179P\210x") > (3,"~\238%\192\174\206\\\f\214\173\162\148\&3\139_\183\193\235") > (4,"Z\b0\188\DC2\f\247\f,\136\&6S\209\&5\n\FS,\223") > (5,"x\EM\CAN\DELI*<\193q7d\192!/\183v\DC3T") >> let shares' = Prelude.drop 2 shares >> decode shares' > "my secret message!" The mathematics behind the secret sharing scheme is described in: \"/How to share a secret/.\" by Adi Shamir. In Communications of the ACM 22 (11): 612–613, 1979.
selecth: 0.1.0.0. A port of Gary Berndhart's Selecta, an editor-independent fuzzy filter that reads from stdin and outputs the selection to stdout.
selectors: 0.1.0.0.
semi-iso: 0.4.0.0. Semi-isomorphisms are partial isomorphisms with weakened iso laws. And they work with Iso and Prism from @lens@! See first "Control.Lens.SemiIso" for semi-isomoprhisms. After that look at "Data.SemiIsoFunctor".
semibounded-lattices: 0.1.0.0. Please see README.md
sendgrid-haskell: 1.0. A Haskell SendGrid API client
servant-bazaar: 0.1. An example project to illustrate how to package servant combinators while avoiding introducing unwanted dependencies.
servant-github: 0.1.0.0. This package provides a servant-client based client for accessing the <https://developer.github.com/v3/ GitHub API v3>. The github client is provided through the 'Network.GitHub.GitHub' monad, which provides support for managing the user-agent (a requirement for github), an authentication token, and, pagination support when the resulting value is a list. > > import System.Environment > import Data.String > import Network.GitHub > > main = do > token <- fmap fromString <$> lookupEnv "GITHUB_TOKEN" > result <- runGitHub userOrganisations token > case result of > Left e -> print e > Right orgs -> mapM_ print orgs
servant-github-webhook: 0.1.0.0. This package provides servant combinators that make writing safe GitHub webhooks very simple. It features automatic verification of the digital signatures provided by GitHub in the webhook HTTP requests as well as route dispatching based on repository event type.
servant-pandoc: 0.4.0. See <https://github.com/mpickering/servant-pandoc/blob/master/README.md README>.
setup: 0.
sexp-grammar: 1.0.0, 1.1.1. Invertible grammar combinators for serializing and deserializing from S-expessions
sext: 0.1.0.0. Sext (/s/tatic t/ext/) 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.
sha-streams: 0.1.0, 0.2.0, 0.2.1. SHA hashes for io-streams.
shadow-box-model: 0.1.0. For discretized 2d collision detection, a binary array is a nice world model.
shadower: 0.1.0.2, 0.1.0.3, 0.1.0.4. Shadower watches folders with Haskell sources, and runs doctests in files that are modified
shakespeare: 2.0.5. Shakespeare is a family of type-safe, efficient template languages. Shakespeare templates are expanded at compile-time, ensuring that all interpolated variables are in scope. Variables are interpolated according to their type through a typeclass. Shakespeare templates can be used inline with a quasi-quoter or in an external file. Note there is no dependency on haskell-src-extras. Instead Shakespeare believes logic should stay out of templates and has its own minimal Haskell parser. Packages that use this: shakespeare-js, shakespeare-css, shakespeare-text, hamlet, and xml-hamlet Please see the documentation at <http://www.yesodweb.com/book/shakespearean-templates> for more details.
should-not-typecheck: 0.1.0.0, 1.0, 1.0.1, 2.0, 2.0.1, 2.1.0. For examples and an introduction to the library please take a look at the <https://github.com/CRogers/should-not-typecheck#should-not-typecheck- README> on github.
sifflet: 2.3.0. Sifflet is a visual, functional programming language. It is intended as an aid for learning about recursion. Sifflet users can make programs by drawing diagrams to connect functions and other units. Sifflet shows the intermediate steps of the computation on the diagram, and can expand function calls to show further details.
sign: 0.4.1, 0.4.2. Arithmetic over signs (i.e. -, 0, +) and sets of signs
simple: 0.7.0.1. \Simple\ is \"framework-less\" web framework for Haskell web applications based on the WAI server interface (e.g. for use with the warp server). \Simple\ does not enforce a particular structure or paradigm for web applications. Rather, \Simple\ contains tools to help you create your own patterns (or re-create existing ones). \Simple\ is minimalist, providing a lightweight base - the most basic \Simple\ app is little more than a WAI `Application` with some routing logic. Everything else (e.g. authentication, controllers, persistence, caching etc\') is provided in composable units, so you can include only the ones you need in your app, and easily replace with your own components. To get started, create an app skeleton with the `smpl` utility: @ $ cabal install simple $ smpl create my_app_name $ cd my_app_name $ smpl @ See "Web.Simple" for a more detailed introduction.
simple-genetic-algorithm: 0.1.0.0. Simple parallel genetic algorithm implementation
simple-session: 0.8.0.1. Adds cookie-based session management to simple 'Controller's. To add to an application, declare the Controller setting\'s type an instance of 'HasSession', and wrap routes with 'withSession'. For example: > data AppSettings = ... > > instance HasSession AppSettings where > ... > controllerApp settings $ withSessions $ do > routeName \"posts\" $ ... Then, in your controllers you can seemlessly get and set keys from the session: > get "/profile" $ do > muserId <- sessionLookup "current_user_id" > case muserIf of > Nothing -> respond $ redirectTo "/login" > Just userId -> [handle request]
simple-smt: 0.5.0. A simple way to interact with an SMT solver process.
simple-sql-parser: 0.1.0.0, 0.2.0, 0.3.0, 0.3.1, 0.4.0, 0.4.1. A parser for SQL queries. Parses most SQL:2011 queries. Please see the homepage for more information <http://jakewheat.github.io/simple-sql-parser/>.
simpleirc: 0.3.0. Simple IRC Library. This IRC Library aims to be simple and lightweight.
simplessh: 0.1.0.0, 0.2.0.0, 0.2.0.1, 0.2.0.3, 0.2.0.4, 0.2.0.5. It supports authentication by password or keys. Everything is in the SimpleSSH monad which is ErrorT SimpleSSHError IO, allowing to manage errors in a "haskeller" way.
size-based: 0.1.0.0.
sized-types: 0.5.0. Providing matrixes, sparse matrixes, and signed and unsigned bit vectors, using GHC Nat kind.
skeletons: 0.1.0.0, 0.2.0.
skype4hs: 0.0.0.0. Skype Desktop API binding for Haskell
slidemews: 0.2, 0.3. Simple WebService to convert markdown to reveal-js | https://github.com/j4/slidemews
slim: 0.0.1. More to come
smallcaps: 0.4, 0.4.0.1, 0.4.1, 0.4.1.1, 0.4.1.2, 0.6.0.2. smallcaps is a pre-processor library for LaTeX files. The library comes with an executable that makes most functionality accessible through a command line interface. The pre-processor formats sequences of uppercase letters with TeX's @\\small@ macro or whatever you configure. Uppercase letters at the beginning of sentences are not formatted. Other formatting conditions can be configured by the user. The executable can be configured through its command line arguments as well as through TeX comments. In the default configuration, lesscase does not change the content of any macro argument or environment (different from document). More and less restrictive configuration profiles can be activated and adapted. Configurations can be stored and restored at any time, even while processing the input file. ["Text.SmallCaps"] exports the main program as library. ["Text.SmallCaps.Config"] specifies the default configuration values for "Text.SmallCaps". ["Text.SmallCaps.TeXParser"] parses 'Text' to a 'TeXElement' token stream. ["Text.SmallCaps.TeXLaTeXParser"] parses a 'TeXElement' token stream and produces a 'LaTeXElement' token stream. ["Text.SmallCaps.DocumentParser"] replaces uppercase letters in 'LaTeXElement' token streams. A simple program can be defined as @ import Data.Default ( def ) import Text.SmallCaps ( smallcaps ) import Text.SmallCaps.Config ( defaultProfile ) main = smallcaps def defaultProfile @ This is virtually all the code that is necessary to implement the executable @lesscase@. Have a look in the source of the executable @twocase@ which only formats sequences of two or more uppercase letters. It is a good reference for understanding the API changes that took place between the revisions 0.5 and 0.6.
smoothie: 0.1.0.0. This package exports several splines and curves you can use to interpolate points in between.
smtlib2: 1.0.
smtp-mail-ng: 0.1.0.0. An SMTP client EDSL
smtps-gmail: 1.0.0, 1.1.0, 1.1.1, 1.2.0, 1.2.1, 1.3.0, 1.3.1, 1.3.2. Send email from your Gmail account.
snake: 0.1.0.0. A basic console snake game with rudimentary ASCII-based graphics and minimal dependencies.
snap: 1.0.0.0, 1.0.0.1. This is the top-level package for the official Snap Framework libraries. It includes: * The Snaplets API * Snaplets for sessions, authentication, and templates To get started, issue the following sequence of commands: @$ cabal install snap snap-templates $ mkdir myproject $ cd myproject $ snap init@ If you have trouble or any questions, see our FAQ page (<http://snapframework.com/faq>) or the documentation (<http://snapframework.com/docs>). Note: since version 1.0, the \"snap\" executable program for generating starter projects is provided by the @snap-templates@ package.
snap-core: 1.0.0.0. Snap is a simple and fast web development framework and server written in Haskell. For more information or to download the latest version, you can visit the Snap project website at <http://snapframework.com/>. This library contains the core definitions and types for the Snap framework, including: 1. Primitive types and functions for HTTP (requests, responses, cookies, post/query parameters, etc) 2. A monad for programming web handlers called \"Snap\", which allows: * Stateful access to the HTTP request and response objects * Monadic failure (i.e. MonadPlus/Alternative instances) for declining to handle requests and chaining handlers together * Early termination of the computation if you know early what you want to return and want to prevent further monadic processing /Quick start/: The 'Snap' monad and HTTP definitions are in "Snap.Core".
snap-extras: 0.9. This package contains a collection of helper functions that come in handy in most practical, real-world applications. Check individual modules to understand what's here. You can simply import Snap.Extras and use the initializer in there to get them all at once.
snap-language: 0.1.0.0, 0.1.0.1, 0.1.0.2. Language handling for Snap. Support for determining the client's prefered language using the Accept-Language header or using suffixes to the requested URI.
snap-loader-dynamic: 1.0.0.0. Snap Framework dynamic code loader for development mode
snap-loader-static: 1.0.0.0. Snap Framework static loader
snap-server: 1.0.0.0. Snap is a simple and fast web development framework and server written in Haskell. For more information or to download the latest version, you can visit the Snap project website at <http://snapframework.com/>. The Snap HTTP server is a high performance web server library written in Haskell. Together with the @snap-core@ library upon which it depends, it provides a clean and efficient Haskell programming interface to the HTTP protocol.
snap-templates: 1.0.0.0. This is the Scaffolding CLI for the official Snap Framework libraries. It includes: * The \"snap\" executable program for generating starter projects To get started, issue the following sequence of commands: @$ cabal install snap-templates $ mkdir myproject $ cd myproject $ snap init@ If you have trouble or any questions, see our FAQ page (<http://snapframework.com/faq>) or the documentation (<http://snapframework.com/docs>).
snap-testing: 0.2.0.0, 0.4.1.1, 0.6.0.0.
snaplet-postgresql-simple: 1.0.1.0. This snaplet contains support for using the Postgresql database with a Snap Framework application via the postgresql-simple package. It also includes an authentication backend.
snaplet-redis: 0.1.3.1, 0.1.3.3, 0.1.4. This package provides a snaplet which exposes interface to Redis in-memory key-value storage as implemented by Hedis library. Inline documentation contains usage examples.
snaplet-sqlite-simple: 0.4.6. This snaplet provides support for using the SQLite database with a Snap Framework application via the sqlite-simple package. It also includes an authentication backend. See <https://github.com/nurpax/snaplet-sqlite-simple/tree/master/example> for an example project that demonstrates the use of this snaplet. It implements a stand-alone application with a login screen that persists user information in a SQLite database and allows a logged in user to save comments. Querying and listing comments demonstrates how a user of snaplet-sqlite-simple might relate Snaplet.Auth based AuthUsers to his own tables.
snaplet-stripe: 0.3.0. This snaplet contains support for using the Stripe payment platform with a Snap Framework application.
sneakyterm: 0.1. `SneakyTerm` gives you 'MonadTerminal' which gives you two operations, 'tmRender' to render a list of tiles, and 'tmCharEvent' to wait for character input. A simple example: > main = do > let viewport = rectFromOriginAndDim (V2 0 0) (V2 80 25) > runTerminal viewport $ do > tmRender [Tile (V2 10 10) '@' (ColorPair Red Blue)] > _ <- tmCharEvent > return () This will render a red `@` at column 11, line 11, with blue background.
snowflake-core: 0.1.0.0, 0.1.0.1. Please see README.md
snowflake-server: 0.1.0.0. Please see README.md
so-daily: 0.1.0.0. Opens a browser and logins into the stackoverflow website every X minutes. An example of scheduling logins for each 12 hours of runtime: > ./so-daily --email example@domain.com --password test123 -repeat $((12*60)) This package is designed to work as a background process with a selenium server. Use the @verbose@ option to print runtime information to standard output. > so-daily - automatic scheduled SO login > > Usage: sodaily [-r|--repeat X] [-v|--verbose] (-e|--email ARG) > (-p|--password ARG) > Login daily to the stackoverflow website > > Available options: > > -h, --help Show this help text > -r, --repeat X Login in each X seconds > -v, --verbose Show more information while running > -e, --email ARG Email to use for login > -p, --password ARG Password to use for login
socket-activation: 0.1.0.0. a module for systemd socket activation. See <http://0pointer.de/blog/projects/socket-activation.html> and <http://www.freedesktop.org/software/systemd/man/systemd.socket.html> for more details.
socketio: 0.1.0.0. Socket.IO for Haskell folks. [Socket.IO] <http://socket.io/> [Protocol] <https://github.com/LearnBoost/socket.io-spec> @ {-# LANGUAGE OverloadedStrings #-} import Web.SocketIO \-\- listens to port 4000 main = server 4000 $ do     \-\- ping pong     on "ping" $ emit "pong" []     \-\- reply :: CallbackM [Text]     on "echo" $ reply >>= emit "pong"     \-\- do some IO     on "Kim Jong-Un" $ liftIO launchMissile @
sodaily: 0.1.0.0. Opens a browser and logins into the stackoverflow website every X minutes.
solga: 0.1.0.0. A library for easily specifying web APIs and implementing them in a type-safe way.
solga-swagger: 0.1.0.0. Swagger generation for Solga
sorting: 1.0.0. Utils for sorting.
spacefill: 0.1. Generators of Hilbert and Moore space-filling curves in configurable coordinate domains.
spanout: 0.1. A breakout clone written in netwire and gloss.
spoty: 0.1.0.0, 0.1.0.1, 0.1.0.2. Web API <https://developer.spotify.com/web-api/> wrapper powered by lens and pipes, allowing easy access to public endpoints. Does not have any external dependencies nor requirements regarding app registration. * Paging is handled transparently using pipes * All data types are navigated using lenses All public endpoints, with multi-get versions excluded, are implemented. > > :set -XOverloadedStrings > > :m +Control.Lens Utils.Spoty > > Just artist <- fetchOne (searchArtist "avicii") -- assume at least one match > > popular <- getArtistTop (view spotifyID artist) "SE" -- retrieve the most popular tracks in Sweden > > mapM_ (print . view name) popular -- print the corresponding names > "Hey Brother" > "Addicted To You" > "Wake Me Up" > ... Please read the README for details.
sqlite-simple: 0.4.3.1, 0.4.4.0, 0.4.5.0, 0.4.5.2. Mid-level SQLite client library, based on postgresql-simple. Main documentation: <docs/Database-SQLite-Simple.html Database.SQLite.Simple> For more info, browse to <http://github.com/nurpax/sqlite-simple> for examples & more information.
sqlite-simple-typed: 0.1.0.0. Simplifies Simple
sscript: 0.1.0.0. Please see README.md
ssv: 0.3. This modules provides conversion routines to and from "something-separated values", especially the infamous "comma separated value" (CSV) format. It attempts to adhere to the spirit and (mostly) to the letter of RFC 4180, which defines the 'text/csv' MIME type.
stack: 0.1.0.0. Please see the README.md for usage information, and the wiki on Github for more details. Also, note that the API for the library is not currently stable, and may change significantly, even between minor releases. It is currently only intended for use by the executable.
stackage-everything: 5.4. This meta-package depends on the entirety of Stackage. See README.md for further details.
standalone-derive-topdown: 0.0.0.1. For a very complex composited data type, you just need to write one deriving declaration instead of writing deriving for each of them. Please see the example in Readme file. You need to use GHC 7.10 or higher GHC version.
static-resources: 0.1.7. You need to add static resources to your web page. For production you want to decrease number of files. For development you need them separated. Support for distinct sets of JS, CSS and LESS files for different views.
statistics-hypergeometric-genvar: 0.1.0.0. Supplements the @Statistics.Distribution.Hypergeometric@ module from the excellent @statistics@ package. Implements the interfaces @ContGen@ and @DiscreteGen@ for @HypergeometricDistribution@. Provides it's own function @genVar@ generalised over @Integral@.
statistics-incremental: 0.1.0.0. incremental staistics folds
statsd-client: 0.3.0.0. Statsd UDP client
statvfs: 0.2. C FFI wrapper for POSIX statvfs and fstatvfs calls.
step-function: 0.1.0.0, 0.1.1.1. Step functions, staircase functions or piecewise constant functions. Implemented as a default value and a series of transitions. Supports merging two step functions using a supplied merging function.
stm: 2.4.3, 2.4.4, 2.4.4.1. A modular composable concurrency abstraction.
stm-data-collection: 0.1.0.0. Package provides implementation of different data structures, relying on STM (https:\/\/hackage.haskell.org\/package\/stm) for safe and flexible concurrency. There are several implemenations for each data structure. The reason is that the concrete one should be chosen depending on use-case. Description of cons and pros may be found in corresponding documentation. Some of the modules also provide parameterized constructors which must be imported separately and used with care.
stochastic: 0.1.0.0, 0.1.1.0. This package allows the user to perform monadic composition of probabilistic functions (i.e. functions that take values and return distributions over values). These functions can then be sampled from to generate datapoints.
stomp-queue: 0.0.5. The Stomp Protocol specifies message-oriented interoperability. Applications connect to a message broker to send (publish) or receive (subscribe) messages through queues. Interoperating applications do not know the location or internal structure of each other. They see only each other's interfaces, /i.e./ the messages published and subscribed through the broker. The Stomp Queue library provides a Stomp client, using abstractions like 'Connection', 'Transaction', 'Queue' and 'Message'. More information, examples and a test suite are available on <http://github.com/toschoo/mom>. The Stomp specification can be found at <http://stomp.github.com>. Release History: [0.0.5] Underline functions removed, with* functions: withWriter, withPair, new option for connection (ClientId), Headers for broker-specific options can be passed to connection, memory leaks solved. [0.0.3] New interface writeAdHoc [0.0.2] Minor corrections [0.0.1] Initial release
stratosphere: 0.1.0. EDSL for AWS CloudFormation
streaming-png: 0.1.0.0. Please see README.md
strict-identity: 0.1.0.0. strict Identity monad for writing strict performant code sanely
string-conversions: 0.3.0.1, 0.3.0.2, 0.3.0.3. Provides a simple type class for converting values of different string types into values of other string types.
stringprep: 1.0.0. Implements the "StringPrep" algorithm
strive: 0.1.0. A Haskell client for the <http://strava.github.io/api/ Strava V3 API>.
structural-traversal: 0.1.0.0. Please see README.md
subleq-toolchain: 0.1.8.4. Toolchain of subleq computer, which comprise of assembler and simulator.
subnet: 0.0.1.4. used for my programming work and putting it up for use by others
super-user-spark: 0.2.0.0. Configure your dotfile deployment with a DSL.
superdoc: 0.1.2.4. This package extends Cabal's documentation building capabilities. It extends the Haddock markup language with syntax for subscripts, superscripts, bold text, non-breaking spaces, and images. Moreover, it works around various bugs in Haddock's and HsColour's Unicode support, making it possible to use UTF8 encodings in both source code and documentation comments. This package is designed to work transparently. It provides a custom main function that package maintainers can use in their Setup.hs file. In most cases, this is as simple as setting the build-type to Custom, adding superdoc to the package dependencies, and putting the following two lines into Setup.hs: > import Distribution.Superdoc > main = superdocMain For more information on the available markup, see "Distribution.Superdoc".
supermonad: 0.1. 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. Additional information can be found in the <https://github.com/jbracker/supermonad README>.
swagger: 0.1, 0.2, 0.2.1, 0.2.2, 0.3.0. Implementation of Swagger specification version 1.2 as defined in <https://github.com/wordnik/swagger-spec/blob/master/versions/1.2.md>
symengine-hs: 0.1.0.0. Please see README.md
sync-mht: 0.3.2.0. A command line tool that can be used to incrementally synchronize a directory hierarchy with a second one. It is using a Merkle-Hash-Tree to compare the folders, such that the synchronization time and communication (round) complexity grows only logarithmically with the size of the directories (assuming the actual difference of the directories is small). The communication happens through standard streams between parent and child processes, which can easily be routed through remote command execution tools.
synt: 0.1.1. Calculate percentage of similarity between two pieces of code.
system-canonicalpath: 0.1.1.0, 0.1.2.0, 0.2.3.0, 0.3.0.0, 0.3.1.0. This library provides abstract data type named 'Filesystem.CanonicalPath.CanonicalPath' and some useful functions for working with it.
system-info: 0.1.0.2. An OS independent Haskell library for getting information about CPUs, memory, etc.
system-test: 0.1.2. System Test is a Haskell application which allows you to specify and run system tests of applications. Tests are defined in JSON files, whereby each test has a name, command, and expected output.
tagged-binary: 0.1.0.0, 0.1.2.0. Very minimal library providing tools for serializing and decoding data into 'ByteString' tagged with information about its type, inspired by Cloud Haskell and distributed-process. Intended for use by libraries and frameworks in distributed contexts, such as distributed computation between native servers and communication between native servers and ghcjs/various front-ends, for behavior similar to the polymorphic communication channels of Cloud Haskell and distributed-process; servers can send tagged data, and clients can choose to selectively accept, ignore or queue incoming messages depending on their types. For basic encoding, decoding and categorization, only 'Data.Binary.Tagged' should be necessary. 'Data.Binary.Tagged.Internal' is exported in case you need it. Quick example: > > let x = encodeTagged (1 :: Int) > > decodeTagged x :: Maybe Bool > Nothing > > decodeTagged x :: Maybe Int > Just 1
tagged-exception-core: 2.0.0.0, 2.1.0.0, 2.2.0.0. This library provides interface similar to /extensible-exceptions/. It introduces @Throws@ monad transformer that uses phantom type to tag code that may raise exception. Intention is to make exceptions explicit and to enforce exception handling.
tagged-transformer: 0.6.3, 0.6.4, 0.6.5. Provides newtype wrappers for phantom types to avoid unsafely passing dummy arguments
takusen-oracle: 0.9.0. Takusen-Oracle is a Oracle access library. Like HSQL and HDBC, we support arbitrary SQL statements (currently strings, extensible to anything that can be converted to a string). It is based on original Takusen library. It was just upgraded to support Oracle 12c instant client and GHC 7.6.3.
tasty-discover: 0.0.1. Automatically discover and run Tasty framework tests <http://github.com/lwm/tasty-discover>
tasty-html: 0.1, 0.2, 0.3, 0.4, 0.4.1. A tasty ingredient to output test results in HTML5.
tasty-integrate: 0.0.1, 1.0.0.
tasty-program: 1.0.1, 1.0.2. This package provides a function that extends <http://hackage.haskell.org/package/tasty tasty> testing framework with capability to test whether an external program runs successfully. This package is inspired by <http://hackage.haskell.org/package/test-framework-program test-framework-program> package by Adam Wick. tasty-program provides basic functionality of running a program with specified set of command line parameters, and optionally a working directory, and checking the exit code. Program's output and error streams are ignored.
tasty-tap: 0.0.1. A tasty ingredient to output test results in TAP 13 format.
telegram-api: 0.1.0.0, 0.1.0.1, 0.2.0.0, 0.2.1.0, 0.2.1.1, 0.3.0.0, 0.3.1.0, 0.4.0.0, 0.4.0.1, 0.4.1.0, 0.4.2.0, 0.4.3.0. High-level bindings to the Telegram Bot API
tellbot: 0.3.3.0. An IRC bot that can be used to create queuing message. It also offers a simple administration IRC bot interface.
template-haskell: 2.9.0.0, 2.10.0.0, 2.11.0.0. This package provides modules containing facilities for manipulating Haskell source code using Template Haskell. See <http://www.haskell.org/haskellwiki/Template_Haskell> for more information.
tempodb: 0.1.0.0. TempoDB is a time-series database as-a-service with a robust REST API. This module provides a simple API wrapper to perform all of the primary requests to TempoDB.
temporary-resourcet: 0.1.0.0. The functions for creating temporary files and directories in the base library are quite limited. The @unixutils@ package contains some good ones, but they aren't portable to Windows. This library repackages the Cabal implementations of its own temporary file and folder functions so that you can use them without linking against Cabal or depending on it being installed. This library provides the same functionality as the @temporary@ package, but uses @resourcet@ to provide automatic deletion without nesting @withTempFile@.
terntup: 0.0.1. a library for converting to and from (balanced) ternary
test: 0.
test-framework: 0.8.1.0. Allows tests such as QuickCheck properties and HUnit test cases to be assembled into test groups, run in parallel (but reported in deterministic order, to aid diff interpretation) and filtered and controlled by command line options. All of this comes with colored test output, progress reporting and test statistics output.
test-hackage-ags: 0.1.0.0. For testing how the Hackage package page will look (esp. the flags) via candidates system on Hackage.
testing-feat: 0.4.0.3. Feat (Functional Enumeration of Algebraic Types) provides enumerations as functions from natural numbers to values (similar to @toEnum@ but for any algebraic data type). This can be used for SmallCheck-style systematic testing, QuickCheck style random testing, and hybrids of the two. The enumerators are defined in a very boilerplate manner and there is a Template Haskell script for deriving the class instance for most types. "Test.Feat" contain a subset of the other modules that should be sufficient for most test usage. There are some small and large example in the tar ball. Builds with haskell-platform-2012-2.0.0 and with ghc-7.6.1.
testing-type-modifiers: 0.1.0.0, 0.1.0.1. Property based testing libraries such as QuickCheck tend to include type modifiers. Most of them are used to quantify over subsets of a type. For example a property on non-empty lists: @ prop_tail_length (NonEmpty xs) = length (tail xs) == length xs - 1 @ This library is intended to supply these modifiers to be used by testing libraries, in an effort to make properties more portable between testing frameworks. For every modifier it also provides an access function that converts to the underlying type, which enables point-free style properties as such: @ prop_tail_length2 = (> 0) . length . nonEmpty @
tex2txt: 0.1.0.0. tex2txt converts LaTeX files to linguistic coherent plain-text which could be used for many natural language processing and analysis tasks. The primary aim of the tool is to help NLP community to simplify building large databases of NLP-ready texts from LaTeX sources. The tool can also be used as a system component when input is LaTeX text.
text-show: 0.1.0.0. @text-show@ offers a complete drop-in replacement of the @Show@ typeclass, but for @Text@ instead of @String@. This package was created in the spirit of @<http://hackage.haskell.org/package/bytestring-show bytestring-show>@.
textPlot: 0.4. Graph plots of y(x), parametric (x(t),y(t)), and polar r(phi) functions with ASCII text.
textocat-api: 0.1.0.0. Unofficial Haskell SDK for Textocat API -- http://textocat.com Textocat is "catalyst of text analytics". It focuses on Russian texts, mainly news
textual: 0.1.0.0, 0.2.0.0. Exposes the Textual type class, for data that represent textual content Also, exposes a simple utility for conversion between instances, much like fromIntegral converts between Integral instances.
th-lift-instances: 0.1.8, 0.1.9, 0.1.10. Most data types in haskell platform do not have Lift instances. This package provides orphan instances for containers, text, bytestring and vector.
th-orphans: 0.8. Orphan instances for TH datatypes. In particular, instances for Ord and Lift, as well as a few missing Show / Eq. These instances used to live in haskell-src-meta, and that's where the version number started.
thorn: 0.1, 0.1.0.1, 0.1.0.2, 0.1.0.3, 0.2. Thorn generates * functors from various kinds of datatypes, regardless of arity or variances. * folds and unfolds from various kinds of recursive datatypes, including mutually recursive ones. A single function of Thorn will give you a lot. Just try it. The haddock is here. <http://kinokkory.github.io/Thorn/>
threadscope: 0.2.7. ThreadScope is a graphical viewer for thread profile information generated by the Glasgow Haskell compiler (GHC). The Threadscope program allows us to debug the parallel performance of Haskell programs. Using Threadscope we can check to see that work is well balanced across the available processors and spot performance issues relating to garbage collection or poor load balancing.
thrift: 0.9.2, 0.9.3. Haskell bindings for the Apache Thrift RPC system. Requires the use of the thrift code generator.
time-exts: 1.0.0, 1.0.1, 1.0.2, 1.1.0, 1.1.1, 1.1.2, 1.1.3, 2.0.0, 2.1.0. Haskell timestamps in various bit length and granularity.
time-patterns: 0.1.0.1, 0.1.0.2, 0.1.1.0, 0.1.2.0, 0.1.3.0, 0.1.3.1. This package contains a set of primitives and combinators for event patterns. Example: > >> import qualified Prelude as P > >> let sundays = every 2 sunday > >> let today = (YearMonthDay 2013 12 01)^.from gregorian > >> P.take 2 $ instancesFrom today sundays > [2013-12-08, 2013-12-22] See @Data.Time.Patterns@ for more examples.
time-series: 0.1.0.0. A package containing time series analysis prototyping. The analysis is for finding time-shifted correlations from multiple time series input data. In later phase, we might extend to do analysis of burst detection, but other analysis than for finding correlations are not considered yet.
timezone-olson-th: 0.1.0.0, 0.1.0.2. Template Haskell to load a TimeZoneSeries from an Olson file at compile time. For Example:
tinyMesh: 0.1.0.0. TinyMesh are modules build on CC11xx TI MCU transceivers that allow for automatic meshing, and remote sensor reading. Whole sensor network may be orchestrated by a single *gateway* machine that is best connected to internet in order to submit the data to the cloud. This library is aimed to allow programming such a gateway machine in Haskell, so that it may be Raspberry Pi, or a similar networked ARM device. *Current functionality of the module is limited to querying all the nodes within the mesh.*
tinylog: 0.8, 0.10.2, 0.10.3, 0.10.4, 0.10.5, 0.12.0, 0.12.1, 0.13.0, 0.14.0. Trivial logger on top of fast-logger.
titlecase: 0.1.0.0, 0.1.0.1, 0.1.0.2. Capitalize all English words except articles (a, an, the), coordinating conjunctions (for, and, nor, but, or, yet, so), and prepositions (unless they begin or end the title). The prepositions are taken from this list: <https://en.wikipedia.org/wiki/List_of_English_prepositions>.
toolshed: 0.15.0.1. An ill-defined collection of simple unrelated utilities used by other packages from <http://functionalley.eu>
topkata: 0.2.4. Guide a jumping ball through a maze.
toxcore: 0.0.1, 0.0.2. Haskell bindings to the C reference implementation of Tox. See <https://github.com/TokTok/toxcore>.
toysolver: 0.1.0, 0.2.0, 0.3.0. Toy-level implementation of some decision procedures
tracer: 0.1. Transformers for 'Functor', 'Applicative' and 'Monad' types that add tracing facilities for computation steps and applicative nesting. Simplifies print-based debugging.
travis: 0.1.0.0. A simple client implementation using Travis CI API.
trawl: 0.1.0.0. trawl is a human-friendly wrapper around ghc-pkg, for locating local documentation for Haskell packages and modules.
treemap: 1.20160814. A tree of Data.Map, which is like a 'Map' but whose key is now a 'NonEmpty' list of 'Map' keys (a 'Path') enabling the possibility to gather mapped values by 'Path' prefixes (inside a 'Node').
tsession: 0.1. The concept of this web transaction framework is influenced by sessions, transactions and software transactional memory. To web-developers it offers sessions with integrated transaction management that has an included server-side storage of key-value pairs. The transactions can be spanned over multiple web requests and only affect the database when a commit is instructed. Additionally, the sessions have access to the (not yet committed) key-value pairs and the status (e.g., the last requested page) of all other sessions that are active. As sessions have to be canceled after a given timeout, the framework has a garbage collector that safely cleans up the timed out sessions. The framework introduces a monad which encapsulates all the logic of the transactions and frees them of side effects. This is a concept known from the STM--monad and like in STM, the transactions cannot dead-lock each other. For more information check my master thesis: <http://stud.micheler.net/master.pdf>
tsession-happstack: 0.1. This is the integration of tsession to Happstack For more information check my master thesis: <http://stud.micheler.net/master.pdf>
tslib: 0.1.4.
tubes: 0.2.2.0, 0.2.2.2, 0.2.2.3, 1.0.0.0, 1.0.0.1. This package provides the @Tube@ monad transformer, allowing any monad computation to become a stream processing pipeline. A computation of type @Tube a b m r@ consumes values of type 'a' and produces values of type 'b'. @Tube@s are coroutines which can suspend computation to yield an intermediate value or continue execution by requesting an upstream value. Also provided are @Pump@s, the comonadic dual to @Tube@s. Examples are provided of how they can be used with @Tube@s but we have almost certainly only scratched the surface. Examples and more information may be found at <https://github.com/gatlin/tubes>. I seem to have trouble uploading packages where the documentation can be built correctly on Hackage. If I have (once again) messed this up, you can find Haddock documentation at <https://niltag.net/tubes>. I apologize for any inconvenience! This should compile on GHC 7.8, but the problem is that previous attempts at setting the versions properly rendered Hackage unable to generate documentation. Hopefully I have this fixed but any advice is welcome.
turingMachine: 0.1.1.1, 0.1.1.2, 0.1.2.0, 0.1.3.0. An implementation of Turing Machine and Automaton for language theory
twentefp-eventloop-graphics: 0.1.0.3. An eventloop based graphical IO system. It uses websockets as a way to communicate with IO devices; a browser in this case. This system is used in the Graphical submodule to be able to express graphical output using the eventloop system for a browser.
twentyseven: 0.0.0. Solve 3×3×3 Rubik's cubes in the fewest possible moves. Or, if you can't wait, get /close enough/ with the two-phase solver.
twitter-feed: 0.1.0.1. Fetches a user timeline from Twitter, and optionally linkifies the results using the Twitter entity API.
type-iso: 0.1.0.0. This package defines \"can be cast to\" relations between types: two types a and b are an instance of Injective if there's an injective function from a to b. If there is also an injective function from b to a, a and b are instances of Iso, meaning that one can convert back and forth losslessly (up to some appropriate notion of equality). The main purpose of this little package is to provide easy casting between the common string types (String, strict/lazy Text) and numeric types (Integers, Peano numbers), without having to look up the names of the various conversion functions all the time.
type-level-sets: 0.5, 0.7, 0.8.0.0. This package provides type-level sets (no duplicates, sorted to provide a normal form) via 'Set' and type-level finite maps via 'Map', with value-level counterparts. Described in the paper "Embedding effect systems in Haskell" by Dominic Orchard and Tomas Petricek <http://www.cl.cam.ac.uk/~dao29/publ/haskell14-effects.pdf> (Haskell Symposium, 2014). This version now uses Quicksort to normalise the representation. Here is a brief example for finite maps: @ import Data.Type.Map type instance Combine Int Int = Int instance Combinable Int Int where combine x y = x + y foo :: Map '["x" :-> Int, "z" :-> Bool, "w" :-> Int] foo = Ext (Var :: (Var "x")) 2 $ Ext (Var :: (Var "z")) True $ Ext (Var :: (Var "w")) 5 $ Empty bar :: Map '["y" :-> Int, "w" :-> Int] bar = Ext (Var :: (Var "y")) 3 $ Ext (Var :: (Var "w")) 1 $ Empty foobar = foo `union` bar @ The 'Map' type for 'foobar' here shows the normalised form (sorted with no duplicates). The type signatures is commented out as it can be infered. Running the example we get: @ > >>> foobar > w :-> 6, x :-> 2, y :-> 3, z :-> True @ Thus, we see that the values for \"w\" are added together. For sets, here is an example: @ import GHC.TypeLits import Data.Type.Set type instance Cmp (Natural n) (Natural m) = CmpNat n m data Natural (a :: Nat) where Z :: Natural 0 S :: Natural n -> Natural (n + 1) foo = asSet $ Ext (S Z) (Ext (S (S (S Z))) (Ext Z Empty)) bar = asSet $ Ext (S (S Z)) (Ext (S Z) (Ext (S Z) Empty)) foobar = foo `union` bar @ Note the types here are all inferred.
type-list: 0.0.0.0, 0.1.0.0. Operations on type-level lists and tuples, together with their curried versions.
typedquery: 0.1.0.0. Base package for parsing queries
tz: 0.0.0.1. This package has two main goals: * To distribute the standard time zone database in a cabal package, so that it can be used in Haskell programs uniformly on all platforms. * To provide a library that can read time zone info files (aka. Olson files), and does time zone conversions in a /pure/ and /efficient/ way. The current version ships the @2014b@ version of the time zone database. See: <http://www.iana.org/time-zones> for more info. The package is currently in a draft phase, I'm still experimenting with different ideas wrt. scope\/API\/implementation\/etc. All comments are welcome!
u2f: 0.1.0.0. Library useful for server-side U2F Registration and Signin flows.
uber: 0.1.0.0. Bindings for Uber API
uhttpc: 0.1.0.0, 0.1.1.0. @uhttpc@ contains a simple low-level and lightweight Haskell <https://tools.ietf.org/html/rfc2616 HTTP 1.1> library optimized for providing the bare minimum required for HTTP benchmarking purposes and allowing for time measurements of the individual phases of the HTTP transaction. This package also provides the command-line tool @uhttpc-bench@ as an usage example which mimics the popular <https://github.com/lighttpd/weighttp weighttp> HTTP benchmarking tool's CLI. WARNING: @uhttpc@ was originally developed for evaluating the new <http://haskell.cs.yale.edu/wp-content/uploads/2013/08/hask035-voellmy.pdf \"Mio\" parallel I/O manager> introduced with GHC 7.8 and provide a base-line for HTTP client libraries. However, this is not a fully RFC compliant HTTP client library and therefore ought not be used as a general purpose HTTP implementation; Use libraries such as <http://hackage.haskell.org/package/http-streams http-streams> instead which aim toward full RFC compliance as well as having good performance.
unagi-streams: 0.1.0.0, 0.1.1.0, 0.1.2. Io-streams chans implemented underneath with unagi-chans. This library is a straight port of the default io-streams chan implementation.
unbound: 0.5.0. Specify the binding structure of your data type with an expressive set of type combinators, and Unbound handles the rest! Automatically derives alpha-equivalence, free variable calculation, capture-avoiding substitution, and more. See "Unbound.LocallyNameless" to get started.
unbuildable: 0. This package can be used to express impossible build configurations
unicode-transforms: 0.2.0. Fast Unicode 8.0 normalization in Haskell (NFC, NFKC, NFD, NFKD).
uniform-io: 0.1.0.0, 0.1.1.0, 0.2.0.0, 1.0.0.0, 1.0.1.0, 1.1.1.0, 1.2.0.0. This library defines a typeclass for abstracting the differences between the several IO channels available. It also includes implementations for standard IO, files and network IO, and easy to use TLS wrapping of network data, with an extensible interface for user supplied instances. Currently there's no support for TLS certificate verification. That is planned to be added soon. Requires a '-threaded' compiler switch.
uniform-strings: 0.0.7. reduce complexity of Haskell by providing a set of uniformly named of conversion routines between String, Text, ByteString and urlEncoding with the most important text manipulation functions for string and text where the semantic is the same (tested with quickcheck).
unix: 2.7.2.0. This package gives you access to the set of operating system services standardised by <http://pubs.opengroup.org/onlinepubs/9699919799/ POSIX.1-2008> (or the IEEE Portable Operating System Interface for Computing Environments - IEEE Std. 1003.1). The package is not supported under Windows.
unjson: 0.14. Bidirectional JSON parsing and generation with automatic documentation support.
unlit: 0.1.0.0, 0.1.1.0, 0.3.2.0. Tool to convert literate code between styles or to code. Usage: > unlit > -f STYLE_NAME --from=STYLE_NAME Source style (all, bird, haskell, latex, markdown, tildefence, backtickfence) > -t STYLE_NAME --to=STYLE_NAME Target style (bird, latex, tildefence, backtickfence, code) > -i FILE --input=FILE Input file (optional) > -o FILE --output=FILE Output file (optional) > -l LANGUAGE --language=LANGUAGE Programming language (restrict fenced code blocks) > -h --help Show help > -v --version Show version
unordered-graphs: 0.1.0. Simple graph library allowing any Hashable instance to be a node type.
uo-stack: 0.1.1. This library implements a lazy stack structure that Only provides `insert` and `pop` functionality, and requres all elements in the stack to decend or ascend and to be unique.
uri-bytestring: 0.0.1, 0.1.1, 0.1.2. uri-bytestring aims to be an RFC3986 compliant URI parser that uses efficient ByteStrings for parsing and representing the URI data.
urlpath: 0.0.1, 0.0.2, 0.0.3, 0.0.4, 0.0.5, 0.0.6, 0.1, 0.1.0.1, 0.2. Simple URL DSL for Haskell. This library tries to make it easier for people to write Url strings, structurally. Packages like <https://hackage.haskell.org/package/yesod-routes Yesod Routes> do a wonderful job at implementing string-free routing and references, but sometimes we have to compromise. This tries to make that compromise less painful. Use bare combinators to render your strings (kinda useless): > expandRelative $ "foo.php" <?> ("key1","bar") <&> ("key2","baz") > > ↪ "foo.php?key1=bar&key2=baz" ... or use the MonadReader instance for a configurable host: > let path = runAbsoluteUrl $ url $ "foo.php" <?> ("key1","bar") <&> ("key2","baz") > path "example.com" > > ↪ "example.com/foo.php?key1=bar&key2=baz" @url@ puts the @UrlString@ in a MonadReader that we can use for applying our host. We use different monads for different deployment schemes (currently we have 3 - @RelativeUrl@, @GroundedUrl@, and @AbsoluteUrl@), which we can integrate in different libraries, like Lucid: > (runAbsoluteUrl $ renderTextT $ do > foo <- lift $ url $ "foo" <?> ("bar","baz") > script_ [src_ foo] "" ) > ) "example.com" > > ↪ "<script src=\"example.com/foo?bar=baz\"></script>" ... and in Scotty ... > main :: IO () > main = scottyT 3000 > rootConf > rootConf > run > > where > rootConf = flip runAbsoluteT "http://example.com" > > run :: ( MonadIO m > , MonadReader T.Text m > , Url T.Text m ) => > ScottyT LT.Text m () > run = get "/" $ do > path <- lift $ url $ "foo" <?> ("bar","baz") > text $ LT.fromStrict path > > λ> curl localhost:3000/ > ↪ "http://example.com/foo?bar=baz" Note that in the scotty example, we don't use one of our deployment schemes - this is because the @scottyT@ function expects it's underlying monad to be an instance of @MonadIO@, which we can only instantiate in our monad transformers. Please take mind - the string type underlying the Url rendering is generalized to @Data.String.IsString@ for convenient use with @-XOverloadedStrings@. However, due to that generality, we need to specify the monomorphic type (like @Data.Text.Text@ above).
uuid-aeson: 0.1.0.0. Instances of Aeson's ToJSON and FromJSON for UUIDs.
uxadt: 0.0.13.0, 0.0.16.0. A library that supports a universal, cross-platform embedded representation for algebraic data type (ADT) values.
uzbl-with-source: 0.1.0.0. Utility function for reading a source of loaded uzbl pages. It attemps to read the UZBL_SOCKET variable passed in by uzbl during runtime and extract source by probing it. The program ‘socat’ is a run-time dependency.
validated-literals: 0.1.0, 0.2.0. To disallow invalid input it is common to define (new)types with hidden data constructors. Forcing the user to go through a smart-constructor that enforces invariants and returns @Maybe ResultType@, preventing the construction of data with invalid values. However, it is __also__ common to want to include literal values of such types in source text. Things of textual literals for HTML, HTTP, etc. In such cases smart-constructors force us to handle potential conversion failures at runtime, or abusing functions like @fromJust@ to break away all the safety smart-constructors provide. All this despite the fact that we can statically know at compile time that the conversion will always succeed or always fails. This package provides a typeclasses for using TH to validate the correctness of provided literals at compile. This lets you define, e.g., @newtype Even = Even Integer@ and write: @ x :: Even x = $$(valid 38) @ This will check, at compile time, that the provided @Integer@ is, in fact, even and unwrap it from @Maybe@, avoiding the runtime check.
validation: 0.5.0. <<http://i.imgur.com/Ns5hntl.jpg>> Several data-types like Either but with differing properties and type-class instances. Library support is provided for those different representations, include `lens`-related functions for converting between each and abstracting over their similarities. * `AccValidation` The `AccValidation` data type is isomorphic to `Either`, but has an instance of `Applicative` that accumulates on the error side. That is to say, if two (or more) errors are encountered, they are appended using a `Semigroup` operation. As a consequence of this `Applicative` instance, there is no corresponding `Bind` or `Monad` instance. `AccValidation` is an example of, "An applicative functor that is not a monad." * `Validation` The `Validation` data type is isomorphic to `Either` and has a `Monad` instance that does the same as `Either`. The only difference to `Either` is the constructor names and surrounding library support. * `ValidationT` The `ValidationT` data type is the monad transformer for `Validation`. An instance of `MonadTrans` is provided for `(ValidationT err)`. Due to the arrangement of the `ValidationT` type constructor, which permits a `MonadTrans instance, there is no possible `Bifunctor` instance. Consequently, the `ValidationB` data type provides a `Bifunctor` instance (but not a `MonadTrans` instance). Library support is provided to exploit the isomorphism to `ValidationB`. Note that since `AccValidation` is not a monad, there is also no corresponding monad transformer for this data type. * `ValidationB` The `ValidationB` data type is similar to the monad transformer for `Validation` (`ValidationT`), however, due to the arrangement of the `ValidationB` type constructor, which permits a `Bifunctor` instance, there is no possible `MonadTrans` instance. Consequently, the `ValidationT` data type provides a `MonadTrans` instance (but not a `Bifunctor` instance). Library support is provided to exploit the isomorphism to `ValidationT`.
validations: 0.1.0.0, 0.1.0.1, 0.1.0.2. See <https://github.com/mavenraven/validations> for description and tutorial. Code used in the tutorial can be found in src\/Validations\/Tutorial.lhs.
vaultaire-common: 2.9.1. Defines a set of types, typeclasses and instances for Vaultaire, intended for use with Marquise and other Vaultaire related libraries and executables
vector: 0.10.9.2, 0.10.10.0, 0.10.11.0, 0.10.12.0, 0.10.12.1, 0.10.12.2, 0.10.12.3, 0.11.0.0. An efficient implementation of Int-indexed arrays (both mutable and immutable), with a powerful loop optimisation framework . It is structured as follows: ["Data.Vector"] Boxed vectors of arbitrary types. ["Data.Vector.Unboxed"] Unboxed vectors with an adaptive representation based on data type families. ["Data.Vector.Storable"] Unboxed vectors of 'Storable' types. ["Data.Vector.Primitive"] Unboxed vectors of primitive types as defined by the @primitive@ package. "Data.Vector.Unboxed" is more flexible at no performance cost. ["Data.Vector.Generic"] Generic interface to the vector types. There is also a (draft) tutorial on common uses of vector. * <http://haskell.org/haskellwiki/Numeric_Haskell:_A_Vector_Tutorial>
vector-algorithms: 0.6.0.1, 0.6.0.2, 0.6.0.3, 0.6.0.4, 0.7, 0.7.0.1. Efficient algorithms for vector arrays
vector-clock: 0.2.3. This package provides a ready to use implementation of the vector clock data-structures, which may be used to version messages and determine causality relations between them in a distributed system. See @Fundamentals of Distributed Computing: A Practical Tour of Vector Clock Systems@ by R. Baldoni and M. Raynal for an overview of vector clocks. See the README.md file for details.
vector-th-unbox: 0.2.1.4. A Template Haskell deriver for unboxed vectors, given a pair of coercion functions to and from some existing type with an Unbox instance. Refer to "Data.Vector.Unboxed.Deriving" for documentation and examples.
verbosity: 0.1.0.0, 0.2.0.0, 0.2.1.0, 0.2.2.0, 0.2.3.0. Simple enum that encodes application verbosity with various useful instances.
vinyl-utils: 0.0.0.0, 0.1.0.0. Operations on records parametrized with various kinds of functors.
vty: 5.0.0. vty is terminal GUI library in the niche of ncurses. It is intended to be easy to use, have no confusing corner cases, and good support for common terminal types. Included in the source distribution is a program test/interactive_terminal_test.hs that demonstrates the various features. Developers: See the "Graphics.Vty" module. Users: See the "Graphics.Vty.Config" module. If your terminal is not behaving as expected the results of the vty-interactive-terminal-test executable should be sent to the Vty maintainter to aid in debugging the issue. Notable infelicities: Assumes UTF-8 character encoding support by the terminal; Poor signal handling; Requires terminfo. Project is hosted on github.com: https:\/\/github.com\/coreyoconnor\/vty git clone git:\/\/github.com\/coreyoconnor\/vty.git © 2006-2007 Stefan O'Rear; BSD3 license. © Corey O'Connor; BSD3 license.
waddle: 0.1.0.0. Library for reading WAD files into Haskell types.
wai-cors: 0.1.0, 0.1.1, 0.1.2, 0.1.3, 0.1.4, 0.2, 0.2.1, 0.2.3, 0.2.4, 0.2.5. This package provides an implemenation of Cross-Origin resource sharing (CORS) for <http://hackage.haskell.org/package/wai Wai> that aims to be compliant with <http://www.w3.org/TR/cors>.
wai-devel: 0.0.0.1, 0.0.0.2, 0.0.0.3, 0.0.0.4. A development server for WAI applications.
wai-middleware-etag: 0.1.0.0. WAI middleware that attaches ETags to responses for static files if they exist. Caveats: If caching is turned on, the middleware caches calculated checksums aggressively in a synchronized hashmap; checksums are calculated only once, so changes on the file-system are not reflected until the server is restarted. This middleware only calculates ETag checksums for file smaller than 1MB, otherwise it attaches a last-modified tag to the response. [WAI] <http://hackage.haskell.org/package/wai>
wai-middleware-gunzip: 0.0.2. WAI middleware to transparently unzip request bodies.
wai-middleware-metrics: 0.2.0, 0.2.1. This WAI middleware counts the number of requests, the number of server errors (http status >= 500) and keeps a latency distribution. It can be added to any WAI-based webserver, such as Yesod, Scotty, Spock and Servant. The counters are EKG Counters from ekg-core. <https://ocharles.org.uk/blog/posts/2012-12-11-24-day-of-hackage-ekg.html>
wai-middleware-preprocessor: 0.2.0.0. WAI middleware that preprocesses and caches files (e.g.: for Fay, purescript, etc.)
wai-predicates: 0.1, 0.2, 0.2.1, 0.3, 0.3.1, 0.3.2, 0.4, 0.5, 0.6, 0.7, 0.8, 0.8.1, 0.8.2, 0.8.3, 0.8.4, 0.8.5, 0.8.6, 0.9.0. Evaluate predicate functions against WAI requests and receive metadata in addition to a success/failure indicator. Predicates can be combined using logical connectives and the metadata are passed on accordingly. <http://hackage.haskell.org/package/wai-routing wai-routing> extends the functionality of @wai-predicates@ with additional predicates and predicated request routing.
wai-route: 0.1.0, 0.1.1, 0.1.2, 0.2, 0.3.1, 0.3.1.1. Simple routing for applications using the WAI, based on an efficient tree structure. Routes are defined as string literals and path segments prefixed with a ':' indicate captures. A sample is available at: <https://github.com/romanb/wai-route/blob/master/sample/Main.hs>.
wai-routing: 0.1, 0.2, 0.3, 0.3.1, 0.4, 0.4.1, 0.5, 0.5.1, 0.5.2, 0.5.3, 0.6, 0.7, 0.8, 0.9, 0.9.1, 0.10, 0.10.1, 0.10.2, 0.11, 0.11.1, 0.12, 0.12.1, 0.12.2, 0.12.3, 0.13.0. Enables the declaration of \"routes\" which handle requests to a specific URL. The set of possible handlers can be restricted by \"predicates\", which operate on WAI requests and have to be true or else the handler will not be called. Example: >import Data.ByteString (ByteString) >import Data.Text (Text) >import Network.Wai >import Network.Wai.Predicate >import Network.Wai.Routing >import Network.Wai.Handler.Warp > >main :: IO () >main = run 8080 (route (prepare start)) > >start :: Monad m => Routes a m () >start = do > get "/user/:name" (continue fetchUser) $ > capture "name" > > get "/user/find" (continue findUser) $ > query "byName" ||| query "byId" > > delete "/user/:name" rmUser $ > capture "name" .&. opt (cookie "foo") > >fetchUser :: Monad m => Text -> m Response >fetchUser name = ... > >findUser :: Monad m => Either ByteString Word64 -> m Response >findUser (Left name) = ... >findUser (Right ident) = ... > >rmUser :: Monad m => Text ::: Maybe Int -> Continue m -> m ResponseReceived >rmUser (name ::: foo) k = k $ ...
wai-session-postgresql: 0.2.0.0. Provides a PostgreSQL backed session store for the Network.Wai.Session interface.
watchit: 0.1.0.0. Watch a directory and run a command whenever a file changes.
web-browser-in-haskell: 1.0. The package is my first attempt to build a WEB BROWSER by using webkit. Its a multitab web browser which doesn't store any history but provides previous and next tab facility. The following links is to my blog article containing some screenshots of this browser including steps to install adobe flash player to this web browser. Link : "http://ilovehaskell.blogspot.in/2014/05/web-browser-in-haskell.html"
webapi: 0.2.2.0. WAI based library for web api
webapp: 0.0.1, 0.1.0, 0.1.1, 0.1.2, 0.2.0. See README.md
webcloud: 0.1.0.1. Automatically generate a web interface for your existing optparse-applicative command line applications.
webpage: 0.0.1, 0.0.2, 0.0.3. This is a general organization scheme for web pages, implemented for Lucid, and adapted for Blaze-html. It's as easy as 1-2-3: > import Web.Page.Lucid > > λ> renderText $ template def "some content" > > ↪ "<!DOCTYPE HTML><html><head><title></title><link href > rel="icon"></head><body>some content</body></html>" overload the particular areas with record syntax and stuff: > λ> let page = WebPage > "foo" > mempty > mempty > mempty > mempty > mempty > mempty > (script_ [src_ "jquery.js"] "") > > > λ> template page "some content" > > ↪ "<!DOCTYPE HTML><html><head><title>foo</title> > </head><body>some content<script > src=\"jquery.js\"></script></body></html>"
webrtc-vad: 0.1.0.0, 0.1.0.3. A simple library wrapping WebRTC's voice activity detection engine.
wheb-mongo: 0.0.2.0. Wheb plugin for MongoDB. * Implements SessionBackend and AuthBackend instances using MongoDB and Wheb. * Creates simple interface for arbitrary MongoDB actions using <http://hackage.haskell.org/package/Wheb Wheb> * Creates simple interface for arbitrary MongoDB actions using <http://hackage.haskell.org/package/mongoDB mongoDB> For a complete example, see the examples folder at <https://github.com/hansonkd/Wheb-Framework/tree/master/examples github> You can override the collection names for the Auth and Session documents by using 'addSetting' and setting keys for \"session-collection\" and \"auth-collection\" > opts <- generateOptions $ do > addSetting "session-collection" "my-collection" Reimplimentation of official example below. Use with language extensions /OvererloadedStrings/ & /ExtendedDefaultRules/. > import qualified Data.Text.Lazy as T > > import Web.Wheb > import Web.Wheb.Plugins.Mongo > > data MyApp = MyApp MongoContainer > data MyRequestState = MyRequestState > > instance MongoApp MyApp where > getMongoContainer (MyApp mc) = mc > > homePage :: WhebHandler MyApp MyRequestState > homePage = do > teams <- runAction $ rest =<< find (select [] "team") > text $ T.intercalate " | " $ map spack teams > > main :: IO () > main = do > opts <- generateOptions $ do > addGET "." rootPat $ homePage > mongo <- initMongo "127.0.0.1:27017" "master" > return (MyApp mongo, MyRequestState) > > runRawHandler opts $ do > runAction $ do > delete (select [] "team") > insertMany "team" [ > ["name" =: "Yankees", "home" =: ["city" =: "New York", "state" =: "NY"], "league" =: "American"], > ["name" =: "Mets", "home" =: ["city" =: "New York", "state" =: "NY"], "league" =: "National"], > ["name" =: "Phillies", "home" =: ["city" =: "Philadelphia", "state" =: "PA"], "league" =: "National"], > ["name" =: "Red Sox", "home" =: ["city" =: "Boston", "state" =: "MA"], "league" =: "American"] ] > > runWhebServer opts
wheb-strapped: 0.0.1.0. Implements basic functionality for: * <http://hackage.haskell.org/package/StrappedTemplates StrappedTemplates> * <http://hackage.haskell.org/package/Wheb Wheb> /In action:/ Use with language extensions /OverloadedStrings/, /FlexibleInstances/, /MultiParamTypeClasses/ > import Control.Monad.Except > > import Web.Wheb > import Web.Wheb.Plugins.Strapped > import Text.Strapped > > type MyApp = WhebT MyGlobalCtx () IO > > data MyGlobalCtx = MyGlobalCtx (StrappedContainer MyApp) > > instance StrappedApp MyGlobalCtx MyApp where > getStrappedContainer (MyGlobalCtx g) = g > > main :: IO () > main = do > opts <- generateOptions $ do > sc <- initStrapped "examples/resources" ".html" > addGET "." rootPat $ renderTemplate "index.html" (emptyBucket) > return (MyGlobalCtx sc, ()) > runWhebServer opts
whois: 1.0.0, 1.1.0. Provides a simple client to return WHOIS information about IP addresses or hostnames.
wordpass: 0.2.0.0, 0.3.0.0, 0.4.0.0. This script reads dict word lists and generates word-based passwords. Not unlike <http://xkcd.com/936/ Xkcd>. Program also prints how many words have been read, and indicates estimated password space size in bits. Using just four words from default English dictionary of ~50k words will give approximately 90 bits of entropy. Lucky speakers of languages with rich flexion like Polish (over 3 million words) can easily up this to over 110 bits of entropy.
workflow-osx: 0.0.0, 0.0.1. a \"Desktop Workflow\" monad with Objective-C bindings. includes bindings to: * press keys with modifiers * get/set the clipboard * launch/focus applications * get the name of the current application * open URLs for example: > -- | cut the currently highlighted region > cut :: (MonadWorkflow m) => m String > cut = do > sendKeyChord [CommandModifier] XKey > delay 250 > getClipboard > -- | transform the currently highlighted region, via the clipboard > transformClipboard :: (MonadWorkflow m) => (String -> String) -> m () > transformClipboard f = do > contents <- cut > setClipboard (f contents) > sendKeyChord [CommandModifier] VKey see @Workflow.OSX@ for several more examples (if hackage won't build the docs, see them at <http://sboosali.github.io/documentation/workflow-osx/index.html>) (this package is on hackage for convenience, but it's still a prerelease)
world: 0.
x86-64bit: 0.1. The primary goal of x86-64bit is to provide a lightweight assembler for machine generated 64 bit x86 assembly instructions. Features: * The size of operands are statically checked. For example, exchanging @rax@ with @eax@ raises a compile time error rather than a code-generation time error. * Immediate values are automatically converted to smaller size if possible. * De Bruijn indices are used instead of named labels * Quickcheck tests: You can quickcheck your x86 processor! Please report failures, there is a higher chance that the error is this library rather than in your processor.
xdot: 0.2.4. Parse Graphviz xdot files and interactively view them using GTK and Cairo. Currently not all xdot features are supported. Nodes and edges can be highlighted by hovering them and clicked. For an example of using this library try the accompanying @Demo.hs@ with the dot-files in @dot-examples/@. This library was originally written as part of ghc-vis, but is now a seperate project, in case anyone else may have a use for it.
xhb: 0.5.2014.4.10, 0.6.2014.4.22. Provides low-level bindings to the X11 protocol. Similar to XCB - the X C Bindings. This library is based on version 1.6 of the xcb-proto package. See http:\/\/xcb.freedesktop.org\/XmlXcb\/ and http:\/\/xcb.freedesktop.org\/dist\/ .
xml-html-conduit-lens: 0.1.0.0, 0.1.0.1, 0.2.0.0, 0.3.0.0, 0.3.1.0. Optics for xml-conduit and html-conduit
xmlhtml: 0.2.3.5. Contains renderers and parsers for both XML and HTML 5 document fragments, which share data structures so that it's easy to work with both. Document fragments are bits of documents, which are not constrained by some of the high-level structure rules (in particular, they may contain more than one root element). Note that this is not a compliant HTML 5 parser. Rather, it is a parser for HTML 5 compliant documents. It does not implement the HTML 5 parsing algorithm, and should generally be expected to perform correctly only on documents that you trust to conform to HTML 5. This is not a suitable library for implementing web crawlers or other software that will be exposed to documents from outside sources. The result is also not the HTML 5 node structure, but rather something closer to the physical structure. For example, omitted start tags are not inserted (and so, their corresponding end tags must also be omitted).
xmltv: 0.0.1. A program for showing whats on tv in the terminal using xmltv. Comes with a lib and a program to fetch and prettyprint the info.
xmobar: 0.21, 0.22, 0.22.1, 0.23.1, 0.24.1, 0.24.2. Xmobar is a minimalistic text based status bar. Inspired by the Ion3 status bar, it supports similar features, like dynamic color management, output templates, and extensibility through plugins.
xmonad-entryhelper: 0.1.0.0. xmonad-entryhelper makes your compiled XMonad config a standalone binary. It simulates the XMonad's argument handling and supports customized compliation. Please check <https://github.com/Javran/xmonad-entryhelper/blob/master/README.md README> for details.
xmonad-utils: 0.1.3.3. A small collection of X utilities useful when running XMonad. It includes: * hxsel, which returns the text currently in the X selection; * hslock, a simple X screen lock; * hmanage: an utility to toggle the override-redirect property of any window; * and hhp, a simple utility to hide the pointer, similar to unclutter.
xmpipe: 0.0.0.0. This package includes XMPP libraries. Now this contains only core (RFC 6120). This package needs more improvement yet. It has following features. C2S * TLS: use package <https://hackage.haskell.org/package/peyotls> (sample programs are coming soon) * SASL: PLAIN, DIGEST-MD5, SCRAM-SHA-1, EXTERNAL (XEP-0178) S2S * TLS: use package <https://hackage.haskell.org/package/peyotls> (sample programs are comming soon) * SASL: EXTERNAL (XEP-0178) It does not have following features yet. S2S * DIALBACK (XEP-0220) Example programs Client examples/simpleClient.hs > % runhaskell simpleClient.hs yoshikuni@localhost/im password yoshio@localhost > Hello, my name is Yoshikuni! > yoshio@localhost: Hi, I'm Yoshio. > yoshio@localhost: I am busy. > Good-bye! > /quit extensions * OverloadedStrings * PackageImports replace * &#123; to '{' * &#125; to '}' > import Prelude hiding (filter) > > import Control.Applicative > import "monads-tf" Control.Monad.State > import "monads-tf" Control.Monad.Writer > import Control.Concurrent hiding (yield) > import Data.Maybe > import Data.Pipe > import Data.Pipe.Flow > import Data.Pipe.ByteString > import System.IO > import System.Environment > import Text.XML.Pipe > import Network > import Network.Sasl > import Network.XMPiPe.Core.C2S.Client > > import qualified Data.ByteString as BS > import qualified Data.ByteString.Char8 as BSC > > mechanisms :: [BS.ByteString] > mechanisms = ["SCRAM-SHA-1", "DIGEST-MD5", "PLAIN"] > > data St = St [(BS.ByteString, BS.ByteString)] > instance SaslState St where getSaslState (St ss) = ss; putSaslState ss _ = St ss > > main :: IO () > main = do > (me_ : pw : you_ : _) <- map BSC.pack <$> getArgs > let me@(Jid un d (Just rsc)) = toJid me_; you = toJid you_ > ss = St [ > ("username", un), ("authcid", un), ("password", pw), > ("cnonce", "00DEADBEEF00") ] > h <- connectTo (BSC.unpack d) $ PortNumber 5222 > void . (`evalStateT` ss) . runPipe $ > fromHandle h =$= sasl d mechanisms =$= toHandle h > (Just ns, _fts) <- runWriterT . runPipe $ > fromHandle h =$= bind d rsc =@= toHandle h > void . forkIO . void . runPipe $ fromHandle h =$= input ns > =$= convert fromMessage =$= filter isJust =$= convert fromJust > =$= toHandleLn stdout > void . (`runStateT` 0) . runPipe $ do > yield (presence me) =$= output =$= toHandle h > fromHandleLn stdin =$= before (== "/quit") > =$= mkMessage you =$= output =$= toHandle h > yield End =$= output =$= toHandle h > > presence :: Jid -> Mpi > presence me = Presence > (tagsNull { tagFrom = Just me }) [XmlNode (nullQ "presence") [] [] []] > > mkMessage :: Jid -> Pipe BS.ByteString Mpi (StateT Int IO) () > mkMessage you = (await >>=) . maybe (return ()) $ \m -> do > n <- get; modify succ > yield $ toM n m > mkMessage you > where toM n msg = Message (tagsType "chat") { > tagId = Just . BSC.pack . ("msg_" ++) $ show n, > tagTo = Just you } > [XmlNode (nullQ "body") [] [] [XmlCharData msg]] > > fromMessage :: Mpi -> Maybe BS.ByteString > fromMessage (Message ts [XmlNode _ [] [] [XmlCharData m]]) > | Just (Jid n d _) <- tagFrom ts = Just $ BS.concat [n, "@", d, ": ", m] > fromMessage _ = Nothing Server examples/simpleServer.hs This simple server can process only chat between same domain (localhost) users. Because this code use only C2S modules. You can implement S2S connection by S2S modules. But now this package contain only EXTERNAL authentification. This package is not contain DIALBACK yet. S2S examples which use EXTERNAL are comming soon. extensions * OverloadedStrings * PackageImports replace * &#123; to '{' * &#125; to '}' > import Control.Applicative > import Control.Arrow > import Control.Monad > import "monads-tf" Control.Monad.State > import "monads-tf" Control.Monad.Error > import Control.Concurrent hiding (yield) > import Control.Concurrent.STM > import Data.Pipe > import Data.Pipe.ByteString > import Data.Pipe.TChan > import Network > import Network.Sasl > import Network.XMPiPe.Core.C2S.Server > > import qualified Data.ByteString as BS > import qualified Network.Sasl.DigestMd5.Server as DM5 > import qualified Network.Sasl.ScramSha1.Server as SS1 > > main :: IO () > main = do > userlist <- atomically $ newTVar [] > soc <- listenOn $ PortNumber 5222 > forever $ accept soc >>= \(h, _, _) -> forkIO $ do > c <- atomically newTChan > (Just ns, st) <- (`runStateT` initXSt) . runPipe $ do > fromHandle h =$= sasl "localhost" retrieves =$= toHandle h > fromHandle h =$= bind "localhost" [] =@= toHandle h > let u = user st; sl = selector userlist > atomically $ modifyTVar userlist ((u, c) :) > void . forkIO . runPipe_ $ fromTChan c =$= output =$= toHandle h > runPipe_ $ fromHandle h =$= input ns =$= select u =$= toTChansM sl > > selector :: TVar [(Jid, TChan Mpi)] -> IO [(Jid -> Bool, TChan Mpi)] > selector ul = map (first eq) <$> atomically (readTVar ul) > where > eq (Jid u d _) (Jid v e Nothing) = u == v && d == e > eq j k = j == k > > select :: Monad m => Jid -> Pipe Mpi (Jid, Mpi) m () > select f = (await >>=) . maybe (return ()) $ \mpi -> case mpi of > End -> yield (f, End) > Message tgs@(Tags { tagTo = Just to }) b -> > yield (to, Message tgs { tagFrom = Just f } b) >> select f > _ -> select f > > initXSt :: XSt > initXSt = XSt { > user = Jid "" "localhost" Nothing, rands = repeat "00DEADBEEF00", > sSt = [ ("realm", "localhost"), ("qop", "auth"), ("charset", "utf-8"), > ("algorithm", "md5-sess") ] } > > retrieves :: ( > MonadState m, SaslState (StateType m), > MonadError m, SaslError (ErrorType m) ) => [Retrieve m] > retrieves = [RTPlain retrievePln, RTDigestMd5 retrieveDM5, RTScramSha1 retrieveSS1] > > retrievePln :: ( > MonadState m, SaslState (StateType m), > MonadError m, SaslError (ErrorType m) ) => > BS.ByteString -> BS.ByteString -> BS.ByteString -> m () > retrievePln "" "yoshikuni" "password" = return () > retrievePln "" "yoshio" "password" = return () > retrievePln _ _ _ = throwError $ fromSaslError NotAuthorized "auth failure" > > retrieveDM5 :: ( > MonadState m, SaslState (StateType m), > MonadError m, SaslError (ErrorType m) ) => BS.ByteString -> m BS.ByteString > retrieveDM5 "yoshikuni" = return $ DM5.mkStored "yoshikuni" "localhost" "password" > retrieveDM5 "yoshio" = return $ DM5.mkStored "yoshio" "localhost" "password" > retrieveDM5 _ = throwError $ fromSaslError NotAuthorized "auth failure" > > retrieveSS1 :: ( > MonadState m, SaslState (StateType m), > MonadError m, SaslError (ErrorType m) ) => BS.ByteString -> > m (BS.ByteString, BS.ByteString, BS.ByteString, Int) > retrieveSS1 "yoshikuni" = return (slt, stk, svk, i) > where slt = "pepper"; i = 4492; (stk, svk) = SS1.salt "password" slt i > retrieveSS1 "yoshio" = return (slt, stk, svk, i) > where slt = "sugar"; i = 4492; (stk, svk) = SS1.salt "password" slt i > retrieveSS1 _ = throwError $ fromSaslError NotAuthorized "auth failure" > > type Pairs a = [(a, a)] > data XSt = XSt { user :: Jid, rands :: [BS.ByteString], sSt :: Pairs BS.ByteString } > > instance XmppState XSt where > getXmppState xs = (user xs, rands xs) > putXmppState (usr, rl) xs = xs { user = usr, rands = rl } > > instance SaslState XSt where > getSaslState XSt { user = Jid n _ _, rands = nnc : _, sSt = ss } = > ("username", n) : ("nonce", nnc) : ("snonce", nnc) : ss > getSaslState _ = error "XSt.getSaslState: null random list" > putSaslState ss xs@XSt { user = Jid _ d r, rands = _ : rs } = > xs { user = Jid n d r, rands = rs, sSt = ss } > where Just n = lookup "username" ss > putSaslState _ _ = error "XSt.getSaslState: null random list"
yabi: 0.1.0.0. Yet Another Brainfuck Interpreter
yampa-canvas: 0.2.
yampa2048: 0.1.0.0. A simple game clone of a popular 2048 game using Yampa FRP library and Gloss for graphics. Use the arrow keys to slide the rows or columns of the board and try to survive for as long as possible. When there is no more move possible you will be presented with a game over message for 5 seconds and the game will be restarted after that.
yate: 0.1.0.0. Agnostic pure template engine
yesod-angular: 0.1.0.0, 0.1.0.1. Yesod Angular JS integration. This module is based on Michael Snoyman's original work in the <https://github.com/snoyberg/yesod-js> repository.
yesod-auth-bcrypt: 0.1.0. BCrypt salted and hashed passwords in a database as auth for yesod
yesod-auth-ldap-native: 0.1.0.0. This package provides an LDAP authentication plugin for Yesod.
yesod-content-pdf: 0.1.0.0, 0.1.0.1. Please see README.md
yesod-form-json: 0.0.1. Extension for Yesod web framework to handle JSON requests as applicative forms
yesod-pnotify: 0.4.4.0. Yet another getMessage/setMessage using pnotify jquery plugins
yesod-purescript: 0.0.4.1, 0.0.4.2. PureScript is an awesome statically typed language that compiles to JS and runs in your browser, and this module makes it easier to use PureScript in Yesod.
yesod-session-redis: 0.1.0.
yesod-tls: 1.4.0. This package makes possible to build Yesod web applications that provide SSL support.
yesod-transloadit: 0.1.0.0, 0.2.1.0. Drop in Transloadit capabilites for Yesod web apps
yet-another-logger: 0.0.1, 0.1, 0.1.1, 0.1.1.1, 0.2, 0.2.1, 0.2.2, 0.2.3, 0.2.3.1, 0.3.0. A logging framework written with flexibility and performance in mind. = Quick Start > import System.Logger > > main ∷ IO () > main = withConsoleLogger Info $ do > logg Info "moin" > withLabel ("function", "f") f > logg Warn "tschüss" > where > f = withLevel Debug $ do > logg Debug "debug f" = Description /This Version is yet a preview/ The logging system consists of four main parts: 1. The logging front-end are those types and functions that are used to produce log messages in the code. This includes the 'LogLevel' type, the 'LogPolicy' type, the 'LogLabel' and 'LogScope' types, the 'LogFunction' type, and the 'MonadLog' type class. 2. The abstract 'LoggerCtx' is the context through which the 'LogFunction' delivers log messages to the logger back-end. 3. The formatter is a function for serializing log messages. 4. The logger back-end is a callback that is invoked by 'Logger' on each log messages. The logger back-end applies the formatting function and delivers the log messages to some sink. The framework allows to combine this components in a modular way. The front-end types, the 'Logger', and the back-end callback are represented by types or type classes. The formatter exists only as a concept in the implementation of back-ends. These types and concepts together form the abstract logger interface that is defined in the module "System.Logger.Types". The package also provides a concrete Logger that implements these components in the module "System.Logger.Logger" and "System.Logger.Backend.Handle"
yi-language: 0.1.0.8. Collection of language-related Yi libraries: lexers, scanners…
yi-monokai: 0.1.0.0.
yi-solarized: 0.1.0. Solarized colour theme for Yi. Check source for yi.hs usage.
yi-spolsky: 0.1. Spolsky colour theme for Yi. Check source for yi.hs usage.
yoctoparsec: 0.1.0.0. A monadic parsing library making use of the free monad transformer. All instances are provided by the FreeT monad.
your-project: 0.1.0.0. Making haskell library demo
yql: 0.0.0. A YQL engine that provides a Haskell backbone library for the YQL specification, and a Javascript host environment to execute Open Data Tables.
zalgo: 0.1.0.0. A few efficient list-processing functions using the Z-function, which is defined as: > (z xs) !! i is the length of the largest proper substring of @xs@ ending at position @i@, such that it equals the beginning of @xs@. For example: > .-----. .-----. > a b a c a b a a a b a b a c d > 0 0 1 0 1 2 3 1 1 2 3 2 3 4 0 > ^ The marked substrings are equal, hence the value at the marked location is their length, 4.
zasni-gerna: 0.0.1. lojban zasni gerna parser
zendesk-api: 0.1.0.0. This is a library for accessing zendesk api using haskell bindings.
zeromq3-haskell: 0.2.5, 0.5.1, 0.5.2. The 0MQ lightweight messaging kernel is a library which extends the standard socket interfaces with features traditionally provided by specialised messaging middleware products. 0MQ sockets provide an abstraction of asynchronous message queues, multiple messaging patterns, message filtering (subscriptions), seamless access to multiple transport protocols and more. This library provides the Haskell language binding to 0MQ >= 3.2.2
zeromq4-haskell: 0.1, 0.2, 0.2.1, 0.3, 0.3.1, 0.3.2, 0.4, 0.4.1, 0.5, 0.5.1, 0.6, 0.6.1, 0.6.2, 0.6.3, 0.6.4, 0.6.5. The 0MQ lightweight messaging kernel is a library which extends the standard socket interfaces with features traditionally provided by specialised messaging middleware products. 0MQ sockets provide an abstraction of asynchronous message queues, multiple messaging patterns, message filtering (subscriptions), seamless access to multiple transport protocols and more. This library provides the Haskell language binding to 0MQ >= 4.x
zim-parser: 0.1.0.0. zim-parser is a library to read and parse ZIM (http://openzim.org) files. ZiM files contain offline web content (eg. Wikipedia) which can be browsed locally without an Internet connection.
zmidi-core: 0.7.0, 0.8.0, 0.8.1. Minimalist library to read and write MIDI files, with dependencies only on ByteString, Containers and Data.Binary. Changelog: v0.8.0 to v0.8.1: * Fixed error with missing CPP directive in ZMidi.Core.Pretty. v0.7.0 to v0.8.0: * Updated to compile without errors with GHC 7.10. v0.6.0 to v0.7.0: * Changed @ChannelPrefix@ constructor to have a single argument - channel number (previously it stored a constant tag 0x01 as well as channel number). * Added @SysExCont@ and @SysExEscape@ constructors to the @MidiSysExEvent@ data type. * Added new pretty printers - @Csv@ based on @midicsv@ and @Ascii@ based on the ASCII MIDI representation in the book Beyond Midi (the zmidi ASCII representation is simplified). The demo application @MidiPrint@ now allows choice of pretty printer. * @printMidiHeader@ and @printMidiTrack@ from @Pretty@ changed to MidiFiles as arguments, @printMidi@ has now become @putMidi@. v0.5.0 to v0.6.0: * Extended the parser and changed the syntax tree to interpret MIDI Running Status. * Added a module @ZMidi.Core.Canonical@ to translate MidiFiles to a canonical form where any shorthand NoteOff introduced by Running Status is expanded to regular NoteOn and NoteOff events (with Running Status set, MidiFiles can signal NoteOff events as another NoteOn with 0 channel velocity). * Added a hack to the pretty printer to stop printing ASCII chars greater than 164 causing an error when printing to stdout. For older changes see - CHANGES file.
zmidi-score: 0.3.0.0. Representing MIDI data as a simple score using the zmidi-core library.
zoom-refs: 0.0.0.0. Zoom (a'la lens zoom for State) for TVars, IORefs, and STRefs. TVars and STRef additionaly can be paired to form composite references. Multi-refs that use Traversals instead of Lenses are also available.