Algebra.Core

Raw data

data ByteString

A space-efficient representation of a Word8 vector, supporting many efficient operations. A ByteString contains 8-bit characters only.

Instances of Eq, Ord, Read, Show, Data, Typeable

Instances

Eq ByteString

Data ByteString

Ord ByteString

Read ByteString

Show ByteString

Typeable ByteString

IsString ByteString

Monoid ByteString

NFData ByteString

Stream Char ByteString

readFile :: FilePath -> IO ByteString

Read an entire file strictly into a ByteString. This is far more efficient than reading the characters into a String and then using pack. It also may be more efficient than opening the file and reading it using hGet.

writeFile :: FilePath -> ByteString -> IO ()

Write a ByteString to a file.

hGetContents :: Handle -> IO ByteString

Read entire handle contents strictly into a ByteString.

This function reads chunks at a time, doubling the chunksize on each read. The final buffer is then realloced to the appropriate size. For files > half of available memory, this may lead to memory exhaustion. Consider using readFile in this case.

As with hGet, the string representation in the file is assumed to be ISO-8859-1.

The Handle is closed once the contents have been read, or if an exception is thrown.

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 a) (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 Builder

Semigroup Void

Semigroup File

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 (f b a) => Semigroup (Flip f a b)

(Semigroup (f a), Applicative g) => Semigroup (Compose' f g a)

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

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

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

Semigroup (m r) => Semigroup (ContT r 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 Builder

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 a => Monoid (Const 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 (f b a) => Monoid (Flip f a b)

(Monoid (f a), Applicative g) => Monoid (Compose' f g a)

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

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

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

Monoid (m r) => Monoid (ContT r 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]

(Ord a, Monoid a) => Ring (Set 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 (a, s, Void)) => Ring (StateT s m a)

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

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

Ring (m r) => Ring (ContT r 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 Id

Unit Accum

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 (MaybeT m)

Unit m => Unit (TreeT m)

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 f, Unit g) => Unit (Compose' f g)

Unit m => Unit (StateT s m)

Unit m => Unit (ReaderT r m)

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

Unit m => Unit (ContT r m)

Unit m => Unit (EitherT e 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)

newtype Id a

The Identity Functor

Constructors

Id

Fields

getId :: a

Instances

Unit Id

MonadFix Id

Monad Id

Applicative Id

Functor Id

Foldable Id

Contravariant Id

Isomorphic a b (Id a) (Id b)

Show a => Show (Id 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 (Kleisli m)

Monad m => Category (StateA 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 (Kleisli m)

Monad m => Choice (StateA 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 (Kleisli m)

Monad m => Split (StateA 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

is :: a -> (a -> Bool) -> Bool

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

rmod :: (RealFrac m, Ring m) => m -> m -> m

inside :: Ord t => t -> t -> t -> Bool

swap :: (a, b) -> (b, a)

Lazily ordering values

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