SimpleH.Core

Basic union and product types

data Void

Instances

Monoid Void

Semigroup Void

Monoid a => SubSemi a Void

MonadError Void []

MonadError Void Maybe

Isomorphic Bool Bool (Maybe Void) (Maybe Void)

Isomorphic a b (Void, a) (Void, b)

Monad m => MonadError Void (ListT m)

(Monad m, Monoid w) => MonadError Void (ParserT w c m)

Ord a => DataMap (Set a) a Void

Foldable m => Foldable (RWST Void w Void m)

Traversable m => Traversable (RWST Void w Void m)

type :*: a b = (a, b)

type :+: a b = Either a b

Basic group and ring structure

Classes

class Semigroup m where

The class of all types that have a binary operation. Note that the operation isn't necesarily commutative (in the case of lists, for example)

Methods

(+) :: m -> m -> m

Instances

Semigroup Bool

Semigroup Double

Semigroup Float

Semigroup Int

Semigroup Integer

Semigroup ()

Semigroup Void

Semigroup [a]

Semigroup (Maybe a)

Ord a => Semigroup (Set a)

Semigroup (Interleave a)

Orderable a => Semigroup (OrdList a)

Semigroup m => Semigroup (Dual m)

Ord a => Semigroup (Max a)

Monoid a => Semigroup (Accum a)

Semigroup (StrictEndo a)

Ring a => Semigroup (Product a)

Semigroup a => Semigroup (ZipList a)

Ord t => Semigroup (Time t)

The Time semigroup where ta + tb == max ta tb

Semigroup b => Semigroup (a -> b)

Ord k => Semigroup (Map k a)

Category k => Semigroup (Endo k a)

SubSemi b a => Semigroup (:+: a b)

(Semigroup a, Semigroup b) => Semigroup (:*: a b)

Semigroup a => Semigroup (Const a b)

Semigroup (f a) => Semigroup (Backwards f a)

Applicative m => Semigroup (ListT m a)

(Ord t, Semigroup a) => Semigroup (Future t a)

Ord t => Semigroup (Event t a)

(Semigroup a, Semigroup b, Semigroup c) => Semigroup (a, b, c)

(Applicative f, Semigroup (g a)) => Semigroup (:.: f g a)

Semigroup (m r) => Semigroup (ContT r m a)

Semigroup (m (a, Void, w)) => Semigroup (WriterT w m a)

Semigroup (m (a, Void, Void)) => Semigroup (ReaderT r m a)

Semigroup (m (a, s, Void)) => Semigroup (StateT s m a)

(Monoid w, Monad m) => Semigroup (ParserT w s m a)

Semigroup (m (a, s, w)) => Semigroup (RWST r w s m a)

class Semigroup m => Monoid m where

A monoid is a semigroup with a null element such that zero + a == a + zero == a

Methods

zero :: m

Instances

Monoid Bool

Monoid Double

Monoid Float

Monoid Int

Monoid Integer

Monoid ()

Monoid Void

Monoid [a]

Monoid (Maybe a)

Ord a => Monoid (Set a)

Monoid (Interleave a)

Orderable a => Monoid (OrdList a)

Monoid m => Monoid (Dual m)

(Ord a, Bounded a) => Monoid (Max a)

Monoid a => Monoid (Accum a)

Ring a => Monoid (Product a)

Monoid a => Monoid (ZipList a)

Ord t => Monoid (Time t)

The Time monoid where zero == minBound

Monoid b => Monoid (a -> b)

Ord k => Monoid (Map k a)

Category k => Monoid (Endo k a)

(SubSemi b a, Monoid a) => Monoid (:+: a b)

(Monoid a, Monoid b) => Monoid (:*: a b)

Monoid (f a) => Monoid (Backwards f a)

Applicative m => Monoid (ListT m a)

(Ord t, Monoid a) => Monoid (Future t a)

Ord t => Monoid (Event t a)

(Monoid a, Monoid b, Monoid c) => Monoid (a, b, c)

