abstract-deque
- Ebuilds: 1, Testing: 0.3-r1 Description:
An abstract interface to highly-parameterizable queues/deques.
Background: There exists a feature space for queues that extends between:
* simple, single-ended, non-concurrent, bounded queues
* double-ended, threadsafe, growable queues
... with important points inbetween (such as
the queues used for work-stealing).
This package includes an interface for Deques that allows the
programmer to use a single API for all of the above, while using the
type-system to select an efficient implementation given the
requirements (using type families).
This package also includes a simple reference implementation based
on 'IORef' and "Data.Sequence".
Homepage:https://github.com/rrnewton/haskell-lockfree/wiki License: BSD
ac-ppm
- Ebuilds: 1, Testing: 1.1.1 Description:
This package is written in 100% Haskell and enables you to
write PPM (\"Portable Pixel Map\") images in human-readable
text format as well as the more efficient binary format.
It uses the ByteString library for maximum efficiency.
For those that don't know, PPM is an image file format
which is trivially simple, but therefore horribly inefficient.
None the less, many programs can read PPM files, so this
package represents an easy way to write Haskell code that
generates images, without having to depend on any external
C code.
Homepage:https://hackage.haskell.org/package/AC-PPM License: BSD
ac-vector
- Ebuilds: 1, Testing: 2.3.2 Description:
This Haskell library implements several small vectors types
with @Double@ fields, with seperate types for each size of
vector, and a type class for handling vectors generally.
(Note that although this package is listed in the \"graphics\"
category, the package itself has no graphics facilities. It
just contains data structures that are useful for graphics
work.)
Changes:
* Fixed a stupid bug in @union@. Until now, the function could
sometimes return gibberish answers. Hopefully this is now fixed.
Homepage:https://hackage.haskell.org/package/AC-Vector License: BSD
aeson-casing
- Ebuilds: 1, Testing: 0.2.0.0 Description:
Tools to change the formatting of field names in Aeson
instances. This includes CamelCasing, Pascal Casing and
Snake Casing.
Homepage:https://hackage.haskell.org/package/aeson-casing License: MIT
aeson-qq
- Ebuilds: 1, Testing: 0.8.4 Description:
@aeson-qq@ provides a JSON quasiquoter for Haskell.
This package exposes the function `aesonQQ` that compile-time
converts a string representation of a JSON value into a
`Data.Aeson.Value`. `aesonQQ` has the signature
>aesonQQ :: QuasiQuoter
Consult the @README@ for documentation:
<https://github.com/zalora/aeson-qq#readme>
Homepage:https://github.com/sol/aeson-qq#readme License: MIT
alex
- Ebuilds: 1, Testing: 3.5.1.0 Description: Alex is a tool for generating lexical analysers in Haskell
Homepage:https://www.haskell.org/alex/ License: BSD
alsa-pcm
- Ebuilds: 1, Testing: 0.6.1.2 Description:
This package provides access to ALSA realtime audio signal input and output.
For MIDI support see alsa-seq.
Homepage:https://www.haskell.org/haskellwiki/ALSA License: BSD
alut
- Ebuilds: 1, Testing: 2.4.0.3 Description:
A Haskell binding for the OpenAL Utility Toolkit, which makes
managing of OpenAL contexts, loading sounds in various formats
and creating waveforms very easy. For more information about the
C library on which this binding is based, please see:
<http://connect.creativelabs.com/openal/Documentation/The%20OpenAL%20Utility%20Toolkit.pdf>.
Homepage:https://github.com/haskell-openal/ALUT License: BSD
amazonka-opsworks
- Ebuilds: 1, Testing: 2.0 Description:
The types from this library are intended to be used with
<http://hackage.haskell.org/package/amazonka amazonka>, which provides
mechanisms for specifying AuthN/AuthZ information, sending requests,
and receiving responses.
Lenses are used for constructing and manipulating types,
due to the depth of nesting of AWS types and transparency regarding
de/serialisation into more palatable Haskell values.
The provided lenses should be compatible with any of the major lens libraries
such as <http://hackage.haskell.org/package/lens lens> or
<http://hackage.haskell.org/package/lens-family-core lens-family-core>.
See "Network.AWS.OpsWorks" or <https://aws.amazon.com/documentation/ the AWS documentation>
to get started.
Homepage:https://github.com/brendanhay/amazonka License: MPL-2.0
applicative-numbers
- Ebuilds: 1, Testing: 0.1.3 Description:
Any applicative functor can be given numeric instances in a boilerplate way.
The /applicative-numbers/ package provides an include file that makes it a
snap to define these instances.
See "Data.Numeric.Function" for an example.
Project wiki page: <http://haskell.org/haskellwiki/applicative-numbers>
Copyright 2009-2013 Conal Elliott; BSD3 license.
Instances of @Num@ classes for applicative functors. To be @#include@'d after
defining @APPLICATIVE@ as the applicative functor name and @CONSTRAINTS@ as a
list of constraints, which must carry its own trailing comma if non-empty.
The @APPLICATIVE@ symbol gets @#undef@'d at the end of the include file, so
that multiple includes are convenient.
For instance,
@
#define INSTANCE_Ord
#define INSTANCE_Enum
#define APPLICATIVE Vec2
#include \"ApplicativeNumeric-inc.hs\"
#define APPLICATIVE Vec3
#include \"ApplicativeNumeric-inc.hs\"
#define APPLICATIVE Vec4
#include \"ApplicativeNumeric-inc.hs\"
@
You'll also have to import 'pure' and 'liftA2' from "Control.Applicative"
and specify @the FlexibleContexts@ language extension (due to an implementation hack).
Some instances are generated only if a corresponding CPP symbol is
defined: @INSTANCE_Eq@, @INSTANCE_Ord@, @INSTANCE_Show@, @INSTANCE_Enum@
Homepage:http://haskell.org/haskellwiki/applicative-numbers License: BSD
arrows
- Ebuilds: 1, Testing: 0.4.4.2 Description:
Several classes that extend the Arrow class, and some
transformers that implement or lift these classes.
Homepage:https://www.haskell.org/arrows/ License: BSD
async
- Ebuilds: 1, Testing: 2.2.5-r1 Description: Run IO operations asynchronously and wait for their results
Homepage:https://github.com/simonmar/async License: BSD
atomic-write
- Ebuilds: 1, Testing: 0.2.0.7 Description:
Atomically write to a file on POSIX-compliant systems while preserving
permissions.
On most Unix systems, `mv` is an atomic operation. This makes it simple to write
to a file atomically just by using the mv operation. However, this will
destroy the permissions on the original file. This library does the following
to preserve permissions while atomically writing to a file:
* If an original file exists, take those permissions and apply them to the
temp file before `mv`ing the file into place.
* If the original file does not exist, create a following with default
permissions (based on the currently-active umask).
This way, when the file is `mv`'ed into place, the permissions will be the ones
held by the original file.
This library is based on similar implementations found in common libraries in
Ruby and Python:
* <http://apidock.com/rails/File/atomic_write/class Ruby on Rails includes a similar method called atomic_write>
* <https://github.com/chef/chef/blob/c4631816132fcfefaba3d123a1d0dfe8bc2866bb/lib/chef/file_content_management/deploy/mv_unix.rb#L23:L71 Chef includes atomic update functionality>
* <https://github.com/sashka/atomicfile There is a python library for atomically updating a file>
To use `atomic-write`, import the module corresponding to the type you wish to
write atomically, e.g., to write a (strict) ByteString atomically:
> import System.AtomicWrite.Writer.ByteString
Then you can use the atomicWriteFile function that accepts a `FilePath` and a
`ByteString`, e.g.:
> atomicWriteFile myFilePath myByteString
Homepage:https://github.com/stackbuilders/atomic-write License: MIT
attobencode
- Ebuilds: 1, Testing: 0.3.1.0 Description:
A library for encoding and decoding the Bencode data serialisation format
used by BitTorrent. The focus of this library are good performance (good
enough to be used in a BitTorrent client) and ease of
use.
Homepage:https://bitbucket.org/FlorianHartwig/attobencode License: BSD
attoparsec-binary
- Ebuilds: 1, Testing: 0.2-r1 Description:
This package adds a collection of helper functions to make
the task dealing with binary data of varying endianness from within an
Attoparsec parser easier.
Homepage:https://hackage.haskell.org/package/attoparsec-binary License: BSD
base-noprelude
- Ebuilds: 1, Testing: 4.13.0.0 Description:
This package simplifies defining custom "Prelude"s without having
to use @-XNoImplicitPrelude@ by re-exporting the full module-hierarchy of
the [base-4.13.0.0](https://hackage.haskell.org/package/base-4.13.0.0)
package /except/ for the "Prelude" module.
An usage example for such a "Prelude"-replacement is available with
the [Prelude](http://hackage.haskell.org/package/Prelude) package.
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.
Homepage:https://github.com/hvr/base-noprelude License: BSD
base-unicode-symbols
- Ebuilds: 1, Testing: 0.2.4.2-r1 Description:
This package defines new symbols for a number of functions,
operators and types in the base package.
All symbols are documented with their actual definition and
information regarding their Unicode code point. They should be
completely interchangeable with their definitions.
For further Unicode goodness you can enable the @UnicodeSyntax@
language extension \[1\]. This extension enables Unicode characters
to be used to stand for certain ASCII character sequences,
i.e. &#x2192; instead of @->@, &#x2200; instead of @forall@ and many
others.
Original idea by P&#xE9;ter Divi&#xE1;nszky.
\[1\] <http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#unicode-syntax>
Homepage:https://haskell.org/haskellwiki/Unicode-symbols License: BSD
base64-string
- Ebuilds: 1, Testing: 0.2 Description:
This Base64 implementation uses the characters
A-Z a-z 0-9 + /
along with
=
to signal the number of characters mod 3.
It is compliant with both PEM (RFC 989 / RFC 1421) and MIME (RFC 2045).
Homepage:http://urchin.earth.li/~ian/cabal/base64-string/ License: BSD
basic-prelude
- Ebuilds: 1, Testing: 0.7.0 Description:
The premise of @basic-prelude@ is that there are a lot of very commonly desired features missing from the standard @Prelude@, such as commonly used operators (@\<$\>@ and @>=>@, for instance) and imports for common datatypes (e.g., @ByteString@ and @Vector@). At the same time, there are lots of other components which are more debatable, such as providing polymorphic versions of common functions.
So @basic-prelude@ is intended to give a common foundation for a number of alternate preludes. The package provides two modules: @CorePrelude@ provides the common ground for other preludes to build on top of, while @BasicPrelude@ exports @CorePrelude@ together with commonly used list functions to provide a drop-in replacement for the standard @Prelude@.
Users wishing to have an improved @Prelude@ can use @BasicPrelude@. Developers wishing to create a new prelude should use @CorePrelude@.
Release history:
[0.3] Moved a number of exports from @BasicPrelude@ to @CorePrelude@ and vice-versa.
[0.2] Renamed @BasicPrelude@ to @CorePrelude@ and added a new @BasicPrelude@ module provided a full-featured @Prelude@ alternative. Also added a number of new exports.
[0.1] Initial version, code taken from @classy-prelude@ with a few minor tweaks.
Homepage:https://github.com/snoyberg/basic-prelude#readme License: MIT
bcrypt
- Ebuilds: 1, Testing: 0.0.11 Description:
Haskell bindings to the bcrypt password hash.
Unlike other bindings already in existence, this package is designed to allow users to work directly with password hash strings that include information about the hashing algorithm, strength, and salt. This approach allows hashed passwords to be stored in a single field that can also be used by non-Haskell applications, and makes it easy to implement a policy of updating passwords hashed to an old policy next time the plaintext password is available.
Version 1.1.3 of the OpenWall C source for bcrypt is included in this package (<http://www.openwall.com/crypt/>). The only modification is that the flag which enables the use of assembler has been disabled.
Homepage:https://hackage.haskell.org/package/bcrypt License: BSD
bibtex
- Ebuilds: 1, Testing: 0.1.0.6 Description:
This package allows parsing, formatting and processing of BibTeX files.
BibTeX files are databases for literature for the natbib package
of the LaTeX typesetting system.
The package contains two examples:
* The first example demonstrates the BibTeX parser
by generating a publication overview from a @.bib@ file.
* The second example demonstrates the BibTeX generation
by producing a large @.bib@ file from the tar archive
that cabal-install downloads to your local cabal directory.
Both examples will be build as stand-alone executable
when running
> cabal install -fbuildExamples bibtex
For the first example see the @publications@ directory of this package.
You can start the program and build an example document by running
> make pubs
Technically the program generates a list of custom @\\nocite@ commands
for the LaTeX package @multibib@.
You can add the custom bibtex field @subtype@ to BibTeX entries
for more detailed categorization of an entry.
See "publications/publications.bib" for examples.
The second example can be executed using
> make hackbib
The file @hackage.bib@ is written to the @hackage@ subdirectory.
The @hackage-bibtex@ program
reads an uncompressed tar archive from standard input
and writes the result bibliography file to standard output.
Note that @hackage.bib@ exceeds some limits of standard BibTeX and LaTeX:
There are currently much more than 5000 versions of packages,
the maximum my BibTeX can handle at once.
That is, you can use the bibliography file,
but you cannot cite all entries with @\\nocite*@.
If there are more than 26 uploads by the same author in a year,
the BibTeX style @alpha@ generates identifiers including curly braces
which interacts badly with LaTeX's handling of them.
If you reduce the Bibliography file to 5000 entries
and try to generate an overview of all entries with @\\nocite@,
then @pdflatex@ hits its limits:
> TeX capacity exceeded, sorry [save size=5000]
Homepage:https://www.haskell.org/haskellwiki/BibTeX License: BSD
binary-search
- Ebuilds: 1, Testing: 2.0.0 Description:
These modules address the problem of finding the boundary
of an upward-closed set of integers, using a combination
of exponential and binary searches. Variants are provided
for searching within bounded and unbounded intervals of
both 'Integer' and bounded integral types.
Homepage:https://hackage.haskell.org/package/binary-search License: BSD
bindings-dsl
- Ebuilds: 1, Testing: 1.0.25 Description:
This is a set of macros to be used when writing Haskell FFI.
They were designed to be able to fully describe C interfaces,
so that hsc2hs can extract from them all Haskell code needed to
mimic such interfaces. All Haskell names used are automatically
derived from C names, structures are mapped to Haskell instances
of Storable, and there are also macros you can use with C code
to help write bindings to inline functions or macro functions.
Documentation is available at package homepage:
<http://bitbucket.org/mauricio/bindings-dsl>
This package contains no Haskell code, only C header files
designed for hsc2hs.
Homepage:https://github.com/jwiegley/bindings-dsl/wiki License: BSD
biocore
- Ebuilds: 1, Testing: 0.3.1 Description:
A set of core definitions and data structures
commonly used in bioinformatics. The intention is that bioinformatics
libraries will use this as a common ground to avoid needless incompatibilities
and duplicated work.
Homepage:https://hackage.haskell.org/package/biocore License: LGPL-2.1
biopsl
- Ebuilds: 1, Testing: 0.4 Description:
The library contains the functionality for reading and writing
PSL files (alignment data, e.g. from BLAT output). It duplicates
code from (and is incompatible with) the "bio" library.
Homepage:http://biohaskell.org/ License: LGPL-2.1
biosff
- Ebuilds: 1, Testing: 0.3.7.1 Description:
The library contains the functionality for reading and writing
SFF files (sequencing data from 454 and Ion Torrent). It duplicates
code from (and is incompatible with) the "bio" library.
Homepage:http://biohaskell.org/ License: LGPL-2.1
bitmap
- Ebuilds: 1, Testing: 0.0.2-r1 Description: A library for handling and manipulating bitmaps (rectangular pixel arrays)
Homepage:https://code.haskell.org/~bkomuves/ License: BSD
bits-extras
- Ebuilds: 1, Testing: 0.1.3 Description:
This package contains efficient implementations of high-level bit operations
missing from Data.Bits. The implementation is based on GCC builtins, which
translate to specialized instructions where available.
All operations in this package can also be (less efficiently) implemented in
terms of Data.Bits operations.
/Issues:/ A GCC-provided library, @libgcc_s@, is dynamically linked to
provide software fallbacks on architectures without instructions
corresponding to specific operations. This is currently only expected to work
on Linux systems, and even there can lead to issues with GHCi's custom
linker. A workaround for GHCi on a linux system: @ln -s \/lib\/libgcc_s.so.1
\/lib\/libgcc_s.so@.
The current plan for broader support is to replace the libgcc dependency with
built-in fallbacks in C or Haskell code. This needs to closely follow GCC's
fall-back behaviour for each architecture. Alternative ideas would be
appreciated.
Relevant Hackage tickets:
* <http://hackage.haskell.org/trac/ghc/ticket/3563>
* <http://hackage.haskell.org/trac/ghc/ticket/4102>
/Changes/:
* 0.1.3: Added a first test and tweaked documentation. No functional changes.
* 0.1.2: Moved the 'Data.Bits.Atomic' module to the package @bits-atomic@.
Those operations do not depend on libgcc_s and should work wherever GCC 4.X
is available. Link to @bits-atomic@ on hackage:
<http://hackage.haskell.org/package/bits-atomic>
Homepage:https://hackage.haskell.org/package/bits-extras License: BSD
bitwise
- Ebuilds: 1, Testing: 1.0.0.1 Description: fast multi-dimensional unboxed bit packed Bool arrays
Homepage:https://code.mathr.co.uk/bitwise License: BSD
bktrees
- Ebuilds: 1, Testing: 0.3.1 Description:
Burkhard-Keller trees provide an implementation of sets
which apart from the ordinary operations also has an
approximate member search, allowing you to search for
elements that are of a certain distance from the element
you are searching for.
Homepage:https://hackage.haskell.org/package/bktrees License: BSD
blastxml
- Ebuilds: 1, Testing: 0.3.2 Description:
This library contains a data structure and functions for
reading output from the BLAST sequence alignment program.
Homepage:http://biohaskell.org/ License: LGPL-2.1
blaze-html
- Ebuilds: 1, Testing: 0.9.2.0 Description: A blazingly fast HTML combinator library for Haskell
Homepage:https://jaspervdj.be/blaze License: BSD
blaze-markup
- Ebuilds: 1, Testing: 0.8.3.0 Description: A blazingly fast markup combinator library for Haskell
Homepage:https://jaspervdj.be/blaze License: BSD
bson
- Ebuilds: 1, Testing: 0.4.0.1-r2 Description: BSON documents are JSON-like objects with a standard binary encoding
Homepage:https://github.com/mongodb-haskell/bson License: Apache-2.0
btrfs
- Ebuilds: 1, Testing: 0.2.1.0 Description:
This package provides bindings to the low-level btrfs API (i.e. the
@BTRFS_IOC_@* @ioctl@s). Currently, only a subset of the API is
supported, including all functions needed to work with subvolumes/snapshots
as well as file cloning.
In order to build this package, @linux-headers@ needs 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.
Homepage:https://github.com/redneb/hs-btrfs License: BSD
bytestring-builder
- Ebuilds: 1, Testing: 0.10.8.2.0 Description:
This is the bytestring builder that is debuting in bytestring-0.10.4.0, which
should be shipping with GHC 7.8, probably late in 2013. This builder has
several nice simplifications and improvements, and more out-of-box
functionality than the older blaze-builder.
Note that this package detects which version of bytestring you are compiling
against, and if you are compiling against bytestring-0.10.4 or later, will
be an empty package.
This package lets the new interface and implementation be used with most
older compilers without upgrading bytestring, which can be rather
problematic. In conjunction with blaze-builder-0.4 or later, which
offers an implementation of blaze-builder in terms of bytestring-builder,
this should let most people try the new interface and implementation without
causing undue compatibility problems with packages that depend on
blaze-builder.
GHC 7.6 did debut an almost identical interface and implementation, but with
slightly different module names and organization. Trying to re-export/rename
the builder provided with 7.6 did not turn out to be very practical, because
this interface includes new functions that rely on Builder internals,
which are not exported in 7.6. Furthermore, these module names should be
deprecated in 7.10.
Homepage:https://hackage.haskell.org/package/bytestring-builder License: BSD
bytestring-to-vector
- Ebuilds: 1, Testing: 0.3.0.1 Description:
This library allows conversion between the types from @Data.ByteString@
(package @bytestring@) and @Data.Vector.Storable@ (package @vector@) without
copying the underlying data. This is useful, for example, when @ByteString@
IO produces or consumes vectors of numbers in native byte order.
The conversion relies on the fact that @ByteString@ and @Vector@ use their
respective @ForeignPtr@s in compatible ways.
This library is a fork of the @spool@ package written by Keegan McAllister.
Homepage:https://github.com/sheyll/bytestring-to-vector License: BSD
cascading
- Ebuilds: 1, Testing: 0.1.0-r2 Description:
This library implements an HTML-specific domain-specific language
for cascading style sheets (CSS) in the spirit of blaze-html. See
the documentation of the Data.CSS module for a tutorial.
Homepage:https://hackage.haskell.org/package/cascading License: BSD
case-insensitive
- Ebuilds: 1, Testing: 1.2.1.0 Description:
The module @Data.CaseInsensitive@ provides the 'CI' type
constructor which can be parameterised by a string-like
type like: 'String', 'ByteString', 'Text',
etc.. Comparisons of values of the resulting type will be
insensitive to cases.
Homepage:https://github.com/basvandijk/case-insensitive License: BSD
cc-delcont
- Ebuilds: 1, Testing: 0.2.1.0 Description:
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>).
Homepage:http://code.haskell.org/~dolio/CC-delcont License: MIT
cereal-text
- Ebuilds: 1, Testing: 0.1.0.2 Description:
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.
Homepage:https://github.com/ulikoehler/cereal-text License: Apache-2.0
charset
- Ebuilds: 1, Testing: 0.3.11 Description: Fast unicode character sets based on complemented PATRICIA tries
Homepage:https://github.com/ekmett/charset License: BSD
charsetdetect-ae
- Ebuilds: 1, Testing: 1.1.0.4 Description:
Mozilla have developed a robust and efficient character set detection algorithm for
use in their web browsers. The algorithm is able to detect all of the most frequently
encountered character encodings totally automatically.
This library wraps up their library and exposes a very simple Haskell interface to it.
The library is portable, and is confirmed to work on both Unix and Windows.
Homepage:https://github.com/aelve/charsetdetect-ae License: LGPL-2.1
chaselev-deque
- Ebuilds: 1, Testing: 0.5.0.5 Description:
A queue that is push/pop on one end and pop-only on the other. These are commonly
used for work-stealing.
This implementation derives directly from the pseudocode in the 2005 SPAA paper:
http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.170.1097&rep=rep1&type=pdf
Homepage:https://github.com/rrnewton/haskell-lockfree/wiki License: BSD
chell
- Ebuilds: 1, Testing: 0.5.0.2-r1 Description: A simple and intuitive library for automated testing
Homepage:https://github.com/typeclasses/chell License: MIT
chimera
- Ebuilds: 1, Testing: 0.3.4.0 Description:
There are plenty of memoizing libraries on Hackage, but they
usually fall into two categories:
* Store cache as a flat array, enabling us
to obtain cached values in O(1) time, which is nice.
The drawback is that one must specify the size
of the array beforehand,
limiting an interval of inputs,
and actually allocate it at once.
* Store cache as a lazy binary tree.
Thanks to laziness, one can freely use the full range of inputs.
The drawback is that obtaining values from a tree
takes logarithmic time and is unfriendly to CPU cache,
which kinda defeats the purpose.
This package intends to tackle both issues,
providing a data type 'Chimera' for
lazy infinite compact streams with cache-friendly O(1) indexing.
Additional features include:
* memoization of recursive functions and recurrent sequences,
* memoization of functions of several, possibly signed arguments,
* efficient memoization of boolean predicates.
Homepage:https://github.com/Bodigrim/chimera#readme License: BSD
chr-data
- Ebuilds: 1, Testing: 0.1.0.1 Description:
Datatypes required for chr library, in particular searching on treestructures, lookup abstraction, substitutions, etc. These are also used (via uhc-util) in UHC.
Homepage:https://github.com/atzedijkstra/chr License: BSD
chr-parse
- Ebuilds: 1, Testing: 0.1.0.0 Description:
Parsing for chr library, currently wrapping around the parsing lib from uulib and adding some utilities
Homepage:https://github.com/atzedijkstra/chr License: BSD
cipher-aes
- Ebuilds: 1, Testing: 0.2.11-r1 Description:
Fast AES cipher implementation with advanced mode of operations.
The modes of operations available are ECB (Electronic code book),
CBC (Cipher block chaining), CTR (Counter), XTS (XEX with ciphertext stealing),
GCM (Galois Counter Mode).
The AES implementation uses AES-NI when available (on x86 and x86-64 architecture),
but fallback gracefully to a software C implementation.
The software implementation uses S-Boxes, which might suffer for cache timing issues.
However do notes that most other known software implementations, including very popular
one (openssl, gnutls) also uses similar implementation. If it matters for your
case, you should make sure you have AES-NI available, or you'll need to use a different
implementation.
Homepage:https://github.com/vincenthz/hs-cipher-aes License: BSD
clash-ghc
- Ebuilds: 1, Testing: 1.8.4 Description: Clash: a functional hardware description language - GHC frontend
Homepage:https://clash-lang.org/ License: BSD-2
clash-lib
- Ebuilds: 1, Testing: 1.8.4 Description: Clash: a functional hardware description language - As a library
Homepage:https://clash-lang.org/ License: BSD-2
clash-prelude
- Ebuilds: 1, Testing: 1.8.4 Description: Clash: a functional hardware description language - Prelude library
Homepage:https://clash-lang.org/ License: BSD-2
clevercss
- Ebuilds: 1, Testing: 0.2.4-r2 Description:
CleverCSS is a CSS preprocessing library that allows defining variables and nesting selectors so that you don't need to Repeat Yourself.
Homepage:http://sandbox.pocoo.org/clevercss-hs/ License: BSD
codec-image-devil
- Ebuilds: 1, Testing: 0.2.4 Description:
Provides a very simple interface to the DevIL image library.
Provides functions readImage and writeImage, which can read
and write many image formats from/to an RGBA array of values
to work with.
Homepage:https://hackage.haskell.org/package/Codec-Image-DevIL License: BSD
colock
- Ebuilds: 1, Testing: 0.2.2-r1 Description:
This module provides file locks that (unlike their counterparts in System.Posix.IO)
leave other threads running while one waits for the lock.
Homepage:https://hackage.haskell.org/package/colock License: LGPL-2.1
conceit
- Ebuilds: 1, Testing: 0.5.0.0 Description:
A version of the async package's 'Control.Concurrent.Async.Concurrently' for which the actions may fail with a value.
Homepage:https://hackage.haskell.org/package/conceit License: BSD
concurrent-extra
- Ebuilds: 1, Testing: 0.7.0.12 Description:
The @concurrent-extra@ package offers among other things the
following selection of synchronisation primitives:
* @Broadcast@: Wake multiple threads by broadcasting a value.
* @Event@: Wake multiple threads by signalling an event.
* @Lock@: Enforce exclusive access to a resource. Also known as a
binary semaphore or mutex. The package additionally provides an
alternative that works in the @STM@ monad.
* @RLock@: A lock which can be acquired multiple times by the same
thread. Also known as a reentrant mutex.
* @ReadWriteLock@: Multiple-reader, single-writer locks. Used to
protect shared resources which may be concurrently read, but only
sequentially written.
* @ReadWriteVar@: Concurrent read, sequential write variables.
Please consult the API documentation of the individual modules for
more detailed information.
This package was inspired by the concurrency libraries of Java and
Python.
Homepage:https://github.com/basvandijk/concurrent-extra License: BSD
concurrent-split
- Ebuilds: 1, Testing: 0.0.1.1 Description:
MVars and Channels with distinguished input and output side.
When threads communicate via an MVar or a Chan
there are often clearly defined roles,
which thread is the sender and which one is receiver.
We provide wrappers around the standard concurrency communication channels
that make the distinction clear and type safe.
For example, if a function has a parameter of type @TChan.In@
then it is sure that it will only write to that channel.
Additionally if the compiler warns about an unused @TChan.Out@
that was created by @TChan.new@
then you know that the receiver part of your communication is missing.
See also package @stm-split@ for transactional communication.
This package follows the same idea as @chan-split@ but is strictly Haskell 98.
Homepage:https://hackage.haskell.org/package/concurrent-split License: BSD
concurrentoutput
- Ebuilds: 1, Testing: 0.2.0.2 Description:
This library provides a simple interface to output status
messages from more than one thread.
It will continue adding information (such as dots, or \"done\")
to the correct line and continue scrolling when a line is done.
For example, this screen:
@
Thread ThreadId 27: still working... done
Thread ThreadId 25: still working...
Thread ThreadId 26: still working...
_
@
will, once thread 25 has finished, look like this:
@
Thread ThreadId 25: still working... done
Thread ThreadId 27: still working... done
Thread ThreadId 26: still working...
_
@
If standard output is not a terminal, it will only print
complete lines and not output any control characters.
At the moment, it can only handle lines that are shorter than
the terminal. If they are not, output will be garbled again.
Homepage:https://hackage.haskell.org/package/concurrentoutput License: BSD
cond
- Ebuilds: 1, Testing: 0.5.1 Description: Basic conditional and boolean operators with monadic variants
Homepage:https://github.com/jcranch/cond License: BSD
conduit-audio
- Ebuilds: 1, Testing: 0.2.0.3 Description:
@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)
Homepage:https://github.com/mtolly/conduit-audio License: BSD
conduit-audio-lame
- Ebuilds: 1, Testing: 0.1.2.1 Description:
A simple binding to the LAME MP3 library for use with @conduit-audio@,
to save audio streams as MP3 files.
Requires the LAME library.
On Ubuntu, @apt-get install libmp3lame-dev@;
on Mac with Homebrew, @brew install lame@.
LAME is LGPL licensed, so you may dynamically link to it from a closed-source program.
Homepage:https://github.com/mtolly/conduit-audio License: BSD
conduit-audio-samplerate
- Ebuilds: 1, Testing: 0.1.0.3 Description:
A binding to the @libsamplerate@ library for use with @conduit-audio@,
to resample audio streams.
Requires the @libsamplerate@ library.
On Ubuntu, @apt-get install libsamplerate0-dev@;
on Mac with Homebrew, @brew install libsamplerate@.
Note that unless you have a commercial license, @libsamplerate@ is GPL licensed.
Homepage:https://github.com/mtolly/conduit-audio License: BSD
conduit-audio-sndfile
- Ebuilds: 1, Testing: 0.1.2.2 Description:
A wrapper around @hsndfile@ (binding to the @libsndfile@ library)
for use with @conduit-audio@, to load a wide variety of audio files as streams.
@libsndfile@ is LGPL licensed, so you may dynamically link to it from a closed-source program.
However, note that @hsndfile@ is also LGPL licensed,
so if your program is closed-source you also must dynamically link @hsndfile@.
Homepage:https://github.com/mtolly/conduit-audio License: BSD
configurator
- Ebuilds: 1, Testing: 0.3.0.0-r1 Description:
A configuration management library for programs and daemons.
Features include:
* Automatic, dynamic reloading in response to modifications to
configuration files.
* A simple, but flexible, configuration language, supporting several
of the most commonly needed types of data, along with
interpolation of strings from the configuration or the system
environment (e.g. @$(HOME)@).
* Subscription-based notification of changes to configuration
properties.
* An @import@ directive allows the configuration of a complex
application to be split across several smaller files, or common
configuration data to be shared across several applications.
For details of the configuration file format, see
<http://hackage.haskell.org/packages/archive/configurator/latest/doc/html/Data-Configurator.html>.
Homepage:https://github.com/bos/configurator License: BSD
conversion
- Ebuilds: 1, Testing: 1.2.1 Description:
This library provides a typeclass with instances for types
defined in \"base\".
Instances for other types are expected to be defined in other libraries.
Such libraries should be listed under
<http://hackage.haskell.org/packages/#cat:Conversion the Conversion category>.
So far the following are known:
* <http://hackage.haskell.org/package/conversion-bytestring "conversion-bytestring">
* <http://hackage.haskell.org/package/conversion-text "conversion-text">
* <http://hackage.haskell.org/package/conversion-case-insensitive "conversion-case-insensitive">
Homepage:https://github.com/nikita-volkov/conversion License: MIT
cordering
- Ebuilds: 1, Testing: 2.3-r2 Description:
Typically this is used as the return type of a combining comparison, which combines two
values if they are deemed equal in some sense. Currently combining comparisons are used
extensively by the AVL tree package (AvlTree).
Homepage:https://hackage.haskell.org/package/COrdering License: BSD
cpphs
- Ebuilds: 1, Testing: 1.20.9.1-r1 Description: A liberalised re-implementation of cpp, the C pre-processor
Homepage:https://projects.haskell.org/cpphs/ License: LGPL-2.1
crypto
- Ebuilds: 1, Testing: 4.2.5.1-r1 Description: Collects together existing Haskell cryptographic functions into a package
Homepage:https://hackage.haskell.org/package/Crypto License: BSD GPL-2
crypto-api
- Ebuilds: 1, Testing: 0.13.3 Description:
A generic interface for cryptographic operations (hashes, ciphers, randomness).
Maintainers of hash and cipher implementations are
encouraged to add instances for the classes defined
in Crypto.Classes. Crypto users are similarly
encouraged to use the interfaces defined in the Classes
module.
Any concepts or functions of general use to more than
one cryptographic algorithm (ex: padding) is within
scope of this package.
Homepage:https://github.com/TomMD/crypto-api License: BSD
cryptonite-conduit
- Ebuilds: 1, Testing: 0.2.2-r1 Description:
Conduit bridge for cryptonite
For now only provide a conduit version for hash and hmac, but
with contribution, this could provide cipher conduits too,
and probably other things.
Homepage:https://github.com/haskell-crypto/cryptonite-conduit License: BSD
csv
- Ebuilds: 1, Testing: 0.1.2-r1 Description:
CSV loader and dumper
This library parses and dumps documents that are formatted
according to RFC 4180, \"The common Format and MIME Type for
Comma-Separated Values (CSV) Files\". This format is used, among
many other things, as a lingua franca for spreadsheets, and for
certain web services.
Homepage:https://hackage.haskell.org/package/csv License: MIT
cuda
- Ebuilds: 1, Testing: 0.10.1.0 Description:
The CUDA library provides a direct, general purpose C-like SPMD programming
model for NVIDIA graphics cards (G8x series onwards). This is a collection
of bindings to allow you to call and control, although not write, such
functions from Haskell-land. You will need to install the CUDA driver and
developer toolkit.
<http://developer.nvidia.com/cuda-downloads>
The configure script will look for your CUDA installation in the standard
places, and if the nvcc compiler is found in your PATH, relative to that.
This release is for version 4.0 of the CUDA toolkit.
Homepage:https://github.com/tmcdonell/cuda License: BSD
cufft
- Ebuilds: 1, Testing: 0.10.0.0 Description:
The CUFFT library is part of the CUDA developer toolkit.
<http://developer.nvidia.com/cuda-downloads>
It contains a highly optimised, FFTW compatible, Fast-Fourier Transform
implementation that can execute on NVIDIA GPUs.
Homepage:https://github.com/robeverest/cufft License: BSD
data-checked
- Ebuilds: 1, Testing: 0.3 Description:
This package provides a (phantom) type-indexed newtype evidence-wrapper for
values that are checked to satisfy the property associated with the type.
Homepage:https://github.com/mvv/data-checked License: BSD
data-flags
- Ebuilds: 1, Testing: 0.0.3.4 Description:
This package provides type classes for flags and corresponding instances
for standard numeric types viewed as bit masks.
Homepage:https://github.com/mvv/data-flags License: BSD
data-textual
- Ebuilds: 1, Testing: 0.3.0.3 Description:
This package provides an interface for converting between data and its
(human-friendly) textual representation.
Homepage:https://github.com/mvv/data-textual License: BSD
dates
- Ebuilds: 1, Testing: 0.2.3.3 Description: Small library for parsing different dates formats
Homepage:https://github.com/portnov/dates License: BSD
datetime
- Ebuilds: 1, Testing: 0.3.1 Description:
Provides several utilities for easily converting among the
various standard library Date and Time types, and for converting
between these and standard external representations.
Homepage:https://github.com/stackbuilders/datetime License: GPL-2
dav
- Ebuilds: 1, Testing: 1.3.4-r1 Description:
This is a library for the Web Distributed Authoring and Versioning
(WebDAV) extensions to HTTP. At present it supports a very small
subset of client functionality.
In addition, there is an executable, hdav, which can be used for
command-line operation.
Homepage:https://floss.scru.org/hDAV License: GPL-3
descriptive
- Ebuilds: 1, Testing: 0.9.5 Description:
Self-describing consumers/parsers. See the README.md for more information. It is currently EXPERIMENTAL.
Homepage:https://github.com/chrisdone/descriptive License: BSD
df1
- Ebuilds: 1, Testing: 0.4.1 Description: Type, render and parse the df1 hierarchical structured log format
Homepage:https://github.com/k0001/di License: BSD
di
- Ebuilds: 1, Testing: 1.3 Description: Typeful hierarchical structured logging using di, mtl and df1
Homepage:https://github.com/k0001/di License: BSD
di-df1
- Ebuilds: 1, Testing: 1.2.1 Description: Write logs in the df1 format using the di logging framework
Homepage:https://github.com/k0001/di License: BSD
diagrams-gtk
- Ebuilds: 1, Testing: 1.4-r1 Description:
An optional add-on to the diagrams-cairo package
which allows rendering diagrams directly to GTK windows.
Homepage:http://projects.haskell.org/diagrams/ License: BSD
diagrams-lib
- Ebuilds: 1, Testing: 1.4.7-r1 Description: Embedded domain-specific language for declarative graphics
Homepage:https://diagrams.github.io License: BSD
directory-listing-webpage-parser
- Ebuilds: 1, Testing: 0.1.1.0 Description:
A parser that parses directory listings (webpage that autogenerated by web server).
example webpage that this package can parse:
nginx: <https://www.kernel.org/pub/linux/devel/gcc/>
apache: <https://nixos.org/channels/nixos-15.09/>
However, some hard coding is used in this package, so it may failed to parse
depend on directory listings' html structure.
Homepage:https://hackage.haskell.org/package/directory-listing-webpage-parser License: BSD
directory-tree
- Ebuilds: 1, Testing: 0.12.1 Description:
A simple directory-like tree datatype, with useful IO functions and Foldable and Traversable instance
Provides a simple data structure mirroring a directory tree on the
filesystem, as well as useful functions for reading and writing
file and directory structures in the IO monad.
Importing the library and optional (useful) Foldable and Traverable libraries:
> import System.Directory.Tree
> import qualified Data.Foldable as F
> import qualified Data.Traversable as T
Write a hand-made directory tree of textfiles (strings) to the disk.
Simulates creating a new user Tux's home directory on a unix machine:
> writeDirectory$ "/home" :/ Dir "Tux" [File "README" "Welcome!"]
"read" a directory by opening all the files at a filepath with readFile,
returning an 'AnchoredDirTree String' (d2). Then check for any IO failures:
> do (base :/ d2) <- readDirectory "../parent_dir/dir2/"
> let failed = anyFailed d2
> if failed then ...
Use Foldable instance function to concat a directory 'dir' of text files into a
single file under the same directory:
> do (b :/ dt) <- readDirectory dir
> let f = F.concat dt
> return$ b :/ File "ALL_TEXT" f
Open all the files in the current directory as lazy bytestrings, ignoring
the base path in Anchored wrapper:
> import qualified Data.ByteString.Lazy as B
> do (_ :/ dTree) <- readDirectoryWith B.readFile "./"
This version also offers an experimental function `readDirectoryWithL` that does
lazy directory IO, allowing you to treat the returned `DirTree` as if it were a
normal lazily-generated data structure.
For example, the following does only the amount of IO necessary to list the file
names of the children of the root directory, similar to "ls /":
> do d <- readDirectoryWithL readFile "/"
> mapM_ (putStrLn . name) $ contents $ free d
Any ideas or suggestions for improvements are most welcome :-)
Homepage:http://brandon.si/code/directory-tree-module-released/ License: BSD
djinn
- Ebuilds: 1, Testing: 2025.2.21 Description:
Djinn uses an theorem prover for intuitionistic propositional logic
to generate a Haskell expression when given a type.
Homepage:https://hackage.haskell.org/package/djinn License: BSD
dlist-instances
- Ebuilds: 1, Testing: 0.1.1.1 Description:
See the dlist packages.
This package is the canonical source for some orphan instances.
Orphan instances are placed here to avoid dependencies elsewhere.
Homepage:https://github.com/gregwebs/dlist-instances License: BSD
docopt
- Ebuilds: 1, Testing: 0.7.0.8 Description: A command-line interface parser that will make you smile
Homepage:https://github.com/docopt/docopt.hs License: MIT
download-curl
- Ebuilds: 1, Testing: 0.1.4-r2 Description:
High-level file download based on URLs
Download web content as strict or lazy bytestringrs, strings, HTML
tags, XML, RSS or Atom feeds or JSON, using the curl network library.
Importing the library:
> import Network.Curl.Download
Loading a webpage as a "ByteString":
> doc <- openURI "http://haskell.org"
Loading from a file:
> doc <- openURI "file:///tmp/A.hs"
Loading a HTML page as a list of tags:
> tags <- openAsTags "http://haskell.org"
Loading a HTML page as XML:
> tags <- openAsXML "http://haskell.org"
Loading an RSS or Atom feed:
> feed <- openAsFeed "http://haskell.org"
These data types can the be processed further with the XML, Feed and
TagSoup libraries.
Homepage:http://code.haskell.org/~dons/code/download-curl License: BSD
drbg
- Ebuilds: 1, Testing: 0.5.5-r1 Description: Deterministic random bit generator (aka PRNG) based HMACs, Hashes, and Ciphers
Homepage:https://hackage.haskell.org/package/DRBG License: BSD
dynamic-graph
- Ebuilds: 1, Testing: 0.1.0.13 Description:
Draw and update graphs in real time with OpenGL. Suitable for displaying large amounts of frequently changing data. Line graphs and waterfall plots are supported, as well as axis drawing.
See <https://github.com/adamwalker/dynamic-graph> for examples of the graphs it can produce.
To get started, see "Graphics.DynamicGraph.Window"
Homepage:https://github.com/adamwalker/dynamic-graph License: BSD
easyrender
- Ebuilds: 1, Testing: 0.1.1.4 Description:
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.
Homepage:http://www.mathstat.dal.ca/~selinger/easyrender/ License: GPL-3
echo
- Ebuilds: 1, Testing: 0.1.4-r2 Description: A cross-platform, cross-console way to handle echoing terminal input
Homepage:https://github.com/RyanGlScott/echo License: BSD
ede
- Ebuilds: 1, Testing: 0.3.4.0 Description: Templating language with similar syntax and features to Liquid or Jinja2
Homepage:https://github.com/brendanhay/ede License: MPL-2.0
edit-distance-vector
- Ebuilds: 1, Testing: 1.0.0.4 Description:
An implementation of the Wagner-Fischer dynamic programming algorithm to
find the optimal edit script and cost between two sequences.
The implementation in this package is specialised to sequences represented
with "Data.Vector" but is otherwise agnostic to:
* The type of values in the vectors;
* The type representing edit operations; and
* The type representing the cost of operations.
Homepage:https://github.com/thsutton/edit-distance-vector License: BSD
editline
- Ebuilds: 1, Testing: 0.2.1.1-r1 Description:
This package contains bindings to the BSD editline library
(<http://www.thrysoee.dk/editline/>).
It provides a basic interface to the editline API for
reading lines of input from the user.
Additionally, a readline compatibility module is included
which provides a subset of the functions from the
readline package.
Homepage:http://code.haskell.org/editline License: BSD
editor-open
- Ebuilds: 1, Testing: 0.6.0.0 Description:
You know when you run @git commit@, and an editor pops open so you can enter a
commit message? This is a Haskell library that does that.
This library isn't very portable. It relies on the @$EDITOR@ environment
variable. The concept only exists on *nix systems.
CHANGES
[0.6.0.0] Support less common @$VISUAL@. @vi@ is the fallback editor now
instead of @nano@.
[0.5.0.0] Now use conduits on the backend. Support @base\<4.8@
Homepage:https://github.com/pharpend/editor-open License: Apache-2.0
enumset
- Ebuilds: 1, Testing: 0.0.5 Description:
With this package you can create a type safe interface to flag sets.
It is intended for interfacing to C libraries via FFI,
where Word8, Word16, or Word32 types are commonly used to store bit vectors.
E.g. the type @EnumSet Word16 Ordering@
represents a flag set stored in a Word16
that supports the flags @LT@, @EQ@, @GT@.
This package is similar to the @bitset@ package and
the @Data.Edison.Coll.EnumSet@ module in the @edison@ package,
however our implementation allows you to choose the embedding type
and thus the maximum size of the set.
Homepage:https://hackage.haskell.org/package/enumset License: BSD
executable-path
- Ebuilds: 1, Testing: 0.0.3.1 Description:
The documentation of "System.Environment.getProgName" says that
\"However, this is hard-to-impossible to implement on some non-Unix OSes,
so instead, for maximum portability, we just return the leafname
of the program as invoked.\"
This library tries to provide the missing path.
Homepage:http://code.haskell.org/~bkomuves/ License: public-domain
exif
- Ebuilds: 1, Testing: 3000.0.0-r1 Description:
This is a Haskell binding to a subset of libexif.
Only tag reading is currently supported.
Image files containing EXIF data can be read from memory or
disk.
Homepage:https://hackage.haskell.org/package/exif License: BSD
extensible
- Ebuilds: 1, Testing: 0.9.2 Description:
This package provides a powerful framework to combine and manipulate various types of structures.
See also <https://www.schoolofhaskell.com/user/fumieval/extensible School of Haskell> for tutorials.
Homepage:https://github.com/fumieval/extensible License: BSD
extensible-effects
- Ebuilds: 1, Testing: 5.0.0.1 Description:
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!
Homepage:https://github.com/suhailshergill/extensible-effects License: MIT
fail
- Ebuilds: 1, Testing: 4.9.0.0 Description:
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.
Homepage:https://prime.haskell.org/wiki/Libraries/Proposals/MonadFail License: BSD
fast-math
- Ebuilds: 1, Testing: 1.0.2 Description:
The "Numeric.FastMath" module brings into scope many unsafe @RULES@ for
'Float's and 'Double's that can greatly improve run time performance.
It is roughly equivalent to gcc\'s @-ffast-math@ compiler flag.
Optimisation (at least @-O1@) must be enabled for any @RULES@ to take effect.
These rules are unsafe because they don't strictly adhere to the
IEEE-754 regulations and may subtly change the results of your numeric computations.
See the <http://github.com/liyang/fast-math/ README> on github for more details.
Homepage:https://hackage.haskell.org/package/fast-math License: BSD
fastcgi
- Ebuilds: 1, Testing: 3001.0.2.5 Description:
This library lets you write FastCGI programs. This package reuses the
cgi package API, making it very easy to port CGI programs to FastCGI.
The FastCGI C development kit is required to build this library.
Homepage:https://hackage.haskell.org/package/fastcgi License: BSD
file-location
- Ebuilds: 1, Testing: 0.4.9.1 Description:
Common debugging/error/exception functions that give file location information
> $(err "OH NO!")
>
> main:Main main.hs:16:1 OH NO!
Notice how it displays package:module file:line:character
It exposes the functions err (error), undef (undefined), and trc (Debug.Trace.trace). All of these behave the same as their normal counterpart but also spit out a location.
Here is my favorite helper, debug, which is like trace but just show the value.
> debug [1,2,3]
>
> DEBUG: [1,2,3]
> [1,2,3]
And The Template Haskell version.
> $(dbg) [1,2,3]
>
> DEBUG main:Main main.hs:1:3 [1,2,3]
> [1,2,3]
Also there is a version of thrwIO that gives location information
> ($(thrwIO) $ AException) `catch` \e -> putStrLn ("Caught " ++ show (e :: AException))
>
> Caught AException "main:Main test/main.hs:25:6"
See module for a listing of all the functions with short descriptions, and the homepage for some more examples https://github.com/gregwebs/ErrorLocation.hs
Homepage:https://github.com/gregwebs/FileLocation.hs License: BSD
file-modules
- Ebuilds: 1, Testing: 0.1.2.4 Description:
Uses @haskell-src-exts@ to parse module imports and follows links
. to local modules in order to build a list of module dependencies.
Homepage:https://github.com/yamadapc/stack-run-auto License: MIT
fixplate
- Ebuilds: 1, Testing: 0.1.8 Description:
Uniplate-style generic traversals for fixed-point types, which can be
optionally annotated with attributes. We also provide recursion schemes,
and a generic zipper. See the module "Data.Generics.Fixplate" and then
the individual modules for more detailed information.
Homepage:http://code.haskell.org/~bkomuves/ License: BSD
flexible-defaults
- Ebuilds: 1, Testing: 0.0.3-r1 Description:
Template Haskell code to implement default implementations
for type-class functions based on which functions are
already implemented. Currently extremely crude but
still fairly effective.
Homepage:https://github.com/peti/flexible-defaults License: public-domain
floatinghex
- Ebuilds: 1, Testing: 0.4 Description:
Read and write hexadecimal floating point numbers. Provides a quasiquoter for
entering hex-float literals, and a function for printing them in hexadecimal.
See: <http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1256.pdf>, pages 57-58.
We slightly diverge from the standard and do not allow for the "floating-suffix,"
as the type inference of Haskell makes this unnecessary.
For details, please see: <http://github.com/LeventErkok/FloatingHex/>
Homepage:https://hackage.haskell.org/package/FloatingHex License: BSD
focus
- Ebuilds: 1, Testing: 1.0.3.2 Description: A general abstraction for manipulating elements of container data structures
Homepage:https://github.com/nikita-volkov/focus License: MIT
fontyfruity
- Ebuilds: 1, Testing: 0.5.3.5 Description:
A haskell Truetype file parser.
You can load a font file and extract some curves to be
drawed with a library like Rasterific .
Homepage:https://hackage.haskell.org/package/FontyFruity License: BSD
fpretty
- Ebuilds: 1, Testing: 1.1 Description:
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.
Homepage:http://www.cs.kent.ac.uk/~oc/pretty.html License: BSD
freer
- Ebuilds: 1, Testing: 0.2.4.1 Description:
Freer is an implementation of "Freer Monads, More Extensible
Effects"
The key features of Freer are:
* An efficient effect system for Haskell - as a library!
* Implementations for several common Haskell monad instances:
* Core components for defining your own Effects
Homepage:https://gitlab.com/queertypes/freer License: BSD
freer-effects
- Ebuilds: 1, Testing: 0.3.0.1 Description:
Implementation of effect system for Haskell, which is based on the work of
Oleg Kiselyov et al.:
* http://okmij.org/ftp/Haskell/extensible/more.pdf Freer Monads, More Extensible Effects;
* http://okmij.org/ftp/Haskell/zseq.pdf Reflection without Remorse;
* http://okmij.org/ftp/Haskell/extensible/exteff.pdf Extensible Effects;
The key features are:
* An efficient effect system for Haskell - as a library!
* Reimplementations of several common Haskell monad transformers as effects.
* Core components for defining your own Effects.
Homepage:https://github.com/IxpertaSolutions/freer-effects License: BSD
fst
- Ebuilds: 1, Testing: 0.10.0.1-r1 Description:
Fst is an application for construction and running of
finite state transducers. The application was written
purely in Haskell, and is intended to be a tool for the
Haskell programmer, especially for ones that develop language applications.
Homepage:http://www.cse.chalmers.se/alumni/markus/fstStudio/ License: BSD
ftgl
- Ebuilds: 1, Testing: 2.1-r1 Description: Portable TrueType font rendering for OpenGL using the Freetype2 library
Homepage:https://hackage.haskell.org/package/FTGL License: BSD
funcmp
- Ebuilds: 1, Testing: 1.9 Description:
Functional MetaPost is a Haskell frontend to the
MetaPost language by John Hobby. Users write their
graphics as Haskell programs, which then emit MetaPost
code that can be compiled into encapsulated PostScript
files and smoothly included into e.g. LaTeX.
A collection of useful examples how to use Functional
MetaPost can be found in the user's manual at
<http://download.savannah.nongnu.org/releases/funcmp/Manual_eng.ps>. The
document doesn't offer very much detail in terms of
explanations, but the code samples are quite helpful.
Further documentation can be found in the original
thesis that describes the implementation. The text is
available in German at
<http://download.savannah.nongnu.org/releases/funcmp/Thesis.ps> and in
English at
<http://download.savannah.nongnu.org/releases/funcmp/Thesis_eng.ps>.
Last but not least, there is a tutorial that offers many
helpful examples available in German at
<http://download.savannah.nongnu.org/releases/funcmp/Tutorial.ps> and in
English at
<http://download.savannah.nongnu.org/releases/funcmp/Tutorial_eng.ps>.
Homepage:https://github.com/peti/funcmp License: GPL-3
functor-monadic
- Ebuilds: 1, Testing: 0.1.0.3 Description:
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.
Homepage:https://github.com/ombocomp/FunctorMonadic/ License: Apache-2.0
fusion-plugin-types
- Ebuilds: 1, Testing: 0.1.0 Description:
GHC package that provides types that when used in a package can be identified by the <https://hackage.haskell.org/package/fusion-plugin fusion-plugin> package to perform any extra optimizations.
Homepage:https://github.com/composewell/fusion-plugin-types License: BSD
fuzzy
- Ebuilds: 1, Testing: 0.1.0.1 Description: Filters a list based on a fuzzy string search
Homepage:https://github.com/joom/fuzzy License: MIT
gamma
- Ebuilds: 1, Testing: 0.10.0.0 Description: Gamma function and related functions
Homepage:https://github.com/rockbmb/gamma2 License: public-domain
gd
- Ebuilds: 1, Testing: 3000.7.3 Description: A Haskell binding to a subset of the GD graphics library
Homepage:https://hackage.haskell.org/package/gd License: BSD
generic-random
- Ebuilds: 1, Testing: 1.3.0.1 Description:
For more information
- "Generic.Random.Tutorial"
- http://blog.poisson.chat/posts/2018-01-05-generic-random-tour.html
- https://byorgey.wordpress.com/2016/09/20/the-generic-random-library-part-1-simple-generic-arbitrary-instances/
Homepage:https://github.com/lysxia/generic-random License: MIT
generic-trie
- Ebuilds: 1, Testing: 0.3.2 Description:
This type implements maps where the keys are themselves
complex structured data. For example, the keys may be
the abstract syntax trees for a programming language.
The map is implemented as a trie, so common parts of the
keys will be shared in the representation. The library
provides a generic implementation of the data structure,
so values of types that have support for 'Generic' may
be automatically used as keys in the map.
Homepage:https://github.com/glguy/tries License: BSD
genericpretty
- Ebuilds: 1, Testing: 1.2.2 Description:
GenericPretty is a Haskell library that supports automatic
derivation of pretty printing functions on user defined data
types.
The form of generics used is based on that introduced in the paper:
Magalhaes, Dijkstra, Jeuring, and Loh,
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>.
Changes from the original paper in the GHC implementation
are described here:
<http://www.haskell.org/haskellwiki/GHC.Generics#Changes_from_the_paper>.
This package requires the use of the new GHC.Generics features
<http://www.haskell.org/haskellwiki/GHC.Generics>, present from GHC 7.2.
Use of these features is indicated by the DeriveGeneric pragma
or the flag -XDeriveGeneric.
Pretty printing produces values of type Text.PrettyPrint.Doc, using
the Text.PrettyPrint library
<http://www.haskell.org/ghc/docs/latest/html/libraries/pretty-1.1.1.0/Text-PrettyPrint.html>.
The output provided is a pretty printed version of that provided by
Prelude.show. That is, rendering the document provided by this pretty
printer yields an output identical to that of Prelude.show, except
for extra whitespace.
For information about the functions exported by the package please see
the API linked further down this page.
For examples of usage, both basic and more complex see the README file and
the haskell source code files in the TestSuite folder, both included in the package.
Finally for installation instructions also see the README file or this page:
<http://www.haskell.org/haskellwiki/Cabal/How_to_install_a_Cabal_package>
Homepage:https://github.com/RazvanRanca/GenericPretty License: BSD
ghc-core
- Ebuilds: 1, Testing: 0.5.6 Description:
A convenient command line wrapper for GHC that displays
GHC's optimised core and assembly output in a human
readable, colourised manner, in a pager. Unix systems
only, currently.
Usage:
> ghc-core A.hs
> ghc-core -fvia-C -optc-O3 A.hs
Screenshot: <http://galois.com/~dons/images/ghc-core.png>
Homepage:https://github.com/shachaf/ghc-core License: BSD
ghc-datasize
- Ebuilds: 1, Testing: 0.2.7 Description:
ghc-datasize is a tool to determine the size of data
structures in GHC's memory. Determining the size of
recursive data structures is supported. All sizes are in
Bytes.
Homepage:https://dennis.felsing.org/ghc-datasize/ License: BSD
ghc-debug-stub
- Ebuilds: 1, Testing: 0.6.0.0 Description: Functions for instrumenting your application so the heap can be analysed with ghc-debug-common
Homepage:https://gitlab.haskell.org/ghc/ghc-debug License: BSD
ghci-pretty
- Ebuilds: 1, Testing: 0.0.2 Description:
A tiny package that combines the ipprint package and
the hscolour package to provide colored pretty-printing
in ghci.
Homepage:https://github.com/larskuhtz/ghci-pretty License: MIT
ghcjs-codemirror
- Ebuilds: 1, Testing: 0.0.0.2 Description:
CodeMirror is a versatile text editor implemented in
JavaScript for the browser. It is specialized for
editing code, and comes with a number of language modes
and addons that implement more advanced editing
functionaly.
Homepage:https://github.com/ghcjs/CodeMirror License: MIT
ginger
- Ebuilds: 1, Testing: 0.10.5.2-r1 Description: An implementation of the Jinja2 template language in Haskell
Homepage:https://ginger.tobiasdammers.nl/ License: MIT
glambda
- Ebuilds: 1, Testing: 1.0.2-r1 Description:
This is an interpreter for the simply-typed lambda calculus. It is
written making heavy use of generalized algebraic datatypes (GADTs), and is
meant to serve as an example how how these GADTs can be useful. See
the GitHub repo for more information about the syntax for the language
and interpreter commands.
Homepage:https://github.com/goldfirere/glambda License: BSD
glfw
- Ebuilds: 1, Testing: 0.5.2.5 Description:
A Haskell binding for GLFW, 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://glfw.sourceforge.net>.
Homepage:http://haskell.org/haskellwiki/GLFW License: BSD
gloss
- Ebuilds: 1, Testing: 1.13.2.2 Description:
Gloss hides the pain of drawing simple vector graphics behind a nice data type and
a few display functions. Gloss uses OpenGL under the hood, but you won't need to
worry about any of that. Get something cool on the screen in under 10 minutes.
Homepage:http://gloss.ouroborus.net License: MIT
gloss-juicy
- Ebuilds: 1, Testing: 0.2.3 Description:
Lets you convert any image supported by Juicy.Pixels in a gloss application by converting to gloss' Bitmap representation.
Version 0.1.2 just enabled caching (from a frame to the next, and so on) of the images you load, so that they are not recomputed for each frame. Credits go to Jonathan Daugherty for the patch.
Homepage:https://github.com/hpacheco/gloss-juicy License: BSD
goa
- Ebuilds: 1, Testing: 3.3 Description:
Offers an interface to be able to call Lambdabot commands within GHCi. Now works with recent lambdabots.
Homepage:https://hackage.haskell.org/package/goa License: BSD
graphmod
- Ebuilds: 1, Testing: 1.4.5.1 Description:
This package contains a program that computes .dot graphs
from the dependencies of a number of Haskell modules.
Homepage:https://github.com/yav/graphmod/wiki License: BSD
groom
- Ebuilds: 1, Testing: 0.1.2.1 Description:
Automatically derived Show instances are an easy way
to inspect data in your program. However, for large
data-structures, the resulting output lacks
whitespace, making it unreadable. Groom offers an
replacement to `show' called `groom' which attempts
to pretty-print the output of `show'. For example:
> let x = parseExp "foobar 1 [1,2]"
> in do
> putStrLn (show x)
> putStrLn (groom x)
results in:
> ParseOk (App (App (Var (UnQual (Ident "foobar"))) (Lit (Int 1))) (List [Lit (Int 1),Lit (Int 2)]))
> ParseOk
> (App (App (Var (UnQual (Ident "foobar"))) (Lit (Int 1)))
> (List [Lit (Int 1), Lit (Int 2)]))
Groom works only on Show instances that output valid
Haskell code; if Groom can't understand its input,
it will not make any changes.
Homepage:https://hackage.haskell.org/package/groom License: BSD
gtk-traymanager
- Ebuilds: 1, Testing: 1.0.1 Description:
This package provides a wrapper around the prolific eggtraymanager code.
Note that it is *NOT* itself a system tray widget, though it is a very
convenient utility for implementing one. This package adopts the style
of gtk2hs and is designed to work well with it.
Changes in 0.1.3: Remove an unnecessary include
Changes in 0.1.2: depend on gtk 0.12.1 to build with ghc 7.2
Homepage:https://github.com/travitch/gtk-traymanager License: LGPL-2.1
happraise
- Ebuilds: 1, Testing: 0.1-r1 Description:
A small program for counting the comments in the haskell source files of
a project. It can work recursively over directories and/or over a list
of given files. For example one can run: "happraise $(darcs query manifest)".
Or put this as a command in your Setup.hs file.
Homepage:https://hackage.haskell.org/package/happraise License: BSD
happstack
- Ebuilds: 1, Testing: 7.0.2-r1 Description: The haskell application server stack + code generation
Homepage:http://happstack.com License: BSD
happstack-hamlet
- Ebuilds: 1, Testing: 7.0.4-r1 Description:
Happstack is a web application development framework.
Hamlet provides HTML templates which are checked for
correctness at compile time. This package add support
for using Hamlet templates with Happstack.
Homepage:http://www.happstack.com/ License: BSD
happstack-plugins
- Ebuilds: 1, Testing: 7.0.2-r4 Description:
This library provides support for automatically recompiling and reloading modules into a running server.
Homepage:http://happstack.com License: BSD
hashing
- Ebuilds: 1, Testing: 0.1.1.0 Description: A pure haskell library implements several hash algorithms
Homepage:https://github.com/wangbj/hashing License: MIT
hashmap
- Ebuilds: 1, Testing: 1.3.3 Description:
An implementation of persistent 'Map' and 'Set' containers
based on hashing. The implementation is build on
top of 'Data.IntMap.IntMap' and 'Data.IntSet.IntSet',
with very similar API. It uses 'Hashable' class from the
@hashable@ package for hashing.
This package can be used as a drop-in replacement for
'Data.Map' and 'Data.Set' modules.
The @'Map' key value@ is an 'Data.IntMap.IntMap'
indexed by the hash value, containing either one ('key', 'value')
or a @'Data.Map.Map' key value@ for all keys with the same hash value.
The @'Set' elem@ is an 'Data.IntMap.IntMap' indexed by
the hash value, containing either one 'elem' or @'Data.Set.Set' elem@ for
all elements with the same hash value.
Homepage:https://github.com/foxik/hashmap License: BSD
hashring
- Ebuilds: 1, Testing: 0.0.0 Description:
An efficient implementation of consistent hashing. See the documentation for
@Data.HashRing@ for more info.
Homepage:https://github.com/mkscrg/hashring License: BSD
haskakafka
- Ebuilds: 1, Testing: 1.2.0 Description:
Apache Kafka bindings backed by the librdkafka
C library. This implies full consumer and producer
support for Kafka 0.9.x.
Homepage:https://github.com/cosbynator/haskakafka License: MIT
haskell-mpi
- Ebuilds: 1, Testing: 1.4.0 Description:
MPI is defined by the Message-Passing Interface Standard,
as specified by the Message Passing Interface Forum. The latest release
of the standard is known as MPI-2. These Haskell
bindings are designed to work with any standards compliant
implementation of MPI-2. Examples are MPICH2:
<http://www.mcs.anl.gov/research/projects/mpich2> and
OpenMPI: <http://www.open-mpi.org>.
In addition to reading these documents, users may also find it
beneficial to consult the MPI-2 standard documentation provided by the
MPI Forum: <http://www.mpi-forum.org>, and also the documentation for
the MPI implementation linked to this library (that is, the MPI
implementation that was chosen when this Haskell library was compiled).
"Control.Parallel.MPI.Fast" contains a high-performance interface
for working with (possibly mutable) arrays of storable Haskell data types.
"Control.Parallel.MPI.Simple" contains a convenient (but slower)
interface for sending arbitrary serializable Haskell data values as messages.
"Control.Parallel.MPI.Internal" contains a direct binding to the
C interface.
"Control.Parallel.MPI.Base" contains essential MPI functionality
which is independent of the message passing API. This is re-exported
by the Fast and Simple modules, and usually does not need to be
explcitly imported itself.
Notable differences between Haskell-MPI and the standard C interface to MPI:
1. Some collective message passing operations are split into send
and receive parts to facilitate a more idiomatic Haskell style of programming.
For example, C provides the @MPI_Gather@ function which is called
by all processes participating in the communication, whereas
Haskell-MPI provides 'gatherSend' and 'gatherRecv' which are called
by the sending and receiving processes respectively.
2. The order of arguments for some functions is changed to allow
for the most common patterns of partial function application.
3. Errors are raised as exceptions rather than return codes (assuming
that the error handler to 'errorsThrowExceptions', otherwise errors
will terminate the computation just like C interface).
Below is a small but complete MPI program. Process 1 sends the message
@\"Hello World\"@ to process 0, which in turn receives the message and
prints it to standard output. All other processes, if there are any,
do nothing.
>module Main where
>
>import Control.Parallel.MPI.Simple (mpiWorld, commWorld, unitTag, send, recv)
>
>main :: IO ()
>main = mpiWorld $ \size rank ->
> if size < 2
> then putStrLn "At least two processes are needed"
> else case rank of
> 0 -> do (msg, _status) <- recv commWorld 1 unitTag
> putStrLn msg
> 1 -> send commWorld 0 unitTag "Hello World"
> _ -> return ()
Homepage:https://github.com/bjpop/haskell-mpi License: BSD
haskell-qrencode
- Ebuilds: 1, Testing: 1.0.4 Description:
Haskell bindings for libqrencode.
Libqrencode is a C library for encoding data in a QR Code symbol, a kind of 2D symbology
that can be scanned by handy terminals such as a mobile phone with CCD. The capacity of
QR Code is up to 7000 digits or 4000 characters, and is highly robust.
Homepage:https://github.com/jamessanders/haskell-qrencode License: BSD
haskell-src
- Ebuilds: 1, Testing: 1.0.3.1 Description:
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.
Homepage:https://hackage.haskell.org/package/haskell-src License: BSD
haskell-src-exts-simple
- Ebuilds: 1, Testing: 1.23.1.0 Description:
This package provides a shim for haskell-src-exts (HSE), exposing the
same AST but without annotations, using ghc's pattern synonyms.
See README.md for further information and compatibility considerations.
Homepage:https://github.com/int-e/haskell-src-exts-simple License: MIT
hclip
- Ebuilds: 1, Testing: 3.0.0.4 Description:
A small cross-platform library for reading and modifying the system clipboard.
Hclip works on Windows, Mac OS X and Linux (but see the requirements below!).
Requirements:
* Windows: No additional requirements.
* Mac OS X: Requires the pbcopy and pbpaste commands, which ship with Mac OS X.
* Linux: Requires xclip or xsel installed.
Homepage:https://github.com/jetho/Hclip License: BSD
hcodecs
- Ebuilds: 1, Testing: 0.5.2 Description:
The library provides functions to read, write and manipulate MIDI, WAVE and
SoundFont2 multimedia files. It is written entirely in Haskell (without any
FFI). It uses efficient parsing and building combinators for binary data
stored in ByteStrings (based on the one in 'binary' package).
Correctness of significant parts of the library has been validated with
QuickCheck and Haskell Program Coverage (HPC) tool-kits.
Homepage:http://www-db.informatik.uni-tuebingen.de/team/giorgidze License: BSD
hdbc
- Ebuilds: 1, Testing: 2.4.0.4 Description:
HDBC provides an abstraction layer between Haskell programs and SQL
relational databases. This lets you write database code once, in
Haskell, and have it work with any number of backend SQL databases
(MySQL, Oracle, PostgreSQL, ODBC-compliant databases, etc.)
Homepage:https://github.com/hdbc/hdbc License: BSD
hdbc-mysql
- Ebuilds: 1, Testing: 0.7.1.0-r1 Description:
This package provides a MySQL driver for HDBC, implemented via
bindings to the C @mysqlclient@ library.
Homepage:https://github.com/ryantm/hdbc-mysql License: LGPL-2.1
hdfa
- Ebuilds: 1, Testing: 0.0.2 Description:
hDFA provides a simple API for representing and minimizing
deterministic finite automata (DFAs) using an explicit representation
(a list of transitions). It includes a port of Antti Valmari's
efficient DFA minimization algorithm from C++ to C. (See A. Valmari,
"Fast brief practical DFA minimization" Information Processing
Letters 112(6) 2012.)
Homepage:https://hackage.haskell.org/package/hDFA License: BSD
hedis
- Ebuilds: 1, Testing: 0.15.2 Description: Client library for the Redis datastore: supports full command set, pipelining
Homepage:https://github.com/informatikr/hedis License: BSD
hedis-config
- Ebuilds: 1, Testing: 1.0.0 Description:
Datatype to parse redis connection settings from file like
> host: localhost # host name or address
> port: 6379 # you can specify either port
> # socket: /run/redis.socket # or unix socket path
> # service: redis # or service name
> password: "pass" # if not specified then no password used
> database: 0 # database number to connect to
> max-connections: 5 # max connections in pool
> max-idle-time: 30 # keep connection open for 30 seconds
> timeout: 30 # connection timeout
Homepage:https://bitbucket.org/s9gf4ult/hedis-config License: BSD
heist
- Ebuilds: 1, Testing: 1.1.1.2 Description: An Haskell template system supporting both HTML5 and XML
Homepage:https://snapframework.com/ License: BSD
here
- Ebuilds: 1, Testing: 1.2.14 Description: Here docs & interpolated strings via quasiquotation
Homepage:https://github.com/tmhedberg/here License: BSD
hflags
- Ebuilds: 1, Testing: 0.4.3 Description:
The @HFlags@ library supports easy definition of command line flags,
reimplementing the ideas from Google's @gflags@
(<http://code.google.com/p/gflags>).
Command line flags can be declared in any file at the toplevel,
using 'defineFlag'. At runtime, the actual values are assigned to
the toplevel @flags_name@ constants. Those can be used purely
throughout the program.
At the beginning of the @main@ function, @$initHFlags \"program
description\"@ has to be called to initialize the flags. All flags
will be initialized that are transitively reachable via imports from
@main@. This means, that any Haskell package can easily define
command line flags with @HFlags@. This feature is demonstrated by
<http://github.com/errge/hflags/blob/master/examples/ImportExample.hs>
and <http://github.com/errge/hflags/tree/master/examples/package>.
A simple example (more in the
<http://github.com/errge/hflags/tree/master/examples> directory):
@
\#!\/usr\/bin\/env runhaskell
&#x7b;-\# LANGUAGE TemplateHaskell \#-&#x7d;
import HFlags
'defineFlag' \"name\" \"Indiana Jones\" \"Who to greet.\"
'defineFlag' \"r:repeat\" (3 + 4 :: Int) \"Number of times to repeat the message.\"
main = do s <- $initHFlags \"Simple program v0.1\"
&#x20; sequence_ $ replicate flags_repeat greet
&#x20; putStrLn $ \"Your additional arguments were: \" ++ show s
&#x20; putStrLn $ \"Which is the same as: \" ++ show HFlags.arguments
&#x20; where
&#x20; greet = putStrLn $ \"Hello \" ++ flags_name ++ \", very nice to meet you!\"
@
At @initHFlags@ time, the library also tries to gather flags out of
environment variables. @HFLAGS_verbose=True@ is equivalent to
specify --verbose=True. This environment feature only works with
long options and the user has to specify a value even for Bools.
/Since version 0.2, you mustn't put the initHFlags in a parentheses with the program description. Just/ @$initHFlags@, /it's cleaner./
See <http://github.com/errge/hflags/tree/master/changelog> for recent changes.
Homepage:https://github.com/errge/hflags License: Apache-2.0
hgamer3d
- Ebuilds: 1, Testing: 0.9.5 Description: Toolset for the Haskell Game Programmer
Homepage:http://www.hgamer3d.org License: Apache-2.0
hgdbmi
- Ebuilds: 1, Testing: 0.2-r1 Description:
GDB\/MI lets programs drive GDB. It can be used, for example, by GDB
frontends. See section 27 of the GDB manual
This module encapsualtes a GDB subprocess and provides an API to send
commands as well as receive both responses and notifications.
The actual GDB behavior diverges from the GDB manual in many points, so the
implementation of the Machine Interface highly depends on the GDB version.
This module is tested with GDB version 7.4.
Homepage:https://github.com/copton/hgdbmi License: BSD
hgl
- Ebuilds: 1, Testing: 3.2.3.2 Description:
A simple graphics library, designed to give the programmer access
to most interesting parts of the Win32 Graphics Device Interface
and X11 library without exposing the programmer to the pain and
anguish usually associated with using these interfaces.
The library also includes a module Graphics.SOE providing the
interface used in "The Haskell School of Expression", by Paul
Hudak, cf <http://www.haskell.org/soe/>.
Homepage:https://hackage.haskell.org/package/HGL License: BSD
highlighter
- Ebuilds: 1, Testing: 0.2.2-r1 Description:
Processes source code using tons of lexers, tokenizing it and formatting it as e.g. HTML.
Very similar to the Python Pygments library; many lexers directly converted from it.
Homepage:https://hackage.haskell.org/package/highlighter License: BSD
hint
- Ebuilds: 1, Testing: 0.9.0.8-r1 Description: A Haskell interpreter built on top of the GHC API
Homepage:https://github.com/haskell-hint/hint License: BSD
hip
- Ebuilds: 1, Testing: 1.5.6.0 Description:
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 various color spaces or provide implementations for underlying array like custom data structures.
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.
Homepage:https://github.com/lehins/hip License: BSD
hjavascript
- Ebuilds: 1, Testing: 0.4.7 Description:
HJavaScript defines an abstract syntax and pretty printer for
a subset of JavaScript. as Language.HJavaScript. However, a significant
difference from JavaScript is that HJavaScript is typed, even on the
abstract syntax level using GADTs. The subset of JavaScript that is
supported is those parts that lend themself to typing
(i.e. no prototyping of classes).
Homepage:https://hackage.haskell.org/package/HJavaScript License: BSD
hjsmin
- Ebuilds: 1, Testing: 0.2.1 Description: Haskell implementation of a javascript minifier
Homepage:https://github.com/erikd/hjsmin License: BSD
hledger-lib
- Ebuilds: 2, Testing: 1.50.2 Description: A library providing the core functionality of hledger
Homepage:https://hledger.org License: GPL-3+
hlibsass
- Ebuilds: 1, Testing: 0.1.10.1 Description:
This package provides (very) low level bindings to LibSass. By default, it
uses LibSass compiled as a static library, so if you use this in your project,
you have to link your project with C++ runtime (which hLibsass does
automatically - links with /libstdc++/).
For documentation visit <https://github.com/sass/libsass>.
Homepage:https://github.com/jakubfijalkowski/hlibsass License: MIT
hmatrix-gsl-stats
- Ebuilds: 1, Testing: 0.4.1.8 Description:
Purely functional interface for statistics based on hmatrix and GSL
Relieves the burden of alloc/free routines and is otherwise essentially 1:1
Documentation can be found at <http://www.gnu.org/software/gsl/manual/>
The vector type is Data.Vector.Storable from the 'vector' package.
Homepage:http://code.haskell.org/hmatrix-gsl-stats License: BSD
hmatrix-vector-sized
- Ebuilds: 1, Testing: 0.1.3.0 Description:
Conversions between statically sized types in hmatrix and vector-sized.
See README on Github <https://github.com/mstksg/hmatrix-vector-sized#readme>
Homepage:https://github.com/mstksg/hmatrix-vector-sized#readme License: BSD
hogg
- Ebuilds: 1, Testing: 0.4.1.2 Description:
The HOgg package provides a commandline tool for manipulating Ogg files.
It supports chained and multiplexed Ogg bitstreams and Ogg Skeleton.
HOgg also includes a library that may be used by other packages for handling
the Ogg container format.
Homepage:http://www.kfish.org/software/hogg/ License: BSD
hookup
- Ebuilds: 1, Testing: 0.8 Description: Abstraction over creating network connections with SOCKS5 and TLS
Homepage:https://github.com/glguy/irc-core License: ISC
hoopl
- Ebuilds: 1, Testing: 3.10.2.2 Description:
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.
Homepage:https://github.com/haskell/hoopl License: BSD
hs-bibutils
- Ebuilds: 1, Testing: 6.8.0.0 Description:
Haskell bindings to Chris Putnam's bibutils, a
library that interconverts between various
bibliography formats using a common MODS-format
XML intermediate.
Homepage:https://github.com/wilx/hs-bibutils License: GPL-2
hs3
- Ebuilds: 1, Testing: 0.5.9-r1 Description:
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.
Homepage:http://gregheartsfield.com/hS3/ License: BSD
hsass
- Ebuilds: 1, Testing: 0.8.0 Description:
This package provides quite simple (but not too simple) API for
compilation of <http://sass-lang.com/ Sass> code. It uses
<http://libsass.org libsass> (hlibsass) underneath, so the code it
parses/generates should be compatible with original Sass implementation (or at
least <http://libsass.org/#sassc sassc>).
This package tries to minimize C API usage, so the only place where it is used
is in the 'compileFile' / 'compileString' methods. This allows us to stay pure
as long as we can and not waste performance for going back and forth.
If you feel that compilation options constrain you too much, you may use rest
of modules without it. With them, you can use Haskell types and mechanisms to
manage libsass's data(eg. importers, options, values) and modify compilation
process as you like.
Homepage:https://github.com/jakubfijalkowski/hsass License: MIT
hscrtmpl
- Ebuilds: 1, Testing: 1.6 Description:
A template for writing shell scripts in Haskell. Contains some useful functions and examples of things commonly done in bash.
Homepage:https://github.com/dino-/hscrtmpl#readme License: ISC
hscurses
- Ebuilds: 1, Testing: 1.4.2.0 Description:
Binding to NCurses, a library of functions that manage an
application's display on character-cell terminals. Additionally,
it contains some basic widgets such as a text input widget and
a table widget.
Homepage:https://github.com/skogsbaer/hscurses License: LGPL-2.1
hsh
- Ebuilds: 1, Testing: 2.1.3 Description:
HSH is designed to let you mix and match shell expressions with
Haskell programs. With HSH, it is possible to easily run shell
commands, capture their output or provide their input, and pipe them
to and from other shell commands and arbitrary Haskell functions at will.
Category: System
Homepage:http://software.complete.org/hsh License: LGPL-2.1
hsndfile-vector
- Ebuilds: 1, Testing: 0.5.2 Description:
Haskell bindings for libsndfile (@Data.Vector@ interface).
For more information on /hsndfile/ visit its homepage at <http://haskell.org/haskellwiki/Hsndfile>.
Homepage:http://haskell.org/haskellwiki/Hsndfile License: LGPL-2
hspec-meta
- Ebuilds: 1, Testing: 2.11.16 Description: A version of Hspec which is used to test Hspec itself
Homepage:https://hspec.github.io/ License: MIT
hstatistics
- Ebuilds: 1, Testing: 0.2.5.4 Description:
Purely functional interface for statistics based on hmatrix and hmatrix-gsl-stats
The vector type is Data.Vector.Storable from the 'vector' package and compatible with the 'statistics' package.
<http://hackage.haskell.org/package/statistics>
Feature requests, suggestions, and bug fixes welcome.
Homepage:http://code.haskell.org/hstatistics License: BSD
hsyslog
- Ebuilds: 1, Testing: 5.0.2 Description:
This library provides FFI bindings to syslog(3) from POSIX.1-2001.
See <http://www.opengroup.org/onlinepubs/009695399/basedefs/syslog.h.html> for
further details.
Homepage:https://github.com/peti/hsyslog License: BSD
html-conduit
- Ebuilds: 1, Testing: 1.3.2.2-r1 Description:
This package uses tagstream-conduit for its parser. It automatically balances mismatched tags, so that there shouldn't be any parse failures. It does not handle a full HTML document rendering, such as adding missing html and head tags.
Homepage:https://github.com/snoyberg/xml License: MIT
htoml
- Ebuilds: 1, Testing: 1.0.0.3-r1 Description:
TOML is an obvious and minimal format for config files.
This package provides a TOML parser,
build with the Parsec library, and providing a JSON
interface using the Aeson library.
Homepage:https://github.com/cies/htoml License: BSD
http-client-openssl
- Ebuilds: 1, Testing: 0.3.0.0 Description:
Hackage documentation generation is not reliable. For up to date documentation, please see: <http://www.stackage.org/package/http-client>.
Homepage:https://github.com/snoyberg/http-client License: MIT
http-conduit
- Ebuilds: 1, Testing: 2.3.9.1-r1 Description:
This package uses attoparsec for parsing the actual contents of the HTTP connection. It also provides higher-level functions which allow you to avoid direct usage of conduits. See <http://www.yesodweb.com/book/http-conduit> for more information.
Homepage:https://github.com/snoyberg/http-client License: BSD
http-media
- Ebuilds: 1, Testing: 0.8.1.1 Description:
This library is intended to be a comprehensive solution to parsing and
selecting quality-indexed values in HTTP headers. It is capable of parsing
both media types and language parameters from the Accept and Content header
families, and can be extended to match against other accept headers as well.
Selecting the appropriate header value is achieved by comparing a list of
server options against the quality-indexed values supplied by the client.
In the following example, the Accept header is parsed and then matched against
a list of server options to serve the appropriate media using
'mapAcceptMedia':
> getHeader >>= maybe send406Error sendResourceWith . mapAcceptMedia
> [ ("text/html", asHtml)
> , ("application/json", asJson)
> ]
Similarly, the Content-Type header can be used to produce a parser for request
bodies based on the given content type with 'mapContentMedia':
> getContentType >>= maybe send415Error readRequestBodyWith . mapContentMedia
> [ ("application/json", parseJson)
> , ("text/plain", parseText)
> ]
The API is agnostic to your choice of server.
Homepage:https://github.com/zmthy/http-media License: MIT
http-reverse-proxy
- Ebuilds: 1, Testing: 0.6.2.0 Description:
Provides a simple means of reverse-proxying HTTP requests. The raw approach uses the same technique as leveraged by keter, whereas the WAI approach performs full request/response parsing via WAI and http-conduit.
Homepage:https://github.com/fpco/http-reverse-proxy License: BSD
huffman
- Ebuilds: 1, Testing: 1.0.1 Description:
A simple and pure Haskell implementation of the Huffman encoding
algorithm.
The @huffman@ function provides the original O(n log n) algorithm
implemented with a priority queue. If the input symbols are sorted
by probability, the O(n) @huffmanSorted@ function can be used instead.
Homepage:https://hackage.haskell.org/package/huffman License: BSD
hxt
- Ebuilds: 1, Testing: 9.3.1.22 Description: A collection of tools for processing XML with Haskell
Homepage:https://github.com/UweSchmidt/hxt License: MIT
hxt-http
- Ebuilds: 1, Testing: 9.1.5.2-r1 Description:
Interface to native Haskell HTTP package HTTP.
This package can be used as alternative for the hxt-curl package
for accessing documents via HTTP.
Changes to 9.1.3: New warnings from ghc-7.4 removed
Homepage:https://github.com/UweSchmidt/hxt License: MIT
hxt-unicode
- Ebuilds: 1, Testing: 9.0.2.4 Description: Unicode en-/decoding functions for utf8, iso-latin-* and other encodings
Homepage:https://github.com/UweSchmidt/hxt License: MIT
ieee754
- Ebuilds: 1, Testing: 0.8.0-r1 Description:
Utilities for dealing with IEEE floating point numbers, ported from the Tangoi
math library; approximate and exact equality comparisons for general types.
Homepage:https://github.com/patperry/hs-ieee754 License: BSD
ilist
- Ebuilds: 1, Testing: 0.4.0.1 Description: Optimised list functions for doing index-related things
Homepage:https://github.com/kowainik/ilist License: MPL-2.0
imagesize-conduit
- Ebuilds: 1, Testing: 1.1-r1 Description:
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.
Homepage:https://github.com/silkapp/imagesize-conduit License: BSD
indexed-list-literals
- Ebuilds: 1, Testing: 0.2.1.3 Description:
This is an incredibly simple library, which makes writing lists where the length is known at compile time a little bit nicer.
If you write a function with the signature
> vector :: ILL input length output => input -> Vector length output
then
> v :: Vector 3 Int
> v = vector (1,2,3)
>
> x :: Vector 0 Double
> x = vector $ ZeroTuple @Double
>
> y :: Vector 1 Double
> y = vector (Only 1)
>
> z :: Vector 2 String
> z = vector ("Hello", "World")
If want matrix literals you can write a function
> matrix :: (ILL row width ty, ILL matrix height row) => matrix -> Matrix width height ty
then
> a :: Matrix 0 0 Bool
> a = matrix $ ZeroTuple @(ZeroTuple Bool)
>
> b :: Matrix 1 2 String
> b = matrix $ Only ("Hello","World")
>
> c :: Matrix 4 5 Double
> c = matrix ((1,2,3,0,0)
> ,(4,5,6,0,0)
> ,(7,8,9,0,0)
> ,(0,0,0,0,0))
The full code is in test\/Docs.hs
This only supports literals of length up to 20, though that can be easily extended using the code generator in src\/Data\/IndexedListLiterals.hs
Homepage:https://github.com/davidm-d/indexed-list-literals License: BSD
io-string-like
- Ebuilds: 1, Testing: 0.1.0.1 Description:
The functions in the Prelude such as "getContents", "putStr" only work for plain Strings.
There are similar functions in "ByteString" for reading and writing, as well as \"Text\".
This requires one to import the appropriate functions, usually qualified, for the particular datatype one is using. Changing the datatype at the very least involves changing import statements across your program.
The package introduces classes to overload functions like "getContents", "putStr" over multiple datatypes, so implementations can be changed easily.
All the code documentation is in "System.IO.StringLike.Impl".
All the other modules are just re-exports.
Homepage:https://github.com/clintonmead/io-string-like#readme License: BSD
ipython-kernel
- Ebuilds: 1, Testing: 0.11.0.0 Description:
ipython-kernel is a library for communicating with frontends for the interactive IPython framework. It is used extensively in IHaskell, the interactive Haskell environment.
Homepage:https://github.com/gibiansky/IHaskell License: MIT
iso3166-country-codes
- Ebuilds: 1, Testing: 0.20140203.8 Description:
Defines datatype CountryCode that has a two
letter constructor corresponding to each of the two letter
ISO 3166 country codes, and mappings from that type to the
official name of the country.
Homepage:https://hackage.haskell.org/package/iso3166-country-codes License: LGPL-2.1
iso8601-time
- Ebuilds: 1, Testing: 0.1.5 Description:
Conversion functions between Haskell time types and the ISO 8601 format,
which is often used for printing times, e.g. JavaScript's @new Date().toISOString()@.
CHANGELOG
Version 0.1.0
* Initial version.
Homepage:https://github.com/nh2/iso8601-time License: MIT
ix-shapable
- Ebuilds: 1, Testing: 0.1.0 Description:
Reshape multi-dimensional arrays.
Provides the 'Shapable' class, respresenting those
instances of 'Ix' that provide to arrays indexing
that is isomorphic to that of C-style
multi-dimensional arrays.
Factored out of the 'carray' library with the kind
permission of its author.
Homepage:https://hackage.haskell.org/package/ix-shapable License: BSD
jail
- Ebuilds: 1, Testing: 0.0.1.1-r4 Description:
Like all of us know, the IO monad from the System.IO module
is a wild beast allowing all forms of insecure computations
that can read, or even worse, alter /the real world/. Writing
to sockets, deleting files or even launching missiles, its
possibilities are endless. This library provides a special
IO module that wraps all file and handle based IO operations
from the System.IO module, but provides a possibility to run
them in an restricted environment. When running a jailed IO
computation a file path can be specified all IO operations
will be checked against. Accessing files outside this
directory is not allowed and results in a runtime error.
Additionally, when running a jailed IO computation a
whitelist of file handles can be specified that are
accessible as well.
For example, running some code with the permission to access
all files within (and only within) my home directory and
allowing to access the standard output and standard error can
be enforced like this:
> Jail.run (Just "/home/sebas") [stdout, stderr] yourUntrustworthyComputation
Only allowing the code to access the standard input and
nothing else can be enforced like this:
> Jail.run Nothing [stdin] yourEvenMoreUntrustworthyComputation
Because the jailed IO environment keeps track of all file
handles and checks that are opened by its own operations,
smuggling in evil file handles from the fierce and dangerous
outside world will be punished by border patrol. Only handles
from the whitelist or handles securely opened by functions
like `openFile' will be accepted. Because of the opaque IO
constructor and the restricted set of exported operations
this module is not easily fooled.
I would almost dare to say this module is conceptually safe
and code with the jailed IO type can blindly be trusted.
Except, yes unfortunately except, @unsafePerformIO@ ruins it
all. I would almost suggest adding a flag to the compiler to
enforce the absence of @unsafeRuinMyTypeSafety@-alike
functions in order to be able to create systems in which code
can be trusted by its type alone.
Nonetheless, this module is one step forward in trusting your
own programs. Some real <http://tinyurl.com/paranoidpeople>
prefer writing their software in one of the most insecure
programming languages and perform security audits by hand,
I'd rather have my compiler do the job. (Anyone who wants to
audit this library is more than welcome!)
Homepage:https://hackage.haskell.org/package/jail License: BSD
js-dgtable
- Ebuilds: 1, Testing: 0.5.2 Description:
This package bundles the minified <https://github.com/danielgindi/jquery.dgtable jquery.dgtable> code into a Haskell package,
so it can be depended upon by Cabal packages. The first three components of
the version number match the upstream jquery.dgtable version. The package is designed
to meet the redistribution requirements of downstream users (e.g. Debian).
Homepage:https://github.com/ndmitchell/js-dgtable#readme License: MIT
json
- Ebuilds: 1, Testing: 0.10 Description:
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.
Homepage:https://hackage.haskell.org/package/json License: BSD
jsonb
- Ebuilds: 1, Testing: 1.0.8-r1 Description:
This parser consumes lazy ByteStrings to produce JSON in a simple, efficient
format backed with strict ByteStrings, Rationals and ByteString tries. See
the schema generation tools and the command line JSON schema generator (in
the examples subdir) for an example of how to use the parsing tools.
Have you considered @aeson@ (<http://hackage.haskell.org/package/aeson>), a
newer, extensively benchmarked JSON parsing library?
Homepage:https://github.com/solidsnack/JSONb/ License: BSD
kinds
- Ebuilds: 1, Testing: 0.0.1.5 Description:
Subkinds are the kind-level analog to subtypes. A kind denotes a set of types, and a
subkind of some base kind denotes a subset of the base kind&#x2019;s set of types.
Haskell has no support for subkinds and subkind polymorphism. However, this package
can be used to emulate subkinds of kind&#xA0;@*@ and subkind variables.
To define a new subkind, the user declares a type that represents the subkind, and
instantiates some classes. Afterwards, the user can declare types to be of that
subkind and universally quantify over the inhabitants of the subkind. Since subkinds
are represented by types, type-level polymorphism can be used to emulate kind-level
polymorphism.
For detailed information, please refer to Section&#xA0;6 of the paper
/Generic Record Combinators with Static Type Checking/.
Homepage:http://darcs.wolfgang.jeltsch.info/haskell/kinds License: BSD
lambdabot-novelty-plugins
- Ebuilds: 1, Testing: 5.3.1.2 Description:
Lambdabot is an IRC bot written over several years by
those on the #haskell IRC channel.
Provided plugins:
[bf] Run Brainf*ck code.
[dice] Roll some dice.
[elite] zPEak Gib8erI$|-|.
[filter] More gibberish.
[numberwang] Sorry, that's not Numberwang.
[quote] Parrot profound wisdom.
[slap] Delegate punishment.
[unlambda] Run Unlambda code.
[vixen] Let's chat, honey.
Homepage:https://wiki.haskell.org/Lambdabot License: GPL-2
lambdabot-social-plugins
- Ebuilds: 1, Testing: 5.3.1.2 Description:
Lambdabot is an IRC bot written over several years by
those on the #haskell IRC channel.
Provided plugins:
[activity] Check where and how much is lambdabot used.
[karma] Track who's been good and who's been naughty.
[poll] Let the people vote.
[seen] Track who was around when.
[tell] Leave messages for other users.
Homepage:https://wiki.haskell.org/Lambdabot License: GPL-2
lambdabot-trusted
- Ebuilds: 1, Testing: 5.3 Description:
Lambdabot is an IRC bot written over several years by
those on the #haskell IRC channel.
This small package provides functions used by
the \@run command.
Homepage:https://wiki.haskell.org/Lambdabot License: GPL-2
language-glsl
- Ebuilds: 1, Testing: 0.3.0 Description:
The package language-glsl is a Haskell library for the
representation, the parsing, and the pretty-printing of
GLSL 1.50 code.
Homepage:https://hackage.haskell.org/package/language-glsl License: BSD
latex
- Ebuilds: 1, Testing: 0.1.0.4 Description:
Currently the package only provides
conversion between LaTeX escape sequences and Unicode characters.
It is used in the @bibtex@ package.
In the future we might add support
for formatting Haskell values in LaTeX markup
for automated report generation.
See the packages @HaTeX@ for LaTeX document generation
and @pandoc@ for document analysis and generation in multiple markup languages.
Homepage:https://www.haskell.org/haskellwiki/LaTeX License: BSD
lattices
- Ebuilds: 1, Testing: 2.2.1 Description: Fine-grained library for constructing and manipulating lattices
Homepage:https://github.com/phadej/lattices/ License: BSD
lazysmallcheck
- Ebuilds: 1, Testing: 0.6-r1 Description:
Lazy SmallCheck is a library for exhaustive, demand-driven testing of
Haskell programs. It is based on the idea that if a property holds
for a partially-defined input then it must also hold for all
fully-defined refinements of the that input. Compared to ``eager''
input generation as in SmallCheck, Lazy SmallCheck may require
significantly fewer test-cases to verify a property for all inputs up
to a given depth.
Homepage:http://www.cs.york.ac.uk/~mfn/lazysmallcheck/ License: BSD
lenses
- Ebuilds: 1, Testing: 0.1.8 Description:
A simple but powerful implementation of function lenses (aka functional
references, accessors, etc..).
They allow an easy way to manipulate fields of records
Homepage:https://github.com/jvranish/Lenses/tree/master License: BSD
libnotify
- Ebuilds: 1, Testing: 0.2.1 Description:
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
Homepage:https://hackage.haskell.org/package/libnotify License: MIT
libtagc
- Ebuilds: 1, Testing: 0.12.0-r1 Description:
TagLib is a library for reading and editing the meta-data of several popular audio formats.
Currently it supports both ID3v1 and ID3v2 for MP3 files, Ogg Vorbis comments and ID3 tags
and Vorbis comments in FLAC, MPC, Speex, WavPack and TrueAudio files.
Homepage:https://patch-tag.com/r/AndyStewart/libtagc/home License: LGPL-2.1
libzip
- Ebuilds: 1, Testing: 1.0.1 Description:
libzip is a C library for reading, creating, and modifying zip archives.
This package allows to use it from Haskell code.
Homepage:http://bitbucket.org/astanin/hs-libzip/ License: BSD
listsafe
- Ebuilds: 1, Testing: 0.1.0.1 Description:
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.
Homepage:https://github.com/ombocomp/listsafe License: Apache-2.0
lmdb
- Ebuilds: 1, Testing: 0.2.5 Description:
LMDB is a read-optimized Berkeley DB replacement developed by Symas
for the OpenLDAP project. LMDB has impressive performance characteristics
and a friendly BSD-style OpenLDAP license. See <http://symas.com/mdb/>.
This library has Haskell bindings to the LMDB library. You must install
the lmdb development files before installing this library,
e.g. `sudo apt-get install liblmdb-dev` works for Ubuntu 14.04.
For now, only a low level interface is provided, and the author is moving
on to use LMDB rather than further develop its bindings. If a higher level
API is desired, please consider contributing, or develop a separate package.
Homepage:https://github.com/dmbarbour/haskell-lmdb License: BSD-2
load-env
- Ebuilds: 1, Testing: 0.2.1.0 Description:
Parse a .env file and load any declared variables into
the current process's environment. This allows for a
.env file to specify development-friendly defaults for
configuration values normally set in the deployment
environment.
Homepage:https://github.com/pbrisbin/load-env#readme License: BSD
located-base
- Ebuilds: 1, Testing: 0.1.1.1 Description:
This library provides variants of standard partial functions
that include their call-site in the error message when they crash.
For example:
@
ghci> 'Data.List.Located.head' []
*** Exception: Prelude.head: empty list
Callstack:
\ \ error, called at src\/Data\/List\/Located.hs:19:14 in locat_KhGZ7Rz1bn9DKFeFxhawNB:Data.List.Located
\ \ head, called at \<interactive\>:6:1 in interactive:Ghci1
@
Homepage:https://github.com/gridaphobe/located-base License: BSD
loch-th
- Ebuilds: 1, Testing: 0.2.2 Description:
This module provides a Template Haskell based mechanism to
tag failures with the location of the failure call. The
location message includes the file name, line and column
numbers.
Homepage:https://github.com/liskin/loch-th License: BSD
loop
- Ebuilds: 1, Testing: 0.3.0 Description:
This package provides a convenient and fast alternative to the common
`forM_ [1..n]` idiom, which in many cases GHC cannot fuse to efficient
code.
See https://ghc.haskell.org/trac/ghc/ticket/8763.
Homepage:https://github.com/nh2/loop License: MIT
lpeg
- Ebuilds: 1, Testing: 1.1.0 Description: LPeg – Parsing Expression Grammars For Lua
Homepage:https://hslua.org/ License: MIT
lrucache
- Ebuilds: 1, Testing: 1.2.0.1-r1 Description:
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.
Version History:
1.1.1 - Add an additional modification function for AtomicLRUCache.
1.1.0.1 - Update containers constraint to allow containers from ghc-7
1.1 - Add a Functor instance for LRUCache.
Add a generic modification function for AtomicLRUCache.
1.0 - Breaking API changes:
1) The newLRU smart constructor now makes the maximum
size optional.
2) The delete function now returns the value removed, if
one was.
Additionally, a function was added to remove the least-recently
used element in the LRU.
0.3 - Added a Show instance for LRU. (Requested by Ben Lee)
0.2.0.1 - Increase strictness slightly.
Remove cabal target for test executable.
(Just include test sources instead.)
0.2 - Added an Eq instance for LRU.
Added strictness to eliminate space leaks in common use patterns.
0.1.1 - Add the Data.Cache.LRU.IO.Internal module.
Clean up build warnings on GHC 6.12.1.
0.1.0.1 - Minor refactoring
0.1 - First release
Homepage:https://github.com/chowells79/lrucache License: BSD
lsp
- Ebuilds: 2, Testing: 2.7.0.1 Description: Haskell library for the Microsoft Language Server Protocol
Homepage:https://github.com/haskell/lsp License: MIT
lsp-types
- Ebuilds: 2, Testing: 2.3.0.1-r1 Description: Haskell library for the Microsoft Language Server Protocol, data types
Homepage:https://github.com/haskell/lsp License: MIT
lua
- Ebuilds: 1, Testing: 2.3.4 Description: Lua, an embeddable scripting language
Homepage:https://hslua.org/ License: MIT
lua-arbitrary
- Ebuilds: 1, Testing: 1.0.1.2 Description: Arbitrary instances for Lua types
Homepage:https://hslua.org/ License: MIT
lushtags
- Ebuilds: 2, Testing: 0.0.2_pre20250323 Description: Create ctags compatible tags files for Haskell programs
Homepage:https://github.com/bitc/lushtags License: MIT
lz4
- Ebuilds: 1, Testing: 0.2.3.1 Description:
High level bindings to the LZ4 compression library.
Currently based on lz4 r119. C sources are included and no external
dependencies are needed other than @cereal@.
Homepage:https://github.com/mwotton/lz4hs License: BSD
matrices
- Ebuilds: 1, Testing: 0.5.0 Description:
This library provide the APIs for creating, indexing,
modifying matrices (2d arrays), including dense and
sparse representations. The underling data
structure is vector.
Homepage:https://hackage.haskell.org/package/matrices License: BSD
mediawiki
- Ebuilds: 1, Testing: 0.2.6 Description:
A complete Haskell binding to the MediaWiki API letting you
programmatically access (read and write) MediaWiki content.
See <http://www.mediawiki.org/wiki/API> and <http://haskell.forkio.com/>
for more.
Homepage:https://hackage.haskell.org/package/mediawiki License: BSD
meldable-heap
- Ebuilds: 1, Testing: 2.0.3-r1 Description:
A heap is a container supporting the insertion of elements and the extraction of the minimum element. This library additionally supports melding two heaps. This library models the implementation of asymptotically optimal purely functional heaps given by Brodal and Okasaki in their paper \"Optimal Purely Functional Priority Queues\". It has been proved correct using the Coq proof assistant. The proofs are included in the Cabal package.
A description of the differences between versions of this package is available at <http://priority-queues.googlecode.com/hg/brodal-okasaki/cabal/CHANGELOG>.
Homepage:https://github.com/jbapple/priority-queues License: BSD
mersenne-random-pure64
- Ebuilds: 1, Testing: 0.2.2.0 Description:
The Mersenne twister is a pseudorandom number generator developed by
Makoto Matsumoto and Takuji Nishimura that is based on a matrix linear
recurrence over a finite binary field. It provides for fast generation
of very high quality pseudorandom numbers. The source for the C code
can be found here:
<http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt64.html>
This library provides a purely functional binding to the 64 bit
classic mersenne twister, along with instances of RandomGen, so the
generator can be used with System.Random. The generator should
typically be a few times faster than the default StdGen (but a tad
slower than the impure 'mersenne-random' library based on SIMD
instructions and destructive state updates.
Homepage:http://code.haskell.org/~dons/code/mersenne-random-pure64/ License: BSD
microspec
- Ebuilds: 1, Testing: 0.2.1.3 Description:
A tiny (1 module, <500 lines) property-based (and unit) testing library with minimal dependencies.
Instead of reinventing the wheel (<https://xkcd.com/927>), we use a
RSpec/HSpec-like DSL and run tests with QuickCheck.
For many use-cases, microspec is a drop-in replacement for hspec.
> import Test.Microspec
>
> main :: IO ()
> main = microspec $ do
> describe "replicate" $ do
> it "doubles with 2" $
> replicate 2 'x' === "xx"
> it "creates a list of the right size" $
> \(Positive n) -> length (replicate n 'x') === n
>
> describe "reverse" $ do
> it "reverse . reverse === id" $ \l ->
> reverse (reverse l) === (l :: [Int])
>
> describe "tail" $
> it "length is -1" $ \(NonEmpty l) ->
> length (tail l :: [Int]) === length l - 1
>
> describe "solve the halting problem" $
> pending
Homepage:https://hackage.haskell.org/package/microspec License: BSD
midi
- Ebuilds: 1, Testing: 0.2.2.4-r1 Description: Handling of MIDI messages and files
Homepage:https://wiki.haskell.org/MIDI License: GPL-2
midi-alsa
- Ebuilds: 1, Testing: 0.2.1-r1 Description:
MIDI is the Musical Instrument Digital Interface,
ALSA is the Advanced Linux Sound Architecture.
This package provides accessors to data structures
of the ALSA sequencer interface
via the more specific types from the @midi@ package.
The package also contains a orphan instances
for the @alsa-seq:Event@ type
of the @midi:Message.Class.Check@ and @midi:Message.Class.Query@ classes.
Homepage:https://www.haskell.org/haskellwiki/MIDI License: BSD
mintty
- Ebuilds: 1, Testing: 0.1.2 Description:
MinTTY is a Windows-specific terminal emulator for the
widely used Cygwin and MSYS projects, which provide
Unix-like environments for Windows. MinTTY consoles behave
differently from native Windows consoles (such as
@cmd.exe@ or PowerShell) in many ways, and in some cases,
these differences make it necessary to treat MinTTY
consoles differently in code.
The @mintty@ library provides a simple way to detect if
your code in running in a MinTTY console on Windows. It
exports @isMinTTY@, which does the right thing 90% of the
time (by checking if standard error is attached to
MinTTY), and it also exports @isMinTTYHandle@ for the
other 10% of the time (when you want to check is some
arbitrary handle is attached to MinTTY). As you might
expect, both of these functions will simply return @False@
on any non-Windows operating system.
Homepage:https://github.com/RyanGlScott/mintty License: BSD
mmap
- Ebuilds: 1, Testing: 0.5.9 Description:
This library provides a wrapper to mmap(2) or MapViewOfFile,
allowing files or devices to be lazily loaded into memory as
strict or lazy ByteStrings, ForeignPtrs or plain Ptrs, using
the virtual memory subsystem to do on-demand loading.
Modifications are also supported.
Homepage:https://hackage.haskell.org/package/mmap License: BSD
modular-arithmetic
- Ebuilds: 1, Testing: 1.2.1.5 Description:
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.
Homepage:https://github.com/TikhonJelvis/modular-arithmetic License: BSD
monad-par-extras
- Ebuilds: 1, Testing: 0.3.3-r2 Description:
The modules below provide additional
data structures, and other added capabilities
layered on top of the 'Par' monad.
* Finish These
* Module Descriptions
Homepage:https://github.com/simonmar/monad-par License: BSD
monad-peel
- Ebuilds: 1, Testing: 0.3 Description:
This package defines @MonadPeelIO@, a subset of @MonadIO@ into which
generic control operations such as @catch@ can be lifted from @IO@.
Instances are based on monad transformers in @MonadTransPeel@, which
includes all standard monad transformers in the @transformers@
library except @ContT@. For convenience, it provides a wrapped
version of Control.Exception with types generalized from @IO@ to all
monads in @MonadPeelIO@.
Homepage:https://andersk.mit.edu/haskell/monad-peel/ License: BSD
monadplus
- Ebuilds: 1, Testing: 1.4.2-r1 Description:
Filtering and folding over arbitrary `MonadPlus` instances.
This package generalizes many common stream operations such as
`filter`, `catMaybes` etc.
Homepage:https://hackage.haskell.org/package/monadplus License: BSD
multistate
- Ebuilds: 1, Testing: 0.8.0.4-r1 Description: like mtl's ReaderT / WriterT / StateT, but more than one contained value/type
Homepage:https://github.com/lspitzner/multistate License: BSD
nanomsg-haskell
- Ebuilds: 1, Testing: 0.2.4 Description:
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.
Homepage:https://github.com/ivarnymoen/nanomsg-haskell License: MIT
nanoprolog
- Ebuilds: 1, Testing: 0.3-r2 Description:
This package was developed to demonstrate the ideas behind
the Prolog language. It contains a very small interpreter
(@Language.Prolog.Nanoprolog@) which can be run on its
own. It reads a file with definitions, and then prompts
for a goal. All possibe solutions are printed, preceded by
a tree showing which rules were applied in which order.
The file @royals.pro@ contains a description of part of the Dutch royal family, whereas the file
@tc.pro@ shows unification at work in a very small type inferencer.
Homepage:https://hackage.haskell.org/package/NanoProlog License: BSD
natural-numbers
- Ebuilds: 1, Testing: 0.1.2.0-r1 Description:
This package provides a type of all natural numbers, that is, non-negative integers.
In contrast to the @naturals@ package, it does not use an “indeterminate value” to
represent underflows, but raises errors on underflows. We think this is more
reasonable, as this “indeterminate value” is not really a natural.
Homepage:http://darcs.wolfgang.jeltsch.info/haskell/natural-numbers License: BSD
natural-sort
- Ebuilds: 1, Testing: 0.1.2 Description:
The built-in comparisons for textual data are based on Unicode ordinals. This
does not match most every-day sorting algorithms. For example,
\"z10.txt\" is sorted after \"z2.txt\" by users, but before it by
na&#239;ve algorithms.
This package provides an implementation of \"natural sort\", which more
closely matches user expectations.
See also: <http://www.davekoelle.com/alphanum.html>
Homepage:https://john-millikin.com/software/natural-sort/ License: BSD
netwire
- Ebuilds: 1, Testing: 5.0.3 Description:
Efficient and flexible wire arrows for functional reactive programming
and other forms of locally stateful programming.
Homepage:https://github.com/esoeylemez/netwire License: BSD
network-data
- Ebuilds: 1, Testing: 0.5.3 Description:
This library includes definitions for common headers such as
Ethernet, IPv4, IPv6, UDP, TCP, etc. This code is untested for any serious
work - use at your own risk.
Homepage:https://hackage.haskell.org/package/network-data License: BSD
network-simple
- Ebuilds: 1, Testing: 0.4.5 Description:
This module exports functions that abstract simple network socket
usage patterns.
See the @NEWS@ file in the source distribution to learn about any
important changes between version.
Homepage:https://github.com/k0001/network-simple License: BSD
newtype
- Ebuilds: 1, Testing: 0.2.2.0 Description:
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.
Homepage:https://hackage.haskell.org/package/newtype License: BSD
non-negative
- Ebuilds: 1, Testing: 0.1.2 Description:
Provides a class for non-negative numbers,
a wrapper which can turn any ordered numeric type into a member of that class,
and a lazy number type for non-negative numbers
(a generalization of Peano numbers).
This library is used by the 'event-list' package.
Homepage:http://code.haskell.org/~thielema/non-negative/ License: GPL-2
nonce
- Ebuilds: 1, Testing: 1.0.7-r1 Description:
According to the Wikipedia, a nonce is an arbitrary number used
only once in a cryptographic communication. This package
contain helper functions for generating nonces.
There are many kinds of nonces used in different situations.
It's not guaranteed that by using the nonces from this package
you won't have any security issues. Please make sure that the
nonces generated via this package are usable on your design.
Homepage:https://github.com/prowdsponsor/nonce License: BSD
numbers
- Ebuilds: 1, Testing: 3000.2.0.2 Description:
Instances of the numerical classes for a variety of
different numbers: (computable) real numbers,
arbitrary precision fixed numbers,
arbitrary precision floating point numbers,
differentiable numbers, symbolic numbers,
natural numbers, interval arithmetic.
Homepage:https://github.com/jwiegley/numbers#readme License: BSD
numbersieves
- Ebuilds: 1, Testing: 0.1.2 Description:
This package includes the Sieve of O'Neill and two generalizations of the Sieve of Eratosthenes. The Sieve of O'Neill is a fully incremental primality sieve based on priority queues. The other two are array based, and are not incremental. One sieves the smallest prime factor, and is useful if you want to factor a large quantity of small numbers. The other sieves Euler's Totient, which is the number of positive integers relatively prime and less than a given number.
Homepage:http://patch-tag.com/r/lpsmith/NumberSieves License: BSD
numeric-quest
- Ebuilds: 1, Testing: 0.2.0.2 Description:
List based linear algebra, similtaneous linear equations, eigenvalues and eigenvectors, roots of polynomials, transcendent functions with arbitrary precision implemented by continued fractions, quantum operations, tensors
Homepage:https://www.haskell.org/haskellwiki/Numeric_Quest License: GPL-2
numtype
- Ebuilds: 1, Testing: 1.2 Description:
This package provides unary type level representations of the
(positive and negative) integers and basic operations (addition,
subtraction, multiplication, division) on these.
Due to the unary implementation the practical size of the
NumTypes is severely limited making them unsuitable for
large-cardinality applications. If you will be working with
integers beyond (-20, 20) this package probably isn't for you.
It is, however, eminently suitable for applications such as
representing physical dimensions (see the 'Dimensional' library).
Requires GHC 6.6.1 or later.
Homepage:http://dimensional.googlecode.com/ License: BSD
numtype-dk
- Ebuilds: 1, Testing: 0.5.0.3 Description: Type-level integers, using TypeNats, Data Kinds, and Closed Type Families
Homepage:https://github.com/bjornbm/numtype-dk License: BSD
openal
- Ebuilds: 1, Testing: 1.7.0.5-r1 Description:
A Haskell binding for the OpenAL cross-platform 3D audio API,
appropriate for use with gaming applications and many other
types of audio applications. For more information about OpenAL,
please see: <http://connect.creativelabs.com/openal/>.
Homepage:https://github.com/haskell-openal/ALUT License: BSD
optional-args
- Ebuilds: 1, Testing: 1.0.2-r2 Description:
This library provides a type for specifying `Optional` function
arguments
Read the tutorial in "Data.Optional" to learn more
Homepage:https://hackage.haskell.org/package/optional-args License: BSD
parsec-extra
- Ebuilds: 1, Testing: 0.2.0.0-r1 Description:
Basic string parsers for integer numbers and case-insensitive string parsing.
Also an alternative parse function, which throws a monadic error on parse failure.
Homepage:https://hackage.haskell.org/package/parsec-extra License: BSD
parsedate
- Ebuilds: 1, Testing: 3000.0.0-r1 Description:
This library provides a function for parsing dates and times
given a date format string.
This package creates CalendarTime values and is meant
for use with the old-time package. New code should
use the time package, which now includes parsing, instead.
Homepage:http://www.cs.chalmers.se/~bringert/darcs/parsedate/doc/ License: BSD
patch
- Ebuilds: 1, Testing: 0.0.8.4-r1 Description: Data structures for describing changes to other data structures
Homepage:https://obsidian.systems License: BSD
pcre-heavy
- Ebuilds: 1, Testing: 1.0.0.2 Description:
A regular expressions library that does not suck.
Based on <https://hackage.haskell.org/package/pcre-light pcre-light>.
Takes and returns <https://hackage.haskell.org/package/stringable Stringables> everywhere.
Includes a QuasiQuoter for regexps that does compile time checking.
SEARCHES FOR MULTIPLE MATCHES! DOES REPLACEMENT!
Homepage:https://github.com/myfreeweb/pcre-heavy License: public-domain
pcre-light
- Ebuilds: 1, Testing: 0.4.1.3 Description:
A small, efficient and portable regex library for Perl 5 compatible regular expressions
The PCRE library is a set of functions that implement regular
expression pattern matching using the same syntax and semantics as Perl 5.
Test coverage data for this library is available at:
<http://code.haskell.org/~dons/tests/pcre-light/hpc_index.html>
Homepage:https://codeberg.org/daniel-casanueva/pcre-light License: BSD
pgp-wordlist
- Ebuilds: 1, Testing: 0.1.0.3 Description:
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>.
Homepage:https://github.com/quchen/pgp-wordlist License: BSD
pid1
- Ebuilds: 1, Testing: 0.1.2.0 Description: Do signal handling and orphan reaping for Unix PID1 init processes
Homepage:https://github.com/fpco/pid1#readme License: MIT
pipes-concurrency
- Ebuilds: 1, Testing: 2.0.14 Description:
This library provides light-weight concurrency primitives for
pipes, with the following features:
* /Simple API/: Use only five functions
* /Deadlock Safety/: Automatically avoid concurrency deadlocks
* /Flexibility/: Build many-to-many and cyclic communication topologies
* /Dynamic Graphs/: Add or remove readers and writers at any time
Import "Pipes.Concurrent" to use the library.
Read "Pipes.Concurrent.Tutorial" for a tutorial.
Homepage:https://hackage.haskell.org/package/pipes-concurrency License: BSD
pipes-network
- Ebuilds: 1, Testing: 0.6.5 Description:
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 @changelog@ file in the source distribution to learn about any
important changes between version.
Homepage:https://github.com/k0001/pipes-network License: BSD
placeholders
- Ebuilds: 1, Testing: 0.1 Description:
While working on some Haskell code, it is often useful to
work incrementally by inserting @undefined@ as a
placeholder for missing code.
This library provides placeholders that produce better
messages when evaluated at run-time and also generate
compile-time warnings so that they do not get forgotten
so easily.
For details, see <http://github.com/ahammar/placeholders>
Homepage:https://github.com/ahammar/placeholders License: BSD
plailude
- Ebuilds: 1, Testing: 0.6.0-r1 Description:
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.
Homepage:https://secure.plaimi.net/works/plailude License: GPL-3
plugins-auto
- Ebuilds: 1, Testing: 0.0.4 Description:
This library provides support for automatically recompiling and reloading
modules into your programs when the source code is modified.
Any program called ghc in your PATH will be used for recompiling.
> module Main where
> import System.IO (hSetBuffering,stdout,BufferMode(..))
> import System.Plugins.Auto (withMonadIO,initPlugins)
> import Answer
>
> main :: IO ()
> main = do ph<-initPlugins
> hSetBuffering stdout NoBuffering
> putStrLn "This program interacts with you in a loop."
> putStrLn "Type something, and the program will respond when you hit the Enter Key."
> putStrLn "Modify Answer.hs while interacting and you should see the answers"
> putStrLn "change accordingly."
> let interactiveLoop = prompt ph >> interactiveLoop
> interactiveLoop
> where
> prompt ph = do
> putStr "> "
> input <- getLine
> $(withMonadIO 'getAnswer) ph id notLoaded$ \errs getAnswer ->
> mapM_ putStrLn errs >> getAnswer input
>
> notLoaded errs =
> if null errs then putStrLn "Plugin not loaded yet."
> else putStrLn "Errors found:" >> mapM_ (putStrLn . (" "++)) errs
> >> putStrLn "Try fixing the errors and come back here."
> module Answer where
>
> getAnswer :: String -> IO ()
> getAnswer input = putStrLn ("What you typed: "++input)
Homepage:https://hackage.haskell.org/package/plugins-auto License: BSD
polynomial
- Ebuilds: 1, Testing: 0.7.3 Description:
A type for representing polynomials, several functions
for manipulating and evaluating them, and several
interesting polynomial sequences.
Homepage:https://github.com/mokus0/polynomial License: public-domain
prelude-compat
- Ebuilds: 1, Testing: 0.0.0.2 Description:
This package allows you to write warning-free code
that compiles with versions of 'base' before and after AMP and FTP,
that is, 'base' before and beginning with 4.8, respectively,
and GHC before and beginning with 7.10, respectively.
It serves three purposes:
* Prevent you from name clashes of FTP-Prelude
with locally defined functions having names like '<*>', 'join', 'foldMap'.
* Prevent you from redundant import warnings
if you manually import "Data.Monoid" or "Control.Applicative".
* Fix list functions to the list type, contrarily to the aim of the FTP.
This way you are saved from @length (2,1) == 1@ and @maximum (2,1) == 1@,
until you import @Data.Foldable@.
You should add
> import Prelude2010
> import Prelude ()
to your modules.
This way, you must change all affected modules.
If you want to avoid this you may try the 'prelude2010' package
or if you already import Prelude explicitly, you may try to add
> Default-Extensions: CPP, NoImplicitPrelude
> CPP-Options: -DPrelude=Prelude2010
to your Cabal file.
In my opinion, this is the wrong way round.
The presented Prelude2010 module should have been the one for GHC-7.10
and the Prelude with added and generalized list functions
should have been an additionally PreludeFTP,
preferably exported by a separate package
like all other alternate Prelude projects.
But the purpose of the FTP was to save some import statements
at the expense of blowing up the 'Foldable' class
and prevent simple ways to write code that works
with GHC version before and starting with GHC-7.10
and that does not provoke warnings.
Related packages:
* 'base-compat': The opposite approach -
Make future function definitions available in older GHC versions.
* 'haskell2010': Defines the Prelude for Haskell 2010.
Unfortunately, 'haskell2010' is not available anymore since GHC-7.10,
because of the AMP.
* 'numeric-prelude':
It is intended to provide a refined numeric class hierarchy
but it also provides a non-numeric subset of the Prelude
that is more stable than the one of 'base'.
Homepage:https://hackage.haskell.org/package/prelude-compat License: BSD
preprocessor-tools
- Ebuilds: 1, Testing: 2.0.2 Description:
This library provides a quick-and-dirty (but often effective)
method for extending Haskell's syntax using a custom
preprocessor. It parses Haskell into a bare-bones AST with just
enough knowledge of the syntax to preserve nesting, and then
allows transformations on the AST.
See the package ixdopp
(<http://hackage.haskell.org/cgi-bin/hackage-scripts/package/ixdopp>)
for an example of how to do this.
Homepage:https://github.com/tov/preprocessor-tools-hs License: BSD
presburger
- Ebuilds: 1, Testing: 1.3.1_pre20250321 Description: A decision procedure for quantifier-free linear arithmetic
Homepage:https://github.com/yav/presburger License: MIT
pretty-hex
- Ebuilds: 1, Testing: 1.1 Description:
This library generates pretty hex dumps of ByteStrings in the
style of other common *nix hex dump tools.
Homepage:https://hackage.haskell.org/package/pretty-hex License: BSD
pretty-ncols
- Ebuilds: 1, Testing: 0.1-r2 Description:
pretty-ncols allows for the following layouts to work nicely, so that:
One Two Three
1 2 3
a b c
can be written as:
cols_rowMajor = map text $ [["One", "Two", "Three"], ["1", "2","3"], ["a","b","c"]]
cols_colMajor = transpose $ cols_rowMajors
asColumns cols_rowMajor
asColumns cols_colMajor
Homepage:https://hackage.haskell.org/package/pretty-ncols License: BSD
proctest
- Ebuilds: 1, Testing: 0.1.3.1 Description: An IO library for testing interactive command line programs
Homepage:https://github.com/nh2/proctest License: MIT
prof2dot
- Ebuilds: 1, Testing: 0.4.1-r1 Description:
prof2dot takes profiling information (a file generated by running
a ghc-compiled application with the +RTS -px -RTS flags) and converts it to
GraphViz's dot format.
Homepage:http://antiope.com/downloads.html License: BSD
pseudomacros
- Ebuilds: 1, Testing: 0.0.2 Description:
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.
Homepage:https://hackage.haskell.org/package/pseudomacros License: BSD
pulseaudio
- Ebuilds: 1, Testing: 0.0.2.1-r1 Description:
This package mainly exists, because I wanted to query the current system
volume from the pulse audio server.
Doing this required me to build at least the core of the pulse api.
This package is provided as is, with very little testing and only a small
subset of the pulse api implemented.
Expanding this package *should* be rather easy. At least for query/control.
If you are interested in doing this, but don't know how, feel free to contact me.
In package is a bit unrefined and rough. If you have better structure for
modules feel free to reorganize them and making a PR. This also means, don't
see this structur as fixed yet, it may change if someone has a better idea.
Homepage:https://hackage.haskell.org/package/pulseaudio License: LGPL-3
punycode
- Ebuilds: 1, Testing: 2.0 Description:
Encode unicode strings to ascii forms according to RFC 3492. It is written in pure Haskell, as opposed to gnuidn's Data.Text.IDN.Punycode. Please note that Data.Encoding.BootString from the 'encoding' package also contains an implementation of the Punycode algorithm.
Homepage:https://github.com/litherum/punycode License: BSD
pwstore-purehaskell
- Ebuilds: 1, Testing: 2.1.4 Description:
To store passwords securely, they should be salted,
then hashed with a slow hash function. This library
uses PBKDF1-SHA256, and handles all the details.
It is implemented in pure Haskell, with no C
dependencies. For a faster implementation, the
pwstore-fast package has the exact same API but is
about 25 times faster due to its use of the cryptohash
package, which is partly implemented in C. This pure
Haskell version is visibly slower, but still quite usable.
Homepage:https://github.com/PeterScott/pwstore License: BSD
pyf
- Ebuilds: 1, Testing: 0.11.4.0 Description: Quasiquotations for a python like interpolated string formatter
Homepage:https://hackage.haskell.org/package/PyF License: BSD
quickcheck-text
- Ebuilds: 1, Testing: 0.1.2.1 Description:
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).
Homepage:https://github.com/olorin/quickcheck-text License: MIT
quicktest
- Ebuilds: 1, Testing: 0.1.3 Description:
QuickTest inspects Haskell source files for unit tests, and runs all tests found through GHCi with a dynamically generated test harness. This means you can simply write properties about your code, and QuickTest will test these properties en masse using QuickCheck. QuickTest is based on quickcheck-script by Koen Claessen and John Hughes.
Homepage:https://github.com/davidsiegel/quicktest License: BSD
random-fu
- Ebuilds: 1, Testing: 0.3.0.0 Description:
Random number generation based on modeling random
variables in two complementary ways: first, by the
parameters of standard mathematical distributions and,
second, by an abstract type ('RVar') which can be
composed and manipulated monadically and sampled in
either monadic or \"pure\" styles.
The primary purpose of this library is to support
defining and sampling a wide variety of high quality
random variables. Quality is prioritized over speed,
but performance is an important goal too.
In my testing, I have found it capable of speed
comparable to other Haskell libraries, but still
a fair bit slower than straight C implementations of
the same algorithms.
Homepage:https://github.com/mokus0/random-fu License: public-domain
ranged-sets
- Ebuilds: 1, Testing: 0.4.0 Description:
A ranged set is an ordered list of ranges. This allows sets such as all reals x such that:
> (0.25 < x <= 0.75 or 1.4 <= x < 2.3 or 4.5 < x)
Alternatively you can have all strings s such that:
> ("F" <= s < "G")
Homepage:https://github.com/PaulJohnson/Ranged-sets License: BSD
ranges
- Ebuilds: 1, Testing: 0.2.4-r1 Description:
Ranges and some functions allowing things like fast membership
lookup on ranges with holes in them and so on.
Homepage:https://hackage.haskell.org/package/ranges License: BSD
rate-limit
- Ebuilds: 1, Testing: 1.4.2 Description:
In many cases, it is useful, necessary, or simply nice to limit how
frequently you perform some action. For example, you may want to limit
how often your program makes a request of some web site. This library
is intended as a general-purpose mechanism for rate-limiting IO actions.
Homepage:https://github.com/acw/rate-limit License: BSD
ratio-int
- Ebuilds: 1, Testing: 0.1.2 Description:
Fast specialisation of Data.Ratio for Int.
Runs about ten times faster than Data.Int while being half
as fast as floating-point types.
Homepage:https://github.com/RaphaelJ/ratio-int License: BSD
readargs
- Ebuilds: 1, Testing: 1.2.3 Description:
ReadArgs provides the @readArgs@ IO action, which lets you tell the compiler
to parse the command line arguments to fit the type signature you give.
For example @(a :: Int, b :: String, c :: Float) <- readArgs@ would
parse the first runtime argument as an @Int@, the second as a @String@ (no
quotes required) and the third as a @Float@.
If the runtime arguments are incompatible with the type signature,
then a simple usage statement is given of the types needed.
Continuing the previous example, if it was used in a
program named @Example@, the error message for the above
action would be:
@
usage: Example Int String Float
@
Any type that has both @Typeable@ and @Read@ instances
can be used. @Char@, @String@, and @Text@ are handled specially so that
command line arguments for both do not require quotes (as their
@Read@ instances do). A special instance is provided for @FilePath@ so
that no constructor or quotes are required.
@readArgs@ also supports optional arguments and variadic arguments.
Optional arguments are specified using @Maybe@, and variadic arguments
using a list. @(a :: Int, b :: Maybe String, c :: [Float]) <- readArgs@
would successfully parse any of the following sets of command line arguments:
@
Example 1
Example 1 2 3 4
Example 1 foo
Example 1 foo 2 3 4
@
But not
@
Example
Example foo
Example 1.0
@
Usage statements for optional and variadic arguments use command-line
parlance:
@
usage: Example Int [String] [Float..]
@
Note that both optional and variadic parsers are greedy by default
(so @Example 1 2 3 4@ was parsed as @(1, "2", [3.0,4.0])@. They
may both be made non-greedy through use of the @NonGreedy@ constructor:
@
( a :: Int
, NonGreedy b :: NonGreedy Maybe String
, NonGreedy c :: NonGreedy [] Float
) <- readArgs
@
Homepage:https://github.com/rampion/ReadArgs License: BSD
recaptcha
- Ebuilds: 1, Testing: 0.1.0.4-r1 Description:
reCAPTCHA (http://recaptcha.net/) is a service that provides
captchas for preventing automated spam in web applications.
recaptcha-hs provides functions for using reCAPTCHA in Haskell
web applications.
Homepage:https://github.com/jgm/recaptcha/tree/master License: BSD
reflection
- Ebuilds: 1, Testing: 2.1.9 Description: Reifies arbitrary terms into types that can be reflected back into terms
Homepage:https://github.com/ekmett/reflection License: BSD
reform
- Ebuilds: 1, Testing: 0.2.7.6 Description: reform is a type-safe HTML form generation and validation library
Homepage:https://www.happstack.com/ License: BSD
reform-hamlet
- Ebuilds: 1, Testing: 0.0.5.3-r1 Description:
Reform is a library for building and validating forms using applicative functors. This package add support for using reform with Hamlet.
Homepage:http://www.happstack.com/ License: BSD
refserialize
- Ebuilds: 1, Testing: 0.4.0 Description:
Read, Show and Data.Binary do not check for internal data references to the same address.
As a result, the data is duplicated when serialized. This is a waste of space in the filesystem
and also a waste of serialization time. but the worst consequence is that, when the serialized data is read,
it allocates multiple copies for the same object when referenced multiple times. Because multiple referenced
data is very typical in a pure language such is Haskell, this means that the resulting data loose the beatiful
economy of space and processing time that referential transparency permits.
Every instance of Show/Read can be an instance of Data.RefSerialize.
This package allows the serialization and deserialization of large data structures without duplication of data, with
the result of optimized performance and memory usage. Since the serialized data is also human readable, It is also
useful for debugging purposes.
The deserializer contains a subset of Parsec.Token for defining deserializing parsers.
the serialized string has the form:
@expr( var1, ...varn) where var1=value1,..valn=valueN @
so that the string can agree with the haskell syntax.
See demo.hs and tutorial.
in this release:
* Serialization instance now includes an internal wiriter
* Solved a criitical bug only appearing in structures with many references, when StableNames started to be
freed by the gartbage colllector before serialization was completed, which gave erroneous references
* Bug in 0.2.5 fixed: empty lists were written with two indirections (insertVar . insertVar). That caused an error in readp
* Bug in 0.2.6 fixed for lists
* Added instances for standard datatypes. More "deeper" instances favouring more variable usage
* Instance of Serialize [a] changed
* Derived Serialize instances for Data.Binary instances: readpBinary, showpBinary
*- Serialization now is to/from ByteStings
Homepage:https://hackage.haskell.org/package/RefSerialize License: BSD
regex-applicative
- Ebuilds: 1, Testing: 0.3.3.1 Description:
regex-applicative is a Haskell library for parsing using regular expressions.
Parsers can be built using Applicative interface.
Homepage:https://github.com/feuerbach/regex-applicative License: MIT
regex-with-pcre
- Ebuilds: 1, Testing: 1.1.0.0 Description:
A regular expression toolkit for regex-base with
compile-time checking of RE syntax, data types for
matches and captures, a text replacement toolkit,
portable options, high-level AWK-like tools
for building text processing apps, regular expression
macros with parsers and test bench, omprehensive
documentation, tutorials and copious examples.
Homepage:http://regex.uk License: BSD
reinterpret-cast
- Ebuilds: 1, Testing: 0.1.0 Description:
Memory reinterpretation casts for Float\/Double and Word32\/Word64.
The implementations in the @.Internal@ package are different ways to tackle
the problem; the @array@ method (current default) is about 5 times faster
than the @FFI@ method.
Homepage:https://github.com/nh2/reinterpret-cast License: MIT
relational-query-hdbc
- Ebuilds: 1, Testing: 0.7.2.0 Description:
This package contains the HDBC instance of relational-query and
the typed query interface for HDBC.
Generating Database table definitions and functions for
relational-query by reading table and index definitions
from Database system catalogs.
Homepage:http://khibino.github.io/haskell-relational-record/ License: BSD
relational-schemas
- Ebuilds: 1, Testing: 0.1.8.0 Description:
This package contains some RDBMSs' schema structure definitions.
Supported RDBMS schemas are below:
- IBM DB2
- PostgreSQL
- Microsoft SQLServer
- SQLite3
- Oracle
- MySQL
Homepage:http://khibino.github.io/haskell-relational-record/ License: BSD
relude
- Ebuilds: 1, Testing: 1.2.2.2 Description: Safe, performant, user-friendly and lightweight Haskell Standard Library
Homepage:https://github.com/kowainik/relude License: MIT
rematch
- Ebuilds: 1, Testing: 0.2.0.0 Description:
Rematch is a simple library of matchers, which express rules
that can pass or fail. Matchers also report their failure with
human readable output. Custom matchers can be build, and
matchers can be combined using several predefined combinators
or you can write your own.
Matchers are often used in automated tests to provide expressive
failure messages.
Rematch is very similar to, and very inspired by the hamcrest
library for Java
Homepage:https://hackage.haskell.org/package/rematch License: MIT
repa
- Ebuilds: 1, Testing: 3.4.2.0 Description: Algorithms using the Repa array library
Homepage:http://repa.ouroborus.net License: BSD
repa-devil
- Ebuilds: 1, Testing: 0.3.2.6-r2 Description: Support for image reading and writing of Repa arrays using in-place FFI calls
Homepage:https://github.com/RaphaelJ/repa-devil License: BSD
repa-io
- Ebuilds: 1, Testing: 3.4.2.0 Description: Read and write Repa arrays in various formats
Homepage:https://repa.ouroborus.net License: BSD
resolv
- Ebuilds: 1, Testing: 0.1.2.0-r1 Description:
This package implements an API for accessing
the [Domain Name Service (DNS)](https://tools.ietf.org/html/rfc1035)
resolver service via the standard @libresolv@ system library (whose
API is often available directly via the standard @libc@ C library) on
Unix systems.
This package also includes support for decoding message record types
as defined in the following RFCs:
- [RFC 1035](https://tools.ietf.org/html/rfc1035): Domain Names - Implementation And Specification
- [RFC 1183](https://tools.ietf.org/html/rfc1183): New DNS RR Definitions
- [RFC 2782](https://tools.ietf.org/html/rfc2782): A DNS RR for specifying the location of services (DNS SRV)
- [RFC 2915](https://tools.ietf.org/html/rfc2915): The Naming Authority Pointer (NAPTR) DNS Resource Record
- [RFC 3596](https://tools.ietf.org/html/rfc3596): DNS Extensions to Support IP Version 6
- [RFC 4034](https://tools.ietf.org/html/rfc4034): Resource Records for the DNS Security Extensions
- [RFC 4255](https://tools.ietf.org/html/rfc4255): Using DNS to Securely Publish Secure Shell (SSH) Key Fingerprints
- [RFC 4408](https://tools.ietf.org/html/rfc4408): Sender Policy Framework (SPF) for Authorizing Use of Domains in E-Mail, Version 1
- [RFC 5155](https://tools.ietf.org/html/rfc5155): DNS Security (DNSSEC) Hashed Authenticated Denial of Existence
- [RFC 6844](https://tools.ietf.org/html/rfc6844): DNS Certification Authority Authorization (CAA) Resource Record
- [RFC 6891](https://tools.ietf.org/html/rfc6891): Extension Mechanisms for DNS (EDNS(0))
- [RFC 7553](https://tools.ietf.org/html/rfc7553): The Uniform Resource Identifier (URI) DNS Resource Record
Homepage:https://hackage.haskell.org/package/resolv License: GPL-2+
riff
- Ebuilds: 1, Testing: 0.3.0.1 Description:
This library provides a RIFF parser for Haskell for easy manipulation
of common file formats like WAVE and RIFF container AVI files.
Homepage:https://bitbucket.org/robertmassaioli/riff/overview License: MIT
roman-numerals
- Ebuilds: 1, Testing: 0.5.1.5-r1 Description:
This library provides functions for parsing and pretty printing
Roman numerals. Because the notation of Roman numerals has varied
through the centuries this package allows for some customisation
using a configuration that is passed to the conversion functions.
Homepage:https://github.com/roelvandijk/roman-numerals License: BSD
rsa
- Ebuilds: 1, Testing: 2.4.1 Description: Implementation of RSA, using the padding schemes of PKCS#1 v2.1
Homepage:https://hackage.haskell.org/package/RSA License: BSD
rset
- Ebuilds: 1, Testing: 1.0.0 Description: Range set: Data structure that stores a set of ranges
Homepage:https://github.com/lovasko/rset License: BSD-2
rss
- Ebuilds: 1, Testing: 3000.2.0.8 Description: A library for generating RSS 2.0 feeds
Homepage:https://github.com/haskell-hvr/rss License: public-domain
samtools
- Ebuilds: 1, Testing: 0.2.4.3 Description:
Binding to the C samtools library, which reads and
writes SAM format alignments, both binary and tab-
delimited text formats. It also supports rapid access
to specific alignments in a sorted BAM file and access
to sequences from indexed Fasta files.
Homepage:http://www.ingolia-lab.org/samtools-tutorial.html License: MIT
sbv
- Ebuilds: 1, Testing: 11.0 Description: SMT Based Verification: Symbolic Haskell theorem prover using SMT solving
Homepage:https://github.com/LeventErkok/sbv License: BSD
scalpel
- Ebuilds: 1, Testing: 0.6.1 Description:
Scalpel is a web scraping library inspired by libraries like Parsec and
Perl's Web::Scraper Scalpel builds on top of TagSoup to provide a
declarative and monadic interface.
Homepage:https://github.com/fimad/scalpel License: Apache-2.0
scalpel-core
- Ebuilds: 1, Testing: 0.6.1 Description:
Scalpel core provides a subset of the scalpel web scraping library that is
intended to have lightweight dependencies and to be free of all non-Haskell
dependencies.
Homepage:https://github.com/fimad/scalpel License: Apache-2.0
scanner
- Ebuilds: 1, Testing: 0.3.1 Description: Fast non-backtracking incremental combinator parsing for bytestrings
Homepage:https://github.com/Yuras/scanner License: BSD
scotty
- Ebuilds: 1, Testing: 0.22 Description: Haskell web framework inspired by Ruby's Sinatra, using WAI and Warp
Homepage:https://github.com/scotty-web/scotty License: BSD
scrypt
- Ebuilds: 1, Testing: 0.5.0 Description:
This package provides bindings to Colin Percival's `scrypt`
implementation (<http://www.tarsnap.com/scrypt.html>). Scrypt is a key
derivation function designed to be far more secure against hardware
brute-force attacks than alternative functions such as PBKDF2 or bcrypt.
Details of the scrypt key derivation function are given in a paper by
Colin Percival, Stronger Key Derivation via Sequential Memory-Hard
Functions: <http://www.tarsnap.com/scrypt/scrypt.pdf>.
Homepage:https://github.com/informatikr/scrypt License: BSD
sdl
- Ebuilds: 1, Testing: 0.6.7.0 Description:
Simple DirectMedia Layer \(libSDL\) is a cross-platform multimedia
library designed to provide low level access to audio,
keyboard, mouse, joystick, 3D hardware via OpenGL, and 2D
video framebuffer. It is used by MPEG playback software,
emulators, and many popular games, including the award
winning Linux port of \"Civilization: Call To Power.\"
Homepage:https://hackage.haskell.org/package/SDL License: BSD
sdl-image
- Ebuilds: 1, Testing: 0.6.2.0 Description:
SDL_image is an image file loading library.
It loads images as SDL surfaces, and supports the
following formats: BMP, GIF, JPEG, LBM, PCX, PNG,
PNM, TGA, TIFF, XCF, XPM, XV.
Homepage:https://hackage.haskell.org/package/SDL-image License: BSD
sdl-mixer
- Ebuilds: 1, Testing: 0.6.3.0 Description:
SDL_mixer is a sample multi-channel audio mixer library.
It supports any number of simultaneously playing channels
of 16 bit stereo audio, plus a single channel of music,
mixed by the popular MikMod MOD, Timidity MIDI, Ogg Vorbis,
and SMPEG MP3 libraries.
Homepage:https://hackage.haskell.org/package/SDL-mixer License: BSD
securemem
- Ebuilds: 1, Testing: 0.1.10-r1 Description:
SecureMem is similar to ByteString, except that it provides a memory chunk that
will be auto-scrubbed after it run out of scope.
Homepage:https://github.com/vincenthz/hs-securemem License: BSD
semver
- Ebuilds: 1, Testing: 0.3.4 Description:
Representation, manipulation, and de/serialisation of a Version type
following the Semantic Versioning specification.
For more information see: <http://semver.org>
Homepage:https://github.com/brendanhay/semver License: MPL-2.0
servant
- Ebuilds: 1, Testing: 0.20.3.0 Description: A family of combinators for defining webservices APIs
Homepage:https://docs.servant.dev/ License: BSD
servant-client
- Ebuilds: 1, Testing: 0.20.2 Description: Automatic derivation of querying functions for servant
Homepage:https://docs.servant.dev/ License: BSD
servant-client-core
- Ebuilds: 1, Testing: 0.20.2 Description: Core functionality and class for client function generation for servant APIs
Homepage:https://docs.servant.dev/ License: BSD
servant-server
- Ebuilds: 1, Testing: 0.20.3.0 Description: A family of combinators for defining webservices APIs and serving them
Homepage:https://docs.servant.dev/ License: BSD
sfml-audio
- Ebuilds: 1, Testing: 0.7.1.1816 Description:
Provides a very minimal interface to the audio module of sfml.
Currently, only the playing of sounds is covered.
Playing background music is not yet supported, but planned.
(sfml is a multimedia library: <http://www.sfml-dev.org/>)
Homepage:http://patch-tag.com/r/shahn/sfml-audio License: ZLIB
sha
- Ebuilds: 1, Testing: 1.6.4.4 Description:
This library implements the SHA suite of message digest functions,
according to NIST FIPS 180-2 (with the SHA-224 addendum), as well
as the SHA-based HMAC routines. The functions have been tested
against most of the NIST and RFC test vectors for the various
functions. While some attention has been paid to performance,
these do not presently reach the speed of well-tuned libraries,
like OpenSSL.
Homepage:https://hackage.haskell.org/package/SHA License: BSD
shell-utility
- Ebuilds: 1, Testing: 0.0 Description:
Utility functions for writing command-line programs including
parsing of numbers with restrictions and enumerations
for command-line arguments,
verbosity controlled output,
escaping shell arguments, exit with message.
The package has very light dependencies and is Haskell 98.
Homepage:http://hub.darcs.net/thielema/shell-utility/ License: BSD
shellac-editline
- Ebuilds: 1, Testing: 0.9.9 Description:
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.
Homepage:http://rwd.rdockins.name/shellac/home/ License: BSD
should-not-typecheck
- Ebuilds: 1, Testing: 2.1.0-r1 Description:
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.
Homepage:https://github.com/CRogers/should-not-typecheck License: BSD
show-please
- Ebuilds: 1, Testing: 0.5.5 Description:
Provides Show instances for various types whose official
Show won't Read. This is particularly intended for exception types,
which can appear unexpectedly and be difficult to track down.
Homepage:https://github.com/ddssff/show-please License: BSD
simple-affine-space
- Ebuilds: 1, Testing: 0.1.1 Description:
Affine spaces and vector spaces with a few basic instances.
This library implements affine spaces and vector spaces. Two instances are
provided for affine spaces (points) and two more for vector spaces (vectors).
These definitions are strict, implement deepseq, and are designed to have
minimal memory overhead.
Homepage:https://www.haskell.org/haskellwiki/Yampa License: BSD
simple-reflect
- Ebuilds: 1, Testing: 0.3.3 Description:
This package allows simple reflection of expressions containing variables.
Reflection here means that a Haskell expression is turned into a string.
The primary aim of this package is teaching and understanding;
there are no options for manipulating the reflected expressions beyond showing them.
Homepage:http://twanvl.nl/blog/haskell/simple-reflection-of-expressions License: BSD
simple-sendfile
- Ebuilds: 1, Testing: 0.2.30-r1 Description:
Cross platform library for the sendfile system call.
This library tries to call minimum system calls which
are the bottleneck of web servers.
Homepage:https://hackage.haskell.org/package/simple-sendfile License: BSD
simpleargs
- Ebuilds: 1, Testing: 0.2.1 Description:
The provided getArgs returns an arbitrary tuple of values instead of a
list of Strings. This means that the number and type (i.e. parseability)
of parameters are checked, and reported to the user. The module is not
a substitute for proper error handling (use "System.Console.GetOpt" for that),
but is useful for making quick and dirty command line tools a bit less dirty,
without sacrificing the quick part.
Homepage:http://malde.org/~ketil/simpleargs License: LGPL-2.1
skein
- Ebuilds: 1, Testing: 1.0.9.4-r1 Description:
Skein (<http://www.skein-hash.info/>) is a family of fast
secure cryptographic hash functions designed by Niels
Ferguson, Stefan Lucks, Bruce Schneier, Doug Whiting, Mihir
Bellare, Tadayoshi Kohno, Jon Callas and Jesse Walker.
This package uses bindings to the optimized C implementation
of Skein. We provide a high-level interface (see module
"Crypto.Skein") to some of the Skein use cases. We also
provide a low-level interface (see module
"Crypto.Skein.Internal") should you need to use Skein in a
different way.
Currently we have support for Skein as cryptographic hash
function as Skein as a message authentication code
(Skein-MAC). For examples of how to use this package, see
"Crypto.Skein" module documentation.
This package includes Skein v1.3. Versions of this package
before 1.0.0 implemented Skein v1.1.
Homepage:https://github.com/meteficha/skein License: BSD
socket-sctp
- Ebuilds: 1, Testing: 0.3.0.0-r1 Description:
This is a binding to the types and operations of `libsctp`.
This library is intended to used in conjunction with the `socket`
library it depends on.
Homepage:https://github.com/shlevy/haskell-socket-sctp License: MIT
soegtk
- Ebuilds: 1, Testing: 0.12.1-r6 Description:
An alternative implementation of the graphics library used in the book The Haskell
School of Expression, by Paul Hudak, <http://www.haskell.org/soe/
This library builds on top of Gtk+.
Homepage:http://projects.haskell.org/gtk2hs/ License: LGPL-2.1
speculation
- Ebuilds: 1, Testing: 1.5.0.3-r2 Description:
A framework for safe, programmable, speculative parallelism, loosely based on:
* Prakash Prabhu, G. Ramalingam, and Kapil Vaswani, \"/Safe Programmable Speculative Parallelism/\",
In the proceedings of Programming Language Design and Implementation (PLDI) Vol 45, Issue 6 (June 2010) pp 50-61.
<http://research.microsoft.com/pubs/118795/pldi026-vaswani.pdf>
This package provides speculative function application and speculative folds. Speculative STM transactions take the place
of the transactional rollback machinery from the paper.
For example:
@'spec' g f a@ evaluates @f g@ while forcing @a@, if @g == a@ then @f g@ is returned, otherwise @f a@ is evaluated and returned. Furthermore, if the argument has already been evaluated, we skip the @f g@ computation entirely. If a good guess at the value of @a@ is available, this is one way to induce parallelism in an otherwise sequential task. However, if the guess isn\'t available more cheaply than the actual answer, then this saves no work and if the guess is wrong, you risk evaluating the function twice. Under high load, since 'f g' is computed via the spark queue, the speculation will be skipped and you will obtain the same answer as 'f $! a'.
The best-case timeline looks like:
> foreground: [----- a -----]
> foreground: [-] (check g == a)
> spark: [----- f g -----]
> overall: [--- spec g f a ---]
The worst-case timeline looks like:
> foreground: [----- a -----]
> foreground: [-] (check g == a)
> foreground: [---- f a ----]
> spark: [----- f g -----]
> overall: [-------- spec g f a ---------]
Note that, if @f g@ takes longer than a to compute, in the HEAD release of GHC, @f g@ will be collected and killed during garbage collection.
> foreground: [----- a -----]
> foreground: [-] (check g == a)
> foreground: [---- f a ----]
> spark: [---- f g ----###### (#'s mark when this spark is collectable)
> overall: [--------- spec g f a --------]
Under high load:
> foreground: [----- a -----]
> foreground: [-] (check g == a)
> foreground: [---- f a ----]
> overall: [-------- spec g f a ---------]
Compare these to the timeline of @f $! a@:
> foreground: [----- a -----]
> foreground: [---- f a ----]
> orverall: [---------- f $! a ---------]
'specSTM' provides a similar time table for STM actions, but also rolls back side-effects. The one unfortunate operational distinction is that it is forced to compute 'a' in the background thread and therefore degrades slightly less gracefully under load, although we mitigate this effect by only enqueuing if the number of sparks for the current capability is lower than the total number of capabilities, to try to avoid wasting time when all computational resources are in use.
Homepage:https://github.com/ekmett/speculation License: BSD
spool
- Ebuilds: 1, Testing: 0.1 Description:
This library allows conversion between the types from @Data.ByteString@
(package @bytestring@) and @Data.Vector.Storable@ (package @vector@) without
copying the underlying data. This is useful, for example, when @ByteString@
IO produces or consumes vectors of numbers in native byte order.
This trick relies on the fact that @ByteString@ and @Vector@ use their
respective @ForeignPtr@s in compatible ways. It works with
@bytestring-0.9.1.10@ and @vector-0.9@ on GHC 7.0. It may break with future
releases of these packages. Depending on this library should be seen as a
way to document and standardize an existing hack, and not as an absolute
guarantee of correct behavior.
Homepage:https://hackage.haskell.org/package/spool License: BSD
sqlite-simple-errors
- Ebuilds: 1, Testing: 0.6.1.0 Description:
Light wrapper around errors from sqlite-simple to make working with constraint errors a bit easier.
To have more information go to <https://github.com/caneroj1/sqlite-simple-errors>.
Homepage:https://github.com/caneroj1/sqlite-simple-errors License: BSD
ssh-known-hosts
- Ebuilds: 1, Testing: 0.2.0.0 Description:
Utility to read the contents of the SSH known_hosts file and create
local in-memory data structures for each of the remote entities
listed.
Homepage:http://hub.darcs.net/kquick/ssh-known-hosts License: BSD
stack-bin
- Ebuilds: 2, Testing: 2.5.1 Description:
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.
Homepage:https://github.com/commercialhaskell/stack License: BSD
stateref
- Ebuilds: 1, Testing: 0.3 Description:
A collection of type-classes generalizing the
read\/write\/modify operations for stateful variables
provided by things like IORef, TVar, &c.
Note that The interface has changed a bit from the
0.2.* version. \"*Ref\" functions are now called
\"*Reference\" and new \"*Ref\" function exist with
simpler signatures.
The new 'Ref' existential type provides a convenient
monad-indexed reference type, and the HasRef class
indicates monads for which there is a default
reference type for every referent.
Homepage:https://hackage.haskell.org/package/stateref License: public-domain
stm-delay
- Ebuilds: 1, Testing: 0.1.1.1 Description:
This library lets you create a one-shot timer, poll it using STM,
and update it to ring at a different time than initially specified.
It uses GHC event manager timeouts when available
(GHC 7.2+, @-threaded@, non-Windows OS), yielding performance similar
to @threadDelay@ and @registerDelay@. Otherwise, it falls back to
forked threads and @threadDelay@.
[0.1.1]
Add tryWaitDelayIO, improve performance for certain cases of @newDelay@
and @updateDelay@, and improve example.
Homepage:https://github.com/joeyadams/haskell-stm-delay License: BSD
stm-linkedlist
- Ebuilds: 1, Testing: 0.1.0.0 Description:
Doubly linked lists are often used in imperative languages to maintain a
collection of objects such that an object can remove itself easily. The
same idea applies here. Thanks to STM, these lists can be shared among
threads with little effort.
Suppose you have a thread listening for events. You want to dispatch
events to any thread that opts in. You could write a function that
installs an event handler, performs an action, and removes the handler:
>withEventHandler list handler action =
> bracket (atomically $ LinkedList.append handler list)
> (atomically . LinkedList.delete)
> (\_ -> action)
Then, you could have your listener thread dispatch events using a function
like this:
>dispatchEvent list event = do
> handlers <- atomically $ LinkedList.toList list
> forM_ handlers $ \handler -> handler event
Homepage:https://hackage.haskell.org/package/stm-linkedlist License: BSD
stm-split
- Ebuilds: 1, Testing: 0.0.2.1 Description:
Transactional MVars, Vars and Channels with distinguished input and output side.
When threads communicate via a TMVar, a TVar or a TChan
there are often clearly defined roles,
which thread is the sender and which one is receiver.
We provide wrappers around the standard concurrency communication channels
that make the distinction clear and type safe.
For example, if a function has a parameter of type @TChan.In@
then it is sure that it will only write to that channel.
Additionally if the compiler warns about an unused @TChan.Out@
that was created by @TChan.new@
then you know that the receiver part of your communication is missing.
See also package @concurrent-split@ for non-transactional communication.
This package follows the same idea as @chan-split@ but is strictly Haskell 98.
Homepage:https://hackage.haskell.org/package/stm-split License: BSD
storable-complex
- Ebuilds: 1, Testing: 0.2.3.0 Description:
Provides a Storable instance for Complex which is binary
compatible with C99, C++ and Fortran complex data types.
The only purpose of this package is to provide a standard
location for this instance so that other packages needing
this instance can play nicely together.
Homepage:https://github.com/cartazio/storable-complex License: BSD
storable-tuple
- Ebuilds: 1, Testing: 0.0.3.3 Description:
Provides a Storable instance for pair and triple
which should be binary compatible with C99 and C++.
The only purpose of this package is to provide a standard location
for this instance so that other packages needing this instance
can play nicely together.
Homepage:http://code.haskell.org/~thielema/storable-tuple/ License: BSD
string-conv
- Ebuilds: 1, Testing: 0.1.2 Description:
Avoids the need to remember many different functions
for converting string types. Just use one universal
function toS for all monomorphic string conversions.
Homepage:https://github.com/Soostone/string-conv License: BSD
stringsearch
- Ebuilds: 1, Testing: 0.3.6.6-r1 Description:
This package provides several functions to quickly
search for substrings in strict or lazy ByteStrings.
It also provides functions for breaking or splitting
on substrings and replacing all occurrences of a
substring (the first in case of overlaps) with another.
GHC before 6.10 are no longer supported, other compilers
only if they support BangPatterns. If you need it to
work with other compilers, send a feature request.
Homepage:https://bitbucket.org/dafis/stringsearch License: BSD
suitable
- Ebuilds: 1, Testing: 0.1.1-r1 Description:
This library provides a general purpose typeclass, 'Suitable f a',
which expresses that values of type 'f a' are legal or "make sense".
Homepage:https://hackage.haskell.org/package/suitable License: BSD
sxml
- Ebuilds: 1, Testing: 0.1.0.0 Description:
This library parses and write <http://okmij.org/ftp/Scheme/SXML.html SXML> files, using datatypes from the <https://hackage.haskell.org/package/xml-types xml-types> package to represent their structure. It currently only features a DOM-style parser.
Homepage:http://blog.luigiscorner.com/ License: public-domain
symbol
- Ebuilds: 1, Testing: 0.2.4 Description:
Provides a 'Symbol' data type allowing fast symbol comparisons
and functions for interning symbols and recovering their
'String' representation.
Homepage:http://www.cs.drexel.edu/~mainland/ License: BSD
syz
- Ebuilds: 1, Testing: 0.2.0.0 Description:
This package contains the generic zipper system described
in the Scrap Your Zippers paper
(see <http://www.cs.indiana.edu/~adamsmd/papers/scrap_your_zippers/>).
It defines the @Zipper@ type permitting zipper traversals
over arbitrary instances of @Data@.
Homepage:http://www.cs.indiana.edu/~adamsmd/papers/scrap_your_zippers/ License: BSD
tagsoup
- Ebuilds: 1, Testing: 0.14.8 Description:
TagSoup is a library for parsing HTML/XML. It supports the HTML 5 specification,
and can be used to parse either well-formed XML, or unstructured and malformed HTML
from the web. The library also provides useful functions to extract information
from an HTML document, making it ideal for screen-scraping.
Users should start from the "Text.HTML.TagSoup" module.
Homepage:https://github.com/ndmitchell/tagsoup#readme License: BSD
temporary
- Ebuilds: 1, Testing: 1.3 Description:
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 just 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.
Homepage:https://github.com/feuerbach/temporary License: BSD
terminal-progress-bar
- Ebuilds: 1, Testing: 0.4.1 Description:
A progress bar is used to convey the progress of a task. This
package implements a very simple textual progress bar.
See the module 'System.ProgressBar' on how to use the progress bar
or build the package with the -fexample flag for a small example
program.
The animated progress bar depends entirely on the interpretation of
the carriage return character (\'\\r\'). If your terminal interprets
it as something else then \"move cursor to beginning of line\", the
animation won't work.
Note: Due to a bug in \"cabal haddock\" you will have to manually
uncomment the example section in the cabal file. But uncommenting
that section will result in \"cabal haddock\" failing.
Homepage:https://github.com/roelvandijk/terminal-progress-bar License: BSD
terminfo-hs
- Ebuilds: 1, Testing: 0.2.1.1 Description:
This module can acquire terminfo databases and query them for terminal
capabilities. For details of terminfo, consult the man pages for
term(5) and terminfo(5).
This package is dead simple, and doesn't do anything fancy with the
capabilities themselves. It merely provides a means for accessing them.
Homepage:https://hackage.haskell.org/package/terminfo-hs License: BSD
testing-feat
- Ebuilds: 1, Testing: 1.1.1.1 Description:
Feat (Functional Enumeration of Abstract 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.
Homepage:https://github.com/size-based/testing-feat License: BSD
testing-type-modifiers
- Ebuilds: 1, Testing: 0.1.0.1 Description:
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
@
Homepage:https://hackage.haskell.org/package/testing-type-modifiers License: public-domain
text
- Ebuilds: 6, Testing: 2.1.3, 2.1.1, 1.2.5.0-r1 Description: An efficient packed Unicode text type
Homepage:https://github.com/haskell/text License: BSD-2
text-binary
- Ebuilds: 1, Testing: 0.2.1.1 Description:
A compatibility layer providing Binary instances for strict
and lazy text types for versions older than 1.2.1 of
<https://hackage.haskell.org/package/text>.
Homepage:https://github.com/kawu/text-binary License: BSD-2
text-latin1
- Ebuilds: 1, Testing: 0.3.1 Description:
This package provides various functions over the ASCII ang Latin-1
portions of the 'Char' and 'Word8' data types.
Homepage:https://github.com/mvv/text-latin1 License: BSD
tf-random
- Ebuilds: 1, Testing: 0.5 Description:
This package contains an implementation of a high-quality splittable pseudorandom number generator. The generator is based on a cryptographic hash function built on top of the ThreeFish block cipher. See the paper /Splittable Pseudorandom Number Generators Using Cryptographic Hashing/ by Claessen, PaBka for details and the rationale of the design.
The package provides the following:
* A splittable PRNG that implements the standard 'System.Random.RandomGen' class.
* The generator also implements an alternative version of the 'System.Random.TF.Gen.RandomGen' class (exported from "System.Random.TF.Gen"), which requires the generator to return pseudorandom integers from the full 32-bit range, and contains an n-way split function.
* An alternative version of the @Random@ class is provided, which is linked to the new @RandomGen@ class, together with @Random@ instances for some integral types.
* Two functions for initialising the generator with a non-deterministic seed: one using the system time, and one using the @\/dev\/urandom@ UNIX special file.
The package uses an adapted version of the reference C implementation of ThreeFish from the reference package of the Skein hash function (<https://www.schneier.com/skein.html>), originally written by Doug Whiting.
Please note that even though the generator provides very high-quality pseudorandom numbers, it has not been designed with cryptographic applications in mind.
Homepage:https://hackage.haskell.org/package/tf-random License: BSD
tga
- Ebuilds: 1, Testing: 0.2 Description:
TGA is a very simple format (like Bitmap), but in contrast to Bitmap also stores an alpha channel for transparency. Although tga might be outdated it had to be implemented because stb-image only supports reading. This version supports raw RGB24 and RGB32 data without palettes or run length encoding
Homepage:https://hackage.haskell.org/package/tga License: BSD
th-extras
- Ebuilds: 1, Testing: 0.0.0.8 Description: A grab bag of functions for use with Template Haskell
Homepage:https://github.com/erikd/th-extras License: public-domain
thyme
- Ebuilds: 1, Testing: 0.3.5.5 Description:
Thyme is a rewrite of the fine @time@ library, with a particular focus
on performance for applications that make heavy use of timestamps.
See "Data.Thyme" for a full description.
Homepage:https://github.com/liyang/thyme License: BSD
tidal
- Ebuilds: 1, Testing: 1.10.1 Description: Pattern language for improvised music
Homepage:https://tidalcycles.org/ License: GPL-3
tidal-core
- Ebuilds: 1, Testing: 1.10.1 Description: Core pattern library for TidalCycles, a pattern language for improvised music
Homepage:https://tidalcycles.org/ License: GPL-3
tidal-link
- Ebuilds: 2, Testing: 1.2.0 Description: Ableton Link integration for Tidal
Homepage:https://tidalcycles.org/ License: GPL-3
time-units
- Ebuilds: 1, Testing: 1.0.0 Description:
In many cases, it is useful (either for error checking or documentation
reasons) to define input and output types as having a particular unit of
time. In addition, by creating a type class defining type units, this
library should make it easier to separate the units of time the developer
wants to think in versus the units of time the library author wants to
think in.
Homepage:https://github.com/acw/time-units License: BSD
timerep
- Ebuilds: 1, Testing: 2.1.0.0 Description: Parse and display time according to some RFCs (RFC3339, RFC2822, RFC822)
Homepage:https://github.com/HugoDaniel/timerep License: BSD
top
- Ebuilds: 1, Testing: 1.7 Description:
At its most general, Top is a framework for constructing abstract interpretations
which focuses on giving good feedback on why an abstract interpretation does not give
any useful information. In a mathematical notation this is usually made explicit by
returning the top element of a (complete) lattice. This is also one of the reasons
for the name of the project.
Homepage:http://www.cs.uu.nl/wiki/bin/view/Helium/WebHome License: GPL-2
type-equality
- Ebuilds: 1, Testing: 1 Description:
In the presence of GADTs, sometimes a proof is
needed that two types are equal. This package
contains an equality type for this purpose, plus its
properties (reflexive, symmetric, transitive) and
some useful operations (substitution, congruence,
coercion/cast). It also contains a type class for
producing equality proofs, providing some form of
decidable equality on types.
Homepage:https://github.com/hesselink/type-equality License: BSD
type-functions
- Ebuilds: 1, Testing: 0.2.0.4 Description:
This package supports emulation of type-level functions using defunctionalization.
All functions whose domain is a subkind of&#xA0;@*@ and whose codomain is&#xA0;@*@
itself can be represented.
For detailed information, please refer to Subsection&#xA0;3.2 of the paper
/Generic Record Combinators with Static Type Checking/.
Homepage:http://darcs.wolfgang.jeltsch.info/haskell/type-functions License: BSD
type-hint
- Ebuilds: 1, Testing: 0.1 Description:
This package provides 'Proxy' values for various types from the @base@
library and functions to use these values as hints for type inference.
Homepage:https://github.com/mvv/type-hint License: BSD
type-level
- Ebuilds: 1, Testing: 0.3.0 Description:
This library permits performing computations on the type-level. Type-level
functions are implemented using functional dependencies of multi
parameter type classes.
To date, Booleans and Numerals (Naturals and Positives) are
supported. With regard to Numerals, there is support for common
arithmetic operations (addition, substraction, multiplication,
division, exponientation, logarithm, maximum, comparison, GCD)
over natural numbers (using a decimal representation to make
compile-time errors friendlier).
Although making use of type-level computations might seem devious and
obfuscated at first sight, it is indeed useful in practice to implement
lightweight dependent types such us number-parameterized types (e.g. an array
type parameterized by the array's size or a modular group type Zn
parameterized by the modulus).
Here is a tutorial on type-level numerals and how to use them to
implement numerically-parameterized vectors: <http://www.ict.kth.se/forsyde/files/tutorial/tutorial.html#FSVec>
Homepage:http://code.haskell.org/type-level License: BSD
unamb
- Ebuilds: 1, Testing: 0.2.7 Description:
unamb contains the "unambiguous choice" operator "unamb", which
wraps thread racing up in a purely functional, semantically simple
wrapper. Originally a part of Reactive, I moved unamb to its own
package in order to encourage experimentation.
Project wiki page: <http://haskell.org/haskellwiki/unamb>
&#169; 2008 by Conal Elliott; BSD3 license.
Contributions from: Luke Palmer, Spencer Janssen, Sterling Clover,
Bertram Felgenhauer, Peter Verswyvelen, Svein Ove Aas, and Edward Kmett.
Please let me know if I've forgotten to list you.
Homepage:http://haskell.org/haskellwiki/unamb License: BSD
unexceptionalio
- Ebuilds: 1, Testing: 0.5.1 Description:
When you've caught all the exceptions that can be handled safely,
this is what you're left with.
It is intended that you use qualified imports with this library.
> import UnexceptionalIO (UIO)
> import qualified UnexceptionalIO as UIO
Homepage:https://github.com/singpolyma/unexceptionalio License: ISC
uniqueid
- Ebuilds: 1, Testing: 0.1.1 Description:
This package provides splittable supplies of unique
identifiers. The implementation mimics (only) essential
parts of the code that is used internally in GHC for
the same purpose. After improvements of the value-supply
package it is now deprecated.
Homepage:https://github.com/sebfisch/uniqueid/wikis License: BSD
units
- Ebuilds: 1, Testing: 2.4.1.5-r2 Description: A domain-specific type system for dimensional analysis
Homepage:https://github.com/goldfirere/units License: BSD
unix-bytestring
- Ebuilds: 1, Testing: 0.3.7.3 Description:
Unix\/Posix-specific functions for ByteStrings.
Provides @ByteString@ file-descriptor based I\/O API, designed
loosely after the @String@ file-descriptor based I\/O API in
"System.Posix.IO". The functions here wrap standard C implementations
of the functions specified by the ISO\/IEC 9945-1:1990 (``POSIX.1'')
and X\/Open Portability Guide Issue 4, Version 2 (``XPG4.2'')
specifications.
Note that this package doesn't require the @unix@ package as a
dependency. But you'll need it in order to get your hands on
an @Fd@, so we're not offering a complete replacement.
Homepage:http://code.haskell.org/~wren/ License: BSD
unlambda
- Ebuilds: 1, Testing: 0.1.4.2 Description:
This is an interpreter of the Unlambda language,
written in the pure, lazy, functional language Haskell.
Homepage:https://hackage.haskell.org/package/unlambda License: GPL-2
users
- Ebuilds: 1, Testing: 0.5.0.0 Description:
Scrap the boilerplate for managing user accounts in web applications
Features:
* Easy to understand API
* CRUD for Users
* Session Management
* Password reset functionality
* Activation functionality
Current Backends:
* <http://hackage.haskell.org/package/users-postgresql-simple PostgreSQL-Simple Backend>
* <http://hackage.haskell.org/package/users-persistent Persistent Backend>
Homepage:https://github.com/agrafix/users License: MIT
uu-interleaved
- Ebuilds: 1, Testing: 0.2.0.2 Description:
This module contains parser library independent code which can be used to describe inlerleaved execution of applicative style structures.
It is amongst other used in the uu-options package, which provides facilities for parsing command-line options or files containing preferences.
It gneralises the permuting parsers and the list merging parsers as e.g. found in the uulib library. For a fuller description see the Technical Report
describing its implementation and application at: http://www.cs.uu.nl/research/techreps/UU-CS-2013-005.html
Homepage:https://github.com/UU-ComputerScience/uu-interleaved License: MIT
uu-parsinglib
- Ebuilds: 1, Testing: 2.9.1.1 Description:
New version of the Utrecht University parser combinator library, which provides online, error correction,
annotation free, applicative style parser combinators. In addition to this we do provide a monadic and idomatic interface.
Parsers do analyse themselves to avoid commonly made errors. A recent addition was the combinator @`<||>`@ and
associates, which generalise merging and permuting parsers.
This version is based on the module "Data.Listlike", and as a result a great variety of input structures (@Strings@, @ByteStrings@, etc.)
can be handled.
The modules "Text.ParserCombinators.UU.Demo.Examples", "Text.ParserCombinators.UU.Idioms" and "Text.ParserCombinators.UU.Demo.MergeAndpermute"
contain a ready-made @show_examples@ function,
which can be called (e.g. from @ghci@) to see e.g. the error correction at work. It contains extensive haddock documentation, so why not just take a look to see the correction process at work, and to get a feeling for how the various combinators can be used?
The file "Text.ParserCombinators.UU.CHANGELOG" contains a log of the most recent changes and additions.
The file "Text.ParserCombinators.UU.README" contains some references to background information.
We maintain a low frequency mailing for discussing the package. You can subscribe at: <https://mail.cs.uu.nl/mailman/listinfo/parsing>
Homepage:http://www.cs.uu.nl/wiki/bin/view/HUT/ParserCombinators License: MIT
varying
- Ebuilds: 1, Testing: 0.8.1.0 Description:
Varying is a FRP library aimed at providing a
simple way to describe values that change over a domain.
It allows monadic, applicative and arrow notation and has
convenience functions for tweening.
Homepage:https://github.com/schell/varying License: MIT
vect
- Ebuilds: 1, Testing: 0.4.7 Description:
A low-dimensional (2, 3 and 4) linear algebra library,
with lots of useful functions. Intended usage is primarily
computer graphics (basic OpenGL support is included as a separate package).
Projective 4 dimensional operations, as used in eg. OpenGL,
are also supported; and so are quaternions.
The base field is either Float or Double.
Homepage:http://code.haskell.org/~bkomuves/ License: BSD
vinyl-gl
- Ebuilds: 1, Testing: 0.3.4 Description:
Using "Data.Vinyl" records (similar in spirit to @HList@)
to carry GLSL uniform parameters and vertex data enables
library code to reflect over the types of the data to
facilitate interaction between Haskell and GLSL. See the
@examples@ directory in the repository for more
information.
Homepage:https://hackage.haskell.org/package/vinyl-gl License: BSD
void
- Ebuilds: 1, Testing: 0.7.4 Description: A Haskell 98 logically uninhabited data type
Homepage:https://github.com/ekmett/void License: BSD
wai-cors
- Ebuilds: 1, Testing: 0.2.7-r1 Description:
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>.
Homepage:https://github.com/larskuhtz/wai-cors License: MIT
warp
- Ebuilds: 1, Testing: 3.4.7 Description: A fast, light-weight web server for WAI applications
Homepage:https://github.com/yesodweb/wai License: MIT
warp-tls
- Ebuilds: 1, Testing: 3.4.12 Description: HTTP over TLS support for Warp via the TLS package
Homepage:https://github.com/yesodweb/wai License: MIT
wavy
- Ebuilds: 1, Testing: 0.1.0.0 Description:
Wavy was designed to be a fast and efficient method of extracting and writing PCM
data to and from WAV files. It is here to help you make fast use of Audio
data in your Haskell programs and thus encourage many more audio projects in Haskell.
Homepage:http://bitbucket.org/robertmassaioli/wavy License: BSD
wcwidth
- Ebuilds: 1, Testing: 0.0.2 Description:
Bindings for your system's native wcwidth and a command line tool to examine
the widths assigned by it. The command line tool can compile a width table
to Haskell code that assigns widths to the Char type.
Homepage:https://github.com/solidsnack/wcwidth/ License: BSD
websockets
- Ebuilds: 1, Testing: 0.13.0.0-r2 Description: A sensible and clean way to write WebSocket-capable servers in Haskell
Homepage:https://jaspervdj.be/websockets License: BSD
wide-word
- Ebuilds: 1, Testing: 0.1.8.1 Description: Data types for large but fixed width signed and unsigned integers
Homepage:https://github.com/erikd/wide-word License: BSD-2
wizards
- Ebuilds: 1, Testing: 1.0.3-r1 Description:
@wizards@ is a package designed for the quick and painless development of /interrogative/ programs, which
revolve around a \"dialogue\" with the user, who is asked a series of questions in a sequence much like an
installation wizard.
Everything from interactive system scripts, to installation wizards, to full-blown shells can be implemented with
the support of @wizards@.
It is developed transparently on top of a free monad, which separates out the semantics of the program from any
particular interface. A variety of backends exist, including console-based "System.Console.Wizard.Haskeline" and
"System.Console.Wizard.BasicIO", and the pure "System.Console.Wizard.Pure". It is also possible to write your
own backends, or extend existing back-ends with new features. While both built-in IO backends operate on a
console, there is no reason why @wizards@ cannot also be used for making GUI wizard interfaces.
See the github page for examples on usage:
<http://www.github.com/liamoc/wizards>
For creating backends, the module "System.Console.Wizard.Internal" has a brief tutorial.
Homepage:https://hackage.haskell.org/package/wizards License: BSD
wl-pprint
- Ebuilds: 1, Testing: 1.2.1 Description:
This is a pretty printing library based on Wadler's paper "A Prettier
Printer". See the haddocks for full info. This version allows the
library user to declare overlapping instances of the 'Pretty' class.
Homepage:https://hackage.haskell.org/package/wl-pprint License: BSD
writer-cps-mtl
- Ebuilds: 1, Testing: 0.1.1.6 Description:
The WriterT and RWST monad transformers provided by writer-cps-transformers are written in continuation passing style and avoid the space-leak problem of the traditional Control.Monad.Trans.Writer.Strict and Control.Monad.Trans.Writer.Lazy. See also (<http://hackage.haskell.org/package/writer-cps-transformers>).
Homepage:https://github.com/minad/writer-cps-mtl#readme License: BSD
writer-cps-transformers
- Ebuilds: 1, Testing: 0.5.6.1 Description:
The WriterT and RWST monad transformers provided by writer-cps-transformers are written in continuation passing style and avoid the space-leak problem of the traditional Control.Monad.Trans.Writer.Strict and Control.Monad.Trans.Writer.Lazy. The corresponding MTL class instances are in the package writer-cps-mtl (<http://hackage.haskell.org/package/writer-cps-mtl>).
Homepage:https://github.com/minad/writer-cps-transformers#readme License: BSD
wxc
- Ebuilds: 1, Testing: 1.0.0.2 Description:
wxHaskell is a portable and native GUI library for Haskell. It is
built on top of wxWidgets, a comprehensive C++ library that is
portable across all major GUI platforms, including GTK, Windows,
X11, and MacOS X. This version works with wxWidgets 2.9 only.
Distributed under the WXWINDOWS LIBRARY LICENSE. Please see
LICENSE file, but note that this is essentially LGPL with an
exception allowing binary distribution of proprietary software.
This is the same license as wxWidgets itself uses.
Homepage:https://codeberg.org/wxHaskell/wxHaskell/src/branch/master/wxc License: wxWinLL-3.1
xattr
- Ebuilds: 1, Testing: 0.6.2 Description:
Relatively low-level interface to work with extended attributes
on Unix systems. This is a fairly straightforward port of the
API exposed by SGI's libattr.
Homepage:https://hackage.haskell.org/package/xattr License: BSD
xdot
- Ebuilds: 1, Testing: 0.3.0.5 Description: Parse Graphviz xdot files and interactively view them using GTK and Cairo
Homepage:https://hackage.haskell.org/package/xdot License: BSD
xeno
- Ebuilds: 1, Testing: 0.6 Description: A fast event-based XML parser in pure Haskell
Homepage:https://github.com/ocramz/xeno License: BSD
xformat
- Ebuilds: 1, Testing: 0.1.2.1 Description:
/Warning:/ This version of the package is very experimental and the interface
may change in later versions. I am seeking comments to improve it.
This package is composed of two functions for formatted conversion between
strings and typed values. Each is defined as a type-indexed function using a
type class with multiple parameters and functional dependencies along with
format descriptors.
"Text.XFormat.Read" allows one to parse values from a formatted string. Its
functionality is similar to the C @scanf@ function. Unlike @scanf@, however,
the format descriptor is well-typed, ensuring that the output type is
statically known.
"Text.XFormat.Show" allows one to print values to a formatted string. Its
functionality is similar to the C @printf@ function. Unlike @printf@, however,
the format descriptor is well-typed, ensuring that the variable number
arguments are statically known.
These functions can be easily extended to support new formats and new types.
Extension is simple: define a format descriptor and an instance of the
appropriate class.
Homepage:https://github.com/spl/xformat License: BSD
xhtml-combinators
- Ebuilds: 1, Testing: 0.3-r1 Description:
xhtml-combinators provides a set of (hopefully!) fast and
easy to use XHTML 1.0 Strict combinators built on top of the
Data.Text library.
Homepage:https://www.dcs.shef.ac.uk/~aca08aa/xhtmlc.html License: BSD
xlsx
- Ebuilds: 1, Testing: 1.1.3 Description: Simple and incomplete Excel file parser/writer
Homepage:https://github.com/qrilka/xlsx License: MIT
xml
- Ebuilds: 1, Testing: 1.3.14 Description: A simple XML library
Homepage:http://code.galois.com License: BSD
xml-conduit
- Ebuilds: 1, Testing: 1.9.1.4 Description: Pure-Haskell utilities for dealing with XML with the conduit package
Homepage:https://github.com/snoyberg/xml License: MIT
xml-hamlet
- Ebuilds: 1, Testing: 0.5.0.3 Description: Hamlet-style quasiquoter for XML content
Homepage:https://www.yesodweb.com/ License: BSD
xml-picklers
- Ebuilds: 1, Testing: 0.3.6 Description:
A library of combinators that allows Haskell data structures to be pickled
(serialized) to/from a representation of XML as defined in xml-types
Release history
[0.3] Changed the Result type of unpicklers. Unpicklers now fail by default when
there are remaining elements
[0.2] Error system overhaul
[0.1] Initial release
Homepage:https://hackage.haskell.org/package/xml-picklers License: BSD
xxhash-ffi
- Ebuilds: 1, Testing: 0.2.0.0 Description:
Bindings to the C implementation the xxHash algorithm. xxHash provides 32-bit and 64-bit extremely fast non-cryptographic hash functions.
Homepage:https://github.com/haskell-haskey/xxhash-ffi#readme License: BSD
yampa
- Ebuilds: 1, Testing: 0.13.1 Description:
Domain-specific language embedded in Haskell for programming
hybrid (mixed discrete-time and continuous-time) systems. Yampa is based on
the concepts of Functional Reactive Programming (FRP) and is structured using
arrow combinators.
Homepage:https://github.com/ivanperez-keera/Yampa/ License: BSD
yesod
- Ebuilds: 1, Testing: 1.6.2.1 Description: Creation of type-safe, RESTful web applications
Homepage:https://www.yesodweb.com/ License: MIT
yesod-angular
- Ebuilds: 1, Testing: 0.1.0.2 Description:
Angular JS integration for Yesod.
This module is based on Michael Snoyman's original work
in the <https://github.com/snoyberg/yesod-js> repository.
Homepage:https://hackage.haskell.org/package/yesod-angular License: BSD
yesod-core
- Ebuilds: 1, Testing: 1.6.28.1 Description: Creation of type-safe, RESTful web applications
Homepage:https://www.yesodweb.com/ License: MIT
yesod-default
- Ebuilds: 1, Testing: 1.2.0 Description: Default config and main functions for your yesod application (deprecated)
Homepage:http://www.yesodweb.com/ License: MIT
yesod-json
- Ebuilds: 1, Testing: 1.2.0 Description: Generate content for Yesod using the aeson package. (deprecated)
Homepage:http://www.yesodweb.com/ License: MIT
yesod-newsfeed
- Ebuilds: 1, Testing: 1.7.0.0 Description: Helper functions and data types for producing News feeds
Homepage:http://www.yesodweb.com/ License: MIT
zeromq4-haskell
- Ebuilds: 1, Testing: 0.8.0-r1 Description:
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
Homepage:https://gitlab.com/twittner/zeromq-haskell/ License: MIT
zmidi-core
- Ebuilds: 1, Testing: 0.9.0 Description:
Minimalist library to read and write MIDI files, with
dependencies only on ByteString and Data.Binary.
Changelog:
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.
v0.4.0 to v0.5.0:
* Changed order of @MidiVoiceEvent@ constructors so the Ord
instance follows the order of the /tag/ in the MIDI binary
representation.
* Changed @MidiSysCommonEvent@ to have different constructors
for unidentified F4 anf F5 events.
* Changed @MidiSysRealTimeEvent@ to have different constructors
for unidentified F9 and FD events.
* Added more Haddock docs.
* Various internal code changes.
v0.3.0 to v0.4.0:
* Added new constructors to @MidiMetaEvent@ for MidiPort and
MetaOther. MetaOther recognizes otherwise unrecognized events
improving the robustness of the parser. Similarly a new
/other/ constructor has been added to @MidiScaleType@ to
avoid parse errors.
v0.2.1 to v0.3.0:
* Revised naming of the MIDI data types. All data types now have
the prefix Midi (previously only MidiFile followed this scheme).
The rationale for this is client software, that might want a
higher-level representation, is then free to use the more
generic names Track, Message, etc.
* @DeltaTime@ made a newtype wrapper rather than a type synonym.
* Renamed the pretty print functions @track@ to @printMidiTrack@
and @header@ to @printMidiHeader@.
* Moved internal dataypes (SplitByte, Varlen) into a private
module.
v0.2.0 to v0.2.1:
* Added Show class constraints to various type signatures to
accommodate changes to Num superclass hierarchy in GHC 7.4.
Thanks to Remy Moueza for the patches.
v0.1.0 to v0.2.0:
* Added a top-level /shim/ module to import all the exposed
modules. Added a version number module
Homepage:https://github.com/stephentetley/zmidi-core License: BSD
zstd
- Ebuilds: 1, Testing: 0.1.3.0 Description: Haskell bindings to the Zstandard compression algorithm
Homepage:https://github.com/luispedro/hs-zstd License: BSD