-- UUAGC 0.9.52.1 (build/103/lib-ehc/UHC/Light/Compiler/Core/BindExtra)
module UHC.Light.Compiler.Core.BindExtract(BoundSel (..), noBoundSel, emptyBoundSel
, boundSelVal, boundSelExpr, boundSelMetaLev0, boundSelMetaLev01
, SelVal
, cbindExtractMk, cbindExtract, cboundExtract
, cbindExtractExprMk
, cbindExtractVal', cbindExtractVal, cboundExtractVal', cboundExtractVal) where

import UHC.Light.Compiler.Base.Common
import UHC.Light.Compiler.Core
import UHC.Light.Compiler.Ty
import Control.Monad.State



type StateSel = State ([SelVal],[SelVal]) ()

-- | Return the selected, the not selected, and a function taking selected merging it back with the not selected
mkSel :: Bool -> SelVal -> ([SelVal], [SelVal], [StateSel])
mkSel isSelected boundval
  | isSelected = ([boundval], []        , [modify (\(s:sel, acc) -> (sel, s       :acc))])
  | otherwise  = ([]        , [boundval], [modify (\(  sel, acc) -> (sel, boundval:acc))])









-- | Selection predicates, an algebra for CBound fixed to yield Bool
data BoundSel
  = BoundSel
      { selBind         :: Bool
      , selMeta         :: ACoreBindAspectKeyS -> Bool
      , selVal          :: ACoreBindAspectKeyS -> MetaLev -> CLbl -> Bool
      , selTy           :: ACoreBindAspectKeyS -> Bool
      , selFFE          :: Bool
      }


-- | Default selection
noBoundSel, emptyBoundSel :: BoundSel
noBoundSel
  = BoundSel
      { selBind			= False
      , selMeta			= const False
      , selVal			= \_ _ _ -> False
      , selTy			= const False
      , selFFE			= False
      }

emptyBoundSel = noBoundSel



-- | Predefined selection: Val
boundSelVal :: BoundSel
boundSelVal
  = noBoundSel
      { selVal 			= \_ _ _ -> True
      }

-- | Predefined selection: Expr occurring in either Val or Bind or FFE
boundSelExpr :: BoundSel
boundSelExpr
  = boundSelMetaLev0
      { selBind			= True
      }

-- | Predefined selection: same MetaLev (i.e. 0)
boundSelMetaLev0 :: BoundSel
boundSelMetaLev0
  = noBoundSel
      { selBind			= True
      , selVal 			= \_ mlev _ -> mlev == 0
      , selFFE 			= True
      }

-- | Predefined selection: same MetaLev (i.e. 0), + 1 higher (i.e. has signature)
boundSelMetaLev01 :: BoundSel
boundSelMetaLev01
  = boundSelMetaLev0
      { selVal 			= \_ mlev _ -> mlev <= 1
      , selTy			= const True
      }



type SelVal = CBound



-- | Extract CBounds for a binding, partitioned according to selection, returning a reconstruction function taking mapped CBounds
cbindExtractMk :: BoundSel -> CBind -> ([SelVal],[SelVal],[SelVal] -> CBind)
cbindExtractMk sel b
  = ( selvalYesL_Syn_CBind t
    , selvalNoL_Syn_CBind t
    , \yessel -> b {bindAspects_CBind_Bind = selvalInsertYes_Syn_CBind t yessel}
    )
  where t = wrap_CBind (sem_CBind b)
              (Inh_CBind
                { boundsel_Inh_CBind = sel
                })

-- | Extract CBounds for a binding, partitioned according to selection
cbindExtract :: BoundSel -> CBind -> ([SelVal],[SelVal])
cbindExtract sel b
  = (yessel,nosel)
  where (yessel,nosel,_) = cbindExtractMk sel b

-- | Extract CBounds for a bound, partitioned according to selection
cboundExtract :: BoundSel -> CBound -> ([SelVal],[SelVal])
cboundExtract sel b
  = (selvalYesL_Syn_CBound t, selvalNoL_Syn_CBound t)
  where t = wrap_CBound (sem_CBound b)
              (Inh_CBound
                { boundsel_Inh_CBound = sel
                })



-- | Extract (first) bound CExpr and reconstruction
cbindExtractExprMk :: CBind -> (CExpr, CExpr -> CBind)
cbindExtractExprMk bi
  = case bo of
      CBound_Val  {expr_CBound_Val =e} -> (e, mkbi $ \e' -> bo {expr_CBound_Val =e'})
      CBound_Bind {expr_CBound_Bind=e} -> (e, mkbi $ \e' -> bo {expr_CBound_Bind=e'})
      CBound_FFE  {expr_CBound_FFE =e} -> (e, mkbi $ \e' -> bo {expr_CBound_FFE =e'})
  where mkbi mke = \e' -> mks (mke e' : bos)
        (bo : bos, _, mks) = cbindExtractMk boundSelExpr bi



extractVal' :: (BoundSel -> b -> ([SelVal],[SelVal])) -> b -> (ACoreBindAspectKeyS,MetaLev,CExpr)
extractVal' extr b
  = (a,ml,e)
  where (CBound_Val a ml _ e:_, _) = extr boundSelVal b

extractVal :: (BoundSel -> b -> ([SelVal],[SelVal])) -> b -> CExpr
extractVal extr b
  = e
  where (_,_,e) = extractVal' extr b

cbindExtractVal' :: CBind -> (ACoreBindAspectKeyS,MetaLev,CExpr)
cbindExtractVal' = extractVal' cbindExtract

cbindExtractVal :: CBind -> CExpr
cbindExtractVal = extractVal cbindExtract

cboundExtractVal' :: CBound -> (ACoreBindAspectKeyS,MetaLev,CExpr)
cboundExtractVal' = extractVal' cboundExtract

cboundExtractVal :: CBound -> CExpr
cboundExtractVal = extractVal cboundExtract

-- CAlt --------------------------------------------------------
{-
   visit 0:
      synthesized attribute:
         boundval             : CAlt 
   alternatives:
      alternative Alt:
         child pat            : CPat 
         child expr           : CExpr 
         visit 0:
            local boundval    : _
-}
-- cata
sem_CAlt :: CAlt ->
            T_CAlt
sem_CAlt (CAlt_Alt _pat _expr) =
    (sem_CAlt_Alt (sem_CPat _pat) (sem_CExpr _expr))
-- semantic domain
type T_CAlt = ( CAlt)
sem_CAlt_Alt :: T_CPat ->
                T_CExpr ->
                T_CAlt
sem_CAlt_Alt pat_ expr_ =
    (case (expr_) of
     { ( _exprIboundval) ->
         (case (pat_) of
          { ( _patIboundval) ->
              (case (CAlt_Alt _patIboundval _exprIboundval) of
               { _boundval ->
               (case (_boundval) of
                { _lhsOboundval ->
                ( _lhsOboundval) }) }) }) })
-- CAltL -------------------------------------------------------
{-
   visit 0:
      synthesized attribute:
         boundval             : CAltL 
   alternatives:
      alternative Cons:
         child hd             : CAlt 
         child tl             : CAltL 
         visit 0:
            local boundval    : _
      alternative Nil:
         visit 0:
            local boundval    : _
-}
-- cata
sem_CAltL :: CAltL ->
             T_CAltL
