author:Neil-Mitchell

Library for manipulating FilePaths in a cross platform way. This package provides functionality for manipulating FilePath values, and is shipped with GHC. It provides two variants for filepaths:

1. legacy filepaths: type FilePath = String
2. operating system abstracted filepaths (OsPath): internally unpinned ShortByteString (platform-dependent encoding)

It is recommended to use OsPath when possible, because it is more correct. For each variant there are three main modules:

• System.FilePath.Posix / System.OsPath.Posix manipulates POSIX/Linux style FilePath values (with / as the path separator).
• System.FilePath.Windows / System.OsPath.Windows manipulates Windows style FilePath values (with either \ or / as the path separator, and deals with drives).
• System.FilePath / System.OsPath for dealing with current platform-specific filepaths

For more powerful string manipulation of OsPath, you can use the os-string package (OsPath is a type synonym for OsString). An introduction into the new API can be found in this blog post. Code examples for the new API can be found here.

Library of safe (exception free) functions A library wrapping Prelude/Data.List functions that can throw exceptions, such as head and !!. Each unsafe function has up to four variants, e.g. with tail:

• tail :: [a] -> [a], raises an error on tail [].
• tailMay :: [a] -> Maybe [a], turns errors into Nothing.
• tailDef :: [a] -> [a] -> [a], takes a default to return on errors.
• tailNote :: String -> [a] -> [a], takes an extra argument which supplements the error message.
• tailSafe :: [a] -> [a], returns some sensible default if possible, [] in the case of tail.

This package is divided into three modules:

• Safe contains safe variants of Prelude and Data.List functions.
• Safe.Foldable contains safe variants of Foldable functions.
• Safe.Exact creates crashing versions of functions like zip (errors if the lists are not equal) and take (errors if there are not enough elements), then wraps them to provide safe variants.

Extra functions I use. A library of extra functions for the standard Haskell libraries. Most functions are simple additions, filling out missing functionality. A few functions are available in later versions of GHC, but this package makes them available back to GHC 7.2. The module Extra documents all functions provided by this library. Modules such as Data.List.Extra provide extra functions over Data.List and also reexport Data.List. Users are recommended to replace Data.List imports with Data.List.Extra if they need the extra functionality.

Command line argument processing This library provides an easy way to define command line parsers. Most users will want to use the System.Console.CmdArgs.Implicit module, whose documentation contains an example.

• System.Console.CmdArgs.Explicit provides a way to write command line parsers for both single mode programs (most programs) and multiple mode programs (e.g. darcs or cabal). Parsers are defined by constructing a data structure.
• System.Console.CmdArgs.Implicit provides a way to concisely define command line parsers, up to three times shorter than getopt. These parsers are translated into the Explicit data type.
• System.Console.CmdArgs.GetOpt provides a wrapper allowing compatiblity with existing getopt parsers, mapping to the Explicit data type.

For a general reference on what command line flags are commonly used, see http://www.faqs.org/docs/artu/ch10s05.html.

Parsing and extracting information from (possibly malformed) HTML/XML documents TagSoup is a library for parsing HTML/XML. It supports the HTML 5 specification, and can be used to parse either well-formed XML, or unstructured and malformed HTML from the web. The library also provides useful functions to extract information from an HTML document, making it ideal for screen-scraping. Users should start from the Text.HTML.TagSoup module.

Source code suggestions HLint gives suggestions on how to improve your source code.

Help writing simple, concise and fast generic operations. Uniplate is library for writing simple and concise generic operations. Uniplate has similar goals to the original Scrap Your Boilerplate work, but is substantially simpler and faster. To get started with Uniplate you should import one of the three following modules:

• Data.Generics.Uniplate.Data - to quickly start writing generic functions. Most users should start by importing this module.
• Data.Generics.Uniplate.Direct - a replacement for Data.Generics.Uniplate.Data with substantially higher performance (around 5 times), but requires writing instance declarations.
• Data.Generics.Uniplate.Operations - definitions of all the operations defined by Uniplate. Both the above two modules re-export this module.

In addition, some users may want to make use of the following modules:

• Data.Generics.Uniplate.Zipper - a zipper built on top of Uniplate instances.
• Data.Generics.SYB - users transitioning from the Scrap Your Boilerplate library.
• Data.Generics.Compos - users transitioning from the Compos library.
• Data.Generics.Uniplate.DataOnly - users making use of both Data and Direct to avoid getting instance conflicts.

Not on Stackage, so not searched. A program and library to derive instances for data types

