Hydrogen.Prelude

Documentation

module Prelude

module Control.Applicative

module Control.Arrow

module Control.Monad

module Data.Array

module Data.Bits

module Data.Bool

module Data.Char

module Data.Complex

module Data.Dynamic

module Data.Either

module Data.Fixed

module Data.Function

module Data.Functor.Identity

module Data.Functor.Reverse

module Data.Hashable

module Data.Foldable

module Data.Int

module Data.Ix

module Data.List

module Data.Maybe

module Data.Ord

module Data.Ratio

module Data.Serialize

module Data.String

module Data.Time

module Data.Tuple

module Data.Typeable

module Data.Word

module Hydrogen.Version

module Numeric

module Text.Printf

(.&) :: (a -> Bool) -> (a -> Bool) -> a -> Bool

(.|) :: (a -> Bool) -> (a -> Bool) -> a -> Bool

(=~) :: (RegexMaker Regex CompOption ExecOption source, RegexContext Regex source1 target) => source1 -> source -> target

This is the pure functional matching operator. If the target cannot be produced then some empty result will be returned. If there is an error in processing, then error will be called.

(=~~) :: (RegexMaker Regex CompOption ExecOption source, RegexContext Regex source1 target, Monad m) => source1 -> source -> m target

This is the monadic matching operator. If a single match fails, then fail will be called.

for :: Functor f => f a -> (a -> b) -> f b

class Generic a

Representable types of kind *. This class is derivable in GHC with the DeriveGeneric flag on.

Minimal complete definition

from, to

Instances

Generic Bool

Generic Char

Generic Double

Generic Float

Generic Int

Generic Ordering

Generic ()

Generic All

Generic Any

Generic Arity

Generic Fixity

Generic Associativity

Generic Version

Generic [a]

Generic (U1 p)

Generic (Par1 p)

Generic (ZipList a)

Generic (Dual a)

Generic (Endo a)

Generic (Sum a)

Generic (Product a)

Generic (First a)

Generic (Last a)

Generic (Maybe a)

Generic (Either a b)

Generic (Rec1 f p)

Generic (a, b)

Generic (Const a b)

Generic (WrappedMonad m a)

Generic (Proxy * t)

Generic (K1 i c p)

Generic ((:+:) f g p)

Generic ((:*:) f g p)

Generic ((:.:) f g p)

Generic (a, b, c)

Generic (WrappedArrow a b c)

Generic (M1 i c f p)

Generic (a, b, c, d)

Generic (a, b, c, d, e)

Generic (a, b, c, d, e, f)

Generic (a, b, c, d, e, f, g)

data Map k a :: * -> * -> *

A Map from keys k to values a.

Instances

Functor (Map k)

Foldable (Map k)

Traversable (Map k)

(Eq k, Eq a) => Eq (Map k a)

(Data k, Data a, Ord k) => Data (Map k a)

(Ord k, Ord v) => Ord (Map k v)

(Ord k, Read k, Read e) => Read (Map k e)

(Show k, Show a) => Show (Map k a)

Ord k => Monoid (Map k v)

(Ord k, Serialize k, Serialize e) => Serialize (Map k e)

(NFData k, NFData a) => NFData (Map k a)

Typeable (* -> * -> *) Map

data Set a :: * -> *

A set of values a.

Instances

Foldable Set

Eq a => Eq (Set a)

(Data a, Ord a) => Data (Set a)

Ord a => Ord (Set a)

(Read a, Ord a) => Read (Set a)

Show a => Show (Set a)

Ord a => Monoid (Set a)

(Ord a, Serialize a) => Serialize (Set a)

NFData a => NFData (Set a)

Typeable (* -> *) Set