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.

(|>) :: a -> (a -> b) -> b

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

uuidFromString :: String -> Maybe UUID

randomUUID :: IO UUID

safeHead :: a -> [a] -> a

data UUID :: *

The UUID type. A Random instance is provided which produces version 4 UUIDs as specified in RFC 4122. The Storable and Binary instances are compatible with RFC 4122, storing the fields in network order as 16 bytes.

Instances

Eq UUID

Data UUID

Ord UUID

Read UUID

Show UUID

Storable UUID

Binary UUID

Serialize UUID

NFData UUID

Hashable UUID

Random UUID

Typeable * UUID

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 LocalTime

Generic ZonedTime

Generic TimeOfDay

Generic TimeZone

Generic Day

Generic UniversalTime

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)

type List a = [a]

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)

Ord k => Has (Map k v)

TMap (Map k v)

Typeable (* -> * -> *) Map

type K (Map k v) = k

type V (Map k v) = v

type Component (Map k v) = v

type Transform ((v -> w) -> Map k v) = Map k w

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

data Seq a :: * -> *

General-purpose finite sequences.

Instances

Alternative Seq

Monad Seq

Functor Seq

MonadPlus Seq

Applicative Seq

Foldable Seq

Traversable Seq

RegexMaker Regex CompOption ExecOption (Seq Char)

RegexLike Regex (Seq Char)

RegexContext Regex (Seq Char) (Seq Char)

Eq a => Eq (Seq a)

Data a => Data (Seq a)

Ord a => Ord (Seq a)

Read a => Read (Seq a)

Show a => Show (Seq a)

Monoid (Seq a)

Serialize e => Serialize (Seq e)

NFData a => NFData (Seq a)

Extract (Seq a)

TMap (Seq a)

Typeable (* -> *) Seq

type Component (Seq a) = a

type Transform ((a -> b) -> Seq a) = Seq b

data ShowBox

Instances

Show ShowBox

class TMap a where

Associated Types

type Component x

type Transform x

Methods

tmap :: (Component a -> b) -> a -> Transform ((Component a -> b) -> a)

Instances

TMap [a]

TMap (Seq a)

TMap (a, a)

TMap (Map k v)

TMap (a, a, a)

TMap (a, a, a, a)

class Has a where

Associated Types

type K a

type V a

Methods

(!) :: a -> K a -> V a

Instances

Eq k => Has [(k, v)]

Ix i => Has (Array i e)

Ord k => Has (Map k v)

__ :: a