Hoogle Search

Within LTS Haskell 24.4 (ghc-9.10.2)

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

package microlens

A tiny lens library with no dependencies NOTE: If you're writing an app, you probably want microlens-platform – it has the most features. microlens is intended more for library writers who want a tiny lens library (after all, lenses are pretty useful for everything, not just for updating records!). This library is an extract from lens (with no dependencies). It's not a toy lenses library, unsuitable for “real world”, but merely a small one. It is compatible with lens, and should have same performance. It also has better documentation. There's a longer readme on Github. It has a migration guide for lens users, a description of other packages in the family, a discussion of other lens libraries you could use instead, and so on. Here are some usecases for this library:
- You want to define lenses or traversals in your own library, but don't want to depend on lens. Having lenses available often make working with a library more pleasant.
- You just want to be able to use lenses to transform data (or even just use over _1 to change the first element of a tuple).
- You are new to lenses and want a small library to play with.
However, don't use this library if:
- You need Isos, Prisms, indexed traversals, or actually anything else which isn't defined here (though some indexed functions are available elsewhere – containers and vector provide them for their types, and ilist provides indexed functions for lists).
- You want a library with a clean, understandable implementation (in which case you're looking for lens-simple).
As already mentioned, if you're writing an application which uses lenses more extensively, look at microlens-platform – it combines features of most other microlens packages (microlens-mtl, microlens-th, microlens-ghc). If you want to export getters or folds and don't mind the contravariant dependency, please consider using microlens-contra. If you haven't ever used lenses before, read this tutorial. (It's for lens, but it applies to microlens just as well.) Note that microlens has no dependencies starting from GHC 7.10 (base-4.8). Prior to that, it depends on transformers-0.2 or above.
package memory

memory and related abstraction stuff Chunk of memory, polymorphic byte array management and manipulation
- A polymorphic byte array abstraction and function similar to strict ByteString.
- Different type of byte array abstraction.
- Raw memory IO operations (memory set, memory copy, ..)
- Aliasing with endianness support.
- Encoding : Base16, Base32, Base64.
- Hashing : FNV, SipHash
package transformers-compat

A small compatibility shim for the transformers library This package includes backported versions of types that were added to transformers in transformers 0.3, 0.4, and 0.5 for users who need strict transformers 0.2 or 0.3 compatibility to run on old versions of the platform, but also need those types. Those users should be able to just depend on transformers >= 0.2 and transformers-compat >= 0.3. Note: missing methods are not supplied, but this at least permits the types to be used.
package megaparsec

Monadic parser combinators This is an industrial-strength monadic parser combinator library. Megaparsec is a feature-rich package that tries to find a nice balance between speed, flexibility, and quality of parse errors.
package safe

Library of safe (exception free) functions A library wrapping Prelude/Data.List functions that can throw exceptions, such as head and !!. Each unsafe function has up to four variants, e.g. with tail:
- tail :: [a] -> [a], raises an error on tail [].
- tailMay :: [a] -> Maybe [a], turns errors into Nothing.
- tailDef :: [a] -> [a] -> [a], takes a default to return on errors.
- tailNote :: String -> [a] -> [a], takes an extra argument which supplements the error message.
- tailSafe :: [a] -> [a], returns some sensible default if possible, [] in the case of tail.
This package is divided into three modules:
- Safe contains safe variants of Prelude and Data.List functions.
- Safe.Foldable contains safe variants of Foldable functions.
- Safe.Exact creates crashing versions of functions like zip (errors if the lists are not equal) and take (errors if there are not enough elements), then wraps them to provide safe variants.
package syb

Scrap Your Boilerplate This package contains the generics system described in the Scrap Your Boilerplate papers (see http://www.cs.uu.nl/wiki/GenericProgramming/SYB). It defines the Data class of types permitting folding and unfolding of constructor applications, instances of this class for primitive types, and a variety of traversals.
package semigroupoids

Semigroupoids: Category sans id Provides a wide array of (semi)groupoids and operations for working with them. A Semigroupoid is a Category without the requirement of identity arrows for every object in the category. A Category is any Semigroupoid for which the Yoneda lemma holds. When working with comonads you often have the <*> portion of an Applicative, but not the pure. This was captured in Uustalu and Vene's "Essence of Dataflow Programming" in the form of the ComonadZip class in the days before Applicative. Apply provides a weaker invariant, but for the comonads used for data flow programming (found in the streams package), this invariant is preserved. Applicative function composition forms a semigroupoid. Similarly many structures are nearly a comonad, but not quite, for instance lists provide a reasonable extend operation in the form of tails, but do not always contain a value. We describe the relationships between the type classes defined in this package and those from base (and some from contravariant) in the diagram below. Thick-bordered nodes correspond to type classes defined in this package; thin-bordered ones correspond to type classes from elsewhere. Solid edges indicate a subclass relationship that actually exists; dashed edges indicate a subclass relationship that should exist, but currently doesn't. Apply, Bind, and Extend (not shown) give rise the Static, Kleisli and Cokleisli semigroupoids respectively. This lets us remove many of the restrictions from various monad transformers as in many cases the binding operation or <*> operation does not require them. Finally, to work with these weaker structures it is beneficial to have containers that can provide stronger guarantees about their contents, so versions of Traversable and Foldable that can be folded with just a Semigroup are added.
package validity

Validity typeclass For more info, see the readme. Note: There are companion instance packages for this library:
package ansi-terminal

Simple ANSI terminal support ANSI terminal support for Haskell: allows cursor movement, screen clearing, color output, showing or hiding the cursor, and changing the title. Works on UNIX and Windows.
package base-compat

A compatibility layer for base Provides functions available in later versions of base to a wider range of compilers, without requiring you to use CPP pragmas in your code. See the README for what is covered. Also see the changelog for recent changes. Note that base-compat does not add any orphan instances. There is a separate package, base-orphans, for that. In addition, base-compat does not backport any data types or type classes. See this section of the README for more info. base-compat is designed to have zero dependencies. For a version of base-compat that depends on compatibility libraries for a wider support window, see the base-compat-batteries package. Most of the modules in this library have the same names as in base-compat-batteries to make it easier to switch between the two. There also exist versions of each module with the suffix .Repl, which are distinct from anything in base-compat-batteries, to allow for easier use in GHCi.

Page 8 of many | Previous | Next