Hoogle Search

Within LTS Haskell 24.18 (ghc-9.10.3)

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

package deque

Double-ended queues Strict and lazy implementations of Double-Ended Queue (aka Dequeue or Deque) based on head-tail linked list.
package deriving-aeson

Type driven generic aeson instance customisation This package provides a newtype wrapper with FromJSON/ToJSON instances customisable via a phantom type parameter. The instances can be rendered to the original type using DerivingVia.
package df1

Type, render and parse the df1 hierarchical structured log format Type, render and parse logs in df1 format, a hierarchical structured log format that is easy for humans and fast for computers.
package diagrams-cairo

Cairo backend for diagrams drawing EDSL A full-featured backend for rendering diagrams using the cairo rendering engine. This ultimately depends on a C library, via Haskell's FFI, and can be difficult to install on some platforms. If you are just looking for a quick way to visualize diagrams, try the diagrams-svg backend; if you want raster output like PNG, try the diagrams-rasterific backend; if you want to embed diagrams in LaTeX documents, try diagrams-pgf.
- Diagrams.Backend.Cairo.CmdLine - if you're just getting started with diagrams, begin here.
- Diagrams.Backend.Cairo - look at this next. The general API for the cairo backend.
- Diagrams.Backend.Cairo.Internal - the implementation guts of the cairo backend. Users should normally not need to import this module.
- Diagrams.Backend.Cairo.List - render diagrams to two-dimensional lists of colors (i.e. pixels).
- Diagrams.Backend.Cairo.Ptr - render diagrams to buffers in memory.
package diagrams-rasterific

Rasterific backend for diagrams. A full-featured backend for rendering diagrams using the Rasterific rendering engine.
package diagrams-solve

Pure Haskell solver routines used by diagrams Pure Haskell solver routines used by the diagrams project. Currently includes finding real roots of low-degree (n < 5) polynomials, and solving tridiagonal and cyclic tridiagonal linear systems.
package directory-tree

A simple directory-like tree datatype, with useful IO functions A simple directory-like tree datatype, with useful IO functions and Foldable and Traversable instance Provides a simple data structure mirroring a directory tree on the filesystem, as well as useful functions for reading and writing file and directory structures in the IO monad. Importing the library and optional (useful) Foldable and Traverable libraries:
```
import System.Directory.Tree
import qualified Data.Foldable as F
import qualified Data.Traversable as T
```
Write a hand-made directory tree of textfiles (strings) to the disk. Simulates creating a new user Tux's home directory on a unix machine:
```
writeDirectory$ "/home" :/ Dir "Tux" [File "README" "Welcome!"]
```
"read" a directory by opening all the files at a filepath with readFile, returning an 'AnchoredDirTree String' (d2). Then check for any IO failures:
```
do (base :/ d2) <- readDirectory "../parent_dir/dir2/"
let failed = anyFailed d2
if failed then ...
```
Use Foldable instance function to concat a directory dir of text files into a single file under the same directory:
```
do (b :/ dt) <- readDirectory dir
let f = F.concat dt
return$ b :/ File "ALL_TEXT" f
```
Open all the files in the current directory as lazy bytestrings, ignoring the base path in Anchored wrapper:
```
import qualified Data.ByteString.Lazy as B
do (_ :/ dTree) <- readDirectoryWith B.readFile "./"
```
This version also offers an experimental function readDirectoryWithL that does lazy directory IO, allowing you to treat the returned DirTree as if it were a normal lazily-generated data structure. For example, the following does only the amount of IO necessary to list the file names of the children of the root directory, similar to "ls /":
```
do d <- readDirectoryWithL readFile "/"
mapM_ (putStrLn . name) $ contents $ free d
```
Any ideas or suggestions for improvements are most welcome :-) CHANGES: from 0.11
- export System.Directory.Tree.transformDir as requested
- add test suite to cabal file
- remove redundant removeNonexistent (thanks to dmwit for patch)
package distributed-process-client-server

The Cloud Haskell Application Platform Modelled after Erlang OTP's gen_server, this framework provides similar facilities for Cloud Haskell, grouping essential practices for client/server development into a set of modules and standards designed to help you build concurrent, distributed applications with relative ease.
package distributed-static

Compositional, type-safe, polymorphic static values and closures Towards Haskell in the Cloud (Epstein et al, Haskell Symposium 2011) introduces the concept of static values: values that are known at compile time. In a distributed setting where all nodes are running the same executable, static values can be serialized simply by transmitting a code pointer to the value. This however requires special compiler support, which is not yet available in ghc. We can mimick the behaviour by keeping an explicit mapping (RemoteTable) from labels to values (and making sure that all distributed nodes are using the same RemoteTable). In this module we implement this mimickry and various extensions: type safety (including for polymorphic static values) and compositionality.
package dns

DNS library in Haskell A thread-safe DNS library for both clients and servers written in pure Haskell.

Page 80 of many | Previous | Next