Safe Haskell	Safe-Inferred
Language	Haskell2010

H.Prelude

Synopsis

Documentation

module Control.Applicative

module Control.Category

module Control.Monad

module Control.Monad.Error

module Control.Monad.Identity

module Control.Monad.Reader

module Control.Monad.State

module Data.Bool

module Data.ByteString

module Data.Char

module Data.Either

module Data.Foldable

module Data.Function

module Data.List

module Data.Map

module Data.Maybe

module Data.Monoid

module Data.Ord

module Data.Ratio

module Data.Set

module Data.Text

module Data.Text.Encoding

module Data.Traversable

module Prelude

show :: Show a => a -> Text Source

read :: Read a => Text -> Maybe a Source

todo :: a Source

error :: Text -> a Source

impossible :: Text -> a Source

whenJust :: Monad m => Maybe a -> (a -> m ()) -> m () Source

If the input is Just, do a monadic action on the value

onFst :: (a -> c) -> (a, b) -> (c, b) Source

onSnd :: (b -> c) -> (a, b) -> (a, c) Source

onFstF :: Functor f => (a -> f c) -> (a, b) -> f (c, b) Source

onSndF :: Functor f => (b -> f c) -> (a, b) -> f (a, c) Source

lift2 :: (MonadTrans t, MonadTrans u, Monad m, Monad (u m)) => m a -> t (u m) a Source

lift3 :: (MonadTrans t, MonadTrans u, MonadTrans v, Monad m, Monad (u m), Monad (t (u m))) => m a -> v (t (u m)) a Source

lift4 :: (MonadTrans t, MonadTrans u, MonadTrans v, MonadTrans w, Monad m, Monad (u m), Monad (t (u m)), Monad (v (t (u m)))) => m a -> w (v (t (u m))) a Source

modifyM :: Monad m => (s -> m s) -> StateT s m () Source

Modify the state of a StateT using a monadic action of the inner monad.

minimumByM :: Monad m => (a -> a -> m Ordering) -> [a] -> m a Source

Find the minimum element of a list using a monadic comparison action.

data Proxy a Source

Constructors

Proxy

asProxied :: a -> Proxy a -> a infix 8 Source

eitherAlt :: Alternative f => f a -> f b -> f (Either a b) infixl 3 Source

Like |, but the operands may have different value types, with Either providing a union of those two types in the result

sequenceWhileJust :: Monad m => [m (Maybe a)] -> m [a] Source

Sequence a list of actions that return Maybes, stopping at the first Nothing

headView :: [a] -> Maybe (a, [a]) Source

Deconstruct a list into its head and tail

fst3 :: (a, b, c) -> a Source

Get the first element of a triple

snd3 :: (a, b, c) -> b Source

Get the second element of a triple

thd3 :: (a, b, c) -> c Source

Get the third element of a triple

unionWithM :: (Ord k, Monad m) => (a -> a -> m a) -> Map k a -> Map k a -> m (Map k a) Source

Union two maps, with a monadic action for merging duplicates

textMsg :: Error a => Text -> a Source

Create an error from a message

whenM :: Monad m => m Bool -> m () -> m () Source

Like when, but the condition is also a monadic action