Hoogle Search

Within LTS Haskell 24.34 (ghc-9.10.3)

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

package paramtree

Generate labelled test/benchmark trees from sets of parameters Easily generate a labelled tree of tests/benchmarks from a generation function and sets of parameters to use for each of that functions arguments. Example usecases include criterion benchmark trees or tasty test trees.
package parseargs

Parse command-line arguments Full-featured command-line argument parsing library.
package parsec-numbers

Utilities for parsing numbers from strings parsec-numbers provides the number parsers without the need to use a large (and unportable) token parser
package parser-regex

Regex based parsers Regex based parsers. See
- Regex.Text To work with Text from the text library.
- Regex.List To work with Strings or lists.
- Regex.Base To work with other sequences.
package partial-isomorphisms

Partial isomorphisms. Partial isomorphisms as described in the paper: Tillmann Rendel and Klaus Ostermann. Invertible Syntax Descriptions: Unifying Parsing and Pretty Printing. In Proc. of Haskell Symposium, 2010. The paper also describes invertible syntax descriptions as a common interface for parsers and pretty printers. These are distributed separately in the invertible-syntax package.
package password

Hashing and checking of passwords A library providing functionality for working with plain-text and hashed passwords with different types of algorithms.
API
Every supported hashing algorithm has its own module (e.g. Data.Password.Bcrypt) which exports its own hashPassword and checkPassword functions, as well as all the types and functions in this module. If you are not sure about the specifics of an algorithm you want to use, you can rest assured that by using the hashPassword function of the respective algorithm you are not making any big mistakes, security-wise. Of course, if you know what you're doing and you want more fine-grained control over the hashing function, you can adjust it using the hashPasswordWithParams function of the respective algorithm.
Algorithms
Generally, the most "secure" algorithm is believed to be Argon2, then scrypt, then bcrypt, and lastly PBKDF2. bcrypt and PBKDF2 are the most established algorithms, so they have been tried and tested, though they both lack a memory cost, and therefore have a greater vulnerability to specialized hardware attacks. When choosing an algorithm, and you have no idea which to pick, just go for bcrypt if your password does not need the highest security possible. It's still a fine way for hashing passwords, and the cost is easily adjustable if needed. If your needs do require stronger protection, you should find someone who can advise you on this topic. (And if you're already knowledgeable enough, you know what to do)
package password-instances

typeclass instances for password package A library providing typeclass instances for common libraries for the types from the password package.
package path-like

PathLike, FileLike and DirLike type classes for the Path library. Type classes for the Path library. Exports PathLike, FileLike and DirLike classes so that stricter types may be used as Paths.
package pathtype

Type-safe replacement for System.FilePath etc This package provides type-safe access to filepath manipulations. System.Path is designed to be used instead of System.FilePath. (It is intended to provide versions of functions from that module which have equivalent functionality but are more typesafe). System.Path.Directory is a companion module providing a type-safe alternative to System.Directory. The heart of this package is the Path ar fd abstract type which represents file and directory paths. The idea is that there are two type parameters - the first should be Abs or Rel, and the second File or Dir. A number of type synonyms are provided for common types:
```
type Path.AbsFile = Path Abs File
type Path.RelFile = Path Rel File
type Path.AbsDir  = Path Abs Dir
type Path.RelDir  = Path Rel Dir

type Path.Abs  fd = Path Abs fd
type Path.Rel  fd = Path Rel fd
type Path.File ar = Path ar File
type Path.Dir  ar = Path ar Dir
```
The type of the combine (aka </>) function gives the idea:
```
(</>) :: Path.Dir ar -> Path.Rel fd -> Path ar fd
```
Together this enables us to give more meaningful types to a lot of the functions, and (hopefully) catch a bunch more errors at compile time. For more details see the README.md file. Related packages:
- filepath: The API of Neil Mitchell's System.FilePath module (and properties satisfied) heavily influenced our package.
- path: Provides a wrapper type around FilePath and maps to functions from filepath package. This warrants consistency with filepath functions. Requires Template Haskell.
- data-filepath: Requires Typeable and Template Haskell.
- hpath: ByteString-based path type with type parameter for absolute and relative paths.
package pathwalk

Path walking utilities for Haskell programs System.Directory.PathWalk is an implementation of Python's excellent os.walk function. Given a root directory, it recursively scans all subdirectories, calling a callback with directories and files it finds. Importantly, it calls the callback as soon as it finishes scanning each directory to allow the caller to begin processing results immediately. Maximum memory usage is O(N+M) where N is the depth of the tree and M is the maximum number of entries in a particular directory.
```
import System.Directory.PathWalk

pathWalk "some/directory" $ \root dirs files -> do
forM_ files $ \file ->
when (".hs" `isSuffixOf` file) $ do
putStrLn $ joinPath [root, file]
```

Page 225 of many | Previous | Next

Hoogle Search

API

Algorithms