Hoogle Search

Within LTS Haskell 24.42 (ghc-9.10.3)

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

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 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"
```
package bech32

Implementation of the Bech32 cryptocurrency address format (BIP 0173). Implementation of the Bech32 cryptocurrency address format documented in the BIP (Bitcoin Improvement Proposal) 0173.
package bench-show

Show, plot and compare benchmark results Generate text reports and graphical charts from the benchmark results generated by gauge or criterion and stored in a CSV file. This tool is especially useful when you have many benchmarks or if you want to compare benchmarks across multiple packages. You can generate many interesting reports including:
- Show individual reports for all the fields measured e.g. time taken, peak memory usage, allocations, among many other fields measured by gauge
- Sort benchmark results on a specified criterion e.g. you may want to see the biggest cpu hoggers or biggest memory hoggers on top
- Across two benchmark runs (e.g. before and after a change), show all the operations that resulted in a regression of more than x% in descending order, so that we can quickly identify and fix performance problems in our application.
- Across two (or more) packages providing similar functionality, show all the operations where the performance differs by more than 10%, so that we can critically analyze the packages and choose the right one.
Quick Start: Use gauge or criterion to generate a results.csv file, and then use either the bench-show executable or the library APIs to generate textual or graphical reports.
```
$ bench-show report results.csv
$ bench-show graph results.csv output
```
```
report "results.csv"  Nothing defaultConfig
graph  "results.csv" "output" defaultConfig
```
There are many ways to present the reports, for example, you can show can show % regression from a baseline in descending order textually as follows:
```
(time)(Median)(Diff using min estimator)
Benchmark streamly(0)(μs)(base) streamly(1)(%)(-base)
--------- --------------------- ---------------------
zip                      644.33                +23.28
map                      653.36                 +7.65
fold                     639.96                -15.63
```
To show the same graphically: See the README and the BenchShow.Tutorial module for comprehensive documentation.
package bencode

Parsers and printers for bencoded data. Parsers and printers for bencoded data. Bencode (pronounced like B encode) is the encoding used by the peer-to-peer file sharing system BitTorrent for storing and transmitting loosely structured data.

Page 103 of many | Previous | Next