Hoogle Search

Within LTS Haskell 24.45 (ghc-9.10.3)

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

  1. package ad

    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.
    While not every mode can provide all operations, the following basic operations are supported, modified as appropriate by the suffixes below:
    • 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.
    The following suffixes alter the meanings of the functions above as follows:
    • ' -- 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

  2. package aeson-qq

    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

  3. package asn1-encoding

    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).

  4. package base-compat-batteries

    base-compat with extra batteries Provides functions available in later versions of base to a wider range of compilers, without requiring you to use CPP pragmas in your code. This package provides the same API as the base-compat library, but depends on compatibility packages (such as semigroups) to offer a wider support window than base-compat, which has no dependencies. Most of the modules in this library have the same names as in base-compat to make it easier to switch between the two. There also exist versions of each module with the suffix .Repl.Batteries, which are distinct from anything in base-compat, to allow for easier use in GHCi. See here for a more comprehensive list of differences between base-compat and base-compat-batteries.

  5. package boring

    Boring and Absurd types

    • Boring types are isomorphic to ().
    • Absurd types are isomorphic to Void.
    See What does () mean in Haskell -answer by Conor McBride

  6. package deriving-compat

    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)
    See the Data.Deriving module for a full list of backported changes. In addition, deriving-compat also provides some additional deriving functionality that has not yet been merged into upstream GHC. Aside from the GHC deriving extensions mentioned above, deriving-compat also permits deriving instances of classes in the Data.Functor.Classes module, covering the Eq1, Eq2, Ord1, Ord2, Read1, Read2, Show1, and Show2 classes. This extra functionality is outside of the main scope of deriving-compat, as it does not backport extensions that exist in today's GHC. Nevertheless, the underlying Template Haskell machinery needed to derive Eq and friends extends very naturally to Eq1 and friends, so this extra functionality is included in deriving-compat as a convenience. Note that some recent GHC typeclasses/extensions are not covered by this package: 
    • 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.

  7. package doctest-parallel

    Test interactive Haskell examples The doctest program checks examples in source code comments. It is modeled after doctest for Python (https://docs.python.org/3/library/doctest.html). Documentation is at https://github.com/martijnbastiaan/doctest-parallel#readme.

  8. package formatting

    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.

  9. package generic-lens

    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.

  10. package generic-random

    Generic random generators for QuickCheck Derive instances of Arbitrary for QuickCheck, with various options to customize implementations. For more information

Page 37 of many | Previous | Next