The central monad of comptrans, defined as the Q monad with additional configuration parameters

Runs a comptrans computation, resulting in a Template Haskell command which creates some number of declarations.

CompTrans values are created by deriveMulti, deriveTrans, and deriveUntrans, and may be configured using functions such as withSubstitutions

Runs a comptrans declaration with a given set of type variable substitutions

Retrieves the names of type parameters attached to a list of type declarations, referenced by name

Runs a comptrans declaration with a given set of excluded namess

Names that should be excluded from an AST hierarchy. Includes base types, basic containers (Maybe, Either), and Text/ByteString.

A default annotation propagator: Assumes 0 or 1 annotations per constructor Returns the default annotation or copies the given annotation as appropriate.

A default annotation unpropagator: Assumes 0 or 1 annotations per constructor. If 1 annotation given, copies it.

Declares a multi-sorted compositional datatype isomorphic to the given ADT.

e.g.

import qualified Foo as F
runCompTrans $ deriveMultiComp ''F.Arith

will create

data ArithL
data AtomL
data LitL

data Arith e l where
  Add :: e AtomL -> e AtomL -> Arith e ArithL

data Atom e l where
  Var :: String -> Atom e AtomL
  Const :: e LitL -> Atom e AtomL

data Lit (e :: * -> *) l where
  Lit :: Int -> Lit e LitL

e.g.

runCompTrans $ generateNameLists ''Arith

will create

origASTTypes = [mkName Foo.Arith, mkName Foo.Atom, mkName Foo.Lit]
newASTTypes  = [mkName Arith, mkName Atom, mkName Lit]
newASTLabels = map ConT [mkName ArithL, mkName "AtomL', mkName LitL]

Creates a type-level list from a list of TH names.

Example:

-- In Names.hs
import qualified Foo as F
runCompTrans $ generateNameLists ''F.Arith -- Defines newASTTypes

-- In Types.hs
import qualified Foo as F
import Names
runCompTrans $ deriveMult ''F.arith
runCompTrans $ makeSumType "ArithSig" newASTTypes

will create

type ArithSig = '[Arith, Atom, Lit]

Creates a functions translating from an ADT to its isomorphic multi-sorted compositional data type

import qualified Foo as F
...
type ArithTerm = Term Arith
runCompTrans $ deriveTrans [''Arith, ''Atom, ''Lit] (TH.ConT ''ArithTerm)

will create,

class Trans a l where
  trans :: a -> ArithTerm l

instance Trans F.Arith ArithL where
  trans (F.Add x y) = iAdd (trans x) (trans y)

instance Trans F.Atom AtomL where
  trans (F.Var s)   = iVar s
  trans (F.Const x) = iConst (trans x)

instance Trans F.Lit LitL where
  trans (F.Lit n) = iLit n

With annotation propagation on, it will instead produce, e.g.: `trans :: F.Arith Ann -> Term (Arith :&: Ann) ArithL`

Creates an untranslate function inverting the translate function created by deriveTrans.

import qualified Foo as F
type ArithTerm = Term (Sum '[Arith, Atom, Lit])
deriveUntrans [''F.Arith, ''F.Atom, ''F.Lit] (TH.ConT ''ArithTerm)

will create

type family Targ l
newtype T l = T {t :: Targ l}

class Untrans f where
  untrans :: Alg f t

untranslate :: ArithTerm l -> Targ l
untranslate = t . cata untrans

type instance Targ ArithL = F.Arith
instance Untrans Arith where
  untrans (Add x y) = T $ F.Add (t x) (t y)

type instance Targ AtomL = F.Atom
instance Untrans Atom where
  untrans (Var s)   = T $ F.Var s
  untrans (Const x) = T $ F.Const (t x)

type instance Targ LitL = F.Lit
instance Untrans Lit where
  untrans (Lit n) = T $ F.Lit n

With annotation propagations on, it will instead produce untranslate :: Term (Arith :&: Ann) l -> Targ l Ann

where Ann is the provided annotation type.

Note that you will need to manually provide an instance (All Untrans fs) => Untrans (Sum fs) due to phase issues. (Or (All Untrans (DistAnn fs a)) => Untrans (Sum fs :&: a), if you are propagating annotations.)