hydrogen-prelude
================
[](https://travis-ci.org/scravy/hydrogen-prelude)
+ [`about`](#about)
+ [`scravy.de/hydrogen-prelude`](http://scravy.de/hydrogen-prelude)
+ [`hackage.haskell.org/package/hydrogen-prelude`](http://hackage.haskell.org/package/hydrogen-prelude)
+ [`goodies`](#goodies)
+ [`(!)`](#--has-a--a--haskey-a--hasvalue-a)
+ [`(?)`](#--container-a--a--contained-a--bool)
+ [`tmap`](#tmap)
+ [`fmap` vs `map`](#fmap-vs-map)
+ [`__`](#__--a)
+ [`|>`](#fsharps--which-is-flip-)
+ [`safeHead`](#safehead--a--a--a)
+ [`ShowBox`](#showbox--forall-a-show-a--a--showbox)
+ [`.|`, `.&`, `.^`](#----a--bool--a--bool--a--bool)
+ [`List a`](#type-list-a--a)
+ [`Default a`](#class-default-a)
+ [`Apply a`](#class-apply-a)
+ [`re-exports`](#re-exports)
+ [`Hydrogen.Prelude`](#hydrogenprelude)
+ [`Hydrogen.Prelude.IO`](#hydrogenpreludeio)
+ [`Hydrogen.Prelude.System`](#hydrogenpreludesystem)
+ [`Hydrogen.Prelude.Network`](#hydrogenpreludenetwork)
+ [`FAQ`](#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
----------
### Hydrogen.Prelude
The Hydrogen Prelude offers you the functions and datatypes from these modules, all with one import:
+ from [`base`](http://hackage.haskell.org/package/base)
+ `module Prelude`
+ `module Control.Applicative`
+ `module Control.Arrow`
+ `module Control.Monad`
+ `module Data.Bits`
+ `module Data.Bool`
+ `module Data.Char`
+ `module Data.Complex`
+ `module Data.Complex`
+ `module Data.Dynamic`
+ `module Data.Either`
+ `module Data.Fixed`
+ `module Data.Function`
+ `module Data.Foldable`
+ `module Data.Int`
+ `module Data.Ix`
+ `module Data.List`
+ `module Data.Maybe`
+ `module Data.Ord`
+ `module Data.Ratio`
+ `module Data.String`
+ `module Data.Time`
+ `module Data.Traversable`
+ `module Data.Tuple`
+ `module Data.Typeable`
+ `module Data.Word`
+ `module Numeric`
+ `module Text.Printf`
+ from [`array`](http://hackage.haskell.org/package/array)
+ `module Data.Array`
+ from [`cereal`](http://hackage.haskell.org/package/cereal)
+ `module Data.Serialize`
+ from [`containers`](http://hackage.haskell.org/package/containers)
+ `Data.Set`, `Data.Map`, and `Data.Seq`
+ from [`hashable`](http://hackage.haskell.org/package/hashable)
+ `module Data.Hashable`
+ form [`hydrogen-multimap`](http://hackage.haskell.org/package/hydrogen-multimap)
+ `Hydrogen.MultiMap`
+ from [`hydrogen-version`](http://hackage.haskell.org/package/hydrogen-version)
+ `module Hydrogen.Version`
+ from [`regex-tdfa`](http://hackage.haskell.org/package/regex-tdfa)
+ `module Text.Regex.TDFA`
+ from [`time`](http://hackage.haskell.org/package/time)
+ `module Data.Time`
+ from [`transformers`](http://hackage.haskell.org/package/transformers)
+ `module Data.Functor.Identity`
+ `module Data.Functor.Reverse`
+ from [`uuid`](http://hackage.haskell.org/package/uuid)
+ `Data.UUID`
+ `Data.UUID.fromString` as `uuidFromString`
+ `Data.UUID.V4.nextRandom` as `randomUUID`
### Hydrogen.Prelude.IO
+ from [`base`](http://hackage.haskell.org/package/base)
+ `module Data.IORef`
+ `module Control.Concurret`
+ `module Control.Exception`
+ `module System.IO`
+ `module System.Timeout`
+ from [`strict`](http://hackage.haskell.org/package/strict)
+ strict IO functions `hGetContents'`, `getContents'`, `readFile'`, `interact'`
### Hydrogen.Prelude.System
+ from [`base`](http://hackage.haskell.org/package/base)
+ `module System.CPUTime`
+ `module System.Environment`
+ `module System.Exit`
+ `module System.Info`
+ from [`directory`](http://hackage.haskell.org/package/directory)
+ `module System.Directory`
+ from [`filepath`](http://hackage.haskell.org/package/filepath)
+ `module System.FilePath`
+ from [`process`](http://hackage.haskell.org/package/process)
+ `module System.Process`
+ from [`random`](http://hackage.haskell.org/package/random)
+ `module System.Random`
### Hydrogen.Prelude.Network
+ from [`network`](http://hackage.haskell.org/package/network)
+ `module Network`
FAQ
===
How is some of the *magic* accomplished?
----------------------------------------
Mostly with `XTypeFamilies` and `XStandaloneDeriving`.
So this works only with GHC?
----------------------------
Yes, for now at least.
What is `hydrogen`
------------------
https://www.youtube.com/watch?v=rbBX6aEzEz8