Algebra.Core

Raw data

data Handle

Haskell defines operations to read and write characters from and to files, represented by values of type Handle. Each value of this type is a handle: a record used by the Haskell run-time system to manage I/O with file system objects. A handle has at least the following properties:

• whether it manages input or output or both;
• whether it is open, closed or semi-closed;
• whether the object is seekable;
• whether buffering is disabled, or enabled on a line or block basis;
• a buffer (whose length may be zero).

Most handles will also have a current I/O position indicating where the next input or output operation will occur. A handle is readable if it manages only input or both input and output; likewise, it is writable if it manages only output or both input and output. A handle is open when first allocated. Once it is closed it can no longer be used for either input or output, though an implementation cannot re-use its storage while references remain to it. Handles are in the Show and Eq classes. The string produced by showing a handle is system dependent; it should include enough information to identify the handle for debugging. A handle is equal according to == only to itself; no attempt is made to compare the internal state of different handles for equality.

Instances

Eq Handle

Show Handle

Typeable Handle

type Bytes = ByteString

readBytes :: String -> IO Bytes

writeBytes :: String -> Bytes -> IO ()

contentBytes :: Handle -> IO Bytes

type Chunk = ByteString

readChunk :: String -> IO Chunk

writeChunk :: String -> Chunk -> IO ()

contentChunk :: Handle -> IO Chunk

readString :: String -> IO String

writeString :: String -> String -> IO ()

contentString :: Handle -> IO String

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)

Ord a => DataMap (Set a) a Void

Eq b => OrderedMap (Set a) a Void (Set b) b Void

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

Foldable m => Foldable (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 Bytes

Semigroup Chunk

Semigroup [a]

Semigroup (Maybe a)

Ord a => Semigroup (Set a)

Storable a => Semigroup (Vector 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 (Slices a)

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 (Zip f), Semigroup a) => Semigroup (Zip f a)

Applicative m => Semigroup (ListT m a)

(Ord a, Ord b) => Semigroup (Relation a b)

(Ord a, Ord b) => Semigroup (Bimap a b)

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

Applicative m => Semigroup (ProbT t 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 Bytes

Monoid Chunk

Monoid [a]

Monoid (Maybe a)

Ord a => Monoid (Set a)

Storable a => Monoid (Vector 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 (Slices a)

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 (Zip f), Monoid a) => Monoid (Zip f a)

Applicative m => Monoid (ListT m a)

(Ord a, Ord b) => Monoid (Relation a b)

(Ord a, Ord b) => Monoid (Bimap a b)

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

Applicative m => Monoid (ProbT t m a)

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

class Monoid m => Negative m where

Methods

negate :: m -> m

Instances

Negative Bool

Negative Double

Negative Float

Negative Int

Negative Integer

class Monoid m => Disjonctive m where

Methods

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

Instances

Disjonctive Bool

Disjonctive Double

Disjonctive Float

Disjonctive Int

Disjonctive Integer

Ord a => Disjonctive (Set a)

Ord k => Disjonctive (Map k a)

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

(Ord a, Ord b) => Disjonctive (Bimap a b)

class Monoid m => Semiring m where

Methods

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

Instances

Semiring Bool

Semiring Double

Semiring Float

Semiring Int

Semiring Integer

Monoid a => Semiring [a]

Ord a => Semiring (Set a)

Semiring m => Semiring (Dual m)

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

Semiring b => Semiring (a -> b)

(Ord k, Semigroup a) => Semiring (Map k a)

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

Semiring (f a) => Semiring (Backwards f a)

(Ord a, Ord b) => Semiring (Relation a b)

(Ord a, Ord b, Semigroup a, Semigroup b) => Semiring (Bimap a b)

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

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

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

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

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

class Semiring m => Ring m where

Methods

one :: 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)

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 (f a), Monoid n, Num n) => SubSemi n (f a)

class Unit f where

Methods

pure :: a -> f a

Instances

Unit []

Unit IO

Unit Maybe

Unit Tree

Unit Interleave

Unit Range

Unit OrdList

Unit Id

Unit Accum

Unit Strict

Unit ((->) b)

Unit (Either a)

Monoid w => Unit ((,) w)

Monoid a => Unit (Const a)

Unit f => Unit (Backwards f)

Unit (Zip [])

Unit (Zip Tree)

Unit m => Unit (MaybeT m)

Unit m => Unit (TreeT m)

Unit m => Unit (ListT m)

(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, Ring t) => Unit (ProbT t m)

(Unit m, Monoid w) => Unit (WriterAccT w acc 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)

Semiring m => Semiring (Dual m)

Monoid m => Monoid (Dual m)

Semigroup m => Semigroup (Dual m)

newtype Product a

The Product monoid

Constructors

Product

Fields

getProduct :: a

Instances

Isomorphic a b (Product a) (Product b)

Eq a => Eq (Product a)

Ord a => Ord (Product a)

Show a => Show (Product a)

Ring a => Monoid (Product a)

Ring a => Semigroup (Product a)

(Ring t, Monad m) => MonadWriter (Product t) (ProbT t m)

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

Traversable OrdList

Foldable OrdList

Functor 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

Traversable Interleave

Foldable Interleave

Monad Interleave

Applicative Interleave

Functor 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) => Semiring (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

Foldable Id

Monad Id

Applicative Id

Functor 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)

(<<<) :: 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)

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)

Expression-level type constraints

type Constraint a = a -> a

c'listOf :: Constraint a -> Constraint [a]

c'list :: Constraint [a]

c'int :: Constraint Int

c'float :: Constraint Float

Miscellaneous functions

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

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

($^) :: (a -> b -> c) -> b -> a -> c

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

extreme :: Bounded 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

fromMaybe :: a -> Maybe 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)

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

Ranges

newtype Range a

A range of shape (min,max) of ordered values.

Such ranges may be multiplied to create n-dimensional ranges for which equivalence means sharing an n-dimensional subrange. They may be very useful in creating Maps that partition an n-dimensional space in which we may query for subrange membership with logarithmic complexity for any point P (a point is a subrange of volume 0, or `(pure x0,...,pure xn) where (x0,..,xn) = p`).

Indeed, a point is equivalent to a range iff it belongs to that range.

Constructors

Range (a, a)

Instances

Unit Range

Ord a => Eq (Range a)

Range equivalence. Two ranges are equivalent iff they share a common subrange (equivalence in this case is not transitive, so beware of unintended consequences)

Ord a => Ord (Range a)

r < r' iff all values of r are below any value of r'

The rest is imported from the Prelude

module Prelude