{-# LANGUAGE FlexibleInstances     #-}
{-# LANGUAGE InstanceSigs          #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE RecordWildCards       #-}
{-# LANGUAGE ScopedTypeVariables   #-}
{-# LANGUAGE Strict                #-}
{-# LANGUAGE StrictData            #-}
{-# LANGUAGE TypeFamilies          #-}
module Language.Cimple.MapAst
    ( mapAst

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

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

import           Data.Fix              (Fix (..))
import           Language.Cimple.Ast   (Node, NodeF (..))
import           Language.Cimple.Lexer (Lexeme (..))

class MapAst itext otext a where
    type Mapped itext otext a
    mapFileAst
        :: Applicative f
        => AstActions f itext otext
        -> FilePath
        -> a
        -> f (Mapped itext otext a)

mapAst
    :: (MapAst itext otext    a, Applicative f)
    => AstActions f itext otext -> a
    -> f    (Mapped itext otext    a)
mapAst :: forall itext otext a (f :: * -> *).
(MapAst itext otext a, Applicative f) =>
AstActions f itext otext -> a -> f (Mapped itext otext a)
mapAst = (AstActions f itext otext
 -> FilePath -> a -> f (Mapped itext otext a))
-> FilePath
-> AstActions f itext otext
-> a
-> f (Mapped itext otext a)
forall a b c. (a -> b -> c) -> b -> a -> c
flip AstActions f itext otext
-> FilePath -> a -> f (Mapped itext otext a)
forall itext otext a (f :: * -> *).
(MapAst itext otext a, Applicative f) =>
AstActions f itext otext
-> FilePath -> a -> f (Mapped itext otext a)
mapFileAst FilePath
"<stdin>"

data AstActions f itext otext = AstActions
    { forall (f :: * -> *) itext otext.
AstActions f itext otext
-> [(FilePath, [Node (Lexeme itext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
doFiles     :: [(FilePath, [Node (Lexeme itext)])] -> f [(FilePath, [Node (Lexeme otext)])] -> f [(FilePath, [Node (Lexeme otext)])]
    , forall (f :: * -> *) itext otext.
AstActions f itext otext
-> (FilePath, [Node (Lexeme itext)])
-> f (FilePath, [Node (Lexeme otext)])
-> f (FilePath, [Node (Lexeme otext)])
doFile      ::  (FilePath, [Node (Lexeme itext)])  -> f  (FilePath, [Node (Lexeme otext)])  -> f  (FilePath, [Node (Lexeme otext)])
    , forall (f :: * -> *) itext otext.
AstActions f itext otext
-> FilePath
-> [Node (Lexeme itext)]
-> f [Node (Lexeme otext)]
-> f [Node (Lexeme otext)]
doNodes     :: FilePath -> [Node (Lexeme itext)]   -> f             [Node (Lexeme otext)]   -> f             [Node (Lexeme otext)]
    , forall (f :: * -> *) itext otext.
AstActions f itext otext
-> FilePath
-> Node (Lexeme itext)
-> f (Node (Lexeme otext))
-> f (Node (Lexeme otext))
doNode      :: FilePath ->  Node (Lexeme itext)    -> f             (Node (Lexeme otext))   -> f             (Node (Lexeme otext))
    , forall (f :: * -> *) itext otext.
AstActions f itext otext
-> FilePath
-> [Lexeme itext]
-> f [Lexeme otext]
-> f [Lexeme otext]
doLexemes   :: FilePath ->       [Lexeme itext]    -> f                   [Lexeme otext]    -> f                   [Lexeme otext]
    , forall (f :: * -> *) itext otext.
AstActions f itext otext
-> FilePath -> Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext)
doLexeme    :: FilePath ->        Lexeme itext     -> f                   (Lexeme otext)    -> f                   (Lexeme otext)
    , forall (f :: * -> *) itext otext.
AstActions f itext otext -> FilePath -> itext -> f otext
doText      :: FilePath ->               itext                                              -> f                           otext
    }

instance MapAst itext otext        a
      => MapAst itext otext (Maybe a) where
    type        Mapped itext otext (Maybe a)
       = Maybe (Mapped itext otext        a)
    mapFileAst :: forall (f :: * -> *).
Applicative f =>
AstActions f itext otext
-> FilePath -> Maybe a -> f (Mapped itext otext (Maybe a))
mapFileAst AstActions f itext otext
_       FilePath
_           Maybe a
Nothing  = Maybe (Mapped itext otext a) -> f (Maybe (Mapped itext otext a))
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe (Mapped itext otext a)
forall a. Maybe a
Nothing
    mapFileAst AstActions f itext otext
actions FilePath
currentFile (Just a
x) = Mapped itext otext a -> Maybe (Mapped itext otext a)
forall a. a -> Maybe a
Just (Mapped itext otext a -> Maybe (Mapped itext otext a))
-> f (Mapped itext otext a) -> f (Maybe (Mapped itext otext a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> AstActions f itext otext
-> FilePath -> a -> f (Mapped itext otext a)
forall itext otext a (f :: * -> *).
(MapAst itext otext a, Applicative f) =>
AstActions f itext otext
-> FilePath -> a -> f (Mapped itext otext a)
mapFileAst AstActions f itext otext
actions FilePath
currentFile a
x

astActions
    :: Applicative f
    => (itext -> f otext)
    -> AstActions f itext otext
astActions :: forall (f :: * -> *) itext otext.
Applicative f =>
(itext -> f otext) -> AstActions f itext otext
astActions itext -> f otext
ft = AstActions
    { doFiles :: [(FilePath, [Node (Lexeme itext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
doFiles     = (f [(FilePath, [Node (Lexeme otext)])]
 -> f [(FilePath, [Node (Lexeme otext)])])
-> [(FilePath, [Node (Lexeme itext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
forall a b. a -> b -> a
const f [(FilePath, [Node (Lexeme otext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
forall a. a -> a
id
    , doFile :: (FilePath, [Node (Lexeme itext)])
-> f (FilePath, [Node (Lexeme otext)])
-> f (FilePath, [Node (Lexeme otext)])
doFile      = (f (FilePath, [Node (Lexeme otext)])
 -> f (FilePath, [Node (Lexeme otext)]))
-> (FilePath, [Node (Lexeme itext)])
-> f (FilePath, [Node (Lexeme otext)])
-> f (FilePath, [Node (Lexeme otext)])
forall a b. a -> b -> a
const f (FilePath, [Node (Lexeme otext)])
-> f (FilePath, [Node (Lexeme otext)])
forall a. a -> a
id
    , doNodes :: FilePath
-> [Node (Lexeme itext)]
-> f [Node (Lexeme otext)]
-> f [Node (Lexeme otext)]
doNodes     = ([Node (Lexeme itext)]
 -> f [Node (Lexeme otext)] -> f [Node (Lexeme otext)])
-> FilePath
-> [Node (Lexeme itext)]
-> f [Node (Lexeme otext)]
-> f [Node (Lexeme otext)]
forall a b. a -> b -> a
const (([Node (Lexeme itext)]
  -> f [Node (Lexeme otext)] -> f [Node (Lexeme otext)])
 -> FilePath
 -> [Node (Lexeme itext)]
 -> f [Node (Lexeme otext)]
 -> f [Node (Lexeme otext)])
-> ([Node (Lexeme itext)]
    -> f [Node (Lexeme otext)] -> f [Node (Lexeme otext)])
-> FilePath
-> [Node (Lexeme itext)]
-> f [Node (Lexeme otext)]
-> f [Node (Lexeme otext)]
forall a b. (a -> b) -> a -> b
$ (f [Node (Lexeme otext)] -> f [Node (Lexeme otext)])
-> [Node (Lexeme itext)]
-> f [Node (Lexeme otext)]
-> f [Node (Lexeme otext)]
forall a b. a -> b -> a
const f [Node (Lexeme otext)] -> f [Node (Lexeme otext)]
forall a. a -> a
id
    , doNode :: FilePath
-> Node (Lexeme itext)
-> f (Node (Lexeme otext))
-> f (Node (Lexeme otext))
doNode      = (Node (Lexeme itext)
 -> f (Node (Lexeme otext)) -> f (Node (Lexeme otext)))
-> FilePath
-> Node (Lexeme itext)
-> f (Node (Lexeme otext))
-> f (Node (Lexeme otext))
forall a b. a -> b -> a
const ((Node (Lexeme itext)
  -> f (Node (Lexeme otext)) -> f (Node (Lexeme otext)))
 -> FilePath
 -> Node (Lexeme itext)
 -> f (Node (Lexeme otext))
 -> f (Node (Lexeme otext)))
-> (Node (Lexeme itext)
    -> f (Node (Lexeme otext)) -> f (Node (Lexeme otext)))
-> FilePath
-> Node (Lexeme itext)
-> f (Node (Lexeme otext))
-> f (Node (Lexeme otext))
forall a b. (a -> b) -> a -> b
$ (f (Node (Lexeme otext)) -> f (Node (Lexeme otext)))
-> Node (Lexeme itext)
-> f (Node (Lexeme otext))
-> f (Node (Lexeme otext))
forall a b. a -> b -> a
const f (Node (Lexeme otext)) -> f (Node (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
    }

type TextActions f itext otext = AstActions f itext otext
textActions :: Applicative f => (itext -> f otext) -> TextActions f itext otext
textActions :: forall (f :: * -> *) itext otext.
Applicative f =>
(itext -> f otext) -> AstActions f itext otext
textActions = (itext -> f otext) -> AstActions f itext otext
forall (f :: * -> *) itext otext.
Applicative f =>
(itext -> f otext) -> AstActions f itext otext
astActions

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


instance MapAst itext otext (Lexeme itext) where
    type Mapped itext otext (Lexeme itext)
                          =  Lexeme otext
    mapFileAst :: forall f . Applicative f
               => AstActions f itext otext -> FilePath -> Lexeme itext -> f (Lexeme otext)
    mapFileAst :: forall (f :: * -> *).
Applicative f =>
AstActions f itext otext
-> FilePath -> Lexeme itext -> f (Lexeme otext)
mapFileAst AstActions{FilePath -> itext -> f otext
FilePath
-> [Node (Lexeme itext)]
-> f [Node (Lexeme otext)]
-> f [Node (Lexeme otext)]
FilePath -> [Lexeme itext] -> f [Lexeme otext] -> f [Lexeme otext]
FilePath
-> Node (Lexeme itext)
-> f (Node (Lexeme otext))
-> f (Node (Lexeme otext))
FilePath -> Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext)
[(FilePath, [Node (Lexeme itext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
(FilePath, [Node (Lexeme itext)])
-> f (FilePath, [Node (Lexeme otext)])
-> f (FilePath, [Node (Lexeme otext)])
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 (Lexeme itext)
-> f (Node (Lexeme otext))
-> f (Node (Lexeme otext))
doNodes :: FilePath
-> [Node (Lexeme itext)]
-> f [Node (Lexeme otext)]
-> f [Node (Lexeme otext)]
doFile :: (FilePath, [Node (Lexeme itext)])
-> f (FilePath, [Node (Lexeme otext)])
-> f (FilePath, [Node (Lexeme otext)])
doFiles :: [(FilePath, [Node (Lexeme itext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
doText :: forall (f :: * -> *) itext otext.
AstActions f itext otext -> FilePath -> itext -> f otext
doLexeme :: forall (f :: * -> *) itext otext.
AstActions f itext otext
-> FilePath -> Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext)
doLexemes :: forall (f :: * -> *) itext otext.
AstActions f itext otext
-> FilePath
-> [Lexeme itext]
-> f [Lexeme otext]
-> f [Lexeme otext]
doNode :: forall (f :: * -> *) itext otext.
AstActions f itext otext
-> FilePath
-> Node (Lexeme itext)
-> f (Node (Lexeme otext))
-> f (Node (Lexeme otext))
doNodes :: forall (f :: * -> *) itext otext.
AstActions f itext otext
-> FilePath
-> [Node (Lexeme itext)]
-> f [Node (Lexeme otext)]
-> f [Node (Lexeme otext)]
doFile :: forall (f :: * -> *) itext otext.
AstActions f itext otext
-> (FilePath, [Node (Lexeme itext)])
-> f (FilePath, [Node (Lexeme otext)])
-> f (FilePath, [Node (Lexeme otext)])
doFiles :: forall (f :: * -> *) itext otext.
AstActions f itext otext
-> [(FilePath, [Node (Lexeme itext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
..} FilePath
currentFile = 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
<$> FilePath -> itext -> f otext
doText FilePath
currentFile itext
s

instance MapAst itext otext [Lexeme itext] where
    type Mapped itext otext [Lexeme itext]
                          = [Lexeme otext]
    mapFileAst :: forall (f :: * -> *).
Applicative f =>
AstActions f itext otext
-> FilePath
-> [Lexeme itext]
-> f (Mapped itext otext [Lexeme itext])
mapFileAst actions :: AstActions f itext otext
actions@AstActions{FilePath -> itext -> f otext
FilePath
-> [Node (Lexeme itext)]
-> f [Node (Lexeme otext)]
-> f [Node (Lexeme otext)]
FilePath -> [Lexeme itext] -> f [Lexeme otext] -> f [Lexeme otext]
FilePath
-> Node (Lexeme itext)
-> f (Node (Lexeme otext))
-> f (Node (Lexeme otext))
FilePath -> Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext)
[(FilePath, [Node (Lexeme itext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
(FilePath, [Node (Lexeme itext)])
-> f (FilePath, [Node (Lexeme otext)])
-> f (FilePath, [Node (Lexeme otext)])
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 (Lexeme itext)
-> f (Node (Lexeme otext))
-> f (Node (Lexeme otext))
doNodes :: FilePath
-> [Node (Lexeme itext)]
-> f [Node (Lexeme otext)]
-> f [Node (Lexeme otext)]
doFile :: (FilePath, [Node (Lexeme itext)])
-> f (FilePath, [Node (Lexeme otext)])
-> f (FilePath, [Node (Lexeme otext)])
doFiles :: [(FilePath, [Node (Lexeme itext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
doText :: forall (f :: * -> *) itext otext.
AstActions f itext otext -> FilePath -> itext -> f otext
doLexeme :: forall (f :: * -> *) itext otext.
AstActions f itext otext
-> FilePath -> Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext)
doLexemes :: forall (f :: * -> *) itext otext.
AstActions f itext otext
-> FilePath
-> [Lexeme itext]
-> f [Lexeme otext]
-> f [Lexeme otext]
doNode :: forall (f :: * -> *) itext otext.
AstActions f itext otext
-> FilePath
-> Node (Lexeme itext)
-> f (Node (Lexeme otext))
-> f (Node (Lexeme otext))
doNodes :: forall (f :: * -> *) itext otext.
AstActions f itext otext
-> FilePath
-> [Node (Lexeme itext)]
-> f [Node (Lexeme otext)]
-> f [Node (Lexeme otext)]
doFile :: forall (f :: * -> *) itext otext.
AstActions f itext otext
-> (FilePath, [Node (Lexeme itext)])
-> f (FilePath, [Node (Lexeme otext)])
-> f (FilePath, [Node (Lexeme otext)])
doFiles :: forall (f :: * -> *) itext otext.
AstActions f itext otext
-> [(FilePath, [Node (Lexeme itext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
..} FilePath
currentFile = 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 itext otext
-> FilePath
-> Lexeme itext
-> f (Mapped itext otext (Lexeme itext))
forall itext otext a (f :: * -> *).
(MapAst itext otext a, Applicative f) =>
AstActions f itext otext
-> FilePath -> a -> f (Mapped itext otext a)
mapFileAst AstActions f itext otext
actions FilePath
currentFile)

instance MapAst itext otext (Node (Lexeme itext)) where
    type Mapped itext otext (Node (Lexeme itext))
                          =  Node (Lexeme otext)
    mapFileAst
        :: forall f . Applicative f
        => AstActions f itext otext
        -> FilePath
        ->    Node (Lexeme itext)
        -> f (Node (Lexeme otext))
    mapFileAst :: forall (f :: * -> *).
Applicative f =>
AstActions f itext otext
-> FilePath -> Node (Lexeme itext) -> f (Node (Lexeme otext))
mapFileAst actions :: AstActions f itext otext
actions@AstActions{FilePath -> itext -> f otext
FilePath
-> [Node (Lexeme itext)]
-> f [Node (Lexeme otext)]
-> f [Node (Lexeme otext)]
FilePath -> [Lexeme itext] -> f [Lexeme otext] -> f [Lexeme otext]
FilePath
-> Node (Lexeme itext)
-> f (Node (Lexeme otext))
-> f (Node (Lexeme otext))
FilePath -> Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext)
[(FilePath, [Node (Lexeme itext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
(FilePath, [Node (Lexeme itext)])
-> f (FilePath, [Node (Lexeme otext)])
-> f (FilePath, [Node (Lexeme otext)])
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 (Lexeme itext)
-> f (Node (Lexeme otext))
-> f (Node (Lexeme otext))
doNodes :: FilePath
-> [Node (Lexeme itext)]
-> f [Node (Lexeme otext)]
-> f [Node (Lexeme otext)]
doFile :: (FilePath, [Node (Lexeme itext)])
-> f (FilePath, [Node (Lexeme otext)])
-> f (FilePath, [Node (Lexeme otext)])
doFiles :: [(FilePath, [Node (Lexeme itext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
doText :: forall (f :: * -> *) itext otext.
AstActions f itext otext -> FilePath -> itext -> f otext
doLexeme :: forall (f :: * -> *) itext otext.
AstActions f itext otext
-> FilePath -> Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext)
doLexemes :: forall (f :: * -> *) itext otext.
AstActions f itext otext
-> FilePath
-> [Lexeme itext]
-> f [Lexeme otext]
-> f [Lexeme otext]
doNode :: forall (f :: * -> *) itext otext.
AstActions f itext otext
-> FilePath
-> Node (Lexeme itext)
-> f (Node (Lexeme otext))
-> f (Node (Lexeme otext))
doNodes :: forall (f :: * -> *) itext otext.
AstActions f itext otext
-> FilePath
-> [Node (Lexeme itext)]
-> f [Node (Lexeme otext)]
-> f [Node (Lexeme otext)]
doFile :: forall (f :: * -> *) itext otext.
AstActions f itext otext
-> (FilePath, [Node (Lexeme itext)])
-> f (FilePath, [Node (Lexeme otext)])
-> f (FilePath, [Node (Lexeme otext)])
doFiles :: forall (f :: * -> *) itext otext.
AstActions f itext otext
-> [(FilePath, [Node (Lexeme itext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
..} FilePath
currentFile = FilePath
-> Node (Lexeme itext)
-> f (Node (Lexeme otext))
-> f (Node (Lexeme otext))
doNode FilePath
currentFile (Node (Lexeme itext)
 -> f (Node (Lexeme otext)) -> f (Node (Lexeme otext)))
-> (Node (Lexeme itext) -> f (Node (Lexeme otext)))
-> Node (Lexeme itext)
-> f (Node (Lexeme otext))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> \Node (Lexeme itext)
node -> case Node (Lexeme itext) -> NodeF (Lexeme itext) (Node (Lexeme itext))
forall (f :: * -> *). Fix f -> f (Fix f)
unFix Node (Lexeme itext)
node of
        PreprocInclude Lexeme itext
path ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Mapped itext otext (Lexeme itext)
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. lexeme -> NodeF lexeme a
PreprocInclude (Mapped itext otext (Lexeme itext)
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Mapped itext otext (Lexeme itext))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Mapped itext otext (Lexeme itext))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Lexeme itext
path)
        PreprocDefine Lexeme itext
name ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Mapped itext otext (Lexeme itext)
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. lexeme -> NodeF lexeme a
PreprocDefine (Mapped itext otext (Lexeme itext)
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Mapped itext otext (Lexeme itext))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Mapped itext otext (Lexeme itext))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Lexeme itext
name)
        PreprocDefineConst Lexeme itext
name Node (Lexeme itext)
value ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Mapped itext otext (Lexeme itext)
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. lexeme -> a -> NodeF lexeme a
PreprocDefineConst (Mapped itext otext (Lexeme itext)
 -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Mapped itext otext (Lexeme itext))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Mapped itext otext (Lexeme itext))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Lexeme itext
name f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
value)
        PreprocDefineMacro Lexeme itext
name [Node (Lexeme itext)]
params Node (Lexeme itext)
body ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Mapped itext otext (Lexeme itext)
-> [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. lexeme -> [a] -> a -> NodeF lexeme a
PreprocDefineMacro (Mapped itext otext (Lexeme itext)
 -> [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
 -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Mapped itext otext (Lexeme itext))
-> f ([Fix (NodeF (Mapped itext otext (Lexeme itext)))]
      -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Mapped itext otext (Lexeme itext))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Lexeme itext
name f ([Fix (NodeF (Mapped itext otext (Lexeme itext)))]
   -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Node (Lexeme itext)]
-> f (Mapped itext otext [Node (Lexeme itext)])
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse [Node (Lexeme itext)]
params f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
body)
        PreprocIf Node (Lexeme itext)
cond [Node (Lexeme itext)]
thenDecls Node (Lexeme itext)
elseBranch ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. a -> [a] -> a -> NodeF lexeme a
PreprocIf (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
 -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f ([Fix (NodeF (Mapped itext otext (Lexeme itext)))]
      -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
cond f ([Fix (NodeF (Mapped itext otext (Lexeme itext)))]
   -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Node (Lexeme itext)]
-> f (Mapped itext otext [Node (Lexeme itext)])
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse [Node (Lexeme itext)]
thenDecls f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
elseBranch)
        PreprocIfdef Lexeme itext
name [Node (Lexeme itext)]
thenDecls Node (Lexeme itext)
elseBranch ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Mapped itext otext (Lexeme itext)
-> [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. lexeme -> [a] -> a -> NodeF lexeme a
PreprocIfdef (Mapped itext otext (Lexeme itext)
 -> [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
 -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Mapped itext otext (Lexeme itext))
-> f ([Fix (NodeF (Mapped itext otext (Lexeme itext)))]
      -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Mapped itext otext (Lexeme itext))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Lexeme itext
name f ([Fix (NodeF (Mapped itext otext (Lexeme itext)))]
   -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Node (Lexeme itext)]
-> f (Mapped itext otext [Node (Lexeme itext)])
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse [Node (Lexeme itext)]
thenDecls f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
elseBranch)
        PreprocIfndef Lexeme itext
name [Node (Lexeme itext)]
thenDecls Node (Lexeme itext)
elseBranch ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Mapped itext otext (Lexeme itext)
-> [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. lexeme -> [a] -> a -> NodeF lexeme a
PreprocIfndef (Mapped itext otext (Lexeme itext)
 -> [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
 -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Mapped itext otext (Lexeme itext))
-> f ([Fix (NodeF (Mapped itext otext (Lexeme itext)))]
      -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Mapped itext otext (Lexeme itext))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Lexeme itext
name f ([Fix (NodeF (Mapped itext otext (Lexeme itext)))]
   -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Node (Lexeme itext)]
-> f (Mapped itext otext [Node (Lexeme itext)])
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse [Node (Lexeme itext)]
thenDecls f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
elseBranch)
        PreprocElse [Node (Lexeme itext)]
decls ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ([Fix (NodeF (Mapped itext otext (Lexeme itext)))]
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. [a] -> NodeF lexeme a
PreprocElse ([Fix (NodeF (Mapped itext otext (Lexeme itext)))]
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Node (Lexeme itext)]
-> f (Mapped itext otext [Node (Lexeme itext)])
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse [Node (Lexeme itext)]
decls)
        PreprocElif Node (Lexeme itext)
cond [Node (Lexeme itext)]
decls Node (Lexeme itext)
elseBranch ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. a -> [a] -> a -> NodeF lexeme a
PreprocElif (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
 -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f ([Fix (NodeF (Mapped itext otext (Lexeme itext)))]
      -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
cond f ([Fix (NodeF (Mapped itext otext (Lexeme itext)))]
   -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Node (Lexeme itext)]
-> f (Mapped itext otext [Node (Lexeme itext)])
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse [Node (Lexeme itext)]
decls f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
elseBranch)
        PreprocUndef Lexeme itext
name ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Mapped itext otext (Lexeme itext)
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. lexeme -> NodeF lexeme a
PreprocUndef (Mapped itext otext (Lexeme itext)
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Mapped itext otext (Lexeme itext))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Mapped itext otext (Lexeme itext))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Lexeme itext
name)
        PreprocDefined Lexeme itext
name ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Mapped itext otext (Lexeme itext)
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. lexeme -> NodeF lexeme a
PreprocDefined (Mapped itext otext (Lexeme itext)
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Mapped itext otext (Lexeme itext))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Mapped itext otext (Lexeme itext))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Lexeme itext
name)
        PreprocScopedDefine Node (Lexeme itext)
define [Node (Lexeme itext)]
stmts Node (Lexeme itext)
undef ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. a -> [a] -> a -> NodeF lexeme a
PreprocScopedDefine (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
 -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f ([Fix (NodeF (Mapped itext otext (Lexeme itext)))]
      -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
define f ([Fix (NodeF (Mapped itext otext (Lexeme itext)))]
   -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Node (Lexeme itext)]
-> f (Mapped itext otext [Node (Lexeme itext)])
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse [Node (Lexeme itext)]
stmts f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
undef)
        MacroBodyStmt Node (Lexeme itext)
stmts ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. a -> NodeF lexeme a
MacroBodyStmt (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
stmts)
        MacroBodyFunCall Node (Lexeme itext)
expr ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. a -> NodeF lexeme a
MacroBodyFunCall (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
expr)
        MacroParam Lexeme itext
name ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Mapped itext otext (Lexeme itext)
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. lexeme -> NodeF lexeme a
MacroParam (Mapped itext otext (Lexeme itext)
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Mapped itext otext (Lexeme itext))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Mapped itext otext (Lexeme itext))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Lexeme itext
name)
        StaticAssert Node (Lexeme itext)
cond Lexeme itext
msg ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> Mapped itext otext (Lexeme itext)
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. a -> lexeme -> NodeF lexeme a
StaticAssert (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> Mapped itext otext (Lexeme itext)
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (Mapped itext otext (Lexeme itext)
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
cond f (Mapped itext otext (Lexeme itext)
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Mapped itext otext (Lexeme itext))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Lexeme itext -> f (Mapped itext otext (Lexeme itext))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Lexeme itext
msg)
        LicenseDecl Lexeme itext
license [Node (Lexeme itext)]
copyrights ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Mapped itext otext (Lexeme itext)
-> [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. lexeme -> [a] -> NodeF lexeme a
LicenseDecl (Mapped itext otext (Lexeme itext)
 -> [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Mapped itext otext (Lexeme itext))
-> f ([Fix (NodeF (Mapped itext otext (Lexeme itext)))]
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Mapped itext otext (Lexeme itext))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Lexeme itext
license f ([Fix (NodeF (Mapped itext otext (Lexeme itext)))]
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Node (Lexeme itext)]
-> f (Mapped itext otext [Node (Lexeme itext)])
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse [Node (Lexeme itext)]
copyrights)
        CopyrightDecl Lexeme itext
from Maybe (Lexeme itext)
to [Lexeme itext]
owner ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Mapped itext otext (Lexeme itext)
-> Maybe (Mapped itext otext (Lexeme itext))
-> [Mapped itext otext (Lexeme itext)]
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a.
lexeme -> Maybe lexeme -> [lexeme] -> NodeF lexeme a
CopyrightDecl (Mapped itext otext (Lexeme itext)
 -> Maybe (Mapped itext otext (Lexeme itext))
 -> [Mapped itext otext (Lexeme itext)]
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Mapped itext otext (Lexeme itext))
-> f (Maybe (Mapped itext otext (Lexeme itext))
      -> [Mapped itext otext (Lexeme itext)]
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Mapped itext otext (Lexeme itext))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Lexeme itext
from f (Maybe (Mapped itext otext (Lexeme itext))
   -> [Mapped itext otext (Lexeme itext)]
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Maybe (Mapped itext otext (Lexeme itext)))
-> f ([Mapped itext otext (Lexeme itext)]
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe (Lexeme itext)
-> f (Mapped itext otext (Maybe (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Maybe (Lexeme itext)
to f ([Mapped itext otext (Lexeme itext)]
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f [Mapped itext otext (Lexeme itext)]
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Lexeme itext] -> f (Mapped itext otext [Lexeme itext])
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse [Lexeme itext]
owner)
        Comment CommentStyle
doc Lexeme itext
start [Lexeme itext]
contents Lexeme itext
end ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (CommentStyle
-> Mapped itext otext (Lexeme itext)
-> [Mapped itext otext (Lexeme itext)]
-> Mapped itext otext (Lexeme itext)
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a.
CommentStyle -> lexeme -> [lexeme] -> lexeme -> NodeF lexeme a
Comment CommentStyle
doc (Mapped itext otext (Lexeme itext)
 -> [Mapped itext otext (Lexeme itext)]
 -> Mapped itext otext (Lexeme itext)
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Mapped itext otext (Lexeme itext))
-> f ([Mapped itext otext (Lexeme itext)]
      -> Mapped itext otext (Lexeme itext)
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Mapped itext otext (Lexeme itext))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Lexeme itext
start f ([Mapped itext otext (Lexeme itext)]
   -> Mapped itext otext (Lexeme itext)
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f [Mapped itext otext (Lexeme itext)]
-> f (Mapped itext otext (Lexeme itext)
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Lexeme itext] -> f (Mapped itext otext [Lexeme itext])
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse [Lexeme itext]
contents f (Mapped itext otext (Lexeme itext)
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Mapped itext otext (Lexeme itext))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Lexeme itext -> f (Mapped itext otext (Lexeme itext))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Lexeme itext
end)
        CommentBlock Lexeme itext
comment ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Mapped itext otext (Lexeme itext)
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. lexeme -> NodeF lexeme a
CommentBlock (Mapped itext otext (Lexeme itext)
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Mapped itext otext (Lexeme itext))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Mapped itext otext (Lexeme itext))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Lexeme itext
comment)
        Commented Node (Lexeme itext)
comment Node (Lexeme itext)
subject ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. a -> a -> NodeF lexeme a
Commented (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
comment f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
subject)
        ExternC [Node (Lexeme itext)]
decls ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ([Fix (NodeF (Mapped itext otext (Lexeme itext)))]
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. [a] -> NodeF lexeme a
ExternC ([Fix (NodeF (Mapped itext otext (Lexeme itext)))]
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Node (Lexeme itext)]
-> f (Mapped itext otext [Node (Lexeme itext)])
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse [Node (Lexeme itext)]
decls)
        CompoundStmt [Node (Lexeme itext)]
stmts ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ([Fix (NodeF (Mapped itext otext (Lexeme itext)))]
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. [a] -> NodeF lexeme a
CompoundStmt ([Fix (NodeF (Mapped itext otext (Lexeme itext)))]
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Node (Lexeme itext)]
-> f (Mapped itext otext [Node (Lexeme itext)])
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse [Node (Lexeme itext)]
stmts)
        NodeF (Lexeme itext) (Node (Lexeme itext))
Break ->
            Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> f (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall a b. (a -> b) -> a -> b
$ NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. NodeF lexeme a
Break
        Goto Lexeme itext
label ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Mapped itext otext (Lexeme itext)
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. lexeme -> NodeF lexeme a
Goto (Mapped itext otext (Lexeme itext)
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Mapped itext otext (Lexeme itext))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Mapped itext otext (Lexeme itext))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Lexeme itext
label)
        NodeF (Lexeme itext) (Node (Lexeme itext))
Continue ->
            Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> f (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall a b. (a -> b) -> a -> b
$ NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. NodeF lexeme a
Continue
        Return Maybe (Node (Lexeme itext))
value ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Maybe (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. Maybe a -> NodeF lexeme a
Return (Maybe (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Maybe (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (Node (Lexeme itext))
-> f (Mapped itext otext (Maybe (Node (Lexeme itext))))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Maybe (Node (Lexeme itext))
value)
        SwitchStmt Node (Lexeme itext)
value [Node (Lexeme itext)]
cases ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. a -> [a] -> NodeF lexeme a
SwitchStmt (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f ([Fix (NodeF (Mapped itext otext (Lexeme itext)))]
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
value f ([Fix (NodeF (Mapped itext otext (Lexeme itext)))]
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Node (Lexeme itext)]
-> f (Mapped itext otext [Node (Lexeme itext)])
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse [Node (Lexeme itext)]
cases)
        IfStmt Node (Lexeme itext)
cond Node (Lexeme itext)
thenStmts Maybe (Node (Lexeme itext))
elseStmt ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> Maybe (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. a -> a -> Maybe a -> NodeF lexeme a
IfStmt (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> Maybe (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
      -> Maybe (Fix (NodeF (Mapped itext otext (Lexeme itext))))
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
cond f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
   -> Maybe (Fix (NodeF (Mapped itext otext (Lexeme itext))))
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (Maybe (Fix (NodeF (Mapped itext otext (Lexeme itext))))
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
thenStmts f (Maybe (Fix (NodeF (Mapped itext otext (Lexeme itext))))
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Maybe (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe (Node (Lexeme itext))
-> f (Mapped itext otext (Maybe (Node (Lexeme itext))))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Maybe (Node (Lexeme itext))
elseStmt)
        ForStmt Node (Lexeme itext)
initStmt Node (Lexeme itext)
cond Node (Lexeme itext)
next Node (Lexeme itext)
stmts ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. a -> a -> a -> a -> NodeF lexeme a
ForStmt (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
      -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
      -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
initStmt f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
   -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
   -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
      -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
cond f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
   -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
next f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
stmts)
        WhileStmt Node (Lexeme itext)
cond Node (Lexeme itext)
stmts ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. a -> a -> NodeF lexeme a
WhileStmt (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
cond f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
stmts)
        DoWhileStmt Node (Lexeme itext)
stmts Node (Lexeme itext)
cond ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. a -> a -> NodeF lexeme a
DoWhileStmt (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
stmts f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
cond)
        Case Node (Lexeme itext)
value Node (Lexeme itext)
stmt ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. a -> a -> NodeF lexeme a
Case (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
value f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
stmt)
        Default Node (Lexeme itext)
stmt ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. a -> NodeF lexeme a
Default (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
stmt)
        Label Lexeme itext
label Node (Lexeme itext)
stmt ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Mapped itext otext (Lexeme itext)
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. lexeme -> a -> NodeF lexeme a
Label (Mapped itext otext (Lexeme itext)
 -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Mapped itext otext (Lexeme itext))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Mapped itext otext (Lexeme itext))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Lexeme itext
label f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
stmt)
        VLA Node (Lexeme itext)
ty Lexeme itext
name Node (Lexeme itext)
size ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> Mapped itext otext (Lexeme itext)
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. a -> lexeme -> a -> NodeF lexeme a
VLA (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> Mapped itext otext (Lexeme itext)
 -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (Mapped itext otext (Lexeme itext)
      -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
ty f (Mapped itext otext (Lexeme itext)
   -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Mapped itext otext (Lexeme itext))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Lexeme itext -> f (Mapped itext otext (Lexeme itext))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Lexeme itext
name f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
size)
        VarDeclStmt Node (Lexeme itext)
decl Maybe (Node (Lexeme itext))
ini ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> Maybe (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. a -> Maybe a -> NodeF lexeme a
VarDeclStmt (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> Maybe (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (Maybe (Fix (NodeF (Mapped itext otext (Lexeme itext))))
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
decl f (Maybe (Fix (NodeF (Mapped itext otext (Lexeme itext))))
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Maybe (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe (Node (Lexeme itext))
-> f (Mapped itext otext (Maybe (Node (Lexeme itext))))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Maybe (Node (Lexeme itext))
ini)
        VarDecl Node (Lexeme itext)
ty Lexeme itext
name [Node (Lexeme itext)]
arrs ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> Mapped itext otext (Lexeme itext)
-> [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. a -> lexeme -> [a] -> NodeF lexeme a
VarDecl (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> Mapped itext otext (Lexeme itext)
 -> [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (Mapped itext otext (Lexeme itext)
      -> [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
ty f (Mapped itext otext (Lexeme itext)
   -> [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Mapped itext otext (Lexeme itext))
-> f ([Fix (NodeF (Mapped itext otext (Lexeme itext)))]
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Lexeme itext -> f (Mapped itext otext (Lexeme itext))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Lexeme itext
name f ([Fix (NodeF (Mapped itext otext (Lexeme itext)))]
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Node (Lexeme itext)]
-> f (Mapped itext otext [Node (Lexeme itext)])
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse [Node (Lexeme itext)]
arrs)
        DeclSpecArray Maybe (Node (Lexeme itext))
size ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Maybe (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. Maybe a -> NodeF lexeme a
DeclSpecArray (Maybe (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Maybe (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (Node (Lexeme itext))
-> f (Mapped itext otext (Maybe (Node (Lexeme itext))))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Maybe (Node (Lexeme itext))
size)
        InitialiserList [Node (Lexeme itext)]
values ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ([Fix (NodeF (Mapped itext otext (Lexeme itext)))]
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. [a] -> NodeF lexeme a
InitialiserList ([Fix (NodeF (Mapped itext otext (Lexeme itext)))]
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Node (Lexeme itext)]
-> f (Mapped itext otext [Node (Lexeme itext)])
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse [Node (Lexeme itext)]
values)
        UnaryExpr UnaryOp
op Node (Lexeme itext)
expr ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (UnaryOp
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. UnaryOp -> a -> NodeF lexeme a
UnaryExpr UnaryOp
op (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
expr)
        BinaryExpr Node (Lexeme itext)
lhs BinaryOp
op Node (Lexeme itext)
rhs ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> BinaryOp
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. a -> BinaryOp -> a -> NodeF lexeme a
BinaryExpr (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> BinaryOp
 -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (BinaryOp
      -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
lhs f (BinaryOp
   -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f BinaryOp
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
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 (Fix (NodeF (Mapped itext otext (Lexeme itext)))
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
rhs)
        TernaryExpr Node (Lexeme itext)
cond Node (Lexeme itext)
thenExpr Node (Lexeme itext)
elseExpr ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. a -> a -> a -> NodeF lexeme a
TernaryExpr (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
      -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
cond f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
   -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
thenExpr f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
elseExpr)
        AssignExpr Node (Lexeme itext)
lhs AssignOp
op Node (Lexeme itext)
rhs ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> AssignOp
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. a -> AssignOp -> a -> NodeF lexeme a
AssignExpr (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> AssignOp
 -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (AssignOp
      -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
lhs f (AssignOp
   -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f AssignOp
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
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 (Fix (NodeF (Mapped itext otext (Lexeme itext)))
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
rhs)
        ParenExpr Node (Lexeme itext)
expr ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. a -> NodeF lexeme a
ParenExpr (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
expr)
        CastExpr Node (Lexeme itext)
ty Node (Lexeme itext)
expr ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. a -> a -> NodeF lexeme a
CastExpr (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
ty f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
expr)
        CompoundExpr Node (Lexeme itext)
ty Node (Lexeme itext)
expr ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. a -> a -> NodeF lexeme a
CompoundExpr (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
ty f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
expr)
        SizeofExpr Node (Lexeme itext)
expr ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. a -> NodeF lexeme a
SizeofExpr (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
expr)
        SizeofType Node (Lexeme itext)
ty ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. a -> NodeF lexeme a
SizeofType (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
ty)
        LiteralExpr LiteralType
ty Lexeme itext
value ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (LiteralType
-> Mapped itext otext (Lexeme itext)
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. LiteralType -> lexeme -> NodeF lexeme a
LiteralExpr LiteralType
ty (Mapped itext otext (Lexeme itext)
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Mapped itext otext (Lexeme itext))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Mapped itext otext (Lexeme itext))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Lexeme itext
value)
        VarExpr Lexeme itext
name ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Mapped itext otext (Lexeme itext)
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. lexeme -> NodeF lexeme a
VarExpr (Mapped itext otext (Lexeme itext)
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Mapped itext otext (Lexeme itext))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Mapped itext otext (Lexeme itext))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Lexeme itext
name)
        MemberAccess Node (Lexeme itext)
name Lexeme itext
field ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> Mapped itext otext (Lexeme itext)
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. a -> lexeme -> NodeF lexeme a
MemberAccess (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> Mapped itext otext (Lexeme itext)
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (Mapped itext otext (Lexeme itext)
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
name f (Mapped itext otext (Lexeme itext)
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Mapped itext otext (Lexeme itext))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Lexeme itext -> f (Mapped itext otext (Lexeme itext))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Lexeme itext
field)
        PointerAccess Node (Lexeme itext)
name Lexeme itext
field ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> Mapped itext otext (Lexeme itext)
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. a -> lexeme -> NodeF lexeme a
PointerAccess (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> Mapped itext otext (Lexeme itext)
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (Mapped itext otext (Lexeme itext)
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
name f (Mapped itext otext (Lexeme itext)
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Mapped itext otext (Lexeme itext))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Lexeme itext -> f (Mapped itext otext (Lexeme itext))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Lexeme itext
field)
        ArrayAccess Node (Lexeme itext)
arr Node (Lexeme itext)
idx ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. a -> a -> NodeF lexeme a
ArrayAccess (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
arr f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
idx)
        FunctionCall Node (Lexeme itext)
callee [Node (Lexeme itext)]
args ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. a -> [a] -> NodeF lexeme a
FunctionCall (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f ([Fix (NodeF (Mapped itext otext (Lexeme itext)))]
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
callee f ([Fix (NodeF (Mapped itext otext (Lexeme itext)))]
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Node (Lexeme itext)]
-> f (Mapped itext otext [Node (Lexeme itext)])
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse [Node (Lexeme itext)]
args)
        CommentExpr Node (Lexeme itext)
comment Node (Lexeme itext)
expr ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. a -> a -> NodeF lexeme a
CommentExpr (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
comment f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
expr)
        EnumConsts Maybe (Lexeme itext)
name [Node (Lexeme itext)]
members ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Maybe (Mapped itext otext (Lexeme itext))
-> [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. Maybe lexeme -> [a] -> NodeF lexeme a
EnumConsts (Maybe (Mapped itext otext (Lexeme itext))
 -> [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Maybe (Mapped itext otext (Lexeme itext)))
-> f ([Fix (NodeF (Mapped itext otext (Lexeme itext)))]
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (Lexeme itext)
-> f (Mapped itext otext (Maybe (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Maybe (Lexeme itext)
name f ([Fix (NodeF (Mapped itext otext (Lexeme itext)))]
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Node (Lexeme itext)]
-> f (Mapped itext otext [Node (Lexeme itext)])
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse [Node (Lexeme itext)]
members)
        EnumDecl Lexeme itext
name [Node (Lexeme itext)]
members Lexeme itext
tyName ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Mapped itext otext (Lexeme itext)
-> [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
-> Mapped itext otext (Lexeme itext)
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. lexeme -> [a] -> lexeme -> NodeF lexeme a
EnumDecl (Mapped itext otext (Lexeme itext)
 -> [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
 -> Mapped itext otext (Lexeme itext)
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Mapped itext otext (Lexeme itext))
-> f ([Fix (NodeF (Mapped itext otext (Lexeme itext)))]
      -> Mapped itext otext (Lexeme itext)
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Mapped itext otext (Lexeme itext))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Lexeme itext
name f ([Fix (NodeF (Mapped itext otext (Lexeme itext)))]
   -> Mapped itext otext (Lexeme itext)
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
-> f (Mapped itext otext (Lexeme itext)
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Node (Lexeme itext)]
-> f (Mapped itext otext [Node (Lexeme itext)])
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse [Node (Lexeme itext)]
members f (Mapped itext otext (Lexeme itext)
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Mapped itext otext (Lexeme itext))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Lexeme itext -> f (Mapped itext otext (Lexeme itext))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Lexeme itext
tyName)
        Enumerator Lexeme itext
name Maybe (Node (Lexeme itext))
value ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Mapped itext otext (Lexeme itext)
-> Maybe (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. lexeme -> Maybe a -> NodeF lexeme a
Enumerator (Mapped itext otext (Lexeme itext)
 -> Maybe (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Mapped itext otext (Lexeme itext))
-> f (Maybe (Fix (NodeF (Mapped itext otext (Lexeme itext))))
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Mapped itext otext (Lexeme itext))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Lexeme itext
name f (Maybe (Fix (NodeF (Mapped itext otext (Lexeme itext))))
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Maybe (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe (Node (Lexeme itext))
-> f (Mapped itext otext (Maybe (Node (Lexeme itext))))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Maybe (Node (Lexeme itext))
value)
        Typedef Node (Lexeme itext)
ty Lexeme itext
name ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> Mapped itext otext (Lexeme itext)
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. a -> lexeme -> NodeF lexeme a
Typedef (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> Mapped itext otext (Lexeme itext)
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (Mapped itext otext (Lexeme itext)
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
ty f (Mapped itext otext (Lexeme itext)
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Mapped itext otext (Lexeme itext))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Lexeme itext -> f (Mapped itext otext (Lexeme itext))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Lexeme itext
name)
        TypedefFunction Node (Lexeme itext)
ty ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. a -> NodeF lexeme a
TypedefFunction (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
ty)
        Struct Lexeme itext
name [Node (Lexeme itext)]
members ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Mapped itext otext (Lexeme itext)
-> [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. lexeme -> [a] -> NodeF lexeme a
Struct (Mapped itext otext (Lexeme itext)
 -> [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Mapped itext otext (Lexeme itext))
-> f ([Fix (NodeF (Mapped itext otext (Lexeme itext)))]
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Mapped itext otext (Lexeme itext))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Lexeme itext
name f ([Fix (NodeF (Mapped itext otext (Lexeme itext)))]
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Node (Lexeme itext)]
-> f (Mapped itext otext [Node (Lexeme itext)])
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse [Node (Lexeme itext)]
members)
        Union Lexeme itext
name [Node (Lexeme itext)]
members ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Mapped itext otext (Lexeme itext)
-> [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. lexeme -> [a] -> NodeF lexeme a
Union (Mapped itext otext (Lexeme itext)
 -> [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Mapped itext otext (Lexeme itext))
-> f ([Fix (NodeF (Mapped itext otext (Lexeme itext)))]
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Mapped itext otext (Lexeme itext))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Lexeme itext
name f ([Fix (NodeF (Mapped itext otext (Lexeme itext)))]
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Node (Lexeme itext)]
-> f (Mapped itext otext [Node (Lexeme itext)])
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse [Node (Lexeme itext)]
members)
        MemberDecl Node (Lexeme itext)
decl Maybe (Lexeme itext)
bits ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> Maybe (Mapped itext otext (Lexeme itext))
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. a -> Maybe lexeme -> NodeF lexeme a
MemberDecl (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> Maybe (Mapped itext otext (Lexeme itext))
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (Maybe (Mapped itext otext (Lexeme itext))
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
decl f (Maybe (Mapped itext otext (Lexeme itext))
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Maybe (Mapped itext otext (Lexeme itext)))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe (Lexeme itext)
-> f (Mapped itext otext (Maybe (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Maybe (Lexeme itext)
bits)
        TyConst Node (Lexeme itext)
ty ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. a -> NodeF lexeme a
TyConst (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
ty)
        TyPointer Node (Lexeme itext)
ty ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. a -> NodeF lexeme a
TyPointer (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
ty)
        TyStruct Lexeme itext
name ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Mapped itext otext (Lexeme itext)
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. lexeme -> NodeF lexeme a
TyStruct (Mapped itext otext (Lexeme itext)
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Mapped itext otext (Lexeme itext))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Mapped itext otext (Lexeme itext))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Lexeme itext
name)
        TyFunc Lexeme itext
name ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Mapped itext otext (Lexeme itext)
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. lexeme -> NodeF lexeme a
TyFunc (Mapped itext otext (Lexeme itext)
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Mapped itext otext (Lexeme itext))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Mapped itext otext (Lexeme itext))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Lexeme itext
name)
        TyStd Lexeme itext
name ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Mapped itext otext (Lexeme itext)
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. lexeme -> NodeF lexeme a
TyStd (Mapped itext otext (Lexeme itext)
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Mapped itext otext (Lexeme itext))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Mapped itext otext (Lexeme itext))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Lexeme itext
name)
        TyUserDefined Lexeme itext
name ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Mapped itext otext (Lexeme itext)
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. lexeme -> NodeF lexeme a
TyUserDefined (Mapped itext otext (Lexeme itext)
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Mapped itext otext (Lexeme itext))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Lexeme itext -> f (Mapped itext otext (Lexeme itext))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Lexeme itext
name)
        FunctionDecl Scope
scope Node (Lexeme itext)
proto ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Scope
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. Scope -> a -> NodeF lexeme a
FunctionDecl Scope
scope (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
proto)
        FunctionDefn Scope
scope Node (Lexeme itext)
proto Node (Lexeme itext)
body ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Scope
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. Scope -> a -> a -> NodeF lexeme a
FunctionDefn Scope
scope (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
proto f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
body)
        FunctionPrototype Node (Lexeme itext)
ty Lexeme itext
name [Node (Lexeme itext)]
params ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> Mapped itext otext (Lexeme itext)
-> [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. a -> lexeme -> [a] -> NodeF lexeme a
FunctionPrototype (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> Mapped itext otext (Lexeme itext)
 -> [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (Mapped itext otext (Lexeme itext)
      -> [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
ty f (Mapped itext otext (Lexeme itext)
   -> [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Mapped itext otext (Lexeme itext))
-> f ([Fix (NodeF (Mapped itext otext (Lexeme itext)))]
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Lexeme itext -> f (Mapped itext otext (Lexeme itext))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Lexeme itext
name f ([Fix (NodeF (Mapped itext otext (Lexeme itext)))]
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f [Fix (NodeF (Mapped itext otext (Lexeme itext)))]
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Node (Lexeme itext)]
-> f (Mapped itext otext [Node (Lexeme itext)])
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse [Node (Lexeme itext)]
params)
        NodeF (Lexeme itext) (Node (Lexeme itext))
Ellipsis ->
            Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> f (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall a b. (a -> b) -> a -> b
$ NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. NodeF lexeme a
Ellipsis
        ConstDecl Node (Lexeme itext)
ty Lexeme itext
name ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> Mapped itext otext (Lexeme itext)
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. a -> lexeme -> NodeF lexeme a
ConstDecl (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> Mapped itext otext (Lexeme itext)
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (Mapped itext otext (Lexeme itext)
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
ty f (Mapped itext otext (Lexeme itext)
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Mapped itext otext (Lexeme itext))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Lexeme itext -> f (Mapped itext otext (Lexeme itext))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Lexeme itext
name)
        ConstDefn Scope
scope Node (Lexeme itext)
ty Lexeme itext
name Node (Lexeme itext)
value ->
            NodeF
  (Mapped itext otext (Lexeme itext))
  (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NodeF
   (Mapped itext otext (Lexeme itext))
   (Fix (NodeF (Mapped itext otext (Lexeme itext))))
 -> Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Scope
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> Mapped itext otext (Lexeme itext)
-> Fix (NodeF (Mapped itext otext (Lexeme itext)))
-> NodeF
     (Mapped itext otext (Lexeme itext))
     (Fix (NodeF (Mapped itext otext (Lexeme itext))))
forall lexeme a. Scope -> a -> lexeme -> a -> NodeF lexeme a
ConstDefn Scope
scope (Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> Mapped itext otext (Lexeme itext)
 -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
 -> NodeF
      (Mapped itext otext (Lexeme itext))
      (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (Mapped itext otext (Lexeme itext)
      -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
ty f (Mapped itext otext (Lexeme itext)
   -> Fix (NodeF (Mapped itext otext (Lexeme itext)))
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Mapped itext otext (Lexeme itext))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
      -> NodeF
           (Mapped itext otext (Lexeme itext))
           (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Lexeme itext -> f (Mapped itext otext (Lexeme itext))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Lexeme itext
name f (Fix (NodeF (Mapped itext otext (Lexeme itext)))
   -> NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
-> f (Fix (NodeF (Mapped itext otext (Lexeme itext))))
-> f (NodeF
        (Mapped itext otext (Lexeme itext))
        (Fix (NodeF (Mapped itext otext (Lexeme itext)))))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Node (Lexeme itext) -> f (Mapped itext otext (Node (Lexeme itext)))
forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse Node (Lexeme itext)
value)

      where
        recurse :: MapAst itext otext a => a -> f (Mapped itext otext a)
        recurse :: forall a. MapAst itext otext a => a -> f (Mapped itext otext a)
recurse = AstActions f itext otext
-> FilePath -> a -> f (Mapped itext otext a)
forall itext otext a (f :: * -> *).
(MapAst itext otext a, Applicative f) =>
AstActions f itext otext
-> FilePath -> a -> f (Mapped itext otext a)
mapFileAst AstActions f itext otext
actions FilePath
currentFile

instance MapAst itext otext [Node (Lexeme itext)] where
    type Mapped itext otext [Node (Lexeme itext)]
                          = [Node (Lexeme otext)]
    mapFileAst :: forall (f :: * -> *).
Applicative f =>
AstActions f itext otext
-> FilePath
-> [Node (Lexeme itext)]
-> f (Mapped itext otext [Node (Lexeme itext)])
mapFileAst actions :: AstActions f itext otext
actions@AstActions{FilePath -> itext -> f otext
FilePath
-> [Node (Lexeme itext)]
-> f [Node (Lexeme otext)]
-> f [Node (Lexeme otext)]
FilePath -> [Lexeme itext] -> f [Lexeme otext] -> f [Lexeme otext]
FilePath
-> Node (Lexeme itext)
-> f (Node (Lexeme otext))
-> f (Node (Lexeme otext))
FilePath -> Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext)
[(FilePath, [Node (Lexeme itext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
(FilePath, [Node (Lexeme itext)])
-> f (FilePath, [Node (Lexeme otext)])
-> f (FilePath, [Node (Lexeme otext)])
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 (Lexeme itext)
-> f (Node (Lexeme otext))
-> f (Node (Lexeme otext))
doNodes :: FilePath
-> [Node (Lexeme itext)]
-> f [Node (Lexeme otext)]
-> f [Node (Lexeme otext)]
doFile :: (FilePath, [Node (Lexeme itext)])
-> f (FilePath, [Node (Lexeme otext)])
-> f (FilePath, [Node (Lexeme otext)])
doFiles :: [(FilePath, [Node (Lexeme itext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
doText :: forall (f :: * -> *) itext otext.
AstActions f itext otext -> FilePath -> itext -> f otext
doLexeme :: forall (f :: * -> *) itext otext.
AstActions f itext otext
-> FilePath -> Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext)
doLexemes :: forall (f :: * -> *) itext otext.
AstActions f itext otext
-> FilePath
-> [Lexeme itext]
-> f [Lexeme otext]
-> f [Lexeme otext]
doNode :: forall (f :: * -> *) itext otext.
AstActions f itext otext
-> FilePath
-> Node (Lexeme itext)
-> f (Node (Lexeme otext))
-> f (Node (Lexeme otext))
doNodes :: forall (f :: * -> *) itext otext.
AstActions f itext otext
-> FilePath
-> [Node (Lexeme itext)]
-> f [Node (Lexeme otext)]
-> f [Node (Lexeme otext)]
doFile :: forall (f :: * -> *) itext otext.
AstActions f itext otext
-> (FilePath, [Node (Lexeme itext)])
-> f (FilePath, [Node (Lexeme otext)])
-> f (FilePath, [Node (Lexeme otext)])
doFiles :: forall (f :: * -> *) itext otext.
AstActions f itext otext
-> [(FilePath, [Node (Lexeme itext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
..} FilePath
currentFile = FilePath
-> [Node (Lexeme itext)]
-> f [Node (Lexeme otext)]
-> f [Node (Lexeme otext)]
doNodes FilePath
currentFile ([Node (Lexeme itext)]
 -> f [Node (Lexeme otext)] -> f [Node (Lexeme otext)])
-> ([Node (Lexeme itext)] -> f [Node (Lexeme otext)])
-> [Node (Lexeme itext)]
-> f [Node (Lexeme otext)]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
        (Node (Lexeme itext) -> f (Node (Lexeme otext)))
-> [Node (Lexeme itext)] -> f [Node (Lexeme otext)]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (AstActions f itext otext
-> FilePath
-> Node (Lexeme itext)
-> f (Mapped itext otext (Node (Lexeme itext)))
forall itext otext a (f :: * -> *).
(MapAst itext otext a, Applicative f) =>
AstActions f itext otext
-> FilePath -> a -> f (Mapped itext otext a)
mapFileAst AstActions f itext otext
actions FilePath
currentFile)

instance MapAst itext otext (FilePath, [Node (Lexeme itext)]) where
    type Mapped itext otext (FilePath, [Node (Lexeme itext)])
                          = (FilePath, [Node (Lexeme otext)])
    mapFileAst :: forall (f :: * -> *).
Applicative f =>
AstActions f itext otext
-> FilePath
-> (FilePath, [Node (Lexeme itext)])
-> f (Mapped itext otext (FilePath, [Node (Lexeme itext)]))
mapFileAst actions :: AstActions f itext otext
actions@AstActions{FilePath -> itext -> f otext
FilePath
-> [Node (Lexeme itext)]
-> f [Node (Lexeme otext)]
-> f [Node (Lexeme otext)]
FilePath -> [Lexeme itext] -> f [Lexeme otext] -> f [Lexeme otext]
FilePath
-> Node (Lexeme itext)
-> f (Node (Lexeme otext))
-> f (Node (Lexeme otext))
FilePath -> Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext)
[(FilePath, [Node (Lexeme itext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
(FilePath, [Node (Lexeme itext)])
-> f (FilePath, [Node (Lexeme otext)])
-> f (FilePath, [Node (Lexeme otext)])
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 (Lexeme itext)
-> f (Node (Lexeme otext))
-> f (Node (Lexeme otext))
doNodes :: FilePath
-> [Node (Lexeme itext)]
-> f [Node (Lexeme otext)]
-> f [Node (Lexeme otext)]
doFile :: (FilePath, [Node (Lexeme itext)])
-> f (FilePath, [Node (Lexeme otext)])
-> f (FilePath, [Node (Lexeme otext)])
doFiles :: [(FilePath, [Node (Lexeme itext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
doText :: forall (f :: * -> *) itext otext.
AstActions f itext otext -> FilePath -> itext -> f otext
doLexeme :: forall (f :: * -> *) itext otext.
AstActions f itext otext
-> FilePath -> Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext)
doLexemes :: forall (f :: * -> *) itext otext.
AstActions f itext otext
-> FilePath
-> [Lexeme itext]
-> f [Lexeme otext]
-> f [Lexeme otext]
doNode :: forall (f :: * -> *) itext otext.
AstActions f itext otext
-> FilePath
-> Node (Lexeme itext)
-> f (Node (Lexeme otext))
-> f (Node (Lexeme otext))
doNodes :: forall (f :: * -> *) itext otext.
AstActions f itext otext
-> FilePath
-> [Node (Lexeme itext)]
-> f [Node (Lexeme otext)]
-> f [Node (Lexeme otext)]
doFile :: forall (f :: * -> *) itext otext.
AstActions f itext otext
-> (FilePath, [Node (Lexeme itext)])
-> f (FilePath, [Node (Lexeme otext)])
-> f (FilePath, [Node (Lexeme otext)])
doFiles :: forall (f :: * -> *) itext otext.
AstActions f itext otext
-> [(FilePath, [Node (Lexeme itext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
..} FilePath
_ tu :: (FilePath, [Node (Lexeme itext)])
tu@(FilePath
currentFile, [Node (Lexeme itext)]
_) = (FilePath, [Node (Lexeme itext)])
-> f (FilePath, [Node (Lexeme otext)])
-> f (FilePath, [Node (Lexeme otext)])
(FilePath, [Node (Lexeme itext)])
-> f (FilePath, [Node (Lexeme otext)])
-> f (Mapped itext otext (FilePath, [Node (Lexeme itext)]))
doFile ((FilePath, [Node (Lexeme itext)])
 -> f (FilePath, [Node (Lexeme otext)])
 -> f (Mapped itext otext (FilePath, [Node (Lexeme itext)])))
-> ((FilePath, [Node (Lexeme itext)])
    -> f (FilePath, [Node (Lexeme otext)]))
-> (FilePath, [Node (Lexeme itext)])
-> f (Mapped itext otext (FilePath, [Node (Lexeme itext)]))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
        ([Node (Lexeme itext)] -> f [Node (Lexeme otext)])
-> (FilePath, [Node (Lexeme itext)])
-> f (FilePath, [Node (Lexeme otext)])
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (AstActions f itext otext
-> FilePath
-> [Node (Lexeme itext)]
-> f (Mapped itext otext [Node (Lexeme itext)])
forall itext otext a (f :: * -> *).
(MapAst itext otext a, Applicative f) =>
AstActions f itext otext
-> FilePath -> a -> f (Mapped itext otext a)
mapFileAst AstActions f itext otext
actions FilePath
currentFile) ((FilePath, [Node (Lexeme itext)])
 -> f (Mapped itext otext (FilePath, [Node (Lexeme itext)])))
-> (FilePath, [Node (Lexeme itext)])
-> f (Mapped itext otext (FilePath, [Node (Lexeme itext)]))
forall a b. (a -> b) -> a -> b
$ (FilePath, [Node (Lexeme itext)])
tu

instance MapAst itext otext [(FilePath, [Node (Lexeme itext)])] where
    type Mapped itext otext [(FilePath, [Node (Lexeme itext)])]
                          = [(FilePath, [Node (Lexeme otext)])]
    mapFileAst :: forall (f :: * -> *).
Applicative f =>
AstActions f itext otext
-> FilePath
-> [(FilePath, [Node (Lexeme itext)])]
-> f (Mapped itext otext [(FilePath, [Node (Lexeme itext)])])
mapFileAst actions :: AstActions f itext otext
actions@AstActions{FilePath -> itext -> f otext
FilePath
-> [Node (Lexeme itext)]
-> f [Node (Lexeme otext)]
-> f [Node (Lexeme otext)]
FilePath -> [Lexeme itext] -> f [Lexeme otext] -> f [Lexeme otext]
FilePath
-> Node (Lexeme itext)
-> f (Node (Lexeme otext))
-> f (Node (Lexeme otext))
FilePath -> Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext)
[(FilePath, [Node (Lexeme itext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
(FilePath, [Node (Lexeme itext)])
-> f (FilePath, [Node (Lexeme otext)])
-> f (FilePath, [Node (Lexeme otext)])
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 (Lexeme itext)
-> f (Node (Lexeme otext))
-> f (Node (Lexeme otext))
doNodes :: FilePath
-> [Node (Lexeme itext)]
-> f [Node (Lexeme otext)]
-> f [Node (Lexeme otext)]
doFile :: (FilePath, [Node (Lexeme itext)])
-> f (FilePath, [Node (Lexeme otext)])
-> f (FilePath, [Node (Lexeme otext)])
doFiles :: [(FilePath, [Node (Lexeme itext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
doText :: forall (f :: * -> *) itext otext.
AstActions f itext otext -> FilePath -> itext -> f otext
doLexeme :: forall (f :: * -> *) itext otext.
AstActions f itext otext
-> FilePath -> Lexeme itext -> f (Lexeme otext) -> f (Lexeme otext)
doLexemes :: forall (f :: * -> *) itext otext.
AstActions f itext otext
-> FilePath
-> [Lexeme itext]
-> f [Lexeme otext]
-> f [Lexeme otext]
doNode :: forall (f :: * -> *) itext otext.
AstActions f itext otext
-> FilePath
-> Node (Lexeme itext)
-> f (Node (Lexeme otext))
-> f (Node (Lexeme otext))
doNodes :: forall (f :: * -> *) itext otext.
AstActions f itext otext
-> FilePath
-> [Node (Lexeme itext)]
-> f [Node (Lexeme otext)]
-> f [Node (Lexeme otext)]
doFile :: forall (f :: * -> *) itext otext.
AstActions f itext otext
-> (FilePath, [Node (Lexeme itext)])
-> f (FilePath, [Node (Lexeme otext)])
-> f (FilePath, [Node (Lexeme otext)])
doFiles :: forall (f :: * -> *) itext otext.
AstActions f itext otext
-> [(FilePath, [Node (Lexeme itext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
..} FilePath
currentFile = [(FilePath, [Node (Lexeme itext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
doFiles ([(FilePath, [Node (Lexeme itext)])]
 -> f [(FilePath, [Node (Lexeme otext)])]
 -> f [(FilePath, [Node (Lexeme otext)])])
-> ([(FilePath, [Node (Lexeme itext)])]
    -> f [(FilePath, [Node (Lexeme otext)])])
-> [(FilePath, [Node (Lexeme itext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
        ((FilePath, [Node (Lexeme itext)])
 -> f (FilePath, [Node (Lexeme otext)]))
-> [(FilePath, [Node (Lexeme itext)])]
-> f [(FilePath, [Node (Lexeme otext)])]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (AstActions f itext otext
-> FilePath
-> (FilePath, [Node (Lexeme itext)])
-> f (Mapped itext otext (FilePath, [Node (Lexeme itext)]))
forall itext otext a (f :: * -> *).
(MapAst itext otext a, Applicative f) =>
AstActions f itext otext
-> FilePath -> a -> f (Mapped itext otext a)
mapFileAst AstActions f itext otext
actions FilePath
currentFile)