Please see the README on Github at <https://github.com/IvanMalison/dbus-hslogger#readme>

Bindings for Gio, autogenerated by haskell-gi.

Haskell bindings for libarchive. Provides the ability to unpack archives, including the ability to unpack archives lazily.

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.

This package provides array, slice and text operations.

Parser and writer for handling sectioned config files in Haskell. . The ConfigFile module works with configuration files in a standard format that is easy for the user to edit, easy for the programmer to work with, yet remains powerful and flexible. It is inspired by, and compatible with, Python's ConfigParser module. It uses files that resemble Windows .INI-style files, but with numerous improvements. . ConfigFile provides simple calls to both read and write config files. It's possible to make a config file parsable by this module, the Unix shell, and make.

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.

Cairo is a library to render high quality vector graphics. There exist various backends that allows rendering to Gtk windows, PDF, PS, PNG and SVG documents, amongst others.

Bindings for JavaScriptCore 6.x, autogenerated by haskell-gi.

This package adds resource management and exception handling to the @pipes@ ecosystem. . Notable features include: . * /Resource Safety/: Guarantee finalization using @finally@, @bracket@ and more . * /Exception Safety/: Even against asynchronous exceptions! . * /Laziness/: Only acquire resources when you need them . * /Promptness/: Finalize resources early when you are done with them . * /Native Exception Handling/: Catch and resume from exceptions inside pipes . * /No Buy-in/: Mix resource-safe pipes with unmanaged pipes using @hoist@.

This package lacks a description. Run "info '(guix) Synopses and Descriptions'" for more information.

This library provides an interface to portably work with byte arrays whose contents are known to be of a fixed endianness. There are two ways to use this module. See the `System.ByteOrder` module for more documentation.

This package provides a practical incremental and one-pass, pure API to the <https://en.wikipedia.org/wiki/SHA-1 SHA-1 hash algorithm> (including <https://en.wikipedia.org/wiki/HMAC HMAC> support) with performance close to the fastest implementations available in other languages. . The implementation is made in C with a haskell FFI wrapper that hides the C implementation. . NOTE: This package has been forked off @cryptohash-0.11.7@ because the @cryptohash@ package has been deprecated and so this package continues to satisfy the need for a lightweight package providing the SHA1 hash algorithm without any dependencies on packages other than @base@ and @bytestring@. . Consequently, this package can be used as a drop-in replacement for @cryptohash@'s "Crypto.Hash.SHA1" module, though with a clearly smaller footprint.

For upgrading to streamly-0.9.0+ please read the <https://github.com/composewell/streamly/blob/streamly-0.10.0/docs/User/Project/Upgrading-0.8-to-0.9.md Streamly-0.9.0 upgrade guide>. . Streamly is a standard library for Haskell that focuses on C-like performance, modular combinators, and streaming data flow model. Streamly consists of two packages: "streamly-core" and "streamly". <https://hackage.haskell.org/package/streamly-core streamly-core> provides basic features, and depends only on GHC boot libraries (see note below), while <https://hackage.haskell.org/package/streamly streamly> provides higher-level features like concurrency, time, lifted exceptions, and networking. For documentation, visit the <https://streamly.composewell.com Streamly website>. . The streamly-core package provides the following functionality: . * Streams as composable producers of a sequence of values. * Streams provide all the functionality provided by Haskell lists but in an effectful, streaming fashion with better performance. * Streams provide ListT and logic programming functionality as well. * Folds as composable stream consumers that reduce the streams to a single value or reduce segments of streams to transform the stream. * Parsers as more powerful, composable stream consumers supporting standard parser combinators with backtracking but in a streaming fashion. * Arrays with streaming interfaces providing high performance, modularity, and concise interface as all streaming operations can be performed on arrays. * Arrays can be immutable or mutable, unboxed or boxed, pinned or unpinned. * Arrays generalize the functionality provided by @bytestring@ and @text@ packages. * Interoperability with @bytestring@ and @text@ is provided via separate packages. * Arrays and folds provide natural builder functionality so there are no separate builder modules. * High performance binary serialization with configurable JSON like features. * Streaming combinators for unicode text processing, providing functionality equivalent to the @text@ package. * String interpolation for convenient construction of strings. * Streaming console IO (stdin/stdout) operations. * Streaming file and directory IO operations. . This package covers some or all of the functionality covered by @streaming, pipes, conduit, list-t, logic-t, foldl, attoparsec, array, primitive, vector, vector-algorithms, binary, cereal, store, bytestring, text, stringsearch, interpolate@. Streamly provides a consistent, concise, modular and performant interface for all this functionality. . Note: The dependencies "heaps" and "monad-control" are included in the package solely for backward compatibility, and will be removed in future versions.

The Haskell Common Architecture for Building Applications and Libraries: a framework defining a common interface for authors to more easily build their Haskell applications in a portable way. . The Haskell Cabal is part of a larger infrastructure for distributing, organizing, and cataloging Haskell libraries and tools.

Dyre implements dynamic reconfiguration facilities after the style of Xmonad. Dyre aims to be as simple as possible without sacrificing features, and places an emphasis on simplicity of integration with an application. A full introduction with a complete example project can be found in the documentation for 'Config.Dyre'

Michael and Scott queues are described in their PODC 1996 paper: . <http://dl.acm.org/citation.cfm?id=248052.248106> . These are single-ended concurrent queues based on a singlly linked list and using atomic CAS instructions to swap the tail pointers. As a well-known efficient algorithm they became the basis for Java's @ConcurrentLinkedQueue@.

Please see the README on Github at <https://github.com/IvanMalison/gtk-sni-tray#readme>

Replacement for [composition](hackage.haskell.org/package/composition) or [composition-extra](hackage.haskell.org/package/composition-extra), exporting everything in one module.

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.

Bindings for xlib, autogenerated by haskell-gi.

Please see the README on Github at <https://github.com/IvanMalison/gtk-strut#readme>

QuickCheck is a library for random testing of program properties. The programmer provides a specification of the program, in the form of properties which functions should satisfy, and QuickCheck then tests that the properties hold in a large number of randomly generated cases. Specifications are expressed in Haskell, using combinators provided by QuickCheck. QuickCheck provides combinators to define properties, observe the distribution of test data, and define test data generators. . Most of QuickCheck's functionality is exported by the main "Test.QuickCheck" module. The main exception is the monadic property testing library in "Test.QuickCheck.Monadic". . If you are new to QuickCheck, you can try looking at the following resources: . * The <http://www.cse.chalmers.se/~rjmh/QuickCheck/manual.html official QuickCheck manual>. It's a bit out-of-date in some details and doesn't cover newer QuickCheck features, but is still full of good advice. * <https://begriffs.com/posts/2017-01-14-design-use-quickcheck.html>, a detailed tutorial written by a user of QuickCheck. . The <https://hackage.haskell.org/package/quickcheck-instances quickcheck-instances> companion package provides instances for types in Haskell Platform packages at the cost of additional dependencies.