{-# LANGUAGE FlexibleInstances     #-}
{-# LANGUAGE InstanceSigs          #-}
{-# LANGUAGE LambdaCase            #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE NamedFieldPuns        #-}
{-# LANGUAGE RecordWildCards       #-}
{-# LANGUAGE ScopedTypeVariables   #-}
{-# LANGUAGE StrictData            #-}
module Language.Cimple.TraverseAst
    ( mapAst, traverseAst

    , doFiles, doFile
    , doNodes, doNode
    , doLexemes, doLexeme
    , doText
    , doAttr

    , astActions
    , AttrActions, attrActions
    , TextActions, textActions
    , IdentityActions, identityActions
    ) where

import           Language.Cimple.AST   (Node (..))
import           Language.Cimple.Lexer (Lexeme (..))

class TraverseAst iattr oattr itext otext a b where
    mapAst :: Applicative f => AstActions f iattr oattr itext otext -> a -> f b

traverseAst
    :: (TraverseAst iattr oattr itext otext a a, Applicative f)
    => AstActions f iattr oattr itext otext -> a -> f a
traverseAst :: AstActions f iattr oattr itext otext -> a -> f a
traverseAst = AstActions f iattr oattr itext otext -> a -> f a
forall iattr oattr itext otext a b (f :: * -> *).
(TraverseAst iattr oattr itext otext a b, Applicative f) =>
AstActions f iattr oattr itext otext -> a -> f b
mapAst

data AstActions f iattr oattr itext otext = AstActions
    { AstActions f iattr oattr itext otext -> FilePath
currentFile :: FilePath
    , AstActions f iattr oattr itext otext
-> [(FilePath, [Node iattr (Lexeme itext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
doFiles     :: [(FilePath, [Node iattr (Lexeme itext)])] -> f [(FilePath, [Node oattr (Lexeme otext)])] -> f [(FilePath, [Node oattr (Lexeme otext)])]
    , AstActions f iattr oattr itext otext
-> (FilePath, [Node iattr (Lexeme itext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
doFile      ::  (FilePath, [Node iattr (Lexeme itext)])  -> f  (FilePath, [Node oattr (Lexeme otext)])  -> f  (FilePath, [Node oattr (Lexeme otext)])
    , AstActions f iattr oattr itext otext
-> FilePath
-> [Node iattr (Lexeme itext)]
-> f [Node oattr (Lexeme otext)]
-> f [Node oattr (Lexeme otext)]
doNodes     :: FilePath -> [Node iattr (Lexeme itext)]   -> f             [Node oattr (Lexeme otext)]   -> f             [Node oattr (Lexeme otext)]
    , AstActions f iattr oattr itext otext
-> FilePath
-> Node iattr (Lexeme itext)
-> f (Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
doNode      :: FilePath ->  Node iattr (Lexeme itext)    -> f             (Node oattr (Lexeme otext))   -> f             (Node oattr (Lexeme otext))
    , AstActions f iattr oattr itext otext
-> FilePath
-> [Lexeme itext]
-> f [Lexeme otext]
-> f [Lexeme otext]
doLexemes   :: FilePath ->             [Lexeme itext]    -> f                         [Lexeme otext]    -> f                         [Lexeme otext]
    , AstActions f iattr oattr itext otext
-> FilePath -> Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext)
doLexeme    :: FilePath ->              Lexeme itext     -> f                         (Lexeme otext)    -> f                         (Lexeme otext)
    , AstActions f iattr oattr itext otext
-> FilePath -> itext -> f otext
doText      :: FilePath ->                     itext                                                    -> f                                 otext
    , AstActions f iattr oattr itext otext
-> FilePath -> iattr -> f oattr
doAttr      :: FilePath ->       iattr                                                                  -> f                   oattr
    }

instance TraverseAst iattr oattr itext otext        a         b
      => TraverseAst iattr oattr itext otext (Maybe a) (Maybe b) where
    mapAst :: AstActions f iattr oattr itext otext -> Maybe a -> f (Maybe b)
mapAst AstActions f iattr oattr itext otext
_       Maybe a
Nothing  = Maybe b -> f (Maybe b)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe b
forall a. Maybe a
Nothing
    mapAst AstActions f iattr oattr itext otext
actions (Just a
x) = b -> Maybe b
forall a. a -> Maybe a
Just (b -> Maybe b) -> f b -> f (Maybe b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AstActions f iattr oattr itext otext -> a -> f b
forall iattr oattr itext otext a b (f :: * -> *).
(TraverseAst iattr oattr itext otext a b, Applicative f) =>
AstActions f iattr oattr itext otext -> a -> f b
mapAst AstActions f iattr oattr itext otext
actions a
x

astActions
    :: Applicative f
    => (iattr -> f oattr)
    -> (itext -> f otext)
    -> AstActions f iattr oattr itext otext
astActions :: (iattr -> f oattr)
-> (itext -> f otext) -> AstActions f iattr oattr itext otext
astActions iattr -> f oattr
fa itext -> f otext
ft = AstActions :: forall (f :: * -> *) iattr oattr itext otext.
FilePath
-> ([(FilePath, [Node iattr (Lexeme itext)])]
    -> f [(FilePath, [Node oattr (Lexeme otext)])]
    -> f [(FilePath, [Node oattr (Lexeme otext)])])
-> ((FilePath, [Node iattr (Lexeme itext)])
    -> f (FilePath, [Node oattr (Lexeme otext)])
    -> f (FilePath, [Node oattr (Lexeme otext)]))
-> (FilePath
    -> [Node iattr (Lexeme itext)]
    -> f [Node oattr (Lexeme otext)]
    -> f [Node oattr (Lexeme otext)])
-> (FilePath
    -> Node iattr (Lexeme itext)
    -> f (Node oattr (Lexeme otext))
    -> f (Node oattr (Lexeme otext)))
-> (FilePath
    -> [Lexeme itext] -> f [Lexeme otext] -> f [Lexeme otext])
-> (FilePath
    -> Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext))
-> (FilePath -> itext -> f otext)
-> (FilePath -> iattr -> f oattr)
-> AstActions f iattr oattr itext otext
AstActions
    { currentFile :: FilePath
currentFile = FilePath
"<stdin>"
    , doFiles :: [(FilePath, [Node iattr (Lexeme itext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
doFiles     = (f [(FilePath, [Node oattr (Lexeme otext)])]
 -> f [(FilePath, [Node oattr (Lexeme otext)])])
-> [(FilePath, [Node iattr (Lexeme itext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
forall a b. a -> b -> a
const f [(FilePath, [Node oattr (Lexeme otext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
forall a. a -> a
id
    , doFile :: (FilePath, [Node iattr (Lexeme itext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
doFile      = (f (FilePath, [Node oattr (Lexeme otext)])
 -> f (FilePath, [Node oattr (Lexeme otext)]))
-> (FilePath, [Node iattr (Lexeme itext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
forall a b. a -> b -> a
const f (FilePath, [Node oattr (Lexeme otext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
forall a. a -> a
id
    , doNodes :: FilePath
-> [Node iattr (Lexeme itext)]
-> f [Node oattr (Lexeme otext)]
-> f [Node oattr (Lexeme otext)]
doNodes     = ([Node iattr (Lexeme itext)]
 -> f [Node oattr (Lexeme otext)] -> f [Node oattr (Lexeme otext)])
-> FilePath
-> [Node iattr (Lexeme itext)]
-> f [Node oattr (Lexeme otext)]
-> f [Node oattr (Lexeme otext)]
forall a b. a -> b -> a
const (([Node iattr (Lexeme itext)]
  -> f [Node oattr (Lexeme otext)] -> f [Node oattr (Lexeme otext)])
 -> FilePath
 -> [Node iattr (Lexeme itext)]
 -> f [Node oattr (Lexeme otext)]
 -> f [Node oattr (Lexeme otext)])
-> ([Node iattr (Lexeme itext)]
    -> f [Node oattr (Lexeme otext)] -> f [Node oattr (Lexeme otext)])
-> FilePath
-> [Node iattr (Lexeme itext)]
-> f [Node oattr (Lexeme otext)]
-> f [Node oattr (Lexeme otext)]
forall a b. (a -> b) -> a -> b
$ (f [Node oattr (Lexeme otext)] -> f [Node oattr (Lexeme otext)])
-> [Node iattr (Lexeme itext)]
-> f [Node oattr (Lexeme otext)]
-> f [Node oattr (Lexeme otext)]
forall a b. a -> b -> a
const f [Node oattr (Lexeme otext)] -> f [Node oattr (Lexeme otext)]
forall a. a -> a
id
    , doNode :: FilePath
-> Node iattr (Lexeme itext)
-> f (Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
doNode      = (Node iattr (Lexeme itext)
 -> f (Node oattr (Lexeme otext)) -> f (Node oattr (Lexeme otext)))
-> FilePath
-> Node iattr (Lexeme itext)
-> f (Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
forall a b. a -> b -> a
const ((Node iattr (Lexeme itext)
  -> f (Node oattr (Lexeme otext)) -> f (Node oattr (Lexeme otext)))
 -> FilePath
 -> Node iattr (Lexeme itext)
 -> f (Node oattr (Lexeme otext))
 -> f (Node oattr (Lexeme otext)))
-> (Node iattr (Lexeme itext)
    -> f (Node oattr (Lexeme otext)) -> f (Node oattr (Lexeme otext)))
-> FilePath
-> Node iattr (Lexeme itext)
-> f (Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
forall a b. (a -> b) -> a -> b
$ (f (Node oattr (Lexeme otext)) -> f (Node oattr (Lexeme otext)))
-> Node iattr (Lexeme itext)
-> f (Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
forall a b. a -> b -> a
const f (Node oattr (Lexeme otext)) -> f (Node oattr (Lexeme otext))
forall a. a -> a
id
    , doLexeme :: FilePath -> Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext)
doLexeme    = (Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext))
-> FilePath -> Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext)
forall a b. a -> b -> a
const ((Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext))
 -> FilePath
 -> Lexeme itext
 -> f (Lexeme otext)
 -> f (Lexeme otext))
-> (Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext))
-> FilePath
-> Lexeme itext
-> f (Lexeme otext)
-> f (Lexeme otext)
forall a b. (a -> b) -> a -> b
$ (f (Lexeme otext) -> f (Lexeme otext))
-> Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext)
forall a b. a -> b -> a
const f (Lexeme otext) -> f (Lexeme otext)
forall a. a -> a
id
    , doLexemes :: FilePath -> [Lexeme itext] -> f [Lexeme otext] -> f [Lexeme otext]
doLexemes   = ([Lexeme itext] -> f [Lexeme otext] -> f [Lexeme otext])
-> FilePath
-> [Lexeme itext]
-> f [Lexeme otext]
-> f [Lexeme otext]
forall a b. a -> b -> a
const (([Lexeme itext] -> f [Lexeme otext] -> f [Lexeme otext])
 -> FilePath
 -> [Lexeme itext]
 -> f [Lexeme otext]
 -> f [Lexeme otext])
-> ([Lexeme itext] -> f [Lexeme otext] -> f [Lexeme otext])
-> FilePath
-> [Lexeme itext]
-> f [Lexeme otext]
-> f [Lexeme otext]
forall a b. (a -> b) -> a -> b
$ (f [Lexeme otext] -> f [Lexeme otext])
-> [Lexeme itext] -> f [Lexeme otext] -> f [Lexeme otext]
forall a b. a -> b -> a
const f [Lexeme otext] -> f [Lexeme otext]
forall a. a -> a
id
    , doText :: FilePath -> itext -> f otext
doText      = (itext -> f otext) -> FilePath -> itext -> f otext
forall a b. a -> b -> a
const itext -> f otext
ft
    , doAttr :: FilePath -> iattr -> f oattr
doAttr      = (iattr -> f oattr) -> FilePath -> iattr -> f oattr
forall a b. a -> b -> a
const iattr -> f oattr
fa
    }

type AttrActions f iattr oattr text = AstActions f iattr oattr text text
attrActions :: Applicative f => (iattr -> f oattr) -> AttrActions f iattr oattr text
attrActions :: (iattr -> f oattr) -> AttrActions f iattr oattr text
attrActions = ((iattr -> f oattr)
 -> (text -> f text) -> AttrActions f iattr oattr text)
-> (text -> f text)
-> (iattr -> f oattr)
-> AttrActions f iattr oattr text
forall a b c. (a -> b -> c) -> b -> a -> c
flip (iattr -> f oattr)
-> (text -> f text) -> AttrActions f iattr oattr text
forall (f :: * -> *) iattr oattr itext otext.
Applicative f =>
(iattr -> f oattr)
-> (itext -> f otext) -> AstActions f iattr oattr itext otext
astActions text -> f text
forall (f :: * -> *) a. Applicative f => a -> f a
pure

type TextActions f attr itext otext = AstActions f attr attr itext otext
textActions :: Applicative f => (itext -> f otext) -> TextActions f attr itext otext
textActions :: (itext -> f otext) -> TextActions f attr itext otext
textActions = (attr -> f attr)
-> (itext -> f otext) -> TextActions f attr itext otext
forall (f :: * -> *) iattr oattr itext otext.
Applicative f =>
(iattr -> f oattr)
-> (itext -> f otext) -> AstActions f iattr oattr itext otext
astActions attr -> f attr
forall (f :: * -> *) a. Applicative f => a -> f a
pure

type IdentityActions f attr text = AstActions f attr attr text text
identityActions :: Applicative f => AstActions f attr attr text text
identityActions :: AstActions f attr attr text text
identityActions = (attr -> f attr)
-> (text -> f text) -> AstActions f attr attr text text
forall (f :: * -> *) iattr oattr itext otext.
Applicative f =>
(iattr -> f oattr)
-> (itext -> f otext) -> AstActions f iattr oattr itext otext
astActions attr -> f attr
forall (f :: * -> *) a. Applicative f => a -> f a
pure text -> f text
forall (f :: * -> *) a. Applicative f => a -> f a
pure


instance TraverseAst iattr oattr itext otext itext otext where
    mapAst :: AstActions f iattr oattr itext otext -> itext -> f otext
mapAst AstActions{FilePath
FilePath -> iattr -> f oattr
FilePath -> itext -> f otext
FilePath
-> [Node iattr (Lexeme itext)]
-> f [Node oattr (Lexeme otext)]
-> f [Node oattr (Lexeme otext)]
FilePath -> [Lexeme itext] -> f [Lexeme otext] -> f [Lexeme otext]
FilePath
-> Node iattr (Lexeme itext)
-> f (Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
FilePath -> Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext)
[(FilePath, [Node iattr (Lexeme itext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
(FilePath, [Node iattr (Lexeme itext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
doAttr :: FilePath -> iattr -> f oattr
doText :: FilePath -> itext -> f otext
doLexeme :: FilePath -> Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext)
doLexemes :: FilePath -> [Lexeme itext] -> f [Lexeme otext] -> f [Lexeme otext]
doNode :: FilePath
-> Node iattr (Lexeme itext)
-> f (Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
doNodes :: FilePath
-> [Node iattr (Lexeme itext)]
-> f [Node oattr (Lexeme otext)]
-> f [Node oattr (Lexeme otext)]
doFile :: (FilePath, [Node iattr (Lexeme itext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
doFiles :: [(FilePath, [Node iattr (Lexeme itext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
currentFile :: FilePath
currentFile :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext -> FilePath
doAttr :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> FilePath -> iattr -> f oattr
doText :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> FilePath -> itext -> f otext
doLexeme :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> FilePath -> Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext)
doLexemes :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> FilePath
-> [Lexeme itext]
-> f [Lexeme otext]
-> f [Lexeme otext]
doNode :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> FilePath
-> Node iattr (Lexeme itext)
-> f (Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
doNodes :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> FilePath
-> [Node iattr (Lexeme itext)]
-> f [Node oattr (Lexeme otext)]
-> f [Node oattr (Lexeme otext)]
doFile :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> (FilePath, [Node iattr (Lexeme itext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
doFiles :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> [(FilePath, [Node iattr (Lexeme itext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
..} = FilePath -> itext -> f otext
doText FilePath
currentFile

instance TraverseAst iattr oattr itext otext iattr oattr where
    mapAst :: AstActions f iattr oattr itext otext -> iattr -> f oattr
mapAst AstActions{FilePath
FilePath -> iattr -> f oattr
FilePath -> itext -> f otext
FilePath
-> [Node iattr (Lexeme itext)]
-> f [Node oattr (Lexeme otext)]
-> f [Node oattr (Lexeme otext)]
FilePath -> [Lexeme itext] -> f [Lexeme otext] -> f [Lexeme otext]
FilePath
-> Node iattr (Lexeme itext)
-> f (Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
FilePath -> Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext)
[(FilePath, [Node iattr (Lexeme itext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
(FilePath, [Node iattr (Lexeme itext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
doAttr :: FilePath -> iattr -> f oattr
doText :: FilePath -> itext -> f otext
doLexeme :: FilePath -> Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext)
doLexemes :: FilePath -> [Lexeme itext] -> f [Lexeme otext] -> f [Lexeme otext]
doNode :: FilePath
-> Node iattr (Lexeme itext)
-> f (Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
doNodes :: FilePath
-> [Node iattr (Lexeme itext)]
-> f [Node oattr (Lexeme otext)]
-> f [Node oattr (Lexeme otext)]
doFile :: (FilePath, [Node iattr (Lexeme itext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
doFiles :: [(FilePath, [Node iattr (Lexeme itext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
currentFile :: FilePath
currentFile :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext -> FilePath
doAttr :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> FilePath -> iattr -> f oattr
doText :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> FilePath -> itext -> f otext
doLexeme :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> FilePath -> Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext)
doLexemes :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> FilePath
-> [Lexeme itext]
-> f [Lexeme otext]
-> f [Lexeme otext]
doNode :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> FilePath
-> Node iattr (Lexeme itext)
-> f (Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
doNodes :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> FilePath
-> [Node iattr (Lexeme itext)]
-> f [Node oattr (Lexeme otext)]
-> f [Node oattr (Lexeme otext)]
doFile :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> (FilePath, [Node iattr (Lexeme itext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
doFiles :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> [(FilePath, [Node iattr (Lexeme itext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
..} = FilePath -> iattr -> f oattr
doAttr FilePath
currentFile

instance TraverseAst iattr oattr itext otext (Lexeme itext)
                                             (Lexeme otext) where
    mapAst :: forall f . Applicative f
           => AstActions f iattr oattr itext otext -> Lexeme itext -> f (Lexeme otext)
    mapAst :: AstActions f iattr oattr itext otext
-> Lexeme itext -> f (Lexeme otext)
mapAst actions :: AstActions f iattr oattr itext otext
actions@AstActions{FilePath
FilePath -> iattr -> f oattr
FilePath -> itext -> f otext
FilePath
-> [Node iattr (Lexeme itext)]
-> f [Node oattr (Lexeme otext)]
-> f [Node oattr (Lexeme otext)]
FilePath -> [Lexeme itext] -> f [Lexeme otext] -> f [Lexeme otext]
FilePath
-> Node iattr (Lexeme itext)
-> f (Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
FilePath -> Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext)
[(FilePath, [Node iattr (Lexeme itext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
(FilePath, [Node iattr (Lexeme itext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
doAttr :: FilePath -> iattr -> f oattr
doText :: FilePath -> itext -> f otext
doLexeme :: FilePath -> Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext)
doLexemes :: FilePath -> [Lexeme itext] -> f [Lexeme otext] -> f [Lexeme otext]
doNode :: FilePath
-> Node iattr (Lexeme itext)
-> f (Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
doNodes :: FilePath
-> [Node iattr (Lexeme itext)]
-> f [Node oattr (Lexeme otext)]
-> f [Node oattr (Lexeme otext)]
doFile :: (FilePath, [Node iattr (Lexeme itext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
doFiles :: [(FilePath, [Node iattr (Lexeme itext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
currentFile :: FilePath
currentFile :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext -> FilePath
doAttr :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> FilePath -> iattr -> f oattr
doText :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> FilePath -> itext -> f otext
doLexeme :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> FilePath -> Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext)
doLexemes :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> FilePath
-> [Lexeme itext]
-> f [Lexeme otext]
-> f [Lexeme otext]
doNode :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> FilePath
-> Node iattr (Lexeme itext)
-> f (Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
doNodes :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> FilePath
-> [Node iattr (Lexeme itext)]
-> f [Node oattr (Lexeme otext)]
-> f [Node oattr (Lexeme otext)]
doFile :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> (FilePath, [Node iattr (Lexeme itext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
doFiles :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> [(FilePath, [Node iattr (Lexeme itext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
..} = FilePath -> Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext)
doLexeme FilePath
currentFile (Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext))
-> (Lexeme itext -> f (Lexeme otext))
-> Lexeme itext
-> f (Lexeme otext)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
        \(L AlexPosn
p LexemeClass
c itext
s) -> AlexPosn -> LexemeClass -> otext -> Lexeme otext
forall text. AlexPosn -> LexemeClass -> text -> Lexeme text
L AlexPosn
p LexemeClass
c (otext -> Lexeme otext) -> f otext -> f (Lexeme otext)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> itext -> f otext
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse itext
s
      where
        recurse :: TraverseAst iattr oattr itext otext a b => a -> f b
        recurse :: a -> f b
recurse = AstActions f iattr oattr itext otext -> a -> f b
forall iattr oattr itext otext a b (f :: * -> *).
(TraverseAst iattr oattr itext otext a b, Applicative f) =>
AstActions f iattr oattr itext otext -> a -> f b
mapAst AstActions f iattr oattr itext otext
actions

instance TraverseAst iattr oattr itext otext [Lexeme itext]
                                             [Lexeme otext] where
    mapAst :: AstActions f iattr oattr itext otext
-> [Lexeme itext] -> f [Lexeme otext]
mapAst actions :: AstActions f iattr oattr itext otext
actions@AstActions{FilePath
FilePath -> iattr -> f oattr
FilePath -> itext -> f otext
FilePath
-> [Node iattr (Lexeme itext)]
-> f [Node oattr (Lexeme otext)]
-> f [Node oattr (Lexeme otext)]
FilePath -> [Lexeme itext] -> f [Lexeme otext] -> f [Lexeme otext]
FilePath
-> Node iattr (Lexeme itext)
-> f (Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
FilePath -> Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext)
[(FilePath, [Node iattr (Lexeme itext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
(FilePath, [Node iattr (Lexeme itext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
doAttr :: FilePath -> iattr -> f oattr
doText :: FilePath -> itext -> f otext
doLexeme :: FilePath -> Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext)
doLexemes :: FilePath -> [Lexeme itext] -> f [Lexeme otext] -> f [Lexeme otext]
doNode :: FilePath
-> Node iattr (Lexeme itext)
-> f (Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
doNodes :: FilePath
-> [Node iattr (Lexeme itext)]
-> f [Node oattr (Lexeme otext)]
-> f [Node oattr (Lexeme otext)]
doFile :: (FilePath, [Node iattr (Lexeme itext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
doFiles :: [(FilePath, [Node iattr (Lexeme itext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
currentFile :: FilePath
currentFile :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext -> FilePath
doAttr :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> FilePath -> iattr -> f oattr
doText :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> FilePath -> itext -> f otext
doLexeme :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> FilePath -> Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext)
doLexemes :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> FilePath
-> [Lexeme itext]
-> f [Lexeme otext]
-> f [Lexeme otext]
doNode :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> FilePath
-> Node iattr (Lexeme itext)
-> f (Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
doNodes :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> FilePath
-> [Node iattr (Lexeme itext)]
-> f [Node oattr (Lexeme otext)]
-> f [Node oattr (Lexeme otext)]
doFile :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> (FilePath, [Node iattr (Lexeme itext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
doFiles :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> [(FilePath, [Node iattr (Lexeme itext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
..} = FilePath -> [Lexeme itext] -> f [Lexeme otext] -> f [Lexeme otext]
doLexemes FilePath
currentFile ([Lexeme itext] -> f [Lexeme otext] -> f [Lexeme otext])
-> ([Lexeme itext] -> f [Lexeme otext])
-> [Lexeme itext]
-> f [Lexeme otext]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
        (Lexeme itext -> f (Lexeme otext))
-> [Lexeme itext] -> f [Lexeme otext]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (AstActions f iattr oattr itext otext
-> Lexeme itext -> f (Lexeme otext)
forall iattr oattr itext otext a b (f :: * -> *).
(TraverseAst iattr oattr itext otext a b, Applicative f) =>
AstActions f iattr oattr itext otext -> a -> f b
mapAst AstActions f iattr oattr itext otext
actions)

instance TraverseAst iattr oattr itext otext (Node iattr (Lexeme itext))
                                             (Node oattr (Lexeme otext)) where
    mapAst :: forall f . Applicative f
           => AstActions f iattr oattr itext otext -> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
    mapAst :: AstActions f iattr oattr itext otext
-> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
mapAst actions :: AstActions f iattr oattr itext otext
actions@AstActions{FilePath
FilePath -> iattr -> f oattr
FilePath -> itext -> f otext
FilePath
-> [Node iattr (Lexeme itext)]
-> f [Node oattr (Lexeme otext)]
-> f [Node oattr (Lexeme otext)]
FilePath -> [Lexeme itext] -> f [Lexeme otext] -> f [Lexeme otext]
FilePath
-> Node iattr (Lexeme itext)
-> f (Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
FilePath -> Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext)
[(FilePath, [Node iattr (Lexeme itext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
(FilePath, [Node iattr (Lexeme itext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
doAttr :: FilePath -> iattr -> f oattr
doText :: FilePath -> itext -> f otext
doLexeme :: FilePath -> Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext)
doLexemes :: FilePath -> [Lexeme itext] -> f [Lexeme otext] -> f [Lexeme otext]
doNode :: FilePath
-> Node iattr (Lexeme itext)
-> f (Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
doNodes :: FilePath
-> [Node iattr (Lexeme itext)]
-> f [Node oattr (Lexeme otext)]
-> f [Node oattr (Lexeme otext)]
doFile :: (FilePath, [Node iattr (Lexeme itext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
doFiles :: [(FilePath, [Node iattr (Lexeme itext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
currentFile :: FilePath
currentFile :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext -> FilePath
doAttr :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> FilePath -> iattr -> f oattr
doText :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> FilePath -> itext -> f otext
doLexeme :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> FilePath -> Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext)
doLexemes :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> FilePath
-> [Lexeme itext]
-> f [Lexeme otext]
-> f [Lexeme otext]
doNode :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> FilePath
-> Node iattr (Lexeme itext)
-> f (Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
doNodes :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> FilePath
-> [Node iattr (Lexeme itext)]
-> f [Node oattr (Lexeme otext)]
-> f [Node oattr (Lexeme otext)]
doFile :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> (FilePath, [Node iattr (Lexeme itext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
doFiles :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> [(FilePath, [Node iattr (Lexeme itext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
..} = FilePath
-> Node iattr (Lexeme itext)
-> f (Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
doNode FilePath
currentFile (Node iattr (Lexeme itext)
 -> f (Node oattr (Lexeme otext)) -> f (Node oattr (Lexeme otext)))
-> (Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext)))
-> Node iattr (Lexeme itext)
-> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> \case
        Attr iattr
attr Node iattr (Lexeme itext)
node ->
            oattr -> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext)
forall attr lexeme. attr -> Node attr lexeme -> Node attr lexeme
Attr (oattr -> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f oattr
-> f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> iattr -> f oattr
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse iattr
attr f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext)) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
node
        PreprocInclude Lexeme itext
path ->
            Lexeme otext -> Node oattr (Lexeme otext)
forall attr lexeme. lexeme -> Node attr lexeme
PreprocInclude (Lexeme otext -> Node oattr (Lexeme otext))
-> f (Lexeme otext) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
path
        PreprocDefine Lexeme itext
name ->
            Lexeme otext -> Node oattr (Lexeme otext)
forall attr lexeme. lexeme -> Node attr lexeme
PreprocDefine (Lexeme otext -> Node oattr (Lexeme otext))
-> f (Lexeme otext) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
name
        PreprocDefineConst Lexeme itext
name Node iattr (Lexeme itext)
value ->
            Lexeme otext
-> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext)
forall attr lexeme. lexeme -> Node attr lexeme -> Node attr lexeme
PreprocDefineConst (Lexeme otext
 -> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Lexeme otext)
-> f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
name f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext)) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
value
        PreprocDefineMacro Lexeme itext
name [Node iattr (Lexeme itext)]
params Node iattr (Lexeme itext)
body ->
            Lexeme otext
-> [Node oattr (Lexeme otext)]
-> Node oattr (Lexeme otext)
-> Node oattr (Lexeme otext)
forall attr lexeme.
lexeme
-> [Node attr lexeme] -> Node attr lexeme -> Node attr lexeme
PreprocDefineMacro (Lexeme otext
 -> [Node oattr (Lexeme otext)]
 -> Node oattr (Lexeme otext)
 -> Node oattr (Lexeme otext))
-> f (Lexeme otext)
-> f ([Node oattr (Lexeme otext)]
      -> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
name f ([Node oattr (Lexeme otext)]
   -> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f [Node oattr (Lexeme otext)]
-> f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Node iattr (Lexeme itext)] -> f [Node oattr (Lexeme otext)]
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse [Node iattr (Lexeme itext)]
params f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext)) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
body
        PreprocIf Node iattr (Lexeme itext)
cond [Node iattr (Lexeme itext)]
thenDecls Node iattr (Lexeme itext)
elseBranch ->
            Node oattr (Lexeme otext)
-> [Node oattr (Lexeme otext)]
-> Node oattr (Lexeme otext)
-> Node oattr (Lexeme otext)
forall attr lexeme.
Node attr lexeme
-> [Node attr lexeme] -> Node attr lexeme -> Node attr lexeme
PreprocIf (Node oattr (Lexeme otext)
 -> [Node oattr (Lexeme otext)]
 -> Node oattr (Lexeme otext)
 -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
-> f ([Node oattr (Lexeme otext)]
      -> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
cond f ([Node oattr (Lexeme otext)]
   -> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f [Node oattr (Lexeme otext)]
-> f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Node iattr (Lexeme itext)] -> f [Node oattr (Lexeme otext)]
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse [Node iattr (Lexeme itext)]
thenDecls f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext)) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
elseBranch
        PreprocIfdef Lexeme itext
name [Node iattr (Lexeme itext)]
thenDecls Node iattr (Lexeme itext)
elseBranch ->
            Lexeme otext
-> [Node oattr (Lexeme otext)]
-> Node oattr (Lexeme otext)
-> Node oattr (Lexeme otext)
forall attr lexeme.
lexeme
-> [Node attr lexeme] -> Node attr lexeme -> Node attr lexeme
PreprocIfdef (Lexeme otext
 -> [Node oattr (Lexeme otext)]
 -> Node oattr (Lexeme otext)
 -> Node oattr (Lexeme otext))
-> f (Lexeme otext)
-> f ([Node oattr (Lexeme otext)]
      -> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
name f ([Node oattr (Lexeme otext)]
   -> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f [Node oattr (Lexeme otext)]
-> f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Node iattr (Lexeme itext)] -> f [Node oattr (Lexeme otext)]
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse [Node iattr (Lexeme itext)]
thenDecls f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext)) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
elseBranch
        PreprocIfndef Lexeme itext
name [Node iattr (Lexeme itext)]
thenDecls Node iattr (Lexeme itext)
elseBranch ->
            Lexeme otext
-> [Node oattr (Lexeme otext)]
-> Node oattr (Lexeme otext)
-> Node oattr (Lexeme otext)
forall attr lexeme.
lexeme
-> [Node attr lexeme] -> Node attr lexeme -> Node attr lexeme
PreprocIfndef (Lexeme otext
 -> [Node oattr (Lexeme otext)]
 -> Node oattr (Lexeme otext)
 -> Node oattr (Lexeme otext))
-> f (Lexeme otext)
-> f ([Node oattr (Lexeme otext)]
      -> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
name f ([Node oattr (Lexeme otext)]
   -> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f [Node oattr (Lexeme otext)]
-> f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Node iattr (Lexeme itext)] -> f [Node oattr (Lexeme otext)]
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse [Node iattr (Lexeme itext)]
thenDecls f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext)) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
elseBranch
        PreprocElse [Node iattr (Lexeme itext)]
decls ->
            [Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext)
forall attr lexeme. [Node attr lexeme] -> Node attr lexeme
PreprocElse ([Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
-> f [Node oattr (Lexeme otext)] -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Node iattr (Lexeme itext)] -> f [Node oattr (Lexeme otext)]
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse [Node iattr (Lexeme itext)]
decls
        PreprocElif Node iattr (Lexeme itext)
cond [Node iattr (Lexeme itext)]
decls Node iattr (Lexeme itext)
elseBranch ->
            Node oattr (Lexeme otext)
-> [Node oattr (Lexeme otext)]
-> Node oattr (Lexeme otext)
-> Node oattr (Lexeme otext)
forall attr lexeme.
Node attr lexeme
-> [Node attr lexeme] -> Node attr lexeme -> Node attr lexeme
PreprocElif (Node oattr (Lexeme otext)
 -> [Node oattr (Lexeme otext)]
 -> Node oattr (Lexeme otext)
 -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
-> f ([Node oattr (Lexeme otext)]
      -> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
cond f ([Node oattr (Lexeme otext)]
   -> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f [Node oattr (Lexeme otext)]
-> f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Node iattr (Lexeme itext)] -> f [Node oattr (Lexeme otext)]
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse [Node iattr (Lexeme itext)]
decls f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext)) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
elseBranch
        PreprocUndef Lexeme itext
name ->
            Lexeme otext -> Node oattr (Lexeme otext)
forall attr lexeme. lexeme -> Node attr lexeme
PreprocUndef (Lexeme otext -> Node oattr (Lexeme otext))
-> f (Lexeme otext) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
name
        PreprocDefined Lexeme itext
name ->
            Lexeme otext -> Node oattr (Lexeme otext)
forall attr lexeme. lexeme -> Node attr lexeme
PreprocDefined (Lexeme otext -> Node oattr (Lexeme otext))
-> f (Lexeme otext) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
name
        PreprocScopedDefine Node iattr (Lexeme itext)
define [Node iattr (Lexeme itext)]
stmts Node iattr (Lexeme itext)
undef ->
            Node oattr (Lexeme otext)
-> [Node oattr (Lexeme otext)]
-> Node oattr (Lexeme otext)
-> Node oattr (Lexeme otext)
forall attr lexeme.
Node attr lexeme
-> [Node attr lexeme] -> Node attr lexeme -> Node attr lexeme
PreprocScopedDefine (Node oattr (Lexeme otext)
 -> [Node oattr (Lexeme otext)]
 -> Node oattr (Lexeme otext)
 -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
-> f ([Node oattr (Lexeme otext)]
      -> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
define f ([Node oattr (Lexeme otext)]
   -> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f [Node oattr (Lexeme otext)]
-> f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Node iattr (Lexeme itext)] -> f [Node oattr (Lexeme otext)]
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse [Node iattr (Lexeme itext)]
stmts f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext)) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
undef
        MacroBodyStmt [Node iattr (Lexeme itext)]
stmts ->
            [Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext)
forall attr lexeme. [Node attr lexeme] -> Node attr lexeme
MacroBodyStmt ([Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
-> f [Node oattr (Lexeme otext)] -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Node iattr (Lexeme itext)] -> f [Node oattr (Lexeme otext)]
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse [Node iattr (Lexeme itext)]
stmts
        MacroBodyFunCall Node iattr (Lexeme itext)
expr ->
            Node oattr (Lexeme otext) -> Node oattr (Lexeme otext)
forall attr lexeme. Node attr lexeme -> Node attr lexeme
MacroBodyFunCall (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext)) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
expr
        MacroParam Lexeme itext
name ->
            Lexeme otext -> Node oattr (Lexeme otext)
forall attr lexeme. lexeme -> Node attr lexeme
MacroParam (Lexeme otext -> Node oattr (Lexeme otext))
-> f (Lexeme otext) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
name
        StaticAssert Node iattr (Lexeme itext)
cond Lexeme itext
msg ->
            Node oattr (Lexeme otext)
-> Lexeme otext -> Node oattr (Lexeme otext)
forall attr lexeme. Node attr lexeme -> lexeme -> Node attr lexeme
StaticAssert (Node oattr (Lexeme otext)
 -> Lexeme otext -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
-> f (Lexeme otext -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
cond f (Lexeme otext -> Node oattr (Lexeme otext))
-> f (Lexeme otext) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
msg
        LicenseDecl Lexeme itext
license [Node iattr (Lexeme itext)]
copyrights ->
            Lexeme otext
-> [Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext)
forall attr lexeme.
lexeme -> [Node attr lexeme] -> Node attr lexeme
LicenseDecl (Lexeme otext
 -> [Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
-> f (Lexeme otext)
-> f ([Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
license f ([Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
-> f [Node oattr (Lexeme otext)] -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Node iattr (Lexeme itext)] -> f [Node oattr (Lexeme otext)]
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse [Node iattr (Lexeme itext)]
copyrights
        CopyrightDecl Lexeme itext
from Maybe (Lexeme itext)
to [Lexeme itext]
owner ->
            Lexeme otext
-> Maybe (Lexeme otext)
-> [Lexeme otext]
-> Node oattr (Lexeme otext)
forall attr lexeme.
lexeme -> Maybe lexeme -> [lexeme] -> Node attr lexeme
CopyrightDecl (Lexeme otext
 -> Maybe (Lexeme otext)
 -> [Lexeme otext]
 -> Node oattr (Lexeme otext))
-> f (Lexeme otext)
-> f (Maybe (Lexeme otext)
      -> [Lexeme otext] -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
from f (Maybe (Lexeme otext)
   -> [Lexeme otext] -> Node oattr (Lexeme otext))
-> f (Maybe (Lexeme otext))
-> f ([Lexeme otext] -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe (Lexeme itext) -> f (Maybe (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Maybe (Lexeme itext)
to f ([Lexeme otext] -> Node oattr (Lexeme otext))
-> f [Lexeme otext] -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Lexeme itext] -> f [Lexeme otext]
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse [Lexeme itext]
owner
        Comment CommentStyle
doc Lexeme itext
start [Node iattr (Lexeme itext)]
contents Lexeme itext
end ->
            CommentStyle
-> Lexeme otext
-> [Node oattr (Lexeme otext)]
-> Lexeme otext
-> Node oattr (Lexeme otext)
forall attr lexeme.
CommentStyle
-> lexeme -> [Node attr lexeme] -> lexeme -> Node attr lexeme
Comment CommentStyle
doc (Lexeme otext
 -> [Node oattr (Lexeme otext)]
 -> Lexeme otext
 -> Node oattr (Lexeme otext))
-> f (Lexeme otext)
-> f ([Node oattr (Lexeme otext)]
      -> Lexeme otext -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
start f ([Node oattr (Lexeme otext)]
   -> Lexeme otext -> Node oattr (Lexeme otext))
-> f [Node oattr (Lexeme otext)]
-> f (Lexeme otext -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Node iattr (Lexeme itext)] -> f [Node oattr (Lexeme otext)]
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse [Node iattr (Lexeme itext)]
contents f (Lexeme otext -> Node oattr (Lexeme otext))
-> f (Lexeme otext) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
end
        CommentBlock Lexeme itext
comment ->
            Lexeme otext -> Node oattr (Lexeme otext)
forall attr lexeme. lexeme -> Node attr lexeme
CommentBlock (Lexeme otext -> Node oattr (Lexeme otext))
-> f (Lexeme otext) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
comment
        CommentWord Lexeme itext
word ->
            Lexeme otext -> Node oattr (Lexeme otext)
forall attr lexeme. lexeme -> Node attr lexeme
CommentWord (Lexeme otext -> Node oattr (Lexeme otext))
-> f (Lexeme otext) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
word
        Commented Node iattr (Lexeme itext)
comment Node iattr (Lexeme itext)
node ->
            Node oattr (Lexeme otext)
-> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext)
forall attr lexeme.
Node attr lexeme -> Node attr lexeme -> Node attr lexeme
Commented (Node oattr (Lexeme otext)
 -> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
comment f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext)) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
node
        ExternC [Node iattr (Lexeme itext)]
decls ->
            [Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext)
forall attr lexeme. [Node attr lexeme] -> Node attr lexeme
ExternC ([Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
-> f [Node oattr (Lexeme otext)] -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Node iattr (Lexeme itext)] -> f [Node oattr (Lexeme otext)]
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse [Node iattr (Lexeme itext)]
decls
        CompoundStmt [Node iattr (Lexeme itext)]
stmts ->
            [Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext)
forall attr lexeme. [Node attr lexeme] -> Node attr lexeme
CompoundStmt ([Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
-> f [Node oattr (Lexeme otext)] -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Node iattr (Lexeme itext)] -> f [Node oattr (Lexeme otext)]
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse [Node iattr (Lexeme itext)]
stmts
        Node iattr (Lexeme itext)
Break ->
            Node oattr (Lexeme otext) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a. Applicative f => a -> f a
pure Node oattr (Lexeme otext)
forall attr lexeme. Node attr lexeme
Break
        Goto Lexeme itext
label ->
            Lexeme otext -> Node oattr (Lexeme otext)
forall attr lexeme. lexeme -> Node attr lexeme
Goto (Lexeme otext -> Node oattr (Lexeme otext))
-> f (Lexeme otext) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
label
        Node iattr (Lexeme itext)
Continue ->
            Node oattr (Lexeme otext) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a. Applicative f => a -> f a
pure Node oattr (Lexeme otext)
forall attr lexeme. Node attr lexeme
Continue
        Return Maybe (Node iattr (Lexeme itext))
value ->
            Maybe (Node oattr (Lexeme otext)) -> Node oattr (Lexeme otext)
forall attr lexeme. Maybe (Node attr lexeme) -> Node attr lexeme
Return (Maybe (Node oattr (Lexeme otext)) -> Node oattr (Lexeme otext))
-> f (Maybe (Node oattr (Lexeme otext)))
-> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (Node iattr (Lexeme itext))
-> f (Maybe (Node oattr (Lexeme otext)))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Maybe (Node iattr (Lexeme itext))
value
        SwitchStmt Node iattr (Lexeme itext)
value [Node iattr (Lexeme itext)]
cases ->
            Node oattr (Lexeme otext)
-> [Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext)
forall attr lexeme.
Node attr lexeme -> [Node attr lexeme] -> Node attr lexeme
SwitchStmt (Node oattr (Lexeme otext)
 -> [Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
-> f ([Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
value f ([Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
-> f [Node oattr (Lexeme otext)] -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Node iattr (Lexeme itext)] -> f [Node oattr (Lexeme otext)]
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse [Node iattr (Lexeme itext)]
cases
        IfStmt Node iattr (Lexeme itext)
cond [Node iattr (Lexeme itext)]
thenStmts Maybe (Node iattr (Lexeme itext))
elseStmt ->
            Node oattr (Lexeme otext)
-> [Node oattr (Lexeme otext)]
-> Maybe (Node oattr (Lexeme otext))
-> Node oattr (Lexeme otext)
forall attr lexeme.
Node attr lexeme
-> [Node attr lexeme]
-> Maybe (Node attr lexeme)
-> Node attr lexeme
IfStmt (Node oattr (Lexeme otext)
 -> [Node oattr (Lexeme otext)]
 -> Maybe (Node oattr (Lexeme otext))
 -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
-> f ([Node oattr (Lexeme otext)]
      -> Maybe (Node oattr (Lexeme otext)) -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
cond f ([Node oattr (Lexeme otext)]
   -> Maybe (Node oattr (Lexeme otext)) -> Node oattr (Lexeme otext))
-> f [Node oattr (Lexeme otext)]
-> f (Maybe (Node oattr (Lexeme otext))
      -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Node iattr (Lexeme itext)] -> f [Node oattr (Lexeme otext)]
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse [Node iattr (Lexeme itext)]
thenStmts f (Maybe (Node oattr (Lexeme otext)) -> Node oattr (Lexeme otext))
-> f (Maybe (Node oattr (Lexeme otext)))
-> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe (Node iattr (Lexeme itext))
-> f (Maybe (Node oattr (Lexeme otext)))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Maybe (Node iattr (Lexeme itext))
elseStmt
        ForStmt Node iattr (Lexeme itext)
initStmt Node iattr (Lexeme itext)
cond Node iattr (Lexeme itext)
next [Node iattr (Lexeme itext)]
stmts ->
            Node oattr (Lexeme otext)
-> Node oattr (Lexeme otext)
-> Node oattr (Lexeme otext)
-> [Node oattr (Lexeme otext)]
-> Node oattr (Lexeme otext)
forall attr lexeme.
Node attr lexeme
-> Node attr lexeme
-> Node attr lexeme
-> [Node attr lexeme]
-> Node attr lexeme
ForStmt (Node oattr (Lexeme otext)
 -> Node oattr (Lexeme otext)
 -> Node oattr (Lexeme otext)
 -> [Node oattr (Lexeme otext)]
 -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext)
      -> Node oattr (Lexeme otext)
      -> [Node oattr (Lexeme otext)]
      -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
initStmt f (Node oattr (Lexeme otext)
   -> Node oattr (Lexeme otext)
   -> [Node oattr (Lexeme otext)]
   -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext)
      -> [Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
cond f (Node oattr (Lexeme otext)
   -> [Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
-> f ([Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
next f ([Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
-> f [Node oattr (Lexeme otext)] -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Node iattr (Lexeme itext)] -> f [Node oattr (Lexeme otext)]
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse [Node iattr (Lexeme itext)]
stmts
        WhileStmt Node iattr (Lexeme itext)
cond [Node iattr (Lexeme itext)]
stmts ->
            Node oattr (Lexeme otext)
-> [Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext)
forall attr lexeme.
Node attr lexeme -> [Node attr lexeme] -> Node attr lexeme
WhileStmt (Node oattr (Lexeme otext)
 -> [Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
-> f ([Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
cond f ([Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
-> f [Node oattr (Lexeme otext)] -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Node iattr (Lexeme itext)] -> f [Node oattr (Lexeme otext)]
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse [Node iattr (Lexeme itext)]
stmts
        DoWhileStmt [Node iattr (Lexeme itext)]
stmts Node iattr (Lexeme itext)
cond ->
            [Node oattr (Lexeme otext)]
-> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext)
forall attr lexeme.
[Node attr lexeme] -> Node attr lexeme -> Node attr lexeme
DoWhileStmt ([Node oattr (Lexeme otext)]
 -> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f [Node oattr (Lexeme otext)]
-> f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Node iattr (Lexeme itext)] -> f [Node oattr (Lexeme otext)]
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse [Node iattr (Lexeme itext)]
stmts f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext)) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
cond
        Case Node iattr (Lexeme itext)
value Node iattr (Lexeme itext)
stmt ->
            Node oattr (Lexeme otext)
-> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext)
forall attr lexeme.
Node attr lexeme -> Node attr lexeme -> Node attr lexeme
Case (Node oattr (Lexeme otext)
 -> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
value f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext)) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
stmt
        Default Node iattr (Lexeme itext)
stmt ->
            Node oattr (Lexeme otext) -> Node oattr (Lexeme otext)
forall attr lexeme. Node attr lexeme -> Node attr lexeme
Default (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext)) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
stmt
        Label Lexeme itext
label Node iattr (Lexeme itext)
stmt ->
            Lexeme otext
-> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext)
forall attr lexeme. lexeme -> Node attr lexeme -> Node attr lexeme
Label (Lexeme otext
 -> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Lexeme otext)
-> f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
label f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext)) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
stmt
        VLA Node iattr (Lexeme itext)
ty Lexeme itext
name Node iattr (Lexeme itext)
size ->
            Node oattr (Lexeme otext)
-> Lexeme otext
-> Node oattr (Lexeme otext)
-> Node oattr (Lexeme otext)
forall attr lexeme.
Node attr lexeme -> lexeme -> Node attr lexeme -> Node attr lexeme
VLA (Node oattr (Lexeme otext)
 -> Lexeme otext
 -> Node oattr (Lexeme otext)
 -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
-> f (Lexeme otext
      -> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
ty f (Lexeme otext
   -> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Lexeme otext)
-> f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
name f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext)) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
size
        VarDecl Node iattr (Lexeme itext)
ty Node iattr (Lexeme itext)
decl ->
            Node oattr (Lexeme otext)
-> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext)
forall attr lexeme.
Node attr lexeme -> Node attr lexeme -> Node attr lexeme
VarDecl (Node oattr (Lexeme otext)
 -> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
ty f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext)) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
decl
        Declarator Node iattr (Lexeme itext)
spec Maybe (Node iattr (Lexeme itext))
value ->
            Node oattr (Lexeme otext)
-> Maybe (Node oattr (Lexeme otext)) -> Node oattr (Lexeme otext)
forall attr lexeme.
Node attr lexeme -> Maybe (Node attr lexeme) -> Node attr lexeme
Declarator (Node oattr (Lexeme otext)
 -> Maybe (Node oattr (Lexeme otext)) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
-> f (Maybe (Node oattr (Lexeme otext))
      -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
spec f (Maybe (Node oattr (Lexeme otext)) -> Node oattr (Lexeme otext))
-> f (Maybe (Node oattr (Lexeme otext)))
-> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe (Node iattr (Lexeme itext))
-> f (Maybe (Node oattr (Lexeme otext)))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Maybe (Node iattr (Lexeme itext))
value
        DeclSpecVar Lexeme itext
name ->
            Lexeme otext -> Node oattr (Lexeme otext)
forall attr lexeme. lexeme -> Node attr lexeme
DeclSpecVar (Lexeme otext -> Node oattr (Lexeme otext))
-> f (Lexeme otext) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
name
        DeclSpecArray Node iattr (Lexeme itext)
spec Maybe (Node iattr (Lexeme itext))
size ->
            Node oattr (Lexeme otext)
-> Maybe (Node oattr (Lexeme otext)) -> Node oattr (Lexeme otext)
forall attr lexeme.
Node attr lexeme -> Maybe (Node attr lexeme) -> Node attr lexeme
DeclSpecArray (Node oattr (Lexeme otext)
 -> Maybe (Node oattr (Lexeme otext)) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
-> f (Maybe (Node oattr (Lexeme otext))
      -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
spec f (Maybe (Node oattr (Lexeme otext)) -> Node oattr (Lexeme otext))
-> f (Maybe (Node oattr (Lexeme otext)))
-> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe (Node iattr (Lexeme itext))
-> f (Maybe (Node oattr (Lexeme otext)))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Maybe (Node iattr (Lexeme itext))
size
        InitialiserList [Node iattr (Lexeme itext)]
values ->
            [Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext)
forall attr lexeme. [Node attr lexeme] -> Node attr lexeme
InitialiserList ([Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
-> f [Node oattr (Lexeme otext)] -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Node iattr (Lexeme itext)] -> f [Node oattr (Lexeme otext)]
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse [Node iattr (Lexeme itext)]
values
        UnaryExpr UnaryOp
op Node iattr (Lexeme itext)
expr ->
            UnaryOp -> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext)
forall attr lexeme. UnaryOp -> Node attr lexeme -> Node attr lexeme
UnaryExpr UnaryOp
op (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext)) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
expr
        BinaryExpr Node iattr (Lexeme itext)
lhs BinaryOp
op Node iattr (Lexeme itext)
rhs ->
            Node oattr (Lexeme otext)
-> BinaryOp
-> Node oattr (Lexeme otext)
-> Node oattr (Lexeme otext)
forall attr lexeme.
Node attr lexeme
-> BinaryOp -> Node attr lexeme -> Node attr lexeme
BinaryExpr (Node oattr (Lexeme otext)
 -> BinaryOp
 -> Node oattr (Lexeme otext)
 -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
-> f (BinaryOp
      -> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
lhs f (BinaryOp
   -> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f BinaryOp
-> f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> BinaryOp -> f BinaryOp
forall (f :: * -> *) a. Applicative f => a -> f a
pure BinaryOp
op f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext)) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
rhs
        TernaryExpr Node iattr (Lexeme itext)
cond Node iattr (Lexeme itext)
thenExpr Node iattr (Lexeme itext)
elseExpr ->
            Node oattr (Lexeme otext)
-> Node oattr (Lexeme otext)
-> Node oattr (Lexeme otext)
-> Node oattr (Lexeme otext)
forall attr lexeme.
Node attr lexeme
-> Node attr lexeme -> Node attr lexeme -> Node attr lexeme
TernaryExpr (Node oattr (Lexeme otext)
 -> Node oattr (Lexeme otext)
 -> Node oattr (Lexeme otext)
 -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext)
      -> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
cond f (Node oattr (Lexeme otext)
   -> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
thenExpr f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext)) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
elseExpr
        AssignExpr Node iattr (Lexeme itext)
lhs AssignOp
op Node iattr (Lexeme itext)
rhs ->
            Node oattr (Lexeme otext)
-> AssignOp
-> Node oattr (Lexeme otext)
-> Node oattr (Lexeme otext)
forall attr lexeme.
Node attr lexeme
-> AssignOp -> Node attr lexeme -> Node attr lexeme
AssignExpr (Node oattr (Lexeme otext)
 -> AssignOp
 -> Node oattr (Lexeme otext)
 -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
-> f (AssignOp
      -> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
lhs f (AssignOp
   -> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f AssignOp
-> f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> AssignOp -> f AssignOp
forall (f :: * -> *) a. Applicative f => a -> f a
pure AssignOp
op f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext)) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
rhs
        ParenExpr Node iattr (Lexeme itext)
expr ->
            Node oattr (Lexeme otext) -> Node oattr (Lexeme otext)
forall attr lexeme. Node attr lexeme -> Node attr lexeme
ParenExpr (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext)) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
expr
        CastExpr Node iattr (Lexeme itext)
ty Node iattr (Lexeme itext)
expr ->
            Node oattr (Lexeme otext)
-> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext)
forall attr lexeme.
Node attr lexeme -> Node attr lexeme -> Node attr lexeme
CastExpr (Node oattr (Lexeme otext)
 -> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
ty f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext)) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
expr
        CompoundExpr Node iattr (Lexeme itext)
ty Node iattr (Lexeme itext)
expr ->
            Node oattr (Lexeme otext)
-> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext)
forall attr lexeme.
Node attr lexeme -> Node attr lexeme -> Node attr lexeme
CompoundExpr (Node oattr (Lexeme otext)
 -> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
ty f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext)) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
expr
        SizeofExpr Node iattr (Lexeme itext)
expr ->
            Node oattr (Lexeme otext) -> Node oattr (Lexeme otext)
forall attr lexeme. Node attr lexeme -> Node attr lexeme
SizeofExpr (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext)) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
expr
        SizeofType Node iattr (Lexeme itext)
ty ->
            Node oattr (Lexeme otext) -> Node oattr (Lexeme otext)
forall attr lexeme. Node attr lexeme -> Node attr lexeme
SizeofType (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext)) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
ty
        LiteralExpr LiteralType
ty Lexeme itext
value ->
            LiteralType -> Lexeme otext -> Node oattr (Lexeme otext)
forall attr lexeme. LiteralType -> lexeme -> Node attr lexeme
LiteralExpr LiteralType
ty (Lexeme otext -> Node oattr (Lexeme otext))
-> f (Lexeme otext) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
value
        VarExpr Lexeme itext
name ->
            Lexeme otext -> Node oattr (Lexeme otext)
forall attr lexeme. lexeme -> Node attr lexeme
VarExpr (Lexeme otext -> Node oattr (Lexeme otext))
-> f (Lexeme otext) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
name
        MemberAccess Node iattr (Lexeme itext)
name Lexeme itext
field ->
            Node oattr (Lexeme otext)
-> Lexeme otext -> Node oattr (Lexeme otext)
forall attr lexeme. Node attr lexeme -> lexeme -> Node attr lexeme
MemberAccess (Node oattr (Lexeme otext)
 -> Lexeme otext -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
-> f (Lexeme otext -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
name f (Lexeme otext -> Node oattr (Lexeme otext))
-> f (Lexeme otext) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
field
        PointerAccess Node iattr (Lexeme itext)
name Lexeme itext
field ->
            Node oattr (Lexeme otext)
-> Lexeme otext -> Node oattr (Lexeme otext)
forall attr lexeme. Node attr lexeme -> lexeme -> Node attr lexeme
PointerAccess (Node oattr (Lexeme otext)
 -> Lexeme otext -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
-> f (Lexeme otext -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
name f (Lexeme otext -> Node oattr (Lexeme otext))
-> f (Lexeme otext) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
field
        ArrayAccess Node iattr (Lexeme itext)
arr Node iattr (Lexeme itext)
idx ->
            Node oattr (Lexeme otext)
-> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext)
forall attr lexeme.
Node attr lexeme -> Node attr lexeme -> Node attr lexeme
ArrayAccess (Node oattr (Lexeme otext)
 -> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
arr f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext)) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
idx
        FunctionCall Node iattr (Lexeme itext)
callee [Node iattr (Lexeme itext)]
args ->
            Node oattr (Lexeme otext)
-> [Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext)
forall attr lexeme.
Node attr lexeme -> [Node attr lexeme] -> Node attr lexeme
FunctionCall (Node oattr (Lexeme otext)
 -> [Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
-> f ([Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
callee f ([Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
-> f [Node oattr (Lexeme otext)] -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Node iattr (Lexeme itext)] -> f [Node oattr (Lexeme otext)]
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse [Node iattr (Lexeme itext)]
args
        CommentExpr Node iattr (Lexeme itext)
comment Node iattr (Lexeme itext)
expr ->
            Node oattr (Lexeme otext)
-> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext)
forall attr lexeme.
Node attr lexeme -> Node attr lexeme -> Node attr lexeme
CommentExpr (Node oattr (Lexeme otext)
 -> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
comment f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext)) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
expr
        EnumClass Lexeme itext
name [Node iattr (Lexeme itext)]
members ->
            Lexeme otext
-> [Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext)
forall attr lexeme.
lexeme -> [Node attr lexeme] -> Node attr lexeme
EnumClass (Lexeme otext
 -> [Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
-> f (Lexeme otext)
-> f ([Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
name f ([Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
-> f [Node oattr (Lexeme otext)] -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Node iattr (Lexeme itext)] -> f [Node oattr (Lexeme otext)]
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse [Node iattr (Lexeme itext)]
members
        EnumConsts Maybe (Lexeme itext)
name [Node iattr (Lexeme itext)]
members ->
            Maybe (Lexeme otext)
-> [Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext)
forall attr lexeme.
Maybe lexeme -> [Node attr lexeme] -> Node attr lexeme
EnumConsts (Maybe (Lexeme otext)
 -> [Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
-> f (Maybe (Lexeme otext))
-> f ([Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (Lexeme itext) -> f (Maybe (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Maybe (Lexeme itext)
name f ([Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
-> f [Node oattr (Lexeme otext)] -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Node iattr (Lexeme itext)] -> f [Node oattr (Lexeme otext)]
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse [Node iattr (Lexeme itext)]
members
        EnumDecl Lexeme itext
name [Node iattr (Lexeme itext)]
members Lexeme itext
tyName ->
            Lexeme otext
-> [Node oattr (Lexeme otext)]
-> Lexeme otext
-> Node oattr (Lexeme otext)
forall attr lexeme.
lexeme -> [Node attr lexeme] -> lexeme -> Node attr lexeme
EnumDecl (Lexeme otext
 -> [Node oattr (Lexeme otext)]
 -> Lexeme otext
 -> Node oattr (Lexeme otext))
-> f (Lexeme otext)
-> f ([Node oattr (Lexeme otext)]
      -> Lexeme otext -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
name f ([Node oattr (Lexeme otext)]
   -> Lexeme otext -> Node oattr (Lexeme otext))
-> f [Node oattr (Lexeme otext)]
-> f (Lexeme otext -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Node iattr (Lexeme itext)] -> f [Node oattr (Lexeme otext)]
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse [Node iattr (Lexeme itext)]
members f (Lexeme otext -> Node oattr (Lexeme otext))
-> f (Lexeme otext) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
tyName
        Enumerator Lexeme itext
name Maybe (Node iattr (Lexeme itext))
value ->
            Lexeme otext
-> Maybe (Node oattr (Lexeme otext)) -> Node oattr (Lexeme otext)
forall attr lexeme.
lexeme -> Maybe (Node attr lexeme) -> Node attr lexeme
Enumerator (Lexeme otext
 -> Maybe (Node oattr (Lexeme otext)) -> Node oattr (Lexeme otext))
-> f (Lexeme otext)
-> f (Maybe (Node oattr (Lexeme otext))
      -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
name f (Maybe (Node oattr (Lexeme otext)) -> Node oattr (Lexeme otext))
-> f (Maybe (Node oattr (Lexeme otext)))
-> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe (Node iattr (Lexeme itext))
-> f (Maybe (Node oattr (Lexeme otext)))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Maybe (Node iattr (Lexeme itext))
value
        Typedef Node iattr (Lexeme itext)
ty Lexeme itext
name ->
            Node oattr (Lexeme otext)
-> Lexeme otext -> Node oattr (Lexeme otext)
forall attr lexeme. Node attr lexeme -> lexeme -> Node attr lexeme
Typedef (Node oattr (Lexeme otext)
 -> Lexeme otext -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
-> f (Lexeme otext -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
ty f (Lexeme otext -> Node oattr (Lexeme otext))
-> f (Lexeme otext) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
name
        TypedefFunction Node iattr (Lexeme itext)
ty ->
            Node oattr (Lexeme otext) -> Node oattr (Lexeme otext)
forall attr lexeme. Node attr lexeme -> Node attr lexeme
TypedefFunction (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext)) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
ty
        Namespace Scope
scope Lexeme itext
name [Node iattr (Lexeme itext)]
members ->
            Scope
-> Lexeme otext
-> [Node oattr (Lexeme otext)]
-> Node oattr (Lexeme otext)
forall attr lexeme.
Scope -> lexeme -> [Node attr lexeme] -> Node attr lexeme
Namespace Scope
scope (Lexeme otext
 -> [Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
-> f (Lexeme otext)
-> f ([Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
name f ([Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
-> f [Node oattr (Lexeme otext)] -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Node iattr (Lexeme itext)] -> f [Node oattr (Lexeme otext)]
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse [Node iattr (Lexeme itext)]
members
        Class Scope
scope Lexeme itext
name [Node iattr (Lexeme itext)]
tyvars [Node iattr (Lexeme itext)]
members ->
            Scope
-> Lexeme otext
-> [Node oattr (Lexeme otext)]
-> [Node oattr (Lexeme otext)]
-> Node oattr (Lexeme otext)
forall attr lexeme.
Scope
-> lexeme
-> [Node attr lexeme]
-> [Node attr lexeme]
-> Node attr lexeme
Class Scope
scope (Lexeme otext
 -> [Node oattr (Lexeme otext)]
 -> [Node oattr (Lexeme otext)]
 -> Node oattr (Lexeme otext))
-> f (Lexeme otext)
-> f ([Node oattr (Lexeme otext)]
      -> [Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
name f ([Node oattr (Lexeme otext)]
   -> [Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
-> f [Node oattr (Lexeme otext)]
-> f ([Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Node iattr (Lexeme itext)] -> f [Node oattr (Lexeme otext)]
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse [Node iattr (Lexeme itext)]
tyvars f ([Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
-> f [Node oattr (Lexeme otext)] -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Node iattr (Lexeme itext)] -> f [Node oattr (Lexeme otext)]
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse [Node iattr (Lexeme itext)]
members
        ClassForward Lexeme itext
name [Node iattr (Lexeme itext)]
tyvars ->
            Lexeme otext
-> [Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext)
forall attr lexeme.
lexeme -> [Node attr lexeme] -> Node attr lexeme
ClassForward (Lexeme otext
 -> [Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
-> f (Lexeme otext)
-> f ([Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
name f ([Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
-> f [Node oattr (Lexeme otext)] -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Node iattr (Lexeme itext)] -> f [Node oattr (Lexeme otext)]
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse [Node iattr (Lexeme itext)]
tyvars
        Struct Lexeme itext
name [Node iattr (Lexeme itext)]
members ->
            Lexeme otext
-> [Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext)
forall attr lexeme.
lexeme -> [Node attr lexeme] -> Node attr lexeme
Struct (Lexeme otext
 -> [Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
-> f (Lexeme otext)
-> f ([Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
name f ([Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
-> f [Node oattr (Lexeme otext)] -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Node iattr (Lexeme itext)] -> f [Node oattr (Lexeme otext)]
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse [Node iattr (Lexeme itext)]
members
        Union Lexeme itext
name [Node iattr (Lexeme itext)]
members ->
            Lexeme otext
-> [Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext)
forall attr lexeme.
lexeme -> [Node attr lexeme] -> Node attr lexeme
Union (Lexeme otext
 -> [Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
-> f (Lexeme otext)
-> f ([Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
name f ([Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
-> f [Node oattr (Lexeme otext)] -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Node iattr (Lexeme itext)] -> f [Node oattr (Lexeme otext)]
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse [Node iattr (Lexeme itext)]
members
        MemberDecl Node iattr (Lexeme itext)
ty Node iattr (Lexeme itext)
decl Maybe (Lexeme itext)
width ->
            Node oattr (Lexeme otext)
-> Node oattr (Lexeme otext)
-> Maybe (Lexeme otext)
-> Node oattr (Lexeme otext)
forall attr lexeme.
Node attr lexeme
-> Node attr lexeme -> Maybe lexeme -> Node attr lexeme
MemberDecl (Node oattr (Lexeme otext)
 -> Node oattr (Lexeme otext)
 -> Maybe (Lexeme otext)
 -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext)
      -> Maybe (Lexeme otext) -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
ty f (Node oattr (Lexeme otext)
   -> Maybe (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
-> f (Maybe (Lexeme otext) -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
decl f (Maybe (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Maybe (Lexeme otext)) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe (Lexeme itext) -> f (Maybe (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Maybe (Lexeme itext)
width
        TyConst Node iattr (Lexeme itext)
ty ->
            Node oattr (Lexeme otext) -> Node oattr (Lexeme otext)
forall attr lexeme. Node attr lexeme -> Node attr lexeme
TyConst (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext)) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
ty
        TyPointer Node iattr (Lexeme itext)
ty ->
            Node oattr (Lexeme otext) -> Node oattr (Lexeme otext)
forall attr lexeme. Node attr lexeme -> Node attr lexeme
TyPointer (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext)) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
ty
        TyStruct Lexeme itext
name ->
            Lexeme otext -> Node oattr (Lexeme otext)
forall attr lexeme. lexeme -> Node attr lexeme
TyStruct (Lexeme otext -> Node oattr (Lexeme otext))
-> f (Lexeme otext) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
name
        TyFunc Lexeme itext
name ->
            Lexeme otext -> Node oattr (Lexeme otext)
forall attr lexeme. lexeme -> Node attr lexeme
TyFunc (Lexeme otext -> Node oattr (Lexeme otext))
-> f (Lexeme otext) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
name
        TyVar Lexeme itext
name ->
            Lexeme otext -> Node oattr (Lexeme otext)
forall attr lexeme. lexeme -> Node attr lexeme
TyVar (Lexeme otext -> Node oattr (Lexeme otext))
-> f (Lexeme otext) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
name
        TyStd Lexeme itext
name ->
            Lexeme otext -> Node oattr (Lexeme otext)
forall attr lexeme. lexeme -> Node attr lexeme
TyStd (Lexeme otext -> Node oattr (Lexeme otext))
-> f (Lexeme otext) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
name
        TyUserDefined Lexeme itext
name ->
            Lexeme otext -> Node oattr (Lexeme otext)
forall attr lexeme. lexeme -> Node attr lexeme
TyUserDefined (Lexeme otext -> Node oattr (Lexeme otext))
-> f (Lexeme otext) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
name
        FunctionDecl Scope
scope Node iattr (Lexeme itext)
proto Maybe (Node iattr (Lexeme itext))
errors ->
            Scope
-> Node oattr (Lexeme otext)
-> Maybe (Node oattr (Lexeme otext))
-> Node oattr (Lexeme otext)
forall attr lexeme.
Scope
-> Node attr lexeme -> Maybe (Node attr lexeme) -> Node attr lexeme
FunctionDecl Scope
scope (Node oattr (Lexeme otext)
 -> Maybe (Node oattr (Lexeme otext)) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
-> f (Maybe (Node oattr (Lexeme otext))
      -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
proto f (Maybe (Node oattr (Lexeme otext)) -> Node oattr (Lexeme otext))
-> f (Maybe (Node oattr (Lexeme otext)))
-> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe (Node iattr (Lexeme itext))
-> f (Maybe (Node oattr (Lexeme otext)))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Maybe (Node iattr (Lexeme itext))
errors
        FunctionDefn Scope
scope Node iattr (Lexeme itext)
proto [Node iattr (Lexeme itext)]
body ->
            Scope
-> Node oattr (Lexeme otext)
-> [Node oattr (Lexeme otext)]
-> Node oattr (Lexeme otext)
forall attr lexeme.
Scope -> Node attr lexeme -> [Node attr lexeme] -> Node attr lexeme
FunctionDefn Scope
scope (Node oattr (Lexeme otext)
 -> [Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
-> f ([Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
proto f ([Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
-> f [Node oattr (Lexeme otext)] -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Node iattr (Lexeme itext)] -> f [Node oattr (Lexeme otext)]
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse [Node iattr (Lexeme itext)]
body
        FunctionPrototype Node iattr (Lexeme itext)
ty Lexeme itext
name [Node iattr (Lexeme itext)]
params ->
            Node oattr (Lexeme otext)
-> Lexeme otext
-> [Node oattr (Lexeme otext)]
-> Node oattr (Lexeme otext)
forall attr lexeme.
Node attr lexeme
-> lexeme -> [Node attr lexeme] -> Node attr lexeme
FunctionPrototype (Node oattr (Lexeme otext)
 -> Lexeme otext
 -> [Node oattr (Lexeme otext)]
 -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
-> f (Lexeme otext
      -> [Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
ty f (Lexeme otext
   -> [Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
-> f (Lexeme otext)
-> f ([Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
name f ([Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
-> f [Node oattr (Lexeme otext)] -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Node iattr (Lexeme itext)] -> f [Node oattr (Lexeme otext)]
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse [Node iattr (Lexeme itext)]
params
        FunctionParam Node iattr (Lexeme itext)
ty Node iattr (Lexeme itext)
decl ->
            Node oattr (Lexeme otext)
-> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext)
forall attr lexeme.
Node attr lexeme -> Node attr lexeme -> Node attr lexeme
FunctionParam (Node oattr (Lexeme otext)
 -> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
ty f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext)) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
decl
        Event Lexeme itext
name Node iattr (Lexeme itext)
params ->
            Lexeme otext
-> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext)
forall attr lexeme. lexeme -> Node attr lexeme -> Node attr lexeme
Event (Lexeme otext
 -> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Lexeme otext)
-> f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
name f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext)) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
params
        EventParams [Node iattr (Lexeme itext)]
params ->
            [Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext)
forall attr lexeme. [Node attr lexeme] -> Node attr lexeme
EventParams ([Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
-> f [Node oattr (Lexeme otext)] -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Node iattr (Lexeme itext)] -> f [Node oattr (Lexeme otext)]
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse [Node iattr (Lexeme itext)]
params
        Property Node iattr (Lexeme itext)
ty Node iattr (Lexeme itext)
decl [Node iattr (Lexeme itext)]
accessors ->
            Node oattr (Lexeme otext)
-> Node oattr (Lexeme otext)
-> [Node oattr (Lexeme otext)]
-> Node oattr (Lexeme otext)
forall attr lexeme.
Node attr lexeme
-> Node attr lexeme -> [Node attr lexeme] -> Node attr lexeme
Property (Node oattr (Lexeme otext)
 -> Node oattr (Lexeme otext)
 -> [Node oattr (Lexeme otext)]
 -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext)
      -> [Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
ty f (Node oattr (Lexeme otext)
   -> [Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
-> f ([Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
decl f ([Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
-> f [Node oattr (Lexeme otext)] -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Node iattr (Lexeme itext)] -> f [Node oattr (Lexeme otext)]
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse [Node iattr (Lexeme itext)]
accessors
        Accessor Lexeme itext
name [Node iattr (Lexeme itext)]
params Maybe (Node iattr (Lexeme itext))
errors ->
            Lexeme otext
-> [Node oattr (Lexeme otext)]
-> Maybe (Node oattr (Lexeme otext))
-> Node oattr (Lexeme otext)
forall attr lexeme.
lexeme
-> [Node attr lexeme]
-> Maybe (Node attr lexeme)
-> Node attr lexeme
Accessor (Lexeme otext
 -> [Node oattr (Lexeme otext)]
 -> Maybe (Node oattr (Lexeme otext))
 -> Node oattr (Lexeme otext))
-> f (Lexeme otext)
-> f ([Node oattr (Lexeme otext)]
      -> Maybe (Node oattr (Lexeme otext)) -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
name f ([Node oattr (Lexeme otext)]
   -> Maybe (Node oattr (Lexeme otext)) -> Node oattr (Lexeme otext))
-> f [Node oattr (Lexeme otext)]
-> f (Maybe (Node oattr (Lexeme otext))
      -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Node iattr (Lexeme itext)] -> f [Node oattr (Lexeme otext)]
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse [Node iattr (Lexeme itext)]
params f (Maybe (Node oattr (Lexeme otext)) -> Node oattr (Lexeme otext))
-> f (Maybe (Node oattr (Lexeme otext)))
-> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe (Node iattr (Lexeme itext))
-> f (Maybe (Node oattr (Lexeme otext)))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Maybe (Node iattr (Lexeme itext))
errors
        ErrorDecl Lexeme itext
name [Node iattr (Lexeme itext)]
errors ->
            Lexeme otext
-> [Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext)
forall attr lexeme.
lexeme -> [Node attr lexeme] -> Node attr lexeme
ErrorDecl (Lexeme otext
 -> [Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
-> f (Lexeme otext)
-> f ([Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
name f ([Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
-> f [Node oattr (Lexeme otext)] -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Node iattr (Lexeme itext)] -> f [Node oattr (Lexeme otext)]
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse [Node iattr (Lexeme itext)]
errors
        ErrorList [Node iattr (Lexeme itext)]
errors ->
            [Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext)
forall attr lexeme. [Node attr lexeme] -> Node attr lexeme
ErrorList ([Node oattr (Lexeme otext)] -> Node oattr (Lexeme otext))
-> f [Node oattr (Lexeme otext)] -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Node iattr (Lexeme itext)] -> f [Node oattr (Lexeme otext)]
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse [Node iattr (Lexeme itext)]
errors
        ErrorFor Lexeme itext
name ->
            Lexeme otext -> Node oattr (Lexeme otext)
forall attr lexeme. lexeme -> Node attr lexeme
ErrorFor (Lexeme otext -> Node oattr (Lexeme otext))
-> f (Lexeme otext) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
name
        Node iattr (Lexeme itext)
Ellipsis ->
            Node oattr (Lexeme otext) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a. Applicative f => a -> f a
pure Node oattr (Lexeme otext)
forall attr lexeme. Node attr lexeme
Ellipsis
        ConstDecl Node iattr (Lexeme itext)
ty Lexeme itext
name ->
            Node oattr (Lexeme otext)
-> Lexeme otext -> Node oattr (Lexeme otext)
forall attr lexeme. Node attr lexeme -> lexeme -> Node attr lexeme
ConstDecl (Node oattr (Lexeme otext)
 -> Lexeme otext -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
-> f (Lexeme otext -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
ty f (Lexeme otext -> Node oattr (Lexeme otext))
-> f (Lexeme otext) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
name
        ConstDefn Scope
scope Node iattr (Lexeme itext)
ty Lexeme itext
name Node iattr (Lexeme itext)
value ->
            Scope
-> Node oattr (Lexeme otext)
-> Lexeme otext
-> Node oattr (Lexeme otext)
-> Node oattr (Lexeme otext)
forall attr lexeme.
Scope
-> Node attr lexeme
-> lexeme
-> Node attr lexeme
-> Node attr lexeme
ConstDefn Scope
scope (Node oattr (Lexeme otext)
 -> Lexeme otext
 -> Node oattr (Lexeme otext)
 -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
-> f (Lexeme otext
      -> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
ty f (Lexeme otext
   -> Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Lexeme otext)
-> f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Lexeme itext -> f (Lexeme otext)
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Lexeme itext
name f (Node oattr (Lexeme otext) -> Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext)) -> f (Node oattr (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall a b. TraverseAst iattr oattr itext otext a b => a -> f b
recurse Node iattr (Lexeme itext)
value

      where
        recurse :: TraverseAst iattr oattr itext otext a b => a -> f b
        recurse :: a -> f b
recurse = AstActions f iattr oattr itext otext -> a -> f b
forall iattr oattr itext otext a b (f :: * -> *).
(TraverseAst iattr oattr itext otext a b, Applicative f) =>
AstActions f iattr oattr itext otext -> a -> f b
mapAst AstActions f iattr oattr itext otext
actions

instance TraverseAst iattr oattr itext otext [Node iattr (Lexeme itext)]
                                             [Node oattr (Lexeme otext)] where
    mapAst :: AstActions f iattr oattr itext otext
-> [Node iattr (Lexeme itext)] -> f [Node oattr (Lexeme otext)]
mapAst actions :: AstActions f iattr oattr itext otext
actions@AstActions{FilePath
FilePath -> iattr -> f oattr
FilePath -> itext -> f otext
FilePath
-> [Node iattr (Lexeme itext)]
-> f [Node oattr (Lexeme otext)]
-> f [Node oattr (Lexeme otext)]
FilePath -> [Lexeme itext] -> f [Lexeme otext] -> f [Lexeme otext]
FilePath
-> Node iattr (Lexeme itext)
-> f (Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
FilePath -> Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext)
[(FilePath, [Node iattr (Lexeme itext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
(FilePath, [Node iattr (Lexeme itext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
doAttr :: FilePath -> iattr -> f oattr
doText :: FilePath -> itext -> f otext
doLexeme :: FilePath -> Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext)
doLexemes :: FilePath -> [Lexeme itext] -> f [Lexeme otext] -> f [Lexeme otext]
doNode :: FilePath
-> Node iattr (Lexeme itext)
-> f (Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
doNodes :: FilePath
-> [Node iattr (Lexeme itext)]
-> f [Node oattr (Lexeme otext)]
-> f [Node oattr (Lexeme otext)]
doFile :: (FilePath, [Node iattr (Lexeme itext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
doFiles :: [(FilePath, [Node iattr (Lexeme itext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
currentFile :: FilePath
currentFile :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext -> FilePath
doAttr :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> FilePath -> iattr -> f oattr
doText :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> FilePath -> itext -> f otext
doLexeme :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> FilePath -> Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext)
doLexemes :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> FilePath
-> [Lexeme itext]
-> f [Lexeme otext]
-> f [Lexeme otext]
doNode :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> FilePath
-> Node iattr (Lexeme itext)
-> f (Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
doNodes :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> FilePath
-> [Node iattr (Lexeme itext)]
-> f [Node oattr (Lexeme otext)]
-> f [Node oattr (Lexeme otext)]
doFile :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> (FilePath, [Node iattr (Lexeme itext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
doFiles :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> [(FilePath, [Node iattr (Lexeme itext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
..} = FilePath
-> [Node iattr (Lexeme itext)]
-> f [Node oattr (Lexeme otext)]
-> f [Node oattr (Lexeme otext)]
doNodes FilePath
currentFile ([Node iattr (Lexeme itext)]
 -> f [Node oattr (Lexeme otext)] -> f [Node oattr (Lexeme otext)])
-> ([Node iattr (Lexeme itext)] -> f [Node oattr (Lexeme otext)])
-> [Node iattr (Lexeme itext)]
-> f [Node oattr (Lexeme otext)]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
        (Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext)))
-> [Node iattr (Lexeme itext)] -> f [Node oattr (Lexeme otext)]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (AstActions f iattr oattr itext otext
-> Node iattr (Lexeme itext) -> f (Node oattr (Lexeme otext))
forall iattr oattr itext otext a b (f :: * -> *).
(TraverseAst iattr oattr itext otext a b, Applicative f) =>
AstActions f iattr oattr itext otext -> a -> f b
mapAst AstActions f iattr oattr itext otext
actions)

instance TraverseAst iattr oattr itext otext (FilePath, [Node iattr (Lexeme itext)])
                                             (FilePath, [Node oattr (Lexeme otext)]) where
    mapAst :: AstActions f iattr oattr itext otext
-> (FilePath, [Node iattr (Lexeme itext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
mapAst actions :: AstActions f iattr oattr itext otext
actions@AstActions{(FilePath, [Node iattr (Lexeme itext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
doFile :: (FilePath, [Node iattr (Lexeme itext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
doFile :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> (FilePath, [Node iattr (Lexeme itext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
doFile} tu :: (FilePath, [Node iattr (Lexeme itext)])
tu@(FilePath
currentFile, [Node iattr (Lexeme itext)]
_) = (FilePath, [Node iattr (Lexeme itext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
doFile ((FilePath, [Node iattr (Lexeme itext)])
 -> f (FilePath, [Node oattr (Lexeme otext)])
 -> f (FilePath, [Node oattr (Lexeme otext)]))
-> ((FilePath, [Node iattr (Lexeme itext)])
    -> f (FilePath, [Node oattr (Lexeme otext)]))
-> (FilePath, [Node iattr (Lexeme itext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
        ([Node iattr (Lexeme itext)] -> f [Node oattr (Lexeme otext)])
-> (FilePath, [Node iattr (Lexeme itext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (AstActions f iattr oattr itext otext
-> [Node iattr (Lexeme itext)] -> f [Node oattr (Lexeme otext)]
forall iattr oattr itext otext a b (f :: * -> *).
(TraverseAst iattr oattr itext otext a b, Applicative f) =>
AstActions f iattr oattr itext otext -> a -> f b
mapAst AstActions f iattr oattr itext otext
actions{FilePath
currentFile :: FilePath
currentFile :: FilePath
currentFile}) ((FilePath, [Node iattr (Lexeme itext)])
 -> f (FilePath, [Node oattr (Lexeme otext)]))
-> (FilePath, [Node iattr (Lexeme itext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
forall a b. (a -> b) -> a -> b
$ (FilePath, [Node iattr (Lexeme itext)])
tu

instance TraverseAst iattr oattr itext otext [(FilePath, [Node iattr (Lexeme itext)])]
                                             [(FilePath, [Node oattr (Lexeme otext)])] where
    mapAst :: AstActions f iattr oattr itext otext
-> [(FilePath, [Node iattr (Lexeme itext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
mapAst actions :: AstActions f iattr oattr itext otext
actions@AstActions{FilePath
FilePath -> iattr -> f oattr
FilePath -> itext -> f otext
FilePath
-> [Node iattr (Lexeme itext)]
-> f [Node oattr (Lexeme otext)]
-> f [Node oattr (Lexeme otext)]
FilePath -> [Lexeme itext] -> f [Lexeme otext] -> f [Lexeme otext]
FilePath
-> Node iattr (Lexeme itext)
-> f (Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
FilePath -> Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext)
[(FilePath, [Node iattr (Lexeme itext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
(FilePath, [Node iattr (Lexeme itext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
doAttr :: FilePath -> iattr -> f oattr
doText :: FilePath -> itext -> f otext
doLexeme :: FilePath -> Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext)
doLexemes :: FilePath -> [Lexeme itext] -> f [Lexeme otext] -> f [Lexeme otext]
doNode :: FilePath
-> Node iattr (Lexeme itext)
-> f (Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
doNodes :: FilePath
-> [Node iattr (Lexeme itext)]
-> f [Node oattr (Lexeme otext)]
-> f [Node oattr (Lexeme otext)]
doFile :: (FilePath, [Node iattr (Lexeme itext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
doFiles :: [(FilePath, [Node iattr (Lexeme itext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
currentFile :: FilePath
currentFile :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext -> FilePath
doAttr :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> FilePath -> iattr -> f oattr
doText :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> FilePath -> itext -> f otext
doLexeme :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> FilePath -> Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext)
doLexemes :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> FilePath
-> [Lexeme itext]
-> f [Lexeme otext]
-> f [Lexeme otext]
doNode :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> FilePath
-> Node iattr (Lexeme itext)
-> f (Node oattr (Lexeme otext))
-> f (Node oattr (Lexeme otext))
doNodes :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> FilePath
-> [Node iattr (Lexeme itext)]
-> f [Node oattr (Lexeme otext)]
-> f [Node oattr (Lexeme otext)]
doFile :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> (FilePath, [Node iattr (Lexeme itext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
doFiles :: forall (f :: * -> *) iattr oattr itext otext.
AstActions f iattr oattr itext otext
-> [(FilePath, [Node iattr (Lexeme itext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
..} = [(FilePath, [Node iattr (Lexeme itext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
doFiles ([(FilePath, [Node iattr (Lexeme itext)])]
 -> f [(FilePath, [Node oattr (Lexeme otext)])]
 -> f [(FilePath, [Node oattr (Lexeme otext)])])
-> ([(FilePath, [Node iattr (Lexeme itext)])]
    -> f [(FilePath, [Node oattr (Lexeme otext)])])
-> [(FilePath, [Node iattr (Lexeme itext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
        ((FilePath, [Node iattr (Lexeme itext)])
 -> f (FilePath, [Node oattr (Lexeme otext)]))
-> [(FilePath, [Node iattr (Lexeme itext)])]
-> f [(FilePath, [Node oattr (Lexeme otext)])]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (AstActions f iattr oattr itext otext
-> (FilePath, [Node iattr (Lexeme itext)])
-> f (FilePath, [Node oattr (Lexeme otext)])
forall iattr oattr itext otext a b (f :: * -> *).
(TraverseAst iattr oattr itext otext a b, Applicative f) =>
AstActions f iattr oattr itext otext -> a -> f b
mapAst AstActions f iattr oattr itext otext
actions)