{-# LANGUAGE Rank2Types, GADTs #-}
{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE ScopedTypeVariables #-}
module PrintOcamlCode where
{-# LINE 2 "src-ag/Patterns.ag" #-}
import UU.Scanner.Position(Pos)
import CommonTypes (ConstructorIdent,Identifier)
{-# LINE 12 "dist/build/PrintOcamlCode.hs" #-}
{-# LINE 2 "src-ag/Code.ag" #-}
import Patterns
import Data.Set(Set)
import qualified Data.Set as Set
import Data.Map(Map)
import qualified Data.Map as Map
{-# LINE 21 "dist/build/PrintOcamlCode.hs" #-}
{-# LINE 10 "src-ag/PrintOcamlCode.ag" #-}
import Pretty
import Code
import Patterns
import Options
import CommonTypes hiding (List,Type,Map,Maybe,IntMap,Either)
import Data.List(intersperse,intercalate)
import Data.Char(toLower)
{-# LINE 32 "dist/build/PrintOcamlCode.hs" #-}
import Control.Monad.Identity (Identity)
import qualified Control.Monad.Identity
{-# LINE 146 "src-ag/Code.ag" #-}
mkTupleExpr :: Bool -> Bool -> Exprs -> Expr
mkTupleExpr unbox' noInh exprs | not unbox' || noInh || length exprs == 1 = TupleExpr exprs
| otherwise = UnboxedTupleExpr exprs
mkTupleType :: Bool -> Bool -> Types -> Type
mkTupleType unbox' noInh tps | not unbox' || noInh || length tps == 1 = TupleType tps
| otherwise = UnboxedTupleType tps
mkTupleLhs :: Bool -> Bool -> [String] -> Lhs
mkTupleLhs unbox' noInh comps | not unbox' || noInh || length comps == 1 = TupleLhs comps
| otherwise = UnboxedTupleLhs comps
{-# LINE 52 "dist/build/PrintOcamlCode.hs" #-}
{-# LINE 21 "src-ag/PrintOcamlCode.ag" #-}
type PP_Docs = [PP_Doc]
ppMultiSeqH :: [PP_Doc] -> PP_Doc -> PP_Doc
ppMultiSeqH = ppMultiSeq' (>#<)
ppMultiSeqV :: [PP_Doc] -> PP_Doc -> PP_Doc
ppMultiSeqV = ppMultiSeq' (>-<)
ppMultiSeq' :: (PP_Doc -> PP_Doc -> PP_Doc) -> [PP_Doc] -> PP_Doc -> PP_Doc
ppMultiSeq' next strictArgs expr
= foldr (\v r -> (v >#< "`seq`") `next` pp_parens r) expr strictArgs
ppTuple :: Bool -> [PP_Doc] -> PP_Doc
ppTuple True pps = "(" >|< pp_block " " (replicate (length pps `max` 1) ')') ",(" pps
ppTuple False pps = "(" >|< pp_block " " ")" "," pps
{-# LINE 71 "dist/build/PrintOcamlCode.hs" #-}
{-# LINE 177 "src-ag/PrintOcamlCode.ag" #-}
toOcamlTC :: String -> String
toOcamlTC (c:cs) = toLower c : cs
toOcamlTC xs = xs
{-# LINE 78 "dist/build/PrintOcamlCode.hs" #-}
data Inh_CaseAlt = Inh_CaseAlt { options_Inh_CaseAlt :: !(Options) }
data Syn_CaseAlt = Syn_CaseAlt { pp_Syn_CaseAlt :: !(PP_Doc) }
{-# INLINABLE wrap_CaseAlt #-}
wrap_CaseAlt :: T_CaseAlt -> Inh_CaseAlt -> (Syn_CaseAlt )
wrap_CaseAlt !(T_CaseAlt act) !(Inh_CaseAlt _lhsIoptions) =
Control.Monad.Identity.runIdentity (
do !sem <- act
let arg1 = T_CaseAlt_vIn1 _lhsIoptions
!(T_CaseAlt_vOut1 _lhsOpp) <- return (inv_CaseAlt_s2 sem arg1)
return (Syn_CaseAlt _lhsOpp)
)
{-# NOINLINE sem_CaseAlt #-}
sem_CaseAlt :: CaseAlt -> T_CaseAlt
sem_CaseAlt ( CaseAlt left_ expr_ ) = sem_CaseAlt_CaseAlt ( sem_Lhs left_ ) ( sem_Expr expr_ )
newtype T_CaseAlt = T_CaseAlt {
attach_T_CaseAlt :: Identity (T_CaseAlt_s2 )
}
newtype T_CaseAlt_s2 = C_CaseAlt_s2 {
inv_CaseAlt_s2 :: (T_CaseAlt_v1 )
}
data T_CaseAlt_s3 = C_CaseAlt_s3
type T_CaseAlt_v1 = (T_CaseAlt_vIn1 ) -> (T_CaseAlt_vOut1 )
data T_CaseAlt_vIn1 = T_CaseAlt_vIn1 (Options)
data T_CaseAlt_vOut1 = T_CaseAlt_vOut1 (PP_Doc)
{-# NOINLINE sem_CaseAlt_CaseAlt #-}
sem_CaseAlt_CaseAlt :: T_Lhs -> T_Expr -> T_CaseAlt
sem_CaseAlt_CaseAlt arg_left_ arg_expr_ = T_CaseAlt (return st2) where
{-# NOINLINE st2 #-}
!st2 = let
v1 :: T_CaseAlt_v1
v1 = \ !(T_CaseAlt_vIn1 _lhsIoptions) -> ( let
_leftX32 = Control.Monad.Identity.runIdentity (attach_T_Lhs (arg_left_))
_exprX26 = Control.Monad.Identity.runIdentity (attach_T_Expr (arg_expr_))
(T_Lhs_vOut31 _leftIpp) = inv_Lhs_s32 _leftX32 (T_Lhs_vIn31 _leftOoptions)
(T_Expr_vOut25 _exprIpp) = inv_Expr_s26 _exprX26 (T_Expr_vIn25 _exprOoptions)
_lhsOpp :: PP_Doc
_lhsOpp = rule0 _exprIpp _leftIpp
_leftOoptions = rule1 _lhsIoptions
_exprOoptions = rule2 _lhsIoptions
!__result_ = T_CaseAlt_vOut1 _lhsOpp
in __result_ )
in C_CaseAlt_s2 v1
{-# INLINE rule0 #-}
{-# LINE 184 "src-ag/PrintOcamlCode.ag" #-}
rule0 = \ ((_exprIpp) :: PP_Doc) ((_leftIpp) :: PP_Doc) ->
{-# LINE 184 "src-ag/PrintOcamlCode.ag" #-}
_leftIpp >#< "->" >#< _exprIpp
{-# LINE 132 "dist/build/PrintOcamlCode.hs"#-}
{-# INLINE rule1 #-}
rule1 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# INLINE rule2 #-}
rule2 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
data Inh_CaseAlts = Inh_CaseAlts { options_Inh_CaseAlts :: !(Options) }
data Syn_CaseAlts = Syn_CaseAlts { pps_Syn_CaseAlts :: !(PP_Docs) }
{-# INLINABLE wrap_CaseAlts #-}
wrap_CaseAlts :: T_CaseAlts -> Inh_CaseAlts -> (Syn_CaseAlts )
wrap_CaseAlts !(T_CaseAlts act) !(Inh_CaseAlts _lhsIoptions) =
Control.Monad.Identity.runIdentity (
do !sem <- act
let arg4 = T_CaseAlts_vIn4 _lhsIoptions
!(T_CaseAlts_vOut4 _lhsOpps) <- return (inv_CaseAlts_s5 sem arg4)
return (Syn_CaseAlts _lhsOpps)
)
{-# NOINLINE sem_CaseAlts #-}
sem_CaseAlts :: CaseAlts -> T_CaseAlts
sem_CaseAlts list = Prelude.foldr sem_CaseAlts_Cons sem_CaseAlts_Nil (Prelude.map sem_CaseAlt list)
newtype T_CaseAlts = T_CaseAlts {
attach_T_CaseAlts :: Identity (T_CaseAlts_s5 )
}
newtype T_CaseAlts_s5 = C_CaseAlts_s5 {
inv_CaseAlts_s5 :: (T_CaseAlts_v4 )
}
data T_CaseAlts_s6 = C_CaseAlts_s6
type T_CaseAlts_v4 = (T_CaseAlts_vIn4 ) -> (T_CaseAlts_vOut4 )
data T_CaseAlts_vIn4 = T_CaseAlts_vIn4 (Options)
data T_CaseAlts_vOut4 = T_CaseAlts_vOut4 (PP_Docs)
{-# NOINLINE sem_CaseAlts_Cons #-}
sem_CaseAlts_Cons :: T_CaseAlt -> T_CaseAlts -> T_CaseAlts
sem_CaseAlts_Cons arg_hd_ arg_tl_ = T_CaseAlts (return st5) where
{-# NOINLINE st5 #-}
!st5 = let
v4 :: T_CaseAlts_v4
v4 = \ !(T_CaseAlts_vIn4 _lhsIoptions) -> ( let
_hdX2 = Control.Monad.Identity.runIdentity (attach_T_CaseAlt (arg_hd_))
_tlX5 = Control.Monad.Identity.runIdentity (attach_T_CaseAlts (arg_tl_))
(T_CaseAlt_vOut1 _hdIpp) = inv_CaseAlt_s2 _hdX2 (T_CaseAlt_vIn1 _hdOoptions)
(T_CaseAlts_vOut4 _tlIpps) = inv_CaseAlts_s5 _tlX5 (T_CaseAlts_vIn4 _tlOoptions)
_lhsOpps :: PP_Docs
_lhsOpps = rule3 _hdIpp _tlIpps
_hdOoptions = rule4 _lhsIoptions
_tlOoptions = rule5 _lhsIoptions
!__result_ = T_CaseAlts_vOut4 _lhsOpps
in __result_ )
in C_CaseAlts_s5 v4
{-# INLINE rule3 #-}
{-# LINE 65 "src-ag/PrintOcamlCode.ag" #-}
rule3 = \ ((_hdIpp) :: PP_Doc) ((_tlIpps) :: PP_Docs) ->
{-# LINE 65 "src-ag/PrintOcamlCode.ag" #-}
_hdIpp : _tlIpps
{-# LINE 193 "dist/build/PrintOcamlCode.hs"#-}
{-# INLINE rule4 #-}
rule4 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# INLINE rule5 #-}
rule5 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# NOINLINE sem_CaseAlts_Nil #-}
sem_CaseAlts_Nil :: T_CaseAlts
sem_CaseAlts_Nil = T_CaseAlts (return st5) where
{-# NOINLINE st5 #-}
!st5 = let
v4 :: T_CaseAlts_v4
v4 = \ !(T_CaseAlts_vIn4 _lhsIoptions) -> ( let
_lhsOpps :: PP_Docs
_lhsOpps = rule6 ()
!__result_ = T_CaseAlts_vOut4 _lhsOpps
in __result_ )
in C_CaseAlts_s5 v4
{-# INLINE rule6 #-}
{-# LINE 66 "src-ag/PrintOcamlCode.ag" #-}
rule6 = \ (_ :: ()) ->
{-# LINE 66 "src-ag/PrintOcamlCode.ag" #-}
[]
{-# LINE 217 "dist/build/PrintOcamlCode.hs"#-}
data Inh_Chunk = Inh_Chunk { isToplevel_Inh_Chunk :: !(Bool), options_Inh_Chunk :: !(Options), textBlockMap_Inh_Chunk :: !(Map BlockInfo PP_Doc) }
data Syn_Chunk = Syn_Chunk { pps_Syn_Chunk :: !(PP_Docs) }
{-# INLINABLE wrap_Chunk #-}
wrap_Chunk :: T_Chunk -> Inh_Chunk -> (Syn_Chunk )
wrap_Chunk !(T_Chunk act) !(Inh_Chunk _lhsIisToplevel _lhsIoptions _lhsItextBlockMap) =
Control.Monad.Identity.runIdentity (
do !sem <- act
let arg7 = T_Chunk_vIn7 _lhsIisToplevel _lhsIoptions _lhsItextBlockMap
!(T_Chunk_vOut7 _lhsOpps) <- return (inv_Chunk_s8 sem arg7)
return (Syn_Chunk _lhsOpps)
)
{-# INLINE sem_Chunk #-}
sem_Chunk :: Chunk -> T_Chunk
sem_Chunk ( Chunk !name_ comment_ info_ dataDef_ cataFun_ semDom_ semWrapper_ semFunctions_ !semNames_ ) = sem_Chunk_Chunk name_ ( sem_Decl comment_ ) ( sem_Decls info_ ) ( sem_Decls dataDef_ ) ( sem_Decls cataFun_ ) ( sem_Decls semDom_ ) ( sem_Decls semWrapper_ ) ( sem_Decls semFunctions_ ) semNames_
newtype T_Chunk = T_Chunk {
attach_T_Chunk :: Identity (T_Chunk_s8 )
}
newtype T_Chunk_s8 = C_Chunk_s8 {
inv_Chunk_s8 :: (T_Chunk_v7 )
}
data T_Chunk_s9 = C_Chunk_s9
type T_Chunk_v7 = (T_Chunk_vIn7 ) -> (T_Chunk_vOut7 )
data T_Chunk_vIn7 = T_Chunk_vIn7 (Bool) (Options) (Map BlockInfo PP_Doc)
data T_Chunk_vOut7 = T_Chunk_vOut7 (PP_Docs)
{-# NOINLINE sem_Chunk_Chunk #-}
sem_Chunk_Chunk :: (String) -> T_Decl -> T_Decls -> T_Decls -> T_Decls -> T_Decls -> T_Decls -> T_Decls -> ([String]) -> T_Chunk
sem_Chunk_Chunk !arg_name_ arg_comment_ arg_info_ arg_dataDef_ arg_cataFun_ arg_semDom_ arg_semWrapper_ arg_semFunctions_ _ = T_Chunk (return st8) where
{-# NOINLINE st8 #-}
!st8 = let
v7 :: T_Chunk_v7
v7 = \ !(T_Chunk_vIn7 _lhsIisToplevel _lhsIoptions _lhsItextBlockMap) -> ( let
_commentX20 = Control.Monad.Identity.runIdentity (attach_T_Decl (arg_comment_))
_infoX23 = Control.Monad.Identity.runIdentity (attach_T_Decls (arg_info_))
_dataDefX23 = Control.Monad.Identity.runIdentity (attach_T_Decls (arg_dataDef_))
_cataFunX23 = Control.Monad.Identity.runIdentity (attach_T_Decls (arg_cataFun_))
_semDomX23 = Control.Monad.Identity.runIdentity (attach_T_Decls (arg_semDom_))
_semWrapperX23 = Control.Monad.Identity.runIdentity (attach_T_Decls (arg_semWrapper_))
_semFunctionsX23 = Control.Monad.Identity.runIdentity (attach_T_Decls (arg_semFunctions_))
(T_Decl_vOut19 _commentIpp) = inv_Decl_s20 _commentX20 (T_Decl_vIn19 _commentOisToplevel _commentOoptions)
(T_Decls_vOut22 _infoIpps) = inv_Decls_s23 _infoX23 (T_Decls_vIn22 _infoOisToplevel _infoOoptions)
(T_Decls_vOut22 _dataDefIpps) = inv_Decls_s23 _dataDefX23 (T_Decls_vIn22 _dataDefOisToplevel _dataDefOoptions)
(T_Decls_vOut22 _cataFunIpps) = inv_Decls_s23 _cataFunX23 (T_Decls_vIn22 _cataFunOisToplevel _cataFunOoptions)
(T_Decls_vOut22 _semDomIpps) = inv_Decls_s23 _semDomX23 (T_Decls_vIn22 _semDomOisToplevel _semDomOoptions)
(T_Decls_vOut22 _semWrapperIpps) = inv_Decls_s23 _semWrapperX23 (T_Decls_vIn22 _semWrapperOisToplevel _semWrapperOoptions)
(T_Decls_vOut22 _semFunctionsIpps) = inv_Decls_s23 _semFunctionsX23 (T_Decls_vIn22 _semFunctionsOisToplevel _semFunctionsOoptions)
_lhsOpps :: PP_Docs
_lhsOpps = rule7 _cataFunIpps _commentIpp _dataDefIpps _infoIpps _lhsItextBlockMap _semDomIpps _semFunctionsIpps _semWrapperIpps arg_name_
_commentOisToplevel = rule8 _lhsIisToplevel
_commentOoptions = rule9 _lhsIoptions
_infoOisToplevel = rule10 _lhsIisToplevel
_infoOoptions = rule11 _lhsIoptions
_dataDefOisToplevel = rule12 _lhsIisToplevel
_dataDefOoptions = rule13 _lhsIoptions
_cataFunOisToplevel = rule14 _lhsIisToplevel
_cataFunOoptions = rule15 _lhsIoptions
_semDomOisToplevel = rule16 _lhsIisToplevel
_semDomOoptions = rule17 _lhsIoptions
_semWrapperOisToplevel = rule18 _lhsIisToplevel
_semWrapperOoptions = rule19 _lhsIoptions
_semFunctionsOisToplevel = rule20 _lhsIisToplevel
_semFunctionsOoptions = rule21 _lhsIoptions
!__result_ = T_Chunk_vOut7 _lhsOpps
in __result_ )
in C_Chunk_s8 v7
{-# INLINE rule7 #-}
{-# LINE 97 "src-ag/PrintOcamlCode.ag" #-}
rule7 = \ ((_cataFunIpps) :: PP_Docs) ((_commentIpp) :: PP_Doc) ((_dataDefIpps) :: PP_Docs) ((_infoIpps) :: PP_Docs) ((_lhsItextBlockMap) :: Map BlockInfo PP_Doc) ((_semDomIpps) :: PP_Docs) ((_semFunctionsIpps) :: PP_Docs) ((_semWrapperIpps) :: PP_Docs) name_ ->
{-# LINE 97 "src-ag/PrintOcamlCode.ag" #-}
_commentIpp
: _infoIpps
++ _dataDefIpps
++ _semDomIpps
++ _semFunctionsIpps
++ _semWrapperIpps
++ _cataFunIpps
++ [Map.findWithDefault empty (BlockOther, Just $ identifier name_) _lhsItextBlockMap]
{-# LINE 301 "dist/build/PrintOcamlCode.hs"#-}
{-# INLINE rule8 #-}
rule8 = \ ((_lhsIisToplevel) :: Bool) ->
_lhsIisToplevel
{-# INLINE rule9 #-}
rule9 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# INLINE rule10 #-}
rule10 = \ ((_lhsIisToplevel) :: Bool) ->
_lhsIisToplevel
{-# INLINE rule11 #-}
rule11 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# INLINE rule12 #-}
rule12 = \ ((_lhsIisToplevel) :: Bool) ->
_lhsIisToplevel
{-# INLINE rule13 #-}
rule13 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# INLINE rule14 #-}
rule14 = \ ((_lhsIisToplevel) :: Bool) ->
_lhsIisToplevel
{-# INLINE rule15 #-}
rule15 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# INLINE rule16 #-}
rule16 = \ ((_lhsIisToplevel) :: Bool) ->
_lhsIisToplevel
{-# INLINE rule17 #-}
rule17 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# INLINE rule18 #-}
rule18 = \ ((_lhsIisToplevel) :: Bool) ->
_lhsIisToplevel
{-# INLINE rule19 #-}
rule19 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# INLINE rule20 #-}
rule20 = \ ((_lhsIisToplevel) :: Bool) ->
_lhsIisToplevel
{-# INLINE rule21 #-}
rule21 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
data Inh_Chunks = Inh_Chunks { isToplevel_Inh_Chunks :: !(Bool), options_Inh_Chunks :: !(Options), textBlockMap_Inh_Chunks :: !(Map BlockInfo PP_Doc) }
data Syn_Chunks = Syn_Chunks { pps_Syn_Chunks :: !(PP_Docs) }
{-# INLINABLE wrap_Chunks #-}
wrap_Chunks :: T_Chunks -> Inh_Chunks -> (Syn_Chunks )
wrap_Chunks !(T_Chunks act) !(Inh_Chunks _lhsIisToplevel _lhsIoptions _lhsItextBlockMap) =
Control.Monad.Identity.runIdentity (
do !sem <- act
let arg10 = T_Chunks_vIn10 _lhsIisToplevel _lhsIoptions _lhsItextBlockMap
!(T_Chunks_vOut10 _lhsOpps) <- return (inv_Chunks_s11 sem arg10)
return (Syn_Chunks _lhsOpps)
)
{-# NOINLINE sem_Chunks #-}
sem_Chunks :: Chunks -> T_Chunks
sem_Chunks list = Prelude.foldr sem_Chunks_Cons sem_Chunks_Nil (Prelude.map sem_Chunk list)
newtype T_Chunks = T_Chunks {
attach_T_Chunks :: Identity (T_Chunks_s11 )
}
newtype T_Chunks_s11 = C_Chunks_s11 {
inv_Chunks_s11 :: (T_Chunks_v10 )
}
data T_Chunks_s12 = C_Chunks_s12
type T_Chunks_v10 = (T_Chunks_vIn10 ) -> (T_Chunks_vOut10 )
data T_Chunks_vIn10 = T_Chunks_vIn10 (Bool) (Options) (Map BlockInfo PP_Doc)
data T_Chunks_vOut10 = T_Chunks_vOut10 (PP_Docs)
{-# NOINLINE sem_Chunks_Cons #-}
sem_Chunks_Cons :: T_Chunk -> T_Chunks -> T_Chunks
sem_Chunks_Cons arg_hd_ arg_tl_ = T_Chunks (return st11) where
{-# NOINLINE st11 #-}
!st11 = let
v10 :: T_Chunks_v10
v10 = \ !(T_Chunks_vIn10 _lhsIisToplevel _lhsIoptions _lhsItextBlockMap) -> ( let
_hdX8 = Control.Monad.Identity.runIdentity (attach_T_Chunk (arg_hd_))
_tlX11 = Control.Monad.Identity.runIdentity (attach_T_Chunks (arg_tl_))
(T_Chunk_vOut7 _hdIpps) = inv_Chunk_s8 _hdX8 (T_Chunk_vIn7 _hdOisToplevel _hdOoptions _hdOtextBlockMap)
(T_Chunks_vOut10 _tlIpps) = inv_Chunks_s11 _tlX11 (T_Chunks_vIn10 _tlOisToplevel _tlOoptions _tlOtextBlockMap)
_lhsOpps :: PP_Docs
_lhsOpps = rule22 _hdIpps _tlIpps
_hdOisToplevel = rule23 _lhsIisToplevel
_hdOoptions = rule24 _lhsIoptions
_hdOtextBlockMap = rule25 _lhsItextBlockMap
_tlOisToplevel = rule26 _lhsIisToplevel
_tlOoptions = rule27 _lhsIoptions
_tlOtextBlockMap = rule28 _lhsItextBlockMap
!__result_ = T_Chunks_vOut10 _lhsOpps
in __result_ )
in C_Chunks_s11 v10
{-# INLINE rule22 #-}
{-# LINE 85 "src-ag/PrintOcamlCode.ag" #-}
rule22 = \ ((_hdIpps) :: PP_Docs) ((_tlIpps) :: PP_Docs) ->
{-# LINE 85 "src-ag/PrintOcamlCode.ag" #-}
_hdIpps ++ _tlIpps
{-# LINE 402 "dist/build/PrintOcamlCode.hs"#-}
{-# INLINE rule23 #-}
rule23 = \ ((_lhsIisToplevel) :: Bool) ->
_lhsIisToplevel
{-# INLINE rule24 #-}
rule24 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# INLINE rule25 #-}
rule25 = \ ((_lhsItextBlockMap) :: Map BlockInfo PP_Doc) ->
_lhsItextBlockMap
{-# INLINE rule26 #-}
rule26 = \ ((_lhsIisToplevel) :: Bool) ->
_lhsIisToplevel
{-# INLINE rule27 #-}
rule27 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# INLINE rule28 #-}
rule28 = \ ((_lhsItextBlockMap) :: Map BlockInfo PP_Doc) ->
_lhsItextBlockMap
{-# NOINLINE sem_Chunks_Nil #-}
sem_Chunks_Nil :: T_Chunks
sem_Chunks_Nil = T_Chunks (return st11) where
{-# NOINLINE st11 #-}
!st11 = let
v10 :: T_Chunks_v10
v10 = \ !(T_Chunks_vIn10 _lhsIisToplevel _lhsIoptions _lhsItextBlockMap) -> ( let
_lhsOpps :: PP_Docs
_lhsOpps = rule29 ()
!__result_ = T_Chunks_vOut10 _lhsOpps
in __result_ )
in C_Chunks_s11 v10
{-# INLINE rule29 #-}
{-# LINE 86 "src-ag/PrintOcamlCode.ag" #-}
rule29 = \ (_ :: ()) ->
{-# LINE 86 "src-ag/PrintOcamlCode.ag" #-}
[]
{-# LINE 438 "dist/build/PrintOcamlCode.hs"#-}
data Inh_DataAlt = Inh_DataAlt { }
data Syn_DataAlt = Syn_DataAlt { pp_Syn_DataAlt :: !(PP_Doc) }
{-# INLINABLE wrap_DataAlt #-}
wrap_DataAlt :: T_DataAlt -> Inh_DataAlt -> (Syn_DataAlt )
wrap_DataAlt !(T_DataAlt act) !(Inh_DataAlt ) =
Control.Monad.Identity.runIdentity (
do !sem <- act
let arg13 = T_DataAlt_vIn13
!(T_DataAlt_vOut13 _lhsOpp) <- return (inv_DataAlt_s14 sem arg13)
return (Syn_DataAlt _lhsOpp)
)
{-# NOINLINE sem_DataAlt #-}
sem_DataAlt :: DataAlt -> T_DataAlt
sem_DataAlt ( DataAlt !name_ args_ ) = sem_DataAlt_DataAlt name_ ( sem_Types args_ )
sem_DataAlt ( Record !name_ args_ ) = sem_DataAlt_Record name_ ( sem_NamedTypes args_ )
newtype T_DataAlt = T_DataAlt {
attach_T_DataAlt :: Identity (T_DataAlt_s14 )
}
newtype T_DataAlt_s14 = C_DataAlt_s14 {
inv_DataAlt_s14 :: (T_DataAlt_v13 )
}
data T_DataAlt_s15 = C_DataAlt_s15
type T_DataAlt_v13 = (T_DataAlt_vIn13 ) -> (T_DataAlt_vOut13 )
data T_DataAlt_vIn13 = T_DataAlt_vIn13
data T_DataAlt_vOut13 = T_DataAlt_vOut13 (PP_Doc)
{-# NOINLINE sem_DataAlt_DataAlt #-}
sem_DataAlt_DataAlt :: (String) -> T_Types -> T_DataAlt
sem_DataAlt_DataAlt !arg_name_ arg_args_ = T_DataAlt (return st14) where
{-# NOINLINE st14 #-}
!st14 = let
v13 :: T_DataAlt_v13
v13 = \ !(T_DataAlt_vIn13 ) -> ( let
_argsX53 = Control.Monad.Identity.runIdentity (attach_T_Types (arg_args_))
(T_Types_vOut52 _argsIpps) = inv_Types_s53 _argsX53 (T_Types_vIn52 )
_lhsOpp :: PP_Doc
_lhsOpp = rule30 _argsIpps arg_name_
!__result_ = T_DataAlt_vOut13 _lhsOpp
in __result_ )
in C_DataAlt_s14 v13
{-# INLINE rule30 #-}
{-# LINE 187 "src-ag/PrintOcamlCode.ag" #-}
rule30 = \ ((_argsIpps) :: PP_Docs) name_ ->
{-# LINE 187 "src-ag/PrintOcamlCode.ag" #-}
name_ >#< "of" >#< pp_block "" "" " * " (map pp_parens _argsIpps)
{-# LINE 490 "dist/build/PrintOcamlCode.hs"#-}
{-# NOINLINE sem_DataAlt_Record #-}
sem_DataAlt_Record :: (String) -> T_NamedTypes -> T_DataAlt
sem_DataAlt_Record _ arg_args_ = T_DataAlt (return st14) where
{-# NOINLINE st14 #-}
!st14 = let
v13 :: T_DataAlt_v13
v13 = \ !(T_DataAlt_vIn13 ) -> ( let
_argsX38 = Control.Monad.Identity.runIdentity (attach_T_NamedTypes (arg_args_))
(T_NamedTypes_vOut37 _argsIpps) = inv_NamedTypes_s38 _argsX38 (T_NamedTypes_vIn37 )
_lhsOpp :: PP_Doc
_lhsOpp = rule31 _argsIpps
!__result_ = T_DataAlt_vOut13 _lhsOpp
in __result_ )
in C_DataAlt_s14 v13
{-# INLINE rule31 #-}
{-# LINE 188 "src-ag/PrintOcamlCode.ag" #-}
rule31 = \ ((_argsIpps) :: PP_Docs) ->
{-# LINE 188 "src-ag/PrintOcamlCode.ag" #-}
pp_block "{" "}" ";" _argsIpps
{-# LINE 510 "dist/build/PrintOcamlCode.hs"#-}
data Inh_DataAlts = Inh_DataAlts { }
data Syn_DataAlts = Syn_DataAlts { pps_Syn_DataAlts :: !(PP_Docs) }
{-# INLINABLE wrap_DataAlts #-}
wrap_DataAlts :: T_DataAlts -> Inh_DataAlts -> (Syn_DataAlts )
wrap_DataAlts !(T_DataAlts act) !(Inh_DataAlts ) =
Control.Monad.Identity.runIdentity (
do !sem <- act
let arg16 = T_DataAlts_vIn16
!(T_DataAlts_vOut16 _lhsOpps) <- return (inv_DataAlts_s17 sem arg16)
return (Syn_DataAlts _lhsOpps)
)
{-# NOINLINE sem_DataAlts #-}
sem_DataAlts :: DataAlts -> T_DataAlts
sem_DataAlts list = Prelude.foldr sem_DataAlts_Cons sem_DataAlts_Nil (Prelude.map sem_DataAlt list)
newtype T_DataAlts = T_DataAlts {
attach_T_DataAlts :: Identity (T_DataAlts_s17 )
}
newtype T_DataAlts_s17 = C_DataAlts_s17 {
inv_DataAlts_s17 :: (T_DataAlts_v16 )
}
data T_DataAlts_s18 = C_DataAlts_s18
type T_DataAlts_v16 = (T_DataAlts_vIn16 ) -> (T_DataAlts_vOut16 )
data T_DataAlts_vIn16 = T_DataAlts_vIn16
data T_DataAlts_vOut16 = T_DataAlts_vOut16 (PP_Docs)
{-# NOINLINE sem_DataAlts_Cons #-}
sem_DataAlts_Cons :: T_DataAlt -> T_DataAlts -> T_DataAlts
sem_DataAlts_Cons arg_hd_ arg_tl_ = T_DataAlts (return st17) where
{-# NOINLINE st17 #-}
!st17 = let
v16 :: T_DataAlts_v16
v16 = \ !(T_DataAlts_vIn16 ) -> ( let
_hdX14 = Control.Monad.Identity.runIdentity (attach_T_DataAlt (arg_hd_))
_tlX17 = Control.Monad.Identity.runIdentity (attach_T_DataAlts (arg_tl_))
(T_DataAlt_vOut13 _hdIpp) = inv_DataAlt_s14 _hdX14 (T_DataAlt_vIn13 )
(T_DataAlts_vOut16 _tlIpps) = inv_DataAlts_s17 _tlX17 (T_DataAlts_vIn16 )
_lhsOpps :: PP_Docs
_lhsOpps = rule32 _hdIpp _tlIpps
!__result_ = T_DataAlts_vOut16 _lhsOpps
in __result_ )
in C_DataAlts_s17 v16
{-# INLINE rule32 #-}
{-# LINE 69 "src-ag/PrintOcamlCode.ag" #-}
rule32 = \ ((_hdIpp) :: PP_Doc) ((_tlIpps) :: PP_Docs) ->
{-# LINE 69 "src-ag/PrintOcamlCode.ag" #-}
_hdIpp : _tlIpps
{-# LINE 563 "dist/build/PrintOcamlCode.hs"#-}
{-# NOINLINE sem_DataAlts_Nil #-}
sem_DataAlts_Nil :: T_DataAlts
sem_DataAlts_Nil = T_DataAlts (return st17) where
{-# NOINLINE st17 #-}
!st17 = let
v16 :: T_DataAlts_v16
v16 = \ !(T_DataAlts_vIn16 ) -> ( let
_lhsOpps :: PP_Docs
_lhsOpps = rule33 ()
!__result_ = T_DataAlts_vOut16 _lhsOpps
in __result_ )
in C_DataAlts_s17 v16
{-# INLINE rule33 #-}
{-# LINE 70 "src-ag/PrintOcamlCode.ag" #-}
rule33 = \ (_ :: ()) ->
{-# LINE 70 "src-ag/PrintOcamlCode.ag" #-}
[]
{-# LINE 581 "dist/build/PrintOcamlCode.hs"#-}
data Inh_Decl = Inh_Decl { isToplevel_Inh_Decl :: !(Bool), options_Inh_Decl :: !(Options) }
data Syn_Decl = Syn_Decl { pp_Syn_Decl :: !(PP_Doc) }
{-# INLINABLE wrap_Decl #-}
wrap_Decl :: T_Decl -> Inh_Decl -> (Syn_Decl )
wrap_Decl !(T_Decl act) !(Inh_Decl _lhsIisToplevel _lhsIoptions) =
Control.Monad.Identity.runIdentity (
do !sem <- act
let arg19 = T_Decl_vIn19 _lhsIisToplevel _lhsIoptions
!(T_Decl_vOut19 _lhsOpp) <- return (inv_Decl_s20 sem arg19)
return (Syn_Decl _lhsOpp)
)
{-# NOINLINE sem_Decl #-}
sem_Decl :: Decl -> T_Decl
sem_Decl ( Decl left_ rhs_ !binds_ !uses_ ) = sem_Decl_Decl ( sem_Lhs left_ ) ( sem_Expr rhs_ ) binds_ uses_
sem_Decl ( Bind left_ rhs_ ) = sem_Decl_Bind ( sem_Lhs left_ ) ( sem_Expr rhs_ )
sem_Decl ( BindLet left_ rhs_ ) = sem_Decl_BindLet ( sem_Lhs left_ ) ( sem_Expr rhs_ )
sem_Decl ( Data !name_ !params_ alts_ !strict_ !derivings_ ) = sem_Decl_Data name_ params_ ( sem_DataAlts alts_ ) strict_ derivings_
sem_Decl ( NewType !name_ !params_ !con_ tp_ ) = sem_Decl_NewType name_ params_ con_ ( sem_Type tp_ )
sem_Decl ( Type !name_ !params_ tp_ ) = sem_Decl_Type name_ params_ ( sem_Type tp_ )
sem_Decl ( TSig !name_ tp_ ) = sem_Decl_TSig name_ ( sem_Type tp_ )
sem_Decl ( Comment !txt_ ) = sem_Decl_Comment txt_
sem_Decl ( PragmaDecl !txt_ ) = sem_Decl_PragmaDecl txt_
sem_Decl ( Resume !monadic_ !nt_ left_ rhs_ ) = sem_Decl_Resume monadic_ nt_ ( sem_Lhs left_ ) ( sem_Expr rhs_ )
sem_Decl ( EvalDecl !nt_ left_ rhs_ ) = sem_Decl_EvalDecl nt_ ( sem_Lhs left_ ) ( sem_Expr rhs_ )
newtype T_Decl = T_Decl {
attach_T_Decl :: Identity (T_Decl_s20 )
}
newtype T_Decl_s20 = C_Decl_s20 {
inv_Decl_s20 :: (T_Decl_v19 )
}
data T_Decl_s21 = C_Decl_s21
type T_Decl_v19 = (T_Decl_vIn19 ) -> (T_Decl_vOut19 )
data T_Decl_vIn19 = T_Decl_vIn19 (Bool) (Options)
data T_Decl_vOut19 = T_Decl_vOut19 (PP_Doc)
{-# NOINLINE sem_Decl_Decl #-}
sem_Decl_Decl :: T_Lhs -> T_Expr -> (Set String) -> (Set String) -> T_Decl
sem_Decl_Decl arg_left_ arg_rhs_ _ _ = T_Decl (return st20) where
{-# NOINLINE st20 #-}
!st20 = let
v19 :: T_Decl_v19
v19 = \ !(T_Decl_vIn19 _lhsIisToplevel _lhsIoptions) -> ( let
_leftX32 = Control.Monad.Identity.runIdentity (attach_T_Lhs (arg_left_))
_rhsX26 = Control.Monad.Identity.runIdentity (attach_T_Expr (arg_rhs_))
(T_Lhs_vOut31 _leftIpp) = inv_Lhs_s32 _leftX32 (T_Lhs_vIn31 _leftOoptions)
(T_Expr_vOut25 _rhsIpp) = inv_Expr_s26 _rhsX26 (T_Expr_vIn25 _rhsOoptions)
_lhsOpp :: PP_Doc
_lhsOpp = rule34 _leftIpp _lhsIisToplevel _rhsIpp
_leftOoptions = rule35 _lhsIoptions
_rhsOoptions = rule36 _lhsIoptions
!__result_ = T_Decl_vOut19 _lhsOpp
in __result_ )
in C_Decl_s20 v19
{-# INLINE rule34 #-}
{-# LINE 107 "src-ag/PrintOcamlCode.ag" #-}
rule34 = \ ((_leftIpp) :: PP_Doc) ((_lhsIisToplevel) :: Bool) ((_rhsIpp) :: PP_Doc) ->
{-# LINE 107 "src-ag/PrintOcamlCode.ag" #-}
if _lhsIisToplevel
then "let" >#< _leftIpp >#< "="
>-< indent 4 _rhsIpp >#< ";;"
else "let" >#< _leftIpp >#< "="
>-< indent 4 _rhsIpp >#< "in"
{-# LINE 650 "dist/build/PrintOcamlCode.hs"#-}
{-# INLINE rule35 #-}
rule35 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# INLINE rule36 #-}
rule36 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# NOINLINE sem_Decl_Bind #-}
sem_Decl_Bind :: T_Lhs -> T_Expr -> T_Decl
sem_Decl_Bind arg_left_ arg_rhs_ = T_Decl (return st20) where
{-# NOINLINE st20 #-}
!st20 = let
v19 :: T_Decl_v19
v19 = \ !(T_Decl_vIn19 _lhsIisToplevel _lhsIoptions) -> ( let
_leftX32 = Control.Monad.Identity.runIdentity (attach_T_Lhs (arg_left_))
_rhsX26 = Control.Monad.Identity.runIdentity (attach_T_Expr (arg_rhs_))
(T_Lhs_vOut31 _leftIpp) = inv_Lhs_s32 _leftX32 (T_Lhs_vIn31 _leftOoptions)
(T_Expr_vOut25 _rhsIpp) = inv_Expr_s26 _rhsX26 (T_Expr_vIn25 _rhsOoptions)
_lhsOpp :: PP_Doc
_lhsOpp = rule37 ()
_leftOoptions = rule38 _lhsIoptions
_rhsOoptions = rule39 _lhsIoptions
!__result_ = T_Decl_vOut19 _lhsOpp
in __result_ )
in C_Decl_s20 v19
{-# INLINE rule37 #-}
{-# LINE 112 "src-ag/PrintOcamlCode.ag" #-}
rule37 = \ (_ :: ()) ->
{-# LINE 112 "src-ag/PrintOcamlCode.ag" #-}
error "pp of Decl.Bind not supported"
{-# LINE 680 "dist/build/PrintOcamlCode.hs"#-}
{-# INLINE rule38 #-}
rule38 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# INLINE rule39 #-}
rule39 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# NOINLINE sem_Decl_BindLet #-}
sem_Decl_BindLet :: T_Lhs -> T_Expr -> T_Decl
sem_Decl_BindLet arg_left_ arg_rhs_ = T_Decl (return st20) where
{-# NOINLINE st20 #-}
!st20 = let
v19 :: T_Decl_v19
v19 = \ !(T_Decl_vIn19 _lhsIisToplevel _lhsIoptions) -> ( let
_leftX32 = Control.Monad.Identity.runIdentity (attach_T_Lhs (arg_left_))
_rhsX26 = Control.Monad.Identity.runIdentity (attach_T_Expr (arg_rhs_))
(T_Lhs_vOut31 _leftIpp) = inv_Lhs_s32 _leftX32 (T_Lhs_vIn31 _leftOoptions)
(T_Expr_vOut25 _rhsIpp) = inv_Expr_s26 _rhsX26 (T_Expr_vIn25 _rhsOoptions)
_lhsOpp :: PP_Doc
_lhsOpp = rule40 ()
_leftOoptions = rule41 _lhsIoptions
_rhsOoptions = rule42 _lhsIoptions
!__result_ = T_Decl_vOut19 _lhsOpp
in __result_ )
in C_Decl_s20 v19
{-# INLINE rule40 #-}
{-# LINE 113 "src-ag/PrintOcamlCode.ag" #-}
rule40 = \ (_ :: ()) ->
{-# LINE 113 "src-ag/PrintOcamlCode.ag" #-}
error "pp of Decl.BindLet not supported"
{-# LINE 710 "dist/build/PrintOcamlCode.hs"#-}
{-# INLINE rule41 #-}
rule41 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# INLINE rule42 #-}
rule42 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# NOINLINE sem_Decl_Data #-}
sem_Decl_Data :: (String) -> ([String]) -> T_DataAlts -> (Bool) -> ([String]) -> T_Decl
sem_Decl_Data !arg_name_ !arg_params_ arg_alts_ _ _ = T_Decl (return st20) where
{-# NOINLINE st20 #-}
!st20 = let
v19 :: T_Decl_v19
v19 = \ !(T_Decl_vIn19 _lhsIisToplevel _lhsIoptions) -> ( let
_altsX17 = Control.Monad.Identity.runIdentity (attach_T_DataAlts (arg_alts_))
(T_DataAlts_vOut16 _altsIpps) = inv_DataAlts_s17 _altsX17 (T_DataAlts_vIn16 )
_lhsOpp :: PP_Doc
_lhsOpp = rule43 _altsIpps arg_name_ arg_params_
!__result_ = T_Decl_vOut19 _lhsOpp
in __result_ )
in C_Decl_s20 v19
{-# INLINE rule43 #-}
{-# LINE 114 "src-ag/PrintOcamlCode.ag" #-}
rule43 = \ ((_altsIpps) :: PP_Docs) name_ params_ ->
{-# LINE 114 "src-ag/PrintOcamlCode.ag" #-}
"type" >#< hv_sp (map (\p -> "'" >|< p) params_ ++ [text $ toOcamlTC name_])
>#< ( case _altsIpps of
[] -> empty
(x:xs) -> "=" >#< x
>-< vlist (map ("|" >#<) xs)
)
>#< ";;"
{-# LINE 742 "dist/build/PrintOcamlCode.hs"#-}
{-# NOINLINE sem_Decl_NewType #-}
sem_Decl_NewType :: (String) -> ([String]) -> (String) -> T_Type -> T_Decl
sem_Decl_NewType _ _ _ arg_tp_ = T_Decl (return st20) where
{-# NOINLINE st20 #-}
!st20 = let
v19 :: T_Decl_v19
v19 = \ !(T_Decl_vIn19 _lhsIisToplevel _lhsIoptions) -> ( let
_tpX50 = Control.Monad.Identity.runIdentity (attach_T_Type (arg_tp_))
(T_Type_vOut49 _tpIpp) = inv_Type_s50 _tpX50 (T_Type_vIn49 )
_lhsOpp :: PP_Doc
_lhsOpp = rule44 ()
!__result_ = T_Decl_vOut19 _lhsOpp
in __result_ )
in C_Decl_s20 v19
{-# INLINE rule44 #-}
{-# LINE 121 "src-ag/PrintOcamlCode.ag" #-}
rule44 = \ (_ :: ()) ->
{-# LINE 121 "src-ag/PrintOcamlCode.ag" #-}
error "pp of Decl.NewType not supported"
{-# LINE 762 "dist/build/PrintOcamlCode.hs"#-}
{-# NOINLINE sem_Decl_Type #-}
sem_Decl_Type :: (String) -> ([String]) -> T_Type -> T_Decl
sem_Decl_Type !arg_name_ !arg_params_ arg_tp_ = T_Decl (return st20) where
{-# NOINLINE st20 #-}
!st20 = let
v19 :: T_Decl_v19
v19 = \ !(T_Decl_vIn19 _lhsIisToplevel _lhsIoptions) -> ( let
_tpX50 = Control.Monad.Identity.runIdentity (attach_T_Type (arg_tp_))
(T_Type_vOut49 _tpIpp) = inv_Type_s50 _tpX50 (T_Type_vIn49 )
_lhsOpp :: PP_Doc
_lhsOpp = rule45 _tpIpp arg_name_ arg_params_
!__result_ = T_Decl_vOut19 _lhsOpp
in __result_ )
in C_Decl_s20 v19
{-# INLINE rule45 #-}
{-# LINE 122 "src-ag/PrintOcamlCode.ag" #-}
rule45 = \ ((_tpIpp) :: PP_Doc) name_ params_ ->
{-# LINE 122 "src-ag/PrintOcamlCode.ag" #-}
"type" >#< hv_sp (map (\p -> "'" >|< p) params_ ++ [text $ toOcamlTC name_]) >#< "=" >#< _tpIpp >#< ";;"
{-# LINE 782 "dist/build/PrintOcamlCode.hs"#-}
{-# NOINLINE sem_Decl_TSig #-}
sem_Decl_TSig :: (String) -> T_Type -> T_Decl
sem_Decl_TSig !arg_name_ arg_tp_ = T_Decl (return st20) where
{-# NOINLINE st20 #-}
!st20 = let
v19 :: T_Decl_v19
v19 = \ !(T_Decl_vIn19 _lhsIisToplevel _lhsIoptions) -> ( let
_tpX50 = Control.Monad.Identity.runIdentity (attach_T_Type (arg_tp_))
(T_Type_vOut49 _tpIpp) = inv_Type_s50 _tpX50 (T_Type_vIn49 )
_lhsOpp :: PP_Doc
_lhsOpp = rule46 _tpIpp arg_name_
!__result_ = T_Decl_vOut19 _lhsOpp
in __result_ )
in C_Decl_s20 v19
{-# INLINE rule46 #-}
{-# LINE 123 "src-ag/PrintOcamlCode.ag" #-}
rule46 = \ ((_tpIpp) :: PP_Doc) name_ ->
{-# LINE 123 "src-ag/PrintOcamlCode.ag" #-}
"(*" >#< name_ >#< ":" >#< _tpIpp >#< "*)"
{-# LINE 802 "dist/build/PrintOcamlCode.hs"#-}
{-# NOINLINE sem_Decl_Comment #-}
sem_Decl_Comment :: (String) -> T_Decl
sem_Decl_Comment !arg_txt_ = T_Decl (return st20) where
{-# NOINLINE st20 #-}
!st20 = let
v19 :: T_Decl_v19
v19 = \ !(T_Decl_vIn19 _lhsIisToplevel _lhsIoptions) -> ( let
_lhsOpp :: PP_Doc
_lhsOpp = rule47 arg_txt_
!__result_ = T_Decl_vOut19 _lhsOpp
in __result_ )
in C_Decl_s20 v19
{-# INLINE rule47 #-}
{-# LINE 124 "src-ag/PrintOcamlCode.ag" #-}
rule47 = \ txt_ ->
{-# LINE 124 "src-ag/PrintOcamlCode.ag" #-}
if '\n' `elem` txt_
then "(* " >-< vlist (lines txt_) >-< "*)"
else "(*" >#< txt_ >#< "*)"
{-# LINE 822 "dist/build/PrintOcamlCode.hs"#-}
{-# NOINLINE sem_Decl_PragmaDecl #-}
sem_Decl_PragmaDecl :: (String) -> T_Decl
sem_Decl_PragmaDecl _ = T_Decl (return st20) where
{-# NOINLINE st20 #-}
!st20 = let
v19 :: T_Decl_v19
v19 = \ !(T_Decl_vIn19 _lhsIisToplevel _lhsIoptions) -> ( let
_lhsOpp :: PP_Doc
_lhsOpp = rule48 ()
!__result_ = T_Decl_vOut19 _lhsOpp
in __result_ )
in C_Decl_s20 v19
{-# INLINE rule48 #-}
{-# LINE 127 "src-ag/PrintOcamlCode.ag" #-}
rule48 = \ (_ :: ()) ->
{-# LINE 127 "src-ag/PrintOcamlCode.ag" #-}
error "pp of Decl.PragmaDecl not supported"
{-# LINE 840 "dist/build/PrintOcamlCode.hs"#-}
{-# NOINLINE sem_Decl_Resume #-}
sem_Decl_Resume :: (Bool) -> (String) -> T_Lhs -> T_Expr -> T_Decl
sem_Decl_Resume _ _ arg_left_ arg_rhs_ = T_Decl (return st20) where
{-# NOINLINE st20 #-}
!st20 = let
v19 :: T_Decl_v19
v19 = \ !(T_Decl_vIn19 _lhsIisToplevel _lhsIoptions) -> ( let
_leftX32 = Control.Monad.Identity.runIdentity (attach_T_Lhs (arg_left_))
_rhsX26 = Control.Monad.Identity.runIdentity (attach_T_Expr (arg_rhs_))
(T_Lhs_vOut31 _leftIpp) = inv_Lhs_s32 _leftX32 (T_Lhs_vIn31 _leftOoptions)
(T_Expr_vOut25 _rhsIpp) = inv_Expr_s26 _rhsX26 (T_Expr_vIn25 _rhsOoptions)
_lhsOpp :: PP_Doc
_lhsOpp = rule49 _rhsIpp
_leftOoptions = rule50 _lhsIoptions
_rhsOoptions = rule51 _lhsIoptions
!__result_ = T_Decl_vOut19 _lhsOpp
in __result_ )
in C_Decl_s20 v19
{-# INLINE rule49 #-}
rule49 = \ ((_rhsIpp) :: PP_Doc) ->
_rhsIpp
{-# INLINE rule50 #-}
rule50 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# INLINE rule51 #-}
rule51 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# NOINLINE sem_Decl_EvalDecl #-}
sem_Decl_EvalDecl :: (String) -> T_Lhs -> T_Expr -> T_Decl
sem_Decl_EvalDecl _ arg_left_ arg_rhs_ = T_Decl (return st20) where
{-# NOINLINE st20 #-}
!st20 = let
v19 :: T_Decl_v19
v19 = \ !(T_Decl_vIn19 _lhsIisToplevel _lhsIoptions) -> ( let
_leftX32 = Control.Monad.Identity.runIdentity (attach_T_Lhs (arg_left_))
_rhsX26 = Control.Monad.Identity.runIdentity (attach_T_Expr (arg_rhs_))
(T_Lhs_vOut31 _leftIpp) = inv_Lhs_s32 _leftX32 (T_Lhs_vIn31 _leftOoptions)
(T_Expr_vOut25 _rhsIpp) = inv_Expr_s26 _rhsX26 (T_Expr_vIn25 _rhsOoptions)
_lhsOpp :: PP_Doc
_lhsOpp = rule52 _rhsIpp
_leftOoptions = rule53 _lhsIoptions
_rhsOoptions = rule54 _lhsIoptions
!__result_ = T_Decl_vOut19 _lhsOpp
in __result_ )
in C_Decl_s20 v19
{-# INLINE rule52 #-}
rule52 = \ ((_rhsIpp) :: PP_Doc) ->
_rhsIpp
{-# INLINE rule53 #-}
rule53 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# INLINE rule54 #-}
rule54 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
data Inh_Decls = Inh_Decls { isToplevel_Inh_Decls :: !(Bool), options_Inh_Decls :: !(Options) }
data Syn_Decls = Syn_Decls { pps_Syn_Decls :: !(PP_Docs) }
{-# INLINABLE wrap_Decls #-}
wrap_Decls :: T_Decls -> Inh_Decls -> (Syn_Decls )
wrap_Decls !(T_Decls act) !(Inh_Decls _lhsIisToplevel _lhsIoptions) =
Control.Monad.Identity.runIdentity (
do !sem <- act
let arg22 = T_Decls_vIn22 _lhsIisToplevel _lhsIoptions
!(T_Decls_vOut22 _lhsOpps) <- return (inv_Decls_s23 sem arg22)
return (Syn_Decls _lhsOpps)
)
{-# NOINLINE sem_Decls #-}
sem_Decls :: Decls -> T_Decls
sem_Decls list = Prelude.foldr sem_Decls_Cons sem_Decls_Nil (Prelude.map sem_Decl list)
newtype T_Decls = T_Decls {
attach_T_Decls :: Identity (T_Decls_s23 )
}
newtype T_Decls_s23 = C_Decls_s23 {
inv_Decls_s23 :: (T_Decls_v22 )
}
data T_Decls_s24 = C_Decls_s24
type T_Decls_v22 = (T_Decls_vIn22 ) -> (T_Decls_vOut22 )
data T_Decls_vIn22 = T_Decls_vIn22 (Bool) (Options)
data T_Decls_vOut22 = T_Decls_vOut22 (PP_Docs)
{-# NOINLINE sem_Decls_Cons #-}
sem_Decls_Cons :: T_Decl -> T_Decls -> T_Decls
sem_Decls_Cons arg_hd_ arg_tl_ = T_Decls (return st23) where
{-# NOINLINE st23 #-}
!st23 = let
v22 :: T_Decls_v22
v22 = \ !(T_Decls_vIn22 _lhsIisToplevel _lhsIoptions) -> ( let
_hdX20 = Control.Monad.Identity.runIdentity (attach_T_Decl (arg_hd_))
_tlX23 = Control.Monad.Identity.runIdentity (attach_T_Decls (arg_tl_))
(T_Decl_vOut19 _hdIpp) = inv_Decl_s20 _hdX20 (T_Decl_vIn19 _hdOisToplevel _hdOoptions)
(T_Decls_vOut22 _tlIpps) = inv_Decls_s23 _tlX23 (T_Decls_vIn22 _tlOisToplevel _tlOoptions)
_lhsOpps :: PP_Docs
_lhsOpps = rule55 _hdIpp _tlIpps
_hdOisToplevel = rule56 _lhsIisToplevel
_hdOoptions = rule57 _lhsIoptions
_tlOisToplevel = rule58 _lhsIisToplevel
_tlOoptions = rule59 _lhsIoptions
!__result_ = T_Decls_vOut22 _lhsOpps
in __result_ )
in C_Decls_s23 v22
{-# INLINE rule55 #-}
{-# LINE 81 "src-ag/PrintOcamlCode.ag" #-}
rule55 = \ ((_hdIpp) :: PP_Doc) ((_tlIpps) :: PP_Docs) ->
{-# LINE 81 "src-ag/PrintOcamlCode.ag" #-}
_hdIpp : _tlIpps
{-# LINE 951 "dist/build/PrintOcamlCode.hs"#-}
{-# INLINE rule56 #-}
rule56 = \ ((_lhsIisToplevel) :: Bool) ->
_lhsIisToplevel
{-# INLINE rule57 #-}
rule57 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# INLINE rule58 #-}
rule58 = \ ((_lhsIisToplevel) :: Bool) ->
_lhsIisToplevel
{-# INLINE rule59 #-}
rule59 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# NOINLINE sem_Decls_Nil #-}
sem_Decls_Nil :: T_Decls
sem_Decls_Nil = T_Decls (return st23) where
{-# NOINLINE st23 #-}
!st23 = let
v22 :: T_Decls_v22
v22 = \ !(T_Decls_vIn22 _lhsIisToplevel _lhsIoptions) -> ( let
_lhsOpps :: PP_Docs
_lhsOpps = rule60 ()
!__result_ = T_Decls_vOut22 _lhsOpps
in __result_ )
in C_Decls_s23 v22
{-# INLINE rule60 #-}
{-# LINE 82 "src-ag/PrintOcamlCode.ag" #-}
rule60 = \ (_ :: ()) ->
{-# LINE 82 "src-ag/PrintOcamlCode.ag" #-}
[]
{-# LINE 981 "dist/build/PrintOcamlCode.hs"#-}
data Inh_Expr = Inh_Expr { options_Inh_Expr :: !(Options) }
data Syn_Expr = Syn_Expr { pp_Syn_Expr :: !(PP_Doc) }
{-# INLINABLE wrap_Expr #-}
wrap_Expr :: T_Expr -> Inh_Expr -> (Syn_Expr )
wrap_Expr !(T_Expr act) !(Inh_Expr _lhsIoptions) =
Control.Monad.Identity.runIdentity (
do !sem <- act
let arg25 = T_Expr_vIn25 _lhsIoptions
!(T_Expr_vOut25 _lhsOpp) <- return (inv_Expr_s26 sem arg25)
return (Syn_Expr _lhsOpp)
)
{-# NOINLINE sem_Expr #-}
sem_Expr :: Expr -> T_Expr
sem_Expr ( Let decls_ body_ ) = sem_Expr_Let ( sem_Decls decls_ ) ( sem_Expr body_ )
sem_Expr ( Case expr_ alts_ ) = sem_Expr_Case ( sem_Expr expr_ ) ( sem_CaseAlts alts_ )
sem_Expr ( Do stmts_ body_ ) = sem_Expr_Do ( sem_Decls stmts_ ) ( sem_Expr body_ )
sem_Expr ( Lambda args_ body_ ) = sem_Expr_Lambda ( sem_Exprs args_ ) ( sem_Expr body_ )
sem_Expr ( TupleExpr exprs_ ) = sem_Expr_TupleExpr ( sem_Exprs exprs_ )
sem_Expr ( UnboxedTupleExpr exprs_ ) = sem_Expr_UnboxedTupleExpr ( sem_Exprs exprs_ )
sem_Expr ( App !name_ args_ ) = sem_Expr_App name_ ( sem_Exprs args_ )
sem_Expr ( SimpleExpr !txt_ ) = sem_Expr_SimpleExpr txt_
sem_Expr ( TextExpr !lns_ ) = sem_Expr_TextExpr lns_
sem_Expr ( Trace !txt_ expr_ ) = sem_Expr_Trace txt_ ( sem_Expr expr_ )
sem_Expr ( PragmaExpr !onLeftSide_ !onNewLine_ !txt_ expr_ ) = sem_Expr_PragmaExpr onLeftSide_ onNewLine_ txt_ ( sem_Expr expr_ )
sem_Expr ( LineExpr expr_ ) = sem_Expr_LineExpr ( sem_Expr expr_ )
sem_Expr ( TypedExpr expr_ tp_ ) = sem_Expr_TypedExpr ( sem_Expr expr_ ) ( sem_Type tp_ )
sem_Expr ( ResultExpr !nt_ expr_ ) = sem_Expr_ResultExpr nt_ ( sem_Expr expr_ )
sem_Expr ( InvokeExpr !nt_ expr_ args_ ) = sem_Expr_InvokeExpr nt_ ( sem_Expr expr_ ) ( sem_Exprs args_ )
sem_Expr ( ResumeExpr !nt_ expr_ left_ rhs_ ) = sem_Expr_ResumeExpr nt_ ( sem_Expr expr_ ) ( sem_Lhs left_ ) ( sem_Expr rhs_ )
sem_Expr ( SemFun !nt_ args_ body_ ) = sem_Expr_SemFun nt_ ( sem_Exprs args_ ) ( sem_Expr body_ )
newtype T_Expr = T_Expr {
attach_T_Expr :: Identity (T_Expr_s26 )
}
newtype T_Expr_s26 = C_Expr_s26 {
inv_Expr_s26 :: (T_Expr_v25 )
}
data T_Expr_s27 = C_Expr_s27
type T_Expr_v25 = (T_Expr_vIn25 ) -> (T_Expr_vOut25 )
data T_Expr_vIn25 = T_Expr_vIn25 (Options)
data T_Expr_vOut25 = T_Expr_vOut25 (PP_Doc)
{-# NOINLINE sem_Expr_Let #-}
sem_Expr_Let :: T_Decls -> T_Expr -> T_Expr
sem_Expr_Let arg_decls_ arg_body_ = T_Expr (return st26) where
{-# NOINLINE st26 #-}
!st26 = let
v25 :: T_Expr_v25
v25 = \ !(T_Expr_vIn25 _lhsIoptions) -> ( let
_declsX23 = Control.Monad.Identity.runIdentity (attach_T_Decls (arg_decls_))
_bodyX26 = Control.Monad.Identity.runIdentity (attach_T_Expr (arg_body_))
(T_Decls_vOut22 _declsIpps) = inv_Decls_s23 _declsX23 (T_Decls_vIn22 _declsOisToplevel _declsOoptions)
(T_Expr_vOut25 _bodyIpp) = inv_Expr_s26 _bodyX26 (T_Expr_vIn25 _bodyOoptions)
_lhsOpp :: PP_Doc
_lhsOpp = rule61 _bodyIpp _declsIpps
_declsOisToplevel = rule62 ()
_declsOoptions = rule63 _lhsIoptions
_bodyOoptions = rule64 _lhsIoptions
!__result_ = T_Expr_vOut25 _lhsOpp
in __result_ )
in C_Expr_s26 v25
{-# INLINE rule61 #-}
{-# LINE 131 "src-ag/PrintOcamlCode.ag" #-}
rule61 = \ ((_bodyIpp) :: PP_Doc) ((_declsIpps) :: PP_Docs) ->
{-# LINE 131 "src-ag/PrintOcamlCode.ag" #-}
pp_parens $ vlist (_declsIpps ++ [_bodyIpp])
{-# LINE 1053 "dist/build/PrintOcamlCode.hs"#-}
{-# INLINE rule62 #-}
{-# LINE 220 "src-ag/PrintOcamlCode.ag" #-}
rule62 = \ (_ :: ()) ->
{-# LINE 220 "src-ag/PrintOcamlCode.ag" #-}
False
{-# LINE 1059 "dist/build/PrintOcamlCode.hs"#-}
{-# INLINE rule63 #-}
rule63 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# INLINE rule64 #-}
rule64 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# NOINLINE sem_Expr_Case #-}
sem_Expr_Case :: T_Expr -> T_CaseAlts -> T_Expr
sem_Expr_Case arg_expr_ arg_alts_ = T_Expr (return st26) where
{-# NOINLINE st26 #-}
!st26 = let
v25 :: T_Expr_v25
v25 = \ !(T_Expr_vIn25 _lhsIoptions) -> ( let
_exprX26 = Control.Monad.Identity.runIdentity (attach_T_Expr (arg_expr_))
_altsX5 = Control.Monad.Identity.runIdentity (attach_T_CaseAlts (arg_alts_))
(T_Expr_vOut25 _exprIpp) = inv_Expr_s26 _exprX26 (T_Expr_vIn25 _exprOoptions)
(T_CaseAlts_vOut4 _altsIpps) = inv_CaseAlts_s5 _altsX5 (T_CaseAlts_vIn4 _altsOoptions)
_lhsOpp :: PP_Doc
_lhsOpp = rule65 _altsIpps _exprIpp
_exprOoptions = rule66 _lhsIoptions
_altsOoptions = rule67 _lhsIoptions
!__result_ = T_Expr_vOut25 _lhsOpp
in __result_ )
in C_Expr_s26 v25
{-# INLINE rule65 #-}
{-# LINE 132 "src-ag/PrintOcamlCode.ag" #-}
rule65 = \ ((_altsIpps) :: PP_Docs) ((_exprIpp) :: PP_Doc) ->
{-# LINE 132 "src-ag/PrintOcamlCode.ag" #-}
pp_parens ( "match" >#< _exprIpp >#< "with"
>-< indent 2 ( case _altsIpps of
[] -> empty
(x:xs) -> " " >#< x
>-< vlist (map ("|" >#<) xs)
)
)
{-# LINE 1095 "dist/build/PrintOcamlCode.hs"#-}
{-# INLINE rule66 #-}
rule66 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# INLINE rule67 #-}
rule67 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# NOINLINE sem_Expr_Do #-}
sem_Expr_Do :: T_Decls -> T_Expr -> T_Expr
sem_Expr_Do arg_stmts_ arg_body_ = T_Expr (return st26) where
{-# NOINLINE st26 #-}
!st26 = let
v25 :: T_Expr_v25
v25 = \ !(T_Expr_vIn25 _lhsIoptions) -> ( let
_stmtsX23 = Control.Monad.Identity.runIdentity (attach_T_Decls (arg_stmts_))
_bodyX26 = Control.Monad.Identity.runIdentity (attach_T_Expr (arg_body_))
(T_Decls_vOut22 _stmtsIpps) = inv_Decls_s23 _stmtsX23 (T_Decls_vIn22 _stmtsOisToplevel _stmtsOoptions)
(T_Expr_vOut25 _bodyIpp) = inv_Expr_s26 _bodyX26 (T_Expr_vIn25 _bodyOoptions)
_lhsOpp :: PP_Doc
_lhsOpp = rule68 ()
_stmtsOisToplevel = rule69 ()
_stmtsOoptions = rule70 _lhsIoptions
_bodyOoptions = rule71 _lhsIoptions
!__result_ = T_Expr_vOut25 _lhsOpp
in __result_ )
in C_Expr_s26 v25
{-# INLINE rule68 #-}
{-# LINE 139 "src-ag/PrintOcamlCode.ag" #-}
rule68 = \ (_ :: ()) ->
{-# LINE 139 "src-ag/PrintOcamlCode.ag" #-}
error "pp of Expr.Do not supported"
{-# LINE 1126 "dist/build/PrintOcamlCode.hs"#-}
{-# INLINE rule69 #-}
{-# LINE 222 "src-ag/PrintOcamlCode.ag" #-}
rule69 = \ (_ :: ()) ->
{-# LINE 222 "src-ag/PrintOcamlCode.ag" #-}
False
{-# LINE 1132 "dist/build/PrintOcamlCode.hs"#-}
{-# INLINE rule70 #-}
rule70 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# INLINE rule71 #-}
rule71 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# NOINLINE sem_Expr_Lambda #-}
sem_Expr_Lambda :: T_Exprs -> T_Expr -> T_Expr
sem_Expr_Lambda arg_args_ arg_body_ = T_Expr (return st26) where
{-# NOINLINE st26 #-}
!st26 = let
v25 :: T_Expr_v25
v25 = \ !(T_Expr_vIn25 _lhsIoptions) -> ( let
_argsX29 = Control.Monad.Identity.runIdentity (attach_T_Exprs (arg_args_))
_bodyX26 = Control.Monad.Identity.runIdentity (attach_T_Expr (arg_body_))
(T_Exprs_vOut28 _argsIpps) = inv_Exprs_s29 _argsX29 (T_Exprs_vIn28 _argsOoptions)
(T_Expr_vOut25 _bodyIpp) = inv_Expr_s26 _bodyX26 (T_Expr_vIn25 _bodyOoptions)
_lhsOpp :: PP_Doc
_lhsOpp = rule72 _argsIpps _bodyIpp
_argsOoptions = rule73 _lhsIoptions
_bodyOoptions = rule74 _lhsIoptions
!__result_ = T_Expr_vOut25 _lhsOpp
in __result_ )
in C_Expr_s26 v25
{-# INLINE rule72 #-}
{-# LINE 140 "src-ag/PrintOcamlCode.ag" #-}
rule72 = \ ((_argsIpps) :: PP_Docs) ((_bodyIpp) :: PP_Doc) ->
{-# LINE 140 "src-ag/PrintOcamlCode.ag" #-}
pp_parens ( pp "fun" >#< hv_sp _argsIpps >#< "->"
>-< indent 2 _bodyIpp )
{-# LINE 1163 "dist/build/PrintOcamlCode.hs"#-}
{-# INLINE rule73 #-}
rule73 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# INLINE rule74 #-}
rule74 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# NOINLINE sem_Expr_TupleExpr #-}
sem_Expr_TupleExpr :: T_Exprs -> T_Expr
sem_Expr_TupleExpr arg_exprs_ = T_Expr (return st26) where
{-# NOINLINE st26 #-}
!st26 = let
v25 :: T_Expr_v25
v25 = \ !(T_Expr_vIn25 _lhsIoptions) -> ( let
_exprsX29 = Control.Monad.Identity.runIdentity (attach_T_Exprs (arg_exprs_))
(T_Exprs_vOut28 _exprsIpps) = inv_Exprs_s29 _exprsX29 (T_Exprs_vIn28 _exprsOoptions)
_lhsOpp :: PP_Doc
_lhsOpp = rule75 _exprsIpps
_exprsOoptions = rule76 _lhsIoptions
!__result_ = T_Expr_vOut25 _lhsOpp
in __result_ )
in C_Expr_s26 v25
{-# INLINE rule75 #-}
{-# LINE 142 "src-ag/PrintOcamlCode.ag" #-}
rule75 = \ ((_exprsIpps) :: PP_Docs) ->
{-# LINE 142 "src-ag/PrintOcamlCode.ag" #-}
ppTuple False _exprsIpps
{-# LINE 1190 "dist/build/PrintOcamlCode.hs"#-}
{-# INLINE rule76 #-}
rule76 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# NOINLINE sem_Expr_UnboxedTupleExpr #-}
sem_Expr_UnboxedTupleExpr :: T_Exprs -> T_Expr
sem_Expr_UnboxedTupleExpr arg_exprs_ = T_Expr (return st26) where
{-# NOINLINE st26 #-}
!st26 = let
v25 :: T_Expr_v25
v25 = \ !(T_Expr_vIn25 _lhsIoptions) -> ( let
_exprsX29 = Control.Monad.Identity.runIdentity (attach_T_Exprs (arg_exprs_))
(T_Exprs_vOut28 _exprsIpps) = inv_Exprs_s29 _exprsX29 (T_Exprs_vIn28 _exprsOoptions)
_lhsOpp :: PP_Doc
_lhsOpp = rule77 ()
_exprsOoptions = rule78 _lhsIoptions
!__result_ = T_Expr_vOut25 _lhsOpp
in __result_ )
in C_Expr_s26 v25
{-# INLINE rule77 #-}
{-# LINE 143 "src-ag/PrintOcamlCode.ag" #-}
rule77 = \ (_ :: ()) ->
{-# LINE 143 "src-ag/PrintOcamlCode.ag" #-}
error "pp of Expr.UnboxedTupleExpr not supported"
{-# LINE 1214 "dist/build/PrintOcamlCode.hs"#-}
{-# INLINE rule78 #-}
rule78 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# NOINLINE sem_Expr_App #-}
sem_Expr_App :: (String) -> T_Exprs -> T_Expr
sem_Expr_App !arg_name_ arg_args_ = T_Expr (return st26) where
{-# NOINLINE st26 #-}
!st26 = let
v25 :: T_Expr_v25
v25 = \ !(T_Expr_vIn25 _lhsIoptions) -> ( let
_argsX29 = Control.Monad.Identity.runIdentity (attach_T_Exprs (arg_args_))
(T_Exprs_vOut28 _argsIpps) = inv_Exprs_s29 _argsX29 (T_Exprs_vIn28 _argsOoptions)
_lhsOpp :: PP_Doc
_lhsOpp = rule79 _argsIpps arg_name_
_argsOoptions = rule80 _lhsIoptions
!__result_ = T_Expr_vOut25 _lhsOpp
in __result_ )
in C_Expr_s26 v25
{-# INLINE rule79 #-}
{-# LINE 144 "src-ag/PrintOcamlCode.ag" #-}
rule79 = \ ((_argsIpps) :: PP_Docs) name_ ->
{-# LINE 144 "src-ag/PrintOcamlCode.ag" #-}
pp_parens $ name_ >#< hv_sp _argsIpps
{-# LINE 1238 "dist/build/PrintOcamlCode.hs"#-}
{-# INLINE rule80 #-}
rule80 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# NOINLINE sem_Expr_SimpleExpr #-}
sem_Expr_SimpleExpr :: (String) -> T_Expr
sem_Expr_SimpleExpr !arg_txt_ = T_Expr (return st26) where
{-# NOINLINE st26 #-}
!st26 = let
v25 :: T_Expr_v25
v25 = \ !(T_Expr_vIn25 _lhsIoptions) -> ( let
_lhsOpp :: PP_Doc
_lhsOpp = rule81 arg_txt_
!__result_ = T_Expr_vOut25 _lhsOpp
in __result_ )
in C_Expr_s26 v25
{-# INLINE rule81 #-}
{-# LINE 145 "src-ag/PrintOcamlCode.ag" #-}
rule81 = \ txt_ ->
{-# LINE 145 "src-ag/PrintOcamlCode.ag" #-}
text txt_
{-# LINE 1259 "dist/build/PrintOcamlCode.hs"#-}
{-# NOINLINE sem_Expr_TextExpr #-}
sem_Expr_TextExpr :: ([String]) -> T_Expr
sem_Expr_TextExpr !arg_lns_ = T_Expr (return st26) where
{-# NOINLINE st26 #-}
!st26 = let
v25 :: T_Expr_v25
v25 = \ !(T_Expr_vIn25 _lhsIoptions) -> ( let
_lhsOpp :: PP_Doc
_lhsOpp = rule82 arg_lns_
!__result_ = T_Expr_vOut25 _lhsOpp
in __result_ )
in C_Expr_s26 v25
{-# INLINE rule82 #-}
{-# LINE 146 "src-ag/PrintOcamlCode.ag" #-}
rule82 = \ lns_ ->
{-# LINE 146 "src-ag/PrintOcamlCode.ag" #-}
vlist (map text lns_)
{-# LINE 1277 "dist/build/PrintOcamlCode.hs"#-}
{-# NOINLINE sem_Expr_Trace #-}
sem_Expr_Trace :: (String) -> T_Expr -> T_Expr
sem_Expr_Trace _ arg_expr_ = T_Expr (return st26) where
{-# NOINLINE st26 #-}
!st26 = let
v25 :: T_Expr_v25
v25 = \ !(T_Expr_vIn25 _lhsIoptions) -> ( let
_exprX26 = Control.Monad.Identity.runIdentity (attach_T_Expr (arg_expr_))
(T_Expr_vOut25 _exprIpp) = inv_Expr_s26 _exprX26 (T_Expr_vIn25 _exprOoptions)
_lhsOpp :: PP_Doc
_lhsOpp = rule83 _exprIpp
_exprOoptions = rule84 _lhsIoptions
!__result_ = T_Expr_vOut25 _lhsOpp
in __result_ )
in C_Expr_s26 v25
{-# INLINE rule83 #-}
{-# LINE 147 "src-ag/PrintOcamlCode.ag" #-}
rule83 = \ ((_exprIpp) :: PP_Doc) ->
{-# LINE 147 "src-ag/PrintOcamlCode.ag" #-}
_exprIpp
{-# LINE 1298 "dist/build/PrintOcamlCode.hs"#-}
{-# INLINE rule84 #-}
rule84 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# NOINLINE sem_Expr_PragmaExpr #-}
sem_Expr_PragmaExpr :: (Bool) -> (Bool) -> (String) -> T_Expr -> T_Expr
sem_Expr_PragmaExpr _ _ _ arg_expr_ = T_Expr (return st26) where
{-# NOINLINE st26 #-}
!st26 = let
v25 :: T_Expr_v25
v25 = \ !(T_Expr_vIn25 _lhsIoptions) -> ( let
_exprX26 = Control.Monad.Identity.runIdentity (attach_T_Expr (arg_expr_))
(T_Expr_vOut25 _exprIpp) = inv_Expr_s26 _exprX26 (T_Expr_vIn25 _exprOoptions)
_lhsOpp :: PP_Doc
_lhsOpp = rule85 _exprIpp
_exprOoptions = rule86 _lhsIoptions
!__result_ = T_Expr_vOut25 _lhsOpp
in __result_ )
in C_Expr_s26 v25
{-# INLINE rule85 #-}
{-# LINE 148 "src-ag/PrintOcamlCode.ag" #-}
rule85 = \ ((_exprIpp) :: PP_Doc) ->
{-# LINE 148 "src-ag/PrintOcamlCode.ag" #-}
_exprIpp
{-# LINE 1322 "dist/build/PrintOcamlCode.hs"#-}
{-# INLINE rule86 #-}
rule86 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# NOINLINE sem_Expr_LineExpr #-}
sem_Expr_LineExpr :: T_Expr -> T_Expr
sem_Expr_LineExpr arg_expr_ = T_Expr (return st26) where
{-# NOINLINE st26 #-}
!st26 = let
v25 :: T_Expr_v25
v25 = \ !(T_Expr_vIn25 _lhsIoptions) -> ( let
_exprX26 = Control.Monad.Identity.runIdentity (attach_T_Expr (arg_expr_))
(T_Expr_vOut25 _exprIpp) = inv_Expr_s26 _exprX26 (T_Expr_vIn25 _exprOoptions)
_lhsOpp :: PP_Doc
_lhsOpp = rule87 _exprIpp
_exprOoptions = rule88 _lhsIoptions
!__result_ = T_Expr_vOut25 _lhsOpp
in __result_ )
in C_Expr_s26 v25
{-# INLINE rule87 #-}
{-# LINE 149 "src-ag/PrintOcamlCode.ag" #-}
rule87 = \ ((_exprIpp) :: PP_Doc) ->
{-# LINE 149 "src-ag/PrintOcamlCode.ag" #-}
_exprIpp
{-# LINE 1346 "dist/build/PrintOcamlCode.hs"#-}
{-# INLINE rule88 #-}
rule88 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# NOINLINE sem_Expr_TypedExpr #-}
sem_Expr_TypedExpr :: T_Expr -> T_Type -> T_Expr
sem_Expr_TypedExpr arg_expr_ arg_tp_ = T_Expr (return st26) where
{-# NOINLINE st26 #-}
!st26 = let
v25 :: T_Expr_v25
v25 = \ !(T_Expr_vIn25 _lhsIoptions) -> ( let
_exprX26 = Control.Monad.Identity.runIdentity (attach_T_Expr (arg_expr_))
_tpX50 = Control.Monad.Identity.runIdentity (attach_T_Type (arg_tp_))
(T_Expr_vOut25 _exprIpp) = inv_Expr_s26 _exprX26 (T_Expr_vIn25 _exprOoptions)
(T_Type_vOut49 _tpIpp) = inv_Type_s50 _tpX50 (T_Type_vIn49 )
_lhsOpp :: PP_Doc
_lhsOpp = rule89 _exprIpp
_exprOoptions = rule90 _lhsIoptions
!__result_ = T_Expr_vOut25 _lhsOpp
in __result_ )
in C_Expr_s26 v25
{-# INLINE rule89 #-}
{-# LINE 150 "src-ag/PrintOcamlCode.ag" #-}
rule89 = \ ((_exprIpp) :: PP_Doc) ->
{-# LINE 150 "src-ag/PrintOcamlCode.ag" #-}
_exprIpp
{-# LINE 1372 "dist/build/PrintOcamlCode.hs"#-}
{-# INLINE rule90 #-}
rule90 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# NOINLINE sem_Expr_ResultExpr #-}
sem_Expr_ResultExpr :: (String) -> T_Expr -> T_Expr
sem_Expr_ResultExpr _ arg_expr_ = T_Expr (return st26) where
{-# NOINLINE st26 #-}
!st26 = let
v25 :: T_Expr_v25
v25 = \ !(T_Expr_vIn25 _lhsIoptions) -> ( let
_exprX26 = Control.Monad.Identity.runIdentity (attach_T_Expr (arg_expr_))
(T_Expr_vOut25 _exprIpp) = inv_Expr_s26 _exprX26 (T_Expr_vIn25 _exprOoptions)
_lhsOpp :: PP_Doc
_lhsOpp = rule91 _exprIpp
_exprOoptions = rule92 _lhsIoptions
!__result_ = T_Expr_vOut25 _lhsOpp
in __result_ )
in C_Expr_s26 v25
{-# INLINE rule91 #-}
rule91 = \ ((_exprIpp) :: PP_Doc) ->
_exprIpp
{-# INLINE rule92 #-}
rule92 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# NOINLINE sem_Expr_InvokeExpr #-}
sem_Expr_InvokeExpr :: (String) -> T_Expr -> T_Exprs -> T_Expr
sem_Expr_InvokeExpr _ arg_expr_ arg_args_ = T_Expr (return st26) where
{-# NOINLINE st26 #-}
!st26 = let
v25 :: T_Expr_v25
v25 = \ !(T_Expr_vIn25 _lhsIoptions) -> ( let
_exprX26 = Control.Monad.Identity.runIdentity (attach_T_Expr (arg_expr_))
_argsX29 = Control.Monad.Identity.runIdentity (attach_T_Exprs (arg_args_))
(T_Expr_vOut25 _exprIpp) = inv_Expr_s26 _exprX26 (T_Expr_vIn25 _exprOoptions)
(T_Exprs_vOut28 _argsIpps) = inv_Exprs_s29 _argsX29 (T_Exprs_vIn28 _argsOoptions)
_lhsOpp :: PP_Doc
_lhsOpp = rule93 _exprIpp
_exprOoptions = rule94 _lhsIoptions
_argsOoptions = rule95 _lhsIoptions
!__result_ = T_Expr_vOut25 _lhsOpp
in __result_ )
in C_Expr_s26 v25
{-# INLINE rule93 #-}
rule93 = \ ((_exprIpp) :: PP_Doc) ->
_exprIpp
{-# INLINE rule94 #-}
rule94 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# INLINE rule95 #-}
rule95 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# NOINLINE sem_Expr_ResumeExpr #-}
sem_Expr_ResumeExpr :: (String) -> T_Expr -> T_Lhs -> T_Expr -> T_Expr
sem_Expr_ResumeExpr _ arg_expr_ arg_left_ arg_rhs_ = T_Expr (return st26) where
{-# NOINLINE st26 #-}
!st26 = let
v25 :: T_Expr_v25
v25 = \ !(T_Expr_vIn25 _lhsIoptions) -> ( let
_exprX26 = Control.Monad.Identity.runIdentity (attach_T_Expr (arg_expr_))
_leftX32 = Control.Monad.Identity.runIdentity (attach_T_Lhs (arg_left_))
_rhsX26 = Control.Monad.Identity.runIdentity (attach_T_Expr (arg_rhs_))
(T_Expr_vOut25 _exprIpp) = inv_Expr_s26 _exprX26 (T_Expr_vIn25 _exprOoptions)
(T_Lhs_vOut31 _leftIpp) = inv_Lhs_s32 _leftX32 (T_Lhs_vIn31 _leftOoptions)
(T_Expr_vOut25 _rhsIpp) = inv_Expr_s26 _rhsX26 (T_Expr_vIn25 _rhsOoptions)
_lhsOpp :: PP_Doc
_lhsOpp = rule96 _rhsIpp
_exprOoptions = rule97 _lhsIoptions
_leftOoptions = rule98 _lhsIoptions
_rhsOoptions = rule99 _lhsIoptions
!__result_ = T_Expr_vOut25 _lhsOpp
in __result_ )
in C_Expr_s26 v25
{-# INLINE rule96 #-}
rule96 = \ ((_rhsIpp) :: PP_Doc) ->
_rhsIpp
{-# INLINE rule97 #-}
rule97 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# INLINE rule98 #-}
rule98 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# INLINE rule99 #-}
rule99 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# NOINLINE sem_Expr_SemFun #-}
sem_Expr_SemFun :: (String) -> T_Exprs -> T_Expr -> T_Expr
sem_Expr_SemFun _ arg_args_ arg_body_ = T_Expr (return st26) where
{-# NOINLINE st26 #-}
!st26 = let
v25 :: T_Expr_v25
v25 = \ !(T_Expr_vIn25 _lhsIoptions) -> ( let
_argsX29 = Control.Monad.Identity.runIdentity (attach_T_Exprs (arg_args_))
_bodyX26 = Control.Monad.Identity.runIdentity (attach_T_Expr (arg_body_))
(T_Exprs_vOut28 _argsIpps) = inv_Exprs_s29 _argsX29 (T_Exprs_vIn28 _argsOoptions)
(T_Expr_vOut25 _bodyIpp) = inv_Expr_s26 _bodyX26 (T_Expr_vIn25 _bodyOoptions)
_lhsOpp :: PP_Doc
_lhsOpp = rule100 _bodyIpp
_argsOoptions = rule101 _lhsIoptions
_bodyOoptions = rule102 _lhsIoptions
!__result_ = T_Expr_vOut25 _lhsOpp
in __result_ )
in C_Expr_s26 v25
{-# INLINE rule100 #-}
rule100 = \ ((_bodyIpp) :: PP_Doc) ->
_bodyIpp
{-# INLINE rule101 #-}
rule101 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# INLINE rule102 #-}
rule102 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
data Inh_Exprs = Inh_Exprs { options_Inh_Exprs :: !(Options) }
data Syn_Exprs = Syn_Exprs { pps_Syn_Exprs :: !(PP_Docs) }
{-# INLINABLE wrap_Exprs #-}
wrap_Exprs :: T_Exprs -> Inh_Exprs -> (Syn_Exprs )
wrap_Exprs !(T_Exprs act) !(Inh_Exprs _lhsIoptions) =
Control.Monad.Identity.runIdentity (
do !sem <- act
let arg28 = T_Exprs_vIn28 _lhsIoptions
!(T_Exprs_vOut28 _lhsOpps) <- return (inv_Exprs_s29 sem arg28)
return (Syn_Exprs _lhsOpps)
)
{-# NOINLINE sem_Exprs #-}
sem_Exprs :: Exprs -> T_Exprs
sem_Exprs list = Prelude.foldr sem_Exprs_Cons sem_Exprs_Nil (Prelude.map sem_Expr list)
newtype T_Exprs = T_Exprs {
attach_T_Exprs :: Identity (T_Exprs_s29 )
}
newtype T_Exprs_s29 = C_Exprs_s29 {
inv_Exprs_s29 :: (T_Exprs_v28 )
}
data T_Exprs_s30 = C_Exprs_s30
type T_Exprs_v28 = (T_Exprs_vIn28 ) -> (T_Exprs_vOut28 )
data T_Exprs_vIn28 = T_Exprs_vIn28 (Options)
data T_Exprs_vOut28 = T_Exprs_vOut28 (PP_Docs)
{-# NOINLINE sem_Exprs_Cons #-}
sem_Exprs_Cons :: T_Expr -> T_Exprs -> T_Exprs
sem_Exprs_Cons arg_hd_ arg_tl_ = T_Exprs (return st29) where
{-# NOINLINE st29 #-}
!st29 = let
v28 :: T_Exprs_v28
v28 = \ !(T_Exprs_vIn28 _lhsIoptions) -> ( let
_hdX26 = Control.Monad.Identity.runIdentity (attach_T_Expr (arg_hd_))
_tlX29 = Control.Monad.Identity.runIdentity (attach_T_Exprs (arg_tl_))
(T_Expr_vOut25 _hdIpp) = inv_Expr_s26 _hdX26 (T_Expr_vIn25 _hdOoptions)
(T_Exprs_vOut28 _tlIpps) = inv_Exprs_s29 _tlX29 (T_Exprs_vIn28 _tlOoptions)
_lhsOpps :: PP_Docs
_lhsOpps = rule103 _hdIpp _tlIpps
_hdOoptions = rule104 _lhsIoptions
_tlOoptions = rule105 _lhsIoptions
!__result_ = T_Exprs_vOut28 _lhsOpps
in __result_ )
in C_Exprs_s29 v28
{-# INLINE rule103 #-}
{-# LINE 61 "src-ag/PrintOcamlCode.ag" #-}
rule103 = \ ((_hdIpp) :: PP_Doc) ((_tlIpps) :: PP_Docs) ->
{-# LINE 61 "src-ag/PrintOcamlCode.ag" #-}
_hdIpp : _tlIpps
{-# LINE 1538 "dist/build/PrintOcamlCode.hs"#-}
{-# INLINE rule104 #-}
rule104 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# INLINE rule105 #-}
rule105 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# NOINLINE sem_Exprs_Nil #-}
sem_Exprs_Nil :: T_Exprs
sem_Exprs_Nil = T_Exprs (return st29) where
{-# NOINLINE st29 #-}
!st29 = let
v28 :: T_Exprs_v28
v28 = \ !(T_Exprs_vIn28 _lhsIoptions) -> ( let
_lhsOpps :: PP_Docs
_lhsOpps = rule106 ()
!__result_ = T_Exprs_vOut28 _lhsOpps
in __result_ )
in C_Exprs_s29 v28
{-# INLINE rule106 #-}
{-# LINE 62 "src-ag/PrintOcamlCode.ag" #-}
rule106 = \ (_ :: ()) ->
{-# LINE 62 "src-ag/PrintOcamlCode.ag" #-}
[]
{-# LINE 1562 "dist/build/PrintOcamlCode.hs"#-}
data Inh_Lhs = Inh_Lhs { options_Inh_Lhs :: !(Options) }
data Syn_Lhs = Syn_Lhs { pp_Syn_Lhs :: !(PP_Doc) }
{-# INLINABLE wrap_Lhs #-}
wrap_Lhs :: T_Lhs -> Inh_Lhs -> (Syn_Lhs )
wrap_Lhs !(T_Lhs act) !(Inh_Lhs _lhsIoptions) =
Control.Monad.Identity.runIdentity (
do !sem <- act
let arg31 = T_Lhs_vIn31 _lhsIoptions
!(T_Lhs_vOut31 _lhsOpp) <- return (inv_Lhs_s32 sem arg31)
return (Syn_Lhs _lhsOpp)
)
{-# NOINLINE sem_Lhs #-}
sem_Lhs :: Lhs -> T_Lhs
sem_Lhs ( Pattern3 pat3_ ) = sem_Lhs_Pattern3 ( sem_Pattern pat3_ )
sem_Lhs ( Pattern3SM pat3_ ) = sem_Lhs_Pattern3SM ( sem_Pattern pat3_ )
sem_Lhs ( TupleLhs !comps_ ) = sem_Lhs_TupleLhs comps_
sem_Lhs ( UnboxedTupleLhs !comps_ ) = sem_Lhs_UnboxedTupleLhs comps_
sem_Lhs ( Fun !name_ args_ ) = sem_Lhs_Fun name_ ( sem_Exprs args_ )
sem_Lhs ( Unwrap !name_ sub_ ) = sem_Lhs_Unwrap name_ ( sem_Lhs sub_ )
newtype T_Lhs = T_Lhs {
attach_T_Lhs :: Identity (T_Lhs_s32 )
}
newtype T_Lhs_s32 = C_Lhs_s32 {
inv_Lhs_s32 :: (T_Lhs_v31 )
}
data T_Lhs_s33 = C_Lhs_s33
type T_Lhs_v31 = (T_Lhs_vIn31 ) -> (T_Lhs_vOut31 )
data T_Lhs_vIn31 = T_Lhs_vIn31 (Options)
data T_Lhs_vOut31 = T_Lhs_vOut31 (PP_Doc)
{-# NOINLINE sem_Lhs_Pattern3 #-}
sem_Lhs_Pattern3 :: T_Pattern -> T_Lhs
sem_Lhs_Pattern3 arg_pat3_ = T_Lhs (return st32) where
{-# NOINLINE st32 #-}
!st32 = let
v31 :: T_Lhs_v31
v31 = \ !(T_Lhs_vIn31 _lhsIoptions) -> ( let
_pat3X41 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_pat3_))
(T_Pattern_vOut40 _pat3Icopy _pat3IisUnderscore _pat3Ipp) = inv_Pattern_s41 _pat3X41 (T_Pattern_vIn40 _pat3Ooptions)
_lhsOpp :: PP_Doc
_lhsOpp = rule107 _pat3Ipp
_pat3Ooptions = rule108 _lhsIoptions
!__result_ = T_Lhs_vOut31 _lhsOpp
in __result_ )
in C_Lhs_s32 v31
{-# INLINE rule107 #-}
{-# LINE 153 "src-ag/PrintOcamlCode.ag" #-}
rule107 = \ ((_pat3Ipp) :: PP_Doc) ->
{-# LINE 153 "src-ag/PrintOcamlCode.ag" #-}
_pat3Ipp
{-# LINE 1619 "dist/build/PrintOcamlCode.hs"#-}
{-# INLINE rule108 #-}
rule108 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# NOINLINE sem_Lhs_Pattern3SM #-}
sem_Lhs_Pattern3SM :: T_Pattern -> T_Lhs
sem_Lhs_Pattern3SM arg_pat3_ = T_Lhs (return st32) where
{-# NOINLINE st32 #-}
!st32 = let
v31 :: T_Lhs_v31
v31 = \ !(T_Lhs_vIn31 _lhsIoptions) -> ( let
_pat3X41 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_pat3_))
(T_Pattern_vOut40 _pat3Icopy _pat3IisUnderscore _pat3Ipp) = inv_Pattern_s41 _pat3X41 (T_Pattern_vIn40 _pat3Ooptions)
_lhsOpp :: PP_Doc
_lhsOpp = rule109 ()
_pat3Ooptions = rule110 _lhsIoptions
!__result_ = T_Lhs_vOut31 _lhsOpp
in __result_ )
in C_Lhs_s32 v31
{-# INLINE rule109 #-}
{-# LINE 154 "src-ag/PrintOcamlCode.ag" #-}
rule109 = \ (_ :: ()) ->
{-# LINE 154 "src-ag/PrintOcamlCode.ag" #-}
error "pp of Lhs.Pattern3SM not supported"
{-# LINE 1643 "dist/build/PrintOcamlCode.hs"#-}
{-# INLINE rule110 #-}
rule110 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# NOINLINE sem_Lhs_TupleLhs #-}
sem_Lhs_TupleLhs :: ([String]) -> T_Lhs
sem_Lhs_TupleLhs !arg_comps_ = T_Lhs (return st32) where
{-# NOINLINE st32 #-}
!st32 = let
v31 :: T_Lhs_v31
v31 = \ !(T_Lhs_vIn31 _lhsIoptions) -> ( let
_lhsOpp :: PP_Doc
_lhsOpp = rule111 arg_comps_
!__result_ = T_Lhs_vOut31 _lhsOpp
in __result_ )
in C_Lhs_s32 v31
{-# INLINE rule111 #-}
{-# LINE 155 "src-ag/PrintOcamlCode.ag" #-}
rule111 = \ comps_ ->
{-# LINE 155 "src-ag/PrintOcamlCode.ag" #-}
ppTuple False (map text comps_)
{-# LINE 1664 "dist/build/PrintOcamlCode.hs"#-}
{-# NOINLINE sem_Lhs_UnboxedTupleLhs #-}
sem_Lhs_UnboxedTupleLhs :: ([String]) -> T_Lhs
sem_Lhs_UnboxedTupleLhs _ = T_Lhs (return st32) where
{-# NOINLINE st32 #-}
!st32 = let
v31 :: T_Lhs_v31
v31 = \ !(T_Lhs_vIn31 _lhsIoptions) -> ( let
_lhsOpp :: PP_Doc
_lhsOpp = rule112 ()
!__result_ = T_Lhs_vOut31 _lhsOpp
in __result_ )
in C_Lhs_s32 v31
{-# INLINE rule112 #-}
{-# LINE 156 "src-ag/PrintOcamlCode.ag" #-}
rule112 = \ (_ :: ()) ->
{-# LINE 156 "src-ag/PrintOcamlCode.ag" #-}
error "pp of Lhs.UnboxedTupleLhs not supported"
{-# LINE 1682 "dist/build/PrintOcamlCode.hs"#-}
{-# NOINLINE sem_Lhs_Fun #-}
sem_Lhs_Fun :: (String) -> T_Exprs -> T_Lhs
sem_Lhs_Fun !arg_name_ arg_args_ = T_Lhs (return st32) where
{-# NOINLINE st32 #-}
!st32 = let
v31 :: T_Lhs_v31
v31 = \ !(T_Lhs_vIn31 _lhsIoptions) -> ( let
_argsX29 = Control.Monad.Identity.runIdentity (attach_T_Exprs (arg_args_))
(T_Exprs_vOut28 _argsIpps) = inv_Exprs_s29 _argsX29 (T_Exprs_vIn28 _argsOoptions)
_lhsOpp :: PP_Doc
_lhsOpp = rule113 _argsIpps arg_name_
_argsOoptions = rule114 _lhsIoptions
!__result_ = T_Lhs_vOut31 _lhsOpp
in __result_ )
in C_Lhs_s32 v31
{-# INLINE rule113 #-}
{-# LINE 157 "src-ag/PrintOcamlCode.ag" #-}
rule113 = \ ((_argsIpps) :: PP_Docs) name_ ->
{-# LINE 157 "src-ag/PrintOcamlCode.ag" #-}
name_ >#< hv_sp _argsIpps
{-# LINE 1703 "dist/build/PrintOcamlCode.hs"#-}
{-# INLINE rule114 #-}
rule114 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# NOINLINE sem_Lhs_Unwrap #-}
sem_Lhs_Unwrap :: (String) -> T_Lhs -> T_Lhs
sem_Lhs_Unwrap !arg_name_ arg_sub_ = T_Lhs (return st32) where
{-# NOINLINE st32 #-}
!st32 = let
v31 :: T_Lhs_v31
v31 = \ !(T_Lhs_vIn31 _lhsIoptions) -> ( let
_subX32 = Control.Monad.Identity.runIdentity (attach_T_Lhs (arg_sub_))
(T_Lhs_vOut31 _subIpp) = inv_Lhs_s32 _subX32 (T_Lhs_vIn31 _subOoptions)
_lhsOpp :: PP_Doc
_lhsOpp = rule115 _subIpp arg_name_
_subOoptions = rule116 _lhsIoptions
!__result_ = T_Lhs_vOut31 _lhsOpp
in __result_ )
in C_Lhs_s32 v31
{-# INLINE rule115 #-}
{-# LINE 158 "src-ag/PrintOcamlCode.ag" #-}
rule115 = \ ((_subIpp) :: PP_Doc) name_ ->
{-# LINE 158 "src-ag/PrintOcamlCode.ag" #-}
pp_parens (name_ >#< _subIpp)
{-# LINE 1727 "dist/build/PrintOcamlCode.hs"#-}
{-# INLINE rule116 #-}
rule116 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
data Inh_NamedType = Inh_NamedType { }
data Syn_NamedType = Syn_NamedType { pp_Syn_NamedType :: !(PP_Doc) }
{-# INLINABLE wrap_NamedType #-}
wrap_NamedType :: T_NamedType -> Inh_NamedType -> (Syn_NamedType )
wrap_NamedType !(T_NamedType act) !(Inh_NamedType ) =
Control.Monad.Identity.runIdentity (
do !sem <- act
let arg34 = T_NamedType_vIn34
!(T_NamedType_vOut34 _lhsOpp) <- return (inv_NamedType_s35 sem arg34)
return (Syn_NamedType _lhsOpp)
)
{-# INLINE sem_NamedType #-}
sem_NamedType :: NamedType -> T_NamedType
sem_NamedType ( Named !strict_ !name_ tp_ ) = sem_NamedType_Named strict_ name_ ( sem_Type tp_ )
newtype T_NamedType = T_NamedType {
attach_T_NamedType :: Identity (T_NamedType_s35 )
}
newtype T_NamedType_s35 = C_NamedType_s35 {
inv_NamedType_s35 :: (T_NamedType_v34 )
}
data T_NamedType_s36 = C_NamedType_s36
type T_NamedType_v34 = (T_NamedType_vIn34 ) -> (T_NamedType_vOut34 )
data T_NamedType_vIn34 = T_NamedType_vIn34
data T_NamedType_vOut34 = T_NamedType_vOut34 (PP_Doc)
{-# NOINLINE sem_NamedType_Named #-}
sem_NamedType_Named :: (Bool) -> (String) -> T_Type -> T_NamedType
sem_NamedType_Named _ !arg_name_ arg_tp_ = T_NamedType (return st35) where
{-# NOINLINE st35 #-}
!st35 = let
v34 :: T_NamedType_v34
v34 = \ !(T_NamedType_vIn34 ) -> ( let
_tpX50 = Control.Monad.Identity.runIdentity (attach_T_Type (arg_tp_))
(T_Type_vOut49 _tpIpp) = inv_Type_s50 _tpX50 (T_Type_vIn49 )
_lhsOpp :: PP_Doc
_lhsOpp = rule117 _tpIpp arg_name_
!__result_ = T_NamedType_vOut34 _lhsOpp
in __result_ )
in C_NamedType_s35 v34
{-# INLINE rule117 #-}
{-# LINE 191 "src-ag/PrintOcamlCode.ag" #-}
rule117 = \ ((_tpIpp) :: PP_Doc) name_ ->
{-# LINE 191 "src-ag/PrintOcamlCode.ag" #-}
name_ >#< ":" >#< _tpIpp
{-# LINE 1781 "dist/build/PrintOcamlCode.hs"#-}
data Inh_NamedTypes = Inh_NamedTypes { }
data Syn_NamedTypes = Syn_NamedTypes { pps_Syn_NamedTypes :: !(PP_Docs) }
{-# INLINABLE wrap_NamedTypes #-}
wrap_NamedTypes :: T_NamedTypes -> Inh_NamedTypes -> (Syn_NamedTypes )
wrap_NamedTypes !(T_NamedTypes act) !(Inh_NamedTypes ) =
Control.Monad.Identity.runIdentity (
do !sem <- act
let arg37 = T_NamedTypes_vIn37
!(T_NamedTypes_vOut37 _lhsOpps) <- return (inv_NamedTypes_s38 sem arg37)
return (Syn_NamedTypes _lhsOpps)
)
{-# NOINLINE sem_NamedTypes #-}
sem_NamedTypes :: NamedTypes -> T_NamedTypes
sem_NamedTypes list = Prelude.foldr sem_NamedTypes_Cons sem_NamedTypes_Nil (Prelude.map sem_NamedType list)
newtype T_NamedTypes = T_NamedTypes {
attach_T_NamedTypes :: Identity (T_NamedTypes_s38 )
}
newtype T_NamedTypes_s38 = C_NamedTypes_s38 {
inv_NamedTypes_s38 :: (T_NamedTypes_v37 )
}
data T_NamedTypes_s39 = C_NamedTypes_s39
type T_NamedTypes_v37 = (T_NamedTypes_vIn37 ) -> (T_NamedTypes_vOut37 )
data T_NamedTypes_vIn37 = T_NamedTypes_vIn37
data T_NamedTypes_vOut37 = T_NamedTypes_vOut37 (PP_Docs)
{-# NOINLINE sem_NamedTypes_Cons #-}
sem_NamedTypes_Cons :: T_NamedType -> T_NamedTypes -> T_NamedTypes
sem_NamedTypes_Cons arg_hd_ arg_tl_ = T_NamedTypes (return st38) where
{-# NOINLINE st38 #-}
!st38 = let
v37 :: T_NamedTypes_v37
v37 = \ !(T_NamedTypes_vIn37 ) -> ( let
_hdX35 = Control.Monad.Identity.runIdentity (attach_T_NamedType (arg_hd_))
_tlX38 = Control.Monad.Identity.runIdentity (attach_T_NamedTypes (arg_tl_))
(T_NamedType_vOut34 _hdIpp) = inv_NamedType_s35 _hdX35 (T_NamedType_vIn34 )
(T_NamedTypes_vOut37 _tlIpps) = inv_NamedTypes_s38 _tlX38 (T_NamedTypes_vIn37 )
_lhsOpps :: PP_Docs
_lhsOpps = rule118 _hdIpp _tlIpps
!__result_ = T_NamedTypes_vOut37 _lhsOpps
in __result_ )
in C_NamedTypes_s38 v37
{-# INLINE rule118 #-}
{-# LINE 77 "src-ag/PrintOcamlCode.ag" #-}
rule118 = \ ((_hdIpp) :: PP_Doc) ((_tlIpps) :: PP_Docs) ->
{-# LINE 77 "src-ag/PrintOcamlCode.ag" #-}
_hdIpp : _tlIpps
{-# LINE 1834 "dist/build/PrintOcamlCode.hs"#-}
{-# NOINLINE sem_NamedTypes_Nil #-}
sem_NamedTypes_Nil :: T_NamedTypes
sem_NamedTypes_Nil = T_NamedTypes (return st38) where
{-# NOINLINE st38 #-}
!st38 = let
v37 :: T_NamedTypes_v37
v37 = \ !(T_NamedTypes_vIn37 ) -> ( let
_lhsOpps :: PP_Docs
_lhsOpps = rule119 ()
!__result_ = T_NamedTypes_vOut37 _lhsOpps
in __result_ )
in C_NamedTypes_s38 v37
{-# INLINE rule119 #-}
{-# LINE 78 "src-ag/PrintOcamlCode.ag" #-}
rule119 = \ (_ :: ()) ->
{-# LINE 78 "src-ag/PrintOcamlCode.ag" #-}
[]
{-# LINE 1852 "dist/build/PrintOcamlCode.hs"#-}
data Inh_Pattern = Inh_Pattern { options_Inh_Pattern :: !(Options) }
data Syn_Pattern = Syn_Pattern { copy_Syn_Pattern :: !(Pattern), isUnderscore_Syn_Pattern :: !(Bool), pp_Syn_Pattern :: !(PP_Doc) }
{-# INLINABLE wrap_Pattern #-}
wrap_Pattern :: T_Pattern -> Inh_Pattern -> (Syn_Pattern )
wrap_Pattern !(T_Pattern act) !(Inh_Pattern _lhsIoptions) =
Control.Monad.Identity.runIdentity (
do !sem <- act
let arg40 = T_Pattern_vIn40 _lhsIoptions
!(T_Pattern_vOut40 _lhsOcopy _lhsOisUnderscore _lhsOpp) <- return (inv_Pattern_s41 sem arg40)
return (Syn_Pattern _lhsOcopy _lhsOisUnderscore _lhsOpp)
)
{-# NOINLINE sem_Pattern #-}
sem_Pattern :: Pattern -> T_Pattern
sem_Pattern ( Constr !name_ pats_ ) = sem_Pattern_Constr name_ ( sem_Patterns pats_ )
sem_Pattern ( Product !pos_ pats_ ) = sem_Pattern_Product pos_ ( sem_Patterns pats_ )
sem_Pattern ( Alias !field_ !attr_ pat_ ) = sem_Pattern_Alias field_ attr_ ( sem_Pattern pat_ )
sem_Pattern ( Irrefutable pat_ ) = sem_Pattern_Irrefutable ( sem_Pattern pat_ )
sem_Pattern ( Underscore !pos_ ) = sem_Pattern_Underscore pos_
newtype T_Pattern = T_Pattern {
attach_T_Pattern :: Identity (T_Pattern_s41 )
}
newtype T_Pattern_s41 = C_Pattern_s41 {
inv_Pattern_s41 :: (T_Pattern_v40 )
}
data T_Pattern_s42 = C_Pattern_s42
type T_Pattern_v40 = (T_Pattern_vIn40 ) -> (T_Pattern_vOut40 )
data T_Pattern_vIn40 = T_Pattern_vIn40 (Options)
data T_Pattern_vOut40 = T_Pattern_vOut40 (Pattern) (Bool) (PP_Doc)
{-# NOINLINE sem_Pattern_Constr #-}
sem_Pattern_Constr :: (ConstructorIdent) -> T_Patterns -> T_Pattern
sem_Pattern_Constr !arg_name_ arg_pats_ = T_Pattern (return st41) where
{-# NOINLINE st41 #-}
!st41 = let
v40 :: T_Pattern_v40
v40 = \ !(T_Pattern_vIn40 _lhsIoptions) -> ( let
_patsX44 = Control.Monad.Identity.runIdentity (attach_T_Patterns (arg_pats_))
(T_Patterns_vOut43 _patsIcopy _patsIpps) = inv_Patterns_s44 _patsX44 (T_Patterns_vIn43 _patsOoptions)
_lhsOpp :: PP_Doc
_lhsOpp = rule120 _patsIpps arg_name_
_lhsOisUnderscore :: Bool
_lhsOisUnderscore = rule121 ()
_copy = rule122 _patsIcopy arg_name_
_lhsOcopy :: Pattern
_lhsOcopy = rule123 _copy
_patsOoptions = rule124 _lhsIoptions
!__result_ = T_Pattern_vOut40 _lhsOcopy _lhsOisUnderscore _lhsOpp
in __result_ )
in C_Pattern_s41 v40
{-# INLINE rule120 #-}
{-# LINE 194 "src-ag/PrintOcamlCode.ag" #-}
rule120 = \ ((_patsIpps) :: PP_Docs) name_ ->
{-# LINE 194 "src-ag/PrintOcamlCode.ag" #-}
pp_parens $ name_ >#< hv_sp _patsIpps
{-# LINE 1913 "dist/build/PrintOcamlCode.hs"#-}
{-# INLINE rule121 #-}
{-# LINE 204 "src-ag/PrintOcamlCode.ag" #-}
rule121 = \ (_ :: ()) ->
{-# LINE 204 "src-ag/PrintOcamlCode.ag" #-}
False
{-# LINE 1919 "dist/build/PrintOcamlCode.hs"#-}
{-# INLINE rule122 #-}
rule122 = \ ((_patsIcopy) :: Patterns) name_ ->
Constr name_ _patsIcopy
{-# INLINE rule123 #-}
rule123 = \ _copy ->
_copy
{-# INLINE rule124 #-}
rule124 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# NOINLINE sem_Pattern_Product #-}
sem_Pattern_Product :: (Pos) -> T_Patterns -> T_Pattern
sem_Pattern_Product !arg_pos_ arg_pats_ = T_Pattern (return st41) where
{-# NOINLINE st41 #-}
!st41 = let
v40 :: T_Pattern_v40
v40 = \ !(T_Pattern_vIn40 _lhsIoptions) -> ( let
_patsX44 = Control.Monad.Identity.runIdentity (attach_T_Patterns (arg_pats_))
(T_Patterns_vOut43 _patsIcopy _patsIpps) = inv_Patterns_s44 _patsX44 (T_Patterns_vIn43 _patsOoptions)
_lhsOpp :: PP_Doc
_lhsOpp = rule125 _patsIpps
_lhsOisUnderscore :: Bool
_lhsOisUnderscore = rule126 ()
_copy = rule127 _patsIcopy arg_pos_
_lhsOcopy :: Pattern
_lhsOcopy = rule128 _copy
_patsOoptions = rule129 _lhsIoptions
!__result_ = T_Pattern_vOut40 _lhsOcopy _lhsOisUnderscore _lhsOpp
in __result_ )
in C_Pattern_s41 v40
{-# INLINE rule125 #-}
{-# LINE 195 "src-ag/PrintOcamlCode.ag" #-}
rule125 = \ ((_patsIpps) :: PP_Docs) ->
{-# LINE 195 "src-ag/PrintOcamlCode.ag" #-}
pp_block "(" ")" "," _patsIpps
{-# LINE 1954 "dist/build/PrintOcamlCode.hs"#-}
{-# INLINE rule126 #-}
{-# LINE 205 "src-ag/PrintOcamlCode.ag" #-}
rule126 = \ (_ :: ()) ->
{-# LINE 205 "src-ag/PrintOcamlCode.ag" #-}
False
{-# LINE 1960 "dist/build/PrintOcamlCode.hs"#-}
{-# INLINE rule127 #-}
rule127 = \ ((_patsIcopy) :: Patterns) pos_ ->
Product pos_ _patsIcopy
{-# INLINE rule128 #-}
rule128 = \ _copy ->
_copy
{-# INLINE rule129 #-}
rule129 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# NOINLINE sem_Pattern_Alias #-}
sem_Pattern_Alias :: (Identifier) -> (Identifier) -> T_Pattern -> T_Pattern
sem_Pattern_Alias !arg_field_ !arg_attr_ arg_pat_ = T_Pattern (return st41) where
{-# NOINLINE st41 #-}
!st41 = let
v40 :: T_Pattern_v40
v40 = \ !(T_Pattern_vIn40 _lhsIoptions) -> ( let
_patX41 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_pat_))
(T_Pattern_vOut40 _patIcopy _patIisUnderscore _patIpp) = inv_Pattern_s41 _patX41 (T_Pattern_vIn40 _patOoptions)
_lhsOpp :: PP_Doc
_lhsOpp = rule130 _lhsIoptions _patIisUnderscore arg_attr_ arg_field_
_lhsOisUnderscore :: Bool
_lhsOisUnderscore = rule131 ()
_copy = rule132 _patIcopy arg_attr_ arg_field_
_lhsOcopy :: Pattern
_lhsOcopy = rule133 _copy
_patOoptions = rule134 _lhsIoptions
!__result_ = T_Pattern_vOut40 _lhsOcopy _lhsOisUnderscore _lhsOpp
in __result_ )
in C_Pattern_s41 v40
{-# INLINE rule130 #-}
{-# LINE 197 "src-ag/PrintOcamlCode.ag" #-}
rule130 = \ ((_lhsIoptions) :: Options) ((_patIisUnderscore) :: Bool) attr_ field_ ->
{-# LINE 197 "src-ag/PrintOcamlCode.ag" #-}
if _patIisUnderscore
then pp (attrname _lhsIoptions False field_ attr_)
else error "pp of Pattern.Alias is only supported in the form (x@_)"
{-# LINE 1997 "dist/build/PrintOcamlCode.hs"#-}
{-# INLINE rule131 #-}
{-# LINE 206 "src-ag/PrintOcamlCode.ag" #-}
rule131 = \ (_ :: ()) ->
{-# LINE 206 "src-ag/PrintOcamlCode.ag" #-}
False
{-# LINE 2003 "dist/build/PrintOcamlCode.hs"#-}
{-# INLINE rule132 #-}
rule132 = \ ((_patIcopy) :: Pattern) attr_ field_ ->
Alias field_ attr_ _patIcopy
{-# INLINE rule133 #-}
rule133 = \ _copy ->
_copy
{-# INLINE rule134 #-}
rule134 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# NOINLINE sem_Pattern_Irrefutable #-}
sem_Pattern_Irrefutable :: T_Pattern -> T_Pattern
sem_Pattern_Irrefutable arg_pat_ = T_Pattern (return st41) where
{-# NOINLINE st41 #-}
!st41 = let
v40 :: T_Pattern_v40
v40 = \ !(T_Pattern_vIn40 _lhsIoptions) -> ( let
_patX41 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_pat_))
(T_Pattern_vOut40 _patIcopy _patIisUnderscore _patIpp) = inv_Pattern_s41 _patX41 (T_Pattern_vIn40 _patOoptions)
_lhsOpp :: PP_Doc
_lhsOpp = rule135 ()
_copy = rule136 _patIcopy
_lhsOcopy :: Pattern
_lhsOcopy = rule137 _copy
_lhsOisUnderscore :: Bool
_lhsOisUnderscore = rule138 _patIisUnderscore
_patOoptions = rule139 _lhsIoptions
!__result_ = T_Pattern_vOut40 _lhsOcopy _lhsOisUnderscore _lhsOpp
in __result_ )
in C_Pattern_s41 v40
{-# INLINE rule135 #-}
{-# LINE 200 "src-ag/PrintOcamlCode.ag" #-}
rule135 = \ (_ :: ()) ->
{-# LINE 200 "src-ag/PrintOcamlCode.ag" #-}
error "pp of Pattern.Irrefutable not supported"
{-# LINE 2038 "dist/build/PrintOcamlCode.hs"#-}
{-# INLINE rule136 #-}
rule136 = \ ((_patIcopy) :: Pattern) ->
Irrefutable _patIcopy
{-# INLINE rule137 #-}
rule137 = \ _copy ->
_copy
{-# INLINE rule138 #-}
rule138 = \ ((_patIisUnderscore) :: Bool) ->
_patIisUnderscore
{-# INLINE rule139 #-}
rule139 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# NOINLINE sem_Pattern_Underscore #-}
sem_Pattern_Underscore :: (Pos) -> T_Pattern
sem_Pattern_Underscore !arg_pos_ = T_Pattern (return st41) where
{-# NOINLINE st41 #-}
!st41 = let
v40 :: T_Pattern_v40
v40 = \ !(T_Pattern_vIn40 _lhsIoptions) -> ( let
_lhsOpp :: PP_Doc
_lhsOpp = rule140 ()
_lhsOisUnderscore :: Bool
_lhsOisUnderscore = rule141 ()
_copy = rule142 arg_pos_
_lhsOcopy :: Pattern
_lhsOcopy = rule143 _copy
!__result_ = T_Pattern_vOut40 _lhsOcopy _lhsOisUnderscore _lhsOpp
in __result_ )
in C_Pattern_s41 v40
{-# INLINE rule140 #-}
{-# LINE 201 "src-ag/PrintOcamlCode.ag" #-}
rule140 = \ (_ :: ()) ->
{-# LINE 201 "src-ag/PrintOcamlCode.ag" #-}
text "_"
{-# LINE 2073 "dist/build/PrintOcamlCode.hs"#-}
{-# INLINE rule141 #-}
{-# LINE 207 "src-ag/PrintOcamlCode.ag" #-}
rule141 = \ (_ :: ()) ->
{-# LINE 207 "src-ag/PrintOcamlCode.ag" #-}
True
{-# LINE 2079 "dist/build/PrintOcamlCode.hs"#-}
{-# INLINE rule142 #-}
rule142 = \ pos_ ->
Underscore pos_
{-# INLINE rule143 #-}
rule143 = \ _copy ->
_copy
data Inh_Patterns = Inh_Patterns { options_Inh_Patterns :: !(Options) }
data Syn_Patterns = Syn_Patterns { copy_Syn_Patterns :: !(Patterns), pps_Syn_Patterns :: !(PP_Docs) }
{-# INLINABLE wrap_Patterns #-}
wrap_Patterns :: T_Patterns -> Inh_Patterns -> (Syn_Patterns )
wrap_Patterns !(T_Patterns act) !(Inh_Patterns _lhsIoptions) =
Control.Monad.Identity.runIdentity (
do !sem <- act
let arg43 = T_Patterns_vIn43 _lhsIoptions
!(T_Patterns_vOut43 _lhsOcopy _lhsOpps) <- return (inv_Patterns_s44 sem arg43)
return (Syn_Patterns _lhsOcopy _lhsOpps)
)
{-# NOINLINE sem_Patterns #-}
sem_Patterns :: Patterns -> T_Patterns
sem_Patterns list = Prelude.foldr sem_Patterns_Cons sem_Patterns_Nil (Prelude.map sem_Pattern list)
newtype T_Patterns = T_Patterns {
attach_T_Patterns :: Identity (T_Patterns_s44 )
}
newtype T_Patterns_s44 = C_Patterns_s44 {
inv_Patterns_s44 :: (T_Patterns_v43 )
}
data T_Patterns_s45 = C_Patterns_s45
type T_Patterns_v43 = (T_Patterns_vIn43 ) -> (T_Patterns_vOut43 )
data T_Patterns_vIn43 = T_Patterns_vIn43 (Options)
data T_Patterns_vOut43 = T_Patterns_vOut43 (Patterns) (PP_Docs)
{-# NOINLINE sem_Patterns_Cons #-}
sem_Patterns_Cons :: T_Pattern -> T_Patterns -> T_Patterns
sem_Patterns_Cons arg_hd_ arg_tl_ = T_Patterns (return st44) where
{-# NOINLINE st44 #-}
!st44 = let
v43 :: T_Patterns_v43
v43 = \ !(T_Patterns_vIn43 _lhsIoptions) -> ( let
_hdX41 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_hd_))
_tlX44 = Control.Monad.Identity.runIdentity (attach_T_Patterns (arg_tl_))
(T_Pattern_vOut40 _hdIcopy _hdIisUnderscore _hdIpp) = inv_Pattern_s41 _hdX41 (T_Pattern_vIn40 _hdOoptions)
(T_Patterns_vOut43 _tlIcopy _tlIpps) = inv_Patterns_s44 _tlX44 (T_Patterns_vIn43 _tlOoptions)
_lhsOpps :: PP_Docs
_lhsOpps = rule144 _hdIpp _tlIpps
_copy = rule145 _hdIcopy _tlIcopy
_lhsOcopy :: Patterns
_lhsOcopy = rule146 _copy
_hdOoptions = rule147 _lhsIoptions
_tlOoptions = rule148 _lhsIoptions
!__result_ = T_Patterns_vOut43 _lhsOcopy _lhsOpps
in __result_ )
in C_Patterns_s44 v43
{-# INLINE rule144 #-}
{-# LINE 89 "src-ag/PrintOcamlCode.ag" #-}
rule144 = \ ((_hdIpp) :: PP_Doc) ((_tlIpps) :: PP_Docs) ->
{-# LINE 89 "src-ag/PrintOcamlCode.ag" #-}
_hdIpp : _tlIpps
{-# LINE 2143 "dist/build/PrintOcamlCode.hs"#-}
{-# INLINE rule145 #-}
rule145 = \ ((_hdIcopy) :: Pattern) ((_tlIcopy) :: Patterns) ->
(:) _hdIcopy _tlIcopy
{-# INLINE rule146 #-}
rule146 = \ _copy ->
_copy
{-# INLINE rule147 #-}
rule147 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# INLINE rule148 #-}
rule148 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# NOINLINE sem_Patterns_Nil #-}
sem_Patterns_Nil :: T_Patterns
sem_Patterns_Nil = T_Patterns (return st44) where
{-# NOINLINE st44 #-}
!st44 = let
v43 :: T_Patterns_v43
v43 = \ !(T_Patterns_vIn43 _lhsIoptions) -> ( let
_lhsOpps :: PP_Docs
_lhsOpps = rule149 ()
_copy = rule150 ()
_lhsOcopy :: Patterns
_lhsOcopy = rule151 _copy
!__result_ = T_Patterns_vOut43 _lhsOcopy _lhsOpps
in __result_ )
in C_Patterns_s44 v43
{-# INLINE rule149 #-}
{-# LINE 90 "src-ag/PrintOcamlCode.ag" #-}
rule149 = \ (_ :: ()) ->
{-# LINE 90 "src-ag/PrintOcamlCode.ag" #-}
[]
{-# LINE 2176 "dist/build/PrintOcamlCode.hs"#-}
{-# INLINE rule150 #-}
rule150 = \ (_ :: ()) ->
[]
{-# INLINE rule151 #-}
rule151 = \ _copy ->
_copy
data Inh_Program = Inh_Program { options_Inh_Program :: !(Options), textBlockMap_Inh_Program :: !(Map BlockInfo PP_Doc) }
data Syn_Program = Syn_Program { output_Syn_Program :: !(PP_Docs) }
{-# INLINABLE wrap_Program #-}
wrap_Program :: T_Program -> Inh_Program -> (Syn_Program )
wrap_Program !(T_Program act) !(Inh_Program _lhsIoptions _lhsItextBlockMap) =
Control.Monad.Identity.runIdentity (
do !sem <- act
let arg46 = T_Program_vIn46 _lhsIoptions _lhsItextBlockMap
!(T_Program_vOut46 _lhsOoutput) <- return (inv_Program_s47 sem arg46)
return (Syn_Program _lhsOoutput)
)
{-# INLINE sem_Program #-}
sem_Program :: Program -> T_Program
sem_Program ( Program chunks_ !ordered_ ) = sem_Program_Program ( sem_Chunks chunks_ ) ordered_
newtype T_Program = T_Program {
attach_T_Program :: Identity (T_Program_s47 )
}
newtype T_Program_s47 = C_Program_s47 {
inv_Program_s47 :: (T_Program_v46 )
}
data T_Program_s48 = C_Program_s48
type T_Program_v46 = (T_Program_vIn46 ) -> (T_Program_vOut46 )
data T_Program_vIn46 = T_Program_vIn46 (Options) (Map BlockInfo PP_Doc)
data T_Program_vOut46 = T_Program_vOut46 (PP_Docs)
{-# NOINLINE sem_Program_Program #-}
sem_Program_Program :: T_Chunks -> (Bool) -> T_Program
sem_Program_Program arg_chunks_ _ = T_Program (return st47) where
{-# NOINLINE st47 #-}
!st47 = let
v46 :: T_Program_v46
v46 = \ !(T_Program_vIn46 _lhsIoptions _lhsItextBlockMap) -> ( let
_chunksX11 = Control.Monad.Identity.runIdentity (attach_T_Chunks (arg_chunks_))
(T_Chunks_vOut10 _chunksIpps) = inv_Chunks_s11 _chunksX11 (T_Chunks_vIn10 _chunksOisToplevel _chunksOoptions _chunksOtextBlockMap)
_lhsOoutput :: PP_Docs
_lhsOoutput = rule152 _chunksIpps
_chunksOisToplevel = rule153 ()
_chunksOoptions = rule154 _lhsIoptions
_chunksOtextBlockMap = rule155 _lhsItextBlockMap
!__result_ = T_Program_vOut46 _lhsOoutput
in __result_ )
in C_Program_s47 v46
{-# INLINE rule152 #-}
{-# LINE 58 "src-ag/PrintOcamlCode.ag" #-}
rule152 = \ ((_chunksIpps) :: PP_Docs) ->
{-# LINE 58 "src-ag/PrintOcamlCode.ag" #-}
_chunksIpps
{-# LINE 2236 "dist/build/PrintOcamlCode.hs"#-}
{-# INLINE rule153 #-}
{-# LINE 216 "src-ag/PrintOcamlCode.ag" #-}
rule153 = \ (_ :: ()) ->
{-# LINE 216 "src-ag/PrintOcamlCode.ag" #-}
True
{-# LINE 2242 "dist/build/PrintOcamlCode.hs"#-}
{-# INLINE rule154 #-}
rule154 = \ ((_lhsIoptions) :: Options) ->
_lhsIoptions
{-# INLINE rule155 #-}
rule155 = \ ((_lhsItextBlockMap) :: Map BlockInfo PP_Doc) ->
_lhsItextBlockMap
data Inh_Type = Inh_Type { }
data Syn_Type = Syn_Type { pp_Syn_Type :: !(PP_Doc) }
{-# INLINABLE wrap_Type #-}
wrap_Type :: T_Type -> Inh_Type -> (Syn_Type )
wrap_Type !(T_Type act) !(Inh_Type ) =
Control.Monad.Identity.runIdentity (
do !sem <- act
let arg49 = T_Type_vIn49
!(T_Type_vOut49 _lhsOpp) <- return (inv_Type_s50 sem arg49)
return (Syn_Type _lhsOpp)
)
{-# NOINLINE sem_Type #-}
sem_Type :: Type -> T_Type
sem_Type ( Arr left_ right_ ) = sem_Type_Arr ( sem_Type left_ ) ( sem_Type right_ )
sem_Type ( CtxApp !left_ right_ ) = sem_Type_CtxApp left_ ( sem_Type right_ )
sem_Type ( QuantApp !left_ right_ ) = sem_Type_QuantApp left_ ( sem_Type right_ )
sem_Type ( TypeApp func_ args_ ) = sem_Type_TypeApp ( sem_Type func_ ) ( sem_Types args_ )
sem_Type ( TupleType tps_ ) = sem_Type_TupleType ( sem_Types tps_ )
sem_Type ( UnboxedTupleType tps_ ) = sem_Type_UnboxedTupleType ( sem_Types tps_ )
sem_Type ( List tp_ ) = sem_Type_List ( sem_Type tp_ )
sem_Type ( SimpleType !txt_ ) = sem_Type_SimpleType txt_
sem_Type ( NontermType !name_ !params_ !deforested_ ) = sem_Type_NontermType name_ params_ deforested_
sem_Type ( TMaybe tp_ ) = sem_Type_TMaybe ( sem_Type tp_ )
sem_Type ( TEither left_ right_ ) = sem_Type_TEither ( sem_Type left_ ) ( sem_Type right_ )
sem_Type ( TMap key_ value_ ) = sem_Type_TMap ( sem_Type key_ ) ( sem_Type value_ )
sem_Type ( TIntMap value_ ) = sem_Type_TIntMap ( sem_Type value_ )
sem_Type ( TSet tp_ ) = sem_Type_TSet ( sem_Type tp_ )
sem_Type ( TIntSet ) = sem_Type_TIntSet
newtype T_Type = T_Type {
attach_T_Type :: Identity (T_Type_s50 )
}
newtype T_Type_s50 = C_Type_s50 {
inv_Type_s50 :: (T_Type_v49 )
}
data T_Type_s51 = C_Type_s51
type T_Type_v49 = (T_Type_vIn49 ) -> (T_Type_vOut49 )
data T_Type_vIn49 = T_Type_vIn49
data T_Type_vOut49 = T_Type_vOut49 (PP_Doc)
{-# NOINLINE sem_Type_Arr #-}
sem_Type_Arr :: T_Type -> T_Type -> T_Type
sem_Type_Arr arg_left_ arg_right_ = T_Type (return st50) where
{-# NOINLINE st50 #-}
!st50 = let
v49 :: T_Type_v49
v49 = \ !(T_Type_vIn49 ) -> ( let
_leftX50 = Control.Monad.Identity.runIdentity (attach_T_Type (arg_left_))
_rightX50 = Control.Monad.Identity.runIdentity (attach_T_Type (arg_right_))
(T_Type_vOut49 _leftIpp) = inv_Type_s50 _leftX50 (T_Type_vIn49 )
(T_Type_vOut49 _rightIpp) = inv_Type_s50 _rightX50 (T_Type_vIn49 )
_lhsOpp :: PP_Doc
_lhsOpp = rule156 _leftIpp _rightIpp
!__result_ = T_Type_vOut49 _lhsOpp
in __result_ )
in C_Type_s50 v49
{-# INLINE rule156 #-}
{-# LINE 161 "src-ag/PrintOcamlCode.ag" #-}
rule156 = \ ((_leftIpp) :: PP_Doc) ((_rightIpp) :: PP_Doc) ->
{-# LINE 161 "src-ag/PrintOcamlCode.ag" #-}
pp_parens (_leftIpp >#< "->" >#< _rightIpp)
{-# LINE 2315 "dist/build/PrintOcamlCode.hs"#-}
{-# NOINLINE sem_Type_CtxApp #-}
sem_Type_CtxApp :: ([(String, [String])]) -> T_Type -> T_Type
sem_Type_CtxApp _ arg_right_ = T_Type (return st50) where
{-# NOINLINE st50 #-}
!st50 = let
v49 :: T_Type_v49
v49 = \ !(T_Type_vIn49 ) -> ( let
_rightX50 = Control.Monad.Identity.runIdentity (attach_T_Type (arg_right_))
(T_Type_vOut49 _rightIpp) = inv_Type_s50 _rightX50 (T_Type_vIn49 )
_lhsOpp :: PP_Doc
_lhsOpp = rule157 ()
!__result_ = T_Type_vOut49 _lhsOpp
in __result_ )
in C_Type_s50 v49
{-# INLINE rule157 #-}
{-# LINE 162 "src-ag/PrintOcamlCode.ag" #-}
rule157 = \ (_ :: ()) ->
{-# LINE 162 "src-ag/PrintOcamlCode.ag" #-}
error "pp of Type.CtxApp not supported"
{-# LINE 2335 "dist/build/PrintOcamlCode.hs"#-}
{-# NOINLINE sem_Type_QuantApp #-}
sem_Type_QuantApp :: (String) -> T_Type -> T_Type
sem_Type_QuantApp _ arg_right_ = T_Type (return st50) where
{-# NOINLINE st50 #-}
!st50 = let
v49 :: T_Type_v49
v49 = \ !(T_Type_vIn49 ) -> ( let
_rightX50 = Control.Monad.Identity.runIdentity (attach_T_Type (arg_right_))
(T_Type_vOut49 _rightIpp) = inv_Type_s50 _rightX50 (T_Type_vIn49 )
_lhsOpp :: PP_Doc
_lhsOpp = rule158 _rightIpp
!__result_ = T_Type_vOut49 _lhsOpp
in __result_ )
in C_Type_s50 v49
{-# INLINE rule158 #-}
rule158 = \ ((_rightIpp) :: PP_Doc) ->
_rightIpp
{-# NOINLINE sem_Type_TypeApp #-}
sem_Type_TypeApp :: T_Type -> T_Types -> T_Type
sem_Type_TypeApp arg_func_ arg_args_ = T_Type (return st50) where
{-# NOINLINE st50 #-}
!st50 = let
v49 :: T_Type_v49
v49 = \ !(T_Type_vIn49 ) -> ( let
_funcX50 = Control.Monad.Identity.runIdentity (attach_T_Type (arg_func_))
_argsX53 = Control.Monad.Identity.runIdentity (attach_T_Types (arg_args_))
(T_Type_vOut49 _funcIpp) = inv_Type_s50 _funcX50 (T_Type_vIn49 )
(T_Types_vOut52 _argsIpps) = inv_Types_s53 _argsX53 (T_Types_vIn52 )
_lhsOpp :: PP_Doc
_lhsOpp = rule159 _argsIpps _funcIpp
!__result_ = T_Type_vOut49 _lhsOpp
in __result_ )
in C_Type_s50 v49
{-# INLINE rule159 #-}
{-# LINE 163 "src-ag/PrintOcamlCode.ag" #-}
rule159 = \ ((_argsIpps) :: PP_Docs) ((_funcIpp) :: PP_Doc) ->
{-# LINE 163 "src-ag/PrintOcamlCode.ag" #-}
pp_parens (hv_sp (_argsIpps ++ [_funcIpp]))
{-# LINE 2374 "dist/build/PrintOcamlCode.hs"#-}
{-# NOINLINE sem_Type_TupleType #-}
sem_Type_TupleType :: T_Types -> T_Type
sem_Type_TupleType arg_tps_ = T_Type (return st50) where
{-# NOINLINE st50 #-}
!st50 = let
v49 :: T_Type_v49
v49 = \ !(T_Type_vIn49 ) -> ( let
_tpsX53 = Control.Monad.Identity.runIdentity (attach_T_Types (arg_tps_))
(T_Types_vOut52 _tpsIpps) = inv_Types_s53 _tpsX53 (T_Types_vIn52 )
_lhsOpp :: PP_Doc
_lhsOpp = rule160 _tpsIpps
!__result_ = T_Type_vOut49 _lhsOpp
in __result_ )
in C_Type_s50 v49
{-# INLINE rule160 #-}
{-# LINE 164 "src-ag/PrintOcamlCode.ag" #-}
rule160 = \ ((_tpsIpps) :: PP_Docs) ->
{-# LINE 164 "src-ag/PrintOcamlCode.ag" #-}
pp_block "(" ")" "," _tpsIpps
{-# LINE 2394 "dist/build/PrintOcamlCode.hs"#-}
{-# NOINLINE sem_Type_UnboxedTupleType #-}
sem_Type_UnboxedTupleType :: T_Types -> T_Type
sem_Type_UnboxedTupleType arg_tps_ = T_Type (return st50) where
{-# NOINLINE st50 #-}
!st50 = let
v49 :: T_Type_v49
v49 = \ !(T_Type_vIn49 ) -> ( let
_tpsX53 = Control.Monad.Identity.runIdentity (attach_T_Types (arg_tps_))
(T_Types_vOut52 _tpsIpps) = inv_Types_s53 _tpsX53 (T_Types_vIn52 )
_lhsOpp :: PP_Doc
_lhsOpp = rule161 ()
!__result_ = T_Type_vOut49 _lhsOpp
in __result_ )
in C_Type_s50 v49
{-# INLINE rule161 #-}
{-# LINE 166 "src-ag/PrintOcamlCode.ag" #-}
rule161 = \ (_ :: ()) ->
{-# LINE 166 "src-ag/PrintOcamlCode.ag" #-}
error "pp of Type.UnboxedTupleType is not supported"
{-# LINE 2414 "dist/build/PrintOcamlCode.hs"#-}
{-# NOINLINE sem_Type_List #-}
sem_Type_List :: T_Type -> T_Type
sem_Type_List arg_tp_ = T_Type (return st50) where
{-# NOINLINE st50 #-}
!st50 = let
v49 :: T_Type_v49
v49 = \ !(T_Type_vIn49 ) -> ( let
_tpX50 = Control.Monad.Identity.runIdentity (attach_T_Type (arg_tp_))
(T_Type_vOut49 _tpIpp) = inv_Type_s50 _tpX50 (T_Type_vIn49 )
_lhsOpp :: PP_Doc
_lhsOpp = rule162 _tpIpp
!__result_ = T_Type_vOut49 _lhsOpp
in __result_ )
in C_Type_s50 v49
{-# INLINE rule162 #-}
{-# LINE 167 "src-ag/PrintOcamlCode.ag" #-}
rule162 = \ ((_tpIpp) :: PP_Doc) ->
{-# LINE 167 "src-ag/PrintOcamlCode.ag" #-}
_tpIpp >#< "list"
{-# LINE 2434 "dist/build/PrintOcamlCode.hs"#-}
{-# NOINLINE sem_Type_SimpleType #-}
sem_Type_SimpleType :: (String) -> T_Type
sem_Type_SimpleType !arg_txt_ = T_Type (return st50) where
{-# NOINLINE st50 #-}
!st50 = let
v49 :: T_Type_v49
v49 = \ !(T_Type_vIn49 ) -> ( let
_lhsOpp :: PP_Doc
_lhsOpp = rule163 arg_txt_
!__result_ = T_Type_vOut49 _lhsOpp
in __result_ )
in C_Type_s50 v49
{-# INLINE rule163 #-}
{-# LINE 168 "src-ag/PrintOcamlCode.ag" #-}
rule163 = \ txt_ ->
{-# LINE 168 "src-ag/PrintOcamlCode.ag" #-}
text txt_
{-# LINE 2452 "dist/build/PrintOcamlCode.hs"#-}
{-# NOINLINE sem_Type_NontermType #-}
sem_Type_NontermType :: (String) -> ([String]) -> (Bool) -> T_Type
sem_Type_NontermType !arg_name_ !arg_params_ _ = T_Type (return st50) where
{-# NOINLINE st50 #-}
!st50 = let
v49 :: T_Type_v49
v49 = \ !(T_Type_vIn49 ) -> ( let
_lhsOpp :: PP_Doc
_lhsOpp = rule164 arg_name_ arg_params_
!__result_ = T_Type_vOut49 _lhsOpp
in __result_ )
in C_Type_s50 v49
{-# INLINE rule164 #-}
{-# LINE 169 "src-ag/PrintOcamlCode.ag" #-}
rule164 = \ name_ params_ ->
{-# LINE 169 "src-ag/PrintOcamlCode.ag" #-}
pp_block "(" ")" " " (map text params_ ++ [text $ toOcamlTC name_])
{-# LINE 2470 "dist/build/PrintOcamlCode.hs"#-}
{-# NOINLINE sem_Type_TMaybe #-}
sem_Type_TMaybe :: T_Type -> T_Type
sem_Type_TMaybe arg_tp_ = T_Type (return st50) where
{-# NOINLINE st50 #-}
!st50 = let
v49 :: T_Type_v49
v49 = \ !(T_Type_vIn49 ) -> ( let
_tpX50 = Control.Monad.Identity.runIdentity (attach_T_Type (arg_tp_))
(T_Type_vOut49 _tpIpp) = inv_Type_s50 _tpX50 (T_Type_vIn49 )
_lhsOpp :: PP_Doc
_lhsOpp = rule165 _tpIpp
!__result_ = T_Type_vOut49 _lhsOpp
in __result_ )
in C_Type_s50 v49
{-# INLINE rule165 #-}
{-# LINE 170 "src-ag/PrintOcamlCode.ag" #-}
rule165 = \ ((_tpIpp) :: PP_Doc) ->
{-# LINE 170 "src-ag/PrintOcamlCode.ag" #-}
_tpIpp >#< "opt"
{-# LINE 2490 "dist/build/PrintOcamlCode.hs"#-}
{-# NOINLINE sem_Type_TEither #-}
sem_Type_TEither :: T_Type -> T_Type -> T_Type
sem_Type_TEither arg_left_ arg_right_ = T_Type (return st50) where
{-# NOINLINE st50 #-}
!st50 = let
v49 :: T_Type_v49
v49 = \ !(T_Type_vIn49 ) -> ( let
_leftX50 = Control.Monad.Identity.runIdentity (attach_T_Type (arg_left_))
_rightX50 = Control.Monad.Identity.runIdentity (attach_T_Type (arg_right_))
(T_Type_vOut49 _leftIpp) = inv_Type_s50 _leftX50 (T_Type_vIn49 )
(T_Type_vOut49 _rightIpp) = inv_Type_s50 _rightX50 (T_Type_vIn49 )
_lhsOpp :: PP_Doc
_lhsOpp = rule166 ()
!__result_ = T_Type_vOut49 _lhsOpp
in __result_ )
in C_Type_s50 v49
{-# INLINE rule166 #-}
{-# LINE 171 "src-ag/PrintOcamlCode.ag" #-}
rule166 = \ (_ :: ()) ->
{-# LINE 171 "src-ag/PrintOcamlCode.ag" #-}
error "pp of Type.TEither is not supported"
{-# LINE 2512 "dist/build/PrintOcamlCode.hs"#-}
{-# NOINLINE sem_Type_TMap #-}
sem_Type_TMap :: T_Type -> T_Type -> T_Type
sem_Type_TMap arg_key_ arg_value_ = T_Type (return st50) where
{-# NOINLINE st50 #-}
!st50 = let
v49 :: T_Type_v49
v49 = \ !(T_Type_vIn49 ) -> ( let
_keyX50 = Control.Monad.Identity.runIdentity (attach_T_Type (arg_key_))
_valueX50 = Control.Monad.Identity.runIdentity (attach_T_Type (arg_value_))
(T_Type_vOut49 _keyIpp) = inv_Type_s50 _keyX50 (T_Type_vIn49 )
(T_Type_vOut49 _valueIpp) = inv_Type_s50 _valueX50 (T_Type_vIn49 )
_lhsOpp :: PP_Doc
_lhsOpp = rule167 ()
!__result_ = T_Type_vOut49 _lhsOpp
in __result_ )
in C_Type_s50 v49
{-# INLINE rule167 #-}
{-# LINE 172 "src-ag/PrintOcamlCode.ag" #-}
rule167 = \ (_ :: ()) ->
{-# LINE 172 "src-ag/PrintOcamlCode.ag" #-}
error "pp of Type.TMap is not supported"
{-# LINE 2534 "dist/build/PrintOcamlCode.hs"#-}
{-# NOINLINE sem_Type_TIntMap #-}
sem_Type_TIntMap :: T_Type -> T_Type
sem_Type_TIntMap arg_value_ = T_Type (return st50) where
{-# NOINLINE st50 #-}
!st50 = let
v49 :: T_Type_v49
v49 = \ !(T_Type_vIn49 ) -> ( let
_valueX50 = Control.Monad.Identity.runIdentity (attach_T_Type (arg_value_))
(T_Type_vOut49 _valueIpp) = inv_Type_s50 _valueX50 (T_Type_vIn49 )
_lhsOpp :: PP_Doc
_lhsOpp = rule168 ()
!__result_ = T_Type_vOut49 _lhsOpp
in __result_ )
in C_Type_s50 v49
{-# INLINE rule168 #-}
{-# LINE 173 "src-ag/PrintOcamlCode.ag" #-}
rule168 = \ (_ :: ()) ->
{-# LINE 173 "src-ag/PrintOcamlCode.ag" #-}
error "pp of Type.TIntMap is not supported"
{-# LINE 2554 "dist/build/PrintOcamlCode.hs"#-}
{-# NOINLINE sem_Type_TSet #-}
sem_Type_TSet :: T_Type -> T_Type
sem_Type_TSet arg_tp_ = T_Type (return st50) where
{-# NOINLINE st50 #-}
!st50 = let
v49 :: T_Type_v49
v49 = \ !(T_Type_vIn49 ) -> ( let
_tpX50 = Control.Monad.Identity.runIdentity (attach_T_Type (arg_tp_))
(T_Type_vOut49 _tpIpp) = inv_Type_s50 _tpX50 (T_Type_vIn49 )
_lhsOpp :: PP_Doc
_lhsOpp = rule169 ()
!__result_ = T_Type_vOut49 _lhsOpp
in __result_ )
in C_Type_s50 v49
{-# INLINE rule169 #-}
{-# LINE 174 "src-ag/PrintOcamlCode.ag" #-}
rule169 = \ (_ :: ()) ->
{-# LINE 174 "src-ag/PrintOcamlCode.ag" #-}
error "pp of Type.TSet is not supported"
{-# LINE 2574 "dist/build/PrintOcamlCode.hs"#-}
{-# NOINLINE sem_Type_TIntSet #-}
sem_Type_TIntSet :: T_Type
sem_Type_TIntSet = T_Type (return st50) where
{-# NOINLINE st50 #-}
!st50 = let
v49 :: T_Type_v49
v49 = \ !(T_Type_vIn49 ) -> ( let
_lhsOpp :: PP_Doc
_lhsOpp = rule170 ()
!__result_ = T_Type_vOut49 _lhsOpp
in __result_ )
in C_Type_s50 v49
{-# INLINE rule170 #-}
{-# LINE 175 "src-ag/PrintOcamlCode.ag" #-}
rule170 = \ (_ :: ()) ->
{-# LINE 175 "src-ag/PrintOcamlCode.ag" #-}
error "pp of Type.TIntSet is not supported"
{-# LINE 2592 "dist/build/PrintOcamlCode.hs"#-}
data Inh_Types = Inh_Types { }
data Syn_Types = Syn_Types { pps_Syn_Types :: !(PP_Docs) }
{-# INLINABLE wrap_Types #-}
wrap_Types :: T_Types -> Inh_Types -> (Syn_Types )
wrap_Types !(T_Types act) !(Inh_Types ) =
Control.Monad.Identity.runIdentity (
do !sem <- act
let arg52 = T_Types_vIn52
!(T_Types_vOut52 _lhsOpps) <- return (inv_Types_s53 sem arg52)
return (Syn_Types _lhsOpps)
)
{-# NOINLINE sem_Types #-}
sem_Types :: Types -> T_Types
sem_Types list = Prelude.foldr sem_Types_Cons sem_Types_Nil (Prelude.map sem_Type list)
newtype T_Types = T_Types {
attach_T_Types :: Identity (T_Types_s53 )
}
newtype T_Types_s53 = C_Types_s53 {
inv_Types_s53 :: (T_Types_v52 )
}
data T_Types_s54 = C_Types_s54
type T_Types_v52 = (T_Types_vIn52 ) -> (T_Types_vOut52 )
data T_Types_vIn52 = T_Types_vIn52
data T_Types_vOut52 = T_Types_vOut52 (PP_Docs)
{-# NOINLINE sem_Types_Cons #-}
sem_Types_Cons :: T_Type -> T_Types -> T_Types
sem_Types_Cons arg_hd_ arg_tl_ = T_Types (return st53) where
{-# NOINLINE st53 #-}
!st53 = let
v52 :: T_Types_v52
v52 = \ !(T_Types_vIn52 ) -> ( let
_hdX50 = Control.Monad.Identity.runIdentity (attach_T_Type (arg_hd_))
_tlX53 = Control.Monad.Identity.runIdentity (attach_T_Types (arg_tl_))
(T_Type_vOut49 _hdIpp) = inv_Type_s50 _hdX50 (T_Type_vIn49 )
(T_Types_vOut52 _tlIpps) = inv_Types_s53 _tlX53 (T_Types_vIn52 )
_lhsOpps :: PP_Docs
_lhsOpps = rule171 _hdIpp _tlIpps
!__result_ = T_Types_vOut52 _lhsOpps
in __result_ )
in C_Types_s53 v52
{-# INLINE rule171 #-}
{-# LINE 73 "src-ag/PrintOcamlCode.ag" #-}
rule171 = \ ((_hdIpp) :: PP_Doc) ((_tlIpps) :: PP_Docs) ->
{-# LINE 73 "src-ag/PrintOcamlCode.ag" #-}
_hdIpp : _tlIpps
{-# LINE 2645 "dist/build/PrintOcamlCode.hs"#-}
{-# NOINLINE sem_Types_Nil #-}
sem_Types_Nil :: T_Types
sem_Types_Nil = T_Types (return st53) where
{-# NOINLINE st53 #-}
!st53 = let
v52 :: T_Types_v52
v52 = \ !(T_Types_vIn52 ) -> ( let
_lhsOpps :: PP_Docs
_lhsOpps = rule172 ()
!__result_ = T_Types_vOut52 _lhsOpps
in __result_ )
in C_Types_s53 v52
{-# INLINE rule172 #-}
{-# LINE 74 "src-ag/PrintOcamlCode.ag" #-}
rule172 = \ (_ :: ()) ->
{-# LINE 74 "src-ag/PrintOcamlCode.ag" #-}
[]
{-# LINE 2663 "dist/build/PrintOcamlCode.hs"#-}