sem_CAltL list =
    (Prelude.foldr sem_CAltL_Cons sem_CAltL_Nil (Prelude.map sem_CAlt list))
-- semantic domain
type T_CAltL = ( CAltL)
sem_CAltL_Cons :: T_CAlt ->
                  T_CAltL ->
                  T_CAltL
sem_CAltL_Cons hd_ tl_ =
    (case (tl_) of
     { ( _tlIboundval) ->
         (case (hd_) of
          { ( _hdIboundval) ->
              (case ((:) _hdIboundval _tlIboundval) of
               { _boundval ->
               (case (_boundval) of
                { _lhsOboundval ->
                ( _lhsOboundval) }) }) }) })
sem_CAltL_Nil :: T_CAltL
sem_CAltL_Nil =
    (case ([]) of
     { _boundval ->
     (case (_boundval) of
      { _lhsOboundval ->
      ( _lhsOboundval) }) })
-- CBind -------------------------------------------------------
{-
   visit 0:
      inherited attribute:
         boundsel             : BoundSel
      synthesized attributes:
         boundval             : CBind 
         selvalInsertYes      : [SelVal] -> [SelVal]
         selvalNoL            : [SelVal]
         selvalYesL           : [SelVal]
   alternatives:
      alternative Bind:
         child nm             : {HsName}
         child bindAspects    : CBoundL 
         visit 0:
            local boundval    : _
-}
-- cata
sem_CBind :: CBind ->
             T_CBind
sem_CBind (CBind_Bind _nm _bindAspects) =
    (sem_CBind_Bind _nm (sem_CBoundL _bindAspects))
-- semantic domain
type T_CBind = BoundSel ->
               ( CBind,([SelVal] -> [SelVal]),([SelVal]),([SelVal]))
data Inh_CBind = Inh_CBind {boundsel_Inh_CBind :: !(BoundSel)}
data Syn_CBind = Syn_CBind {boundval_Syn_CBind :: !(CBind),selvalInsertYes_Syn_CBind :: !(([SelVal] -> [SelVal])),selvalNoL_Syn_CBind :: !(([SelVal])),selvalYesL_Syn_CBind :: !(([SelVal]))}
wrap_CBind :: T_CBind ->
              Inh_CBind ->
              Syn_CBind
wrap_CBind sem (Inh_CBind _lhsIboundsel) =
    (let ( _lhsOboundval,_lhsOselvalInsertYes,_lhsOselvalNoL,_lhsOselvalYesL) = sem _lhsIboundsel
     in  (Syn_CBind _lhsOboundval _lhsOselvalInsertYes _lhsOselvalNoL _lhsOselvalYesL))
sem_CBind_Bind :: HsName ->
                  T_CBoundL ->
                  T_CBind
sem_CBind_Bind nm_ bindAspects_ =
    (\ _lhsIboundsel ->
         (case (_lhsIboundsel) of
          { _bindAspectsOboundsel ->
          (case (bindAspects_ _bindAspectsOboundsel) of
           { ( _bindAspectsIboundval,_bindAspectsIselvalInsertYesM,_bindAspectsIselvalNoL,_bindAspectsIselvalYesL) ->
               (case (CBind_Bind nm_ _bindAspectsIboundval) of
                { _boundval ->
                (case (_boundval) of
                 { _lhsOboundval ->
                 (case (\sel -> reverse $ snd $ execState (sequence_ _bindAspectsIselvalInsertYesM) (sel,[])) of
                  { _lhsOselvalInsertYes ->
                  (case (_bindAspectsIselvalNoL) of
                   { _lhsOselvalNoL ->
                   (case (_bindAspectsIselvalYesL) of
                    { _lhsOselvalYesL ->
                    ( _lhsOboundval,_lhsOselvalInsertYes,_lhsOselvalNoL,_lhsOselvalYesL) }) }) }) }) }) }) }))
-- CBindAnn ----------------------------------------------------
{-
   visit 0:
      synthesized attribute:
         boundval             : CBindAnn 
   alternatives:
      alternative Coe:
         child coe            : {()}
         visit 0:
            local boundval    : _
-}
-- cata
sem_CBindAnn :: CBindAnn ->
                T_CBindAnn
sem_CBindAnn (CBindAnn_Coe _coe) =
    (sem_CBindAnn_Coe _coe)
-- semantic domain
type T_CBindAnn = ( CBindAnn)
sem_CBindAnn_Coe :: (()) ->
                    T_CBindAnn
sem_CBindAnn_Coe coe_ =
    (case (CBindAnn_Coe coe_) of
     { _boundval ->
     (case (_boundval) of
      { _lhsOboundval ->
      ( _lhsOboundval) }) })
-- CBindAnnL ---------------------------------------------------
{-
   visit 0:
      synthesized attribute:
         boundval             : CBindAnnL 
   alternatives:
      alternative Cons:
         child hd             : CBindAnn 
         child tl             : CBindAnnL 
         visit 0:
            local boundval    : _
      alternative Nil:
         visit 0:
            local boundval    : _
-}
-- cata
sem_CBindAnnL :: CBindAnnL ->
                 T_CBindAnnL
sem_CBindAnnL list =
    (Prelude.foldr sem_CBindAnnL_Cons sem_CBindAnnL_Nil (Prelude.map sem_CBindAnn list))
-- semantic domain
type T_CBindAnnL = ( CBindAnnL)
sem_CBindAnnL_Cons :: T_CBindAnn ->
                      T_CBindAnnL ->
                      T_CBindAnnL
sem_CBindAnnL_Cons hd_ tl_ =
    (case (tl_) of
     { ( _tlIboundval) ->
         (case (hd_) of
          { ( _hdIboundval) ->
              (case ((:) _hdIboundval _tlIboundval) of
               { _boundval ->
               (case (_boundval) of
                { _lhsOboundval ->
                ( _lhsOboundval) }) }) }) })
sem_CBindAnnL_Nil :: T_CBindAnnL
sem_CBindAnnL_Nil =
    (case ([]) of
     { _boundval ->
     (case (_boundval) of
      { _lhsOboundval ->
      ( _lhsOboundval) }) })
-- CBindL ------------------------------------------------------
{-
   visit 0:
      inherited attribute:
         boundsel             : BoundSel
      synthesized attribute:
         boundval             : CBindL 
   alternatives:
      alternative Cons:
         child hd             : CBind 
         child tl             : CBindL 
         visit 0:
            local boundval    : _
      alternative Nil:
         visit 0:
            local boundval    : _
-}
-- cata
sem_CBindL :: CBindL ->
              T_CBindL
sem_CBindL list =
    (Prelude.foldr sem_CBindL_Cons sem_CBindL_Nil (Prelude.map sem_CBind list))
-- semantic domain
type T_CBindL = BoundSel ->
                ( CBindL)
sem_CBindL_Cons :: T_CBind ->
                   T_CBindL ->
                   T_CBindL
