Hoogle Search
Within LTS Haskell 24.4 (ghc-9.10.2)
Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.
-
Library for creating and modifying zip archives. The zip-archive library provides functions for creating, modifying, and extracting files from zip archives. The zip archive format is documented in http://www.pkware.com/documents/casestudies/APPNOTE.TXT. Certain simplifying assumptions are made about the zip archives: in particular, there is no support for strong encryption, zip files that span multiple disks, ZIP64, OS-specific file attributes, or compression methods other than Deflate. However, the library should be able to read the most common zip archives, and the archives it produces should be readable by all standard unzip programs. Archives are built and extracted in memory, so manipulating large zip files will consume a lot of memory. If you work with large zip files or need features not supported by this library, a better choice may be zip, which uses a memory-efficient streaming approach. However, zip can only read and write archives inside instances of MonadIO, so zip-archive is a better choice if you want to manipulate zip archives in "pure" contexts. As an example of the use of the library, a standalone zip archiver and extracter is provided in the source distribution.
-
Automatic Differentiation Forward-, reverse- and mixed- mode automatic differentiation combinators with a common API. Type-level "branding" is used to both prevent the end user from confusing infinitesimals and to limit unsafe access to the implementation details of each Mode. Each mode has a separate module full of combinators.
- Numeric.AD.Mode.Forward provides basic forward-mode AD. It is good for computing simple derivatives.
- Numeric.AD.Mode.Reverse uses benign side-effects to compute reverse-mode AD. It is good for computing gradients in one pass. It generates a Wengert list (linear tape) using Data.Reflection.
- Numeric.AD.Mode.Kahn uses benign side-effects to compute reverse-mode AD. It is good for computing gradients in one pass. It generates a tree-like tape that needs to be topologically sorted in the end.
- Numeric.AD.Mode.Sparse computes a sparse forward-mode AD tower. It is good for higher derivatives or large numbers of outputs.
- Numeric.AD.Mode.Tower computes a dense forward-mode AD tower useful for higher derivatives of single input functions.
- Numeric.AD computes using whichever mode or combination thereof is suitable to each individual combinator.
- grad computes the gradient (partial derivatives) of a function at a point.
- jacobian computes the Jacobian matrix of a function at a point.
- diff computes the derivative of a function at a point.
- du computes a directional derivative of a function at a point.
- hessian computes the Hessian matrix (matrix of second partial derivatives) of a function at a point.
- ' -- also return the answer
- With lets the user supply a function to blend the input with the output
- F is a version of the base function lifted to return a Traversable (or Functor) result
- s means the function returns all higher derivatives in a list or f-branching Stream
- T means the result is transposed with respect to the traditional formulation.
- 0 means that the resulting derivative list is padded with 0s at the end.
- NoEq means that an infinite list of converging values is returned rather than truncating the list when they become constant
-
JSON quasiquoter for Haskell 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/sol/aeson-qq#readme -
ASN1 data reader and writer in RAW, BER and DER forms ASN1 data reader and writer in raw form with supports for high level forms of ASN1 (BER, and DER).
-
Boring and Absurd types
- Boring types are isomorphic to ().
- Absurd types are isomorphic to Void.
-
Composable Contravariant Comonadic Logging Library This package provides core types and functions to work with the LogAction data type which is both simple and powerful.
newtype LogAction m msg = LogAction { unLogAction :: msg -> m () }The ideas behind this package are described in the following blog post: See the following packages for different implementations based on co-log-core:- co-log: taggless final implementations.
- co-log-polysemy: extensible effects implementation based on polysemy.
-
Fast, pure and practical SHA-256 implementation A practical incremental and one-pass, pure API to the SHA-256 cryptographic hash algorithm according to FIPS 180-4 with performance close to the fastest implementations available in other languages. The core SHA-256 algorithm is implemented in C and is thus expected to be as fast as the standard sha256sum(1) tool; for instance, on an Intel Core i7-3770 at 3.40GHz this implementation can compute a SHA-256 hash over 230 MiB of data in under one second. (If, instead, you require a pure Haskell implementation and performance is secondary, please refer to the SHA package.) Additionally, this package provides support for
- HMAC-SHA-256: SHA-256-based Hashed Message Authentication Codes (HMAC)
- HKDF-SHA-256: HMAC-SHA-256-based Key Derivation Function (HKDF)
Relationship to the cryptohash package and its API
This package has been originally a fork of cryptohash-0.11.7 because the cryptohash package had been deprecated and so this package continues to satisfy the need for a lightweight package providing the SHA-256 hash algorithm without any dependencies on packages other than base and bytestring. The API exposed by cryptohash-sha256-0.11.*'s Crypto.Hash.SHA256 module is guaranteed to remain a compatible superset of the API provided by the cryptohash-0.11.7's module of the same name. Consequently, this package is designed to be used as a drop-in replacement for cryptohash-0.11.7's Crypto.Hash.SHA256 module, though with a clearly smaller footprint by almost 3 orders of magnitude. -
Backports of GHC deriving extensions deriving-compat provides Template Haskell functions that mimic deriving extensions that were introduced or modified in recent versions of GHC. Currently, the following typeclasses/extensions are covered:
- Deriving Bounded
- Deriving Enum
- Deriving Ix
- Deriving Eq
- Deriving Ord
- Deriving Read
- Deriving Show
DeriveFoldable
DeriveFunctor
DeriveTraversable
- GeneralizedNewtypeDeriving (with GHC 8.2 or later)
- DerivingVia (with GHC 8.2 or later)
DeriveDataTypeable
- DeriveGeneric, which was introducted in GHC 7.2 for deriving Generic instances, and modified in GHC 7.6 to allow derivation of Generic1 instances. Use Generics.Deriving.TH from generic-deriving to derive Generic(1) using Template Haskell.
- DeriveLift, which was introduced in GHC 8.0 for deriving Lift instances. Use Language.Haskell.TH.Lift from th-lift to derive Lift using Template Haskell.
- The Bifunctor typeclass, which was introduced in GHC 7.10, as well as the Bifoldable and Bitraversable typeclasses, which were introduced in GHC 8.2. Use Data.Bifunctor.TH from bifunctors to derive these typeclasses using Template Haskell.
-
Combinator-based type-safe formatting (like printf() or FORMAT) Combinator-based type-safe formatting (like printf() or FORMAT), modelled from the HoleyMonoids package. See the README at https://github.com/AJChapman/formatting#readme for more info.
-
Generically derive traversals, lenses and prisms. This library uses GHC.Generics to derive efficient optics (traversals, lenses and prisms) for algebraic data types in a type-directed way, with a focus on good type inference and error messages when possible. The library exposes a van Laarhoven interface. For an alternative interface, supporting an opaque optic type, see generic-optics.