algebraic-classes-0.9: Conversions between algebraic classes and F-algebras.

Copyright(c) Sjoerd Visscher 2013
LicenseBSD-style (see the file LICENSE)
Maintainersjoerd@w3future.com
Stabilityexperimental
Portabilitynon-portable
Safe HaskellNone
LanguageHaskell98

Data.Algebra

Contents

Description

 

Synopsis

Documentation

deriveInstance :: Q Type -> Q [Dec] Source #

Derive an instance for an algebraic class. For example:

deriveInstance [t| (Num m, Num n) => Num (m, n) |]

To be able to derive an instance for a of class c, we need an instance of Algebra f a, where f is the signature of c.

deriveInstance will generate a signature for the class if there is no signature in scope.

deriveInstanceWith :: Q Type -> Q [Dec] -> Q [Dec] Source #

Derive an instance for an algebraic class with a given partial implementation. For example:

deriveInstanceWith [t| Num n => Num (Integer -> n) |]
  [d|
    fromInteger x y = fromInteger (x + y)
  |]

Classes

class Algebra f a where Source #

Minimal complete definition

algebra

Methods

algebra :: AlgebraSignature f => f a -> a Source #

An algebra f a -> a corresponds to an instance of a of the class Class f. In some cases, for example for tuple types, you can give an algebra generically for every signature:

instance (Class f m, Class f n) => Algebra f (m, n) where
  algebra fmn = (evaluate (fmap fst fmn), evaluate (fmap snd fmn))

Instances

Algebra f () Source # 

Methods

algebra :: f () -> () Source #

Class f b => Algebra f (STM b) Source # 

Methods

algebra :: f (STM b) -> STM b Source #

Class f b => Algebra f (Maybe b) Source # 

Methods

algebra :: f (Maybe b) -> Maybe b Source #

Class f b => Algebra f (IO b) Source # 

Methods

algebra :: f (IO b) -> IO b Source #

Class f b => Algebra f (Either a b) Source # 

Methods

algebra :: f (Either a b) -> Either a b Source #

Class f b => Algebra f (a -> b) Source # 

Methods

algebra :: f (a -> b) -> a -> b Source #

(Class f m, Class f n) => Algebra f (m, n) Source # 

Methods

algebra :: f (m, n) -> (m, n) Source #

(Monoid m, Class f b) => Algebra f (Const * m b) Source # 

Methods

algebra :: f (Const * m b) -> Const * m b Source #

algebraA :: (Applicative g, Class f b, AlgebraSignature f) => f (g b) -> g b Source #

If you just want to applicatively lift existing instances, you can use this default implementation of algebra.

type family Signature (c :: * -> Constraint) :: * -> * Source #

The signature datatype for the class c.

class Traversable f => AlgebraSignature f where Source #

Minimal complete definition

evaluate

Associated Types

type Class f :: * -> Constraint Source #

The class for which f is the signature.

Methods

evaluate :: Class f b => f b -> b Source #

Translate the operations of the signature to method calls of the class.