sem_CBindL_Cons hd_ tl_ =
    (\ _lhsIboundsel ->
         (case (_lhsIboundsel) of
          { _tlOboundsel ->
          (case (tl_ _tlOboundsel) of
           { ( _tlIboundval) ->
               (case (_lhsIboundsel) of
                { _hdOboundsel ->
                (case (hd_ _hdOboundsel) of
                 { ( _hdIboundval,_hdIselvalInsertYes,_hdIselvalNoL,_hdIselvalYesL) ->
                     (case ((:) _hdIboundval _tlIboundval) of
                      { _boundval ->
                      (case (_boundval) of
                       { _lhsOboundval ->
                       ( _lhsOboundval) }) }) }) }) }) }))
sem_CBindL_Nil :: T_CBindL
sem_CBindL_Nil =
    (\ _lhsIboundsel ->
         (case ([]) of
          { _boundval ->
          (case (_boundval) of
           { _lhsOboundval ->
           ( _lhsOboundval) }) }))
-- CBound ------------------------------------------------------
{-
   visit 0:
      inherited attribute:
         boundsel             : BoundSel
      synthesized attributes:
         boundval             : CBound 
         selvalInsertYesM     : [StateSel]
         selvalNoL            : [SelVal]
         selvalYesL           : [SelVal]
   alternatives:
      alternative Bind:
         child expr           : CExpr 
         visit 0:
            local boundval    : _
            local isSelected  : _
            local _tup1       : _
      alternative Val:
         child aspectKeyS     : {ACoreBindAspectKeyS}
         child mlev           : {MetaLev}
         child lbl            : {CLbl}
         child expr           : CExpr 
         visit 0:
            local boundval    : _
            local isSelected  : _
            local _tup2       : _
      alternative Ty:
         child aspectKeyS     : {ACoreBindAspectKeyS}
         child ty             : {Ty}
         visit 0:
            local boundval    : _
            local isSelected  : _
            local _tup3       : _
      alternative FFE:
         child callconv       : {FFIWay}
         child expEnt         : {ForeignEnt}
         child expr           : CExpr 
         child ty             : {Ty}
         visit 0:
            local boundval    : _
            local isSelected  : _
            local _tup4       : _
-}
-- cata
sem_CBound :: CBound ->
              T_CBound
sem_CBound (CBound_Bind _expr) =
    (sem_CBound_Bind (sem_CExpr _expr))
sem_CBound (CBound_Val _aspectKeyS _mlev _lbl _expr) =
    (sem_CBound_Val _aspectKeyS _mlev _lbl (sem_CExpr _expr))
sem_CBound (CBound_Ty _aspectKeyS _ty) =
    (sem_CBound_Ty _aspectKeyS _ty)
sem_CBound (CBound_FFE _callconv _expEnt _expr _ty) =
    (sem_CBound_FFE _callconv _expEnt (sem_CExpr _expr) _ty)
-- semantic domain
type T_CBound = BoundSel ->
                ( CBound,([StateSel]),([SelVal]),([SelVal]))
data Inh_CBound = Inh_CBound {boundsel_Inh_CBound :: !(BoundSel)}
data Syn_CBound = Syn_CBound {boundval_Syn_CBound :: !(CBound),selvalInsertYesM_Syn_CBound :: !(([StateSel])),selvalNoL_Syn_CBound :: !(([SelVal])),selvalYesL_Syn_CBound :: !(([SelVal]))}
wrap_CBound :: T_CBound ->
               Inh_CBound ->
               Syn_CBound
wrap_CBound sem (Inh_CBound _lhsIboundsel) =
    (let ( _lhsOboundval,_lhsOselvalInsertYesM,_lhsOselvalNoL,_lhsOselvalYesL) = sem _lhsIboundsel
     in  (Syn_CBound _lhsOboundval _lhsOselvalInsertYesM _lhsOselvalNoL _lhsOselvalYesL))
sem_CBound_Bind :: T_CExpr ->
                   T_CBound
sem_CBound_Bind expr_ =
    (\ _lhsIboundsel ->
         (case (expr_) of
          { ( _exprIboundval) ->
              (case (CBound_Bind _exprIboundval) of
               { _boundval ->
               (case (_boundval) of
                { _lhsOboundval ->
                (case (selBind    _lhsIboundsel) of
                 { _isSelected ->
                 (case (mkSel _isSelected _boundval) of
                  { __tup1 ->
                  (case (__tup1) of
                   { (_,_,_lhsOselvalInsertYesM) ->
                   (case (__tup1) of
                    { (_,_lhsOselvalNoL,_) ->
                    (case (__tup1) of
                     { (_lhsOselvalYesL,_,_) ->
                     ( _lhsOboundval,_lhsOselvalInsertYesM,_lhsOselvalNoL,_lhsOselvalYesL) }) }) }) }) }) }) }) }))
sem_CBound_Val :: ACoreBindAspectKeyS ->
                  MetaLev ->
                  CLbl ->
                  T_CExpr ->
                  T_CBound
sem_CBound_Val aspectKeyS_ mlev_ lbl_ expr_ =
    (\ _lhsIboundsel ->
         (case (expr_) of
          { ( _exprIboundval) ->
              (case (CBound_Val aspectKeyS_ mlev_ lbl_ _exprIboundval) of
               { _boundval ->
               (case (_boundval) of
                { _lhsOboundval ->
                (case (selVal     _lhsIboundsel aspectKeyS_ mlev_ lbl_) of
                 { _isSelected ->
                 (case (mkSel _isSelected _boundval) of
                  { __tup2 ->
                  (case (__tup2) of
                   { (_,_,_lhsOselvalInsertYesM) ->
                   (case (__tup2) of
                    { (_,_lhsOselvalNoL,_) ->
                    (case (__tup2) of
                     { (_lhsOselvalYesL,_,_) ->
                     ( _lhsOboundval,_lhsOselvalInsertYesM,_lhsOselvalNoL,_lhsOselvalYesL) }) }) }) }) }) }) }) }))
sem_CBound_Ty :: ACoreBindAspectKeyS ->
                 Ty ->
                 T_CBound
sem_CBound_Ty aspectKeyS_ ty_ =
    (\ _lhsIboundsel ->
         (case (CBound_Ty aspectKeyS_ ty_) of
          { _boundval ->
          (case (_boundval) of
           { _lhsOboundval ->
           (case (selTy      _lhsIboundsel aspectKeyS_) of
            { _isSelected ->
            (case (mkSel _isSelected _boundval) of
             { __tup3 ->
             (case (__tup3) of
              { (_,_,_lhsOselvalInsertYesM) ->
              (case (__tup3) of
               { (_,_lhsOselvalNoL,_) ->
               (case (__tup3) of
                { (_lhsOselvalYesL,_,_) ->
                ( _lhsOboundval,_lhsOselvalInsertYesM,_lhsOselvalNoL,_lhsOselvalYesL) }) }) }) }) }) }) }))
sem_CBound_FFE :: FFIWay ->
                  ForeignEnt ->
                  T_CExpr ->
                  Ty ->
                  T_CBound
