Clean.Core

Basic union and product types

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 Float

Semigroup Int

Semigroup Integer

Semigroup ()

Semigroup [a]

Ord a => Semigroup (Set a)

Semigroup (Interleave a)

Ord a => Semigroup (OrdList a)

Semigroup m => Semigroup (Dual m)

Semigroup a => Semigroup (Id a)

Semigroup a => Semigroup (ZipList a)

Semigroup b => Semigroup (a -> b)

Category k => Semigroup (Endo k a)

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

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

Semigroup w => Semigroup (Const w a)

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

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

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

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

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

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

Methods

to :: b -> a

Instances

Monoid a => SubSemi 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 Float

Monoid Int

Monoid Integer

Monoid ()

Monoid [a]

Ord a => Monoid (Set a)

Monoid (Interleave a)

Ord a => Monoid (OrdList a)

Monoid m => Monoid (Dual m)

Monoid w => Monoid (Id w)

Monoid a => Monoid (ZipList a)

Monoid b => Monoid (a -> b)

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)

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

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

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

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

class Monoid m => Ring m where

Methods

one :: m

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

Instances

Ring Bool

Ring Float

Ring Int

Ring Integer

Monoid a => Ring [a]

Ring m => Ring (Dual m)

Ring w => Ring (Id w)

Ring b => Ring (a -> b)

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

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

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

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

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

class Unit f where

Methods

pure :: a -> f a

Instances

Unit []

Unit IO

Unit Tree

Unit Interleave

Unit OrdList

Unit Id

Unit ZipTree

Unit ZipList

Unit ((->) b)

Unit (Either a)

Monoid w => Unit ((,) w)

Unit (Const a)

Unit f => Unit (Backwards f)

(Unit f, Unit g) => Unit (Compose f g)

Unit m => Unit (ContT r m)

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

Monad m => Unit (ReaderT r m)

Unit m => Unit (StateT s m)

Unit m => Unit (Kleisli m a)

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

newtype Dual m

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

Constructors

Dual

Fields

getDual :: m

Instances

Ring m => Ring (Dual m)

Monoid m => Monoid (Dual m)

Semigroup m => Semigroup (Dual m)

newtype OrdList a

An ordered list

Constructors

OrdList

Fields

getOrdList :: [a]

Instances

Unit OrdList

Ord a => Monoid (OrdList a)

Ord a => Semigroup (OrdList a)

newtype Interleave a

Constructors

Interleave

Fields

interleave :: [a]

Instances

Unit Interleave

Monad Interleave

Applicative Interleave

Functor Interleave

Foldable Interleave

Monoid (Interleave a)

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

class Category k => Choice k where

Methods

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

Instances

Choice (->)

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

Misc functions

const :: Unit f => a -> f a

(&) :: b -> (b -> c) -> c

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

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

left :: Choice k => k a c -> k (:+: a c) c

right :: Choice k => k b c -> k (:+: c b) c

ifThenElse :: Bool -> t -> t -> t

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

fail :: [Char] -> a

The rest is imported from the Prelude

module Prelude