Cabal with c2hs dependencies.

Orphan instances for TH datatypes. In particular, instances for Ord and Lift, as well as a few missing Show / Eq. These instances used to live in haskell-src-meta, and that's where the version number started.

REST is a Rewriting library with online termination checking. For more details see the paper at https://arxiv.org/abs/2202.05872.

Generate Haskell bindings for GObject Introspection capable libraries. This includes most notably Gtk+, but many other libraries in the GObject ecosystem provide introspection data too.

This package provides first class functional references in Van Laarhoven style supporting the following optics: . * Lenses (view, over) . * Traversals (toListOf, matching, over) . * Setters (over) . * Grates (zipWithOf, under, review) . * Resetters (under) . * Adapters (view, review) . * Grids (toListOf, over / under, review) . * Prisms (matching, over / under, review) . * Getters (view) . * Folders (toListOf) . * Reviewers (review).

This package provides functionality for manipulating @FilePath@ values, and is shipped with <https://www.haskell.org/ghc/ GHC>. It provides two variants for filepaths: . 1. legacy filepaths: @type FilePath = String@ . 2. operating system abstracted filepaths (@OsPath@): internally unpinned @ShortByteString@ (platform-dependent encoding) . It is recommended to use @OsPath@ when possible, because it is more correct. . For each variant there are three main modules: . * "System.FilePath.Posix" / "System.OsPath.Posix" manipulates POSIX\/Linux style @FilePath@ values (with @\/@ as the path separator). . * "System.FilePath.Windows" / "System.OsPath.Windows" manipulates Windows style @FilePath@ values (with either @\\@ or @\/@ as the path separator, and deals with drives). . * "System.FilePath" / "System.OsPath" for dealing with current platform-specific filepaths . For more powerful string manipulation of @OsPath@, you can use the <https://hackage.haskell.org/package/os-string os-string package> (@OsPath@ is a type synonym for @OsString@). . An introduction into the new API can be found in this <https://hasufell.github.io/posts/2022-06-29-fixing-haskell-filepaths.html blog post>. Code examples for the new API can be found <https://github.com/hasufell/filepath-examples here>.

This package provides array, slice and text operations.

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

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

Bindings for GModule, autogenerated by haskell-gi.

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.

C-structs lets you create correct C structs in Haskell. These can be used for FFI calls, import as well as exports. This package is part of the development efforts for the Python library Pythas. Pythas provides an interface to import Haskell modules. . Note: As of GHC 9.2 structs cannot be passed by value, only by reference.

Bindings for Gdk, autogenerated by haskell-gi.

Asymptotically optimal Brodal\/Okasaki bootstrapped skew-binomial heaps from the paper <http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.48.973 "Optimal Purely Functional Priority Queues">, extended with a Foldable interface.

Unaligned access to primitive arrays. The offsets are given in bytes rather than elements.

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

As of 2023, this library is largely obsolete: arbitrary test generators with shrinking such as [falsify](https://hackage.haskell.org/package/falsify) offer much better user experience. . SmallCheck is a testing library that allows to verify properties for all test cases up to some depth. The test cases are generated automatically by SmallCheck.

This library provides an extensible interface for interacting with SMT solvers using SMT-LIB. The smtlib-backends-process package provides a backend that runs solvers as external processes, and the smtlib-backends-z3 package provides a backend that uses inlined calls to Z3's C API.

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.

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.

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.

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

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.