sem_CBound_FFE callconv_ expEnt_ expr_ ty_ =
    (\ _lhsIboundsel ->
         (case (expr_) of
          { ( _exprIboundval) ->
              (case (CBound_FFE callconv_ expEnt_ _exprIboundval ty_) of
               { _boundval ->
               (case (_boundval) of
                { _lhsOboundval ->
                (case (selFFE     _lhsIboundsel) of
                 { _isSelected ->
                 (case (mkSel _isSelected _boundval) of
                  { __tup4 ->
                  (case (__tup4) of
                   { (_,_,_lhsOselvalInsertYesM) ->
                   (case (__tup4) of
                    { (_,_lhsOselvalNoL,_) ->
                    (case (__tup4) of
                     { (_lhsOselvalYesL,_,_) ->
                     ( _lhsOboundval,_lhsOselvalInsertYesM,_lhsOselvalNoL,_lhsOselvalYesL) }) }) }) }) }) }) }) }))
-- CBoundL -----------------------------------------------------
{-
   visit 0:
      inherited attribute:
         boundsel             : BoundSel
      synthesized attributes:
         boundval             : CBoundL 
         selvalInsertYesM     : [StateSel]
         selvalNoL            : [SelVal]
         selvalYesL           : [SelVal]
   alternatives:
      alternative Cons:
         child hd             : CBound 
         child tl             : CBoundL 
         visit 0:
            local boundval    : _
      alternative Nil:
         visit 0:
            local boundval    : _
-}
-- cata
sem_CBoundL :: CBoundL ->
               T_CBoundL
sem_CBoundL list =
    (Prelude.foldr sem_CBoundL_Cons sem_CBoundL_Nil (Prelude.map sem_CBound list))
-- semantic domain
type T_CBoundL = BoundSel ->
                 ( CBoundL,([StateSel]),([SelVal]),([SelVal]))
sem_CBoundL_Cons :: T_CBound ->
                    T_CBoundL ->
                    T_CBoundL
sem_CBoundL_Cons hd_ tl_ =
    (\ _lhsIboundsel ->
         (case (_lhsIboundsel) of
          { _tlOboundsel ->
          (case (tl_ _tlOboundsel) of
           { ( _tlIboundval,_tlIselvalInsertYesM,_tlIselvalNoL,_tlIselvalYesL) ->
               (case (_lhsIboundsel) of
                { _hdOboundsel ->
                (case (hd_ _hdOboundsel) of
                 { ( _hdIboundval,_hdIselvalInsertYesM,_hdIselvalNoL,_hdIselvalYesL) ->
                     (case ((:) _hdIboundval _tlIboundval) of
                      { _boundval ->
                      (case (_boundval) of
                       { _lhsOboundval ->
                       (case (_hdIselvalInsertYesM ++ _tlIselvalInsertYesM) of
                        { _lhsOselvalInsertYesM ->
                        (case (_hdIselvalNoL ++ _tlIselvalNoL) of
                         { _lhsOselvalNoL ->
                         (case (_hdIselvalYesL ++ _tlIselvalYesL) of
                          { _lhsOselvalYesL ->
                          ( _lhsOboundval,_lhsOselvalInsertYesM,_lhsOselvalNoL,_lhsOselvalYesL) }) }) }) }) }) }) }) }) }))
sem_CBoundL_Nil :: T_CBoundL
sem_CBoundL_Nil =
    (\ _lhsIboundsel ->
         (case ([]) of
          { _boundval ->
          (case (_boundval) of
           { _lhsOboundval ->
           (case ([]) of
            { _lhsOselvalInsertYesM ->
            (case ([]) of
             { _lhsOselvalNoL ->
             (case ([]) of
              { _lhsOselvalYesL ->
              ( _lhsOboundval,_lhsOselvalInsertYesM,_lhsOselvalNoL,_lhsOselvalYesL) }) }) }) }) }))
-- CDataCon ----------------------------------------------------
{-
   alternatives:
      alternative Con:
         child conNm          : {HsName}
         child tagNr          : {Int}
         child arity          : {Int}
-}
-- cata
sem_CDataCon :: CDataCon ->
                T_CDataCon
sem_CDataCon (CDataCon_Con _conNm _tagNr _arity) =
    (sem_CDataCon_Con _conNm _tagNr _arity)
-- semantic domain
type T_CDataCon = ( )
sem_CDataCon_Con :: HsName ->
                    Int ->
                    Int ->
                    T_CDataCon
sem_CDataCon_Con conNm_ tagNr_ arity_ =
    ( )
-- CDataConL ---------------------------------------------------
{-
   alternatives:
      alternative Cons:
         child hd             : CDataCon 
         child tl             : CDataConL 
      alternative Nil:
-}
-- cata
sem_CDataConL :: CDataConL ->
                 T_CDataConL
sem_CDataConL list =
    (Prelude.foldr sem_CDataConL_Cons sem_CDataConL_Nil (Prelude.map sem_CDataCon list))
-- semantic domain
type T_CDataConL = ( )
sem_CDataConL_Cons :: T_CDataCon ->
                      T_CDataConL ->
                      T_CDataConL
sem_CDataConL_Cons hd_ tl_ =
    ( )
sem_CDataConL_Nil :: T_CDataConL
sem_CDataConL_Nil =
    ( )
-- CDeclMeta ---------------------------------------------------
{-
   alternatives:
      alternative Data:
         child tyNm           : {HsName}
         child dataCons       : CDataConL 
-}
-- cata
sem_CDeclMeta :: CDeclMeta ->
                 T_CDeclMeta
sem_CDeclMeta (CDeclMeta_Data _tyNm _dataCons) =
    (sem_CDeclMeta_Data _tyNm (sem_CDataConL _dataCons))
-- semantic domain
type T_CDeclMeta = ( )
sem_CDeclMeta_Data :: HsName ->
                      T_CDataConL ->
                      T_CDeclMeta
sem_CDeclMeta_Data tyNm_ dataCons_ =
    ( )
-- CDeclMetaL --------------------------------------------------
{-
   alternatives:
      alternative Cons:
         child hd             : CDeclMeta 
         child tl             : CDeclMetaL 
      alternative Nil:
-}
-- cata
sem_CDeclMetaL :: CDeclMetaL ->
                  T_CDeclMetaL
sem_CDeclMetaL list =
    (Prelude.foldr sem_CDeclMetaL_Cons sem_CDeclMetaL_Nil (Prelude.map sem_CDeclMeta list))
-- semantic domain
type T_CDeclMetaL = ( )
sem_CDeclMetaL_Cons :: T_CDeclMeta ->
                       T_CDeclMetaL ->
                       T_CDeclMetaL
sem_CDeclMetaL_Cons hd_ tl_ =
    ( )
sem_CDeclMetaL_Nil :: T_CDeclMetaL
sem_CDeclMetaL_Nil =
    ( )
-- CExport -----------------------------------------------------
{-
   alternatives:
      alternative Export:
         child nm             : {HsName}
      alternative ExportData:
         child nm             : {HsName}
         child mbConNmL       : {Maybe [HsName]}
-}
-- cata
sem_CExport :: CExport ->
               T_CExport
sem_CExport (CExport_Export _nm) =
    (sem_CExport_Export _nm)
sem_CExport (CExport_ExportData _nm _mbConNmL) =
    (sem_CExport_ExportData _nm _mbConNmL)
