Description

Hydrogen Prelude.

README.md

hydrogen-prelude

about
- scravy.de/hydrogen-prelude
- hackage.haskell.org/package/hydrogen-prelude
goodies
re-exports
FAQ

about

A Prelude that exports much of the standard library (more then Prelude), without conflicts. If for example you were to import Prelude and Data.List or Data.Foldable you will run into ambiguous imports (regarding foldr for example). This Prelude aims at exporting the most general functions (in this case foldr from Data.Foldable).

It also pulls in some default packages like cereal for serialization and containers for data types like Map and Set. Every datatype exported by this Prelude comes with instances for Serialize.

Longs story short, instead of:

import Prelude hiding (
  all, and, any, concat, concatMap, elem, foldl, foldl1, foldr, foldr1,
  mapM, mapM_, maximum, minimum, notElem, or, product, sequence, sequence_, sum
 )
import "base" Control.Monad hiding (
  forM, forM_, mapM, mapM_, msum, sequence, sequence_
 )
import Data.Foldable
import Data.Traversable
import Data.List hiding (
  all, and, any, concat, concatMap, elem, find, foldl, foldl', foldl1, foldr, foldr1,
  mapAccumL, mapAccumR, maximum, maximumBy, minimum, minimumBy, notElem, or, product, sum
 )

it suffices to:

import Hydrogen.Prelude

goodies

Beyond existing functions from well-known standard packages, this prelude defines a few utilities (mostly aimed at unifying functionality across different packages, like containers and array).

`(!) :: Has a ⇒ a → HasKey a → HasValue a`

(!) is provided for several data types which associate a key and a value.

[(1, 'a'), (3, 'v')] ! 1  →  'a'

Instances are defined for

Eq k ⇒ [(k, v)]
Ix i ⇒ Array i e with HasKey → i
Ord k ⇒ Map k v with HasValue → v
Ord k ⇒ MultiMap k v with HasValue → [v]

`(?) :: Container a ⇒ a → Contained a → Bool`

Check whether the element on the right is contained in the collection on the left.

[1, 2, 4] ? 3  →  False

Instances are defined for

Eq a ⇒ [a]
Ord a ⇒ Set a
Eq a ⇒ Seq a
Ord k ⇒ Map k v with Contained → k
Ord k ⇒ MultiMap k v with Contained → k

`tmap`

A little bit like fmap but defined differently on some datatypes (applies e.g. to both components of a tuple).

tmap succ (3, 4)  →  (4, 5)

Instances are defined for

(a, a)
(a, a, a)
(a, a, a, a)
[a]
Seq a
Map k v
MultiMap k v

`fmap` vs `map`

Hydrogen Prelude exports fmap as map - the way it ought to be.

`__ :: a`

A handy shortcut for undefined.

FSharp's `|>` (which is `flip ($)`)

Use it to pipe things from one function to the other, left to right:

head xs |> fromEnum |> show

`safeHead :: a → [a] → a`

The head of the list, or the default given as first argument.

safeHead x xs = maybe x head . listToMaybe

`ShowBox :: forall a. (Show a) ⇒ a → ShowBox`

Wrap anything that is showable (can be used to build heterogeneous lists).

`.|, .&, .^ :: (a → Bool) → (a → Bool) → (a → Bool)`

Combines predicates.

filter (isDigit .| isLetter)

`type List a = [a]`

A longhand for the type of lists, if you prefer this more wordy version.

`class Default a`

A class that provides the def function for default values for types. Instances of MonadPlus automatically have an instance where def = mzero.

Default instances for most primitive types are also provided.

`class Apply a`

Provides the *$* operator which is your all-purpose application operator. It does uncurrying (if you want to apply a tupel result of a function to a function that is curryied, works with tupels of up to 5 components) and also works with Applicative, i.e. it also does fmap . uncurry:

data Operator = Operator Value OperatorType Value

parseInfixOperation :: Parser (Value, OperatorType, Value)

... Operator *$* parseInfixOperation ...

re-exports