{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE ConstraintKinds #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
module Futhark.Transform.Rename
(
renameProg
, renameExp
, renameStm
, renameBody
, renameLambda
, renamePattern
, RenameM
, substituteRename
, renamingStms
, Rename (..)
, Renameable
)
where
import Control.Monad.State
import Control.Monad.Reader
import qualified Data.Map.Strict as M
import Data.Maybe
import Futhark.Representation.AST.Syntax
import Futhark.Representation.AST.Traversals
import Futhark.Representation.AST.Attributes.Names
import Futhark.Representation.AST.Attributes.Patterns
import Futhark.FreshNames hiding (newName)
import Futhark.MonadFreshNames (MonadFreshNames(..), modifyNameSource, newName)
import Futhark.Transform.Substitute
runRenamer :: RenameM a -> VNameSource -> (a, VNameSource)
runRenamer :: RenameM a -> VNameSource -> (a, VNameSource)
runRenamer (RenameM StateT VNameSource (Reader RenameEnv) a
m) VNameSource
src = Reader RenameEnv (a, VNameSource) -> RenameEnv -> (a, VNameSource)
forall r a. Reader r a -> r -> a
runReader (StateT VNameSource (Reader RenameEnv) a
-> VNameSource -> Reader RenameEnv (a, VNameSource)
forall s (m :: * -> *) a. StateT s m a -> s -> m (a, s)
runStateT StateT VNameSource (Reader RenameEnv) a
m VNameSource
src) RenameEnv
env
where env :: RenameEnv
env = Map VName VName -> RenameEnv
RenameEnv Map VName VName
forall k a. Map k a
M.empty
renameProg :: (Renameable lore, MonadFreshNames m) =>
Prog lore -> m (Prog lore)
renameProg :: Prog lore -> m (Prog lore)
renameProg Prog lore
prog = (VNameSource -> (Prog lore, VNameSource)) -> m (Prog lore)
forall (m :: * -> *) a.
MonadFreshNames m =>
(VNameSource -> (a, VNameSource)) -> m a
modifyNameSource ((VNameSource -> (Prog lore, VNameSource)) -> m (Prog lore))
-> (VNameSource -> (Prog lore, VNameSource)) -> m (Prog lore)
forall a b. (a -> b) -> a -> b
$ RenameM (Prog lore) -> VNameSource -> (Prog lore, VNameSource)
forall a. RenameM a -> VNameSource -> (a, VNameSource)
runRenamer (RenameM (Prog lore) -> VNameSource -> (Prog lore, VNameSource))
-> RenameM (Prog lore) -> VNameSource -> (Prog lore, VNameSource)
forall a b. (a -> b) -> a -> b
$
Stms lore
-> (Stms lore -> RenameM (Prog lore)) -> RenameM (Prog lore)
forall lore a.
Renameable lore =>
Stms lore -> (Stms lore -> RenameM a) -> RenameM a
renamingStms (Prog lore -> Stms lore
forall lore. Prog lore -> Stms lore
progConsts Prog lore
prog) ((Stms lore -> RenameM (Prog lore)) -> RenameM (Prog lore))
-> (Stms lore -> RenameM (Prog lore)) -> RenameM (Prog lore)
forall a b. (a -> b) -> a -> b
$ \Stms lore
consts -> do
[FunDef lore]
funs <- (FunDef lore -> RenameM (FunDef lore))
-> [FunDef lore] -> RenameM [FunDef lore]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM FunDef lore -> RenameM (FunDef lore)
forall a. Rename a => a -> RenameM a
rename (Prog lore -> [FunDef lore]
forall lore. Prog lore -> [FunDef lore]
progFuns Prog lore
prog)
Prog lore -> RenameM (Prog lore)
forall (m :: * -> *) a. Monad m => a -> m a
return Prog lore
prog { progConsts :: Stms lore
progConsts = Stms lore
consts, progFuns :: [FunDef lore]
progFuns = [FunDef lore]
funs }
renameExp :: (Renameable lore, MonadFreshNames m) =>
Exp lore -> m (Exp lore)
renameExp :: Exp lore -> m (Exp lore)
renameExp = (VNameSource -> (Exp lore, VNameSource)) -> m (Exp lore)
forall (m :: * -> *) a.
MonadFreshNames m =>
(VNameSource -> (a, VNameSource)) -> m a
modifyNameSource ((VNameSource -> (Exp lore, VNameSource)) -> m (Exp lore))
-> (Exp lore -> VNameSource -> (Exp lore, VNameSource))
-> Exp lore
-> m (Exp lore)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RenameM (Exp lore) -> VNameSource -> (Exp lore, VNameSource)
forall a. RenameM a -> VNameSource -> (a, VNameSource)
runRenamer (RenameM (Exp lore) -> VNameSource -> (Exp lore, VNameSource))
-> (Exp lore -> RenameM (Exp lore))
-> Exp lore
-> VNameSource
-> (Exp lore, VNameSource)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Exp lore -> RenameM (Exp lore)
forall a. Rename a => a -> RenameM a
rename
renameStm :: (Renameable lore, MonadFreshNames m) =>
Stm lore -> m (Stm lore)
renameStm :: Stm lore -> m (Stm lore)
renameStm Stm lore
binding = do
Exp lore
e <- Exp lore -> m (Exp lore)
forall lore (m :: * -> *).
(Renameable lore, MonadFreshNames m) =>
Exp lore -> m (Exp lore)
renameExp (Exp lore -> m (Exp lore)) -> Exp lore -> m (Exp lore)
forall a b. (a -> b) -> a -> b
$ Stm lore -> Exp lore
forall lore. Stm lore -> Exp lore
stmExp Stm lore
binding
Stm lore -> m (Stm lore)
forall (m :: * -> *) a. Monad m => a -> m a
return Stm lore
binding { stmExp :: Exp lore
stmExp = Exp lore
e }
renameBody :: (Renameable lore, MonadFreshNames m) =>
Body lore -> m (Body lore)
renameBody :: Body lore -> m (Body lore)
renameBody = (VNameSource -> (Body lore, VNameSource)) -> m (Body lore)
forall (m :: * -> *) a.
MonadFreshNames m =>
(VNameSource -> (a, VNameSource)) -> m a
modifyNameSource ((VNameSource -> (Body lore, VNameSource)) -> m (Body lore))
-> (Body lore -> VNameSource -> (Body lore, VNameSource))
-> Body lore
-> m (Body lore)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RenameM (Body lore) -> VNameSource -> (Body lore, VNameSource)
forall a. RenameM a -> VNameSource -> (a, VNameSource)
runRenamer (RenameM (Body lore) -> VNameSource -> (Body lore, VNameSource))
-> (Body lore -> RenameM (Body lore))
-> Body lore
-> VNameSource
-> (Body lore, VNameSource)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Body lore -> RenameM (Body lore)
forall a. Rename a => a -> RenameM a
rename
renameLambda :: (Renameable lore, MonadFreshNames m) =>
Lambda lore -> m (Lambda lore)
renameLambda :: Lambda lore -> m (Lambda lore)
renameLambda = (VNameSource -> (Lambda lore, VNameSource)) -> m (Lambda lore)
forall (m :: * -> *) a.
MonadFreshNames m =>
(VNameSource -> (a, VNameSource)) -> m a
modifyNameSource ((VNameSource -> (Lambda lore, VNameSource)) -> m (Lambda lore))
-> (Lambda lore -> VNameSource -> (Lambda lore, VNameSource))
-> Lambda lore
-> m (Lambda lore)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RenameM (Lambda lore) -> VNameSource -> (Lambda lore, VNameSource)
forall a. RenameM a -> VNameSource -> (a, VNameSource)
runRenamer (RenameM (Lambda lore)
-> VNameSource -> (Lambda lore, VNameSource))
-> (Lambda lore -> RenameM (Lambda lore))
-> Lambda lore
-> VNameSource
-> (Lambda lore, VNameSource)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lambda lore -> RenameM (Lambda lore)
forall a. Rename a => a -> RenameM a
rename
renamePattern :: (Rename attr, MonadFreshNames m) =>
PatternT attr -> m (PatternT attr)
renamePattern :: PatternT attr -> m (PatternT attr)
renamePattern = (VNameSource -> (PatternT attr, VNameSource)) -> m (PatternT attr)
forall (m :: * -> *) a.
MonadFreshNames m =>
(VNameSource -> (a, VNameSource)) -> m a
modifyNameSource ((VNameSource -> (PatternT attr, VNameSource))
-> m (PatternT attr))
-> (PatternT attr -> VNameSource -> (PatternT attr, VNameSource))
-> PatternT attr
-> m (PatternT attr)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RenameM (PatternT attr)
-> VNameSource -> (PatternT attr, VNameSource)
forall a. RenameM a -> VNameSource -> (a, VNameSource)
runRenamer (RenameM (PatternT attr)
-> VNameSource -> (PatternT attr, VNameSource))
-> (PatternT attr -> RenameM (PatternT attr))
-> PatternT attr
-> VNameSource
-> (PatternT attr, VNameSource)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PatternT attr -> RenameM (PatternT attr)
forall attr.
Rename attr =>
PatternT attr -> RenameM (PatternT attr)
rename'
where rename' :: PatternT attr -> RenameM (PatternT attr)
rename' PatternT attr
pat = [VName] -> RenameM (PatternT attr) -> RenameM (PatternT attr)
forall a. [VName] -> RenameM a -> RenameM a
bind (PatternT attr -> [VName]
forall attr. PatternT attr -> [VName]
patternNames PatternT attr
pat) (RenameM (PatternT attr) -> RenameM (PatternT attr))
-> RenameM (PatternT attr) -> RenameM (PatternT attr)
forall a b. (a -> b) -> a -> b
$ PatternT attr -> RenameM (PatternT attr)
forall a. Rename a => a -> RenameM a
rename PatternT attr
pat
newtype RenameEnv = RenameEnv { RenameEnv -> Map VName VName
envNameMap :: M.Map VName VName }
newtype RenameM a = RenameM (StateT VNameSource (Reader RenameEnv) a)
deriving (a -> RenameM b -> RenameM a
(a -> b) -> RenameM a -> RenameM b
(forall a b. (a -> b) -> RenameM a -> RenameM b)
-> (forall a b. a -> RenameM b -> RenameM a) -> Functor RenameM
forall a b. a -> RenameM b -> RenameM a
forall a b. (a -> b) -> RenameM a -> RenameM b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> RenameM b -> RenameM a
$c<$ :: forall a b. a -> RenameM b -> RenameM a
fmap :: (a -> b) -> RenameM a -> RenameM b
$cfmap :: forall a b. (a -> b) -> RenameM a -> RenameM b
Functor, Functor RenameM
a -> RenameM a
Functor RenameM
-> (forall a. a -> RenameM a)
-> (forall a b. RenameM (a -> b) -> RenameM a -> RenameM b)
-> (forall a b c.
(a -> b -> c) -> RenameM a -> RenameM b -> RenameM c)
-> (forall a b. RenameM a -> RenameM b -> RenameM b)
-> (forall a b. RenameM a -> RenameM b -> RenameM a)
-> Applicative RenameM
RenameM a -> RenameM b -> RenameM b
RenameM a -> RenameM b -> RenameM a
RenameM (a -> b) -> RenameM a -> RenameM b
(a -> b -> c) -> RenameM a -> RenameM b -> RenameM c
forall a. a -> RenameM a
forall a b. RenameM a -> RenameM b -> RenameM a
forall a b. RenameM a -> RenameM b -> RenameM b
forall a b. RenameM (a -> b) -> RenameM a -> RenameM b
forall a b c. (a -> b -> c) -> RenameM a -> RenameM b -> RenameM c
forall (f :: * -> *).
Functor f
-> (forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
<* :: RenameM a -> RenameM b -> RenameM a
$c<* :: forall a b. RenameM a -> RenameM b -> RenameM a
*> :: RenameM a -> RenameM b -> RenameM b
$c*> :: forall a b. RenameM a -> RenameM b -> RenameM b
liftA2 :: (a -> b -> c) -> RenameM a -> RenameM b -> RenameM c
$cliftA2 :: forall a b c. (a -> b -> c) -> RenameM a -> RenameM b -> RenameM c
<*> :: RenameM (a -> b) -> RenameM a -> RenameM b
$c<*> :: forall a b. RenameM (a -> b) -> RenameM a -> RenameM b
pure :: a -> RenameM a
$cpure :: forall a. a -> RenameM a
$cp1Applicative :: Functor RenameM
Applicative, Applicative RenameM
a -> RenameM a
Applicative RenameM
-> (forall a b. RenameM a -> (a -> RenameM b) -> RenameM b)
-> (forall a b. RenameM a -> RenameM b -> RenameM b)
-> (forall a. a -> RenameM a)
-> Monad RenameM
RenameM a -> (a -> RenameM b) -> RenameM b
RenameM a -> RenameM b -> RenameM b
forall a. a -> RenameM a
forall a b. RenameM a -> RenameM b -> RenameM b
forall a b. RenameM a -> (a -> RenameM b) -> RenameM b
forall (m :: * -> *).
Applicative m
-> (forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
return :: a -> RenameM a
$creturn :: forall a. a -> RenameM a
>> :: RenameM a -> RenameM b -> RenameM b
$c>> :: forall a b. RenameM a -> RenameM b -> RenameM b
>>= :: RenameM a -> (a -> RenameM b) -> RenameM b
$c>>= :: forall a b. RenameM a -> (a -> RenameM b) -> RenameM b
$cp1Monad :: Applicative RenameM
Monad,
Monad RenameM
Applicative RenameM
RenameM VNameSource
Applicative RenameM
-> Monad RenameM
-> RenameM VNameSource
-> (VNameSource -> RenameM ())
-> MonadFreshNames RenameM
VNameSource -> RenameM ()
forall (m :: * -> *).
Applicative m
-> Monad m
-> m VNameSource
-> (VNameSource -> m ())
-> MonadFreshNames m
putNameSource :: VNameSource -> RenameM ()
$cputNameSource :: VNameSource -> RenameM ()
getNameSource :: RenameM VNameSource
$cgetNameSource :: RenameM VNameSource
$cp2MonadFreshNames :: Monad RenameM
$cp1MonadFreshNames :: Applicative RenameM
MonadFreshNames, MonadReader RenameEnv)
renamerSubstitutions :: RenameM Substitutions
renamerSubstitutions :: RenameM (Map VName VName)
renamerSubstitutions = (RenameEnv -> Map VName VName) -> RenameM (Map VName VName)
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks RenameEnv -> Map VName VName
envNameMap
substituteRename :: Substitute a => a -> RenameM a
substituteRename :: a -> RenameM a
substituteRename a
x = do
Map VName VName
substs <- RenameM (Map VName VName)
renamerSubstitutions
a -> RenameM a
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> RenameM a) -> a -> RenameM a
forall a b. (a -> b) -> a -> b
$ Map VName VName -> a -> a
forall a. Substitute a => Map VName VName -> a -> a
substituteNames Map VName VName
substs a
x
class Rename a where
rename :: a -> RenameM a
instance Rename VName where
rename :: VName -> RenameM VName
rename VName
name = VName -> Maybe VName -> VName
forall a. a -> Maybe a -> a
fromMaybe VName
name (Maybe VName -> VName) -> RenameM (Maybe VName) -> RenameM VName
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
(RenameEnv -> Maybe VName) -> RenameM (Maybe VName)
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks (VName -> Map VName VName -> Maybe VName
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup VName
name (Map VName VName -> Maybe VName)
-> (RenameEnv -> Map VName VName) -> RenameEnv -> Maybe VName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RenameEnv -> Map VName VName
envNameMap)
instance Rename a => Rename [a] where
rename :: [a] -> RenameM [a]
rename = (a -> RenameM a) -> [a] -> RenameM [a]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM a -> RenameM a
forall a. Rename a => a -> RenameM a
rename
instance (Rename a, Rename b) => Rename (a,b) where
rename :: (a, b) -> RenameM (a, b)
rename (a
a,b
b) = (,) (a -> b -> (a, b)) -> RenameM a -> RenameM (b -> (a, b))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> RenameM a
forall a. Rename a => a -> RenameM a
rename a
a RenameM (b -> (a, b)) -> RenameM b -> RenameM (a, b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> b -> RenameM b
forall a. Rename a => a -> RenameM a
rename b
b
instance (Rename a, Rename b, Rename c) => Rename (a,b,c) where
rename :: (a, b, c) -> RenameM (a, b, c)
rename (a
a,b
b,c
c) = do
a
a' <- a -> RenameM a
forall a. Rename a => a -> RenameM a
rename a
a
b
b' <- b -> RenameM b
forall a. Rename a => a -> RenameM a
rename b
b
c
c' <- c -> RenameM c
forall a. Rename a => a -> RenameM a
rename c
c
(a, b, c) -> RenameM (a, b, c)
forall (m :: * -> *) a. Monad m => a -> m a
return (a
a',b
b',c
c')
instance Rename a => Rename (Maybe a) where
rename :: Maybe a -> RenameM (Maybe a)
rename = RenameM (Maybe a)
-> (a -> RenameM (Maybe a)) -> Maybe a -> RenameM (Maybe a)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Maybe a -> RenameM (Maybe a)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe a
forall a. Maybe a
Nothing) ((a -> Maybe a) -> RenameM a -> RenameM (Maybe a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> Maybe a
forall a. a -> Maybe a
Just (RenameM a -> RenameM (Maybe a))
-> (a -> RenameM a) -> a -> RenameM (Maybe a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> RenameM a
forall a. Rename a => a -> RenameM a
rename)
instance Rename Bool where
rename :: Bool -> RenameM Bool
rename = Bool -> RenameM Bool
forall (m :: * -> *) a. Monad m => a -> m a
return
instance Rename Ident where
rename :: Ident -> RenameM Ident
rename (Ident VName
name Type
tp) = do
VName
name' <- VName -> RenameM VName
forall a. Rename a => a -> RenameM a
rename VName
name
Type
tp' <- Type -> RenameM Type
forall a. Rename a => a -> RenameM a
rename Type
tp
Ident -> RenameM Ident
forall (m :: * -> *) a. Monad m => a -> m a
return (Ident -> RenameM Ident) -> Ident -> RenameM Ident
forall a b. (a -> b) -> a -> b
$ VName -> Type -> Ident
Ident VName
name' Type
tp'
bind :: [VName] -> RenameM a -> RenameM a
bind :: [VName] -> RenameM a -> RenameM a
bind [VName]
vars RenameM a
body = do
[VName]
vars' <- (VName -> RenameM VName) -> [VName] -> RenameM [VName]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM VName -> RenameM VName
forall (m :: * -> *). MonadFreshNames m => VName -> m VName
newName [VName]
vars
(RenameEnv -> RenameEnv) -> RenameM a -> RenameM a
forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local ([VName] -> RenameEnv -> RenameEnv
bind' [VName]
vars') RenameM a
body
where bind' :: [VName] -> RenameEnv -> RenameEnv
bind' [VName]
vars' RenameEnv
env = RenameEnv
env { envNameMap :: Map VName VName
envNameMap = [(VName, VName)] -> Map VName VName
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList ([VName] -> [VName] -> [(VName, VName)]
forall a b. [a] -> [b] -> [(a, b)]
zip [VName]
vars [VName]
vars')
Map VName VName -> Map VName VName -> Map VName VName
forall k a. Ord k => Map k a -> Map k a -> Map k a
`M.union` RenameEnv -> Map VName VName
envNameMap RenameEnv
env }
renamingStms :: Renameable lore => Stms lore -> (Stms lore -> RenameM a) -> RenameM a
renamingStms :: Stms lore -> (Stms lore -> RenameM a) -> RenameM a
renamingStms Stms lore
stms Stms lore -> RenameM a
m = Stms lore -> Stms lore -> RenameM a
descend Stms lore
forall a. Monoid a => a
mempty Stms lore
stms
where descend :: Stms lore -> Stms lore -> RenameM a
descend Stms lore
stms' Stms lore
rem_stms = case Stms lore -> Maybe (Stm lore, Stms lore)
forall lore. Stms lore -> Maybe (Stm lore, Stms lore)
stmsHead Stms lore
rem_stms of
Maybe (Stm lore, Stms lore)
Nothing -> Stms lore -> RenameM a
m Stms lore
stms'
Just (Stm lore
stm, Stms lore
rem_stms') -> [VName] -> RenameM a -> RenameM a
forall a. [VName] -> RenameM a -> RenameM a
bind (PatternT (LetAttr lore) -> [VName]
forall attr. PatternT attr -> [VName]
patternNames (PatternT (LetAttr lore) -> [VName])
-> PatternT (LetAttr lore) -> [VName]
forall a b. (a -> b) -> a -> b
$ Stm lore -> PatternT (LetAttr lore)
forall lore. Stm lore -> Pattern lore
stmPattern Stm lore
stm) (RenameM a -> RenameM a) -> RenameM a -> RenameM a
forall a b. (a -> b) -> a -> b
$ do
Stm lore
stm' <- Stm lore -> RenameM (Stm lore)
forall a. Rename a => a -> RenameM a
rename Stm lore
stm
Stms lore -> Stms lore -> RenameM a
descend (Stms lore
stms' Stms lore -> Stms lore -> Stms lore
forall a. Semigroup a => a -> a -> a
<> Stm lore -> Stms lore
forall lore. Stm lore -> Stms lore
oneStm Stm lore
stm') Stms lore
rem_stms'
instance Renameable lore => Rename (FunDef lore) where
rename :: FunDef lore -> RenameM (FunDef lore)
rename (FunDef Maybe EntryPoint
entry Name
fname [RetType lore]
ret [FParam lore]
params BodyT lore
body) =
[VName] -> RenameM (FunDef lore) -> RenameM (FunDef lore)
forall a. [VName] -> RenameM a -> RenameM a
bind ((FParam lore -> VName) -> [FParam lore] -> [VName]
forall a b. (a -> b) -> [a] -> [b]
map FParam lore -> VName
forall attr. Param attr -> VName
paramName [FParam lore]
params) (RenameM (FunDef lore) -> RenameM (FunDef lore))
-> RenameM (FunDef lore) -> RenameM (FunDef lore)
forall a b. (a -> b) -> a -> b
$ do
[FParam lore]
params' <- (FParam lore -> RenameM (FParam lore))
-> [FParam lore] -> RenameM [FParam lore]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM FParam lore -> RenameM (FParam lore)
forall a. Rename a => a -> RenameM a
rename [FParam lore]
params
BodyT lore
body' <- BodyT lore -> RenameM (BodyT lore)
forall a. Rename a => a -> RenameM a
rename BodyT lore
body
[RetType lore]
ret' <- [RetType lore] -> RenameM [RetType lore]
forall a. Rename a => a -> RenameM a
rename [RetType lore]
ret
FunDef lore -> RenameM (FunDef lore)
forall (m :: * -> *) a. Monad m => a -> m a
return (FunDef lore -> RenameM (FunDef lore))
-> FunDef lore -> RenameM (FunDef lore)
forall a b. (a -> b) -> a -> b
$ Maybe EntryPoint
-> Name
-> [RetType lore]
-> [FParam lore]
-> BodyT lore
-> FunDef lore
forall lore.
Maybe EntryPoint
-> Name
-> [RetType lore]
-> [FParam lore]
-> BodyT lore
-> FunDef lore
FunDef Maybe EntryPoint
entry Name
fname [RetType lore]
ret' [FParam lore]
params' BodyT lore
body'
instance Rename SubExp where
rename :: SubExp -> RenameM SubExp
rename (Var VName
v) = VName -> SubExp
Var (VName -> SubExp) -> RenameM VName -> RenameM SubExp
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> VName -> RenameM VName
forall a. Rename a => a -> RenameM a
rename VName
v
rename (Constant PrimValue
v) = SubExp -> RenameM SubExp
forall (m :: * -> *) a. Monad m => a -> m a
return (SubExp -> RenameM SubExp) -> SubExp -> RenameM SubExp
forall a b. (a -> b) -> a -> b
$ PrimValue -> SubExp
Constant PrimValue
v
instance Rename attr => Rename (Param attr) where
rename :: Param attr -> RenameM (Param attr)
rename (Param VName
name attr
attr) = VName -> attr -> Param attr
forall attr. VName -> attr -> Param attr
Param (VName -> attr -> Param attr)
-> RenameM VName -> RenameM (attr -> Param attr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> VName -> RenameM VName
forall a. Rename a => a -> RenameM a
rename VName
name RenameM (attr -> Param attr)
-> RenameM attr -> RenameM (Param attr)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> attr -> RenameM attr
forall a. Rename a => a -> RenameM a
rename attr
attr
instance Rename attr => Rename (PatternT attr) where
rename :: PatternT attr -> RenameM (PatternT attr)
rename (Pattern [PatElemT attr]
context [PatElemT attr]
values) = [PatElemT attr] -> [PatElemT attr] -> PatternT attr
forall attr. [PatElemT attr] -> [PatElemT attr] -> PatternT attr
Pattern ([PatElemT attr] -> [PatElemT attr] -> PatternT attr)
-> RenameM [PatElemT attr]
-> RenameM ([PatElemT attr] -> PatternT attr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [PatElemT attr] -> RenameM [PatElemT attr]
forall a. Rename a => a -> RenameM a
rename [PatElemT attr]
context RenameM ([PatElemT attr] -> PatternT attr)
-> RenameM [PatElemT attr] -> RenameM (PatternT attr)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [PatElemT attr] -> RenameM [PatElemT attr]
forall a. Rename a => a -> RenameM a
rename [PatElemT attr]
values
instance Rename attr => Rename (PatElemT attr) where
rename :: PatElemT attr -> RenameM (PatElemT attr)
rename (PatElem VName
ident attr
attr) = VName -> attr -> PatElemT attr
forall attr. VName -> attr -> PatElemT attr
PatElem (VName -> attr -> PatElemT attr)
-> RenameM VName -> RenameM (attr -> PatElemT attr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> VName -> RenameM VName
forall a. Rename a => a -> RenameM a
rename VName
ident RenameM (attr -> PatElemT attr)
-> RenameM attr -> RenameM (PatElemT attr)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> attr -> RenameM attr
forall a. Rename a => a -> RenameM a
rename attr
attr
instance Rename Certificates where
rename :: Certificates -> RenameM Certificates
rename (Certificates [VName]
cs) = [VName] -> Certificates
Certificates ([VName] -> Certificates)
-> RenameM [VName] -> RenameM Certificates
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [VName] -> RenameM [VName]
forall a. Rename a => a -> RenameM a
rename [VName]
cs
instance Rename attr => Rename (StmAux attr) where
rename :: StmAux attr -> RenameM (StmAux attr)
rename (StmAux Certificates
cs attr
attr) =
Certificates -> attr -> StmAux attr
forall attr. Certificates -> attr -> StmAux attr
StmAux (Certificates -> attr -> StmAux attr)
-> RenameM Certificates -> RenameM (attr -> StmAux attr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Certificates -> RenameM Certificates
forall a. Rename a => a -> RenameM a
rename Certificates
cs RenameM (attr -> StmAux attr)
-> RenameM attr -> RenameM (StmAux attr)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> attr -> RenameM attr
forall a. Rename a => a -> RenameM a
rename attr
attr
instance Renameable lore => Rename (Body lore) where
rename :: Body lore -> RenameM (Body lore)
rename (Body BodyAttr lore
attr Stms lore
stms Result
res) = do
BodyAttr lore
attr' <- BodyAttr lore -> RenameM (BodyAttr lore)
forall a. Rename a => a -> RenameM a
rename BodyAttr lore
attr
Stms lore
-> (Stms lore -> RenameM (Body lore)) -> RenameM (Body lore)
forall lore a.
Renameable lore =>
Stms lore -> (Stms lore -> RenameM a) -> RenameM a
renamingStms Stms lore
stms ((Stms lore -> RenameM (Body lore)) -> RenameM (Body lore))
-> (Stms lore -> RenameM (Body lore)) -> RenameM (Body lore)
forall a b. (a -> b) -> a -> b
$ \Stms lore
stms' ->
BodyAttr lore -> Stms lore -> Result -> Body lore
forall lore. BodyAttr lore -> Stms lore -> Result -> BodyT lore
Body BodyAttr lore
attr' Stms lore
stms' (Result -> Body lore) -> RenameM Result -> RenameM (Body lore)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Result -> RenameM Result
forall a. Rename a => a -> RenameM a
rename Result
res
instance Renameable lore => Rename (Stm lore) where
rename :: Stm lore -> RenameM (Stm lore)
rename (Let Pattern lore
pat StmAux (ExpAttr lore)
elore Exp lore
e) = Pattern lore -> StmAux (ExpAttr lore) -> Exp lore -> Stm lore
forall lore.
Pattern lore -> StmAux (ExpAttr lore) -> Exp lore -> Stm lore
Let (Pattern lore -> StmAux (ExpAttr lore) -> Exp lore -> Stm lore)
-> RenameM (Pattern lore)
-> RenameM (StmAux (ExpAttr lore) -> Exp lore -> Stm lore)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Pattern lore -> RenameM (Pattern lore)
forall a. Rename a => a -> RenameM a
rename Pattern lore
pat RenameM (StmAux (ExpAttr lore) -> Exp lore -> Stm lore)
-> RenameM (StmAux (ExpAttr lore))
-> RenameM (Exp lore -> Stm lore)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> StmAux (ExpAttr lore) -> RenameM (StmAux (ExpAttr lore))
forall a. Rename a => a -> RenameM a
rename StmAux (ExpAttr lore)
elore RenameM (Exp lore -> Stm lore)
-> RenameM (Exp lore) -> RenameM (Stm lore)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Exp lore -> RenameM (Exp lore)
forall a. Rename a => a -> RenameM a
rename Exp lore
e
instance Renameable lore => Rename (Exp lore) where
rename :: Exp lore -> RenameM (Exp lore)
rename (DoLoop [(FParam lore, SubExp)]
ctx [(FParam lore, SubExp)]
val LoopForm lore
form BodyT lore
loopbody) = do
let ([FParam lore]
ctxparams, Result
ctxinit) = [(FParam lore, SubExp)] -> ([FParam lore], Result)
forall a b. [(a, b)] -> ([a], [b])
unzip [(FParam lore, SubExp)]
ctx
([FParam lore]
valparams, Result
valinit) = [(FParam lore, SubExp)] -> ([FParam lore], Result)
forall a b. [(a, b)] -> ([a], [b])
unzip [(FParam lore, SubExp)]
val
Result
ctxinit' <- (SubExp -> RenameM SubExp) -> Result -> RenameM Result
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM SubExp -> RenameM SubExp
forall a. Rename a => a -> RenameM a
rename Result
ctxinit
Result
valinit' <- (SubExp -> RenameM SubExp) -> Result -> RenameM Result
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM SubExp -> RenameM SubExp
forall a. Rename a => a -> RenameM a
rename Result
valinit
case LoopForm lore
form of
ForLoop VName
loopvar IntType
it SubExp
boundexp [(LParam lore, VName)]
loop_vars -> do
let ([LParam lore]
loop_params, [VName]
loop_arrs) = [(LParam lore, VName)] -> ([LParam lore], [VName])
forall a b. [(a, b)] -> ([a], [b])
unzip [(LParam lore, VName)]
loop_vars
SubExp
boundexp' <- SubExp -> RenameM SubExp
forall a. Rename a => a -> RenameM a
rename SubExp
boundexp
[VName]
loop_arrs' <- [VName] -> RenameM [VName]
forall a. Rename a => a -> RenameM a
rename [VName]
loop_arrs
[VName] -> RenameM (Exp lore) -> RenameM (Exp lore)
forall a. [VName] -> RenameM a -> RenameM a
bind ((FParam lore -> VName) -> [FParam lore] -> [VName]
forall a b. (a -> b) -> [a] -> [b]
map FParam lore -> VName
forall attr. Param attr -> VName
paramName ([FParam lore]
ctxparams[FParam lore] -> [FParam lore] -> [FParam lore]
forall a. [a] -> [a] -> [a]
++[FParam lore]
valparams) [VName] -> [VName] -> [VName]
forall a. [a] -> [a] -> [a]
++
(LParam lore -> VName) -> [LParam lore] -> [VName]
forall a b. (a -> b) -> [a] -> [b]
map LParam lore -> VName
forall attr. Param attr -> VName
paramName [LParam lore]
loop_params) (RenameM (Exp lore) -> RenameM (Exp lore))
-> RenameM (Exp lore) -> RenameM (Exp lore)
forall a b. (a -> b) -> a -> b
$ do
[FParam lore]
ctxparams' <- (FParam lore -> RenameM (FParam lore))
-> [FParam lore] -> RenameM [FParam lore]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM FParam lore -> RenameM (FParam lore)
forall a. Rename a => a -> RenameM a
rename [FParam lore]
ctxparams
[FParam lore]
valparams' <- (FParam lore -> RenameM (FParam lore))
-> [FParam lore] -> RenameM [FParam lore]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM FParam lore -> RenameM (FParam lore)
forall a. Rename a => a -> RenameM a
rename [FParam lore]
valparams
[LParam lore]
loop_params' <- (LParam lore -> RenameM (LParam lore))
-> [LParam lore] -> RenameM [LParam lore]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM LParam lore -> RenameM (LParam lore)
forall a. Rename a => a -> RenameM a
rename [LParam lore]
loop_params
[VName] -> RenameM (Exp lore) -> RenameM (Exp lore)
forall a. [VName] -> RenameM a -> RenameM a
bind [VName
loopvar] (RenameM (Exp lore) -> RenameM (Exp lore))
-> RenameM (Exp lore) -> RenameM (Exp lore)
forall a b. (a -> b) -> a -> b
$ do
VName
loopvar' <- VName -> RenameM VName
forall a. Rename a => a -> RenameM a
rename VName
loopvar
BodyT lore
loopbody' <- BodyT lore -> RenameM (BodyT lore)
forall a. Rename a => a -> RenameM a
rename BodyT lore
loopbody
Exp lore -> RenameM (Exp lore)
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp lore -> RenameM (Exp lore)) -> Exp lore -> RenameM (Exp lore)
forall a b. (a -> b) -> a -> b
$ [(FParam lore, SubExp)]
-> [(FParam lore, SubExp)]
-> LoopForm lore
-> BodyT lore
-> Exp lore
forall lore.
[(FParam lore, SubExp)]
-> [(FParam lore, SubExp)]
-> LoopForm lore
-> BodyT lore
-> ExpT lore
DoLoop
([FParam lore] -> Result -> [(FParam lore, SubExp)]
forall a b. [a] -> [b] -> [(a, b)]
zip [FParam lore]
ctxparams' Result
ctxinit') ([FParam lore] -> Result -> [(FParam lore, SubExp)]
forall a b. [a] -> [b] -> [(a, b)]
zip [FParam lore]
valparams' Result
valinit')
(VName
-> IntType -> SubExp -> [(LParam lore, VName)] -> LoopForm lore
forall lore.
VName
-> IntType -> SubExp -> [(LParam lore, VName)] -> LoopForm lore
ForLoop VName
loopvar' IntType
it SubExp
boundexp' ([(LParam lore, VName)] -> LoopForm lore)
-> [(LParam lore, VName)] -> LoopForm lore
forall a b. (a -> b) -> a -> b
$
[LParam lore] -> [VName] -> [(LParam lore, VName)]
forall a b. [a] -> [b] -> [(a, b)]
zip [LParam lore]
loop_params' [VName]
loop_arrs') BodyT lore
loopbody'
WhileLoop VName
cond ->
[VName] -> RenameM (Exp lore) -> RenameM (Exp lore)
forall a. [VName] -> RenameM a -> RenameM a
bind ((FParam lore -> VName) -> [FParam lore] -> [VName]
forall a b. (a -> b) -> [a] -> [b]
map FParam lore -> VName
forall attr. Param attr -> VName
paramName ([FParam lore] -> [VName]) -> [FParam lore] -> [VName]
forall a b. (a -> b) -> a -> b
$ [FParam lore]
ctxparams[FParam lore] -> [FParam lore] -> [FParam lore]
forall a. [a] -> [a] -> [a]
++[FParam lore]
valparams) (RenameM (Exp lore) -> RenameM (Exp lore))
-> RenameM (Exp lore) -> RenameM (Exp lore)
forall a b. (a -> b) -> a -> b
$ do
[FParam lore]
ctxparams' <- (FParam lore -> RenameM (FParam lore))
-> [FParam lore] -> RenameM [FParam lore]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM FParam lore -> RenameM (FParam lore)
forall a. Rename a => a -> RenameM a
rename [FParam lore]
ctxparams
[FParam lore]
valparams' <- (FParam lore -> RenameM (FParam lore))
-> [FParam lore] -> RenameM [FParam lore]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM FParam lore -> RenameM (FParam lore)
forall a. Rename a => a -> RenameM a
rename [FParam lore]
valparams
BodyT lore
loopbody' <- BodyT lore -> RenameM (BodyT lore)
forall a. Rename a => a -> RenameM a
rename BodyT lore
loopbody
VName
cond' <- VName -> RenameM VName
forall a. Rename a => a -> RenameM a
rename VName
cond
Exp lore -> RenameM (Exp lore)
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp lore -> RenameM (Exp lore)) -> Exp lore -> RenameM (Exp lore)
forall a b. (a -> b) -> a -> b
$ [(FParam lore, SubExp)]
-> [(FParam lore, SubExp)]
-> LoopForm lore
-> BodyT lore
-> Exp lore
forall lore.
[(FParam lore, SubExp)]
-> [(FParam lore, SubExp)]
-> LoopForm lore
-> BodyT lore
-> ExpT lore
DoLoop
([FParam lore] -> Result -> [(FParam lore, SubExp)]
forall a b. [a] -> [b] -> [(a, b)]
zip [FParam lore]
ctxparams' Result
ctxinit') ([FParam lore] -> Result -> [(FParam lore, SubExp)]
forall a b. [a] -> [b] -> [(a, b)]
zip [FParam lore]
valparams' Result
valinit')
(VName -> LoopForm lore
forall lore. VName -> LoopForm lore
WhileLoop VName
cond') BodyT lore
loopbody'
rename Exp lore
e = Mapper lore lore RenameM -> Exp lore -> RenameM (Exp lore)
forall (m :: * -> *) flore tlore.
(Applicative m, Monad m) =>
Mapper flore tlore m -> Exp flore -> m (Exp tlore)
mapExpM Mapper lore lore RenameM
mapper Exp lore
e
where mapper :: Mapper lore lore RenameM
mapper = Mapper :: forall flore tlore (m :: * -> *).
(SubExp -> m SubExp)
-> (Scope tlore -> Body flore -> m (Body tlore))
-> (VName -> m VName)
-> (RetType flore -> m (RetType tlore))
-> (BranchType flore -> m (BranchType tlore))
-> (FParam flore -> m (FParam tlore))
-> (LParam flore -> m (LParam tlore))
-> (Op flore -> m (Op tlore))
-> Mapper flore tlore m
Mapper {
mapOnBody :: Scope lore -> BodyT lore -> RenameM (BodyT lore)
mapOnBody = (BodyT lore -> RenameM (BodyT lore))
-> Scope lore -> BodyT lore -> RenameM (BodyT lore)
forall a b. a -> b -> a
const BodyT lore -> RenameM (BodyT lore)
forall a. Rename a => a -> RenameM a
rename
, mapOnSubExp :: SubExp -> RenameM SubExp
mapOnSubExp = SubExp -> RenameM SubExp
forall a. Rename a => a -> RenameM a
rename
, mapOnVName :: VName -> RenameM VName
mapOnVName = VName -> RenameM VName
forall a. Rename a => a -> RenameM a
rename
, mapOnRetType :: RetType lore -> RenameM (RetType lore)
mapOnRetType = RetType lore -> RenameM (RetType lore)
forall a. Rename a => a -> RenameM a
rename
, mapOnBranchType :: BranchType lore -> RenameM (BranchType lore)
mapOnBranchType = BranchType lore -> RenameM (BranchType lore)
forall a. Rename a => a -> RenameM a
rename
, mapOnFParam :: FParam lore -> RenameM (FParam lore)
mapOnFParam = FParam lore -> RenameM (FParam lore)
forall a. Rename a => a -> RenameM a
rename
, mapOnLParam :: LParam lore -> RenameM (LParam lore)
mapOnLParam = LParam lore -> RenameM (LParam lore)
forall a. Rename a => a -> RenameM a
rename
, mapOnOp :: Op lore -> RenameM (Op lore)
mapOnOp = Op lore -> RenameM (Op lore)
forall a. Rename a => a -> RenameM a
rename
}
instance Rename shape =>
Rename (TypeBase shape u) where
rename :: TypeBase shape u -> RenameM (TypeBase shape u)
rename (Array PrimType
et shape
size u
u) = do
shape
size' <- shape -> RenameM shape
forall a. Rename a => a -> RenameM a
rename shape
size
TypeBase shape u -> RenameM (TypeBase shape u)
forall (m :: * -> *) a. Monad m => a -> m a
return (TypeBase shape u -> RenameM (TypeBase shape u))
-> TypeBase shape u -> RenameM (TypeBase shape u)
forall a b. (a -> b) -> a -> b
$ PrimType -> shape -> u -> TypeBase shape u
forall shape u. PrimType -> shape -> u -> TypeBase shape u
Array PrimType
et shape
size' u
u
rename (Prim PrimType
et) = TypeBase shape u -> RenameM (TypeBase shape u)
forall (m :: * -> *) a. Monad m => a -> m a
return (TypeBase shape u -> RenameM (TypeBase shape u))
-> TypeBase shape u -> RenameM (TypeBase shape u)
forall a b. (a -> b) -> a -> b
$ PrimType -> TypeBase shape u
forall shape u. PrimType -> TypeBase shape u
Prim PrimType
et
rename (Mem Space
space) = TypeBase shape u -> RenameM (TypeBase shape u)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TypeBase shape u -> RenameM (TypeBase shape u))
-> TypeBase shape u -> RenameM (TypeBase shape u)
forall a b. (a -> b) -> a -> b
$ Space -> TypeBase shape u
forall shape u. Space -> TypeBase shape u
Mem Space
space
instance Renameable lore => Rename (Lambda lore) where
rename :: Lambda lore -> RenameM (Lambda lore)
rename (Lambda [LParam lore]
params BodyT lore
body [Type]
ret) =
[VName] -> RenameM (Lambda lore) -> RenameM (Lambda lore)
forall a. [VName] -> RenameM a -> RenameM a
bind ((LParam lore -> VName) -> [LParam lore] -> [VName]
forall a b. (a -> b) -> [a] -> [b]
map LParam lore -> VName
forall attr. Param attr -> VName
paramName [LParam lore]
params) (RenameM (Lambda lore) -> RenameM (Lambda lore))
-> RenameM (Lambda lore) -> RenameM (Lambda lore)
forall a b. (a -> b) -> a -> b
$ do
[LParam lore]
params' <- (LParam lore -> RenameM (LParam lore))
-> [LParam lore] -> RenameM [LParam lore]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM LParam lore -> RenameM (LParam lore)
forall a. Rename a => a -> RenameM a
rename [LParam lore]
params
BodyT lore
body' <- BodyT lore -> RenameM (BodyT lore)
forall a. Rename a => a -> RenameM a
rename BodyT lore
body
[Type]
ret' <- (Type -> RenameM Type) -> [Type] -> RenameM [Type]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Type -> RenameM Type
forall a. Rename a => a -> RenameM a
rename [Type]
ret
Lambda lore -> RenameM (Lambda lore)
forall (m :: * -> *) a. Monad m => a -> m a
return (Lambda lore -> RenameM (Lambda lore))
-> Lambda lore -> RenameM (Lambda lore)
forall a b. (a -> b) -> a -> b
$ [LParam lore] -> BodyT lore -> [Type] -> Lambda lore
forall lore. [LParam lore] -> BodyT lore -> [Type] -> LambdaT lore
Lambda [LParam lore]
params' BodyT lore
body' [Type]
ret'
instance Rename Names where
rename :: Names -> RenameM Names
rename = ([VName] -> Names) -> RenameM [VName] -> RenameM Names
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [VName] -> Names
namesFromList (RenameM [VName] -> RenameM Names)
-> (Names -> RenameM [VName]) -> Names -> RenameM Names
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (VName -> RenameM VName) -> [VName] -> RenameM [VName]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM VName -> RenameM VName
forall a. Rename a => a -> RenameM a
rename ([VName] -> RenameM [VName])
-> (Names -> [VName]) -> Names -> RenameM [VName]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Names -> [VName]
namesToList
instance Rename Rank where
rename :: Rank -> RenameM Rank
rename = Rank -> RenameM Rank
forall (m :: * -> *) a. Monad m => a -> m a
return
instance Rename d => Rename (ShapeBase d) where
rename :: ShapeBase d -> RenameM (ShapeBase d)
rename (Shape [d]
l) = [d] -> ShapeBase d
forall d. [d] -> ShapeBase d
Shape ([d] -> ShapeBase d) -> RenameM [d] -> RenameM (ShapeBase d)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (d -> RenameM d) -> [d] -> RenameM [d]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM d -> RenameM d
forall a. Rename a => a -> RenameM a
rename [d]
l
instance Rename ExtSize where
rename :: ExtSize -> RenameM ExtSize
rename (Free SubExp
se) = SubExp -> ExtSize
forall a. a -> Ext a
Free (SubExp -> ExtSize) -> RenameM SubExp -> RenameM ExtSize
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> SubExp -> RenameM SubExp
forall a. Rename a => a -> RenameM a
rename SubExp
se
rename (Ext Int
x) = ExtSize -> RenameM ExtSize
forall (m :: * -> *) a. Monad m => a -> m a
return (ExtSize -> RenameM ExtSize) -> ExtSize -> RenameM ExtSize
forall a b. (a -> b) -> a -> b
$ Int -> ExtSize
forall a. Int -> Ext a
Ext Int
x
instance Rename () where
rename :: () -> RenameM ()
rename = () -> RenameM ()
forall (m :: * -> *) a. Monad m => a -> m a
return
instance Rename d => Rename (DimIndex d) where
rename :: DimIndex d -> RenameM (DimIndex d)
rename (DimFix d
i) = d -> DimIndex d
forall d. d -> DimIndex d
DimFix (d -> DimIndex d) -> RenameM d -> RenameM (DimIndex d)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> d -> RenameM d
forall a. Rename a => a -> RenameM a
rename d
i
rename (DimSlice d
i d
n d
s) = d -> d -> d -> DimIndex d
forall d. d -> d -> d -> DimIndex d
DimSlice (d -> d -> d -> DimIndex d)
-> RenameM d -> RenameM (d -> d -> DimIndex d)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> d -> RenameM d
forall a. Rename a => a -> RenameM a
rename d
i RenameM (d -> d -> DimIndex d)
-> RenameM d -> RenameM (d -> DimIndex d)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> d -> RenameM d
forall a. Rename a => a -> RenameM a
rename d
n RenameM (d -> DimIndex d) -> RenameM d -> RenameM (DimIndex d)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> d -> RenameM d
forall a. Rename a => a -> RenameM a
rename d
s
type Renameable lore = (Rename (LetAttr lore),
Rename (ExpAttr lore),
Rename (BodyAttr lore),
Rename (FParamAttr lore),
Rename (LParamAttr lore),
Rename (RetType lore),
Rename (BranchType lore),
Rename (Op lore))