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 timerep

Parse and display time according to some RFCs (RFC3339, RFC2822, RFC822) Parse and display time according to some RFC's. Supported:
- RFC822 http://www.ietf.org/rfc/rfc0822.txt
- RFC2822 http://www.ietf.org/rfc/rfc2822.txt
- RFC3339 http://www.ietf.org/rfc/rfc3339.txt
Special thanks to Koral for all the suggestions and help in solving some bugs.
package tree-diff

Diffing of (expression) trees. Common diff algorithm works on list structures:
```
diff :: Eq a => [a] -> [a] -> [Edit a]
```
This package works on trees.
```
treeDiff :: Eq a => Tree a -> Tree a -> Edit (EditTree a)
```
This package also provides a way to diff arbitrary ADTs, using Generics-derivable helpers. This package differs from gdiff, in a two ways: tree-diff doesn't have patch function, and the "edit-script" is a tree itself, which is useful for pretty-printing.
```
>>> prettyEditExpr $ ediff (Foo 42 [True, False] "old") (Foo 42 [False, False, True] "new")
Foo
{fooBool = [-True, +False, False, +True],
fooInt = 42,
fooString = -"old" +"new"}
```
package turtle

Shell programming, Haskell-style turtle is a reimplementation of the Unix command line environment in Haskell so that you can use Haskell as both a shell and a scripting language. Features include:
- Batteries included: Command an extended suite of predefined utilities
- Interoperability: You can still run external shell commands
- Portability: Works on Windows, OS X, and Linux
- Exception safety: Safely acquire and release resources
- Streaming: Transform or fold command output in constant space
- Patterns: Use typed regular expressions that can parse structured values
- Formatting: Type-safe printf-style text formatting
- Modern: Supports text
Read Turtle.Tutorial for a detailed tutorial or Turtle.Prelude for a quick-start guide turtle is designed to be beginner-friendly, but as a result lacks certain features, like tracing commands. If you feel comfortable using turtle then you should also check out the Shelly library which provides similar functionality.
package unagi-chan

Fast concurrent queues with a Chan-like API, and more This library provides implementations of concurrent FIFO queues (for both general boxed and primitive unboxed values) that are fast, perform well under contention, and offer a Chan-like interface. The library may be of limited usefulness outside of x86 architectures where the fetch-and-add instruction is not available. We export several variations of our design; some support additional functionality while others try for lower latency by removing features or making them more restrictive (e.g. in the Unboxed variants).
- Unagi: a general-purpose near drop-in replacement for Chan.
- Unagi.Unboxed: like Unagi but specialized for primitive types; this may perform better if a queue grows very large.
- Unagi.Bounded: a bounded variant with blocking and non-blocking writes, and other functionality where a notion of the queue's capacity is required.
- Unagi.NoBlocking: lowest latency implementations for when blocking reads aren't required.
- Unagi.NoBlocking.Unboxed: like Unagi.NoBlocking but for primitive types.
Some of these may be deprecated in the future if they are found to provide little performance benefit, or no unique features; you should benchmark and experiment with them for your use cases, and please submit pull requests for additions to the benchmark suite that reflect what you find. Here is an example benchmark measuring the time taken to concurrently write and read 100,000 messages, with work divided amongst increasing number of readers and writers, comparing against the top-performing queues in the standard libraries. The inset graph shows a zoomed-in view on the implementations here.
package unicode-collation

Haskell implementation of the Unicode Collation Algorithm This library provides a pure Haskell implementation of the Unicode Collation Algorithm described at http://www.unicode.org/reports/tr10/. It is not as fully-featured or as performant as text-icu, but it avoids a dependency on a large C library. Locale-specific tailorings are also provided.
package unicode-show

print and show in unicode This package provides variants of show and print functions that does not escape non-ascii characters. See README for usage. Run ghci with -interactive-print flag to print unicode characters. See Using a custom interactive printing function section in the GHC manual.
package unsafe

Unified interface to unsafe functions SafeHaskell introduced the notion of safe and unsafe modules. In order to make as many as possible modules "safe", the well-known unsafe functions were moved to distinguished modules. This makes it hard to write packages that work with both old and new versions of GHC. This package provides a single module System.Unsafe that exports the unsafe functions from the base package. It provides them in a style ready for qualification, that is, you should import them by
```
import qualified System.Unsafe as Unsafe
```
The package also contains a script called rename-unsafe.sh. It replaces all occurrences of the original identifiers with the qualified identifiers from this package. You still have to adapt the import commands. It uses the darcs-replace-rec script from the darcs-scripts package.
package validity-time

Validity instances for time Validity instances for time
package vector-instances

Orphan Instances for 'Data.Vector' Orphan Instances for Data.Vector.
package wai-cors

CORS for WAI This package provides an implemenation of Cross-Origin resource sharing (CORS) for Wai that aims to be compliant with http://www.w3.org/TR/cors.

Page 74 of many | Previous | Next