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.

Exact lookup

1. package relude

   Safe, performant, user-friendly and lightweight Haskell Standard Library relude is an alternative prelude library. If you find the default Prelude unsatisfying, despite its advantages, consider using relude instead.

   Relude goals and design principles

   • Productivity. You can be more productive with a "non-standard" standard library, and relude helps you with writing safer and more efficient code faster.
   • Total programming. Usage of partial functions can lead to unexpected bugs and runtime exceptions in pure code. The types of partial functions lie about their behaviour. And even if it is not always possible to rely only on total functions, relude strives to encourage best-practices and reduce the chances of introducing a bug.TODO: table
   • Type-safety. We use the "make invalid states unrepresentable" motto as one of our guiding principles. If it is possible, we express this concept through the types.Example: whenNotNull :: Applicative f => [a] -> (NonEmpty a -> f ()) -> f ()
   • Performance. We prefer Text over String, use space-leaks-free functions (e.g. our custom performant sum and product), introduce {-# INLINE #-} and {-# SPECIALIZE #-} pragmas where appropriate, and make efficient container types (e.g. Map, HashMap, Set) more accessible.
   • Minimalism (low number of dependencies). We do not force users of relude to stick to any specific lens or text formatting or logging library. Where possible, relude depends only on boot libraries. The Dependency graph of relude can give you a clearer picture.
   • Convenience. Despite minimalism, we want to bring commonly used types and functions into scope, and make available functions easier to use. Some examples of conveniences:
     1. No need to add containers, unordered-containers, text and bytestring to dependencies in your .cabal file to use the main API of these libraries
     2. No need to import types like NonEmpty, Text, Set, Reader[T], MVar, STM
     3. Functions like liftIO, fromMaybe, sortWith are available by default as well
     4. IO actions are lifted to MonadIO
   • Excellent documentation.
     1. Tutorial
     2. Migration guide from Prelude
     3. Haddock for every function with examples tested by doctest.
     4. Documentation regarding internal module structure
     5. relude-specific HLint rules: .hlint.yaml
   • User-friendliness. Anyone should be able to quickly migrate to relude. Only some basic familiarity with the common libraries like text and containers should be enough (but not necessary).
   • Exploration. We have space to experiment with new ideas and proposals without introducing breaking changes. relude uses the approach with Extra.* modules which are not exported by default. The chosen approach makes it quite easy for us to provide new functionality without breaking anything and let the users decide to use it or not.

2. package storable-complex

   Storable instance for Complex Provides a Storable instance for Complex which is binary compatible with C99, C++ and Fortran complex data types. The only purpose of this package is to provide a standard location for this instance so that other packages needing this instance can play nicely together.

3. package vinyl

   Extensible Records Extensible records for Haskell with lenses.

4. package auto-update

   Efficiently run periodic, on-demand actions API docs and the README are available at http://www.stackage.org/package/auto-update.

5. package cryptohash

   collection of crypto hashes, fast, pure and practical DEPRECATED: this library is still fully functional, but please use cryptonite for new projects and convert old one to use cryptonite. This is where things are at nowadays. A collection of crypto hashes, with a practical incremental and one-pass, pure APIs, with performance close to the fastest implementations available in other languages. The implementations are made in C with a haskell FFI wrapper that hide the C implementation. Simple examples using the unified API:

   import Crypto.Hash
   
   sha1 :: ByteString -> Digest SHA1
   sha1 = hash
   
   hexSha3_512 :: ByteString -> String
   hexSha3_512 bs = show (hash bs :: Digest SHA3_512)
   

   Simple examples using the module API:

   import qualified Crypto.Hash.SHA1 as SHA1
   
   main = putStrLn $ show $ SHA1.hash (Data.ByteString.pack [0..255])
   

   import qualified Crypto.Hash.SHA3 as SHA3
   
   main = putStrLn $ show $ digest
   where digest = SHA3.finalize ctx
   ctx    = foldl' SHA3.update iCtx (map Data.ByteString.pack [ [1,2,3], [4,5,6] ]
   iCtx   = SHA3.init 224
   

6. package cryptohash-sha256

   Fast, pure and practical SHA-256 implementation A practical incremental and one-pass, pure API to the SHA-256 cryptographic hash algorithm according to FIPS 180-4 with performance close to the fastest implementations available in other languages. The core SHA-256 algorithm is implemented in C and is thus expected to be as fast as the standard sha256sum(1) tool; for instance, on an Intel Core i7-3770 at 3.40GHz this implementation can compute a SHA-256 hash over 230 MiB of data in under one second. (If, instead, you require a pure Haskell implementation and performance is secondary, please refer to the SHA package.) Additionally, this package provides support for

   • HMAC-SHA-256: SHA-256-based Hashed Message Authentication Codes (HMAC)
   • HKDF-SHA-256: HMAC-SHA-256-based Key Derivation Function (HKDF)
   conforming to RFC6234, RFC4231, RFC5869, et al..

   Relationship to the cryptohash package and its API

   This package has been originally a fork of cryptohash-0.11.7 because the cryptohash package had been deprecated and so this package continues to satisfy the need for a lightweight package providing the SHA-256 hash algorithm without any dependencies on packages other than base and bytestring. The API exposed by cryptohash-sha256-0.11.*'s Crypto.Hash.SHA256 module is guaranteed to remain a compatible superset of the API provided by the cryptohash-0.11.7's module of the same name. Consequently, this package is designed to be used as a drop-in replacement for cryptohash-0.11.7's Crypto.Hash.SHA256 module, though with a clearly smaller footprint by almost 3 orders of magnitude.

7. package crypton-x509-store

   X.509 collection accessing and storing methods X.509 collection accessing and storing methods for certificate, crl, exception list

8. package diagrams-core

   Core libraries for diagrams EDSL The core modules underlying diagrams, an embedded domain-specific language for compositional, declarative drawing.

9. package distributed-process

   Cloud Haskell: Erlang-style concurrency in Haskell This is an implementation of Cloud Haskell, as described in Towards Haskell in the Cloud by Jeff Epstein, Andrew Black, and Simon Peyton Jones (https://simon.peytonjones.org/haskell-cloud/), although some of the details are different. The precise message passing semantics are based on A unified semantics for future Erlang by Hans Svensson, Lars-Åke Fredlund and Clara Benac Earle. You will probably also want to install a Cloud Haskell backend such as distributed-process-simplelocalnet.

10. package doclayout

    A prettyprinting library for laying out text documents. doclayout is a prettyprinting library for laying out text documents, with several features not present in prettyprinting libraries designed for code. It was designed for use in pandoc.

Page 30 of many | Previous | Next