Hoogle Search

Within LTS Haskell 24.28 (ghc-9.10.3)

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

package async-refresh

Package implementing core logic for refreshing of expiring data. This package can be used for refreshing of expiring data according to a user-provided action. Using callbacks, the user can decide how she or he would like to be informed about data refreshing.
package atomic-counter

Mutable counters that can be modified with atomic operatinos This package defines Counter type that can be safely modified concurrently from multiple threads. The type supports only few operations, namely read, write, cas (compare and swap), add, subtract and a few bitwise ones like or, and xor. Most common use case is having a shared counter that multiple threads increment. Another potential use case is lightweight locks.
package atomic-write

Atomically write to a file Atomically write to a file on POSIX-compliant systems while preserving permissions. On most Unix systems, mv is an atomic operation. This makes it simple to write to a file atomically just by using the mv operation. However, this will destroy the permissions on the original file. This library does the following to preserve permissions while atomically writing to a file:
- If an original file exists, take those permissions and apply them to the temp file before mving the file into place.
- If the original file does not exist, create a following with default permissions (based on the currently-active umask).
This way, when the file is mv'ed into place, the permissions will be the ones held by the original file. This library is based on similar implementations found in common libraries in Ruby and Python:
To use `atomic-write`, import the module corresponding to the type you wish to write atomically, e.g., to write a (strict) ByteString atomically:
```
import System.AtomicWrite.Writer.ByteString
```
Then you can use the atomicWriteFile function that accepts a FilePath and a ByteString, e.g.:
```
atomicWriteFile myFilePath myByteString
```
package attoparsec-binary

Binary processing extensions to Attoparsec. This package adds a collection of helper functions to make the task dealing with binary data of varying endianness from within an Attoparsec parser easier.
package attoparsec-data

Parsers for the standard Haskell data types Collection of parsers for various common data formats.
package authenticate-oauth

Library to authenticate with OAuth for Haskell web applications. API docs and the README are available at http://www.stackage.org/package/authenticate-oauth.
package autodocodec-schema

Autodocodec interpreters for JSON Schema Autodocodec interpreters for JSON Schema
package backprop

Heterogeneous automatic differentation Write your functions to compute your result, and the library will automatically generate functions to compute your gradient. Implements heterogeneous reverse-mode automatic differentiation, commonly known as "backpropagation". See https://backprop.jle.im for official introduction and documentation.
package base58-bytestring

Implementation of BASE58 transcoding for ByteStrings Implementation of BASE58 transcoding copy-pasted from haskoin package
package bcp47

Language tags as specified by BCP 47 Language tags for use in cases where it is desirable to indicate the language used in an information object. - https://tools.ietf.org/html/bcp47 This package exposes a language tag data type BCP47 and a Trie data structure for collecting and querying information that varies based on language tag.
```
import Data.BCP47 (en, enGB, sw)
import Data.BCP47.Trie (Trie, fromList, lookup)

color :: Trie Text
color = fromList [(en, "color"), (sw, "rangi")]

main = do
print $ match en color -- Just "color"
print $ match enGB color -- Nothing
print $ lookup enGB color -- Just "color"
```

Page 102 of many | Previous | Next