-- semantic domain
type T_CExport = ( )
sem_CExport_Export :: HsName ->
                      T_CExport
sem_CExport_Export nm_ =
    ( )
sem_CExport_ExportData :: HsName ->
                          (Maybe [HsName]) ->
                          T_CExport
sem_CExport_ExportData nm_ mbConNmL_ =
    ( )
-- CExportL ----------------------------------------------------
{-
   alternatives:
      alternative Cons:
         child hd             : CExport 
         child tl             : CExportL 
      alternative Nil:
-}
-- cata
sem_CExportL :: CExportL ->
                T_CExportL
sem_CExportL list =
    (Prelude.foldr sem_CExportL_Cons sem_CExportL_Nil (Prelude.map sem_CExport list))
-- semantic domain
type T_CExportL = ( )
sem_CExportL_Cons :: T_CExport ->
                     T_CExportL ->
                     T_CExportL
sem_CExportL_Cons hd_ tl_ =
    ( )
sem_CExportL_Nil :: T_CExportL
sem_CExportL_Nil =
    ( )
-- CExpr -------------------------------------------------------
{-
   visit 0:
      synthesized attribute:
         boundval             : CExpr 
   alternatives:
      alternative Var:
         child ref            : {ACoreBindRef}
         visit 0:
            local boundval    : _
      alternative Int:
         child int            : {Int}
         visit 0:
            local boundval    : _
      alternative Char:
         child char           : {Char}
         visit 0:
            local boundval    : _
      alternative String:
         child str            : {String}
         visit 0:
            local boundval    : _
      alternative Integer:
         child integer        : {Integer}
         visit 0:
            local boundval    : _
      alternative Tup:
         child tag            : {CTag}
         visit 0:
            local boundval    : _
      alternative Let:
         child categ          : {CBindCateg}
         child binds          : CBindL 
         child body           : CExpr 
         visit 0:
            local boundsel    : _
            local boundval    : _
      alternative App:
         child func           : CExpr 
         child arg            : CBound 
         visit 0:
            local boundsel    : _
            local boundval    : _
      alternative Lam:
         child bind           : CBind 
         child body           : CExpr 
         visit 0:
            local boundsel    : _
            local boundval    : _
      alternative Case:
         child expr           : CExpr 
         child alts           : CAltL 
         child dflt           : CExpr 
         visit 0:
            local boundval    : _
      alternative CaseAltFail:
         child failReason     : {CaseAltFailReason}
         child errorExpr      : CExpr 
         visit 0:
            local boundval    : _
      alternative TupDel:
         child expr           : CExpr 
         child tag            : {CTag}
         child nm             : {HsName}
         child offset         : CExpr 
         visit 0:
            local boundval    : _
      alternative TupIns:
         child expr           : CExpr 
         child tag            : {CTag}
         child nm             : {HsName}
         child offset         : CExpr 
         child fldExpr        : CExpr 
         visit 0:
            local boundval    : _
      alternative TupUpd:
         child expr           : CExpr 
         child tag            : {CTag}
         child nm             : {HsName}
         child offset         : CExpr 
         child fldExpr        : CExpr 
         visit 0:
            local boundval    : _
      alternative FFI:
         child callconv       : {FFIWay}
         child safety         : {String}
         child impEnt         : {ForeignEnt}
         child ty             : {Ty}
         visit 0:
            local boundval    : _
      alternative Dbg:
         child info           : {String}
         visit 0:
            local boundval    : _
      alternative Hole:
         child uid            : {UID}
         visit 0:
            local boundval    : _
      alternative HoleLet:
         child bindsUid       : {UID}
         child body           : CExpr 
         visit 0:
            local boundval    : _
      alternative CoeArg:
         visit 0:
            local boundval    : _
      alternative ImplsApp:
         child func           : CExpr 
         child uid            : {ImplsVarId}
         visit 0:
            local boundval    : _
      alternative ImplsLam:
         child uid            : {ImplsVarId}
         child body           : CExpr 
         visit 0:
            local boundval    : _
      alternative Ann:
         child ann            : CExprAnn 
         child expr           : CExpr 
         visit 0:
            local boundval    : _
-}
-- cata
sem_CExpr :: CExpr ->
             T_CExpr
sem_CExpr (CExpr_Var _ref) =
    (sem_CExpr_Var _ref)
sem_CExpr (CExpr_Int _int) =
    (sem_CExpr_Int _int)
sem_CExpr (CExpr_Char _char) =
    (sem_CExpr_Char _char)
sem_CExpr (CExpr_String _str) =
    (sem_CExpr_String _str)
sem_CExpr (CExpr_Integer _integer) =
    (sem_CExpr_Integer _integer)
sem_CExpr (CExpr_Tup _tag) =
    (sem_CExpr_Tup _tag)
sem_CExpr (CExpr_Let _categ _binds _body) =
    (sem_CExpr_Let _categ (sem_CBindL _binds) (sem_CExpr _body))
sem_CExpr (CExpr_App _func _arg) =
    (sem_CExpr_App (sem_CExpr _func) (sem_CBound _arg))
sem_CExpr (CExpr_Lam _bind _body) =
    (sem_CExpr_Lam (sem_CBind _bind) (sem_CExpr _body))
sem_CExpr (CExpr_Case _expr _alts _dflt) =
    (sem_CExpr_Case (sem_CExpr _expr) (sem_CAltL _alts) (sem_CExpr _dflt))
sem_CExpr (CExpr_CaseAltFail _failReason _errorExpr) =
    (sem_CExpr_CaseAltFail _failReason (sem_CExpr _errorExpr))
sem_CExpr (CExpr_TupDel _expr _tag _nm _offset) =
    (sem_CExpr_TupDel (sem_CExpr _expr) _tag _nm (sem_CExpr _offset))
sem_CExpr (CExpr_TupIns _expr _tag _nm _offset _fldExpr) =
    (sem_CExpr_TupIns (sem_CExpr _expr) _tag _nm (sem_CExpr _offset) (sem_CExpr _fldExpr))
sem_CExpr (CExpr_TupUpd _expr _tag _nm _offset _fldExpr) =
    (sem_CExpr_TupUpd (sem_CExpr _expr) _tag _nm (sem_CExpr _offset) (sem_CExpr _fldExpr))
sem_CExpr (CExpr_FFI _callconv _safety _impEnt _ty) =
    (sem_CExpr_FFI _callconv _safety _impEnt _ty)
sem_CExpr (CExpr_Dbg _info) =
    (sem_CExpr_Dbg _info)
sem_CExpr (CExpr_Hole _uid) =
    (sem_CExpr_Hole _uid)
sem_CExpr (CExpr_HoleLet _bindsUid _body) =
    (sem_CExpr_HoleLet _bindsUid (sem_CExpr _body))
sem_CExpr (CExpr_CoeArg) =
    (sem_CExpr_CoeArg)
sem_CExpr (CExpr_ImplsApp _func _uid) =
    (sem_CExpr_ImplsApp (sem_CExpr _func) _uid)
sem_CExpr (CExpr_ImplsLam _uid _body) =
    (sem_CExpr_ImplsLam _uid (sem_CExpr _body))