(Applicative f, Monoid (g a)) => Monoid (:.: f g a)

Monoid (m r) => Monoid (ContT r m a)

Monoid (m (a, Void, w)) => Monoid (WriterT w m a)

Monoid (m (a, Void, Void)) => Monoid (ReaderT r m a)

Monoid (m (a, s, Void)) => Monoid (StateT s m a)

(Monoid w, Monad m) => Monoid (ParserT w s m a)

Monoid (m (a, s, w)) => Monoid (RWST r w s m a)

class Monoid m => Ring m where

Methods

one :: m

(*) :: m -> m -> m

Instances

Ring Bool

Ring Double

Ring Float

Ring Int

Ring Integer

Monoid a => Ring [a]

Ring m => Ring (Dual m)

(Ord a, Bounded a) => Ring (Max a)

Ord t => Ring (Time t)

The Time ring where (*) == min and one == maxBound

Ring b => Ring (a -> b)

(Ring a, Ring b) => Ring (:*: a b)

Ring (f a) => Ring (Backwards f a)

Ring (m r) => Ring (ContT r m a)

Ring (m (a, Void, w)) => Ring (WriterT w m a)

Ring (m (a, Void, Void)) => Ring (ReaderT r m a)

Ring (m (a, s, Void)) => Ring (StateT s m a)

Ring (m (a, s, w)) => Ring (RWST r w s m a)

class (Semigroup a, Semigroup b) => SubSemi a b where

Methods

cast :: b -> a

Instances

Monoid a => SubSemi a Void

Monoid a => SubSemi a ()

(Foldable f, Semigroup (Sized f a), Monoid n, Num n) => SubSemi n (Sized f a)

class Unit f where

Methods

pure :: a -> f a

Instances

Unit []

Unit IO

Unit Maybe

Unit Tree

Unit Interleave

Unit OrdList

Unit Accum

Unit Id

Unit ZipTree

Unit ZipList

Unit TimeVal

Unit Time

Unit ((->) b)

Unit (Either a)

Monoid w => Unit ((,) w)

Monoid a => Unit (Const a)

Unit f => Unit (Backwards f)

Unit m => Unit (ListT m)

Ord t => Unit (Future t)

Ord t => Unit (Reactive t)

Ord t => Unit (Event t)

(Unit f, Unit g) => Unit (:**: f g)

(Unit f, Unit g) => Unit (:.: f g)

Unit m => Unit (EitherT e m)

Unit m => Unit (ContT r m)

(Unit m, Monoid w) => Unit (WriterT w m)

Unit m => Unit (ReaderT r m)

Unit m => Unit (StateT s m)

(Unit m, Monoid w) => Unit (ParserT w s m)

(Unit f, Monoid w) => Unit (RWST r w s f)

Common monoids

Control monoids

newtype Endo k a

A monoid on category endomorphisms under composition

Constructors

Endo

Fields

runEndo :: k a a

Instances

Category k => Monoid (Endo k a)

Category k => Semigroup (Endo k a)

Isomorphic (k a a) (k b b) (Endo k a) (Endo k b)

newtype StrictEndo a

Constructors

StrictEndo

Fields

runStrictEndo :: a -> a

Instances

Semigroup (StrictEndo a)

Meta-monoids

newtype Dual m

The dual of a monoid is the same as the original, with arguments reversed

Constructors

Dual

Fields

getDual :: m

Instances

Isomorphic a b (Dual a) (Dual b)

Ring m => Ring (Dual m)

Monoid m => Monoid (Dual m)

Semigroup m => Semigroup (Dual m)

newtype Product a

The Product monoid

Constructors

Product

Fields

getProduct :: a

Instances

Ring a => Monoid (Product a)

Ring a => Semigroup (Product a)

Accumulating monoids

newtype OrdList a

An ordered list. The semigroup instance merges two lists so that the result remains in ascending order.

Constructors

OrdList

Fields

getOrdList :: [a]

