Hoogle Search

Within LTS Haskell 24.41 (ghc-9.10.3)

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

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.
package generic-deriving

Generic programming library for generalised deriving. This package provides functionality for generalising the deriving mechanism in Haskell to arbitrary classes. It was first described in the paper:
- A generic deriving mechanism for Haskell. Jose Pedro Magalhaes, Atze Dijkstra, Johan Jeuring, and Andres Loeh. Haskell'10.
The current implementation integrates with the new GHC Generics. See http://www.haskell.org/haskellwiki/GHC.Generics for more information. Template Haskell code is provided for supporting older GHCs. This library is organized as follows:
- Generics.Deriving.Base defines the core functionality for GHC generics, including the Generic(1) classes and representation data types. On modern versions of GHC, this simply re-exports GHC.Generics from base. On older versions of GHC, this module backports parts of GHC.Generics that were not included at the time, including Generic(1) instances.
- Generics.Deriving.TH implements Template Haskell functionality for deriving instances of Generic(1).
- Educational code: in order to provide examples of how to define and use GHC.Generics-based defaults, this library offers a number of modules which define examples of type classes along with default implementations for the classes' methods. Currently, the following modules are provided: Generics.Deriving.Copoint, Generics.Deriving.ConNames, Generics.Deriving.Enum, Generics.Deriving.Eq, Generics.Deriving.Foldable, Generics.Deriving.Functor, Generics.Deriving.Monoid, Generics.Deriving.Semigroup, Generics.Deriving.Show, Generics.Deriving.Traversable, and Generics.Deriving.Uniplate.
It is worth emphasizing that these modules are primarly intended for educational purposes. Many of the classes in these modules resemble other commonly used classes—for example, GShow from Generics.Deriving.Show resembles Show from base—but in general, the classes that generic-deriving defines are not drop-in replacements. Moreover, the generic defaults that generic-deriving provide often make simplifying assumptions that may violate expectations of how these classes might work elsewhere. For example, the generic default for GShow does not behave exactly like deriving Show would. If you are seeking GHC.Generics-based defaults for type classes in base, consider using the generic-data library.
- Generics.Deriving.Default provides newtypes that allow leveraging the generic defaults in this library using the DerivingVia GHC language extension.
- Generics.Deriving re-exports Generics.Deriving.Base, Generics.Deriving.Default, and a selection of educational modules.
package linear

Linear Algebra Types and combinators for linear algebra on free vector spaces
package optics-core

Optics as an abstract interface: core definitions This package makes it possible to define and use Lenses, Traversals, Prisms and other optics, using an abstract interface. . This variant provides core definitions with a minimal dependency footprint. See the optics package (and its dependencies) for documentation and the "batteries-included" variant.
package typed-process

Run external processes, with strong typing of streams Please see the tutorial at https://github.com/fpco/typed-process#readme
package MonadRandom

Random-number generation monad. Support for computations which consume random values.
package ansi-wl-pprint

The Wadler/Leijen Pretty Printer for colored ANSI terminal output This is a pretty printing library based on Wadler's paper "A Prettier Printer". It has been enhanced with support for ANSI terminal colored output using the ansi-terminal package.
package ghc-bignum

GHC BigNum library This package provides the low-level implementation of the standard BigNat, Natural and Integer types.

Page 18 of many | Previous | Next