sem_CExpr (CExpr_Ann _ann _expr) =
    (sem_CExpr_Ann (sem_CExprAnn _ann) (sem_CExpr _expr))
-- semantic domain
type T_CExpr = ( CExpr)
sem_CExpr_Var :: ACoreBindRef ->
                 T_CExpr
sem_CExpr_Var ref_ =
    (case (CExpr_Var ref_) of
     { _boundval ->
     (case (_boundval) of
      { _lhsOboundval ->
      ( _lhsOboundval) }) })
sem_CExpr_Int :: Int ->
                 T_CExpr
sem_CExpr_Int int_ =
    (case (CExpr_Int int_) of
     { _boundval ->
     (case (_boundval) of
      { _lhsOboundval ->
      ( _lhsOboundval) }) })
sem_CExpr_Char :: Char ->
                  T_CExpr
sem_CExpr_Char char_ =
    (case (CExpr_Char char_) of
     { _boundval ->
     (case (_boundval) of
      { _lhsOboundval ->
      ( _lhsOboundval) }) })
sem_CExpr_String :: String ->
                    T_CExpr
sem_CExpr_String str_ =
    (case (CExpr_String str_) of
     { _boundval ->
     (case (_boundval) of
      { _lhsOboundval ->
      ( _lhsOboundval) }) })
sem_CExpr_Integer :: Integer ->
                     T_CExpr
sem_CExpr_Integer integer_ =
    (case (CExpr_Integer integer_) of
     { _boundval ->
     (case (_boundval) of
      { _lhsOboundval ->
      ( _lhsOboundval) }) })
sem_CExpr_Tup :: CTag ->
                 T_CExpr
sem_CExpr_Tup tag_ =
    (case (CExpr_Tup tag_) of
     { _boundval ->
     (case (_boundval) of
      { _lhsOboundval ->
      ( _lhsOboundval) }) })
sem_CExpr_Let :: CBindCateg ->
                 T_CBindL ->
                 T_CExpr ->
                 T_CExpr
sem_CExpr_Let categ_ binds_ body_ =
    (case (body_) of
     { ( _bodyIboundval) ->
         (case (noBoundSel) of
          { _boundsel ->
          (case (_boundsel) of
           { _bindsOboundsel ->
           (case (binds_ _bindsOboundsel) of
            { ( _bindsIboundval) ->
                (case (CExpr_Let categ_ _bindsIboundval _bodyIboundval) of
                 { _boundval ->
                 (case (_boundval) of
                  { _lhsOboundval ->
                  ( _lhsOboundval) }) }) }) }) }) })
sem_CExpr_App :: T_CExpr ->
                 T_CBound ->
                 T_CExpr
sem_CExpr_App func_ arg_ =
    (case (noBoundSel) of
     { _boundsel ->
     (case (_boundsel) of
      { _argOboundsel ->
      (case (arg_ _argOboundsel) of
       { ( _argIboundval,_argIselvalInsertYesM,_argIselvalNoL,_argIselvalYesL) ->
           (case (func_) of
            { ( _funcIboundval) ->
                (case (CExpr_App _funcIboundval _argIboundval) of
                 { _boundval ->
                 (case (_boundval) of
                  { _lhsOboundval ->
                  ( _lhsOboundval) }) }) }) }) }) })
sem_CExpr_Lam :: T_CBind ->
                 T_CExpr ->
                 T_CExpr
sem_CExpr_Lam bind_ body_ =
    (case (body_) of
     { ( _bodyIboundval) ->
         (case (noBoundSel) of
          { _boundsel ->
          (case (_boundsel) of
           { _bindOboundsel ->
           (case (bind_ _bindOboundsel) of
            { ( _bindIboundval,_bindIselvalInsertYes,_bindIselvalNoL,_bindIselvalYesL) ->
                (case (CExpr_Lam _bindIboundval _bodyIboundval) of
                 { _boundval ->
                 (case (_boundval) of
                  { _lhsOboundval ->
                  ( _lhsOboundval) }) }) }) }) }) })
sem_CExpr_Case :: T_CExpr ->
                  T_CAltL ->
                  T_CExpr ->
                  T_CExpr
sem_CExpr_Case expr_ alts_ dflt_ =
    (case (dflt_) of
     { ( _dfltIboundval) ->
         (case (alts_) of
          { ( _altsIboundval) ->
              (case (expr_) of
               { ( _exprIboundval) ->
                   (case (CExpr_Case _exprIboundval _altsIboundval _dfltIboundval) of
                    { _boundval ->
                    (case (_boundval) of
                     { _lhsOboundval ->
                     ( _lhsOboundval) }) }) }) }) })
sem_CExpr_CaseAltFail :: CaseAltFailReason ->
                         T_CExpr ->
                         T_CExpr
sem_CExpr_CaseAltFail failReason_ errorExpr_ =
    (case (errorExpr_) of
     { ( _errorExprIboundval) ->
         (case (CExpr_CaseAltFail failReason_ _errorExprIboundval) of
          { _boundval ->
          (case (_boundval) of
           { _lhsOboundval ->
           ( _lhsOboundval) }) }) })
sem_CExpr_TupDel :: T_CExpr ->
                    CTag ->
                    HsName ->
                    T_CExpr ->
                    T_CExpr
sem_CExpr_TupDel expr_ tag_ nm_ offset_ =
    (case (offset_) of
     { ( _offsetIboundval) ->
         (case (expr_) of
          { ( _exprIboundval) ->
              (case (CExpr_TupDel _exprIboundval tag_ nm_ _offsetIboundval) of
               { _boundval ->
               (case (_boundval) of
                { _lhsOboundval ->
                ( _lhsOboundval) }) }) }) })
sem_CExpr_TupIns :: T_CExpr ->
                    CTag ->
                    HsName ->
                    T_CExpr ->
                    T_CExpr ->
                    T_CExpr
sem_CExpr_TupIns expr_ tag_ nm_ offset_ fldExpr_ =
    (case (fldExpr_) of
     { ( _fldExprIboundval) ->
         (case (offset_) of
          { ( _offsetIboundval) ->
              (case (expr_) of
               { ( _exprIboundval) ->
                   (case (CExpr_TupIns _exprIboundval tag_ nm_ _offsetIboundval _fldExprIboundval) of
                    { _boundval ->
                    (case (_boundval) of
                     { _lhsOboundval ->
                     ( _lhsOboundval) }) }) }) }) })
sem_CExpr_TupUpd :: T_CExpr ->
                    CTag ->
                    HsName ->
                    T_CExpr ->
                    T_CExpr ->
                    T_CExpr
sem_CExpr_TupUpd expr_ tag_ nm_ offset_ fldExpr_ =
    (case (fldExpr_) of
     { ( _fldExprIboundval) ->
         (case (offset_) of
          { ( _offsetIboundval) ->
              (case (expr_) of
               { ( _exprIboundval) ->
                   (case (CExpr_TupUpd _exprIboundval tag_ nm_ _offsetIboundval _fldExprIboundval) of
                    { _boundval ->
                    (case (_boundval) of
                     { _lhsOboundval ->
                     ( _lhsOboundval) }) }) }) }) })
