Hoogle Search

Within LTS Haskell 24.45 (ghc-9.10.3)

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

package concurrency

Typeclasses, functions, and data types for concurrency and STM. A typeclass abstraction over much of Control.Concurrent (and some extras!). If you're looking for a general introduction to Haskell concurrency, you should check out the excellent Parallel and Concurrent Programming in Haskell, by Simon Marlow. If you are already familiar with concurrent Haskell, just change all the imports from Control.Concurrent.* to Control.Concurrent.Classy.* and fix the type errors.
package concurrent-extra

Extra concurrency primitives The concurrent-extra package offers among other things the following selection of synchronisation primitives:
- Broadcast: Wake multiple threads by broadcasting a value.
- Event: Wake multiple threads by signalling an event.
- Lock: Enforce exclusive access to a resource. Also known as a binary semaphore or mutex. The package additionally provides an alternative that works in the STM monad.
- RLock: A lock which can be acquired multiple times by the same thread. Also known as a reentrant mutex.
- ReadWriteLock: Multiple-reader, single-writer locks. Used to protect shared resources which may be concurrently read, but only sequentially written.
- ReadWriteVar: Concurrent read, sequential write variables.
Please consult the API documentation of the individual modules for more detailed information. This package was inspired by the concurrency libraries of Java and Python.
package concurrent-output

Ungarble output from several threads or commands Lets multiple threads and external processes concurrently output to the console, without it getting all garbled up. Built on top of that is a way of defining multiple output regions, which are automatically laid out on the screen and can be individually updated by concurrent threads. Can be used for progress displays etc.
package concurrent-supply

A fast concurrent unique identifier supply with a pure API A fast supply of concurrent unique identifiers suitable for use within a single process. Once the initial Supply has been initialized, the remainder of the API is pure. See Control.Concurrent.Supply for details.
package conduit-parse

Parsing framework based on conduit. Please refer to README.
package config-ini

A library for simple INI-based configuration files. The config-ini library is a set of small monadic languages for writing simple configuration languages with convenient, human-readable error messages.
```
parseConfig :: IniParser (Text, Int, Bool)
parseConfig = section "NETWORK" $ do
user <- field        "user"
port <- fieldOf      "port" number
enc  <- fieldFlagDef "encryption" True
return (user, port, enc)
```
package config-value

Simple, layout-based value language similar to YAML or JSON This package implements a language similar to YAML or JSON but with fewer special cases and fewer dependencies. It emphasizes layout structure for sections and lists, and requires quotes around strings.
package core-data

Convenience wrappers around common data structures and encodings Wrappers around common data structures and encodings. This is part of a library intended to ease interoperability and assist in building command-line programs, both tools and longer-running daemons. A list of features and some background to the library's design is contained in the README on GitHub.
package countable

Countable, Searchable, Finite, Empty classes
- class Countable, for countable types
- class AtLeastOneCountable, for countable types that have at least one value
- class InfiniteCountable, for infinite countable types
- class Searchable, for types that can be searched over. This turns out to include some infinite types, see http://math.andrej.com/2007/09/28/seemingly-impossible-functional-programs/.
- class Finite, for finite types
- class Singular, for singular (n = 1) types
- class Empty, for empty (n = 0) types
Some orphan instances (in their own modules):
- (Searchable a,Eq b) => Eq (a -> b)
- Finite t => Foldable ((->) t)
- Finite a => Traversable ((->) a)
- (Show a,Finite a,Show b) => Show (a -> b)
package covariance

Well-conditioned estimation of large-dimensional covariance matrices Please see the README on GitHub at https://github.com/dschrempf/covariance#readme

Page 109 of many | Previous | Next