    -- |
    --
    -- Functions for generic traversals across Futhark syntax trees.  The
    -- motivation for this module came from dissatisfaction with rewriting
    -- the same trivial tree recursions for every module.  A possible
    -- alternative would be to use normal \"Scrap your
    -- boilerplate\"-techniques, but these are rejected for two reasons:
    --
    --    * They are too slow.
    --
    --    * More importantly, they do not tell you whether you have missed
    --      some cases.
    --
    -- Instead, this module defines various traversals of the Futhark syntax
    -- tree.  The implementation is rather tedious, but the interface is
    -- easy to use.
    --
    -- A traversal of the Futhark syntax tree is expressed as a record of
    -- functions expressing the operations to be performed on the various
    -- types of nodes.
    module Language.Futhark.Traversals
      ( ASTMapper (..),
        ASTMappable (..),
        identityMapper,
        bareExp,
      )
    where

    import Data.Bifunctor
    import Data.Bitraversable
    import Data.List.NonEmpty qualified as NE
    import Language.Futhark.Syntax

    -- | Express a monad mapping operation on a syntax node.  Each element
    -- of this structure expresses the operation to be performed on a
    -- given child.
    data ASTMapper m = ASTMapper
      { forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp :: ExpBase Info VName -> m (ExpBase Info VName),
        forall (m :: * -> *).
    ASTMapper m -> QualName VName -> m (QualName VName)
    mapOnName :: QualName VName -> m (QualName VName),
        forall (m :: * -> *). ASTMapper m -> StructType -> m StructType
    mapOnStructType :: StructType -> m StructType,
        forall (m :: * -> *). ASTMapper m -> ParamType -> m ParamType
    mapOnParamType :: ParamType -> m ParamType,
        forall (m :: * -> *). ASTMapper m -> ResRetType -> m ResRetType
    mapOnResRetType :: ResRetType -> m ResRetType
      }

    -- | An 'ASTMapper' that just leaves its input unchanged.
    identityMapper :: (Monad m) => ASTMapper m
    identityMapper :: forall (m :: * -> *). Monad m => ASTMapper m
    identityMapper =
      ASTMapper
        { mapOnExp :: ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp = ExpBase Info VName -> m (ExpBase Info VName)
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure,
          mapOnName :: QualName VName -> m (QualName VName)
    mapOnName = QualName VName -> m (QualName VName)
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure,
          mapOnStructType :: StructType -> m StructType
    mapOnStructType = StructType -> m StructType
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure,
          mapOnParamType :: ParamType -> m ParamType
    mapOnParamType = ParamType -> m ParamType
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure,
          mapOnResRetType :: ResRetType -> m ResRetType
    mapOnResRetType = ResRetType -> m ResRetType
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure
        }

    -- | The class of things that we can map an 'ASTMapper' across.
    class ASTMappable x where
      -- | Map a monadic action across the immediate children of an
      -- object.  Importantly, the 'astMap' action is not invoked for
      -- the object itself, and the mapping does not descend recursively
      -- into subexpressions.  The mapping is done left-to-right.
      astMap :: (Monad m) => ASTMapper m -> x -> m x

    instance ASTMappable (AppExpBase Info VName) where
      astMap :: forall (m :: * -> *).
    Monad m =>
    ASTMapper m -> AppExpBase Info VName -> m (AppExpBase Info VName)
    astMap ASTMapper m
    tv (Range ExpBase Info VName
    start Maybe (ExpBase Info VName)
    next Inclusiveness (ExpBase Info VName)
    end SrcLoc
    loc) =
        ExpBase Info VName
    -> Maybe (ExpBase Info VName)
    -> Inclusiveness (ExpBase Info VName)
    -> SrcLoc
    -> AppExpBase Info VName
    forall (f :: * -> *) vn.
    ExpBase f vn
    -> Maybe (ExpBase f vn)
    -> Inclusiveness (ExpBase f vn)
    -> SrcLoc
    -> AppExpBase f vn
    Range
          (ExpBase Info VName
     -> Maybe (ExpBase Info VName)
     -> Inclusiveness (ExpBase Info VName)
     -> SrcLoc
     -> AppExpBase Info VName)
    -> m (ExpBase Info VName)
    -> m (Maybe (ExpBase Info VName)
          -> Inclusiveness (ExpBase Info VName)
          -> SrcLoc
          -> AppExpBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv ExpBase Info VName
    start
          m (Maybe (ExpBase Info VName)
       -> Inclusiveness (ExpBase Info VName)
       -> SrcLoc
       -> AppExpBase Info VName)
    -> m (Maybe (ExpBase Info VName))
    -> m (Inclusiveness (ExpBase Info VName)
          -> SrcLoc -> AppExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (ExpBase Info VName -> m (ExpBase Info VName))
    -> Maybe (ExpBase Info VName) -> m (Maybe (ExpBase Info VName))
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Maybe a -> f (Maybe b)
    traverse (ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv) Maybe (ExpBase Info VName)
    next
          m (Inclusiveness (ExpBase Info VName)
       -> SrcLoc -> AppExpBase Info VName)
    -> m (Inclusiveness (ExpBase Info VName))
    -> m (SrcLoc -> AppExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (ExpBase Info VName -> m (ExpBase Info VName))
    -> Inclusiveness (ExpBase Info VName)
    -> m (Inclusiveness (ExpBase Info VName))
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Inclusiveness a -> f (Inclusiveness b)
    traverse (ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv) Inclusiveness (ExpBase Info VName)
    end
          m (SrcLoc -> AppExpBase Info VName)
    -> m SrcLoc -> m (AppExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    tv (If ExpBase Info VName
    c ExpBase Info VName
    texp ExpBase Info VName
    fexp SrcLoc
    loc) =
        ExpBase Info VName
    -> ExpBase Info VName
    -> ExpBase Info VName
    -> SrcLoc
    -> AppExpBase Info VName
    forall (f :: * -> *) vn.
    ExpBase f vn
    -> ExpBase f vn -> ExpBase f vn -> SrcLoc -> AppExpBase f vn
    If (ExpBase Info VName
     -> ExpBase Info VName
     -> ExpBase Info VName
     -> SrcLoc
     -> AppExpBase Info VName)
    -> m (ExpBase Info VName)
    -> m (ExpBase Info VName
          -> ExpBase Info VName -> SrcLoc -> AppExpBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv ExpBase Info VName
    c m (ExpBase Info VName
       -> ExpBase Info VName -> SrcLoc -> AppExpBase Info VName)
    -> m (ExpBase Info VName)
    -> m (ExpBase Info VName -> SrcLoc -> AppExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv ExpBase Info VName
    texp m (ExpBase Info VName -> SrcLoc -> AppExpBase Info VName)
    -> m (ExpBase Info VName) -> m (SrcLoc -> AppExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv ExpBase Info VName
    fexp m (SrcLoc -> AppExpBase Info VName)
    -> m SrcLoc -> m (AppExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    tv (Match ExpBase Info VName
    e NonEmpty (CaseBase Info VName)
    cases SrcLoc
    loc) =
        ExpBase Info VName
    -> NonEmpty (CaseBase Info VName)
    -> SrcLoc
    -> AppExpBase Info VName
    forall (f :: * -> *) vn.
    ExpBase f vn
    -> NonEmpty (CaseBase f vn) -> SrcLoc -> AppExpBase f vn
    Match (ExpBase Info VName
     -> NonEmpty (CaseBase Info VName)
     -> SrcLoc
     -> AppExpBase Info VName)
    -> m (ExpBase Info VName)
    -> m (NonEmpty (CaseBase Info VName)
          -> SrcLoc -> AppExpBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv ExpBase Info VName
    e m (NonEmpty (CaseBase Info VName)
       -> SrcLoc -> AppExpBase Info VName)
    -> m (NonEmpty (CaseBase Info VName))
    -> m (SrcLoc -> AppExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ASTMapper m
    -> NonEmpty (CaseBase Info VName)
    -> m (NonEmpty (CaseBase Info VName))
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> NonEmpty (CaseBase Info VName)
    -> m (NonEmpty (CaseBase Info VName))
    astMap ASTMapper m
    tv NonEmpty (CaseBase Info VName)
    cases m (SrcLoc -> AppExpBase Info VName)
    -> m SrcLoc -> m (AppExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    tv (Apply ExpBase Info VName
    f NonEmpty (Info (Maybe VName), ExpBase Info VName)
    args SrcLoc
    loc) = do
        ExpBase Info VName
    f' <- ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv ExpBase Info VName
    f
        NonEmpty (Info (Maybe VName), ExpBase Info VName)
    args' <- ((Info (Maybe VName), ExpBase Info VName)
     -> m (Info (Maybe VName), ExpBase Info VName))
    -> NonEmpty (Info (Maybe VName), ExpBase Info VName)
    -> m (NonEmpty (Info (Maybe VName), ExpBase Info VName))
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> NonEmpty a -> f (NonEmpty b)
    traverse ((ExpBase Info VName -> m (ExpBase Info VName))
    -> (Info (Maybe VName), ExpBase Info VName)
    -> m (Info (Maybe VName), ExpBase Info VName)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> (Info (Maybe VName), a) -> f (Info (Maybe VName), b)
    traverse ((ExpBase Info VName -> m (ExpBase Info VName))
     -> (Info (Maybe VName), ExpBase Info VName)
     -> m (Info (Maybe VName), ExpBase Info VName))
    -> (ExpBase Info VName -> m (ExpBase Info VName))
    -> (Info (Maybe VName), ExpBase Info VName)
    -> m (Info (Maybe VName), ExpBase Info VName)
    forall a b. (a -> b) -> a -> b
    $ ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv) NonEmpty (Info (Maybe VName), ExpBase Info VName)
    args
        -- Safe to disregard return type because existentials cannot be
        -- instantiated here, as the return is necessarily a function.
        AppExpBase Info VName -> m (AppExpBase Info VName)
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (AppExpBase Info VName -> m (AppExpBase Info VName))
    -> AppExpBase Info VName -> m (AppExpBase Info VName)
    forall a b. (a -> b) -> a -> b
    $ case ExpBase Info VName
    f' of
          AppExp (Apply ExpBase Info VName
    f_inner NonEmpty (Info (Maybe VName), ExpBase Info VName)
    args_inner SrcLoc
    _) Info AppRes
    _ ->
            ExpBase Info VName
    -> NonEmpty (Info (Maybe VName), ExpBase Info VName)
    -> SrcLoc
    -> AppExpBase Info VName
    forall (f :: * -> *) vn.
    ExpBase f vn
    -> NonEmpty (f (Maybe VName), ExpBase f vn)
    -> SrcLoc
    -> AppExpBase f vn
    Apply ExpBase Info VName
    f_inner (NonEmpty (Info (Maybe VName), ExpBase Info VName)
    args_inner NonEmpty (Info (Maybe VName), ExpBase Info VName)
    -> NonEmpty (Info (Maybe VName), ExpBase Info VName)
    -> NonEmpty (Info (Maybe VName), ExpBase Info VName)
    forall a. Semigroup a => a -> a -> a
    <> NonEmpty (Info (Maybe VName), ExpBase Info VName)
    args') SrcLoc
    loc
          ExpBase Info VName
    _ ->
            ExpBase Info VName
    -> NonEmpty (Info (Maybe VName), ExpBase Info VName)
    -> SrcLoc
    -> AppExpBase Info VName
    forall (f :: * -> *) vn.
    ExpBase f vn
    -> NonEmpty (f (Maybe VName), ExpBase f vn)
    -> SrcLoc
    -> AppExpBase f vn
    Apply ExpBase Info VName
    f' NonEmpty (Info (Maybe VName), ExpBase Info VName)
    args' SrcLoc
    loc
      astMap ASTMapper m
    tv (LetPat [SizeBinder VName]
    sizes PatBase Info VName StructType
    pat ExpBase Info VName
    e ExpBase Info VName
    body SrcLoc
    loc) =
        [SizeBinder VName]
    -> PatBase Info VName StructType
    -> ExpBase Info VName
    -> ExpBase Info VName
    -> SrcLoc
    -> AppExpBase Info VName
    forall (f :: * -> *) vn.
    [SizeBinder vn]
    -> PatBase f vn StructType
    -> ExpBase f vn
    -> ExpBase f vn
    -> SrcLoc
    -> AppExpBase f vn
    LetPat [SizeBinder VName]
    sizes (PatBase Info VName StructType
     -> ExpBase Info VName
     -> ExpBase Info VName
     -> SrcLoc
     -> AppExpBase Info VName)
    -> m (PatBase Info VName StructType)
    -> m (ExpBase Info VName
          -> ExpBase Info VName -> SrcLoc -> AppExpBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m
    -> PatBase Info VName StructType
    -> m (PatBase Info VName StructType)
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> PatBase Info VName StructType
    -> m (PatBase Info VName StructType)
    astMap ASTMapper m
    tv PatBase Info VName StructType
    pat m (ExpBase Info VName
       -> ExpBase Info VName -> SrcLoc -> AppExpBase Info VName)
    -> m (ExpBase Info VName)
    -> m (ExpBase Info VName -> SrcLoc -> AppExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv ExpBase Info VName
    e m (ExpBase Info VName -> SrcLoc -> AppExpBase Info VName)
    -> m (ExpBase Info VName) -> m (SrcLoc -> AppExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv ExpBase Info VName
    body m (SrcLoc -> AppExpBase Info VName)
    -> m SrcLoc -> m (AppExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    tv (LetFun VName
    name ([TypeParamBase VName]
    tparams, [PatBase Info VName ParamType]
    params, Maybe (TypeExp (ExpBase Info VName) VName)
    ret, Info ResRetType
    t, ExpBase Info VName
    e) ExpBase Info VName
    body SrcLoc
    loc) =
        VName
    -> ([TypeParamBase VName], [PatBase Info VName ParamType],
        Maybe (TypeExp (ExpBase Info VName) VName), Info ResRetType,
        ExpBase Info VName)
    -> ExpBase Info VName
    -> SrcLoc
    -> AppExpBase Info VName
    forall (f :: * -> *) vn.
    vn
    -> ([TypeParamBase vn], [PatBase f vn ParamType],
        Maybe (TypeExp (ExpBase f vn) vn), f ResRetType, ExpBase f vn)
    -> ExpBase f vn
    -> SrcLoc
    -> AppExpBase f vn
    LetFun VName
    name
          (([TypeParamBase VName], [PatBase Info VName ParamType],
      Maybe (TypeExp (ExpBase Info VName) VName), Info ResRetType,
      ExpBase Info VName)
     -> ExpBase Info VName -> SrcLoc -> AppExpBase Info VName)
    -> m ([TypeParamBase VName], [PatBase Info VName ParamType],
          Maybe (TypeExp (ExpBase Info VName) VName), Info ResRetType,
          ExpBase Info VName)
    -> m (ExpBase Info VName -> SrcLoc -> AppExpBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ( ([TypeParamBase VName]
    tparams,,,,)
                  ([PatBase Info VName ParamType]
     -> Maybe (TypeExp (ExpBase Info VName) VName)
     -> Info ResRetType
     -> ExpBase Info VName
     -> ([TypeParamBase VName], [PatBase Info VName ParamType],
         Maybe (TypeExp (ExpBase Info VName) VName), Info ResRetType,
         ExpBase Info VName))
    -> m [PatBase Info VName ParamType]
    -> m (Maybe (TypeExp (ExpBase Info VName) VName)
          -> Info ResRetType
          -> ExpBase Info VName
          -> ([TypeParamBase VName], [PatBase Info VName ParamType],
              Maybe (TypeExp (ExpBase Info VName) VName), Info ResRetType,
              ExpBase Info VName))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (PatBase Info VName ParamType -> m (PatBase Info VName ParamType))
    -> [PatBase Info VName ParamType]
    -> m [PatBase Info VName ParamType]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM (ASTMapper m
    -> PatBase Info VName ParamType -> m (PatBase Info VName ParamType)
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> PatBase Info VName ParamType -> m (PatBase Info VName ParamType)
    astMap ASTMapper m
    tv) [PatBase Info VName ParamType]
    params
                  m (Maybe (TypeExp (ExpBase Info VName) VName)
       -> Info ResRetType
       -> ExpBase Info VName
       -> ([TypeParamBase VName], [PatBase Info VName ParamType],
           Maybe (TypeExp (ExpBase Info VName) VName), Info ResRetType,
           ExpBase Info VName))
    -> m (Maybe (TypeExp (ExpBase Info VName) VName))
    -> m (Info ResRetType
          -> ExpBase Info VName
          -> ([TypeParamBase VName], [PatBase Info VName ParamType],
              Maybe (TypeExp (ExpBase Info VName) VName), Info ResRetType,
              ExpBase Info VName))
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (TypeExp (ExpBase Info VName) VName
     -> m (TypeExp (ExpBase Info VName) VName))
    -> Maybe (TypeExp (ExpBase Info VName) VName)
    -> m (Maybe (TypeExp (ExpBase Info VName) VName))
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Maybe a -> f (Maybe b)
    traverse (ASTMapper m
    -> TypeExp (ExpBase Info VName) VName
    -> m (TypeExp (ExpBase Info VName) VName)
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> TypeExp (ExpBase Info VName) VName
    -> m (TypeExp (ExpBase Info VName) VName)
    astMap ASTMapper m
    tv) Maybe (TypeExp (ExpBase Info VName) VName)
    ret
                  m (Info ResRetType
       -> ExpBase Info VName
       -> ([TypeParamBase VName], [PatBase Info VName ParamType],
           Maybe (TypeExp (ExpBase Info VName) VName), Info ResRetType,
           ExpBase Info VName))
    -> m (Info ResRetType)
    -> m (ExpBase Info VName
          -> ([TypeParamBase VName], [PatBase Info VName ParamType],
              Maybe (TypeExp (ExpBase Info VName) VName), Info ResRetType,
              ExpBase Info VName))
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (ResRetType -> m ResRetType)
    -> Info ResRetType -> m (Info ResRetType)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Info a -> f (Info b)
    traverse (ASTMapper m -> ResRetType -> m ResRetType
    forall (m :: * -> *). ASTMapper m -> ResRetType -> m ResRetType
    mapOnResRetType ASTMapper m
    tv) Info ResRetType
    t
                  m (ExpBase Info VName
       -> ([TypeParamBase VName], [PatBase Info VName ParamType],
           Maybe (TypeExp (ExpBase Info VName) VName), Info ResRetType,
           ExpBase Info VName))
    -> m (ExpBase Info VName)
    -> m ([TypeParamBase VName], [PatBase Info VName ParamType],
          Maybe (TypeExp (ExpBase Info VName) VName), Info ResRetType,
          ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv ExpBase Info VName
    e
              )
          m (ExpBase Info VName -> SrcLoc -> AppExpBase Info VName)
    -> m (ExpBase Info VName) -> m (SrcLoc -> AppExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv ExpBase Info VName
    body
          m (SrcLoc -> AppExpBase Info VName)
    -> m SrcLoc -> m (AppExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    tv (LetWith IdentBase Info VName StructType
    dest IdentBase Info VName StructType
    src SliceBase Info VName
    idxexps ExpBase Info VName
    vexp ExpBase Info VName
    body SrcLoc
    loc) =
        IdentBase Info VName StructType
    -> IdentBase Info VName StructType
    -> SliceBase Info VName
    -> ExpBase Info VName
    -> ExpBase Info VName
    -> SrcLoc
    -> AppExpBase Info VName
    forall (f :: * -> *) vn.
    IdentBase f vn StructType
    -> IdentBase f vn StructType
    -> SliceBase f vn
    -> ExpBase f vn
    -> ExpBase f vn
    -> SrcLoc
    -> AppExpBase f vn
    LetWith
          (IdentBase Info VName StructType
     -> IdentBase Info VName StructType
     -> SliceBase Info VName
     -> ExpBase Info VName
     -> ExpBase Info VName
     -> SrcLoc
     -> AppExpBase Info VName)
    -> m (IdentBase Info VName StructType)
    -> m (IdentBase Info VName StructType
          -> SliceBase Info VName
          -> ExpBase Info VName
          -> ExpBase Info VName
          -> SrcLoc
          -> AppExpBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m
    -> IdentBase Info VName StructType
    -> m (IdentBase Info VName StructType)
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> IdentBase Info VName StructType
    -> m (IdentBase Info VName StructType)
    astMap ASTMapper m
    tv IdentBase Info VName StructType
    dest
          m (IdentBase Info VName StructType
       -> SliceBase Info VName
       -> ExpBase Info VName
       -> ExpBase Info VName
       -> SrcLoc
       -> AppExpBase Info VName)
    -> m (IdentBase Info VName StructType)
    -> m (SliceBase Info VName
          -> ExpBase Info VName
          -> ExpBase Info VName
          -> SrcLoc
          -> AppExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ASTMapper m
    -> IdentBase Info VName StructType
    -> m (IdentBase Info VName StructType)
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> IdentBase Info VName StructType
    -> m (IdentBase Info VName StructType)
    astMap ASTMapper m
    tv IdentBase Info VName StructType
    src
          m (SliceBase Info VName
       -> ExpBase Info VName
       -> ExpBase Info VName
       -> SrcLoc
       -> AppExpBase Info VName)
    -> m (SliceBase Info VName)
    -> m (ExpBase Info VName
          -> ExpBase Info VName -> SrcLoc -> AppExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (DimIndexBase Info VName -> m (DimIndexBase Info VName))
    -> SliceBase Info VName -> m (SliceBase Info VName)
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM (ASTMapper m
    -> DimIndexBase Info VName -> m (DimIndexBase Info VName)
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> DimIndexBase Info VName -> m (DimIndexBase Info VName)
    astMap ASTMapper m
    tv) SliceBase Info VName
    idxexps
          m (ExpBase Info VName
       -> ExpBase Info VName -> SrcLoc -> AppExpBase Info VName)
    -> m (ExpBase Info VName)
    -> m (ExpBase Info VName -> SrcLoc -> AppExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv ExpBase Info VName
    vexp
          m (ExpBase Info VName -> SrcLoc -> AppExpBase Info VName)
    -> m (ExpBase Info VName) -> m (SrcLoc -> AppExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv ExpBase Info VName
    body
          m (SrcLoc -> AppExpBase Info VName)
    -> m SrcLoc -> m (AppExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    tv (BinOp (QualName VName
    fname, SrcLoc
    fname_loc) Info StructType
    t (ExpBase Info VName
    x, Info (Maybe VName)
    xext) (ExpBase Info VName
    y, Info (Maybe VName)
    yext) SrcLoc
    loc) =
        (QualName VName, SrcLoc)
    -> Info StructType
    -> (ExpBase Info VName, Info (Maybe VName))
    -> (ExpBase Info VName, Info (Maybe VName))
    -> SrcLoc
    -> AppExpBase Info VName
    forall (f :: * -> *) vn.
    (QualName vn, SrcLoc)
    -> f StructType
    -> (ExpBase f vn, f (Maybe VName))
    -> (ExpBase f vn, f (Maybe VName))
    -> SrcLoc
    -> AppExpBase f vn
    BinOp
          ((QualName VName, SrcLoc)
     -> Info StructType
     -> (ExpBase Info VName, Info (Maybe VName))
     -> (ExpBase Info VName, Info (Maybe VName))
     -> SrcLoc
     -> AppExpBase Info VName)
    -> m (QualName VName, SrcLoc)
    -> m (Info StructType
          -> (ExpBase Info VName, Info (Maybe VName))
          -> (ExpBase Info VName, Info (Maybe VName))
          -> SrcLoc
          -> AppExpBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ((,) (QualName VName -> SrcLoc -> (QualName VName, SrcLoc))
    -> m (QualName VName) -> m (SrcLoc -> (QualName VName, SrcLoc))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m -> QualName VName -> m (QualName VName)
    forall (m :: * -> *).
    ASTMapper m -> QualName VName -> m (QualName VName)
    mapOnName ASTMapper m
    tv QualName VName
    fname m (SrcLoc -> (QualName VName, SrcLoc))
    -> m SrcLoc -> m (QualName VName, SrcLoc)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    fname_loc)
          m (Info StructType
       -> (ExpBase Info VName, Info (Maybe VName))
       -> (ExpBase Info VName, Info (Maybe VName))
       -> SrcLoc
       -> AppExpBase Info VName)
    -> m (Info StructType)
    -> m ((ExpBase Info VName, Info (Maybe VName))
          -> (ExpBase Info VName, Info (Maybe VName))
          -> SrcLoc
          -> AppExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (StructType -> m StructType)
    -> Info StructType -> m (Info StructType)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Info a -> f (Info b)
    traverse (ASTMapper m -> StructType -> m StructType
    forall (m :: * -> *). ASTMapper m -> StructType -> m StructType
    mapOnStructType ASTMapper m
    tv) Info StructType
    t
          m ((ExpBase Info VName, Info (Maybe VName))
       -> (ExpBase Info VName, Info (Maybe VName))
       -> SrcLoc
       -> AppExpBase Info VName)
    -> m (ExpBase Info VName, Info (Maybe VName))
    -> m ((ExpBase Info VName, Info (Maybe VName))
          -> SrcLoc -> AppExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ((,) (ExpBase Info VName
     -> Info (Maybe VName) -> (ExpBase Info VName, Info (Maybe VName)))
    -> m (ExpBase Info VName)
    -> m (Info (Maybe VName)
          -> (ExpBase Info VName, Info (Maybe VName)))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv ExpBase Info VName
    x m (Info (Maybe VName) -> (ExpBase Info VName, Info (Maybe VName)))
    -> m (Info (Maybe VName))
    -> m (ExpBase Info VName, Info (Maybe VName))
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Info (Maybe VName) -> m (Info (Maybe VName))
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Info (Maybe VName)
    xext)
          m ((ExpBase Info VName, Info (Maybe VName))
       -> SrcLoc -> AppExpBase Info VName)
    -> m (ExpBase Info VName, Info (Maybe VName))
    -> m (SrcLoc -> AppExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ((,) (ExpBase Info VName
     -> Info (Maybe VName) -> (ExpBase Info VName, Info (Maybe VName)))
    -> m (ExpBase Info VName)
    -> m (Info (Maybe VName)
          -> (ExpBase Info VName, Info (Maybe VName)))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv ExpBase Info VName
    y m (Info (Maybe VName) -> (ExpBase Info VName, Info (Maybe VName)))
    -> m (Info (Maybe VName))
    -> m (ExpBase Info VName, Info (Maybe VName))
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Info (Maybe VName) -> m (Info (Maybe VName))
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Info (Maybe VName)
    yext)
          m (SrcLoc -> AppExpBase Info VName)
    -> m SrcLoc -> m (AppExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    tv (Loop [VName]
    sparams PatBase Info VName ParamType
    mergepat LoopInitBase Info VName
    loopinit LoopFormBase Info VName
    form ExpBase Info VName
    loopbody SrcLoc
    loc) =
        [VName]
    -> PatBase Info VName ParamType
    -> LoopInitBase Info VName
    -> LoopFormBase Info VName
    -> ExpBase Info VName
    -> SrcLoc
    -> AppExpBase Info VName
    forall (f :: * -> *) vn.
    [VName]
    -> PatBase f vn ParamType
    -> LoopInitBase f vn
    -> LoopFormBase f vn
    -> ExpBase f vn
    -> SrcLoc
    -> AppExpBase f vn
    Loop [VName]
    sparams
          (PatBase Info VName ParamType
     -> LoopInitBase Info VName
     -> LoopFormBase Info VName
     -> ExpBase Info VName
     -> SrcLoc
     -> AppExpBase Info VName)
    -> m (PatBase Info VName ParamType)
    -> m (LoopInitBase Info VName
          -> LoopFormBase Info VName
          -> ExpBase Info VName
          -> SrcLoc
          -> AppExpBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m
    -> PatBase Info VName ParamType -> m (PatBase Info VName ParamType)
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> PatBase Info VName ParamType -> m (PatBase Info VName ParamType)
    astMap ASTMapper m
    tv PatBase Info VName ParamType
    mergepat
          m (LoopInitBase Info VName
       -> LoopFormBase Info VName
       -> ExpBase Info VName
       -> SrcLoc
       -> AppExpBase Info VName)
    -> m (LoopInitBase Info VName)
    -> m (LoopFormBase Info VName
          -> ExpBase Info VName -> SrcLoc -> AppExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ASTMapper m
    -> LoopInitBase Info VName -> m (LoopInitBase Info VName)
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> LoopInitBase Info VName -> m (LoopInitBase Info VName)
    astMap ASTMapper m
    tv LoopInitBase Info VName
    loopinit
          m (LoopFormBase Info VName
       -> ExpBase Info VName -> SrcLoc -> AppExpBase Info VName)
    -> m (LoopFormBase Info VName)
    -> m (ExpBase Info VName -> SrcLoc -> AppExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ASTMapper m
    -> LoopFormBase Info VName -> m (LoopFormBase Info VName)
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> LoopFormBase Info VName -> m (LoopFormBase Info VName)
    astMap ASTMapper m
    tv LoopFormBase Info VName
    form
          m (ExpBase Info VName -> SrcLoc -> AppExpBase Info VName)
    -> m (ExpBase Info VName) -> m (SrcLoc -> AppExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv ExpBase Info VName
    loopbody
          m (SrcLoc -> AppExpBase Info VName)
    -> m SrcLoc -> m (AppExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    tv (Index ExpBase Info VName
    arr SliceBase Info VName
    idxexps SrcLoc
    loc) =
        ExpBase Info VName
    -> SliceBase Info VName -> SrcLoc -> AppExpBase Info VName
    forall (f :: * -> *) vn.
    ExpBase f vn -> SliceBase f vn -> SrcLoc -> AppExpBase f vn
    Index (ExpBase Info VName
     -> SliceBase Info VName -> SrcLoc -> AppExpBase Info VName)
    -> m (ExpBase Info VName)
    -> m (SliceBase Info VName -> SrcLoc -> AppExpBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv ExpBase Info VName
    arr m (SliceBase Info VName -> SrcLoc -> AppExpBase Info VName)
    -> m (SliceBase Info VName) -> m (SrcLoc -> AppExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (DimIndexBase Info VName -> m (DimIndexBase Info VName))
    -> SliceBase Info VName -> m (SliceBase Info VName)
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM (ASTMapper m
    -> DimIndexBase Info VName -> m (DimIndexBase Info VName)
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> DimIndexBase Info VName -> m (DimIndexBase Info VName)
    astMap ASTMapper m
    tv) SliceBase Info VName
    idxexps m (SrcLoc -> AppExpBase Info VName)
    -> m SrcLoc -> m (AppExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc

    instance ASTMappable (ExpBase Info VName) where
      astMap :: forall (m :: * -> *).
    Monad m =>
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    astMap ASTMapper m
    tv (Var QualName VName
    name Info StructType
    t SrcLoc
    loc) =
        QualName VName -> Info StructType -> SrcLoc -> ExpBase Info VName
    forall (f :: * -> *) vn.
    QualName vn -> f StructType -> SrcLoc -> ExpBase f vn
    Var
          (QualName VName -> Info StructType -> SrcLoc -> ExpBase Info VName)
    -> m (QualName VName)
    -> m (Info StructType -> SrcLoc -> ExpBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m -> QualName VName -> m (QualName VName)
    forall (m :: * -> *).
    ASTMapper m -> QualName VName -> m (QualName VName)
    mapOnName ASTMapper m
    tv QualName VName
    name
          m (Info StructType -> SrcLoc -> ExpBase Info VName)
    -> m (Info StructType) -> m (SrcLoc -> ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (StructType -> m StructType)
    -> Info StructType -> m (Info StructType)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Info a -> f (Info b)
    traverse (ASTMapper m -> StructType -> m StructType
    forall (m :: * -> *). ASTMapper m -> StructType -> m StructType
    mapOnStructType ASTMapper m
    tv) Info StructType
    t
          m (SrcLoc -> ExpBase Info VName)
    -> m SrcLoc -> m (ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    tv (Hole Info StructType
    t SrcLoc
    loc) =
        Info StructType -> SrcLoc -> ExpBase Info VName
    forall (f :: * -> *) vn. f StructType -> SrcLoc -> ExpBase f vn
    Hole (Info StructType -> SrcLoc -> ExpBase Info VName)
    -> m (Info StructType) -> m (SrcLoc -> ExpBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (StructType -> m StructType)
    -> Info StructType -> m (Info StructType)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Info a -> f (Info b)
    traverse (ASTMapper m -> StructType -> m StructType
    forall (m :: * -> *). ASTMapper m -> StructType -> m StructType
    mapOnStructType ASTMapper m
    tv) Info StructType
    t m (SrcLoc -> ExpBase Info VName)
    -> m SrcLoc -> m (ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    _ (Literal PrimValue
    val SrcLoc
    loc) =
        ExpBase Info VName -> m (ExpBase Info VName)
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (ExpBase Info VName -> m (ExpBase Info VName))
    -> ExpBase Info VName -> m (ExpBase Info VName)
    forall a b. (a -> b) -> a -> b
    $ PrimValue -> SrcLoc -> ExpBase Info VName
    forall (f :: * -> *) vn. PrimValue -> SrcLoc -> ExpBase f vn
    Literal PrimValue
    val SrcLoc
    loc
      astMap ASTMapper m
    _ (StringLit [Word8]
    vs SrcLoc
    loc) =
        ExpBase Info VName -> m (ExpBase Info VName)
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (ExpBase Info VName -> m (ExpBase Info VName))
    -> ExpBase Info VName -> m (ExpBase Info VName)
    forall a b. (a -> b) -> a -> b
    $ [Word8] -> SrcLoc -> ExpBase Info VName
    forall (f :: * -> *) vn. [Word8] -> SrcLoc -> ExpBase f vn
    StringLit [Word8]
    vs SrcLoc
    loc
      astMap ASTMapper m
    tv (IntLit Integer
    val Info StructType
    t SrcLoc
    loc) =
        Integer -> Info StructType -> SrcLoc -> ExpBase Info VName
    forall (f :: * -> *) vn.
    Integer -> f StructType -> SrcLoc -> ExpBase f vn
    IntLit Integer
    val (Info StructType -> SrcLoc -> ExpBase Info VName)
    -> m (Info StructType) -> m (SrcLoc -> ExpBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (StructType -> m StructType)
    -> Info StructType -> m (Info StructType)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Info a -> f (Info b)
    traverse (ASTMapper m -> StructType -> m StructType
    forall (m :: * -> *). ASTMapper m -> StructType -> m StructType
    mapOnStructType ASTMapper m
    tv) Info StructType
    t m (SrcLoc -> ExpBase Info VName)
    -> m SrcLoc -> m (ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    tv (FloatLit Double
    val Info StructType
    t SrcLoc
    loc) =
        Double -> Info StructType -> SrcLoc -> ExpBase Info VName
    forall (f :: * -> *) vn.
    Double -> f StructType -> SrcLoc -> ExpBase f vn
    FloatLit Double
    val (Info StructType -> SrcLoc -> ExpBase Info VName)
    -> m (Info StructType) -> m (SrcLoc -> ExpBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (StructType -> m StructType)
    -> Info StructType -> m (Info StructType)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Info a -> f (Info b)
    traverse (ASTMapper m -> StructType -> m StructType
    forall (m :: * -> *). ASTMapper m -> StructType -> m StructType
    mapOnStructType ASTMapper m
    tv) Info StructType
    t m (SrcLoc -> ExpBase Info VName)
    -> m SrcLoc -> m (ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    tv (Parens ExpBase Info VName
    e SrcLoc
    loc) =
        ExpBase Info VName -> SrcLoc -> ExpBase Info VName
    forall (f :: * -> *) vn. ExpBase f vn -> SrcLoc -> ExpBase f vn
    Parens (ExpBase Info VName -> SrcLoc -> ExpBase Info VName)
    -> m (ExpBase Info VName) -> m (SrcLoc -> ExpBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv ExpBase Info VName
    e m (SrcLoc -> ExpBase Info VName)
    -> m SrcLoc -> m (ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    tv (QualParens (QualName VName
    name, SrcLoc
    nameloc) ExpBase Info VName
    e SrcLoc
    loc) =
        (QualName VName, SrcLoc)
    -> ExpBase Info VName -> SrcLoc -> ExpBase Info VName
    forall (f :: * -> *) vn.
    (QualName vn, SrcLoc) -> ExpBase f vn -> SrcLoc -> ExpBase f vn
    QualParens
          ((QualName VName, SrcLoc)
     -> ExpBase Info VName -> SrcLoc -> ExpBase Info VName)
    -> m (QualName VName, SrcLoc)
    -> m (ExpBase Info VName -> SrcLoc -> ExpBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ((,) (QualName VName -> SrcLoc -> (QualName VName, SrcLoc))
    -> m (QualName VName) -> m (SrcLoc -> (QualName VName, SrcLoc))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m -> QualName VName -> m (QualName VName)
    forall (m :: * -> *).
    ASTMapper m -> QualName VName -> m (QualName VName)
    mapOnName ASTMapper m
    tv QualName VName
    name m (SrcLoc -> (QualName VName, SrcLoc))
    -> m SrcLoc -> m (QualName VName, SrcLoc)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    nameloc)
          m (ExpBase Info VName -> SrcLoc -> ExpBase Info VName)
    -> m (ExpBase Info VName) -> m (SrcLoc -> ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv ExpBase Info VName
    e
          m (SrcLoc -> ExpBase Info VName)
    -> m SrcLoc -> m (ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    tv (TupLit [ExpBase Info VName]
    els SrcLoc
    loc) =
        [ExpBase Info VName] -> SrcLoc -> ExpBase Info VName
    forall (f :: * -> *) vn. [ExpBase f vn] -> SrcLoc -> ExpBase f vn
    TupLit ([ExpBase Info VName] -> SrcLoc -> ExpBase Info VName)
    -> m [ExpBase Info VName] -> m (SrcLoc -> ExpBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (ExpBase Info VName -> m (ExpBase Info VName))
    -> [ExpBase Info VName] -> m [ExpBase Info VName]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM (ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv) [ExpBase Info VName]
    els m (SrcLoc -> ExpBase Info VName)
    -> m SrcLoc -> m (ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    tv (RecordLit [FieldBase Info VName]
    fields SrcLoc
    loc) =
        [FieldBase Info VName] -> SrcLoc -> ExpBase Info VName
    forall (f :: * -> *) vn. [FieldBase f vn] -> SrcLoc -> ExpBase f vn
    RecordLit ([FieldBase Info VName] -> SrcLoc -> ExpBase Info VName)
    -> m [FieldBase Info VName] -> m (SrcLoc -> ExpBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m -> [FieldBase Info VName] -> m [FieldBase Info VName]
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *).
    Monad m =>
    ASTMapper m -> [FieldBase Info VName] -> m [FieldBase Info VName]
    astMap ASTMapper m
    tv [FieldBase Info VName]
    fields m (SrcLoc -> ExpBase Info VName)
    -> m SrcLoc -> m (ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    _ (ArrayVal [PrimValue]
    vs PrimType
    t SrcLoc
    loc) =
        ExpBase Info VName -> m (ExpBase Info VName)
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (ExpBase Info VName -> m (ExpBase Info VName))
    -> ExpBase Info VName -> m (ExpBase Info VName)
    forall a b. (a -> b) -> a -> b
    $ [PrimValue] -> PrimType -> SrcLoc -> ExpBase Info VName
    forall (f :: * -> *) vn.
    [PrimValue] -> PrimType -> SrcLoc -> ExpBase f vn
    ArrayVal [PrimValue]
    vs PrimType
    t SrcLoc
    loc
      astMap ASTMapper m
    tv (ArrayLit [ExpBase Info VName]
    els Info StructType
    t SrcLoc
    loc) =
        [ExpBase Info VName]
    -> Info StructType -> SrcLoc -> ExpBase Info VName
    forall (f :: * -> *) vn.
    [ExpBase f vn] -> f StructType -> SrcLoc -> ExpBase f vn
    ArrayLit ([ExpBase Info VName]
     -> Info StructType -> SrcLoc -> ExpBase Info VName)
    -> m [ExpBase Info VName]
    -> m (Info StructType -> SrcLoc -> ExpBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (ExpBase Info VName -> m (ExpBase Info VName))
    -> [ExpBase Info VName] -> m [ExpBase Info VName]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM (ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv) [ExpBase Info VName]
    els m (Info StructType -> SrcLoc -> ExpBase Info VName)
    -> m (Info StructType) -> m (SrcLoc -> ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (StructType -> m StructType)
    -> Info StructType -> m (Info StructType)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Info a -> f (Info b)
    traverse (ASTMapper m -> StructType -> m StructType
    forall (m :: * -> *). ASTMapper m -> StructType -> m StructType
    mapOnStructType ASTMapper m
    tv) Info StructType
    t m (SrcLoc -> ExpBase Info VName)
    -> m SrcLoc -> m (ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    tv (Ascript ExpBase Info VName
    e TypeExp (ExpBase Info VName) VName
    tdecl SrcLoc
    loc) =
        ExpBase Info VName
    -> TypeExp (ExpBase Info VName) VName
    -> SrcLoc
    -> ExpBase Info VName
    forall (f :: * -> *) vn.
    ExpBase f vn -> TypeExp (ExpBase f vn) vn -> SrcLoc -> ExpBase f vn
    Ascript (ExpBase Info VName
     -> TypeExp (ExpBase Info VName) VName
     -> SrcLoc
     -> ExpBase Info VName)
    -> m (ExpBase Info VName)
    -> m (TypeExp (ExpBase Info VName) VName
          -> SrcLoc -> ExpBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv ExpBase Info VName
    e m (TypeExp (ExpBase Info VName) VName
       -> SrcLoc -> ExpBase Info VName)
    -> m (TypeExp (ExpBase Info VName) VName)
    -> m (SrcLoc -> ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ASTMapper m
    -> TypeExp (ExpBase Info VName) VName
    -> m (TypeExp (ExpBase Info VName) VName)
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> TypeExp (ExpBase Info VName) VName
    -> m (TypeExp (ExpBase Info VName) VName)
    astMap ASTMapper m
    tv TypeExp (ExpBase Info VName) VName
    tdecl m (SrcLoc -> ExpBase Info VName)
    -> m SrcLoc -> m (ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    tv (Coerce ExpBase Info VName
    e TypeExp (ExpBase Info VName) VName
    tdecl Info StructType
    t SrcLoc
    loc) =
        ExpBase Info VName
    -> TypeExp (ExpBase Info VName) VName
    -> Info StructType
    -> SrcLoc
    -> ExpBase Info VName
    forall (f :: * -> *) vn.
    ExpBase f vn
    -> TypeExp (ExpBase f vn) vn
    -> f StructType
    -> SrcLoc
    -> ExpBase f vn
    Coerce (ExpBase Info VName
     -> TypeExp (ExpBase Info VName) VName
     -> Info StructType
     -> SrcLoc
     -> ExpBase Info VName)
    -> m (ExpBase Info VName)
    -> m (TypeExp (ExpBase Info VName) VName
          -> Info StructType -> SrcLoc -> ExpBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv ExpBase Info VName
    e m (TypeExp (ExpBase Info VName) VName
       -> Info StructType -> SrcLoc -> ExpBase Info VName)
    -> m (TypeExp (ExpBase Info VName) VName)
    -> m (Info StructType -> SrcLoc -> ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ASTMapper m
    -> TypeExp (ExpBase Info VName) VName
    -> m (TypeExp (ExpBase Info VName) VName)
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> TypeExp (ExpBase Info VName) VName
    -> m (TypeExp (ExpBase Info VName) VName)
    astMap ASTMapper m
    tv TypeExp (ExpBase Info VName) VName
    tdecl m (Info StructType -> SrcLoc -> ExpBase Info VName)
    -> m (Info StructType) -> m (SrcLoc -> ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (StructType -> m StructType)
    -> Info StructType -> m (Info StructType)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Info a -> f (Info b)
    traverse (ASTMapper m -> StructType -> m StructType
    forall (m :: * -> *). ASTMapper m -> StructType -> m StructType
    mapOnStructType ASTMapper m
    tv) Info StructType
    t m (SrcLoc -> ExpBase Info VName)
    -> m SrcLoc -> m (ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    tv (Negate ExpBase Info VName
    x SrcLoc
    loc) =
        ExpBase Info VName -> SrcLoc -> ExpBase Info VName
    forall (f :: * -> *) vn. ExpBase f vn -> SrcLoc -> ExpBase f vn
    Negate (ExpBase Info VName -> SrcLoc -> ExpBase Info VName)
    -> m (ExpBase Info VName) -> m (SrcLoc -> ExpBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv ExpBase Info VName
    x m (SrcLoc -> ExpBase Info VName)
    -> m SrcLoc -> m (ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    tv (Not ExpBase Info VName
    x SrcLoc
    loc) =
        ExpBase Info VName -> SrcLoc -> ExpBase Info VName
    forall (f :: * -> *) vn. ExpBase f vn -> SrcLoc -> ExpBase f vn
    Not (ExpBase Info VName -> SrcLoc -> ExpBase Info VName)
    -> m (ExpBase Info VName) -> m (SrcLoc -> ExpBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv ExpBase Info VName
    x m (SrcLoc -> ExpBase Info VName)
    -> m SrcLoc -> m (ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    tv (Update ExpBase Info VName
    src SliceBase Info VName
    slice ExpBase Info VName
    v SrcLoc
    loc) =
        ExpBase Info VName
    -> SliceBase Info VName
    -> ExpBase Info VName
    -> SrcLoc
    -> ExpBase Info VName
    forall (f :: * -> *) vn.
    ExpBase f vn
    -> SliceBase f vn -> ExpBase f vn -> SrcLoc -> ExpBase f vn
    Update
          (ExpBase Info VName
     -> SliceBase Info VName
     -> ExpBase Info VName
     -> SrcLoc
     -> ExpBase Info VName)
    -> m (ExpBase Info VName)
    -> m (SliceBase Info VName
          -> ExpBase Info VName -> SrcLoc -> ExpBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv ExpBase Info VName
    src
          m (SliceBase Info VName
       -> ExpBase Info VName -> SrcLoc -> ExpBase Info VName)
    -> m (SliceBase Info VName)
    -> m (ExpBase Info VName -> SrcLoc -> ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (DimIndexBase Info VName -> m (DimIndexBase Info VName))
    -> SliceBase Info VName -> m (SliceBase Info VName)
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM (ASTMapper m
    -> DimIndexBase Info VName -> m (DimIndexBase Info VName)
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> DimIndexBase Info VName -> m (DimIndexBase Info VName)
    astMap ASTMapper m
    tv) SliceBase Info VName
    slice
          m (ExpBase Info VName -> SrcLoc -> ExpBase Info VName)
    -> m (ExpBase Info VName) -> m (SrcLoc -> ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv ExpBase Info VName
    v
          m (SrcLoc -> ExpBase Info VName)
    -> m SrcLoc -> m (ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    tv (RecordUpdate ExpBase Info VName
    src [Name]
    fs ExpBase Info VName
    v (Info StructType
    t) SrcLoc
    loc) =
        ExpBase Info VName
    -> [Name]
    -> ExpBase Info VName
    -> Info StructType
    -> SrcLoc
    -> ExpBase Info VName
    forall (f :: * -> *) vn.
    ExpBase f vn
    -> [Name] -> ExpBase f vn -> f StructType -> SrcLoc -> ExpBase f vn
    RecordUpdate
          (ExpBase Info VName
     -> [Name]
     -> ExpBase Info VName
     -> Info StructType
     -> SrcLoc
     -> ExpBase Info VName)
    -> m (ExpBase Info VName)
    -> m ([Name]
          -> ExpBase Info VName
          -> Info StructType
          -> SrcLoc
          -> ExpBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv ExpBase Info VName
    src
          m ([Name]
       -> ExpBase Info VName
       -> Info StructType
       -> SrcLoc
       -> ExpBase Info VName)
    -> m [Name]
    -> m (ExpBase Info VName
          -> Info StructType -> SrcLoc -> ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> [Name] -> m [Name]
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure [Name]
    fs
          m (ExpBase Info VName
       -> Info StructType -> SrcLoc -> ExpBase Info VName)
    -> m (ExpBase Info VName)
    -> m (Info StructType -> SrcLoc -> ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv ExpBase Info VName
    v
          m (Info StructType -> SrcLoc -> ExpBase Info VName)
    -> m (Info StructType) -> m (SrcLoc -> ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (StructType -> Info StructType
    forall a. a -> Info a
    Info (StructType -> Info StructType)
    -> m StructType -> m (Info StructType)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m -> StructType -> m StructType
    forall (m :: * -> *). ASTMapper m -> StructType -> m StructType
    mapOnStructType ASTMapper m
    tv StructType
    t)
          m (SrcLoc -> ExpBase Info VName)
    -> m SrcLoc -> m (ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    tv (Project Name
    field ExpBase Info VName
    e Info StructType
    t SrcLoc
    loc) =
        Name
    -> ExpBase Info VName
    -> Info StructType
    -> SrcLoc
    -> ExpBase Info VName
    forall (f :: * -> *) vn.
    Name -> ExpBase f vn -> f StructType -> SrcLoc -> ExpBase f vn
    Project Name
    field (ExpBase Info VName
     -> Info StructType -> SrcLoc -> ExpBase Info VName)
    -> m (ExpBase Info VName)
    -> m (Info StructType -> SrcLoc -> ExpBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv ExpBase Info VName
    e m (Info StructType -> SrcLoc -> ExpBase Info VName)
    -> m (Info StructType) -> m (SrcLoc -> ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (StructType -> m StructType)
    -> Info StructType -> m (Info StructType)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Info a -> f (Info b)
    traverse (ASTMapper m -> StructType -> m StructType
    forall (m :: * -> *). ASTMapper m -> StructType -> m StructType
    mapOnStructType ASTMapper m
    tv) Info StructType
    t m (SrcLoc -> ExpBase Info VName)
    -> m SrcLoc -> m (ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    tv (Assert ExpBase Info VName
    e1 ExpBase Info VName
    e2 Info Text
    desc SrcLoc
    loc) =
        ExpBase Info VName
    -> ExpBase Info VName -> Info Text -> SrcLoc -> ExpBase Info VName
    forall (f :: * -> *) vn.
    ExpBase f vn -> ExpBase f vn -> f Text -> SrcLoc -> ExpBase f vn
    Assert (ExpBase Info VName
     -> ExpBase Info VName -> Info Text -> SrcLoc -> ExpBase Info VName)
    -> m (ExpBase Info VName)
    -> m (ExpBase Info VName
          -> Info Text -> SrcLoc -> ExpBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv ExpBase Info VName
    e1 m (ExpBase Info VName -> Info Text -> SrcLoc -> ExpBase Info VName)
    -> m (ExpBase Info VName)
    -> m (Info Text -> SrcLoc -> ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv ExpBase Info VName
    e2 m (Info Text -> SrcLoc -> ExpBase Info VName)
    -> m (Info Text) -> m (SrcLoc -> ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Info Text -> m (Info Text)
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Info Text
    desc m (SrcLoc -> ExpBase Info VName)
    -> m SrcLoc -> m (ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    tv (Lambda [PatBase Info VName ParamType]
    params ExpBase Info VName
    body Maybe (TypeExp (ExpBase Info VName) VName)
    ret Info ResRetType
    t SrcLoc
    loc) =
        [PatBase Info VName ParamType]
    -> ExpBase Info VName
    -> Maybe (TypeExp (ExpBase Info VName) VName)
    -> Info ResRetType
    -> SrcLoc
    -> ExpBase Info VName
    forall (f :: * -> *) vn.
    [PatBase f vn ParamType]
    -> ExpBase f vn
    -> Maybe (TypeExp (ExpBase f vn) vn)
    -> f ResRetType
    -> SrcLoc
    -> ExpBase f vn
    Lambda
          ([PatBase Info VName ParamType]
     -> ExpBase Info VName
     -> Maybe (TypeExp (ExpBase Info VName) VName)
     -> Info ResRetType
     -> SrcLoc
     -> ExpBase Info VName)
    -> m [PatBase Info VName ParamType]
    -> m (ExpBase Info VName
          -> Maybe (TypeExp (ExpBase Info VName) VName)
          -> Info ResRetType
          -> SrcLoc
          -> ExpBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (PatBase Info VName ParamType -> m (PatBase Info VName ParamType))
    -> [PatBase Info VName ParamType]
    -> m [PatBase Info VName ParamType]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM (ASTMapper m
    -> PatBase Info VName ParamType -> m (PatBase Info VName ParamType)
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> PatBase Info VName ParamType -> m (PatBase Info VName ParamType)
    astMap ASTMapper m
    tv) [PatBase Info VName ParamType]
    params
          m (ExpBase Info VName
       -> Maybe (TypeExp (ExpBase Info VName) VName)
       -> Info ResRetType
       -> SrcLoc
       -> ExpBase Info VName)
    -> m (ExpBase Info VName)
    -> m (Maybe (TypeExp (ExpBase Info VName) VName)
          -> Info ResRetType -> SrcLoc -> ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv ExpBase Info VName
    body
          m (Maybe (TypeExp (ExpBase Info VName) VName)
       -> Info ResRetType -> SrcLoc -> ExpBase Info VName)
    -> m (Maybe (TypeExp (ExpBase Info VName) VName))
    -> m (Info ResRetType -> SrcLoc -> ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (TypeExp (ExpBase Info VName) VName
     -> m (TypeExp (ExpBase Info VName) VName))
    -> Maybe (TypeExp (ExpBase Info VName) VName)
    -> m (Maybe (TypeExp (ExpBase Info VName) VName))
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Maybe a -> f (Maybe b)
    traverse (ASTMapper m
    -> TypeExp (ExpBase Info VName) VName
    -> m (TypeExp (ExpBase Info VName) VName)
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> TypeExp (ExpBase Info VName) VName
    -> m (TypeExp (ExpBase Info VName) VName)
    astMap ASTMapper m
    tv) Maybe (TypeExp (ExpBase Info VName) VName)
    ret
          m (Info ResRetType -> SrcLoc -> ExpBase Info VName)
    -> m (Info ResRetType) -> m (SrcLoc -> ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (ResRetType -> m ResRetType)
    -> Info ResRetType -> m (Info ResRetType)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Info a -> f (Info b)
    traverse (ASTMapper m -> ResRetType -> m ResRetType
    forall (m :: * -> *). ASTMapper m -> ResRetType -> m ResRetType
    mapOnResRetType ASTMapper m
    tv) Info ResRetType
    t
          m (SrcLoc -> ExpBase Info VName)
    -> m SrcLoc -> m (ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    tv (OpSection QualName VName
    name Info StructType
    t SrcLoc
    loc) =
        QualName VName -> Info StructType -> SrcLoc -> ExpBase Info VName
    forall (f :: * -> *) vn.
    QualName vn -> f StructType -> SrcLoc -> ExpBase f vn
    OpSection
          (QualName VName -> Info StructType -> SrcLoc -> ExpBase Info VName)
    -> m (QualName VName)
    -> m (Info StructType -> SrcLoc -> ExpBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m -> QualName VName -> m (QualName VName)
    forall (m :: * -> *).
    ASTMapper m -> QualName VName -> m (QualName VName)
    mapOnName ASTMapper m
    tv QualName VName
    name
          m (Info StructType -> SrcLoc -> ExpBase Info VName)
    -> m (Info StructType) -> m (SrcLoc -> ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (StructType -> m StructType)
    -> Info StructType -> m (Info StructType)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Info a -> f (Info b)
    traverse (ASTMapper m -> StructType -> m StructType
    forall (m :: * -> *). ASTMapper m -> StructType -> m StructType
    mapOnStructType ASTMapper m
    tv) Info StructType
    t
          m (SrcLoc -> ExpBase Info VName)
    -> m SrcLoc -> m (ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    tv (OpSectionLeft QualName VName
    name Info StructType
    t ExpBase Info VName
    arg (Info (PName
    pa, ParamType
    t1a, Maybe VName
    argext), Info (PName
    pb, ParamType
    t1b)) (Info ResRetType
    ret, Info [VName]
    retext) SrcLoc
    loc) =
        QualName VName
    -> Info StructType
    -> ExpBase Info VName
    -> (Info (PName, ParamType, Maybe VName), Info (PName, ParamType))
    -> (Info ResRetType, Info [VName])
    -> SrcLoc
    -> ExpBase Info VName
    forall (f :: * -> *) vn.
    QualName vn
    -> f StructType
    -> ExpBase f vn
    -> (f (PName, ParamType, Maybe VName), f (PName, ParamType))
    -> (f ResRetType, f [VName])
    -> SrcLoc
    -> ExpBase f vn
    OpSectionLeft
          (QualName VName
     -> Info StructType
     -> ExpBase Info VName
     -> (Info (PName, ParamType, Maybe VName), Info (PName, ParamType))
     -> (Info ResRetType, Info [VName])
     -> SrcLoc
     -> ExpBase Info VName)
    -> m (QualName VName)
    -> m (Info StructType
          -> ExpBase Info VName
          -> (Info (PName, ParamType, Maybe VName), Info (PName, ParamType))
          -> (Info ResRetType, Info [VName])
          -> SrcLoc
          -> ExpBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m -> QualName VName -> m (QualName VName)
    forall (m :: * -> *).
    ASTMapper m -> QualName VName -> m (QualName VName)
    mapOnName ASTMapper m
    tv QualName VName
    name
          m (Info StructType
       -> ExpBase Info VName
       -> (Info (PName, ParamType, Maybe VName), Info (PName, ParamType))
       -> (Info ResRetType, Info [VName])
       -> SrcLoc
       -> ExpBase Info VName)
    -> m (Info StructType)
    -> m (ExpBase Info VName
          -> (Info (PName, ParamType, Maybe VName), Info (PName, ParamType))
          -> (Info ResRetType, Info [VName])
          -> SrcLoc
          -> ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (StructType -> m StructType)
    -> Info StructType -> m (Info StructType)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Info a -> f (Info b)
    traverse (ASTMapper m -> StructType -> m StructType
    forall (m :: * -> *). ASTMapper m -> StructType -> m StructType
    mapOnStructType ASTMapper m
    tv) Info StructType
    t
          m (ExpBase Info VName
       -> (Info (PName, ParamType, Maybe VName), Info (PName, ParamType))
       -> (Info ResRetType, Info [VName])
       -> SrcLoc
       -> ExpBase Info VName)
    -> m (ExpBase Info VName)
    -> m ((Info (PName, ParamType, Maybe VName),
           Info (PName, ParamType))
          -> (Info ResRetType, Info [VName]) -> SrcLoc -> ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv ExpBase Info VName
    arg
          m ((Info (PName, ParamType, Maybe VName), Info (PName, ParamType))
       -> (Info ResRetType, Info [VName]) -> SrcLoc -> ExpBase Info VName)
    -> m (Info (PName, ParamType, Maybe VName),
          Info (PName, ParamType))
    -> m ((Info ResRetType, Info [VName])
          -> SrcLoc -> ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ( (,)
                  (Info (PName, ParamType, Maybe VName)
     -> Info (PName, ParamType)
     -> (Info (PName, ParamType, Maybe VName), Info (PName, ParamType)))
    -> m (Info (PName, ParamType, Maybe VName))
    -> m (Info (PName, ParamType)
          -> (Info (PName, ParamType, Maybe VName), Info (PName, ParamType)))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ((PName, ParamType, Maybe VName)
    -> Info (PName, ParamType, Maybe VName)
    forall a. a -> Info a
    Info ((PName, ParamType, Maybe VName)
     -> Info (PName, ParamType, Maybe VName))
    -> m (PName, ParamType, Maybe VName)
    -> m (Info (PName, ParamType, Maybe VName))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ((PName
    pa,,) (ParamType -> Maybe VName -> (PName, ParamType, Maybe VName))
    -> m ParamType
    -> m (Maybe VName -> (PName, ParamType, Maybe VName))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m -> ParamType -> m ParamType
    forall (m :: * -> *). ASTMapper m -> ParamType -> m ParamType
    mapOnParamType ASTMapper m
    tv ParamType
    t1a m (Maybe VName -> (PName, ParamType, Maybe VName))
    -> m (Maybe VName) -> m (PName, ParamType, Maybe VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Maybe VName -> m (Maybe VName)
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Maybe VName
    argext))
                  m (Info (PName, ParamType)
       -> (Info (PName, ParamType, Maybe VName), Info (PName, ParamType)))
    -> m (Info (PName, ParamType))
    -> m (Info (PName, ParamType, Maybe VName),
          Info (PName, ParamType))
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ((PName, ParamType) -> Info (PName, ParamType)
    forall a. a -> Info a
    Info ((PName, ParamType) -> Info (PName, ParamType))
    -> m (PName, ParamType) -> m (Info (PName, ParamType))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ((PName
    pb,) (ParamType -> (PName, ParamType))
    -> m ParamType -> m (PName, ParamType)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m -> ParamType -> m ParamType
    forall (m :: * -> *). ASTMapper m -> ParamType -> m ParamType
    mapOnParamType ASTMapper m
    tv ParamType
    t1b))
              )
          m ((Info ResRetType, Info [VName]) -> SrcLoc -> ExpBase Info VName)
    -> m (Info ResRetType, Info [VName])
    -> m (SrcLoc -> ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ((,) (Info ResRetType
     -> Info [VName] -> (Info ResRetType, Info [VName]))
    -> m (Info ResRetType)
    -> m (Info [VName] -> (Info ResRetType, Info [VName]))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (ResRetType -> m ResRetType)
    -> Info ResRetType -> m (Info ResRetType)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Info a -> f (Info b)
    traverse (ASTMapper m -> ResRetType -> m ResRetType
    forall (m :: * -> *). ASTMapper m -> ResRetType -> m ResRetType
    mapOnResRetType ASTMapper m
    tv) Info ResRetType
    ret m (Info [VName] -> (Info ResRetType, Info [VName]))
    -> m (Info [VName]) -> m (Info ResRetType, Info [VName])
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Info [VName] -> m (Info [VName])
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Info [VName]
    retext)
          m (SrcLoc -> ExpBase Info VName)
    -> m SrcLoc -> m (ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    tv (OpSectionRight QualName VName
    name Info StructType
    t ExpBase Info VName
    arg (Info (PName
    pa, ParamType
    t1a), Info (PName
    pb, ParamType
    t1b, Maybe VName
    argext)) Info ResRetType
    t2 SrcLoc
    loc) =
        QualName VName
    -> Info StructType
    -> ExpBase Info VName
    -> (Info (PName, ParamType), Info (PName, ParamType, Maybe VName))
    -> Info ResRetType
    -> SrcLoc
    -> ExpBase Info VName
    forall (f :: * -> *) vn.
    QualName vn
    -> f StructType
    -> ExpBase f vn
    -> (f (PName, ParamType), f (PName, ParamType, Maybe VName))
    -> f ResRetType
    -> SrcLoc
    -> ExpBase f vn
    OpSectionRight
          (QualName VName
     -> Info StructType
     -> ExpBase Info VName
     -> (Info (PName, ParamType), Info (PName, ParamType, Maybe VName))
     -> Info ResRetType
     -> SrcLoc
     -> ExpBase Info VName)
    -> m (QualName VName)
    -> m (Info StructType
          -> ExpBase Info VName
          -> (Info (PName, ParamType), Info (PName, ParamType, Maybe VName))
          -> Info ResRetType
          -> SrcLoc
          -> ExpBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m -> QualName VName -> m (QualName VName)
    forall (m :: * -> *).
    ASTMapper m -> QualName VName -> m (QualName VName)
    mapOnName ASTMapper m
    tv QualName VName
    name
          m (Info StructType
       -> ExpBase Info VName
       -> (Info (PName, ParamType), Info (PName, ParamType, Maybe VName))
       -> Info ResRetType
       -> SrcLoc
       -> ExpBase Info VName)
    -> m (Info StructType)
    -> m (ExpBase Info VName
          -> (Info (PName, ParamType), Info (PName, ParamType, Maybe VName))
          -> Info ResRetType
          -> SrcLoc
          -> ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (StructType -> m StructType)
    -> Info StructType -> m (Info StructType)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Info a -> f (Info b)
    traverse (ASTMapper m -> StructType -> m StructType
    forall (m :: * -> *). ASTMapper m -> StructType -> m StructType
    mapOnStructType ASTMapper m
    tv) Info StructType
    t
          m (ExpBase Info VName
       -> (Info (PName, ParamType), Info (PName, ParamType, Maybe VName))
       -> Info ResRetType
       -> SrcLoc
       -> ExpBase Info VName)
    -> m (ExpBase Info VName)
    -> m ((Info (PName, ParamType),
           Info (PName, ParamType, Maybe VName))
          -> Info ResRetType -> SrcLoc -> ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv ExpBase Info VName
    arg
          m ((Info (PName, ParamType), Info (PName, ParamType, Maybe VName))
       -> Info ResRetType -> SrcLoc -> ExpBase Info VName)
    -> m (Info (PName, ParamType),
          Info (PName, ParamType, Maybe VName))
    -> m (Info ResRetType -> SrcLoc -> ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ( (,)
                  (Info (PName, ParamType)
     -> Info (PName, ParamType, Maybe VName)
     -> (Info (PName, ParamType), Info (PName, ParamType, Maybe VName)))
    -> m (Info (PName, ParamType))
    -> m (Info (PName, ParamType, Maybe VName)
          -> (Info (PName, ParamType), Info (PName, ParamType, Maybe VName)))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ((PName, ParamType) -> Info (PName, ParamType)
    forall a. a -> Info a
    Info ((PName, ParamType) -> Info (PName, ParamType))
    -> m (PName, ParamType) -> m (Info (PName, ParamType))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ((PName
    pa,) (ParamType -> (PName, ParamType))
    -> m ParamType -> m (PName, ParamType)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m -> ParamType -> m ParamType
    forall (m :: * -> *). ASTMapper m -> ParamType -> m ParamType
    mapOnParamType ASTMapper m
    tv ParamType
    t1a))
                  m (Info (PName, ParamType, Maybe VName)
       -> (Info (PName, ParamType), Info (PName, ParamType, Maybe VName)))
    -> m (Info (PName, ParamType, Maybe VName))
    -> m (Info (PName, ParamType),
          Info (PName, ParamType, Maybe VName))
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ((PName, ParamType, Maybe VName)
    -> Info (PName, ParamType, Maybe VName)
    forall a. a -> Info a
    Info ((PName, ParamType, Maybe VName)
     -> Info (PName, ParamType, Maybe VName))
    -> m (PName, ParamType, Maybe VName)
    -> m (Info (PName, ParamType, Maybe VName))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ((PName
    pb,,) (ParamType -> Maybe VName -> (PName, ParamType, Maybe VName))
    -> m ParamType
    -> m (Maybe VName -> (PName, ParamType, Maybe VName))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m -> ParamType -> m ParamType
    forall (m :: * -> *). ASTMapper m -> ParamType -> m ParamType
    mapOnParamType ASTMapper m
    tv ParamType
    t1b m (Maybe VName -> (PName, ParamType, Maybe VName))
    -> m (Maybe VName) -> m (PName, ParamType, Maybe VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Maybe VName -> m (Maybe VName)
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Maybe VName
    argext))
              )
          m (Info ResRetType -> SrcLoc -> ExpBase Info VName)
    -> m (Info ResRetType) -> m (SrcLoc -> ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (ResRetType -> m ResRetType)
    -> Info ResRetType -> m (Info ResRetType)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Info a -> f (Info b)
    traverse (ASTMapper m -> ResRetType -> m ResRetType
    forall (m :: * -> *). ASTMapper m -> ResRetType -> m ResRetType
    mapOnResRetType ASTMapper m
    tv) Info ResRetType
    t2
          m (SrcLoc -> ExpBase Info VName)
    -> m SrcLoc -> m (ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    tv (ProjectSection [Name]
    fields Info StructType
    t SrcLoc
    loc) =
        [Name] -> Info StructType -> SrcLoc -> ExpBase Info VName
    forall (f :: * -> *) vn.
    [Name] -> f StructType -> SrcLoc -> ExpBase f vn
    ProjectSection [Name]
    fields (Info StructType -> SrcLoc -> ExpBase Info VName)
    -> m (Info StructType) -> m (SrcLoc -> ExpBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (StructType -> m StructType)
    -> Info StructType -> m (Info StructType)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Info a -> f (Info b)
    traverse (ASTMapper m -> StructType -> m StructType
    forall (m :: * -> *). ASTMapper m -> StructType -> m StructType
    mapOnStructType ASTMapper m
    tv) Info StructType
    t m (SrcLoc -> ExpBase Info VName)
    -> m SrcLoc -> m (ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    tv (IndexSection SliceBase Info VName
    idxs Info StructType
    t SrcLoc
    loc) =
        SliceBase Info VName
    -> Info StructType -> SrcLoc -> ExpBase Info VName
    forall (f :: * -> *) vn.
    SliceBase f vn -> f StructType -> SrcLoc -> ExpBase f vn
    IndexSection
          (SliceBase Info VName
     -> Info StructType -> SrcLoc -> ExpBase Info VName)
    -> m (SliceBase Info VName)
    -> m (Info StructType -> SrcLoc -> ExpBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (DimIndexBase Info VName -> m (DimIndexBase Info VName))
    -> SliceBase Info VName -> m (SliceBase Info VName)
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM (ASTMapper m
    -> DimIndexBase Info VName -> m (DimIndexBase Info VName)
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> DimIndexBase Info VName -> m (DimIndexBase Info VName)
    astMap ASTMapper m
    tv) SliceBase Info VName
    idxs
          m (Info StructType -> SrcLoc -> ExpBase Info VName)
    -> m (Info StructType) -> m (SrcLoc -> ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (StructType -> m StructType)
    -> Info StructType -> m (Info StructType)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Info a -> f (Info b)
    traverse (ASTMapper m -> StructType -> m StructType
    forall (m :: * -> *). ASTMapper m -> StructType -> m StructType
    mapOnStructType ASTMapper m
    tv) Info StructType
    t
          m (SrcLoc -> ExpBase Info VName)
    -> m SrcLoc -> m (ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    tv (Constr Name
    name [ExpBase Info VName]
    es Info StructType
    t SrcLoc
    loc) =
        Name
    -> [ExpBase Info VName]
    -> Info StructType
    -> SrcLoc
    -> ExpBase Info VName
    forall (f :: * -> *) vn.
    Name -> [ExpBase f vn] -> f StructType -> SrcLoc -> ExpBase f vn
    Constr Name
    name ([ExpBase Info VName]
     -> Info StructType -> SrcLoc -> ExpBase Info VName)
    -> m [ExpBase Info VName]
    -> m (Info StructType -> SrcLoc -> ExpBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (ExpBase Info VName -> m (ExpBase Info VName))
    -> [ExpBase Info VName] -> m [ExpBase Info VName]
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> [a] -> f [b]
    traverse (ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv) [ExpBase Info VName]
    es m (Info StructType -> SrcLoc -> ExpBase Info VName)
    -> m (Info StructType) -> m (SrcLoc -> ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (StructType -> m StructType)
    -> Info StructType -> m (Info StructType)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Info a -> f (Info b)
    traverse (ASTMapper m -> StructType -> m StructType
    forall (m :: * -> *). ASTMapper m -> StructType -> m StructType
    mapOnStructType ASTMapper m
    tv) Info StructType
    t m (SrcLoc -> ExpBase Info VName)
    -> m SrcLoc -> m (ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    tv (Attr AttrInfo VName
    attr ExpBase Info VName
    e SrcLoc
    loc) =
        AttrInfo VName
    -> ExpBase Info VName -> SrcLoc -> ExpBase Info VName
    forall (f :: * -> *) vn.
    AttrInfo vn -> ExpBase f vn -> SrcLoc -> ExpBase f vn
    Attr AttrInfo VName
    attr (ExpBase Info VName -> SrcLoc -> ExpBase Info VName)
    -> m (ExpBase Info VName) -> m (SrcLoc -> ExpBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv ExpBase Info VName
    e m (SrcLoc -> ExpBase Info VName)
    -> m SrcLoc -> m (ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    tv (AppExp AppExpBase Info VName
    e Info AppRes
    res) =
        AppExpBase Info VName -> Info AppRes -> ExpBase Info VName
    forall (f :: * -> *) vn.
    AppExpBase f vn -> f AppRes -> ExpBase f vn
    AppExp (AppExpBase Info VName -> Info AppRes -> ExpBase Info VName)
    -> m (AppExpBase Info VName)
    -> m (Info AppRes -> ExpBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m -> AppExpBase Info VName -> m (AppExpBase Info VName)
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *).
    Monad m =>
    ASTMapper m -> AppExpBase Info VName -> m (AppExpBase Info VName)
    astMap ASTMapper m
    tv AppExpBase Info VName
    e m (Info AppRes -> ExpBase Info VName)
    -> m (Info AppRes) -> m (ExpBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ASTMapper m -> Info AppRes -> m (Info AppRes)
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *).
    Monad m =>
    ASTMapper m -> Info AppRes -> m (Info AppRes)
    astMap ASTMapper m
    tv Info AppRes
    res

    instance ASTMappable (LoopInitBase Info VName) where
      astMap :: forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> LoopInitBase Info VName -> m (LoopInitBase Info VName)
    astMap ASTMapper m
    tv (LoopInitExplicit ExpBase Info VName
    e) =
        ExpBase Info VName -> LoopInitBase Info VName
    forall (f :: * -> *) vn. ExpBase f vn -> LoopInitBase f vn
    LoopInitExplicit (ExpBase Info VName -> LoopInitBase Info VName)
    -> m (ExpBase Info VName) -> m (LoopInitBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv ExpBase Info VName
    e
      astMap ASTMapper m
    tv (LoopInitImplicit (Info ExpBase Info VName
    e)) =
        Info (ExpBase Info VName) -> LoopInitBase Info VName
    forall (f :: * -> *) vn. f (ExpBase f vn) -> LoopInitBase f vn
    LoopInitImplicit (Info (ExpBase Info VName) -> LoopInitBase Info VName)
    -> (ExpBase Info VName -> Info (ExpBase Info VName))
    -> ExpBase Info VName
    -> LoopInitBase Info VName
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ExpBase Info VName -> Info (ExpBase Info VName)
    forall a. a -> Info a
    Info (ExpBase Info VName -> LoopInitBase Info VName)
    -> m (ExpBase Info VName) -> m (LoopInitBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv ExpBase Info VName
    e

    instance ASTMappable (LoopFormBase Info VName) where
      astMap :: forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> LoopFormBase Info VName -> m (LoopFormBase Info VName)
    astMap ASTMapper m
    tv (For IdentBase Info VName StructType
    i ExpBase Info VName
    bound) = IdentBase Info VName StructType
    -> ExpBase Info VName -> LoopFormBase Info VName
    forall (f :: * -> *) vn.
    IdentBase f vn StructType -> ExpBase f vn -> LoopFormBase f vn
    For (IdentBase Info VName StructType
     -> ExpBase Info VName -> LoopFormBase Info VName)
    -> m (IdentBase Info VName StructType)
    -> m (ExpBase Info VName -> LoopFormBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m
    -> IdentBase Info VName StructType
    -> m (IdentBase Info VName StructType)
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> IdentBase Info VName StructType
    -> m (IdentBase Info VName StructType)
    astMap ASTMapper m
    tv IdentBase Info VName StructType
    i m (ExpBase Info VName -> LoopFormBase Info VName)
    -> m (ExpBase Info VName) -> m (LoopFormBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv ExpBase Info VName
    bound
      astMap ASTMapper m
    tv (ForIn PatBase Info VName StructType
    pat ExpBase Info VName
    e) = PatBase Info VName StructType
    -> ExpBase Info VName -> LoopFormBase Info VName
    forall (f :: * -> *) vn.
    PatBase f vn StructType -> ExpBase f vn -> LoopFormBase f vn
    ForIn (PatBase Info VName StructType
     -> ExpBase Info VName -> LoopFormBase Info VName)
    -> m (PatBase Info VName StructType)
    -> m (ExpBase Info VName -> LoopFormBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m
    -> PatBase Info VName StructType
    -> m (PatBase Info VName StructType)
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> PatBase Info VName StructType
    -> m (PatBase Info VName StructType)
    astMap ASTMapper m
    tv PatBase Info VName StructType
    pat m (ExpBase Info VName -> LoopFormBase Info VName)
    -> m (ExpBase Info VName) -> m (LoopFormBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv ExpBase Info VName
    e
      astMap ASTMapper m
    tv (While ExpBase Info VName
    e) = ExpBase Info VName -> LoopFormBase Info VName
    forall (f :: * -> *) vn. ExpBase f vn -> LoopFormBase f vn
    While (ExpBase Info VName -> LoopFormBase Info VName)
    -> m (ExpBase Info VName) -> m (LoopFormBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv ExpBase Info VName
    e

    instance ASTMappable (TypeExp (ExpBase Info VName) VName) where
      astMap :: forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> TypeExp (ExpBase Info VName) VName
    -> m (TypeExp (ExpBase Info VName) VName)
    astMap ASTMapper m
    tv (TEVar QualName VName
    qn SrcLoc
    loc) =
        QualName VName -> SrcLoc -> TypeExp (ExpBase Info VName) VName
    forall d vn. QualName vn -> SrcLoc -> TypeExp d vn
    TEVar (QualName VName -> SrcLoc -> TypeExp (ExpBase Info VName) VName)
    -> m (QualName VName)
    -> m (SrcLoc -> TypeExp (ExpBase Info VName) VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m -> QualName VName -> m (QualName VName)
    forall (m :: * -> *).
    ASTMapper m -> QualName VName -> m (QualName VName)
    mapOnName ASTMapper m
    tv QualName VName
    qn m (SrcLoc -> TypeExp (ExpBase Info VName) VName)
    -> m SrcLoc -> m (TypeExp (ExpBase Info VName) VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    tv (TEParens TypeExp (ExpBase Info VName) VName
    te SrcLoc
    loc) =
        TypeExp (ExpBase Info VName) VName
    -> SrcLoc -> TypeExp (ExpBase Info VName) VName
    forall d vn. TypeExp d vn -> SrcLoc -> TypeExp d vn
    TEParens (TypeExp (ExpBase Info VName) VName
     -> SrcLoc -> TypeExp (ExpBase Info VName) VName)
    -> m (TypeExp (ExpBase Info VName) VName)
    -> m (SrcLoc -> TypeExp (ExpBase Info VName) VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m
    -> TypeExp (ExpBase Info VName) VName
    -> m (TypeExp (ExpBase Info VName) VName)
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> TypeExp (ExpBase Info VName) VName
    -> m (TypeExp (ExpBase Info VName) VName)
    astMap ASTMapper m
    tv TypeExp (ExpBase Info VName) VName
    te m (SrcLoc -> TypeExp (ExpBase Info VName) VName)
    -> m SrcLoc -> m (TypeExp (ExpBase Info VName) VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    tv (TETuple [TypeExp (ExpBase Info VName) VName]
    ts SrcLoc
    loc) =
        [TypeExp (ExpBase Info VName) VName]
    -> SrcLoc -> TypeExp (ExpBase Info VName) VName
    forall d vn. [TypeExp d vn] -> SrcLoc -> TypeExp d vn
    TETuple ([TypeExp (ExpBase Info VName) VName]
     -> SrcLoc -> TypeExp (ExpBase Info VName) VName)
    -> m [TypeExp (ExpBase Info VName) VName]
    -> m (SrcLoc -> TypeExp (ExpBase Info VName) VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (TypeExp (ExpBase Info VName) VName
     -> m (TypeExp (ExpBase Info VName) VName))
    -> [TypeExp (ExpBase Info VName) VName]
    -> m [TypeExp (ExpBase Info VName) VName]
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> [a] -> f [b]
    traverse (ASTMapper m
    -> TypeExp (ExpBase Info VName) VName
    -> m (TypeExp (ExpBase Info VName) VName)
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> TypeExp (ExpBase Info VName) VName
    -> m (TypeExp (ExpBase Info VName) VName)
    astMap ASTMapper m
    tv) [TypeExp (ExpBase Info VName) VName]
    ts m (SrcLoc -> TypeExp (ExpBase Info VName) VName)
    -> m SrcLoc -> m (TypeExp (ExpBase Info VName) VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    tv (TERecord [(L Name, TypeExp (ExpBase Info VName) VName)]
    ts SrcLoc
    loc) =
        [(L Name, TypeExp (ExpBase Info VName) VName)]
    -> SrcLoc -> TypeExp (ExpBase Info VName) VName
    forall d vn. [(L Name, TypeExp d vn)] -> SrcLoc -> TypeExp d vn
    TERecord ([(L Name, TypeExp (ExpBase Info VName) VName)]
     -> SrcLoc -> TypeExp (ExpBase Info VName) VName)
    -> m [(L Name, TypeExp (ExpBase Info VName) VName)]
    -> m (SrcLoc -> TypeExp (ExpBase Info VName) VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ((L Name, TypeExp (ExpBase Info VName) VName)
     -> m (L Name, TypeExp (ExpBase Info VName) VName))
    -> [(L Name, TypeExp (ExpBase Info VName) VName)]
    -> m [(L Name, TypeExp (ExpBase Info VName) VName)]
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> [a] -> f [b]
    traverse ((TypeExp (ExpBase Info VName) VName
     -> m (TypeExp (ExpBase Info VName) VName))
    -> (L Name, TypeExp (ExpBase Info VName) VName)
    -> m (L Name, TypeExp (ExpBase Info VName) VName)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> (L Name, a) -> f (L Name, b)
    traverse ((TypeExp (ExpBase Info VName) VName
      -> m (TypeExp (ExpBase Info VName) VName))
     -> (L Name, TypeExp (ExpBase Info VName) VName)
     -> m (L Name, TypeExp (ExpBase Info VName) VName))
    -> (TypeExp (ExpBase Info VName) VName
        -> m (TypeExp (ExpBase Info VName) VName))
    -> (L Name, TypeExp (ExpBase Info VName) VName)
    -> m (L Name, TypeExp (ExpBase Info VName) VName)
    forall a b. (a -> b) -> a -> b
    $ ASTMapper m
    -> TypeExp (ExpBase Info VName) VName
    -> m (TypeExp (ExpBase Info VName) VName)
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> TypeExp (ExpBase Info VName) VName
    -> m (TypeExp (ExpBase Info VName) VName)
    astMap ASTMapper m
    tv) [(L Name, TypeExp (ExpBase Info VName) VName)]
    ts m (SrcLoc -> TypeExp (ExpBase Info VName) VName)
    -> m SrcLoc -> m (TypeExp (ExpBase Info VName) VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    tv (TEArray SizeExp (ExpBase Info VName)
    te TypeExp (ExpBase Info VName) VName
    dim SrcLoc
    loc) =
        SizeExp (ExpBase Info VName)
    -> TypeExp (ExpBase Info VName) VName
    -> SrcLoc
    -> TypeExp (ExpBase Info VName) VName
    forall d vn. SizeExp d -> TypeExp d vn -> SrcLoc -> TypeExp d vn
    TEArray (SizeExp (ExpBase Info VName)
     -> TypeExp (ExpBase Info VName) VName
     -> SrcLoc
     -> TypeExp (ExpBase Info VName) VName)
    -> m (SizeExp (ExpBase Info VName))
    -> m (TypeExp (ExpBase Info VName) VName
          -> SrcLoc -> TypeExp (ExpBase Info VName) VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m
    -> SizeExp (ExpBase Info VName) -> m (SizeExp (ExpBase Info VName))
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> SizeExp (ExpBase Info VName) -> m (SizeExp (ExpBase Info VName))
    astMap ASTMapper m
    tv SizeExp (ExpBase Info VName)
    te m (TypeExp (ExpBase Info VName) VName
       -> SrcLoc -> TypeExp (ExpBase Info VName) VName)
    -> m (TypeExp (ExpBase Info VName) VName)
    -> m (SrcLoc -> TypeExp (ExpBase Info VName) VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ASTMapper m
    -> TypeExp (ExpBase Info VName) VName
    -> m (TypeExp (ExpBase Info VName) VName)
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> TypeExp (ExpBase Info VName) VName
    -> m (TypeExp (ExpBase Info VName) VName)
    astMap ASTMapper m
    tv TypeExp (ExpBase Info VName) VName
    dim m (SrcLoc -> TypeExp (ExpBase Info VName) VName)
    -> m SrcLoc -> m (TypeExp (ExpBase Info VName) VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    tv (TEUnique TypeExp (ExpBase Info VName) VName
    t SrcLoc
    loc) =
        TypeExp (ExpBase Info VName) VName
    -> SrcLoc -> TypeExp (ExpBase Info VName) VName
    forall d vn. TypeExp d vn -> SrcLoc -> TypeExp d vn
    TEUnique (TypeExp (ExpBase Info VName) VName
     -> SrcLoc -> TypeExp (ExpBase Info VName) VName)
    -> m (TypeExp (ExpBase Info VName) VName)
    -> m (SrcLoc -> TypeExp (ExpBase Info VName) VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m
    -> TypeExp (ExpBase Info VName) VName
    -> m (TypeExp (ExpBase Info VName) VName)
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> TypeExp (ExpBase Info VName) VName
    -> m (TypeExp (ExpBase Info VName) VName)
    astMap ASTMapper m
    tv TypeExp (ExpBase Info VName) VName
    t m (SrcLoc -> TypeExp (ExpBase Info VName) VName)
    -> m SrcLoc -> m (TypeExp (ExpBase Info VName) VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    tv (TEApply TypeExp (ExpBase Info VName) VName
    t1 TypeArgExp (ExpBase Info VName) VName
    t2 SrcLoc
    loc) =
        TypeExp (ExpBase Info VName) VName
    -> TypeArgExp (ExpBase Info VName) VName
    -> SrcLoc
    -> TypeExp (ExpBase Info VName) VName
    forall d vn.
    TypeExp d vn -> TypeArgExp d vn -> SrcLoc -> TypeExp d vn
    TEApply (TypeExp (ExpBase Info VName) VName
     -> TypeArgExp (ExpBase Info VName) VName
     -> SrcLoc
     -> TypeExp (ExpBase Info VName) VName)
    -> m (TypeExp (ExpBase Info VName) VName)
    -> m (TypeArgExp (ExpBase Info VName) VName
          -> SrcLoc -> TypeExp (ExpBase Info VName) VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m
    -> TypeExp (ExpBase Info VName) VName
    -> m (TypeExp (ExpBase Info VName) VName)
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> TypeExp (ExpBase Info VName) VName
    -> m (TypeExp (ExpBase Info VName) VName)
    astMap ASTMapper m
    tv TypeExp (ExpBase Info VName) VName
    t1 m (TypeArgExp (ExpBase Info VName) VName
       -> SrcLoc -> TypeExp (ExpBase Info VName) VName)
    -> m (TypeArgExp (ExpBase Info VName) VName)
    -> m (SrcLoc -> TypeExp (ExpBase Info VName) VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ASTMapper m
    -> TypeArgExp (ExpBase Info VName) VName
    -> m (TypeArgExp (ExpBase Info VName) VName)
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> TypeArgExp (ExpBase Info VName) VName
    -> m (TypeArgExp (ExpBase Info VName) VName)
    astMap ASTMapper m
    tv TypeArgExp (ExpBase Info VName) VName
    t2 m (SrcLoc -> TypeExp (ExpBase Info VName) VName)
    -> m SrcLoc -> m (TypeExp (ExpBase Info VName) VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    tv (TEArrow Maybe VName
    v TypeExp (ExpBase Info VName) VName
    t1 TypeExp (ExpBase Info VName) VName
    t2 SrcLoc
    loc) =
        Maybe VName
    -> TypeExp (ExpBase Info VName) VName
    -> TypeExp (ExpBase Info VName) VName
    -> SrcLoc
    -> TypeExp (ExpBase Info VName) VName
    forall d vn.
    Maybe vn -> TypeExp d vn -> TypeExp d vn -> SrcLoc -> TypeExp d vn
    TEArrow Maybe VName
    v (TypeExp (ExpBase Info VName) VName
     -> TypeExp (ExpBase Info VName) VName
     -> SrcLoc
     -> TypeExp (ExpBase Info VName) VName)
    -> m (TypeExp (ExpBase Info VName) VName)
    -> m (TypeExp (ExpBase Info VName) VName
          -> SrcLoc -> TypeExp (ExpBase Info VName) VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m
    -> TypeExp (ExpBase Info VName) VName
    -> m (TypeExp (ExpBase Info VName) VName)
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> TypeExp (ExpBase Info VName) VName
    -> m (TypeExp (ExpBase Info VName) VName)
    astMap ASTMapper m
    tv TypeExp (ExpBase Info VName) VName
    t1 m (TypeExp (ExpBase Info VName) VName
       -> SrcLoc -> TypeExp (ExpBase Info VName) VName)
    -> m (TypeExp (ExpBase Info VName) VName)
    -> m (SrcLoc -> TypeExp (ExpBase Info VName) VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ASTMapper m
    -> TypeExp (ExpBase Info VName) VName
    -> m (TypeExp (ExpBase Info VName) VName)
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> TypeExp (ExpBase Info VName) VName
    -> m (TypeExp (ExpBase Info VName) VName)
    astMap ASTMapper m
    tv TypeExp (ExpBase Info VName) VName
    t2 m (SrcLoc -> TypeExp (ExpBase Info VName) VName)
    -> m SrcLoc -> m (TypeExp (ExpBase Info VName) VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    tv (TESum [(Name, [TypeExp (ExpBase Info VName) VName])]
    cs SrcLoc
    loc) =
        [(Name, [TypeExp (ExpBase Info VName) VName])]
    -> SrcLoc -> TypeExp (ExpBase Info VName) VName
    forall d vn. [(Name, [TypeExp d vn])] -> SrcLoc -> TypeExp d vn
    TESum ([(Name, [TypeExp (ExpBase Info VName) VName])]
     -> SrcLoc -> TypeExp (ExpBase Info VName) VName)
    -> m [(Name, [TypeExp (ExpBase Info VName) VName])]
    -> m (SrcLoc -> TypeExp (ExpBase Info VName) VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ((Name, [TypeExp (ExpBase Info VName) VName])
     -> m (Name, [TypeExp (ExpBase Info VName) VName]))
    -> [(Name, [TypeExp (ExpBase Info VName) VName])]
    -> m [(Name, [TypeExp (ExpBase Info VName) VName])]
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> [a] -> f [b]
    traverse (([TypeExp (ExpBase Info VName) VName]
     -> m [TypeExp (ExpBase Info VName) VName])
    -> (Name, [TypeExp (ExpBase Info VName) VName])
    -> m (Name, [TypeExp (ExpBase Info VName) VName])
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> (Name, a) -> f (Name, b)
    traverse (([TypeExp (ExpBase Info VName) VName]
      -> m [TypeExp (ExpBase Info VName) VName])
     -> (Name, [TypeExp (ExpBase Info VName) VName])
     -> m (Name, [TypeExp (ExpBase Info VName) VName]))
    -> ([TypeExp (ExpBase Info VName) VName]
        -> m [TypeExp (ExpBase Info VName) VName])
    -> (Name, [TypeExp (ExpBase Info VName) VName])
    -> m (Name, [TypeExp (ExpBase Info VName) VName])
    forall a b. (a -> b) -> a -> b
    $ ASTMapper m
    -> [TypeExp (ExpBase Info VName) VName]
    -> m [TypeExp (ExpBase Info VName) VName]
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> [TypeExp (ExpBase Info VName) VName]
    -> m [TypeExp (ExpBase Info VName) VName]
    astMap ASTMapper m
    tv) [(Name, [TypeExp (ExpBase Info VName) VName])]
    cs m (SrcLoc -> TypeExp (ExpBase Info VName) VName)
    -> m SrcLoc -> m (TypeExp (ExpBase Info VName) VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    tv (TEDim [VName]
    dims TypeExp (ExpBase Info VName) VName
    t SrcLoc
    loc) =
        [VName]
    -> TypeExp (ExpBase Info VName) VName
    -> SrcLoc
    -> TypeExp (ExpBase Info VName) VName
    forall d vn. [vn] -> TypeExp d vn -> SrcLoc -> TypeExp d vn
    TEDim [VName]
    dims (TypeExp (ExpBase Info VName) VName
     -> SrcLoc -> TypeExp (ExpBase Info VName) VName)
    -> m (TypeExp (ExpBase Info VName) VName)
    -> m (SrcLoc -> TypeExp (ExpBase Info VName) VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m
    -> TypeExp (ExpBase Info VName) VName
    -> m (TypeExp (ExpBase Info VName) VName)
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> TypeExp (ExpBase Info VName) VName
    -> m (TypeExp (ExpBase Info VName) VName)
    astMap ASTMapper m
    tv TypeExp (ExpBase Info VName) VName
    t m (SrcLoc -> TypeExp (ExpBase Info VName) VName)
    -> m SrcLoc -> m (TypeExp (ExpBase Info VName) VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc

    instance ASTMappable (TypeArgExp (ExpBase Info VName) VName) where
      astMap :: forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> TypeArgExp (ExpBase Info VName) VName
    -> m (TypeArgExp (ExpBase Info VName) VName)
    astMap ASTMapper m
    tv (TypeArgExpSize SizeExp (ExpBase Info VName)
    dim) = SizeExp (ExpBase Info VName)
    -> TypeArgExp (ExpBase Info VName) VName
    forall d vn. SizeExp d -> TypeArgExp d vn
    TypeArgExpSize (SizeExp (ExpBase Info VName)
     -> TypeArgExp (ExpBase Info VName) VName)
    -> m (SizeExp (ExpBase Info VName))
    -> m (TypeArgExp (ExpBase Info VName) VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m
    -> SizeExp (ExpBase Info VName) -> m (SizeExp (ExpBase Info VName))
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> SizeExp (ExpBase Info VName) -> m (SizeExp (ExpBase Info VName))
    astMap ASTMapper m
    tv SizeExp (ExpBase Info VName)
    dim
      astMap ASTMapper m
    tv (TypeArgExpType TypeExp (ExpBase Info VName) VName
    te) = TypeExp (ExpBase Info VName) VName
    -> TypeArgExp (ExpBase Info VName) VName
    forall d vn. TypeExp d vn -> TypeArgExp d vn
    TypeArgExpType (TypeExp (ExpBase Info VName) VName
     -> TypeArgExp (ExpBase Info VName) VName)
    -> m (TypeExp (ExpBase Info VName) VName)
    -> m (TypeArgExp (ExpBase Info VName) VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m
    -> TypeExp (ExpBase Info VName) VName
    -> m (TypeExp (ExpBase Info VName) VName)
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> TypeExp (ExpBase Info VName) VName
    -> m (TypeExp (ExpBase Info VName) VName)
    astMap ASTMapper m
    tv TypeExp (ExpBase Info VName) VName
    te

    instance ASTMappable (SizeExp (ExpBase Info VName)) where
      astMap :: forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> SizeExp (ExpBase Info VName) -> m (SizeExp (ExpBase Info VName))
    astMap ASTMapper m
    tv (SizeExp ExpBase Info VName
    e SrcLoc
    loc) = ExpBase Info VName -> SrcLoc -> SizeExp (ExpBase Info VName)
    forall d. d -> SrcLoc -> SizeExp d
    SizeExp (ExpBase Info VName -> SrcLoc -> SizeExp (ExpBase Info VName))
    -> m (ExpBase Info VName)
    -> m (SrcLoc -> SizeExp (ExpBase Info VName))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv ExpBase Info VName
    e m (SrcLoc -> SizeExp (ExpBase Info VName))
    -> m SrcLoc -> m (SizeExp (ExpBase Info VName))
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    _ (SizeExpAny SrcLoc
    loc) = SizeExp (ExpBase Info VName) -> m (SizeExp (ExpBase Info VName))
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (SizeExp (ExpBase Info VName) -> m (SizeExp (ExpBase Info VName)))
    -> SizeExp (ExpBase Info VName) -> m (SizeExp (ExpBase Info VName))
    forall a b. (a -> b) -> a -> b
    $ SrcLoc -> SizeExp (ExpBase Info VName)
    forall d. SrcLoc -> SizeExp d
    SizeExpAny SrcLoc
    loc

    instance ASTMappable (DimIndexBase Info VName) where
      astMap :: forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> DimIndexBase Info VName -> m (DimIndexBase Info VName)
    astMap ASTMapper m
    tv (DimFix ExpBase Info VName
    j) = ExpBase Info VName -> DimIndexBase Info VName
    forall (f :: * -> *) vn. ExpBase f vn -> DimIndexBase f vn
    DimFix (ExpBase Info VName -> DimIndexBase Info VName)
    -> m (ExpBase Info VName) -> m (DimIndexBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv ExpBase Info VName
    j
      astMap ASTMapper m
    tv (DimSlice Maybe (ExpBase Info VName)
    i Maybe (ExpBase Info VName)
    j Maybe (ExpBase Info VName)
    stride) =
        Maybe (ExpBase Info VName)
    -> Maybe (ExpBase Info VName)
    -> Maybe (ExpBase Info VName)
    -> DimIndexBase Info VName
    forall (f :: * -> *) vn.
    Maybe (ExpBase f vn)
    -> Maybe (ExpBase f vn)
    -> Maybe (ExpBase f vn)
    -> DimIndexBase f vn
    DimSlice
          (Maybe (ExpBase Info VName)
     -> Maybe (ExpBase Info VName)
     -> Maybe (ExpBase Info VName)
     -> DimIndexBase Info VName)
    -> m (Maybe (ExpBase Info VName))
    -> m (Maybe (ExpBase Info VName)
          -> Maybe (ExpBase Info VName) -> DimIndexBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> m (Maybe (ExpBase Info VName))
    -> (ExpBase Info VName -> m (Maybe (ExpBase Info VName)))
    -> Maybe (ExpBase Info VName)
    -> m (Maybe (ExpBase Info VName))
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe (Maybe (ExpBase Info VName) -> m (Maybe (ExpBase Info VName))
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Maybe (ExpBase Info VName)
    forall a. Maybe a
    Nothing) ((ExpBase Info VName -> Maybe (ExpBase Info VName))
    -> m (ExpBase Info VName) -> m (Maybe (ExpBase Info VName))
    forall a b. (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap ExpBase Info VName -> Maybe (ExpBase Info VName)
    forall a. a -> Maybe a
    Just (m (ExpBase Info VName) -> m (Maybe (ExpBase Info VName)))
    -> (ExpBase Info VName -> m (ExpBase Info VName))
    -> ExpBase Info VName
    -> m (Maybe (ExpBase Info VName))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv) Maybe (ExpBase Info VName)
    i
          m (Maybe (ExpBase Info VName)
       -> Maybe (ExpBase Info VName) -> DimIndexBase Info VName)
    -> m (Maybe (ExpBase Info VName))
    -> m (Maybe (ExpBase Info VName) -> DimIndexBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> m (Maybe (ExpBase Info VName))
    -> (ExpBase Info VName -> m (Maybe (ExpBase Info VName)))
    -> Maybe (ExpBase Info VName)
    -> m (Maybe (ExpBase Info VName))
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe (Maybe (ExpBase Info VName) -> m (Maybe (ExpBase Info VName))
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Maybe (ExpBase Info VName)
    forall a. Maybe a
    Nothing) ((ExpBase Info VName -> Maybe (ExpBase Info VName))
    -> m (ExpBase Info VName) -> m (Maybe (ExpBase Info VName))
    forall a b. (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap ExpBase Info VName -> Maybe (ExpBase Info VName)
    forall a. a -> Maybe a
    Just (m (ExpBase Info VName) -> m (Maybe (ExpBase Info VName)))
    -> (ExpBase Info VName -> m (ExpBase Info VName))
    -> ExpBase Info VName
    -> m (Maybe (ExpBase Info VName))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv) Maybe (ExpBase Info VName)
    j
          m (Maybe (ExpBase Info VName) -> DimIndexBase Info VName)
    -> m (Maybe (ExpBase Info VName)) -> m (DimIndexBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> m (Maybe (ExpBase Info VName))
    -> (ExpBase Info VName -> m (Maybe (ExpBase Info VName)))
    -> Maybe (ExpBase Info VName)
    -> m (Maybe (ExpBase Info VName))
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe (Maybe (ExpBase Info VName) -> m (Maybe (ExpBase Info VName))
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Maybe (ExpBase Info VName)
    forall a. Maybe a
    Nothing) ((ExpBase Info VName -> Maybe (ExpBase Info VName))
    -> m (ExpBase Info VName) -> m (Maybe (ExpBase Info VName))
    forall a b. (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap ExpBase Info VName -> Maybe (ExpBase Info VName)
    forall a. a -> Maybe a
    Just (m (ExpBase Info VName) -> m (Maybe (ExpBase Info VName)))
    -> (ExpBase Info VName -> m (ExpBase Info VName))
    -> ExpBase Info VName
    -> m (Maybe (ExpBase Info VName))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv) Maybe (ExpBase Info VName)
    stride

    instance ASTMappable AppRes where
      astMap :: forall (m :: * -> *). Monad m => ASTMapper m -> AppRes -> m AppRes
    astMap ASTMapper m
    tv (AppRes StructType
    t [VName]
    ext) =
        StructType -> [VName] -> AppRes
    AppRes (StructType -> [VName] -> AppRes)
    -> m StructType -> m ([VName] -> AppRes)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m -> StructType -> m StructType
    forall (m :: * -> *). ASTMapper m -> StructType -> m StructType
    mapOnStructType ASTMapper m
    tv StructType
    t m ([VName] -> AppRes) -> m [VName] -> m AppRes
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> [VName] -> m [VName]
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure [VName]
    ext

    type TypeTraverser f t dim1 als1 dim2 als2 =
      (QualName VName -> f (QualName VName)) ->
      (dim1 -> f dim2) ->
      (als1 -> f als2) ->
      t dim1 als1 ->
      f (t dim2 als2)

    traverseScalarType ::
      (Applicative f) =>
      TypeTraverser f ScalarTypeBase dim1 als1 dims als2
    traverseScalarType :: forall (f :: * -> *) dim1 als1 dims als2.
    Applicative f =>
    TypeTraverser f ScalarTypeBase dim1 als1 dims als2
    traverseScalarType QualName VName -> f (QualName VName)
    _ dim1 -> f dims
    _ als1 -> f als2
    _ (Prim PrimType
    t) = ScalarTypeBase dims als2 -> f (ScalarTypeBase dims als2)
    forall a. a -> f a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (ScalarTypeBase dims als2 -> f (ScalarTypeBase dims als2))
    -> ScalarTypeBase dims als2 -> f (ScalarTypeBase dims als2)
    forall a b. (a -> b) -> a -> b
    $ PrimType -> ScalarTypeBase dims als2
    forall dim u. PrimType -> ScalarTypeBase dim u
    Prim PrimType
    t
    traverseScalarType QualName VName -> f (QualName VName)
    f dim1 -> f dims
    g als1 -> f als2
    h (Record Map Name (TypeBase dim1 als1)
    fs) = Map Name (TypeBase dims als2) -> ScalarTypeBase dims als2
    forall dim u. Map Name (TypeBase dim u) -> ScalarTypeBase dim u
    Record (Map Name (TypeBase dims als2) -> ScalarTypeBase dims als2)
    -> f (Map Name (TypeBase dims als2))
    -> f (ScalarTypeBase dims als2)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (TypeBase dim1 als1 -> f (TypeBase dims als2))
    -> Map Name (TypeBase dim1 als1)
    -> f (Map Name (TypeBase dims als2))
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Map Name a -> f (Map Name b)
    traverse (TypeTraverser f TypeBase dim1 als1 dims als2
    forall (f :: * -> *) dim1 als1 dims als2.
    Applicative f =>
    TypeTraverser f TypeBase dim1 als1 dims als2
    traverseType QualName VName -> f (QualName VName)
    f dim1 -> f dims
    g als1 -> f als2
    h) Map Name (TypeBase dim1 als1)
    fs
    traverseScalarType QualName VName -> f (QualName VName)
    f dim1 -> f dims
    g als1 -> f als2
    h (TypeVar als1
    als QualName VName
    t [TypeArg dim1]
    args) =
      als2
    -> QualName VName -> [TypeArg dims] -> ScalarTypeBase dims als2
    forall dim u.
    u -> QualName VName -> [TypeArg dim] -> ScalarTypeBase dim u
    TypeVar (als2
     -> QualName VName -> [TypeArg dims] -> ScalarTypeBase dims als2)
    -> f als2
    -> f (QualName VName -> [TypeArg dims] -> ScalarTypeBase dims als2)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> als1 -> f als2
    h als1
    als f (QualName VName -> [TypeArg dims] -> ScalarTypeBase dims als2)
    -> f (QualName VName)
    -> f ([TypeArg dims] -> ScalarTypeBase dims als2)
    forall a b. f (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> QualName VName -> f (QualName VName)
    f QualName VName
    t f ([TypeArg dims] -> ScalarTypeBase dims als2)
    -> f [TypeArg dims] -> f (ScalarTypeBase dims als2)
    forall a b. f (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (TypeArg dim1 -> f (TypeArg dims))
    -> [TypeArg dim1] -> f [TypeArg dims]
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> [a] -> f [b]
    traverse ((QualName VName -> f (QualName VName))
    -> (dim1 -> f dims) -> TypeArg dim1 -> f (TypeArg dims)
    forall (f :: * -> *) dim1 dim2.
    Applicative f =>
    (QualName VName -> f (QualName VName))
    -> (dim1 -> f dim2) -> TypeArg dim1 -> f (TypeArg dim2)
    traverseTypeArg QualName VName -> f (QualName VName)
    f dim1 -> f dims
    g) [TypeArg dim1]
    args
    traverseScalarType QualName VName -> f (QualName VName)
    f dim1 -> f dims
    g als1 -> f als2
    h (Arrow als1
    als PName
    v Diet
    u TypeBase dim1 NoUniqueness
    t1 (RetType [VName]
    dims TypeBase dim1 Uniqueness
    t2)) =
      als2
    -> PName
    -> Diet
    -> TypeBase dims NoUniqueness
    -> RetTypeBase dims Uniqueness
    -> ScalarTypeBase dims als2
    forall dim u.
    u
    -> PName
    -> Diet
    -> TypeBase dim NoUniqueness
    -> RetTypeBase dim Uniqueness
    -> ScalarTypeBase dim u
    Arrow
        (als2
     -> PName
     -> Diet
     -> TypeBase dims NoUniqueness
     -> RetTypeBase dims Uniqueness
     -> ScalarTypeBase dims als2)
    -> f als2
    -> f (PName
          -> Diet
          -> TypeBase dims NoUniqueness
          -> RetTypeBase dims Uniqueness
          -> ScalarTypeBase dims als2)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> als1 -> f als2
    h als1
    als
        f (PName
       -> Diet
       -> TypeBase dims NoUniqueness
       -> RetTypeBase dims Uniqueness
       -> ScalarTypeBase dims als2)
    -> f PName
    -> f (Diet
          -> TypeBase dims NoUniqueness
          -> RetTypeBase dims Uniqueness
          -> ScalarTypeBase dims als2)
    forall a b. f (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> PName -> f PName
    forall a. a -> f a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure PName
    v
        f (Diet
       -> TypeBase dims NoUniqueness
       -> RetTypeBase dims Uniqueness
       -> ScalarTypeBase dims als2)
    -> f Diet
    -> f (TypeBase dims NoUniqueness
          -> RetTypeBase dims Uniqueness -> ScalarTypeBase dims als2)
    forall a b. f (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Diet -> f Diet
    forall a. a -> f a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Diet
    u
        f (TypeBase dims NoUniqueness
       -> RetTypeBase dims Uniqueness -> ScalarTypeBase dims als2)
    -> f (TypeBase dims NoUniqueness)
    -> f (RetTypeBase dims Uniqueness -> ScalarTypeBase dims als2)
    forall a b. f (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> TypeTraverser f TypeBase dim1 NoUniqueness dims NoUniqueness
    forall (f :: * -> *) dim1 als1 dims als2.
    Applicative f =>
    TypeTraverser f TypeBase dim1 als1 dims als2
    traverseType QualName VName -> f (QualName VName)
    f dim1 -> f dims
    g NoUniqueness -> f NoUniqueness
    forall a. a -> f a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure TypeBase dim1 NoUniqueness
    t1
        f (RetTypeBase dims Uniqueness -> ScalarTypeBase dims als2)
    -> f (RetTypeBase dims Uniqueness) -> f (ScalarTypeBase dims als2)
    forall a b. f (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ([VName] -> TypeBase dims Uniqueness -> RetTypeBase dims Uniqueness
    forall dim as. [VName] -> TypeBase dim as -> RetTypeBase dim as
    RetType [VName]
    dims (TypeBase dims Uniqueness -> RetTypeBase dims Uniqueness)
    -> f (TypeBase dims Uniqueness) -> f (RetTypeBase dims Uniqueness)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> TypeTraverser f TypeBase dim1 Uniqueness dims Uniqueness
    forall (f :: * -> *) dim1 als1 dims als2.
    Applicative f =>
    TypeTraverser f TypeBase dim1 als1 dims als2
    traverseType QualName VName -> f (QualName VName)
    f dim1 -> f dims
    g Uniqueness -> f Uniqueness
    forall a. a -> f a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure TypeBase dim1 Uniqueness
    t2)
    traverseScalarType QualName VName -> f (QualName VName)
    f dim1 -> f dims
    g als1 -> f als2
    h (Sum Map Name [TypeBase dim1 als1]
    cs) =
      Map Name [TypeBase dims als2] -> ScalarTypeBase dims als2
    forall dim u. Map Name [TypeBase dim u] -> ScalarTypeBase dim u
    Sum (Map Name [TypeBase dims als2] -> ScalarTypeBase dims als2)
    -> f (Map Name [TypeBase dims als2])
    -> f (ScalarTypeBase dims als2)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (([TypeBase dim1 als1] -> f [TypeBase dims als2])
    -> Map Name [TypeBase dim1 als1]
    -> f (Map Name [TypeBase dims als2])
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Map Name a -> f (Map Name b)
    traverse (([TypeBase dim1 als1] -> f [TypeBase dims als2])
     -> Map Name [TypeBase dim1 als1]
     -> f (Map Name [TypeBase dims als2]))
    -> ((TypeBase dim1 als1 -> f (TypeBase dims als2))
        -> [TypeBase dim1 als1] -> f [TypeBase dims als2])
    -> (TypeBase dim1 als1 -> f (TypeBase dims als2))
    -> Map Name [TypeBase dim1 als1]
    -> f (Map Name [TypeBase dims als2])
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (TypeBase dim1 als1 -> f (TypeBase dims als2))
    -> [TypeBase dim1 als1] -> f [TypeBase dims als2]
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> [a] -> f [b]
    traverse) (TypeTraverser f TypeBase dim1 als1 dims als2
    forall (f :: * -> *) dim1 als1 dims als2.
    Applicative f =>
    TypeTraverser f TypeBase dim1 als1 dims als2
    traverseType QualName VName -> f (QualName VName)
    f dim1 -> f dims
    g als1 -> f als2
    h) Map Name [TypeBase dim1 als1]
    cs

    traverseType :: (Applicative f) => TypeTraverser f TypeBase dim1 als1 dims als2
    traverseType :: forall (f :: * -> *) dim1 als1 dims als2.
    Applicative f =>
    TypeTraverser f TypeBase dim1 als1 dims als2
    traverseType QualName VName -> f (QualName VName)
    f dim1 -> f dims
    g als1 -> f als2
    h (Array als1
    als Shape dim1
    shape ScalarTypeBase dim1 NoUniqueness
    et) =
      als2
    -> Shape dims
    -> ScalarTypeBase dims NoUniqueness
    -> TypeBase dims als2
    forall dim u.
    u -> Shape dim -> ScalarTypeBase dim NoUniqueness -> TypeBase dim u
    Array (als2
     -> Shape dims
     -> ScalarTypeBase dims NoUniqueness
     -> TypeBase dims als2)
    -> f als2
    -> f (Shape dims
          -> ScalarTypeBase dims NoUniqueness -> TypeBase dims als2)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> als1 -> f als2
    h als1
    als f (Shape dims
       -> ScalarTypeBase dims NoUniqueness -> TypeBase dims als2)
    -> f (Shape dims)
    -> f (ScalarTypeBase dims NoUniqueness -> TypeBase dims als2)
    forall a b. f (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (dim1 -> f dims) -> Shape dim1 -> f (Shape dims)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Shape a -> f (Shape b)
    traverse dim1 -> f dims
    g Shape dim1
    shape f (ScalarTypeBase dims NoUniqueness -> TypeBase dims als2)
    -> f (ScalarTypeBase dims NoUniqueness) -> f (TypeBase dims als2)
    forall a b. f (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> TypeTraverser f ScalarTypeBase dim1 NoUniqueness dims NoUniqueness
    forall (f :: * -> *) dim1 als1 dims als2.
    Applicative f =>
    TypeTraverser f ScalarTypeBase dim1 als1 dims als2
    traverseScalarType QualName VName -> f (QualName VName)
    f dim1 -> f dims
    g NoUniqueness -> f NoUniqueness
    forall a. a -> f a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure ScalarTypeBase dim1 NoUniqueness
    et
    traverseType QualName VName -> f (QualName VName)
    f dim1 -> f dims
    g als1 -> f als2
    h (Scalar ScalarTypeBase dim1 als1
    t) =
      ScalarTypeBase dims als2 -> TypeBase dims als2
    forall dim u. ScalarTypeBase dim u -> TypeBase dim u
    Scalar (ScalarTypeBase dims als2 -> TypeBase dims als2)
    -> f (ScalarTypeBase dims als2) -> f (TypeBase dims als2)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> TypeTraverser f ScalarTypeBase dim1 als1 dims als2
    forall (f :: * -> *) dim1 als1 dims als2.
    Applicative f =>
    TypeTraverser f ScalarTypeBase dim1 als1 dims als2
    traverseScalarType QualName VName -> f (QualName VName)
    f dim1 -> f dims
    g als1 -> f als2
    h ScalarTypeBase dim1 als1
    t

    traverseTypeArg ::
      (Applicative f) =>
      (QualName VName -> f (QualName VName)) ->
      (dim1 -> f dim2) ->
      TypeArg dim1 ->
      f (TypeArg dim2)
    traverseTypeArg :: forall (f :: * -> *) dim1 dim2.
    Applicative f =>
    (QualName VName -> f (QualName VName))
    -> (dim1 -> f dim2) -> TypeArg dim1 -> f (TypeArg dim2)
    traverseTypeArg QualName VName -> f (QualName VName)
    _ dim1 -> f dim2
    g (TypeArgDim dim1
    d) =
      dim2 -> TypeArg dim2
    forall dim. dim -> TypeArg dim
    TypeArgDim (dim2 -> TypeArg dim2) -> f dim2 -> f (TypeArg dim2)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> dim1 -> f dim2
    g dim1
    d
    traverseTypeArg QualName VName -> f (QualName VName)
    f dim1 -> f dim2
    g (TypeArgType TypeBase dim1 NoUniqueness
    t) =
      TypeBase dim2 NoUniqueness -> TypeArg dim2
    forall dim. TypeBase dim NoUniqueness -> TypeArg dim
    TypeArgType (TypeBase dim2 NoUniqueness -> TypeArg dim2)
    -> f (TypeBase dim2 NoUniqueness) -> f (TypeArg dim2)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> TypeTraverser f TypeBase dim1 NoUniqueness dim2 NoUniqueness
    forall (f :: * -> *) dim1 als1 dims als2.
    Applicative f =>
    TypeTraverser f TypeBase dim1 als1 dims als2
    traverseType QualName VName -> f (QualName VName)
    f dim1 -> f dim2
    g NoUniqueness -> f NoUniqueness
    forall a. a -> f a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure TypeBase dim1 NoUniqueness
    t

    instance ASTMappable StructType where
      astMap :: forall (m :: * -> *).
    Monad m =>
    ASTMapper m -> StructType -> m StructType
    astMap ASTMapper m
    tv = TypeTraverser
      m
      TypeBase
      (ExpBase Info VName)
      NoUniqueness
      (ExpBase Info VName)
      NoUniqueness
    forall (f :: * -> *) dim1 als1 dims als2.
    Applicative f =>
    TypeTraverser f TypeBase dim1 als1 dims als2
    traverseType (ASTMapper m -> QualName VName -> m (QualName VName)
    forall (m :: * -> *).
    ASTMapper m -> QualName VName -> m (QualName VName)
    mapOnName ASTMapper m
    tv) (ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv) NoUniqueness -> m NoUniqueness
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure

    instance ASTMappable ParamType where
      astMap :: forall (m :: * -> *).
    Monad m =>
    ASTMapper m -> ParamType -> m ParamType
    astMap ASTMapper m
    tv = TypeTraverser
      m TypeBase (ExpBase Info VName) Diet (ExpBase Info VName) Diet
    forall (f :: * -> *) dim1 als1 dims als2.
    Applicative f =>
    TypeTraverser f TypeBase dim1 als1 dims als2
    traverseType (ASTMapper m -> QualName VName -> m (QualName VName)
    forall (m :: * -> *).
    ASTMapper m -> QualName VName -> m (QualName VName)
    mapOnName ASTMapper m
    tv) (ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv) Diet -> m Diet
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure

    instance ASTMappable (TypeBase Size Uniqueness) where
      astMap :: forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> TypeBase (ExpBase Info VName) Uniqueness
    -> m (TypeBase (ExpBase Info VName) Uniqueness)
    astMap ASTMapper m
    tv = TypeTraverser
      m
      TypeBase
      (ExpBase Info VName)
      Uniqueness
      (ExpBase Info VName)
      Uniqueness
    forall (f :: * -> *) dim1 als1 dims als2.
    Applicative f =>
    TypeTraverser f TypeBase dim1 als1 dims als2
    traverseType (ASTMapper m -> QualName VName -> m (QualName VName)
    forall (m :: * -> *).
    ASTMapper m -> QualName VName -> m (QualName VName)
    mapOnName ASTMapper m
    tv) (ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv) Uniqueness -> m Uniqueness
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure

    instance ASTMappable ResRetType where
      astMap :: forall (m :: * -> *).
    Monad m =>
    ASTMapper m -> ResRetType -> m ResRetType
    astMap ASTMapper m
    tv (RetType [VName]
    ext TypeBase (ExpBase Info VName) Uniqueness
    t) = [VName] -> TypeBase (ExpBase Info VName) Uniqueness -> ResRetType
    forall dim as. [VName] -> TypeBase dim as -> RetTypeBase dim as
    RetType [VName]
    ext (TypeBase (ExpBase Info VName) Uniqueness -> ResRetType)
    -> m (TypeBase (ExpBase Info VName) Uniqueness) -> m ResRetType
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m
    -> TypeBase (ExpBase Info VName) Uniqueness
    -> m (TypeBase (ExpBase Info VName) Uniqueness)
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> TypeBase (ExpBase Info VName) Uniqueness
    -> m (TypeBase (ExpBase Info VName) Uniqueness)
    astMap ASTMapper m
    tv TypeBase (ExpBase Info VName) Uniqueness
    t

    instance ASTMappable (IdentBase Info VName StructType) where
      astMap :: forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> IdentBase Info VName StructType
    -> m (IdentBase Info VName StructType)
    astMap ASTMapper m
    tv (Ident VName
    name (Info StructType
    t) SrcLoc
    loc) =
        VName
    -> Info StructType -> SrcLoc -> IdentBase Info VName StructType
    forall {k} (f :: k -> *) vn (t :: k).
    vn -> f t -> SrcLoc -> IdentBase f vn t
    Ident VName
    name (Info StructType -> SrcLoc -> IdentBase Info VName StructType)
    -> m (Info StructType)
    -> m (SrcLoc -> IdentBase Info VName StructType)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (StructType -> Info StructType
    forall a. a -> Info a
    Info (StructType -> Info StructType)
    -> m StructType -> m (Info StructType)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m -> StructType -> m StructType
    forall (m :: * -> *). ASTMapper m -> StructType -> m StructType
    mapOnStructType ASTMapper m
    tv StructType
    t) m (SrcLoc -> IdentBase Info VName StructType)
    -> m SrcLoc -> m (IdentBase Info VName StructType)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc

    traversePat ::
      (Monad m) =>
      (t1 -> m t2) ->
      (ExpBase Info VName -> m (ExpBase Info VName)) ->
      PatBase Info VName t1 ->
      m (PatBase Info VName t2)
    traversePat :: forall (m :: * -> *) t1 t2.
    Monad m =>
    (t1 -> m t2)
    -> (ExpBase Info VName -> m (ExpBase Info VName))
    -> PatBase Info VName t1
    -> m (PatBase Info VName t2)
    traversePat t1 -> m t2
    f ExpBase Info VName -> m (ExpBase Info VName)
    _ (Id VName
    name (Info t1
    t) SrcLoc
    loc) =
      VName -> Info t2 -> SrcLoc -> PatBase Info VName t2
    forall (f :: * -> *) vn t. vn -> f t -> SrcLoc -> PatBase f vn t
    Id VName
    name (Info t2 -> SrcLoc -> PatBase Info VName t2)
    -> m (Info t2) -> m (SrcLoc -> PatBase Info VName t2)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (t2 -> Info t2
    forall a. a -> Info a
    Info (t2 -> Info t2) -> m t2 -> m (Info t2)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> t1 -> m t2
    f t1
    t) m (SrcLoc -> PatBase Info VName t2)
    -> m SrcLoc -> m (PatBase Info VName t2)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
    traversePat t1 -> m t2
    f ExpBase Info VName -> m (ExpBase Info VName)
    g (TuplePat [PatBase Info VName t1]
    pats SrcLoc
    loc) =
      [PatBase Info VName t2] -> SrcLoc -> PatBase Info VName t2
    forall (f :: * -> *) vn t.
    [PatBase f vn t] -> SrcLoc -> PatBase f vn t
    TuplePat ([PatBase Info VName t2] -> SrcLoc -> PatBase Info VName t2)
    -> m [PatBase Info VName t2] -> m (SrcLoc -> PatBase Info VName t2)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (PatBase Info VName t1 -> m (PatBase Info VName t2))
    -> [PatBase Info VName t1] -> m [PatBase Info VName t2]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM ((t1 -> m t2)
    -> (ExpBase Info VName -> m (ExpBase Info VName))
    -> PatBase Info VName t1
    -> m (PatBase Info VName t2)
    forall (m :: * -> *) t1 t2.
    Monad m =>
    (t1 -> m t2)
    -> (ExpBase Info VName -> m (ExpBase Info VName))
    -> PatBase Info VName t1
    -> m (PatBase Info VName t2)
    traversePat t1 -> m t2
    f ExpBase Info VName -> m (ExpBase Info VName)
    g) [PatBase Info VName t1]
    pats m (SrcLoc -> PatBase Info VName t2)
    -> m SrcLoc -> m (PatBase Info VName t2)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
    traversePat t1 -> m t2
    f ExpBase Info VName -> m (ExpBase Info VName)
    g (RecordPat [(L Name, PatBase Info VName t1)]
    fields SrcLoc
    loc) =
      [(L Name, PatBase Info VName t2)]
    -> SrcLoc -> PatBase Info VName t2
    forall (f :: * -> *) vn t.
    [(L Name, PatBase f vn t)] -> SrcLoc -> PatBase f vn t
    RecordPat ([(L Name, PatBase Info VName t2)]
     -> SrcLoc -> PatBase Info VName t2)
    -> m [(L Name, PatBase Info VName t2)]
    -> m (SrcLoc -> PatBase Info VName t2)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ((L Name, PatBase Info VName t1)
     -> m (L Name, PatBase Info VName t2))
    -> [(L Name, PatBase Info VName t1)]
    -> m [(L Name, PatBase Info VName t2)]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM ((PatBase Info VName t1 -> m (PatBase Info VName t2))
    -> (L Name, PatBase Info VName t1)
    -> m (L Name, PatBase Info VName t2)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> (L Name, a) -> f (L Name, b)
    traverse ((PatBase Info VName t1 -> m (PatBase Info VName t2))
     -> (L Name, PatBase Info VName t1)
     -> m (L Name, PatBase Info VName t2))
    -> (PatBase Info VName t1 -> m (PatBase Info VName t2))
    -> (L Name, PatBase Info VName t1)
    -> m (L Name, PatBase Info VName t2)
    forall a b. (a -> b) -> a -> b
    $ (t1 -> m t2)
    -> (ExpBase Info VName -> m (ExpBase Info VName))
    -> PatBase Info VName t1
    -> m (PatBase Info VName t2)
    forall (m :: * -> *) t1 t2.
    Monad m =>
    (t1 -> m t2)
    -> (ExpBase Info VName -> m (ExpBase Info VName))
    -> PatBase Info VName t1
    -> m (PatBase Info VName t2)
    traversePat t1 -> m t2
    f ExpBase Info VName -> m (ExpBase Info VName)
    g) [(L Name, PatBase Info VName t1)]
    fields m (SrcLoc -> PatBase Info VName t2)
    -> m SrcLoc -> m (PatBase Info VName t2)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
    traversePat t1 -> m t2
    f ExpBase Info VName -> m (ExpBase Info VName)
    g (PatParens PatBase Info VName t1
    pat SrcLoc
    loc) =
      PatBase Info VName t2 -> SrcLoc -> PatBase Info VName t2
    forall (f :: * -> *) vn t.
    PatBase f vn t -> SrcLoc -> PatBase f vn t
    PatParens (PatBase Info VName t2 -> SrcLoc -> PatBase Info VName t2)
    -> m (PatBase Info VName t2) -> m (SrcLoc -> PatBase Info VName t2)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (t1 -> m t2)
    -> (ExpBase Info VName -> m (ExpBase Info VName))
    -> PatBase Info VName t1
    -> m (PatBase Info VName t2)
    forall (m :: * -> *) t1 t2.
    Monad m =>
    (t1 -> m t2)
    -> (ExpBase Info VName -> m (ExpBase Info VName))
    -> PatBase Info VName t1
    -> m (PatBase Info VName t2)
    traversePat t1 -> m t2
    f ExpBase Info VName -> m (ExpBase Info VName)
    g PatBase Info VName t1
    pat m (SrcLoc -> PatBase Info VName t2)
    -> m SrcLoc -> m (PatBase Info VName t2)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
    traversePat t1 -> m t2
    f ExpBase Info VName -> m (ExpBase Info VName)
    g (PatAscription PatBase Info VName t1
    pat TypeExp (ExpBase Info VName) VName
    t SrcLoc
    loc) =
      PatBase Info VName t2
    -> TypeExp (ExpBase Info VName) VName
    -> SrcLoc
    -> PatBase Info VName t2
    forall (f :: * -> *) vn t.
    PatBase f vn t
    -> TypeExp (ExpBase f vn) vn -> SrcLoc -> PatBase f vn t
    PatAscription (PatBase Info VName t2
     -> TypeExp (ExpBase Info VName) VName
     -> SrcLoc
     -> PatBase Info VName t2)
    -> m (PatBase Info VName t2)
    -> m (TypeExp (ExpBase Info VName) VName
          -> SrcLoc -> PatBase Info VName t2)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (t1 -> m t2)
    -> (ExpBase Info VName -> m (ExpBase Info VName))
    -> PatBase Info VName t1
    -> m (PatBase Info VName t2)
    forall (m :: * -> *) t1 t2.
    Monad m =>
    (t1 -> m t2)
    -> (ExpBase Info VName -> m (ExpBase Info VName))
    -> PatBase Info VName t1
    -> m (PatBase Info VName t2)
    traversePat t1 -> m t2
    f ExpBase Info VName -> m (ExpBase Info VName)
    g PatBase Info VName t1
    pat m (TypeExp (ExpBase Info VName) VName
       -> SrcLoc -> PatBase Info VName t2)
    -> m (TypeExp (ExpBase Info VName) VName)
    -> m (SrcLoc -> PatBase Info VName t2)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (ExpBase Info VName -> m (ExpBase Info VName))
    -> (VName -> m VName)
    -> TypeExp (ExpBase Info VName) VName
    -> m (TypeExp (ExpBase Info VName) VName)
    forall (f :: * -> *) a c b d.
    Applicative f =>
    (a -> f c) -> (b -> f d) -> TypeExp a b -> f (TypeExp c d)
    forall (t :: * -> * -> *) (f :: * -> *) a c b d.
    (Bitraversable t, Applicative f) =>
    (a -> f c) -> (b -> f d) -> t a b -> f (t c d)
    bitraverse ExpBase Info VName -> m (ExpBase Info VName)
    g VName -> m VName
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure TypeExp (ExpBase Info VName) VName
    t m (SrcLoc -> PatBase Info VName t2)
    -> m SrcLoc -> m (PatBase Info VName t2)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
    traversePat t1 -> m t2
    f ExpBase Info VName -> m (ExpBase Info VName)
    _ (Wildcard (Info t1
    t) SrcLoc
    loc) =
      Info t2 -> SrcLoc -> PatBase Info VName t2
    forall (f :: * -> *) vn t. f t -> SrcLoc -> PatBase f vn t
    Wildcard (Info t2 -> SrcLoc -> PatBase Info VName t2)
    -> m (Info t2) -> m (SrcLoc -> PatBase Info VName t2)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (t2 -> Info t2
    forall a. a -> Info a
    Info (t2 -> Info t2) -> m t2 -> m (Info t2)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> t1 -> m t2
    f t1
    t) m (SrcLoc -> PatBase Info VName t2)
    -> m SrcLoc -> m (PatBase Info VName t2)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
    traversePat t1 -> m t2
    f ExpBase Info VName -> m (ExpBase Info VName)
    _ (PatLit PatLit
    v (Info t1
    t) SrcLoc
    loc) =
      PatLit -> Info t2 -> SrcLoc -> PatBase Info VName t2
    forall (f :: * -> *) vn t.
    PatLit -> f t -> SrcLoc -> PatBase f vn t
    PatLit PatLit
    v (Info t2 -> SrcLoc -> PatBase Info VName t2)
    -> m (Info t2) -> m (SrcLoc -> PatBase Info VName t2)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (t2 -> Info t2
    forall a. a -> Info a
    Info (t2 -> Info t2) -> m t2 -> m (Info t2)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> t1 -> m t2
    f t1
    t) m (SrcLoc -> PatBase Info VName t2)
    -> m SrcLoc -> m (PatBase Info VName t2)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
    traversePat t1 -> m t2
    f ExpBase Info VName -> m (ExpBase Info VName)
    g (PatConstr Name
    n (Info t1
    t) [PatBase Info VName t1]
    ps SrcLoc
    loc) =
      Name
    -> Info t2
    -> [PatBase Info VName t2]
    -> SrcLoc
    -> PatBase Info VName t2
    forall (f :: * -> *) vn t.
    Name -> f t -> [PatBase f vn t] -> SrcLoc -> PatBase f vn t
    PatConstr Name
    n (Info t2
     -> [PatBase Info VName t2] -> SrcLoc -> PatBase Info VName t2)
    -> m (Info t2)
    -> m ([PatBase Info VName t2] -> SrcLoc -> PatBase Info VName t2)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (t2 -> Info t2
    forall a. a -> Info a
    Info (t2 -> Info t2) -> m t2 -> m (Info t2)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> t1 -> m t2
    f t1
    t) m ([PatBase Info VName t2] -> SrcLoc -> PatBase Info VName t2)
    -> m [PatBase Info VName t2] -> m (SrcLoc -> PatBase Info VName t2)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (PatBase Info VName t1 -> m (PatBase Info VName t2))
    -> [PatBase Info VName t1] -> m [PatBase Info VName t2]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM ((t1 -> m t2)
    -> (ExpBase Info VName -> m (ExpBase Info VName))
    -> PatBase Info VName t1
    -> m (PatBase Info VName t2)
    forall (m :: * -> *) t1 t2.
    Monad m =>
    (t1 -> m t2)
    -> (ExpBase Info VName -> m (ExpBase Info VName))
    -> PatBase Info VName t1
    -> m (PatBase Info VName t2)
    traversePat t1 -> m t2
    f ExpBase Info VName -> m (ExpBase Info VName)
    g) [PatBase Info VName t1]
    ps m (SrcLoc -> PatBase Info VName t2)
    -> m SrcLoc -> m (PatBase Info VName t2)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
    traversePat t1 -> m t2
    f ExpBase Info VName -> m (ExpBase Info VName)
    g (PatAttr AttrInfo VName
    attr PatBase Info VName t1
    p SrcLoc
    loc) =
      AttrInfo VName
    -> PatBase Info VName t2 -> SrcLoc -> PatBase Info VName t2
    forall (f :: * -> *) vn t.
    AttrInfo vn -> PatBase f vn t -> SrcLoc -> PatBase f vn t
    PatAttr AttrInfo VName
    attr (PatBase Info VName t2 -> SrcLoc -> PatBase Info VName t2)
    -> m (PatBase Info VName t2) -> m (SrcLoc -> PatBase Info VName t2)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (t1 -> m t2)
    -> (ExpBase Info VName -> m (ExpBase Info VName))
    -> PatBase Info VName t1
    -> m (PatBase Info VName t2)
    forall (m :: * -> *) t1 t2.
    Monad m =>
    (t1 -> m t2)
    -> (ExpBase Info VName -> m (ExpBase Info VName))
    -> PatBase Info VName t1
    -> m (PatBase Info VName t2)
    traversePat t1 -> m t2
    f ExpBase Info VName -> m (ExpBase Info VName)
    g PatBase Info VName t1
    p m (SrcLoc -> PatBase Info VName t2)
    -> m SrcLoc -> m (PatBase Info VName t2)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc

    instance ASTMappable (PatBase Info VName StructType) where
      astMap :: forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> PatBase Info VName StructType
    -> m (PatBase Info VName StructType)
    astMap ASTMapper m
    tv = (StructType -> m StructType)
    -> (ExpBase Info VName -> m (ExpBase Info VName))
    -> PatBase Info VName StructType
    -> m (PatBase Info VName StructType)
    forall (m :: * -> *) t1 t2.
    Monad m =>
    (t1 -> m t2)
    -> (ExpBase Info VName -> m (ExpBase Info VName))
    -> PatBase Info VName t1
    -> m (PatBase Info VName t2)
    traversePat (ASTMapper m -> StructType -> m StructType
    forall (m :: * -> *). ASTMapper m -> StructType -> m StructType
    mapOnStructType ASTMapper m
    tv) (ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv)

    instance ASTMappable (PatBase Info VName ParamType) where
      astMap :: forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> PatBase Info VName ParamType -> m (PatBase Info VName ParamType)
    astMap ASTMapper m
    tv = (ParamType -> m ParamType)
    -> (ExpBase Info VName -> m (ExpBase Info VName))
    -> PatBase Info VName ParamType
    -> m (PatBase Info VName ParamType)
    forall (m :: * -> *) t1 t2.
    Monad m =>
    (t1 -> m t2)
    -> (ExpBase Info VName -> m (ExpBase Info VName))
    -> PatBase Info VName t1
    -> m (PatBase Info VName t2)
    traversePat (ASTMapper m -> ParamType -> m ParamType
    forall (m :: * -> *). ASTMapper m -> ParamType -> m ParamType
    mapOnParamType ASTMapper m
    tv) (ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv)

    instance ASTMappable (FieldBase Info VName) where
      astMap :: forall (m :: * -> *).
    Monad m =>
    ASTMapper m -> FieldBase Info VName -> m (FieldBase Info VName)
    astMap ASTMapper m
    tv (RecordFieldExplicit L Name
    name ExpBase Info VName
    e SrcLoc
    loc) =
        L Name -> ExpBase Info VName -> SrcLoc -> FieldBase Info VName
    forall (f :: * -> *) vn.
    L Name -> ExpBase f vn -> SrcLoc -> FieldBase f vn
    RecordFieldExplicit L Name
    name (ExpBase Info VName -> SrcLoc -> FieldBase Info VName)
    -> m (ExpBase Info VName) -> m (SrcLoc -> FieldBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv ExpBase Info VName
    e m (SrcLoc -> FieldBase Info VName)
    -> m SrcLoc -> m (FieldBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc
      astMap ASTMapper m
    tv (RecordFieldImplicit (L Loc
    nameloc VName
    name) Info StructType
    t SrcLoc
    loc) =
        L VName -> Info StructType -> SrcLoc -> FieldBase Info VName
    forall (f :: * -> *) vn.
    L vn -> f StructType -> SrcLoc -> FieldBase f vn
    RecordFieldImplicit
          (L VName -> Info StructType -> SrcLoc -> FieldBase Info VName)
    -> m (L VName)
    -> m (Info StructType -> SrcLoc -> FieldBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Loc -> VName -> L VName
    forall a. Loc -> a -> L a
    L Loc
    nameloc (VName -> L VName) -> m VName -> m (L VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (QualName VName -> VName
    forall vn. QualName vn -> vn
    qualLeaf (QualName VName -> VName) -> m (QualName VName) -> m VName
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m -> QualName VName -> m (QualName VName)
    forall (m :: * -> *).
    ASTMapper m -> QualName VName -> m (QualName VName)
    mapOnName ASTMapper m
    tv ([VName] -> VName -> QualName VName
    forall vn. [vn] -> vn -> QualName vn
    QualName [] VName
    name)))
          m (Info StructType -> SrcLoc -> FieldBase Info VName)
    -> m (Info StructType) -> m (SrcLoc -> FieldBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (StructType -> m StructType)
    -> Info StructType -> m (Info StructType)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Info a -> f (Info b)
    traverse (ASTMapper m -> StructType -> m StructType
    forall (m :: * -> *). ASTMapper m -> StructType -> m StructType
    mapOnStructType ASTMapper m
    tv) Info StructType
    t
          m (SrcLoc -> FieldBase Info VName)
    -> m SrcLoc -> m (FieldBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc

    instance ASTMappable (CaseBase Info VName) where
      astMap :: forall (m :: * -> *).
    Monad m =>
    ASTMapper m -> CaseBase Info VName -> m (CaseBase Info VName)
    astMap ASTMapper m
    tv (CasePat PatBase Info VName StructType
    pat ExpBase Info VName
    e SrcLoc
    loc) =
        PatBase Info VName StructType
    -> ExpBase Info VName -> SrcLoc -> CaseBase Info VName
    forall (f :: * -> *) vn.
    PatBase f vn StructType -> ExpBase f vn -> SrcLoc -> CaseBase f vn
    CasePat (PatBase Info VName StructType
     -> ExpBase Info VName -> SrcLoc -> CaseBase Info VName)
    -> m (PatBase Info VName StructType)
    -> m (ExpBase Info VName -> SrcLoc -> CaseBase Info VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m
    -> PatBase Info VName StructType
    -> m (PatBase Info VName StructType)
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *).
    Monad m =>
    ASTMapper m
    -> PatBase Info VName StructType
    -> m (PatBase Info VName StructType)
    astMap ASTMapper m
    tv PatBase Info VName StructType
    pat m (ExpBase Info VName -> SrcLoc -> CaseBase Info VName)
    -> m (ExpBase Info VName) -> m (SrcLoc -> CaseBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    forall (m :: * -> *).
    ASTMapper m -> ExpBase Info VName -> m (ExpBase Info VName)
    mapOnExp ASTMapper m
    tv ExpBase Info VName
    e m (SrcLoc -> CaseBase Info VName)
    -> m SrcLoc -> m (CaseBase Info VName)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SrcLoc -> m SrcLoc
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure SrcLoc
    loc

    instance (ASTMappable a) => ASTMappable (Info a) where
      astMap :: forall (m :: * -> *).
    Monad m =>
    ASTMapper m -> Info a -> m (Info a)
    astMap ASTMapper m
    tv = (a -> m a) -> Info a -> m (Info a)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Info a -> f (Info b)
    traverse ((a -> m a) -> Info a -> m (Info a))
    -> (a -> m a) -> Info a -> m (Info a)
    forall a b. (a -> b) -> a -> b
    $ ASTMapper m -> a -> m a
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *). Monad m => ASTMapper m -> a -> m a
    astMap ASTMapper m
    tv

    instance (ASTMappable a) => ASTMappable [a] where
      astMap :: forall (m :: * -> *). Monad m => ASTMapper m -> [a] -> m [a]
    astMap ASTMapper m
    tv = (a -> m a) -> [a] -> m [a]
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> [a] -> f [b]
    traverse ((a -> m a) -> [a] -> m [a]) -> (a -> m a) -> [a] -> m [a]
    forall a b. (a -> b) -> a -> b
    $ ASTMapper m -> a -> m a
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *). Monad m => ASTMapper m -> a -> m a
    astMap ASTMapper m
    tv

    instance (ASTMappable a) => ASTMappable (NE.NonEmpty a) where
      astMap :: forall (m :: * -> *).
    Monad m =>
    ASTMapper m -> NonEmpty a -> m (NonEmpty a)
    astMap ASTMapper m
    tv = (a -> m a) -> NonEmpty a -> m (NonEmpty a)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> NonEmpty a -> f (NonEmpty b)
    traverse ((a -> m a) -> NonEmpty a -> m (NonEmpty a))
    -> (a -> m a) -> NonEmpty a -> m (NonEmpty a)
    forall a b. (a -> b) -> a -> b
    $ ASTMapper m -> a -> m a
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *). Monad m => ASTMapper m -> a -> m a
    astMap ASTMapper m
    tv

    instance (ASTMappable a, ASTMappable b) => ASTMappable (a, b) where
      astMap :: forall (m :: * -> *). Monad m => ASTMapper m -> (a, b) -> m (a, b)
    astMap ASTMapper m
    tv (a
    x, b
    y) = (,) (a -> b -> (a, b)) -> m a -> m (b -> (a, b))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m -> a -> m a
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *). Monad m => ASTMapper m -> a -> m a
    astMap ASTMapper m
    tv a
    x m (b -> (a, b)) -> m b -> m (a, b)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ASTMapper m -> b -> m b
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *). Monad m => ASTMapper m -> b -> m b
    astMap ASTMapper m
    tv b
    y

    instance (ASTMappable a, ASTMappable b, ASTMappable c) => ASTMappable (a, b, c) where
      astMap :: forall (m :: * -> *).
    Monad m =>
    ASTMapper m -> (a, b, c) -> m (a, b, c)
    astMap ASTMapper m
    tv (a
    x, b
    y, c
    z) = (,,) (a -> b -> c -> (a, b, c)) -> m a -> m (b -> c -> (a, b, c))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ASTMapper m -> a -> m a
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *). Monad m => ASTMapper m -> a -> m a
    astMap ASTMapper m
    tv a
    x m (b -> c -> (a, b, c)) -> m b -> m (c -> (a, b, c))
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ASTMapper m -> b -> m b
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *). Monad m => ASTMapper m -> b -> m b
    astMap ASTMapper m
    tv b
    y m (c -> (a, b, c)) -> m c -> m (a, b, c)
    forall a b. m (a -> b) -> m a -> m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ASTMapper m -> c -> m c
    forall x (m :: * -> *).
    (ASTMappable x, Monad m) =>
    ASTMapper m -> x -> m x
    forall (m :: * -> *). Monad m => ASTMapper m -> c -> m c
    astMap ASTMapper m
    tv c
    z

    -- It would be lovely if the following code would be written in terms
    -- of ASTMappable, but unfortunately it involves changing the Info
    -- functor.  For simplicity, the general traversals do not support
    -- that.  Sometimes a little duplication is better than an overly
    -- complex abstraction.  The types ensure that this will be correct
    -- anyway, so it's just tedious, and not actually fragile.

    bareField :: FieldBase Info VName -> FieldBase NoInfo VName
    bareField :: FieldBase Info VName -> FieldBase NoInfo VName
    bareField (RecordFieldExplicit L Name
    name ExpBase Info VName
    e SrcLoc
    loc) =
      L Name -> ExpBase NoInfo VName -> SrcLoc -> FieldBase NoInfo VName
    forall (f :: * -> *) vn.
    L Name -> ExpBase f vn -> SrcLoc -> FieldBase f vn
    RecordFieldExplicit L Name
    name (ExpBase Info VName -> ExpBase NoInfo VName
    bareExp ExpBase Info VName
    e) SrcLoc
    loc
    bareField (RecordFieldImplicit L VName
    name Info StructType
    _ SrcLoc
    loc) =
      L VName -> NoInfo StructType -> SrcLoc -> FieldBase NoInfo VName
    forall (f :: * -> *) vn.
    L vn -> f StructType -> SrcLoc -> FieldBase f vn
    RecordFieldImplicit L VName
    name NoInfo StructType
    forall {k} (a :: k). NoInfo a
    NoInfo SrcLoc
    loc

    barePat :: PatBase Info VName t -> PatBase NoInfo VName t
    barePat :: forall t. PatBase Info VName t -> PatBase NoInfo VName t
    barePat (TuplePat [PatBase Info VName t]
    ps SrcLoc
    loc) = [PatBase NoInfo VName t] -> SrcLoc -> PatBase NoInfo VName t
    forall (f :: * -> *) vn t.
    [PatBase f vn t] -> SrcLoc -> PatBase f vn t
    TuplePat ((PatBase Info VName t -> PatBase NoInfo VName t)
    -> [PatBase Info VName t] -> [PatBase NoInfo VName t]
    forall a b. (a -> b) -> [a] -> [b]
    map PatBase Info VName t -> PatBase NoInfo VName t
    forall t. PatBase Info VName t -> PatBase NoInfo VName t
    barePat [PatBase Info VName t]
    ps) SrcLoc
    loc
    barePat (RecordPat [(L Name, PatBase Info VName t)]
    fs SrcLoc
    loc) = [(L Name, PatBase NoInfo VName t)]
    -> SrcLoc -> PatBase NoInfo VName t
    forall (f :: * -> *) vn t.
    [(L Name, PatBase f vn t)] -> SrcLoc -> PatBase f vn t
    RecordPat (((L Name, PatBase Info VName t)
     -> (L Name, PatBase NoInfo VName t))
    -> [(L Name, PatBase Info VName t)]
    -> [(L Name, PatBase NoInfo VName t)]
    forall a b. (a -> b) -> [a] -> [b]
    map ((PatBase Info VName t -> PatBase NoInfo VName t)
    -> (L Name, PatBase Info VName t)
    -> (L Name, PatBase NoInfo VName t)
    forall a b. (a -> b) -> (L Name, a) -> (L Name, b)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap PatBase Info VName t -> PatBase NoInfo VName t
    forall t. PatBase Info VName t -> PatBase NoInfo VName t
    barePat) [(L Name, PatBase Info VName t)]
    fs) SrcLoc
    loc
    barePat (PatParens PatBase Info VName t
    p SrcLoc
    loc) = PatBase NoInfo VName t -> SrcLoc -> PatBase NoInfo VName t
    forall (f :: * -> *) vn t.
    PatBase f vn t -> SrcLoc -> PatBase f vn t
    PatParens (PatBase Info VName t -> PatBase NoInfo VName t
    forall t. PatBase Info VName t -> PatBase NoInfo VName t
    barePat PatBase Info VName t
    p) SrcLoc
    loc
    barePat (Id VName
    v Info t
    _ SrcLoc
    loc) = VName -> NoInfo t -> SrcLoc -> PatBase NoInfo VName t
    forall (f :: * -> *) vn t. vn -> f t -> SrcLoc -> PatBase f vn t
    Id VName
    v NoInfo t
    forall {k} (a :: k). NoInfo a
    NoInfo SrcLoc
    loc
    barePat (Wildcard Info t
    _ SrcLoc
    loc) = NoInfo t -> SrcLoc -> PatBase NoInfo VName t
    forall (f :: * -> *) vn t. f t -> SrcLoc -> PatBase f vn t
    Wildcard NoInfo t
    forall {k} (a :: k). NoInfo a
    NoInfo SrcLoc
    loc
    barePat (PatAscription PatBase Info VName t
    pat TypeExp (ExpBase Info VName) VName
    t SrcLoc
    loc) = PatBase NoInfo VName t
    -> TypeExp (ExpBase NoInfo VName) VName
    -> SrcLoc
    -> PatBase NoInfo VName t
    forall (f :: * -> *) vn t.
    PatBase f vn t
    -> TypeExp (ExpBase f vn) vn -> SrcLoc -> PatBase f vn t
    PatAscription (PatBase Info VName t -> PatBase NoInfo VName t
    forall t. PatBase Info VName t -> PatBase NoInfo VName t
    barePat PatBase Info VName t
    pat) (TypeExp (ExpBase Info VName) VName
    -> TypeExp (ExpBase NoInfo VName) VName
    bareTypeExp TypeExp (ExpBase Info VName) VName
    t) SrcLoc
    loc
    barePat (PatLit PatLit
    v Info t
    _ SrcLoc
    loc) = PatLit -> NoInfo t -> SrcLoc -> PatBase NoInfo VName t
    forall (f :: * -> *) vn t.
    PatLit -> f t -> SrcLoc -> PatBase f vn t
    PatLit PatLit
    v NoInfo t
    forall {k} (a :: k). NoInfo a
    NoInfo SrcLoc
    loc
    barePat (PatConstr Name
    c Info t
    _ [PatBase Info VName t]
    ps SrcLoc
    loc) = Name
    -> NoInfo t
    -> [PatBase NoInfo VName t]
    -> SrcLoc
    -> PatBase NoInfo VName t
    forall (f :: * -> *) vn t.
    Name -> f t -> [PatBase f vn t] -> SrcLoc -> PatBase f vn t
    PatConstr Name
    c NoInfo t
    forall {k} (a :: k). NoInfo a
    NoInfo ((PatBase Info VName t -> PatBase NoInfo VName t)
    -> [PatBase Info VName t] -> [PatBase NoInfo VName t]
    forall a b. (a -> b) -> [a] -> [b]
    map PatBase Info VName t -> PatBase NoInfo VName t
    forall t. PatBase Info VName t -> PatBase NoInfo VName t
    barePat [PatBase Info VName t]
    ps) SrcLoc
    loc
    barePat (PatAttr AttrInfo VName
    attr PatBase Info VName t
    p SrcLoc
    loc) = AttrInfo VName
    -> PatBase NoInfo VName t -> SrcLoc -> PatBase NoInfo VName t
    forall (f :: * -> *) vn t.
    AttrInfo vn -> PatBase f vn t -> SrcLoc -> PatBase f vn t
    PatAttr AttrInfo VName
    attr (PatBase Info VName t -> PatBase NoInfo VName t
    forall t. PatBase Info VName t -> PatBase NoInfo VName t
    barePat PatBase Info VName t
    p) SrcLoc
    loc

    bareDimIndex :: DimIndexBase Info VName -> DimIndexBase NoInfo VName
    bareDimIndex :: DimIndexBase Info VName -> DimIndexBase NoInfo VName
    bareDimIndex (DimFix ExpBase Info VName
    e) =
      ExpBase NoInfo VName -> DimIndexBase NoInfo VName
    forall (f :: * -> *) vn. ExpBase f vn -> DimIndexBase f vn
    DimFix (ExpBase NoInfo VName -> DimIndexBase NoInfo VName)
    -> ExpBase NoInfo VName -> DimIndexBase NoInfo VName
    forall a b. (a -> b) -> a -> b
    $ ExpBase Info VName -> ExpBase NoInfo VName
    bareExp ExpBase Info VName
    e
    bareDimIndex (DimSlice Maybe (ExpBase Info VName)
    x Maybe (ExpBase Info VName)
    y Maybe (ExpBase Info VName)
    z) =
      Maybe (ExpBase NoInfo VName)
    -> Maybe (ExpBase NoInfo VName)
    -> Maybe (ExpBase NoInfo VName)
    -> DimIndexBase NoInfo VName
    forall (f :: * -> *) vn.
    Maybe (ExpBase f vn)
    -> Maybe (ExpBase f vn)
    -> Maybe (ExpBase f vn)
    -> DimIndexBase f vn
    DimSlice (ExpBase Info VName -> ExpBase NoInfo VName
    bareExp (ExpBase Info VName -> ExpBase NoInfo VName)
    -> Maybe (ExpBase Info VName) -> Maybe (ExpBase NoInfo VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe (ExpBase Info VName)
    x) (ExpBase Info VName -> ExpBase NoInfo VName
    bareExp (ExpBase Info VName -> ExpBase NoInfo VName)
    -> Maybe (ExpBase Info VName) -> Maybe (ExpBase NoInfo VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe (ExpBase Info VName)
    y) (ExpBase Info VName -> ExpBase NoInfo VName
    bareExp (ExpBase Info VName -> ExpBase NoInfo VName)
    -> Maybe (ExpBase Info VName) -> Maybe (ExpBase NoInfo VName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe (ExpBase Info VName)
    z)

    bareLoopInit :: LoopInitBase Info VName -> LoopInitBase NoInfo VName
    bareLoopInit :: LoopInitBase Info VName -> LoopInitBase NoInfo VName
    bareLoopInit (LoopInitExplicit ExpBase Info VName
    e) = ExpBase NoInfo VName -> LoopInitBase NoInfo VName
    forall (f :: * -> *) vn. ExpBase f vn -> LoopInitBase f vn
    LoopInitExplicit (ExpBase NoInfo VName -> LoopInitBase NoInfo VName)
    -> ExpBase NoInfo VName -> LoopInitBase NoInfo VName
    forall a b. (a -> b) -> a -> b
    $ ExpBase Info VName -> ExpBase NoInfo VName
    bareExp ExpBase Info VName
    e
    bareLoopInit (LoopInitImplicit Info (ExpBase Info VName)
    _) = NoInfo (ExpBase NoInfo VName) -> LoopInitBase NoInfo VName
    forall (f :: * -> *) vn. f (ExpBase f vn) -> LoopInitBase f vn
    LoopInitImplicit NoInfo (ExpBase NoInfo VName)
    forall {k} (a :: k). NoInfo a
    NoInfo

    bareLoopForm :: LoopFormBase Info VName -> LoopFormBase NoInfo VName
    bareLoopForm :: LoopFormBase Info VName -> LoopFormBase NoInfo VName
    bareLoopForm (For (Ident VName
    i Info StructType
    _ SrcLoc
    loc) ExpBase Info VName
    e) = IdentBase NoInfo VName StructType
    -> ExpBase NoInfo VName -> LoopFormBase NoInfo VName
    forall (f :: * -> *) vn.
    IdentBase f vn StructType -> ExpBase f vn -> LoopFormBase f vn
    For (VName
    -> NoInfo StructType -> SrcLoc -> IdentBase NoInfo VName StructType
    forall {k} (f :: k -> *) vn (t :: k).
    vn -> f t -> SrcLoc -> IdentBase f vn t
    Ident VName
    i NoInfo StructType
    forall {k} (a :: k). NoInfo a
    NoInfo SrcLoc
    loc) (ExpBase Info VName -> ExpBase NoInfo VName
    bareExp ExpBase Info VName
    e)
    bareLoopForm (ForIn PatBase Info VName StructType
    pat ExpBase Info VName
    e) = PatBase NoInfo VName StructType
    -> ExpBase NoInfo VName -> LoopFormBase NoInfo VName
    forall (f :: * -> *) vn.
    PatBase f vn StructType -> ExpBase f vn -> LoopFormBase f vn
    ForIn (PatBase Info VName StructType -> PatBase NoInfo VName StructType
    forall t. PatBase Info VName t -> PatBase NoInfo VName t
    barePat PatBase Info VName StructType
    pat) (ExpBase Info VName -> ExpBase NoInfo VName
    bareExp ExpBase Info VName
    e)
    bareLoopForm (While ExpBase Info VName
    e) = ExpBase NoInfo VName -> LoopFormBase NoInfo VName
    forall (f :: * -> *) vn. ExpBase f vn -> LoopFormBase f vn
    While (ExpBase Info VName -> ExpBase NoInfo VName
    bareExp ExpBase Info VName
    e)

    bareCase :: CaseBase Info VName -> CaseBase NoInfo VName
    bareCase :: CaseBase Info VName -> CaseBase NoInfo VName
    bareCase (CasePat PatBase Info VName StructType
    pat ExpBase Info VName
    e SrcLoc
    loc) = PatBase NoInfo VName StructType
    -> ExpBase NoInfo VName -> SrcLoc -> CaseBase NoInfo VName
    forall (f :: * -> *) vn.
    PatBase f vn StructType -> ExpBase f vn -> SrcLoc -> CaseBase f vn
    CasePat (PatBase Info VName StructType -> PatBase NoInfo VName StructType
    forall t. PatBase Info VName t -> PatBase NoInfo VName t
    barePat PatBase Info VName StructType
    pat) (ExpBase Info VName -> ExpBase NoInfo VName
    bareExp ExpBase Info VName
    e) SrcLoc
    loc

    bareSizeExp :: SizeExp (ExpBase Info VName) -> SizeExp (ExpBase NoInfo VName)
    bareSizeExp :: SizeExp (ExpBase Info VName) -> SizeExp (ExpBase NoInfo VName)
    bareSizeExp (SizeExp ExpBase Info VName
    e SrcLoc
    loc) = ExpBase NoInfo VName -> SrcLoc -> SizeExp (ExpBase NoInfo VName)
    forall d. d -> SrcLoc -> SizeExp d
    SizeExp (ExpBase Info VName -> ExpBase NoInfo VName
    bareExp ExpBase Info VName
    e) SrcLoc
    loc
    bareSizeExp (SizeExpAny SrcLoc
    loc) = SrcLoc -> SizeExp (ExpBase NoInfo VName)
    forall d. SrcLoc -> SizeExp d
    SizeExpAny SrcLoc
    loc

    bareTypeExp :: TypeExp (ExpBase Info VName) VName -> TypeExp (ExpBase NoInfo VName) VName
    bareTypeExp :: TypeExp (ExpBase Info VName) VName
    -> TypeExp (ExpBase NoInfo VName) VName
    bareTypeExp (TEVar QualName VName
    qn SrcLoc
    loc) = QualName VName -> SrcLoc -> TypeExp (ExpBase NoInfo VName) VName
    forall d vn. QualName vn -> SrcLoc -> TypeExp d vn
    TEVar QualName VName
    qn SrcLoc
    loc
    bareTypeExp (TEParens TypeExp (ExpBase Info VName) VName
    te SrcLoc
    loc) = TypeExp (ExpBase NoInfo VName) VName
    -> SrcLoc -> TypeExp (ExpBase NoInfo VName) VName
    forall d vn. TypeExp d vn -> SrcLoc -> TypeExp d vn
    TEParens (TypeExp (ExpBase Info VName) VName
    -> TypeExp (ExpBase NoInfo VName) VName
    bareTypeExp TypeExp (ExpBase Info VName) VName
    te) SrcLoc
    loc
    bareTypeExp (TETuple [TypeExp (ExpBase Info VName) VName]
    tys SrcLoc
    loc) = [TypeExp (ExpBase NoInfo VName) VName]
    -> SrcLoc -> TypeExp (ExpBase NoInfo VName) VName
    forall d vn. [TypeExp d vn] -> SrcLoc -> TypeExp d vn
    TETuple ((TypeExp (ExpBase Info VName) VName
     -> TypeExp (ExpBase NoInfo VName) VName)
    -> [TypeExp (ExpBase Info VName) VName]
    -> [TypeExp (ExpBase NoInfo VName) VName]
    forall a b. (a -> b) -> [a] -> [b]
    map TypeExp (ExpBase Info VName) VName
    -> TypeExp (ExpBase NoInfo VName) VName
    bareTypeExp [TypeExp (ExpBase Info VName) VName]
    tys) SrcLoc
    loc
    bareTypeExp (TERecord [(L Name, TypeExp (ExpBase Info VName) VName)]
    fs SrcLoc
    loc) = [(L Name, TypeExp (ExpBase NoInfo VName) VName)]
    -> SrcLoc -> TypeExp (ExpBase NoInfo VName) VName
    forall d vn. [(L Name, TypeExp d vn)] -> SrcLoc -> TypeExp d vn
    TERecord (((L Name, TypeExp (ExpBase Info VName) VName)
     -> (L Name, TypeExp (ExpBase NoInfo VName) VName))
    -> [(L Name, TypeExp (ExpBase Info VName) VName)]
    -> [(L Name, TypeExp (ExpBase NoInfo VName) VName)]
    forall a b. (a -> b) -> [a] -> [b]
    map ((TypeExp (ExpBase Info VName) VName
     -> TypeExp (ExpBase NoInfo VName) VName)
    -> (L Name, TypeExp (ExpBase Info VName) VName)
    -> (L Name, TypeExp (ExpBase NoInfo VName) VName)
    forall b c a. (b -> c) -> (a, b) -> (a, c)
    forall (p :: * -> * -> *) b c a.
    Bifunctor p =>
    (b -> c) -> p a b -> p a c
    second TypeExp (ExpBase Info VName) VName
    -> TypeExp (ExpBase NoInfo VName) VName
    bareTypeExp) [(L Name, TypeExp (ExpBase Info VName) VName)]
    fs) SrcLoc
    loc
    bareTypeExp (TEArray SizeExp (ExpBase Info VName)
    size TypeExp (ExpBase Info VName) VName
    ty SrcLoc
    loc) = SizeExp (ExpBase NoInfo VName)
    -> TypeExp (ExpBase NoInfo VName) VName
    -> SrcLoc
    -> TypeExp (ExpBase NoInfo VName) VName
    forall d vn. SizeExp d -> TypeExp d vn -> SrcLoc -> TypeExp d vn
    TEArray (SizeExp (ExpBase Info VName) -> SizeExp (ExpBase NoInfo VName)
    bareSizeExp SizeExp (ExpBase Info VName)
    size) (TypeExp (ExpBase Info VName) VName
    -> TypeExp (ExpBase NoInfo VName) VName
    bareTypeExp TypeExp (ExpBase Info VName) VName
    ty) SrcLoc
    loc
    bareTypeExp (TEUnique TypeExp (ExpBase Info VName) VName
    ty SrcLoc
    loc) = TypeExp (ExpBase NoInfo VName) VName
    -> SrcLoc -> TypeExp (ExpBase NoInfo VName) VName
    forall d vn. TypeExp d vn -> SrcLoc -> TypeExp d vn
    TEUnique (TypeExp (ExpBase Info VName) VName
    -> TypeExp (ExpBase NoInfo VName) VName
    bareTypeExp TypeExp (ExpBase Info VName) VName
    ty) SrcLoc
    loc
    bareTypeExp (TEApply TypeExp (ExpBase Info VName) VName
    ty TypeArgExp (ExpBase Info VName) VName
    ta SrcLoc
    loc) = TypeExp (ExpBase NoInfo VName) VName
    -> TypeArgExp (ExpBase NoInfo VName) VName
    -> SrcLoc
    -> TypeExp (ExpBase NoInfo VName) VName
    forall d vn.
    TypeExp d vn -> TypeArgExp d vn -> SrcLoc -> TypeExp d vn
    TEApply (TypeExp (ExpBase Info VName) VName
    -> TypeExp (ExpBase NoInfo VName) VName
    bareTypeExp TypeExp (ExpBase Info VName) VName
    ty) (TypeArgExp (ExpBase Info VName) VName
    -> TypeArgExp (ExpBase NoInfo VName) VName
    bareTypeArgExp TypeArgExp (ExpBase Info VName) VName
    ta) SrcLoc
    loc
      where
        bareTypeArgExp :: TypeArgExp (ExpBase Info VName) VName
    -> TypeArgExp (ExpBase NoInfo VName) VName
    bareTypeArgExp (TypeArgExpSize SizeExp (ExpBase Info VName)
    size) =
          SizeExp (ExpBase NoInfo VName)
    -> TypeArgExp (ExpBase NoInfo VName) VName
    forall d vn. SizeExp d -> TypeArgExp d vn
    TypeArgExpSize (SizeExp (ExpBase NoInfo VName)
     -> TypeArgExp (ExpBase NoInfo VName) VName)
    -> SizeExp (ExpBase NoInfo VName)
    -> TypeArgExp (ExpBase NoInfo VName) VName
    forall a b. (a -> b) -> a -> b
    $ SizeExp (ExpBase Info VName) -> SizeExp (ExpBase NoInfo VName)
    bareSizeExp SizeExp (ExpBase Info VName)
    size
        bareTypeArgExp (TypeArgExpType TypeExp (ExpBase Info VName) VName
    tya) =
          TypeExp (ExpBase NoInfo VName) VName
    -> TypeArgExp (ExpBase NoInfo VName) VName
    forall d vn. TypeExp d vn -> TypeArgExp d vn
    TypeArgExpType (TypeExp (ExpBase NoInfo VName) VName
     -> TypeArgExp (ExpBase NoInfo VName) VName)
    -> TypeExp (ExpBase NoInfo VName) VName
    -> TypeArgExp (ExpBase NoInfo VName) VName
    forall a b. (a -> b) -> a -> b
    $ TypeExp (ExpBase Info VName) VName
    -> TypeExp (ExpBase NoInfo VName) VName
    bareTypeExp TypeExp (ExpBase Info VName) VName
    tya
    bareTypeExp (TEArrow Maybe VName
    arg TypeExp (ExpBase Info VName) VName
    tya TypeExp (ExpBase Info VName) VName
    tyr SrcLoc
    loc) = Maybe VName
    -> TypeExp (ExpBase NoInfo VName) VName
    -> TypeExp (ExpBase NoInfo VName) VName
    -> SrcLoc
    -> TypeExp (ExpBase NoInfo VName) VName
    forall d vn.
    Maybe vn -> TypeExp d vn -> TypeExp d vn -> SrcLoc -> TypeExp d vn
    TEArrow Maybe VName
    arg (TypeExp (ExpBase Info VName) VName
    -> TypeExp (ExpBase NoInfo VName) VName
    bareTypeExp TypeExp (ExpBase Info VName) VName
    tya) (TypeExp (ExpBase Info VName) VName
    -> TypeExp (ExpBase NoInfo VName) VName
    bareTypeExp TypeExp (ExpBase Info VName) VName
    tyr) SrcLoc
    loc
    bareTypeExp (TESum [(Name, [TypeExp (ExpBase Info VName) VName])]
    cs SrcLoc
    loc) = [(Name, [TypeExp (ExpBase NoInfo VName) VName])]
    -> SrcLoc -> TypeExp (ExpBase NoInfo VName) VName
    forall d vn. [(Name, [TypeExp d vn])] -> SrcLoc -> TypeExp d vn
    TESum (((Name, [TypeExp (ExpBase Info VName) VName])
     -> (Name, [TypeExp (ExpBase NoInfo VName) VName]))
    -> [(Name, [TypeExp (ExpBase Info VName) VName])]
    -> [(Name, [TypeExp (ExpBase NoInfo VName) VName])]
    forall a b. (a -> b) -> [a] -> [b]
    map (([TypeExp (ExpBase Info VName) VName]
     -> [TypeExp (ExpBase NoInfo VName) VName])
    -> (Name, [TypeExp (ExpBase Info VName) VName])
    -> (Name, [TypeExp (ExpBase NoInfo VName) VName])
    forall b c a. (b -> c) -> (a, b) -> (a, c)
    forall (p :: * -> * -> *) b c a.
    Bifunctor p =>
    (b -> c) -> p a b -> p a c
    second (([TypeExp (ExpBase Info VName) VName]
      -> [TypeExp (ExpBase NoInfo VName) VName])
     -> (Name, [TypeExp (ExpBase Info VName) VName])
     -> (Name, [TypeExp (ExpBase NoInfo VName) VName]))
    -> ([TypeExp (ExpBase Info VName) VName]
        -> [TypeExp (ExpBase NoInfo VName) VName])
    -> (Name, [TypeExp (ExpBase Info VName) VName])
    -> (Name, [TypeExp (ExpBase NoInfo VName) VName])
    forall a b. (a -> b) -> a -> b
    $ (TypeExp (ExpBase Info VName) VName
     -> TypeExp (ExpBase NoInfo VName) VName)
    -> [TypeExp (ExpBase Info VName) VName]
    -> [TypeExp (ExpBase NoInfo VName) VName]
    forall a b. (a -> b) -> [a] -> [b]
    map TypeExp (ExpBase Info VName) VName
    -> TypeExp (ExpBase NoInfo VName) VName
    bareTypeExp) [(Name, [TypeExp (ExpBase Info VName) VName])]
    cs) SrcLoc
    loc
    bareTypeExp (TEDim [VName]
    names TypeExp (ExpBase Info VName) VName
    ty SrcLoc
    loc) = [VName]
    -> TypeExp (ExpBase NoInfo VName) VName
    -> SrcLoc
    -> TypeExp (ExpBase NoInfo VName) VName
    forall d vn. [vn] -> TypeExp d vn -> SrcLoc -> TypeExp d vn
    TEDim [VName]
    names (TypeExp (ExpBase Info VName) VName
    -> TypeExp (ExpBase NoInfo VName) VName
    bareTypeExp TypeExp (ExpBase Info VName) VName
    ty) SrcLoc
    loc

    -- | Remove all annotations from an expression, but retain the
    -- name/scope information.
    bareExp :: ExpBase Info VName -> ExpBase NoInfo VName
    bareExp :: ExpBase Info VName -> ExpBase NoInfo VName
    bareExp (Var QualName VName
    name Info StructType
    _ SrcLoc
    loc) = QualName VName
    -> NoInfo StructType -> SrcLoc -> ExpBase NoInfo VName
    forall (f :: * -> *) vn.
    QualName vn -> f StructType -> SrcLoc -> ExpBase f vn
    Var QualName VName
    name NoInfo StructType
    forall {k} (a :: k). NoInfo a
    NoInfo SrcLoc
    loc
    bareExp (Hole Info StructType
    _ SrcLoc
    loc) = NoInfo StructType -> SrcLoc -> ExpBase NoInfo VName
    forall (f :: * -> *) vn. f StructType -> SrcLoc -> ExpBase f vn
    Hole NoInfo StructType
    forall {k} (a :: k). NoInfo a
    NoInfo SrcLoc
    loc
    bareExp (Literal PrimValue
    v SrcLoc
    loc) = PrimValue -> SrcLoc -> ExpBase NoInfo VName
    forall (f :: * -> *) vn. PrimValue -> SrcLoc -> ExpBase f vn
    Literal PrimValue
    v SrcLoc
    loc
    bareExp (IntLit Integer
    val Info StructType
    _ SrcLoc
    loc) = Integer -> NoInfo StructType -> SrcLoc -> ExpBase NoInfo VName
    forall (f :: * -> *) vn.
    Integer -> f StructType -> SrcLoc -> ExpBase f vn
    IntLit Integer
    val NoInfo StructType
    forall {k} (a :: k). NoInfo a
    NoInfo SrcLoc
    loc
    bareExp (FloatLit Double
    val Info StructType
    _ SrcLoc
    loc) = Double -> NoInfo StructType -> SrcLoc -> ExpBase NoInfo VName
    forall (f :: * -> *) vn.
    Double -> f StructType -> SrcLoc -> ExpBase f vn
    FloatLit Double
    val NoInfo StructType
    forall {k} (a :: k). NoInfo a
    NoInfo SrcLoc
    loc
    bareExp (Parens ExpBase Info VName
    e SrcLoc
    loc) = ExpBase NoInfo VName -> SrcLoc -> ExpBase NoInfo VName
    forall (f :: * -> *) vn. ExpBase f vn -> SrcLoc -> ExpBase f vn
    Parens (ExpBase Info VName -> ExpBase NoInfo VName
    bareExp ExpBase Info VName
    e) SrcLoc
    loc
    bareExp (QualParens (QualName VName, SrcLoc)
    name ExpBase Info VName
    e SrcLoc
    loc) = (QualName VName, SrcLoc)
    -> ExpBase NoInfo VName -> SrcLoc -> ExpBase NoInfo VName
    forall (f :: * -> *) vn.
    (QualName vn, SrcLoc) -> ExpBase f vn -> SrcLoc -> ExpBase f vn
    QualParens (QualName VName, SrcLoc)
    name (ExpBase Info VName -> ExpBase NoInfo VName
    bareExp ExpBase Info VName
    e) SrcLoc
    loc
    bareExp (TupLit [ExpBase Info VName]
    els SrcLoc
    loc) = [ExpBase NoInfo VName] -> SrcLoc -> ExpBase NoInfo VName
    forall (f :: * -> *) vn. [ExpBase f vn] -> SrcLoc -> ExpBase f vn
    TupLit ((ExpBase Info VName -> ExpBase NoInfo VName)
    -> [ExpBase Info VName] -> [ExpBase NoInfo VName]
    forall a b. (a -> b) -> [a] -> [b]
    map ExpBase Info VName -> ExpBase NoInfo VName
    bareExp [ExpBase Info VName]
    els) SrcLoc
    loc
    bareExp (StringLit [Word8]
    vs SrcLoc
    loc) = [Word8] -> SrcLoc -> ExpBase NoInfo VName
    forall (f :: * -> *) vn. [Word8] -> SrcLoc -> ExpBase f vn
    StringLit [Word8]
    vs SrcLoc
    loc
    bareExp (RecordLit [FieldBase Info VName]
    fields SrcLoc
    loc) = [FieldBase NoInfo VName] -> SrcLoc -> ExpBase NoInfo VName
    forall (f :: * -> *) vn. [FieldBase f vn] -> SrcLoc -> ExpBase f vn
    RecordLit ((FieldBase Info VName -> FieldBase NoInfo VName)
    -> [FieldBase Info VName] -> [FieldBase NoInfo VName]
    forall a b. (a -> b) -> [a] -> [b]
    map FieldBase Info VName -> FieldBase NoInfo VName
    bareField [FieldBase Info VName]
    fields) SrcLoc
    loc
    bareExp (ArrayVal [PrimValue]
    vs PrimType
    t SrcLoc
    loc) = [PrimValue] -> PrimType -> SrcLoc -> ExpBase NoInfo VName
    forall (f :: * -> *) vn.
    [PrimValue] -> PrimType -> SrcLoc -> ExpBase f vn
    ArrayVal [PrimValue]
    vs PrimType
    t SrcLoc
    loc
    bareExp (ArrayLit [ExpBase Info VName]
    els Info StructType
    _ SrcLoc
    loc) = [ExpBase NoInfo VName]
    -> NoInfo StructType -> SrcLoc -> ExpBase NoInfo VName
    forall (f :: * -> *) vn.
    [ExpBase f vn] -> f StructType -> SrcLoc -> ExpBase f vn
    ArrayLit ((ExpBase Info VName -> ExpBase NoInfo VName)
    -> [ExpBase Info VName] -> [ExpBase NoInfo VName]
    forall a b. (a -> b) -> [a] -> [b]
    map ExpBase Info VName -> ExpBase NoInfo VName
    bareExp [ExpBase Info VName]
    els) NoInfo StructType
    forall {k} (a :: k). NoInfo a
    NoInfo SrcLoc
    loc
    bareExp (Ascript ExpBase Info VName
    e TypeExp (ExpBase Info VName) VName
    te SrcLoc
    loc) = ExpBase NoInfo VName
    -> TypeExp (ExpBase NoInfo VName) VName
    -> SrcLoc
    -> ExpBase NoInfo VName
    forall (f :: * -> *) vn.
    ExpBase f vn -> TypeExp (ExpBase f vn) vn -> SrcLoc -> ExpBase f vn
    Ascript (ExpBase Info VName -> ExpBase NoInfo VName
    bareExp ExpBase Info VName
    e) (TypeExp (ExpBase Info VName) VName
    -> TypeExp (ExpBase NoInfo VName) VName
    bareTypeExp TypeExp (ExpBase Info VName) VName
    te) SrcLoc
    loc
    bareExp (Coerce ExpBase Info VName
    e TypeExp (ExpBase Info VName) VName
    te Info StructType
    _ SrcLoc
    loc) = ExpBase NoInfo VName
    -> TypeExp (ExpBase NoInfo VName) VName
    -> NoInfo StructType
    -> SrcLoc
    -> ExpBase NoInfo VName
    forall (f :: * -> *) vn.
    ExpBase f vn
    -> TypeExp (ExpBase f vn) vn
    -> f StructType
    -> SrcLoc
    -> ExpBase f vn
    Coerce (ExpBase Info VName -> ExpBase NoInfo VName
    bareExp ExpBase Info VName
    e) (TypeExp (ExpBase Info VName) VName
    -> TypeExp (ExpBase NoInfo VName) VName
    bareTypeExp TypeExp (ExpBase Info VName) VName
    te) NoInfo StructType
    forall {k} (a :: k). NoInfo a
    NoInfo SrcLoc
    loc
    bareExp (Negate ExpBase Info VName
    x SrcLoc
    loc) = ExpBase NoInfo VName -> SrcLoc -> ExpBase NoInfo VName
    forall (f :: * -> *) vn. ExpBase f vn -> SrcLoc -> ExpBase f vn
    Negate (ExpBase Info VName -> ExpBase NoInfo VName
    bareExp ExpBase Info VName
    x) SrcLoc
    loc
    bareExp (Not ExpBase Info VName
    x SrcLoc
    loc) = ExpBase NoInfo VName -> SrcLoc -> ExpBase NoInfo VName
    forall (f :: * -> *) vn. ExpBase f vn -> SrcLoc -> ExpBase f vn
    Not (ExpBase Info VName -> ExpBase NoInfo VName
    bareExp ExpBase Info VName
    x) SrcLoc
    loc
    bareExp (Update ExpBase Info VName
    src SliceBase Info VName
    slice ExpBase Info VName
    v SrcLoc
    loc) =
      ExpBase NoInfo VName
    -> SliceBase NoInfo VName
    -> ExpBase NoInfo VName
    -> SrcLoc
    -> ExpBase NoInfo VName
    forall (f :: * -> *) vn.
    ExpBase f vn
    -> SliceBase f vn -> ExpBase f vn -> SrcLoc -> ExpBase f vn
    Update (ExpBase Info VName -> ExpBase NoInfo VName
    bareExp ExpBase Info VName
    src) ((DimIndexBase Info VName -> DimIndexBase NoInfo VName)
    -> SliceBase Info VName -> SliceBase NoInfo VName
    forall a b. (a -> b) -> [a] -> [b]
    map DimIndexBase Info VName -> DimIndexBase NoInfo VName
    bareDimIndex SliceBase Info VName
    slice) (ExpBase Info VName -> ExpBase NoInfo VName
    bareExp ExpBase Info VName
    v) SrcLoc
    loc
    bareExp (RecordUpdate ExpBase Info VName
    src [Name]
    fs ExpBase Info VName
    v Info StructType
    _ SrcLoc
    loc) =
      ExpBase NoInfo VName
    -> [Name]
    -> ExpBase NoInfo VName
    -> NoInfo StructType
    -> SrcLoc
    -> ExpBase NoInfo VName
    forall (f :: * -> *) vn.
    ExpBase f vn
    -> [Name] -> ExpBase f vn -> f StructType -> SrcLoc -> ExpBase f vn
    RecordUpdate (ExpBase Info VName -> ExpBase NoInfo VName
    bareExp ExpBase Info VName
    src) [Name]
    fs (ExpBase Info VName -> ExpBase NoInfo VName
    bareExp ExpBase Info VName
    v) NoInfo StructType
    forall {k} (a :: k). NoInfo a
    NoInfo SrcLoc
    loc
    bareExp (Project Name
    field ExpBase Info VName
    e Info StructType
    _ SrcLoc
    loc) =
      Name
    -> ExpBase NoInfo VName
    -> NoInfo StructType
    -> SrcLoc
    -> ExpBase NoInfo VName
    forall (f :: * -> *) vn.
    Name -> ExpBase f vn -> f StructType -> SrcLoc -> ExpBase f vn
    Project Name
    field (ExpBase Info VName -> ExpBase NoInfo VName
    bareExp ExpBase Info VName
    e) NoInfo StructType
    forall {k} (a :: k). NoInfo a
    NoInfo SrcLoc
    loc
    bareExp (Assert ExpBase Info VName
    e1 ExpBase Info VName
    e2 Info Text
    _ SrcLoc
    loc) = ExpBase NoInfo VName
    -> ExpBase NoInfo VName
    -> NoInfo Text
    -> SrcLoc
    -> ExpBase NoInfo VName
    forall (f :: * -> *) vn.
    ExpBase f vn -> ExpBase f vn -> f Text -> SrcLoc -> ExpBase f vn
    Assert (ExpBase Info VName -> ExpBase NoInfo VName
    bareExp ExpBase Info VName
    e1) (ExpBase Info VName -> ExpBase NoInfo VName
    bareExp ExpBase Info VName
    e2) NoInfo Text
    forall {k} (a :: k). NoInfo a
    NoInfo SrcLoc
    loc
    bareExp (Lambda [PatBase Info VName ParamType]
    params ExpBase Info VName
    body Maybe (TypeExp (ExpBase Info VName) VName)
    ret Info ResRetType
    _ SrcLoc
    loc) =
      [PatBase NoInfo VName ParamType]
    -> ExpBase NoInfo VName
    -> Maybe (TypeExp (ExpBase NoInfo VName) VName)
    -> NoInfo ResRetType
    -> SrcLoc
    -> ExpBase NoInfo VName
    forall (f :: * -> *) vn.
    [PatBase f vn ParamType]
    -> ExpBase f vn
    -> Maybe (TypeExp (ExpBase f vn) vn)
    -> f ResRetType
    -> SrcLoc
    -> ExpBase f vn
    Lambda ((PatBase Info VName ParamType -> PatBase NoInfo VName ParamType)
    -> [PatBase Info VName ParamType]
    -> [PatBase NoInfo VName ParamType]
    forall a b. (a -> b) -> [a] -> [b]
    map PatBase Info VName ParamType -> PatBase NoInfo VName ParamType
    forall t. PatBase Info VName t -> PatBase NoInfo VName t
    barePat [PatBase Info VName ParamType]
    params) (ExpBase Info VName -> ExpBase NoInfo VName
    bareExp ExpBase Info VName
    body) ((TypeExp (ExpBase Info VName) VName
     -> TypeExp (ExpBase NoInfo VName) VName)
    -> Maybe (TypeExp (ExpBase Info VName) VName)
    -> Maybe (TypeExp (ExpBase NoInfo VName) VName)
    forall a b. (a -> b) -> Maybe a -> Maybe b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap TypeExp (ExpBase Info VName) VName
    -> TypeExp (ExpBase NoInfo VName) VName
    bareTypeExp Maybe (TypeExp (ExpBase Info VName) VName)
    ret) NoInfo ResRetType
    forall {k} (a :: k). NoInfo a
    NoInfo SrcLoc
    loc
    bareExp (OpSection QualName VName
    name Info StructType
    _ SrcLoc
    loc) = QualName VName
    -> NoInfo StructType -> SrcLoc -> ExpBase NoInfo VName
    forall (f :: * -> *) vn.
    QualName vn -> f StructType -> SrcLoc -> ExpBase f vn
    OpSection QualName VName
    name NoInfo StructType
    forall {k} (a :: k). NoInfo a
    NoInfo SrcLoc
    loc
    bareExp (OpSectionLeft QualName VName
    name Info StructType
    _ ExpBase Info VName
    arg (Info (PName, ParamType, Maybe VName), Info (PName, ParamType))
    _ (Info ResRetType, Info [VName])
    _ SrcLoc
    loc) =
      QualName VName
    -> NoInfo StructType
    -> ExpBase NoInfo VName
    -> (NoInfo (PName, ParamType, Maybe VName),
        NoInfo (PName, ParamType))
    -> (NoInfo ResRetType, NoInfo [VName])
    -> SrcLoc
    -> ExpBase NoInfo VName
    forall (f :: * -> *) vn.
    QualName vn
    -> f StructType
    -> ExpBase f vn
    -> (f (PName, ParamType, Maybe VName), f (PName, ParamType))
    -> (f ResRetType, f [VName])
    -> SrcLoc
    -> ExpBase f vn
    OpSectionLeft QualName VName
    name NoInfo StructType
    forall {k} (a :: k). NoInfo a
    NoInfo (ExpBase Info VName -> ExpBase NoInfo VName
    bareExp ExpBase Info VName
    arg) (NoInfo (PName, ParamType, Maybe VName)
    forall {k} (a :: k). NoInfo a
    NoInfo, NoInfo (PName, ParamType)
    forall {k} (a :: k). NoInfo a
    NoInfo) (NoInfo ResRetType
    forall {k} (a :: k). NoInfo a
    NoInfo, NoInfo [VName]
    forall {k} (a :: k). NoInfo a
    NoInfo) SrcLoc
    loc
    bareExp (OpSectionRight QualName VName
    name Info StructType
    _ ExpBase Info VName
    arg (Info (PName, ParamType), Info (PName, ParamType, Maybe VName))
    _ Info ResRetType
    _ SrcLoc
    loc) =
      QualName VName
    -> NoInfo StructType
    -> ExpBase NoInfo VName
    -> (NoInfo (PName, ParamType),
        NoInfo (PName, ParamType, Maybe VName))
    -> NoInfo ResRetType
    -> SrcLoc
    -> ExpBase NoInfo VName
    forall (f :: * -> *) vn.
    QualName vn
    -> f StructType
    -> ExpBase f vn
    -> (f (PName, ParamType), f (PName, ParamType, Maybe VName))
    -> f ResRetType
    -> SrcLoc
    -> ExpBase f vn
    OpSectionRight QualName VName
    name NoInfo StructType
    forall {k} (a :: k). NoInfo a
    NoInfo (ExpBase Info VName -> ExpBase NoInfo VName
    bareExp ExpBase Info VName
    arg) (NoInfo (PName, ParamType)
    forall {k} (a :: k). NoInfo a
    NoInfo, NoInfo (PName, ParamType, Maybe VName)
    forall {k} (a :: k). NoInfo a
    NoInfo) NoInfo ResRetType
    forall {k} (a :: k). NoInfo a
    NoInfo SrcLoc
    loc
    bareExp (ProjectSection [Name]
    fields Info StructType
    _ SrcLoc
    loc) = [Name] -> NoInfo StructType -> SrcLoc -> ExpBase NoInfo VName
    forall (f :: * -> *) vn.
    [Name] -> f StructType -> SrcLoc -> ExpBase f vn
    ProjectSection [Name]
    fields NoInfo StructType
    forall {k} (a :: k). NoInfo a
    NoInfo SrcLoc
    loc
    bareExp (IndexSection SliceBase Info VName
    slice Info StructType
    _ SrcLoc
    loc) =
      SliceBase NoInfo VName
    -> NoInfo StructType -> SrcLoc -> ExpBase NoInfo VName
    forall (f :: * -> *) vn.
    SliceBase f vn -> f StructType -> SrcLoc -> ExpBase f vn
    IndexSection ((DimIndexBase Info VName -> DimIndexBase NoInfo VName)
    -> SliceBase Info VName -> SliceBase NoInfo VName
    forall a b. (a -> b) -> [a] -> [b]
    map DimIndexBase Info VName -> DimIndexBase NoInfo VName
    bareDimIndex SliceBase Info VName
    slice) NoInfo StructType
    forall {k} (a :: k). NoInfo a
    NoInfo SrcLoc
    loc
    bareExp (Constr Name
    name [ExpBase Info VName]
    es Info StructType
    _ SrcLoc
    loc) =
      Name
    -> [ExpBase NoInfo VName]
    -> NoInfo StructType
    -> SrcLoc
    -> ExpBase NoInfo VName
    forall (f :: * -> *) vn.
    Name -> [ExpBase f vn] -> f StructType -> SrcLoc -> ExpBase f vn
    Constr Name
    name ((ExpBase Info VName -> ExpBase NoInfo VName)
    -> [ExpBase Info VName] -> [ExpBase NoInfo VName]
    forall a b. (a -> b) -> [a] -> [b]
    map ExpBase Info VName -> ExpBase NoInfo VName
    bareExp [ExpBase Info VName]
    es) NoInfo StructType
    forall {k} (a :: k). NoInfo a
    NoInfo SrcLoc
    loc
    bareExp (AppExp AppExpBase Info VName
    appexp Info AppRes
    _) =
      AppExpBase NoInfo VName -> NoInfo AppRes -> ExpBase NoInfo VName
    forall (f :: * -> *) vn.
    AppExpBase f vn -> f AppRes -> ExpBase f vn
    AppExp AppExpBase NoInfo VName
    appexp' NoInfo AppRes
    forall {k} (a :: k). NoInfo a
    NoInfo
      where
        appexp' :: AppExpBase NoInfo VName
    appexp' =
          case AppExpBase Info VName
    appexp of
            Match ExpBase Info VName
    e NonEmpty (CaseBase Info VName)
    cases SrcLoc
    loc ->
              ExpBase NoInfo VName
    -> NonEmpty (CaseBase NoInfo VName)
    -> SrcLoc
    -> AppExpBase NoInfo VName
    forall (f :: * -> *) vn.
    ExpBase f vn
    -> NonEmpty (CaseBase f vn) -> SrcLoc -> AppExpBase f vn
    Match (ExpBase Info VName -> ExpBase NoInfo VName
    bareExp ExpBase Info VName
    e) ((CaseBase Info VName -> CaseBase NoInfo VName)
    -> NonEmpty (CaseBase Info VName)
    -> NonEmpty (CaseBase NoInfo VName)
    forall a b. (a -> b) -> NonEmpty a -> NonEmpty b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap CaseBase Info VName -> CaseBase NoInfo VName
    bareCase NonEmpty (CaseBase Info VName)
    cases) SrcLoc
    loc
            Loop [VName]
    _ PatBase Info VName ParamType
    mergepat LoopInitBase Info VName
    loopinit LoopFormBase Info VName
    form ExpBase Info VName
    loopbody SrcLoc
    loc ->
              [VName]
    -> PatBase NoInfo VName ParamType
    -> LoopInitBase NoInfo VName
    -> LoopFormBase NoInfo VName
    -> ExpBase NoInfo VName
    -> SrcLoc
    -> AppExpBase NoInfo VName
    forall (f :: * -> *) vn.
    [VName]
    -> PatBase f vn ParamType
    -> LoopInitBase f vn
    -> LoopFormBase f vn
    -> ExpBase f vn
    -> SrcLoc
    -> AppExpBase f vn
    Loop
                []
                (PatBase Info VName ParamType -> PatBase NoInfo VName ParamType
    forall t. PatBase Info VName t -> PatBase NoInfo VName t
    barePat PatBase Info VName ParamType
    mergepat)
                (LoopInitBase Info VName -> LoopInitBase NoInfo VName
    bareLoopInit LoopInitBase Info VName
    loopinit)
                (LoopFormBase Info VName -> LoopFormBase NoInfo VName
    bareLoopForm LoopFormBase Info VName
    form)
                (ExpBase Info VName -> ExpBase NoInfo VName
    bareExp ExpBase Info VName
    loopbody)
                SrcLoc
    loc
            LetWith (Ident VName
    dest Info StructType
    _ SrcLoc
    destloc) (Ident VName
    src Info StructType
    _ SrcLoc
    srcloc) SliceBase Info VName
    idxexps ExpBase Info VName
    vexp ExpBase Info VName
    body SrcLoc
    loc ->
              IdentBase NoInfo VName StructType
    -> IdentBase NoInfo VName StructType
    -> SliceBase NoInfo VName
    -> ExpBase NoInfo VName
    -> ExpBase NoInfo VName
    -> SrcLoc
    -> AppExpBase NoInfo VName
    forall (f :: * -> *) vn.
    IdentBase f vn StructType
    -> IdentBase f vn StructType
    -> SliceBase f vn
    -> ExpBase f vn
    -> ExpBase f vn
    -> SrcLoc
    -> AppExpBase f vn
    LetWith
                (VName
    -> NoInfo StructType -> SrcLoc -> IdentBase NoInfo VName StructType
    forall {k} (f :: k -> *) vn (t :: k).
    vn -> f t -> SrcLoc -> IdentBase f vn t
    Ident VName
    dest NoInfo StructType
    forall {k} (a :: k). NoInfo a
    NoInfo SrcLoc
    destloc)
                (VName
    -> NoInfo StructType -> SrcLoc -> IdentBase NoInfo VName StructType
    forall {k} (f :: k -> *) vn (t :: k).
    vn -> f t -> SrcLoc -> IdentBase f vn t
    Ident VName
    src NoInfo StructType
    forall {k} (a :: k). NoInfo a
    NoInfo SrcLoc
    srcloc)
                ((DimIndexBase Info VName -> DimIndexBase NoInfo VName)
    -> SliceBase Info VName -> SliceBase NoInfo VName
    forall a b. (a -> b) -> [a] -> [b]
    map DimIndexBase Info VName -> DimIndexBase NoInfo VName
    bareDimIndex SliceBase Info VName
    idxexps)
                (ExpBase Info VName -> ExpBase NoInfo VName
    bareExp ExpBase Info VName
    vexp)
                (ExpBase Info VName -> ExpBase NoInfo VName
    bareExp ExpBase Info VName
    body)
                SrcLoc
    loc
            BinOp (QualName VName, SrcLoc)
    fname Info StructType
    _ (ExpBase Info VName
    x, Info (Maybe VName)
    _) (ExpBase Info VName
    y, Info (Maybe VName)
    _) SrcLoc
    loc ->
              (QualName VName, SrcLoc)
    -> NoInfo StructType
    -> (ExpBase NoInfo VName, NoInfo (Maybe VName))
    -> (ExpBase NoInfo VName, NoInfo (Maybe VName))
    -> SrcLoc
    -> AppExpBase NoInfo VName
    forall (f :: * -> *) vn.
    (QualName vn, SrcLoc)
    -> f StructType
    -> (ExpBase f vn, f (Maybe VName))
    -> (ExpBase f vn, f (Maybe VName))
    -> SrcLoc
    -> AppExpBase f vn
    BinOp (QualName VName, SrcLoc)
    fname NoInfo StructType
    forall {k} (a :: k). NoInfo a
    NoInfo (ExpBase Info VName -> ExpBase NoInfo VName
    bareExp ExpBase Info VName
    x, NoInfo (Maybe VName)
    forall {k} (a :: k). NoInfo a
    NoInfo) (ExpBase Info VName -> ExpBase NoInfo VName
    bareExp ExpBase Info VName
    y, NoInfo (Maybe VName)
    forall {k} (a :: k). NoInfo a
    NoInfo) SrcLoc
    loc
            If ExpBase Info VName
    c ExpBase Info VName
    texp ExpBase Info VName
    fexp SrcLoc
    loc ->
              ExpBase NoInfo VName
    -> ExpBase NoInfo VName
    -> ExpBase NoInfo VName
    -> SrcLoc
    -> AppExpBase NoInfo VName
    forall (f :: * -> *) vn.
    ExpBase f vn
    -> ExpBase f vn -> ExpBase f vn -> SrcLoc -> AppExpBase f vn
    If (ExpBase Info VName -> ExpBase NoInfo VName
    bareExp ExpBase Info VName
    c) (ExpBase Info VName -> ExpBase NoInfo VName
    bareExp ExpBase Info VName
    texp) (ExpBase Info VName -> ExpBase NoInfo VName
    bareExp ExpBase Info VName
    fexp) SrcLoc
    loc
            Apply ExpBase Info VName
    f NonEmpty (Info (Maybe VName), ExpBase Info VName)
    args SrcLoc
    loc ->
              ExpBase NoInfo VName
    -> NonEmpty (NoInfo (Maybe VName), ExpBase NoInfo VName)
    -> SrcLoc
    -> AppExpBase NoInfo VName
    forall (f :: * -> *) vn.
    ExpBase f vn
    -> NonEmpty (f (Maybe VName), ExpBase f vn)
    -> SrcLoc
    -> AppExpBase f vn
    Apply (ExpBase Info VName -> ExpBase NoInfo VName
    bareExp ExpBase Info VName
    f) (((Info (Maybe VName), ExpBase Info VName)
     -> (NoInfo (Maybe VName), ExpBase NoInfo VName))
    -> NonEmpty (Info (Maybe VName), ExpBase Info VName)
    -> NonEmpty (NoInfo (Maybe VName), ExpBase NoInfo VName)
    forall a b. (a -> b) -> NonEmpty a -> NonEmpty b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap ((NoInfo (Maybe VName)
    forall {k} (a :: k). NoInfo a
    NoInfo,) (ExpBase NoInfo VName
     -> (NoInfo (Maybe VName), ExpBase NoInfo VName))
    -> ((Info (Maybe VName), ExpBase Info VName)
        -> ExpBase NoInfo VName)
    -> (Info (Maybe VName), ExpBase Info VName)
    -> (NoInfo (Maybe VName), ExpBase NoInfo VName)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ExpBase Info VName -> ExpBase NoInfo VName
    bareExp (ExpBase Info VName -> ExpBase NoInfo VName)
    -> ((Info (Maybe VName), ExpBase Info VName) -> ExpBase Info VName)
    -> (Info (Maybe VName), ExpBase Info VName)
    -> ExpBase NoInfo VName
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Info (Maybe VName), ExpBase Info VName) -> ExpBase Info VName
    forall a b. (a, b) -> b
    snd) NonEmpty (Info (Maybe VName), ExpBase Info VName)
    args) SrcLoc
    loc
            LetPat [SizeBinder VName]
    sizes PatBase Info VName StructType
    pat ExpBase Info VName
    e ExpBase Info VName
    body SrcLoc
    loc ->
              [SizeBinder VName]
    -> PatBase NoInfo VName StructType
    -> ExpBase NoInfo VName
    -> ExpBase NoInfo VName
    -> SrcLoc
    -> AppExpBase NoInfo VName
    forall (f :: * -> *) vn.
    [SizeBinder vn]
    -> PatBase f vn StructType
    -> ExpBase f vn
    -> ExpBase f vn
    -> SrcLoc
    -> AppExpBase f vn
    LetPat [SizeBinder VName]
    sizes (PatBase Info VName StructType -> PatBase NoInfo VName StructType
    forall t. PatBase Info VName t -> PatBase NoInfo VName t
    barePat PatBase Info VName StructType
    pat) (ExpBase Info VName -> ExpBase NoInfo VName
    bareExp ExpBase Info VName
    e) (ExpBase Info VName -> ExpBase NoInfo VName
    bareExp ExpBase Info VName
    body) SrcLoc
    loc
            LetFun VName
    name ([TypeParamBase VName]
    fparams, [PatBase Info VName ParamType]
    params, Maybe (TypeExp (ExpBase Info VName) VName)
    ret, Info ResRetType
    _, ExpBase Info VName
    e) ExpBase Info VName
    body SrcLoc
    loc ->
              VName
    -> ([TypeParamBase VName], [PatBase NoInfo VName ParamType],
        Maybe (TypeExp (ExpBase NoInfo VName) VName), NoInfo ResRetType,
        ExpBase NoInfo VName)
    -> ExpBase NoInfo VName
    -> SrcLoc
    -> AppExpBase NoInfo VName
    forall (f :: * -> *) vn.
    vn
    -> ([TypeParamBase vn], [PatBase f vn ParamType],
        Maybe (TypeExp (ExpBase f vn) vn), f ResRetType, ExpBase f vn)
    -> ExpBase f vn
    -> SrcLoc
    -> AppExpBase f vn
    LetFun
                VName
    name
                ([TypeParamBase VName]
    fparams, (PatBase Info VName ParamType -> PatBase NoInfo VName ParamType)
    -> [PatBase Info VName ParamType]
    -> [PatBase NoInfo VName ParamType]
    forall a b. (a -> b) -> [a] -> [b]
    map PatBase Info VName ParamType -> PatBase NoInfo VName ParamType
    forall t. PatBase Info VName t -> PatBase NoInfo VName t
    barePat [PatBase Info VName ParamType]
    params, (TypeExp (ExpBase Info VName) VName
     -> TypeExp (ExpBase NoInfo VName) VName)
    -> Maybe (TypeExp (ExpBase Info VName) VName)
    -> Maybe (TypeExp (ExpBase NoInfo VName) VName)
    forall a b. (a -> b) -> Maybe a -> Maybe b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap TypeExp (ExpBase Info VName) VName
    -> TypeExp (ExpBase NoInfo VName) VName
    bareTypeExp Maybe (TypeExp (ExpBase Info VName) VName)
    ret, NoInfo ResRetType
    forall {k} (a :: k). NoInfo a
    NoInfo, ExpBase Info VName -> ExpBase NoInfo VName
    bareExp ExpBase Info VName
    e)
                (ExpBase Info VName -> ExpBase NoInfo VName
    bareExp ExpBase Info VName
    body)
                SrcLoc
    loc
            Range ExpBase Info VName
    start Maybe (ExpBase Info VName)
    next Inclusiveness (ExpBase Info VName)
    end SrcLoc
    loc ->
              ExpBase NoInfo VName
    -> Maybe (ExpBase NoInfo VName)
    -> Inclusiveness (ExpBase NoInfo VName)
    -> SrcLoc
    -> AppExpBase NoInfo VName
    forall (f :: * -> *) vn.
    ExpBase f vn
    -> Maybe (ExpBase f vn)
    -> Inclusiveness (ExpBase f vn)
    -> SrcLoc
    -> AppExpBase f vn
    Range (ExpBase Info VName -> ExpBase NoInfo VName
    bareExp ExpBase Info VName
    start) ((ExpBase Info VName -> ExpBase NoInfo VName)
    -> Maybe (ExpBase Info VName) -> Maybe (ExpBase NoInfo VName)
    forall a b. (a -> b) -> Maybe a -> Maybe b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap ExpBase Info VName -> ExpBase NoInfo VName
    bareExp Maybe (ExpBase Info VName)
    next) ((ExpBase Info VName -> ExpBase NoInfo VName)
    -> Inclusiveness (ExpBase Info VName)
    -> Inclusiveness (ExpBase NoInfo VName)
    forall a b. (a -> b) -> Inclusiveness a -> Inclusiveness b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap ExpBase Info VName -> ExpBase NoInfo VName
    bareExp Inclusiveness (ExpBase Info VName)
    end) SrcLoc
    loc
            Index ExpBase Info VName
    arr SliceBase Info VName
    slice SrcLoc
    loc ->
              ExpBase NoInfo VName
    -> SliceBase NoInfo VName -> SrcLoc -> AppExpBase NoInfo VName
    forall (f :: * -> *) vn.
    ExpBase f vn -> SliceBase f vn -> SrcLoc -> AppExpBase f vn
    Index (ExpBase Info VName -> ExpBase NoInfo VName
    bareExp ExpBase Info VName
    arr) ((DimIndexBase Info VName -> DimIndexBase NoInfo VName)
    -> SliceBase Info VName -> SliceBase NoInfo VName
    forall a b. (a -> b) -> [a] -> [b]
    map DimIndexBase Info VName -> DimIndexBase NoInfo VName
    bareDimIndex SliceBase Info VName
    slice) SrcLoc
    loc
    bareExp (Attr AttrInfo VName
    attr ExpBase Info VName
    e SrcLoc
    loc) =
      AttrInfo VName
    -> ExpBase NoInfo VName -> SrcLoc -> ExpBase NoInfo VName
    forall (f :: * -> *) vn.
    AttrInfo vn -> ExpBase f vn -> SrcLoc -> ExpBase f vn
    Attr AttrInfo VName
    attr (ExpBase Info VName -> ExpBase NoInfo VName
    bareExp ExpBase Info VName
    e) SrcLoc
    loc