sem_CExpr_FFI :: FFIWay ->
                 String ->
                 ForeignEnt ->
                 Ty ->
                 T_CExpr
sem_CExpr_FFI callconv_ safety_ impEnt_ ty_ =
    (case (CExpr_FFI callconv_ safety_ impEnt_ ty_) of
     { _boundval ->
     (case (_boundval) of
      { _lhsOboundval ->
      ( _lhsOboundval) }) })
sem_CExpr_Dbg :: String ->
                 T_CExpr
sem_CExpr_Dbg info_ =
    (case (CExpr_Dbg info_) of
     { _boundval ->
     (case (_boundval) of
      { _lhsOboundval ->
      ( _lhsOboundval) }) })
sem_CExpr_Hole :: UID ->
                  T_CExpr
sem_CExpr_Hole uid_ =
    (case (CExpr_Hole uid_) of
     { _boundval ->
     (case (_boundval) of
      { _lhsOboundval ->
      ( _lhsOboundval) }) })
sem_CExpr_HoleLet :: UID ->
                     T_CExpr ->
                     T_CExpr
sem_CExpr_HoleLet bindsUid_ body_ =
    (case (body_) of
     { ( _bodyIboundval) ->
         (case (CExpr_HoleLet bindsUid_ _bodyIboundval) of
          { _boundval ->
          (case (_boundval) of
           { _lhsOboundval ->
           ( _lhsOboundval) }) }) })
sem_CExpr_CoeArg :: T_CExpr
sem_CExpr_CoeArg =
    (case (CExpr_CoeArg) of
     { _boundval ->
     (case (_boundval) of
      { _lhsOboundval ->
      ( _lhsOboundval) }) })
sem_CExpr_ImplsApp :: T_CExpr ->
                      ImplsVarId ->
                      T_CExpr
sem_CExpr_ImplsApp func_ uid_ =
    (case (func_) of
     { ( _funcIboundval) ->
         (case (CExpr_ImplsApp _funcIboundval uid_) of
          { _boundval ->
          (case (_boundval) of
           { _lhsOboundval ->
           ( _lhsOboundval) }) }) })
sem_CExpr_ImplsLam :: ImplsVarId ->
                      T_CExpr ->
                      T_CExpr
sem_CExpr_ImplsLam uid_ body_ =
    (case (body_) of
     { ( _bodyIboundval) ->
         (case (CExpr_ImplsLam uid_ _bodyIboundval) of
          { _boundval ->
          (case (_boundval) of
           { _lhsOboundval ->
           ( _lhsOboundval) }) }) })
sem_CExpr_Ann :: T_CExprAnn ->
                 T_CExpr ->
                 T_CExpr
sem_CExpr_Ann ann_ expr_ =
    (case (expr_) of
     { ( _exprIboundval) ->
         (case (ann_) of
          { ( _annIboundval) ->
              (case (CExpr_Ann _annIboundval _exprIboundval) of
               { _boundval ->
               (case (_boundval) of
                { _lhsOboundval ->
                ( _lhsOboundval) }) }) }) })
-- CExprAnn ----------------------------------------------------
{-
   visit 0:
      synthesized attribute:
         boundval             : CExprAnn 
   alternatives:
      alternative Ty:
         child ty             : {Ty}
         visit 0:
            local boundval    : _
      alternative Debug:
         child info           : {String}
         visit 0:
            local boundval    : _
-}
-- cata
sem_CExprAnn :: CExprAnn ->
                T_CExprAnn
sem_CExprAnn (CExprAnn_Ty _ty) =
    (sem_CExprAnn_Ty _ty)
sem_CExprAnn (CExprAnn_Debug _info) =
    (sem_CExprAnn_Debug _info)
-- semantic domain
type T_CExprAnn = ( CExprAnn)
sem_CExprAnn_Ty :: Ty ->
                   T_CExprAnn
sem_CExprAnn_Ty ty_ =
    (case (CExprAnn_Ty ty_) of
     { _boundval ->
     (case (_boundval) of
      { _lhsOboundval ->
      ( _lhsOboundval) }) })
sem_CExprAnn_Debug :: String ->
                      T_CExprAnn
sem_CExprAnn_Debug info_ =
    (case (CExprAnn_Debug info_) of
     { _boundval ->
     (case (_boundval) of
      { _lhsOboundval ->
      ( _lhsOboundval) }) })
-- CImport -----------------------------------------------------
{-
   alternatives:
      alternative Import:
         child nm             : {HsName}
-}
-- cata
sem_CImport :: CImport ->
               T_CImport
sem_CImport (CImport_Import _nm) =
    (sem_CImport_Import _nm)
-- semantic domain
type T_CImport = ( )
sem_CImport_Import :: HsName ->
                      T_CImport
sem_CImport_Import nm_ =
    ( )
-- CImportL ----------------------------------------------------
{-
   alternatives:
      alternative Cons:
         child hd             : CImport 
         child tl             : CImportL 
      alternative Nil:
-}
-- cata
sem_CImportL :: CImportL ->
                T_CImportL
sem_CImportL list =
    (Prelude.foldr sem_CImportL_Cons sem_CImportL_Nil (Prelude.map sem_CImport list))
-- semantic domain
type T_CImportL = ( )
sem_CImportL_Cons :: T_CImport ->
                     T_CImportL ->
                     T_CImportL
sem_CImportL_Cons hd_ tl_ =
    ( )
sem_CImportL_Nil :: T_CImportL
sem_CImportL_Nil =
    ( )
-- CModule -----------------------------------------------------
{-
   alternatives:
      alternative Mod:
         child moduleNm       : {HsName}
         child exports        : CExportL 
         child imports        : CImportL 
         child declMetas      : CDeclMetaL 
         child expr           : CExpr 
-}
-- cata
sem_CModule :: CModule ->
               T_CModule
sem_CModule (CModule_Mod _moduleNm _exports _imports _declMetas _expr) =
    (sem_CModule_Mod _moduleNm (sem_CExportL _exports) (sem_CImportL _imports) (sem_CDeclMetaL _declMetas) (sem_CExpr _expr))
-- semantic domain
type T_CModule = ( )
sem_CModule_Mod :: HsName ->
                   T_CExportL ->
                   T_CImportL ->
                   T_CDeclMetaL ->
                   T_CExpr ->
                   T_CModule
sem_CModule_Mod moduleNm_ exports_ imports_ declMetas_ expr_ =
    ( )
-- CPat --------------------------------------------------------
{-
   visit 0:
      synthesized attribute:
         boundval             : CPat 
   alternatives:
      alternative Var:
         child pnm            : {HsName}
         visit 0:
            local boundval    : _
      alternative Con:
         child tag            : {CTag}
         child rest           : CPatRest 
         child binds          : CPatFldL 
         visit 0:
            local boundval    : _
      alternative Int:
         child int            : {Int}
         visit 0:
            local boundval    : _
      alternative Char:
         child char           : {Char}
         visit 0:
            local boundval    : _
      alternative BoolExpr:
         child cexpr          : {CExpr}
         visit 0:
            local boundval    : _
-}
-- cata
sem_CPat :: CPat ->
            T_CPat
