Alternative to Prelude from @kowainik (and originally from Stephen Diehl). Main design goals for relude:

• Type-safety and function totality
• Performance
• Convenience
• Minimalism

See README.md for motivation behind relude.

A prelude that defines lots of ad-hoc typeclasses (e.g. there's IsMap with methods like lookup, insertMap, etc) and thus removes the need for most qualified imports.

It also defines some utility functions (whenM, etc) and reexports lots of commonly used modules (from time, mtl, and so on).

A prelude by Stephen Diehl. Described here by its author.

Reexports:

• base, mtl, deepseq, async, void, safe (safer functions for lists)
• Text/LText, ByteString/LByteString, Map, Set
• Some utility functions (orAlt, ordNub, whenM, etc)
• Rewrites functions/classes that aren't present in earlier versions of base (bool, Bifunctor, etc)

Other things:

• Defines a class for string conversion and generalises functions like show and print
• Renames id to identity (because it's convenient to be able to name variables id)
• Generalises map to fmap, generalises head to Foldable

Not actually an alternative Prelude, but rather a convenient way to define your own Prelude. It re-exports all of base except for Prelude.

GHC will implicitly import the module called Prelude, which is usually found in the base package. If, however, you depend on base-noprelude rather than base and your package has a module called Prelude, that will be used instead, allowing you to customise it to your needs.

A “foundation” prelude by the author of classy-prelude. Exports two modules – CorePrelude (intended for developers who want to make their own prelude), and BasicPrelude (a simple prelude for users, built on CorePrelude).

CorePrelude reexports:

• commonly used functions from Prelude and other base modules
• types (the usual bunch – Map, Vector, HashMap, ByteString, Text, etc)
• a selection of functions from other packages (lift and liftIO, </> and <.>, as well as hashing functions from hashable, functions for catching exceptions from lifted-base, and readArgs from ReadArgs, a very simple parser for command line arguments)

It also reimplements functions like putStrLn and print for Text, and a small number of utility functions (bool, equating).

BasicPrelude, additionally:

• reexports Control.Monad, methods of Foldable and Traversable, some functions from Data.List
• generalises ++, concat, and map
• replaces read, show, readFile, etc with their Text-based equivalents

Foundation is a Haskell project to implement a modern & performant standard library with various centrally maintained functionalities.

Haskell's base has been designed a while ago and shows its age. For better or worse, it's also really hard to change base, leading to many interesting but ultimately fruitless discussions, lots of wasted efforts, and/or duplicated pieces and libraries.

Also many core libraries, which brings lots of welcome modern additions to the language (text, bytestring, vector, & many others), are maintained on the side, without coordination. For example bytestring and vector doesn't share any code.

Foundation is trying to provide a solution to those technical and maintainance limitations.

A single module reexporting most definitions in base. Doesn't serve any purpose other than reducing the number of imports, but is still pretty useful. (For me it routinely shaves off 5–10 imports.)

A pretty interesting prelude – it depends on lots of commonly used packages (containers, deepseq, hashable, mtl, text, time, uuid, vector, and more), and makes their modules available to you via the Rebase.* namespace – so, for instance, instead of adding a dependency on text and importing Data.Text you can just import Rebase.Data.Text and get Data.Text, Data.Text.IO and Data.Text.Encoding simultaneously. This means that you save some imports and don't have to manually add a dependency.

It also provides a Rebase.Prelude module that reexports many non-conflicting functions and types from other modules (as well as a huge subset of base, by depending on base-prelude).

This package provides a "Prelude" module drop-in replacement for base's Prelude module.

Goals of this package include:

• Be reasonably modest and remain close in spirit to the base package's scope
• Depend only on base (via base-noprelude) for recent GHC versions
• Avoid partial functions being in scope by default; redefine common partial functions such as read or head to be Maybe-valued
• Provide a uniform "Prelude" across multiple GHC releases (currently GHC 7.0 and newer supported) to the extent possible given typeclass restructurings such as AMP or FTP
• Reduce import clutter by reexporting common verbs from modules such as Control.Monad and Control.Applicative

Yet another prelude by Michael Snoyman. From the README:

A Haskell prelude optimized for safety.

• No partial functions, period.

• Choose best in class libraries (bytestring, text, etc) and promote them.

• Regardless of the versions of underlying libraries, this package will always export a consistent API, so that CPP usage should be constrained to just inside this package.

• Use generalization (via type classes) when they are well established. For example: Foldable and Traversable yes, MonoFoldable no.

• Encourage qualified imports with a consistent naming scheme.

• Export any non-conflicting and not-discouraged names from this module that make sense, e.g. ByteString, Text, or readIORef.

Minimal prelude which fixes pain points (Text, unsafe functions, etc) in the standard prelude.

Custom prelude from @serokell team. You can checkout bigger tutorial in README.md.

Multi-package alternative prelude. papa-base exports the safe and useful things in base. papa-bifunctors exports the safe and useful things in bifunctors. papa itself exports everything from all sub-packages.

From the README:

SubHask is a radical rewrite of the Haskell Prelude. The goal is to make numerical computing in Haskell fun and fast. The main idea is to use a type safe interface for programming in arbitrary subcategories of Hask. For example, the category Vect of linear functions is a subcategory of Hask, and SubHask exploits this fact to give a nice interface for linear algebra. To achieve this goal, almost every class hierarchy is redefined to be more general.

A prelude for applications. Doesn't try to fix anything in Haskell, just reexports lots and lots of packages in a single module (aeson, lens, data-default, and so on; as well as the usual ones like bytestring, text, unordered-containers, etc).

write something here!

write something here!

write something here!