Hoogle Search

Within LTS Haskell 24.49 (ghc-9.10.3)

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

package primitive-serial

Serialisation of primitive types Representation of basic numeric types as ByteStrings
package probability

Probabilistic Functional Programming The Library allows exact computation with discrete random variables in terms of their distributions by using a monad. The monad is similar to the List monad for non-deterministic computations, but extends the List monad by a measure of probability. Small interface to R plotting.
package prometheus-metrics-ghc

Metrics exposing GHC runtime information for use with prometheus-client. Metrics exposing GHC runtime information for use with prometheus-client.
package prompt-hs

A user-friendly, dependently-typed library for asking your users questions A library making use of the terminal package to prompt users for answers in a CLI context. Supports freeform text as well as choices between sum type constructors.
package proto-lens-optparse

Adapting proto-lens to optparse-applicative ReadMs. A package adapting proto-lens to optparse-applicative ReadMs. This gives an easy way to define options and arguments for text-format protobuf types.
package proto-lens-protobuf-types

Basic protocol buffer message types. This package provides bindings standard protocol message types, for use with the proto-lens library.
package proto-lens-setup

Cabal support for codegen with proto-lens. This package provides Cabal support for the proto-lens package. It automatically generates Haskell source files from protocol buffer files (.proto). To generate Haskell modules for a Cabal package, import Data.ProtoLens.Setup from the Setup.hs file. For example:
```
import Data.ProtoLens.Setup
-- Here, "src" is the directory where .proto source files may be found
main = defaultMainGeneratingProtos "src"
```
Then, edit the .cabal file of your project to:
- Specify build-type: Custom, and add a custom-setup clause that depends on proto-lens-setup.
- List the .proto files in extra-source-files. Note that the field belongs at the top level of the .cabal file, rather than once per library/executable/etc.
- List the generated modules (e.g. Proto.Foo.Bar) in exposed-modules or other-modules of the rule(s) that use them (e.g. the library or executables). Additionally, add proto-lens-runtime to the build-depends of those rules.
For example, in foo-bar-proto.cabal:
```
build-type: Custom
extra-source-files: src/foo/bar.proto
...
custom-setup
setup-depends: base, Cabal, proto-lens-setup
```
```
library
exposed-modules: Proto.Foo.Bar, Proto.Foo.Bar_Fields
autogen-modules: Proto.Foo.Bar, Proto.Foo.Bar_Fields
build-depends: proto-lens-runtime, ...
```
package proxied

Make functions consume Proxy instead of undefined proxied is a simple library that exports a function to convert constant functions to ones that take a proxy value in the Data.Proxied module. This is useful for retrofiting typeclasses that have functions that return a constant value for any value of a particular type (but still need to consume some value, since one of the parameterized types must appear in a typeclass function). Often, these functions are given undefined as an argument, which might be considered poor design. Proxy, however, does not carry any of the error-throwing risks of undefined, so it is much more preferable to take Proxy as an argument to a constant function instead of undefined. Unfortunately, Proxy wasn't included in base until GHC 7.8, so many of base's typeclasses still contain constant functions that aren't amenable to passing Proxy. proxied addresses this issue by providing variants of those typeclass functions that take an explicit proxy value. This library also contains the Data.Proxyless module, which works in the opposite direction. That is, one can take functions which take Proxy (or undefined) as an argument and convert them to functions which take no arguments. This trick relies on the -XTypeApplications extension, so it is only available with GHC 8.0 or later. This library also offers Data.Proxyless.RequiredTypeArguments, a variant of Data.Proxyless that uses -XRequiredTypeArguments to make type arguments explicit, which is only available with GHC 9.10 or later.
package psql-helpers

A small collection of helper functions to generate postgresql queries Please see README.md
package quaalude

Extremely minimal prelude Essentials is a minimal Prelude alternative containing only what is truly needed by the vast majority of modules.

Page 319 of many | Previous | Next