sem_CPat (CPat_Var _pnm) =
    (sem_CPat_Var _pnm)
sem_CPat (CPat_Con _tag _rest _binds) =
    (sem_CPat_Con _tag (sem_CPatRest _rest) (sem_CPatFldL _binds))
sem_CPat (CPat_Int _int) =
    (sem_CPat_Int _int)
sem_CPat (CPat_Char _char) =
    (sem_CPat_Char _char)
sem_CPat (CPat_BoolExpr _cexpr) =
    (sem_CPat_BoolExpr _cexpr)
-- semantic domain
type T_CPat = ( CPat)
sem_CPat_Var :: HsName ->
                T_CPat
sem_CPat_Var pnm_ =
    (case (CPat_Var pnm_) of
     { _boundval ->
     (case (_boundval) of
      { _lhsOboundval ->
      ( _lhsOboundval) }) })
sem_CPat_Con :: CTag ->
                T_CPatRest ->
                T_CPatFldL ->
                T_CPat
sem_CPat_Con tag_ rest_ binds_ =
    (case (binds_) of
     { ( _bindsIboundval) ->
         (case (rest_) of
          { ( _restIboundval) ->
              (case (CPat_Con tag_ _restIboundval _bindsIboundval) of
               { _boundval ->
               (case (_boundval) of
                { _lhsOboundval ->
                ( _lhsOboundval) }) }) }) })
sem_CPat_Int :: Int ->
                T_CPat
sem_CPat_Int int_ =
    (case (CPat_Int int_) of
     { _boundval ->
     (case (_boundval) of
      { _lhsOboundval ->
      ( _lhsOboundval) }) })
sem_CPat_Char :: Char ->
                 T_CPat
sem_CPat_Char char_ =
    (case (CPat_Char char_) of
     { _boundval ->
     (case (_boundval) of
      { _lhsOboundval ->
      ( _lhsOboundval) }) })
sem_CPat_BoolExpr :: CExpr ->
                     T_CPat
sem_CPat_BoolExpr cexpr_ =
    (case (CPat_BoolExpr cexpr_) of
     { _boundval ->
     (case (_boundval) of
      { _lhsOboundval ->
      ( _lhsOboundval) }) })
-- CPatFld -----------------------------------------------------
{-
   visit 0:
      synthesized attribute:
         boundval             : CPatFld 
   alternatives:
      alternative Fld:
         child lbl            : {HsName}
         child offset         : CExpr 
         child bind           : CBind 
         child fldAnns        : CBindAnnL 
         visit 0:
            local boundsel    : _
            local boundval    : _
-}
-- cata
sem_CPatFld :: CPatFld ->
               T_CPatFld
sem_CPatFld (CPatFld_Fld _lbl _offset _bind _fldAnns) =
    (sem_CPatFld_Fld _lbl (sem_CExpr _offset) (sem_CBind _bind) (sem_CBindAnnL _fldAnns))
-- semantic domain
type T_CPatFld = ( CPatFld)
sem_CPatFld_Fld :: HsName ->
                   T_CExpr ->
                   T_CBind ->
                   T_CBindAnnL ->
                   T_CPatFld
sem_CPatFld_Fld lbl_ offset_ bind_ fldAnns_ =
    (case (fldAnns_) of
     { ( _fldAnnsIboundval) ->
         (case (noBoundSel) of
          { _boundsel ->
          (case (_boundsel) of
           { _bindOboundsel ->
           (case (bind_ _bindOboundsel) of
            { ( _bindIboundval,_bindIselvalInsertYes,_bindIselvalNoL,_bindIselvalYesL) ->
                (case (offset_) of
                 { ( _offsetIboundval) ->
                     (case (CPatFld_Fld lbl_ _offsetIboundval _bindIboundval _fldAnnsIboundval) of
                      { _boundval ->
                      (case (_boundval) of
                       { _lhsOboundval ->
                       ( _lhsOboundval) }) }) }) }) }) }) })
-- CPatFldL ----------------------------------------------------
{-
   visit 0:
      synthesized attribute:
         boundval             : CPatFldL 
   alternatives:
      alternative Cons:
         child hd             : CPatFld 
         child tl             : CPatFldL 
         visit 0:
            local boundval    : _
      alternative Nil:
         visit 0:
            local boundval    : _
-}
-- cata
sem_CPatFldL :: CPatFldL ->
                T_CPatFldL
sem_CPatFldL list =
    (Prelude.foldr sem_CPatFldL_Cons sem_CPatFldL_Nil (Prelude.map sem_CPatFld list))
-- semantic domain
type T_CPatFldL = ( CPatFldL)
sem_CPatFldL_Cons :: T_CPatFld ->
                     T_CPatFldL ->
                     T_CPatFldL
sem_CPatFldL_Cons hd_ tl_ =
    (case (tl_) of
     { ( _tlIboundval) ->
         (case (hd_) of
          { ( _hdIboundval) ->
              (case ((:) _hdIboundval _tlIboundval) of
               { _boundval ->
               (case (_boundval) of
                { _lhsOboundval ->
                ( _lhsOboundval) }) }) }) })
sem_CPatFldL_Nil :: T_CPatFldL
sem_CPatFldL_Nil =
    (case ([]) of
     { _boundval ->
     (case (_boundval) of
      { _lhsOboundval ->
      ( _lhsOboundval) }) })
-- CPatRest ----------------------------------------------------
{-
   visit 0:
      synthesized attribute:
         boundval             : CPatRest 
   alternatives:
      alternative Var:
         child nm             : {HsName}
         visit 0:
            local boundval    : _
      alternative Empty:
         visit 0:
            local boundval    : _
-}
-- cata
sem_CPatRest :: CPatRest ->
                T_CPatRest
sem_CPatRest (CPatRest_Var _nm) =
    (sem_CPatRest_Var _nm)
sem_CPatRest (CPatRest_Empty) =
    (sem_CPatRest_Empty)
-- semantic domain
type T_CPatRest = ( CPatRest)
sem_CPatRest_Var :: HsName ->
                    T_CPatRest
sem_CPatRest_Var nm_ =
    (case (CPatRest_Var nm_) of
     { _boundval ->
     (case (_boundval) of
      { _lhsOboundval ->
      ( _lhsOboundval) }) })
sem_CPatRest_Empty :: T_CPatRest
sem_CPatRest_Empty =
    (case (CPatRest_Empty) of
     { _boundval ->
     (case (_boundval) of
      { _lhsOboundval ->
      ( _lhsOboundval) }) })
-- CodeAGItf ---------------------------------------------------
{-
   alternatives:
      alternative AGItf:
         child module         : CModule 
-}
-- cata
sem_CodeAGItf :: CodeAGItf ->
                 T_CodeAGItf
sem_CodeAGItf (CodeAGItf_AGItf _module) =
    (sem_CodeAGItf_AGItf (sem_CModule _module))
-- semantic domain
type T_CodeAGItf = ( )
sem_CodeAGItf_AGItf :: T_CModule ->
                       T_CodeAGItf
sem_CodeAGItf_AGItf module_ =
    ( )