Hoogle Search

Within LTS Haskell 24.64 (ghc-9.10.3)

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

package haskell-src-meta

Parse source to template-haskell abstract syntax. The translation from haskell-src-exts abstract syntax to template-haskell abstract syntax isn't 100% complete yet.
package inspection-testing

GHC plugin to do inspection testing Some carefully crafted libraries make promises to their users beyond functionality and performance. Examples are: Fusion libraries promise intermediate data structures to be eliminated. Generic programming libraries promise that the generic implementation is identical to the hand-written one. Some libraries may promise allocation-free or branch-free code. Conventionally, the modus operandi in all these cases is that the library author manually inspects the (intermediate or final) code produced by the compiler. This is not only tedious, but makes it very likely that some change, either in the library itself or the surrounding eco-system, breaks the library’s promised without anyone noticing. This package provides a disciplined way of specifying such properties, and have them checked by the compiler. This way, this checking can be part of the ususal development cycle and regressions caught early. See the documentation in Test.Inspection or the project webpage for more examples and more information.
package parallel

Parallel programming library This package provides a library for parallel programming. For documentation, start from the Control.Parallel.Strategies module below. For more tutorial documentation, see the book Parallel and Concurrent Programming in Haskell. To understand the principles behind the library, see Seq no more: Better Strategies for Parallel Haskell.
package silently

Prevent or capture writing to stdout and other handles. Prevent or capture writing to stdout, stderr, and other handles.
package streaming-commons

Common lower-level functions needed by various streaming data libraries Provides low-dependency functionality commonly needed by various streaming data libraries, such as conduit and pipes.
package tasty-expected-failure

Mark tasty tests as failure expected With the function Test.Tasty.ExpectedFailure.expectFail in the provided module Test.Tasty.ExpectedFailure, you can mark that you expect test cases to fail, and not to pass. This can for example be used for test-driven development: Create the tests, mark them with Test.Tasty.ExpectedFailure.expectFail, and you can still push to the main branch, without your continuous integration branch failing. Once someone implements the feature or fixes the bug (maybe unknowingly), the test suite will tell him so, due to the now unexpectedly passing test, and he can remove the Test.Tasty.ExpectedFailure.expectFail marker. The module also provides Test.Tasty.ExpectedFailure.ignoreTest to avoid running a test. Both funtions are implemented via the more general Test.Tasty.ExpectedFailure.wrapTest, which is also provided.
package adjunctions

Adjunctions and representable functors Adjunctions and representable functors.
package cassava

A CSV parsing and encoding library cassava is a library for parsing and encoding RFC 4180 compliant comma-separated values (CSV) data, which is a textual line-oriented format commonly used for exchanging tabular data. cassava's API includes support for
- Index-based record-conversion
- Name-based record-conversion
- Typeclass directed conversion of fields and records
- Built-in field-conversion instances for standard types
- Customizable record-conversion instance derivation via GHC generics
- Low-level bytestring builders (see Data.Csv.Builder)
- Incremental decoding and encoding API (see Data.Csv.Incremental)
- Streaming API for constant-space decoding (see Data.Csv.Streaming)
Moreover, this library is designed to be easy to use; for instance, here's a very simple example of encoding CSV data:
```
>>> Data.Csv.encode [("John",27),("Jane",28)]
"John,27\r\nJane,28\r\n"
```
Please refer to the documentation in Data.Csv and the included README for more usage examples.
package data-accessor

Utilities for accessing and manipulating fields of records In Haskell 98 the name of a record field is automatically also the name of a function which gets the value of the according field. E.g. if we have data Pair a b = Pair {first :: a, second :: b} then
```
first  :: Pair a b -> a
second :: Pair a b -> b
```
However for setting or modifying a field value we need to use some syntactic sugar, which is often clumsy.
```
modifyFirst :: (a -> a) -> (Pair a b -> Pair a b)
modifyFirst f r@(Pair{first=a}) = r{first = f a}
```
With this package you can define record field accessors which allow setting, getting and modifying values easily. The package clearly demonstrates the power of the functional approach: You can combine accessors of a record and sub-records, to make the access look like the fields of the sub-record belong to the main record. Example:
```
*Data.Accessor.Example> (first^:second^=10) (('b',7),"hallo")
(('b',10),"hallo")
```
You can easily manipulate record fields in a Control.Monad.State.State monad, you can easily code Show instances that use the Accessor syntax and you can parse binary streams into records. See Data.Accessor.Example for demonstration of all features. It would be great if in revised Haskell versions the names of record fields are automatically Data.Accessor.Accessors rather than plain get functions. For now, the package data-accessor-template provides Template Haskell functions for automated generation of Data.Acesssor.Accessors. See also the other data-accessor packages that provide an Accessor interface to other data types. The package enumset provides accessors to bit-packed records. For similar packages see lenses and fclabel. A related concept are editors http://conal.net/blog/posts/semantic-editor-combinators/. Editors only consist of a modify method (and modify applied to a const function is a set function). This way, they can modify all function values of a function at once, whereas an accessor can only change a single function value, say, it can change f 0 = 1 to f 0 = 2. This way, editors can even change the type of a record or a function. An Arrow instance can be defined for editors, but for accessors only a Category instance is possible ((.) method). The reason is the arr method of the Arrow class, that conflicts with the two-way nature (set and get) of accessors.
package entropy

A platform independent entropy source A mostly platform independent method to obtain cryptographically strong entropy (RDRAND, urandom, CryptAPI, and patches welcome) Users looking for cryptographically strong (number-theoretically sound) PRNGs should see the DRBG package too.

Page 15 of many | Previous | Next