module Data.Comp.Multi.Sum
(
(:<:),
(:+:),
proj,
proj2,
proj3,
proj4,
proj5,
proj6,
proj7,
proj8,
proj9,
proj10,
project,
project2,
project3,
project4,
project5,
project6,
project7,
project8,
project9,
project10,
deepProject,
deepProject2,
deepProject3,
deepProject4,
deepProject5,
deepProject6,
deepProject7,
deepProject8,
deepProject9,
deepProject10,
inj,
inj2,
inj3,
inj4,
inj5,
inj6,
inj7,
inj8,
inj9,
inj10,
inject,
inject2,
inject3,
inject4,
inject5,
inject6,
inject7,
inject8,
inject9,
inject10,
deepInject,
deepInject2,
deepInject3,
deepInject4,
deepInject5,
deepInject6,
deepInject7,
deepInject8,
deepInject9,
deepInject10,
injectConst,
injectConst2,
injectConst3,
projectConst,
injectCxt,
liftCxt,
substHoles,
) where
import Data.Comp.Multi.Functor
import Data.Comp.Multi.Traversable
import Data.Comp.Multi.Ops
import Data.Comp.Multi.Term
import Data.Comp.Multi.Algebra
import Data.Comp.Multi.Derive.Projections
import Data.Comp.Multi.Derive.Injections
import Control.Monad (liftM)
$(liftM concat $ mapM projn [2..10])
project :: (g :<: f) => NatM Maybe (Cxt h f a) (g (Cxt h f a))
project (Hole _) = Nothing
project (Term t) = proj t
$(liftM concat $ mapM projectn [2..10])
deepProject :: (HTraversable g, g :<: f) => CxtFunM Maybe f g
deepProject = appSigFunM' proj
$(liftM concat $ mapM deepProjectn [2..10])
$(liftM concat $ mapM injn [2..10])
inject :: (g :<: f) => g (Cxt h f a) :-> Cxt h f a
inject = Term . inj
$(liftM concat $ mapM injectn [2..10])
deepInject :: (HFunctor g, g :<: f) => CxtFun g f
deepInject = appSigFun inj
$(liftM concat $ mapM deepInjectn [2..10])
injectCxt :: (HFunctor g, g :<: f) => Cxt h' g (Cxt h f a) :-> Cxt h f a
injectCxt = cata' inject
liftCxt :: (HFunctor f, g :<: f) => g a :-> Context f a
liftCxt g = simpCxt $ inj g
substHoles :: (HFunctor f, HFunctor g, f :<: g)
=> (v :-> Cxt h g a) -> Cxt h' f v :-> Cxt h g a
substHoles f c = injectCxt $ hfmap f c
injectConst :: (HFunctor g, g :<: f) => Const g :-> Cxt h f a
injectConst = inject . hfmap (const undefined)
injectConst2 :: (HFunctor f1, HFunctor f2, HFunctor g, f1 :<: g, f2 :<: g)
=> Const (f1 :+: f2) :-> Cxt h g a
injectConst2 = inject2 . hfmap (const undefined)
injectConst3 :: (HFunctor f1, HFunctor f2, HFunctor f3, HFunctor g,
f1 :<: g, f2 :<: g, f3 :<: g)
=> Const (f1 :+: f2 :+: f3) :-> Cxt h g a
injectConst3 = inject3 . hfmap (const undefined)
projectConst :: (HFunctor g, g :<: f) => NatM Maybe (Cxt h f a) (Const g)
projectConst = fmap (hfmap (const (K ()))) . project