Hi all,

I'd like to announce a hopefully useful new package: algebraic-classes. In 
short it provides conversions between algebraic classes and F-algebras, which 
should make generating instances of certain classes easier.

Algebraic classes are classes where every method has the same result type, 
which is the class parameter. Examples are Num and Monoid. F-algebras are 
functions of the form f a -> a, with f a functor, which can be called the 
signature of the algebra. They are equivalent as follows: Algebraic classes are 
signatures, and the instances of algebraic classes are specific algebras. Take 
for example the Monoid class:

  class Monoid a where
    mempty :: a
    mappend :: a -> a -> a

The equivalent signature would be:

  data MonoidSignature a = Op_mempty | Op_mappend a a

And the list instance 

  instance Monoid [a] where
    mempty = []
    mappend = (++)

would be equivalent to the algebra:

  listAlgebra :: MonoidSignature [a] -> [a]
  listAlgebra Op_mempty = []
  listAlgebra (Op_mappend a b) = a ++ b

And there is an obvious monoid algebra for any Monoid instance:

  evaluate :: Monoid a => MonoidSignature a -> a
  evaluate Op_mempty = mempty
  evaluate (Op_mappend a b) = mappend a b

Using Template Haskell, the algebraic-classes library can generate signatures 
and evaluation functions from algebraic classes, and class instances from 
algebras. Also, for the signatures Functor and Traversable are derived using 
the DeriveFunctor and DeriveTraversable. That makes it possible to create 
algebras generically for any signature in certain cases, which together with 
the conversions means you can generate instances generically.

Take tuples for example: if given that both components are instances of a 
class, then we can create the algebra as follows:

algebra :: (Functor f, Class f m, Class f n) => f (m, n) -> (m, n)
algebra fmn = (evaluate (fmap fst fmn), evaluate (fmap snd fmn))

And for any applicative functor we can do the same:

algebra :: (Traversable f, Applicative g, Class f a) => f (g a) -> g a
algebra = fmap evaluate . sequenceA

Taken all together, all you have to do to get for example the Monoid instance 
for Either a b (based on its applicative instance) is:

deriveInstance [t| Monoid b => Monoid (Either a b) |]

The package lives on Hackage here:


And if you have suggestions, issues (the Template Haskell code is far from 
perfect at the moment) or pull-request, it is also on Github:


Sjoerd Visscher

Haskell-Cafe mailing list

Reply via email to