Hoogle Search

Within LTS Haskell 24.34 (ghc-9.10.3)

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

package haddock-library

Library exposing some functionality of Haddock. Haddock is a documentation-generation tool for Haskell libraries. These modules expose some functionality of it without pulling in the GHC dependency. Please note that the API is likely to change so be sure to specify upper bounds in your projects. For interacting with Haddock itself, see the haddock package.
package haha

A simple library for creating animated ascii art on ANSI terminals. A simple library for creating animated ascii art on ANSI terminals.
package haskell-src

Support for manipulating Haskell source code 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.
package haskoin-core

Bitcoin & Bitcoin Cash library for Haskell Please see the README on GitHub at https://github.com/jprupp/haskoin-core#readme
package hasql-pool

Pool of connections for Hasql Pool of connections for Hasql
package hasql-transaction

Composable abstraction over retryable transactions for Hasql Composable abstraction over retryable transactions for Hasql
package hasty-hamiltonian

Speedy traversal through parameter space. Gradient-based traversal through parameter space. This implementation of HMC algorithm uses lens as a means to operate over generic indexed traversable functors, so you can expect it to work if your target function takes a list, vector, map, sequence, etc. as its argument. If you don't want to calculate your gradients by hand you can use the handy ad library for automatic differentiation. Exports a mcmc function that prints a trace to stdout, a chain function for collecting results in memory, and a hamiltonian transition operator that can be used more generally.
```
import Numeric.AD (grad)
import Numeric.MCMC.Hamiltonian

target :: RealFloat a => [a] -> a
target [x0, x1] = negate ((x0 + 2 * x1 - 7) ^ 2 + (2 * x0 + x1 - 5) ^ 2)

gTarget :: [Double] -> [Double]
gTarget = grad target

booth :: Target [Double]
booth = Target target (Just gTarget)

main :: IO ()
main = withSystemRandom . asGenIO $ mcmc 10000 0.05 20 [0, 0] booth
```
package heap

Heaps in Haskell A flexible Haskell implementation of minimum, maximum, minimum-priority, maximum-priority and custom-ordered heaps.
package hedgehog-classes

Hedgehog will eat your typeclass bugs This library provides Hedgehog properties to ensure that typeclass instances adhere to the set of laws that they are supposed to. There are other libraries that do similar things, such as `genvalidity-hspec` and checkers. This library differs from other solutions by not introducing any new typeclasses that the user needs to learn, and otherwise minimal API overhead. This library is directly inspired by `quickcheck-classes`.
package heftia

higher-order algebraic effects done right This is the core package for heftia-effects. Heftia is an extensible effects library that generalizes "Algebraic Effects and Handlers" to higher-order effects, providing users with maximum flexibility and delivering standard and reasonable speed. In its generalization, the focus is on ensuring predictable results based on simple, consistent semantics, while preserving soundness. Please refer to the Haddock documentation for usage and semantics. For information on performance, please refer to performance.md. This library is inspired by the paper:
- Casper Bach Poulsen and Cas van der Rest. 2023. Hefty Algebras: Modular Elaboration of Higher-Order Algebraic Effects. Proc. ACM Program. Lang. 7, POPL, Article 62 (January 2023), 31 pages. https://doi.org/10.1145/3571255
The elaboration approach proposed in the above paper allows for a straightforward treatment of higher-order effects. Heftia's data structure is an extension of the Freer monad, designed to be theoretically straightforward by eliminating ad-hoc elements.

Page 119 of many | Previous | Next