Build system library, like Make, but more accurate dependencies. Shake is a Haskell library for writing build systems - designed as a replacement for make. See Development.Shake for an introduction, including an example. The homepage contains links to a user manual, an academic paper and further information: https://shakebuild.com To use Shake the user writes a Haskell program that imports Development.Shake, defines some build rules, and calls the Development.Shake.shakeArgs function. Thanks to do notation and infix operators, a simple Shake build system is not too dissimilar from a simple Makefile. However, as build systems get more complex, Shake is able to take advantage of the excellent abstraction facilities offered by Haskell and easily support much larger projects. The Shake library provides all the standard features available in other build systems, including automatic parallelism and minimal rebuilds. Shake also provides more accurate dependency tracking, including seamless support for generated files, and dependencies on system information (e.g. compiler version).

Combinators for executing IO actions in parallel on a thread pool. This package provides combinators for sequencing IO actions onto a thread pool. The thread pool is guaranteed to contain no more unblocked threads than a user-specified upper limit, thus minimizing contention. Furthermore, the parallel combinators can be used reentrantly - your parallel actions can spawn more parallel actions - without violating this property of the thread pool. The package is inspired by the thread http://thread.gmane.org/gmane.comp.lang.haskell.cafe/56499/focus=56521. Thanks to Neil Mitchell and Bulat Ziganshin for some of the code this package is based on.

File path glob-like matching A library for matching files using patterns such as "src/**/*.png" for all .png files recursively under the src directory. Features:

• All matching is O(n). Most functions precompute some information given only one argument.
• See System.FilePattern and ?== simple matching and semantics.
• Use match and substitute to extract suitable strings from the * and ** matches, and substitute them back into other patterns.
• Use step and matchMany to perform bulk matching of many patterns against many paths simultaneously.
• Use System.FilePattern.Directory to perform optimised directory traverals using patterns.

Originally taken from the Shake library.

A tiling window manager xmonad is a tiling window manager for X. Windows are arranged automatically to tile the screen without gaps or overlap, maximising screen use. All features of the window manager are accessible from the keyboard: a mouse is strictly optional. xmonad is written and extensible in Haskell. Custom layout algorithms, and other extensions, may be written by the user in config files. Layouts are applied dynamically, and different layouts may be used on each workspace. Xinerama is fully supported, allowing windows to be tiled on several screens.

Obtain minified jQuery code This package bundles the minified jQuery code into a Haskell package, so it can be depended upon by Cabal packages. The first three components of the version number match the upstream jQuery version. The package is designed to meet the redistribution requirements of downstream users (e.g. Debian).

Library for manipulating RawFilePaths in a cross platform way. This package provides functionality for manipulating RawFilePath values. It can be used as a drop in replacement for the filepath library to get the benefits of using ByteStrings. It provides three modules:

• System.FilePath.Posix.ByteString manipulates POSIX/Linux style RawFilePath values (with / as the path separator).
• System.FilePath.Windows.ByteString manipulates Windows style RawFilePath values (with either \ or / as the path separator, and deals with drives).
• System.FilePath.ByteString is an alias for the module appropriate to your platform.

All three modules provide the same API, and the same documentation (calling out differences in the different variants). This package is now deprecated, since filepath 1.4.100.0 provides an OsPath type that is based on a bytestring. See https:/hasufell.github.ioposts/2022-06-29-fixing-haskell-filepaths.html

Haskell API Search Hoogle is a Haskell API search engine, which allows you to search many standard Haskell libraries by either function name, or by approximate type signature.

GHCi based bare bones IDE Either "GHCi as a daemon" or "GHC + a bit of an IDE". A very simple Haskell development tool which shows you the errors in your project and updates them whenever you save. Run ghcid --topmost --command=ghci, where --topmost makes the window on top of all others (Windows only) and --command is the command to start GHCi on your project (defaults to ghci if you have a .ghci file, or else to cabal repl).

A version of GHC.Records as available in future GHCs. This package provides a version of GHC.Records as it will be after the implementation of GHC proposal #42, plus some helper functions over it.

XML subset DOM parser An XML DOM-style parser, that only parses a subset of XML, but is designed to be fast.

Obtain minified jquery.dgtable code This package bundles the minified jquery.dgtable code into a Haskell package, so it can be depended upon by Cabal packages. The first three components of the version number match the upstream jquery.dgtable version. The package is designed to meet the redistribution requirements of downstream users (e.g. Debian).

Obtain minified flot code This package bundles the minified Flot code (a jQuery plotting library) into a Haskell package, so it can be depended upon by Cabal packages. The first three components of the version number match the upstream flot version. The package is designed to meet the redistribution requirements of downstream users (e.g. Debian).

Preprocessor to allow record.field syntax In almost every programming language a.b will get the b field from the a data type, and many different data types can have a b field. The reason this feature is ubiquitous is because it's useful. The record-dot-preprocessor brings this feature to Haskell - see the README for full details.

Not on Stackage, so not searched. Yhc's Internal Core language.

Not on Stackage, so not searched. Library for safe (pattern match free) functions

Not on Stackage, so not searched. Build Systems à la Carte

Not on Stackage, so not searched. Conveniently run shell commands