Portability | non-portable |
---|---|
Stability | experimental |
Maintainer | sjoerd@w3future.com |
Safe Haskell | None |
- deriveInstance :: Q Type -> Q [Dec]
- deriveInstanceWith :: Q Type -> Q [Dec] -> Q [Dec]
- class Algebra f a where
- algebra :: AlgebraSignature f => f a -> a
- algebraA :: (Applicative g, Class f b, AlgebraSignature f) => f (g b) -> g b
- class Traversable f => AlgebraSignature f where
- type Class f :: * -> Constraint
- evaluate :: Class f b => f b -> b
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
,
where Algebra
f af
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
algebra :: AlgebraSignature f => f a -> aSource
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))
algebraA :: (Applicative g, Class f b, AlgebraSignature f) => f (g b) -> g bSource
If you just want to applicatively lift existing instances, you can use this default implementation of algebra
.
class Traversable f => AlgebraSignature f whereSource
type Class f :: * -> ConstraintSource
The class for which f
is the signature.