Instances

Unit OrdList

Functor OrdList

Foldable OrdList

Traversable OrdList

Eq a => Eq (OrdList a)

Ord a => Ord (OrdList a)

Show a => Show (OrdList a)

Orderable a => Monoid (OrdList a)

Orderable a => Semigroup (OrdList a)

Isomorphic [a] [b] (OrdList a) (OrdList b)

newtype Interleave a

Constructors

Interleave

Fields

interleave :: [a]

Instances

Unit Interleave

Monad Interleave

Applicative Interleave

Functor Interleave

Foldable Interleave

Traversable Interleave

Monoid (Interleave a)

Semigroup (Interleave a)

newtype Accum a

A monoid on Maybes, where the sum is the leftmost non-Nothing value.

Constructors

Accum

Fields

getAccum :: Maybe a

Instances

Unit Accum

Monoid a => Monoid (Accum a)

Monoid a => Semigroup (Accum a)

newtype Max a

The Max monoid, where (+) =~ max

Constructors

Max

Fields

getMax :: a

Instances

Isomorphic a b (Max a) (Max b)

Bounded a => Bounded (Max a)

Eq a => Eq (Max a)

Ord a => Ord (Max a)

Show a => Show (Max a)

Ord t => Orderable (Max t)

(Ord a, Bounded a) => Ring (Max a)

(Ord a, Bounded a) => Monoid (Max a)

Ord a => Semigroup (Max a)

Fundamental control operations

class Category k where

Methods

id :: k a a

(.) :: k b c -> k a b -> k a c

Instances

Category (->)

Monad m => Category (StateA m)

Monad m => Category (Kleisli m)

Category k => Category (ListA k)

(Monoid w, Monad m) => Category (ParserA w m)

(<<<) :: Category k => k b c -> k a b -> k a c

(>>>) :: Category k => k a b -> k b c -> k a c

(+++) :: Split k => (a -> k c c) -> (b -> k d d) -> (a :+: b) -> k (c, d) (c, d)

Splitting and Choosing

class Category k => Choice k where

Methods

(<|>) :: k a c -> k b c -> k (a :+: b) c

Instances

Choice (->)

Monad m => Choice (StateA m)

Monad m => Choice (Kleisli m)

Arrow k => Choice (ListA k)

(Monoid w, Monad m) => Choice (ParserA w m)

class Category k => Split k where

Methods

(<#>) :: k a c -> k b d -> k (a, b) (c, d)

Instances

Split (->)

Monad m => Split (StateA m)

Monad m => Split (Kleisli m)

Arrow k => Split (ListA k)

(Monoid w, Monad m) => Split (ParserA w m)

Misc functions

const :: Unit m => a -> m a

(&) :: a -> (a -> b) -> b

fix :: (a -> a) -> a

first :: Split k => k a b -> k (a, c) (b, c)

second :: Split k => k a b -> k (c, a) (c, b)

ifThenElse :: Bool -> a -> a -> a

bool :: a -> a -> Bool -> a

guard :: (Unit m, Monoid (m ())) => Bool -> m ()

fail :: String -> a

unit :: Unit m => m ()

when :: Unit m => Bool -> m () -> m ()

unless :: Unit m => Bool -> m () -> m ()

tailSafe :: [a] -> [a]

headDef :: a -> [a] -> a

To use with OrdList

class Ord t => Orderable t where

Methods

inOrder :: t -> t -> (t, t, Bool)

Instances

Ord t => Orderable (Max t)

Ord t => Orderable (Time t)

Ord t => Orderable (Future t a)

comparing :: Ord a => (b -> a) -> b -> b -> Ordering

 comparing p x y = compare (p x) (p y)

Useful combinator for use in conjunction with the xxxBy family of functions from Data.List, for example:

   ... sortBy (comparing fst) ...

insertOrd :: Orderable t => t -> [t] -> [t]

invertOrd :: Ordering -> Ordering

The rest is imported from the Prelude

module Prelude