--ATTR Document HeliumTypeInfo [ path : {[Int]} |  pIdC : Int  | ]

--DATA Document | RootDoc IDD IDP Decls

--DATA HeliumTypeInfo | HeliumTypeInfo

--Document = 
--              | HoleDoc
--              | ParseErrDoc Node Presentation deriving Show


--type HeliumTypeInfo = ([HeliumMessage],[(String,String)], [(PathDoc, String)])


SEM EnrichedDoc
  | RootEnr idListDecls.pIdC = @lhs.pIdC + 4
            decls.pIdC = @idListDecls.pIdC
            lhs.pIdC = @decls.pIdC
  | HoleEnrichedDoc     lhs.pres = presHole @lhs.focusD "EnrichedDoc" (HoleEnrichedDocNode @self []) []
  | ParseErrEnrichedDoc lhs.pres = presParseErr @node @presentation


SEM EnrichedDoc
  | RootEnr idListDecls.path  = []
            decls.path  = []

{
type Presentation_Doc_Node_Clip = Presentation Document Node ClipDoc

presentElementXML :: FocusDoc -> Node -> [Int] -> String -> [Presentation_Doc_Node_Clip] -> Presentation_Doc_Node_Clip
presentElementXML focusD node path tag children =
  loc node $ parsing $ presentFocus focusD path $                  
    if null children
    then col [ text $ "<"++tag++"/>"]
    else col [ text  $ "<"++tag++">"
             , row [ text "  ", col children ]
             , text $ "</"++tag++">" ]      
    
presentPrimXMLBool :: Bool -> Presentation_Doc_Node_Clip
presentPrimXMLBool x = text $ "<Bool>"++show x++"<Bool/>"

presentPrimXMLInt :: Int -> Presentation_Doc_Node_Clip
presentPrimXMLInt x = text $ "<Int>"++show x++"<Int/>"

presentPrimXMLString :: String -> Presentation_Doc_Node_Clip
presentPrimXMLString x = text $ "<String>"++x++"<String>"


presentElementTree :: FocusDoc -> Node -> [Int] -> String -> [Presentation_Doc_Node_Clip] -> Presentation_Doc_Node_Clip
presentElementTree focusD node path tag children =
  loc node $ parsing $ presentFocus focusD path $                  
    if null children
    then mkTreeLeaf False $ text $ tag
    else mkTreeNode False True (text tag) children
    
presentPrimTreeBool :: Bool -> Presentation_Doc_Node_Clip
presentPrimTreeBool x =  mkTreeLeaf False $ text $ "Bool: "++show x

presentPrimTreeInt :: Int -> Presentation_Doc_Node_Clip
presentPrimTreeInt x =  mkTreeLeaf False $ text $ "Int: "++show x

presentPrimTreeString :: String -> Presentation_Doc_Node_Clip
presentPrimTreeString x =  mkTreeLeaf False $ text $ "String: "++x

--n2 = mkTreeNode False False (text "node 2" `withFontSize` 50) []
}                   


----- GENERATED PART STARTS HERE. DO NOT EDIT ON OR BEYOND THIS LINE -----

{- ------------------------------------

 generated part

------------------------------------- -}


DATA EnrichedDoc | RootEnr id:IDD idP:IDP idListDecls:List_Decl decls:List_Decl heliumTypeInfo:HeliumTypeInfo document:Document 
                 | HoleEnrichedDoc
                 | ParseErrEnrichedDoc Node presentation:Presentation_Doc_Node_Clip


DATA Decl | Decl idD:IDD idP0:IDP idP1:IDP idP2:IDP idP3:IDP expanded:Bool_ autoLayout:Bool_ ident:Ident exp:Exp 
          | BoardDecl idD:IDD idP0:IDP idP1:IDP board:Board 
          | PPPresentationDecl idD:IDD idP0:IDP idP1:IDP pPPresentation:PPPresentation 
          | InvDecl idD:IDD idP0:IDP idP1:IDP inv:Inv 
          | HoleDecl
          | ParseErrDecl Node presentation:Presentation_Doc_Node_Clip


DATA Ident | Ident idD:IDD idP0:IDP idP1:IDP string_:String_ 
           | HoleIdent
           | ParseErrIdent Node presentation:Presentation_Doc_Node_Clip


DATA Exp | PlusExp idD:IDD idP0:IDP exp1:Exp exp2:Exp 
         | TimesExp idD:IDD idP0:IDP exp1:Exp exp2:Exp 
         | DivExp idD:IDD idP0:IDP exp1:Exp exp2:Exp 
         | PowerExp idD:IDD idP0:IDP exp1:Exp exp2:Exp 
         | BoolExp idD:IDD idP0:IDP bool_:Bool_ 
         | IntExp idD:IDD idP0:IDP int_:Int_ 
         | LamExp idD:IDD idP0:IDP idP1:IDP ident:Ident exp:Exp 
         | AppExp idD:IDD exp1:Exp exp2:Exp 
         | CaseExp idD:IDD idP0:IDP idP1:IDP exp:Exp alts:List_Alt 
         | LetExp idD:IDD idP0:IDP idP1:IDP decls:List_Decl exp:Exp 
         | IdentExp idd:IDD ident:Ident 
         | IfExp idD:IDD idP0:IDP idP1:IDP idP2:IDP exp1:Exp exp2:Exp exp3:Exp 
         | ParenExp idD:IDD idP0:IDP idP1:IDP exp:Exp 
         | ListExp idD:IDD idP0:IDP idP1:IDP ids:{[IDP]} exps:List_Exp 
         | ProductExp idD:IDD idP0:IDP idP1:IDP ids:{[IDP]} exps:List_Exp 
         | HoleExp
         | ParseErrExp Node presentation:Presentation_Doc_Node_Clip


DATA Alt | Alt idD:IDD idP0:IDP idP1:IDP ident:Ident exp:Exp 
         | HoleAlt
         | ParseErrAlt Node presentation:Presentation_Doc_Node_Clip


DATA Board | Board idD:IDD r1:BoardRow r2:BoardRow r3:BoardRow r4:BoardRow r5:BoardRow r6:BoardRow r7:BoardRow r8:BoardRow 
           | HoleBoard
           | ParseErrBoard Node presentation:Presentation_Doc_Node_Clip


DATA BoardRow | BoardRow idD:IDD ca:BoardSquare cb:BoardSquare cc:BoardSquare cd:BoardSquare ce:BoardSquare cf:BoardSquare cg:BoardSquare ch:BoardSquare 
              | HoleBoardRow
              | ParseErrBoardRow Node presentation:Presentation_Doc_Node_Clip


DATA BoardSquare | Queen idD:IDD color:Bool_ 
                 | King idD:IDD color:Bool_ 
                 | Bishop idD:IDD color:Bool_ 
                 | Knight idD:IDD color:Bool_ 
                 | Rook idD:IDD color:Bool_ 
                 | Pawn idD:IDD color:Bool_ 
                 | Empty 
                 | HoleBoardSquare
                 | ParseErrBoardSquare Node presentation:Presentation_Doc_Node_Clip


DATA PPPresentation | PPPresentation idd:IDD viewType:Bool_ slides:List_Slide 
                    | HolePPPresentation
                    | ParseErrPPPresentation Node presentation:Presentation_Doc_Node_Clip


DATA Slide | Slide idd:IDD title:String_ itemList:ItemList 
           | HoleSlide
           | ParseErrSlide Node presentation:Presentation_Doc_Node_Clip


DATA ItemList | ItemList idd:IDD listType:ListType items:List_Item 
              | HoleItemList
              | ParseErrItemList Node presentation:Presentation_Doc_Node_Clip


DATA ListType | Bullet idd:IDD 
              | Number idd:IDD 
              | Alpha idd:IDD 
              | HoleListType
              | ParseErrListType Node presentation:Presentation_Doc_Node_Clip


DATA Item | StringItem idd:IDD string:String_ 
          | HeliumItem idd:IDD exp:Exp 
          | ListItem idd:IDD itemList:ItemList 
          | HoleItem
          | ParseErrItem Node presentation:Presentation_Doc_Node_Clip


DATA Inv | Inv idd:IDD doc:EitherDocView enr:View eval:String_ evalButton:EvalButton 
         | HoleInv
         | ParseErrInv Node presentation:Presentation_Doc_Node_Clip


DATA EvalButton | ReEvaluate1 idd:IDD 
                | ReEvaluate2 idd:IDD 
                | Skip idd:IDD 
                | HoleEvalButton
                | ParseErrEvalButton Node presentation:Presentation_Doc_Node_Clip


DATA EitherDocView | LeftDocView idd:IDD error:String_ 
                   | RightDocView idd:IDD doc:View 
                   | HoleEitherDocView
                   | ParseErrEitherDocView Node presentation:Presentation_Doc_Node_Clip


DATA View | ANil idd:IDD 
          | AN idd:IDD int_:Int_ 
          | AS idd:IDD string_:String_ 
          | Pr idd:IDD view1:View view2:View 
          | Ls idd:IDD view1:View view2:View 
          | Tr idd:IDD view1:View view2:View 
          | L idd:IDD view:View 
          | R idd:IDD view:View 
          | Mark idd:IDD view:View 
          | DelL idd:IDD view1:View view2:View 
          | InsL idd:IDD view1:View view2:View 
          | SndP idd:IDD bool_:Bool_ view1:View view2:View 
          | FstP idd:IDD bool_:Bool_ view1:View view2:View 
          | IfNil idd:IDD bool_:Bool_ view:View 
          | Undef idd:IDD 
          | Unit idd:IDD 
          | HoleView
          | ParseErrView Node presentation:Presentation_Doc_Node_Clip


DATA String_ | String_ idd:IDD string:String 
             | HoleString_
             | ParseErrString_ Node presentation:Presentation_Doc_Node_Clip


DATA Bool_ | Bool_ idd:IDD bool:Bool 
           | HoleBool_
           | ParseErrBool_ Node presentation:Presentation_Doc_Node_Clip


DATA Int_ | Int_ idd:IDD int:Int 
          | HoleInt_
          | ParseErrInt_ Node presentation:Presentation_Doc_Node_Clip


DATA List_Decl | List_Decl idd:IDD elts:ConsList_Decl 
               | HoleList_Decl
               | ParseErrList_Decl Node presentation:Presentation_Doc_Node_Clip


DATA ConsList_Decl | Cons_Decl head:Decl tail:ConsList_Decl 
                   | Nil_Decl 


DATA List_Alt | List_Alt idd:IDD elts:ConsList_Alt 
              | HoleList_Alt
              | ParseErrList_Alt Node presentation:Presentation_Doc_Node_Clip


DATA ConsList_Alt | Cons_Alt head:Alt tail:ConsList_Alt 
                  | Nil_Alt 


DATA List_Exp | List_Exp idd:IDD elts:ConsList_Exp 
              | HoleList_Exp
              | ParseErrList_Exp Node presentation:Presentation_Doc_Node_Clip


DATA ConsList_Exp | Cons_Exp head:Exp tail:ConsList_Exp 
                  | Nil_Exp 


DATA List_Slide | List_Slide idd:IDD elts:ConsList_Slide 
                | HoleList_Slide
                | ParseErrList_Slide Node presentation:Presentation_Doc_Node_Clip


DATA ConsList_Slide | Cons_Slide head:Slide tail:ConsList_Slide 
                    | Nil_Slide 


DATA List_Item | List_Item idd:IDD elts:ConsList_Item 
               | HoleList_Item
               | ParseErrList_Item Node presentation:Presentation_Doc_Node_Clip


DATA ConsList_Item | Cons_Item head:Item tail:ConsList_Item 
                   | Nil_Item 


SEM Decl
  | Decl expanded.pIdC = @lhs.pIdC + 4
         exp.pIdC = @ident.pIdC
         ident.pIdC = @autoLayout.pIdC
         autoLayout.pIdC = @expanded.pIdC
         lhs.pIdC = @exp.pIdC
  | BoardDecl board.pIdC = @lhs.pIdC + 2
              lhs.pIdC = @board.pIdC
  | PPPresentationDecl pPPresentation.pIdC = @lhs.pIdC + 2
                       lhs.pIdC = @pPPresentation.pIdC
  | InvDecl inv.pIdC = @lhs.pIdC + 2
            lhs.pIdC = @inv.pIdC
  | HoleDecl     lhs.pres = presHole @lhs.focusD "Decl" (HoleDeclNode @self @lhs.path) @lhs.path
  | ParseErrDecl lhs.pres = presParseErr @node @presentation


SEM Decl
  | Decl expanded.path  = @lhs.path++[0]
         autoLayout.path  = @lhs.path++[1]
         ident.path  = @lhs.path++[2]
         exp.path  = @lhs.path++[3]
  | BoardDecl board.path  = @lhs.path++[0]
  | PPPresentationDecl pPPresentation.path  = @lhs.path++[0]
  | InvDecl inv.path  = @lhs.path++[0]


SEM Ident
  | Ident string_.pIdC = @lhs.pIdC + 2
          lhs.pIdC = @string_.pIdC
  | HoleIdent     lhs.pres = presHole @lhs.focusD "Ident" (HoleIdentNode @self @lhs.path) @lhs.path
  | ParseErrIdent lhs.pres = presParseErr @node @presentation


SEM Ident
  | Ident string_.path  = @lhs.path++[0]


SEM Exp
  | PlusExp exp1.pIdC = @lhs.pIdC + 1
            exp2.pIdC = @exp1.pIdC
            lhs.pIdC = @exp2.pIdC
  | TimesExp exp1.pIdC = @lhs.pIdC + 1
             exp2.pIdC = @exp1.pIdC
             lhs.pIdC = @exp2.pIdC
  | DivExp exp1.pIdC = @lhs.pIdC + 1
           exp2.pIdC = @exp1.pIdC
           lhs.pIdC = @exp2.pIdC
  | PowerExp exp1.pIdC = @lhs.pIdC + 1
             exp2.pIdC = @exp1.pIdC
             lhs.pIdC = @exp2.pIdC
  | BoolExp bool_.pIdC = @lhs.pIdC + 1
            lhs.pIdC = @bool_.pIdC
  | IntExp int_.pIdC = @lhs.pIdC + 1
           lhs.pIdC = @int_.pIdC
  | LamExp ident.pIdC = @lhs.pIdC + 2
           exp.pIdC = @ident.pIdC
           lhs.pIdC = @exp.pIdC
  | AppExp exp1.pIdC = @lhs.pIdC + 0
           exp2.pIdC = @exp1.pIdC
           lhs.pIdC = @exp2.pIdC
  | CaseExp exp.pIdC = @lhs.pIdC + 2
            alts.pIdC = @exp.pIdC
            lhs.pIdC = @alts.pIdC
  | LetExp decls.pIdC = @lhs.pIdC + 2
           exp.pIdC = @decls.pIdC
           lhs.pIdC = @exp.pIdC
  | IdentExp ident.pIdC = @lhs.pIdC + 0
             lhs.pIdC = @ident.pIdC
  | IfExp exp1.pIdC = @lhs.pIdC + 3
          exp3.pIdC = @exp2.pIdC
          exp2.pIdC = @exp1.pIdC
          lhs.pIdC = @exp3.pIdC
  | ParenExp exp.pIdC = @lhs.pIdC + 2
             lhs.pIdC = @exp.pIdC
  | ListExp exps.pIdC = @lhs.pIdC + 3
            lhs.pIdC = @exps.pIdC
  | ProductExp exps.pIdC = @lhs.pIdC + 3
               lhs.pIdC = @exps.pIdC
  | HoleExp     lhs.pres = presHole @lhs.focusD "Exp" (HoleExpNode @self @lhs.path) @lhs.path
  | ParseErrExp lhs.pres = presParseErr @node @presentation


SEM Exp
  | PlusExp exp1.path  = @lhs.path++[0]
            exp2.path  = @lhs.path++[1]
  | TimesExp exp1.path  = @lhs.path++[0]
             exp2.path  = @lhs.path++[1]
  | DivExp exp1.path  = @lhs.path++[0]
           exp2.path  = @lhs.path++[1]
  | PowerExp exp1.path  = @lhs.path++[0]
             exp2.path  = @lhs.path++[1]
  | BoolExp bool_.path  = @lhs.path++[0]
  | IntExp int_.path  = @lhs.path++[0]
  | LamExp ident.path  = @lhs.path++[0]
           exp.path  = @lhs.path++[1]
  | AppExp exp1.path  = @lhs.path++[0]
           exp2.path  = @lhs.path++[1]
  | CaseExp exp.path  = @lhs.path++[0]
            alts.path  = @lhs.path++[1]
  | LetExp decls.path  = @lhs.path++[0]
           exp.path  = @lhs.path++[1]
  | IdentExp ident.path  = @lhs.path++[0]
  | IfExp exp1.path  = @lhs.path++[0]
          exp2.path  = @lhs.path++[1]
          exp3.path  = @lhs.path++[2]
  | ParenExp exp.path  = @lhs.path++[0]
  | ListExp exps.path  = @lhs.path++[0]
  | ProductExp exps.path  = @lhs.path++[0]


SEM Alt
  | Alt ident.pIdC = @lhs.pIdC + 2
        exp.pIdC = @ident.pIdC
        lhs.pIdC = @exp.pIdC
  | HoleAlt     lhs.pres = presHole @lhs.focusD "Alt" (HoleAltNode @self @lhs.path) @lhs.path
  | ParseErrAlt lhs.pres = presParseErr @node @presentation


SEM Alt
  | Alt ident.path  = @lhs.path++[0]
        exp.path  = @lhs.path++[1]


SEM Board
  | Board r1.pIdC = @lhs.pIdC + 0
          r8.pIdC = @r7.pIdC
          r7.pIdC = @r6.pIdC
          r6.pIdC = @r5.pIdC
          r5.pIdC = @r4.pIdC
          r4.pIdC = @r3.pIdC
          r3.pIdC = @r2.pIdC
          r2.pIdC = @r1.pIdC
          lhs.pIdC = @r8.pIdC
  | HoleBoard     lhs.pres = presHole @lhs.focusD "Board" (HoleBoardNode @self @lhs.path) @lhs.path
  | ParseErrBoard lhs.pres = presParseErr @node @presentation


SEM Board
  | Board r1.path  = @lhs.path++[0]
          r2.path  = @lhs.path++[1]
          r3.path  = @lhs.path++[2]
          r4.path  = @lhs.path++[3]
          r5.path  = @lhs.path++[4]
          r6.path  = @lhs.path++[5]
          r7.path  = @lhs.path++[6]
          r8.path  = @lhs.path++[7]


SEM BoardRow
  | BoardRow ca.pIdC = @lhs.pIdC + 0
             ch.pIdC = @cg.pIdC
             cg.pIdC = @cf.pIdC
             cf.pIdC = @ce.pIdC
             ce.pIdC = @cd.pIdC
             cd.pIdC = @cc.pIdC
             cc.pIdC = @cb.pIdC
             cb.pIdC = @ca.pIdC
             lhs.pIdC = @ch.pIdC
  | HoleBoardRow     lhs.pres = presHole @lhs.focusD "BoardRow" (HoleBoardRowNode @self @lhs.path) @lhs.path
  | ParseErrBoardRow lhs.pres = presParseErr @node @presentation


SEM BoardRow
  | BoardRow ca.path  = @lhs.path++[0]
             cb.path  = @lhs.path++[1]
             cc.path  = @lhs.path++[2]
             cd.path  = @lhs.path++[3]
             ce.path  = @lhs.path++[4]
             cf.path  = @lhs.path++[5]
             cg.path  = @lhs.path++[6]
             ch.path  = @lhs.path++[7]


SEM BoardSquare
  | Queen color.pIdC = @lhs.pIdC + 0
          lhs.pIdC = @color.pIdC
  | King color.pIdC = @lhs.pIdC + 0
         lhs.pIdC = @color.pIdC
  | Bishop color.pIdC = @lhs.pIdC + 0
           lhs.pIdC = @color.pIdC
  | Knight color.pIdC = @lhs.pIdC + 0
           lhs.pIdC = @color.pIdC
  | Rook color.pIdC = @lhs.pIdC + 0
         lhs.pIdC = @color.pIdC
  | Pawn color.pIdC = @lhs.pIdC + 0
         lhs.pIdC = @color.pIdC
  | HoleBoardSquare     lhs.pres = presHole @lhs.focusD "BoardSquare" (HoleBoardSquareNode @self @lhs.path) @lhs.path
  | ParseErrBoardSquare lhs.pres = presParseErr @node @presentation


SEM BoardSquare
  | Queen color.path  = @lhs.path++[0]
  | King color.path  = @lhs.path++[0]
  | Bishop color.path  = @lhs.path++[0]
  | Knight color.path  = @lhs.path++[0]
  | Rook color.path  = @lhs.path++[0]
  | Pawn color.path  = @lhs.path++[0]


SEM PPPresentation
  | PPPresentation viewType.pIdC = @lhs.pIdC + 0
                   slides.pIdC = @viewType.pIdC
                   lhs.pIdC = @slides.pIdC
  | HolePPPresentation     lhs.pres = presHole @lhs.focusD "PPPresentation" (HolePPPresentationNode @self @lhs.path) @lhs.path
  | ParseErrPPPresentation lhs.pres = presParseErr @node @presentation


SEM PPPresentation
  | PPPresentation viewType.path  = @lhs.path++[0]
                   slides.path  = @lhs.path++[1]


SEM Slide
  | Slide title.pIdC = @lhs.pIdC + 0
          itemList.pIdC = @title.pIdC
          lhs.pIdC = @itemList.pIdC
  | HoleSlide     lhs.pres = presHole @lhs.focusD "Slide" (HoleSlideNode @self @lhs.path) @lhs.path
  | ParseErrSlide lhs.pres = presParseErr @node @presentation


SEM Slide
  | Slide title.path  = @lhs.path++[0]
          itemList.path  = @lhs.path++[1]


SEM ItemList
  | ItemList listType.pIdC = @lhs.pIdC + 0
             items.pIdC = @listType.pIdC
             lhs.pIdC = @items.pIdC
  | HoleItemList     lhs.pres = presHole @lhs.focusD "ItemList" (HoleItemListNode @self @lhs.path) @lhs.path
  | ParseErrItemList lhs.pres = presParseErr @node @presentation


SEM ItemList
  | ItemList listType.path  = @lhs.path++[0]
             items.path  = @lhs.path++[1]


SEM ListType
  | HoleListType     lhs.pres = presHole @lhs.focusD "ListType" (HoleListTypeNode @self @lhs.path) @lhs.path
  | ParseErrListType lhs.pres = presParseErr @node @presentation


SEM Item
  | StringItem string.pIdC = @lhs.pIdC + 0
               lhs.pIdC = @string.pIdC
  | HeliumItem exp.pIdC = @lhs.pIdC + 0
               lhs.pIdC = @exp.pIdC
  | ListItem itemList.pIdC = @lhs.pIdC + 0
             lhs.pIdC = @itemList.pIdC
  | HoleItem     lhs.pres = presHole @lhs.focusD "Item" (HoleItemNode @self @lhs.path) @lhs.path
  | ParseErrItem lhs.pres = presParseErr @node @presentation


SEM Item
  | StringItem string.path  = @lhs.path++[0]
  | HeliumItem exp.path  = @lhs.path++[0]
  | ListItem itemList.path  = @lhs.path++[0]


SEM Inv
  | Inv doc.pIdC = @lhs.pIdC + 0
        evalButton.pIdC = @eval.pIdC
        eval.pIdC = @enr.pIdC
        enr.pIdC = @doc.pIdC
        lhs.pIdC = @evalButton.pIdC
  | HoleInv     lhs.pres = presHole @lhs.focusD "Inv" (HoleInvNode @self @lhs.path) @lhs.path
  | ParseErrInv lhs.pres = presParseErr @node @presentation


SEM Inv
  | Inv doc.path  = @lhs.path++[0]
        enr.path  = @lhs.path++[1]
        eval.path  = @lhs.path++[2]
        evalButton.path  = @lhs.path++[3]


SEM EvalButton
  | HoleEvalButton     lhs.pres = presHole @lhs.focusD "EvalButton" (HoleEvalButtonNode @self @lhs.path) @lhs.path
  | ParseErrEvalButton lhs.pres = presParseErr @node @presentation


SEM EitherDocView
  | LeftDocView error.pIdC = @lhs.pIdC + 0
                lhs.pIdC = @error.pIdC
  | RightDocView doc.pIdC = @lhs.pIdC + 0
                 lhs.pIdC = @doc.pIdC
  | HoleEitherDocView     lhs.pres = presHole @lhs.focusD "EitherDocView" (HoleEitherDocViewNode @self @lhs.path) @lhs.path
  | ParseErrEitherDocView lhs.pres = presParseErr @node @presentation


SEM EitherDocView
  | LeftDocView error.path  = @lhs.path++[0]
  | RightDocView doc.path  = @lhs.path++[0]


SEM View
  | AN int_.pIdC = @lhs.pIdC + 0
       lhs.pIdC = @int_.pIdC
  | AS string_.pIdC = @lhs.pIdC + 0
       lhs.pIdC = @string_.pIdC
  | Pr view1.pIdC = @lhs.pIdC + 0
       view2.pIdC = @view1.pIdC
       lhs.pIdC = @view2.pIdC
  | Ls view1.pIdC = @lhs.pIdC + 0
       view2.pIdC = @view1.pIdC
       lhs.pIdC = @view2.pIdC
  | Tr view1.pIdC = @lhs.pIdC + 0
       view2.pIdC = @view1.pIdC
       lhs.pIdC = @view2.pIdC
  | L view.pIdC = @lhs.pIdC + 0
      lhs.pIdC = @view.pIdC
  | R view.pIdC = @lhs.pIdC + 0
      lhs.pIdC = @view.pIdC
  | Mark view.pIdC = @lhs.pIdC + 0
         lhs.pIdC = @view.pIdC
  | DelL view1.pIdC = @lhs.pIdC + 0
         view2.pIdC = @view1.pIdC
         lhs.pIdC = @view2.pIdC
  | InsL view1.pIdC = @lhs.pIdC + 0
         view2.pIdC = @view1.pIdC
         lhs.pIdC = @view2.pIdC
  | SndP bool_.pIdC = @lhs.pIdC + 0
         view2.pIdC = @view1.pIdC
         view1.pIdC = @bool_.pIdC
         lhs.pIdC = @view2.pIdC
  | FstP bool_.pIdC = @lhs.pIdC + 0
         view2.pIdC = @view1.pIdC
         view1.pIdC = @bool_.pIdC
         lhs.pIdC = @view2.pIdC
  | IfNil bool_.pIdC = @lhs.pIdC + 0
          view.pIdC = @bool_.pIdC
          lhs.pIdC = @view.pIdC
  | HoleView     lhs.pres = presHole @lhs.focusD "View" (HoleViewNode @self @lhs.path) @lhs.path
  | ParseErrView lhs.pres = presParseErr @node @presentation


SEM View
  | AN int_.path  = @lhs.path++[0]
  | AS string_.path  = @lhs.path++[0]
  | Pr view1.path  = @lhs.path++[0]
       view2.path  = @lhs.path++[1]
  | Ls view1.path  = @lhs.path++[0]
       view2.path  = @lhs.path++[1]
  | Tr view1.path  = @lhs.path++[0]
       view2.path  = @lhs.path++[1]
  | L view.path  = @lhs.path++[0]
  | R view.path  = @lhs.path++[0]
  | Mark view.path  = @lhs.path++[0]
  | DelL view1.path  = @lhs.path++[0]
         view2.path  = @lhs.path++[1]
  | InsL view1.path  = @lhs.path++[0]
         view2.path  = @lhs.path++[1]
  | SndP bool_.path  = @lhs.path++[0]
         view1.path  = @lhs.path++[1]
         view2.path  = @lhs.path++[2]
  | FstP bool_.path  = @lhs.path++[0]
         view1.path  = @lhs.path++[1]
         view2.path  = @lhs.path++[2]
  | IfNil bool_.path  = @lhs.path++[0]
          view.path  = @lhs.path++[1]


SEM String_
  | HoleString_     lhs.pres = presHole @lhs.focusD "String_" (HoleString_Node @self @lhs.path) @lhs.path
  | ParseErrString_ lhs.pres = presParseErr @node @presentation


SEM Bool_
  | HoleBool_     lhs.pres = presHole @lhs.focusD "Bool_" (HoleBool_Node @self @lhs.path) @lhs.path
  | ParseErrBool_ lhs.pres = presParseErr @node @presentation


SEM Int_
  | HoleInt_     lhs.pres = presHole @lhs.focusD "Int_" (HoleInt_Node @self @lhs.path) @lhs.path
  | ParseErrInt_ lhs.pres = presParseErr @node @presentation

SEM List_Decl
  | List_Decl
      lhs.press = map ( loc (List_DeclNode @self @lhs.path) 
                      . presentFocus @lhs.focusD @lhs.path ) 
                      @elts.press
                      -- parent is reponsible for setting parsing/structural
      elts.pIdC = @lhs.pIdC + 100 -- NOT RIGHT, should be taken from document type def.
      lhs.pIdC = @elts.pIdC
      elts.path = @lhs.path
      elts.ix = 0
  | HoleList_Decl     lhs.press = []
  | ParseErrList_Decl lhs.press = [ presParseErr @node @presentation ]

SEM ConsList_Decl
  | Cons_Decl head.path  = @lhs.path++[@lhs.ix]
             tail.path = @lhs.path
                 lhs.press = @head.pres : @tail.press
                 head.pIdC = @lhs.pIdC + 30 -- NOT RIGHT, should be taken from document type def.
                 tail.pIdC = @head.pIdC
                 lhs.pIdC = @tail.pIdC
  | Nil_Decl      lhs.press = []


SEM ConsList_Decl [ ix : Int | | ]
  | Cons_Decl     tail.ix  = @lhs.ix + 1

SEM List_Alt
  | List_Alt
      lhs.press = map ( loc (List_AltNode @self @lhs.path) 
                      . presentFocus @lhs.focusD @lhs.path ) 
                      @elts.press
                      -- parent is reponsible for setting parsing/structural
      elts.pIdC = @lhs.pIdC + 100 -- NOT RIGHT, should be taken from document type def.
      lhs.pIdC = @elts.pIdC
      elts.path = @lhs.path
      elts.ix = 0
  | HoleList_Alt     lhs.press = []
  | ParseErrList_Alt lhs.press = [ presParseErr @node @presentation ]

SEM ConsList_Alt
  | Cons_Alt head.path  = @lhs.path++[@lhs.ix]
            tail.path = @lhs.path
                 lhs.press = @head.pres : @tail.press
                 head.pIdC = @lhs.pIdC + 30 -- NOT RIGHT, should be taken from document type def.
                 tail.pIdC = @head.pIdC
                 lhs.pIdC = @tail.pIdC
  | Nil_Alt      lhs.press = []


SEM ConsList_Alt [ ix : Int | | ]
  | Cons_Alt     tail.ix  = @lhs.ix + 1

SEM List_Exp
  | List_Exp
      lhs.press = map ( loc (List_ExpNode @self @lhs.path) 
                      . presentFocus @lhs.focusD @lhs.path ) 
                      @elts.press
                      -- parent is reponsible for setting parsing/structural
      elts.pIdC = @lhs.pIdC + 100 -- NOT RIGHT, should be taken from document type def.
      lhs.pIdC = @elts.pIdC
      elts.path = @lhs.path
      elts.ix = 0
  | HoleList_Exp     lhs.press = []
  | ParseErrList_Exp lhs.press = [ presParseErr @node @presentation ]

SEM ConsList_Exp
  | Cons_Exp head.path  = @lhs.path++[@lhs.ix]
            tail.path = @lhs.path
                 lhs.press = @head.pres : @tail.press
                 head.pIdC = @lhs.pIdC + 30 -- NOT RIGHT, should be taken from document type def.
                 tail.pIdC = @head.pIdC
                 lhs.pIdC = @tail.pIdC
  | Nil_Exp      lhs.press = []


SEM ConsList_Exp [ ix : Int | | ]
  | Cons_Exp     tail.ix  = @lhs.ix + 1

SEM List_Slide
  | List_Slide
      lhs.press = map ( loc (List_SlideNode @self @lhs.path) 
                      . presentFocus @lhs.focusD @lhs.path ) 
                      @elts.press
                      -- parent is reponsible for setting parsing/structural
      elts.pIdC = @lhs.pIdC + 100 -- NOT RIGHT, should be taken from document type def.
      lhs.pIdC = @elts.pIdC
      elts.path = @lhs.path
      elts.ix = 0
  | HoleList_Slide     lhs.press = []
  | ParseErrList_Slide lhs.press = [ presParseErr @node @presentation ]

SEM ConsList_Slide
  | Cons_Slide head.path  = @lhs.path++[@lhs.ix]
              tail.path = @lhs.path
                 lhs.press = @head.pres : @tail.press
                 head.pIdC = @lhs.pIdC + 30 -- NOT RIGHT, should be taken from document type def.
                 tail.pIdC = @head.pIdC
                 lhs.pIdC = @tail.pIdC
  | Nil_Slide      lhs.press = []


SEM ConsList_Slide [ ix : Int | | ]
  | Cons_Slide     tail.ix  = @lhs.ix + 1

SEM List_Item
  | List_Item
      lhs.press = map ( loc (List_ItemNode @self @lhs.path) 
                      . presentFocus @lhs.focusD @lhs.path ) 
                      @elts.press
                      -- parent is reponsible for setting parsing/structural
      elts.pIdC = @lhs.pIdC + 100 -- NOT RIGHT, should be taken from document type def.
      lhs.pIdC = @elts.pIdC
      elts.path = @lhs.path
      elts.ix = 0
  | HoleList_Item     lhs.press = []
  | ParseErrList_Item lhs.press = [ presParseErr @node @presentation ]

SEM ConsList_Item
  | Cons_Item head.path  = @lhs.path++[@lhs.ix]
             tail.path = @lhs.path
                 lhs.press = @head.pres : @tail.press
                 head.pIdC = @lhs.pIdC + 30 -- NOT RIGHT, should be taken from document type def.
                 tail.pIdC = @head.pIdC
                 lhs.pIdC = @tail.pIdC
  | Nil_Item      lhs.press = []


SEM ConsList_Item [ ix : Int | | ]
  | Cons_Item     tail.ix  = @lhs.ix + 1


ATTR  EnrichedDoc Decl Ident Exp Alt Board BoardRow BoardSquare PPPresentation Slide ItemList ListType Item Inv EvalButton EitherDocView View String_ Bool_ Int_ List_Decl ConsList_Decl List_Alt ConsList_Alt List_Exp ConsList_Exp List_Slide ConsList_Slide List_Item ConsList_Item
       [ |  pIdC : Int  | ]


ATTR  EnrichedDoc Decl Ident Exp Alt Board BoardRow BoardSquare PPPresentation Slide ItemList ListType Item Inv EvalButton EitherDocView View String_ Bool_ Int_ List_Decl ConsList_Decl List_Alt ConsList_Alt List_Exp ConsList_Exp List_Slide ConsList_Slide List_Item ConsList_Item
       [ focusD : FocusDoc | | ]


ATTR  Decl Ident Exp Alt Board BoardRow BoardSquare PPPresentation Slide ItemList ListType Item Inv EvalButton EitherDocView View String_ Bool_ Int_ List_Decl ConsList_Decl List_Alt ConsList_Alt List_Exp ConsList_Exp List_Slide ConsList_Slide List_Item ConsList_Item
       [ path : {[Int]}  | | ]


ATTR  List_Decl ConsList_Decl List_Alt ConsList_Alt List_Exp ConsList_Exp List_Slide ConsList_Slide List_Item ConsList_Item [ | | press : {[Presentation_Doc_Node_Clip]} ]


ATTR  EnrichedDoc Decl Ident Exp Alt Board BoardRow BoardSquare PPPresentation Slide ItemList ListType Item Inv EvalButton EitherDocView View String_ Bool_ Int_ [ | | pres : Presentation_Doc_Node_Clip ]


ATTR  Decl Ident Exp Alt Board BoardRow BoardSquare PPPresentation Slide ItemList ListType Item Inv EvalButton EitherDocView View String_ Bool_ Int_ [ ix : Int || ]



-- Default XML presentation

SEM Decl [ || presXML : Presentation_Doc_Node_Clip ]
  | Decl
      lhs.presXML = presentElementXML @lhs.focusD (DeclNode @self @lhs.path) @lhs.path "Decl" [ @expanded.presXML, @autoLayout.presXML, @ident.presXML, @exp.presXML ] 
  | BoardDecl
      lhs.presXML = presentElementXML @lhs.focusD (BoardDeclNode @self @lhs.path) @lhs.path "BoardDecl" [ @board.presXML ] 
  | PPPresentationDecl
      lhs.presXML = presentElementXML @lhs.focusD (PPPresentationDeclNode @self @lhs.path) @lhs.path "PPPresentationDecl" [ @pPPresentation.presXML ] 
  | InvDecl
      lhs.presXML = presentElementXML @lhs.focusD (InvDeclNode @self @lhs.path) @lhs.path "InvDecl" [ @inv.presXML ] 
  | HoleDecl     lhs.presXML = presHole @lhs.focusD "Decl" (HoleDeclNode @self @lhs.path) @lhs.path
  | ParseErrDecl lhs.presXML = presParseErr @node @presentation

SEM Ident [ || presXML : Presentation_Doc_Node_Clip ]
  | Ident
      lhs.presXML = presentElementXML @lhs.focusD (IdentNode @self @lhs.path) @lhs.path "Ident" [ @string_.presXML ] 
  | HoleIdent     lhs.presXML = presHole @lhs.focusD "Ident" (HoleIdentNode @self @lhs.path) @lhs.path
  | ParseErrIdent lhs.presXML = presParseErr @node @presentation

SEM Exp [ || presXML : Presentation_Doc_Node_Clip ]
  | PlusExp
      lhs.presXML = presentElementXML @lhs.focusD (PlusExpNode @self @lhs.path) @lhs.path "PlusExp" [ @exp1.presXML, @exp2.presXML ] 
  | TimesExp
      lhs.presXML = presentElementXML @lhs.focusD (TimesExpNode @self @lhs.path) @lhs.path "TimesExp" [ @exp1.presXML, @exp2.presXML ] 
  | DivExp
      lhs.presXML = presentElementXML @lhs.focusD (DivExpNode @self @lhs.path) @lhs.path "DivExp" [ @exp1.presXML, @exp2.presXML ] 
  | PowerExp
      lhs.presXML = presentElementXML @lhs.focusD (PowerExpNode @self @lhs.path) @lhs.path "PowerExp" [ @exp1.presXML, @exp2.presXML ] 
  | BoolExp
      lhs.presXML = presentElementXML @lhs.focusD (BoolExpNode @self @lhs.path) @lhs.path "BoolExp" [ @bool_.presXML ] 
  | IntExp
      lhs.presXML = presentElementXML @lhs.focusD (IntExpNode @self @lhs.path) @lhs.path "IntExp" [ @int_.presXML ] 
  | LamExp
      lhs.presXML = presentElementXML @lhs.focusD (LamExpNode @self @lhs.path) @lhs.path "LamExp" [ @ident.presXML, @exp.presXML ] 
  | AppExp
      lhs.presXML = presentElementXML @lhs.focusD (AppExpNode @self @lhs.path) @lhs.path "AppExp" [ @exp1.presXML, @exp2.presXML ] 
  | CaseExp
      lhs.presXML = presentElementXML @lhs.focusD (CaseExpNode @self @lhs.path) @lhs.path "CaseExp" [ @exp.presXML, @alts.presXML ] 
  | LetExp
      lhs.presXML = presentElementXML @lhs.focusD (LetExpNode @self @lhs.path) @lhs.path "LetExp" [ @decls.presXML, @exp.presXML ] 
  | IdentExp
      lhs.presXML = presentElementXML @lhs.focusD (IdentExpNode @self @lhs.path) @lhs.path "IdentExp" [ @ident.presXML ] 
  | IfExp
      lhs.presXML = presentElementXML @lhs.focusD (IfExpNode @self @lhs.path) @lhs.path "IfExp" [ @exp1.presXML, @exp2.presXML, @exp3.presXML ] 
  | ParenExp
      lhs.presXML = presentElementXML @lhs.focusD (ParenExpNode @self @lhs.path) @lhs.path "ParenExp" [ @exp.presXML ] 
  | ListExp
      lhs.presXML = presentElementXML @lhs.focusD (ListExpNode @self @lhs.path) @lhs.path "ListExp" [ @exps.presXML ] 
  | ProductExp
      lhs.presXML = presentElementXML @lhs.focusD (ProductExpNode @self @lhs.path) @lhs.path "ProductExp" [ @exps.presXML ] 
  | HoleExp     lhs.presXML = presHole @lhs.focusD "Exp" (HoleExpNode @self @lhs.path) @lhs.path
  | ParseErrExp lhs.presXML = presParseErr @node @presentation

SEM Alt [ || presXML : Presentation_Doc_Node_Clip ]
  | Alt
      lhs.presXML = presentElementXML @lhs.focusD (AltNode @self @lhs.path) @lhs.path "Alt" [ @ident.presXML, @exp.presXML ] 
  | HoleAlt     lhs.presXML = presHole @lhs.focusD "Alt" (HoleAltNode @self @lhs.path) @lhs.path
  | ParseErrAlt lhs.presXML = presParseErr @node @presentation

SEM Board [ || presXML : Presentation_Doc_Node_Clip ]
  | Board
      lhs.presXML = presentElementXML @lhs.focusD (BoardNode @self @lhs.path) @lhs.path "Board" [ @r1.presXML, @r2.presXML, @r3.presXML, @r4.presXML, @r5.presXML, @r6.presXML, @r7.presXML, @r8.presXML ] 
  | HoleBoard     lhs.presXML = presHole @lhs.focusD "Board" (HoleBoardNode @self @lhs.path) @lhs.path
  | ParseErrBoard lhs.presXML = presParseErr @node @presentation

SEM BoardRow [ || presXML : Presentation_Doc_Node_Clip ]
  | BoardRow
      lhs.presXML = presentElementXML @lhs.focusD (BoardRowNode @self @lhs.path) @lhs.path "BoardRow" [ @ca.presXML, @cb.presXML, @cc.presXML, @cd.presXML, @ce.presXML, @cf.presXML, @cg.presXML, @ch.presXML ] 
  | HoleBoardRow     lhs.presXML = presHole @lhs.focusD "BoardRow" (HoleBoardRowNode @self @lhs.path) @lhs.path
  | ParseErrBoardRow lhs.presXML = presParseErr @node @presentation

SEM BoardSquare [ || presXML : Presentation_Doc_Node_Clip ]
  | Queen
      lhs.presXML = presentElementXML @lhs.focusD (QueenNode @self @lhs.path) @lhs.path "Queen" [ @color.presXML ] 
  | King
      lhs.presXML = presentElementXML @lhs.focusD (KingNode @self @lhs.path) @lhs.path "King" [ @color.presXML ] 
  | Bishop
      lhs.presXML = presentElementXML @lhs.focusD (BishopNode @self @lhs.path) @lhs.path "Bishop" [ @color.presXML ] 
  | Knight
      lhs.presXML = presentElementXML @lhs.focusD (KnightNode @self @lhs.path) @lhs.path "Knight" [ @color.presXML ] 
  | Rook
      lhs.presXML = presentElementXML @lhs.focusD (RookNode @self @lhs.path) @lhs.path "Rook" [ @color.presXML ] 
  | Pawn
      lhs.presXML = presentElementXML @lhs.focusD (PawnNode @self @lhs.path) @lhs.path "Pawn" [ @color.presXML ] 
  | Empty
      lhs.presXML = presentElementXML @lhs.focusD (EmptyNode @self @lhs.path) @lhs.path "Empty" [  ] 
  | HoleBoardSquare     lhs.presXML = presHole @lhs.focusD "BoardSquare" (HoleBoardSquareNode @self @lhs.path) @lhs.path
  | ParseErrBoardSquare lhs.presXML = presParseErr @node @presentation

SEM PPPresentation [ || presXML : Presentation_Doc_Node_Clip ]
  | PPPresentation
      lhs.presXML = presentElementXML @lhs.focusD (PPPresentationNode @self @lhs.path) @lhs.path "PPPresentation" [ @viewType.presXML, @slides.presXML ] 
  | HolePPPresentation     lhs.presXML = presHole @lhs.focusD "PPPresentation" (HolePPPresentationNode @self @lhs.path) @lhs.path
  | ParseErrPPPresentation lhs.presXML = presParseErr @node @presentation

SEM Slide [ || presXML : Presentation_Doc_Node_Clip ]
  | Slide
      lhs.presXML = presentElementXML @lhs.focusD (SlideNode @self @lhs.path) @lhs.path "Slide" [ @title.presXML, @itemList.presXML ] 
  | HoleSlide     lhs.presXML = presHole @lhs.focusD "Slide" (HoleSlideNode @self @lhs.path) @lhs.path
  | ParseErrSlide lhs.presXML = presParseErr @node @presentation

SEM ItemList [ || presXML : Presentation_Doc_Node_Clip ]
  | ItemList
      lhs.presXML = presentElementXML @lhs.focusD (ItemListNode @self @lhs.path) @lhs.path "ItemList" [ @listType.presXML, @items.presXML ] 
  | HoleItemList     lhs.presXML = presHole @lhs.focusD "ItemList" (HoleItemListNode @self @lhs.path) @lhs.path
  | ParseErrItemList lhs.presXML = presParseErr @node @presentation

SEM ListType [ || presXML : Presentation_Doc_Node_Clip ]
  | Bullet
      lhs.presXML = presentElementXML @lhs.focusD (BulletNode @self @lhs.path) @lhs.path "Bullet" [  ] 
  | Number
      lhs.presXML = presentElementXML @lhs.focusD (NumberNode @self @lhs.path) @lhs.path "Number" [  ] 
  | Alpha
      lhs.presXML = presentElementXML @lhs.focusD (AlphaNode @self @lhs.path) @lhs.path "Alpha" [  ] 
  | HoleListType     lhs.presXML = presHole @lhs.focusD "ListType" (HoleListTypeNode @self @lhs.path) @lhs.path
  | ParseErrListType lhs.presXML = presParseErr @node @presentation

SEM Item [ || presXML : Presentation_Doc_Node_Clip ]
  | StringItem
      lhs.presXML = presentElementXML @lhs.focusD (StringItemNode @self @lhs.path) @lhs.path "StringItem" [ @string.presXML ] 
  | HeliumItem
      lhs.presXML = presentElementXML @lhs.focusD (HeliumItemNode @self @lhs.path) @lhs.path "HeliumItem" [ @exp.presXML ] 
  | ListItem
      lhs.presXML = presentElementXML @lhs.focusD (ListItemNode @self @lhs.path) @lhs.path "ListItem" [ @itemList.presXML ] 
  | HoleItem     lhs.presXML = presHole @lhs.focusD "Item" (HoleItemNode @self @lhs.path) @lhs.path
  | ParseErrItem lhs.presXML = presParseErr @node @presentation

SEM Inv [ || presXML : Presentation_Doc_Node_Clip ]
  | Inv
      lhs.presXML = presentElementXML @lhs.focusD (InvNode @self @lhs.path) @lhs.path "Inv" [ @doc.presXML, @enr.presXML, @eval.presXML, @evalButton.presXML ] 
  | HoleInv     lhs.presXML = presHole @lhs.focusD "Inv" (HoleInvNode @self @lhs.path) @lhs.path
  | ParseErrInv lhs.presXML = presParseErr @node @presentation

SEM EvalButton [ || presXML : Presentation_Doc_Node_Clip ]
  | ReEvaluate1
      lhs.presXML = presentElementXML @lhs.focusD (ReEvaluate1Node @self @lhs.path) @lhs.path "ReEvaluate1" [  ] 
  | ReEvaluate2
      lhs.presXML = presentElementXML @lhs.focusD (ReEvaluate2Node @self @lhs.path) @lhs.path "ReEvaluate2" [  ] 
  | Skip
      lhs.presXML = presentElementXML @lhs.focusD (SkipNode @self @lhs.path) @lhs.path "Skip" [  ] 
  | HoleEvalButton     lhs.presXML = presHole @lhs.focusD "EvalButton" (HoleEvalButtonNode @self @lhs.path) @lhs.path
  | ParseErrEvalButton lhs.presXML = presParseErr @node @presentation

SEM EitherDocView [ || presXML : Presentation_Doc_Node_Clip ]
  | LeftDocView
      lhs.presXML = presentElementXML @lhs.focusD (LeftDocViewNode @self @lhs.path) @lhs.path "LeftDocView" [ @error.presXML ] 
  | RightDocView
      lhs.presXML = presentElementXML @lhs.focusD (RightDocViewNode @self @lhs.path) @lhs.path "RightDocView" [ @doc.presXML ] 
  | HoleEitherDocView     lhs.presXML = presHole @lhs.focusD "EitherDocView" (HoleEitherDocViewNode @self @lhs.path) @lhs.path
  | ParseErrEitherDocView lhs.presXML = presParseErr @node @presentation

SEM View [ || presXML : Presentation_Doc_Node_Clip ]
  | ANil
      lhs.presXML = presentElementXML @lhs.focusD (ANilNode @self @lhs.path) @lhs.path "ANil" [  ] 
  | AN
      lhs.presXML = presentElementXML @lhs.focusD (ANNode @self @lhs.path) @lhs.path "AN" [ @int_.presXML ] 
  | AS
      lhs.presXML = presentElementXML @lhs.focusD (ASNode @self @lhs.path) @lhs.path "AS" [ @string_.presXML ] 
  | Pr
      lhs.presXML = presentElementXML @lhs.focusD (PrNode @self @lhs.path) @lhs.path "Pr" [ @view1.presXML, @view2.presXML ] 
  | Ls
      lhs.presXML = presentElementXML @lhs.focusD (LsNode @self @lhs.path) @lhs.path "Ls" [ @view1.presXML, @view2.presXML ] 
  | Tr
      lhs.presXML = presentElementXML @lhs.focusD (TrNode @self @lhs.path) @lhs.path "Tr" [ @view1.presXML, @view2.presXML ] 
  | L
      lhs.presXML = presentElementXML @lhs.focusD (LNode @self @lhs.path) @lhs.path "L" [ @view.presXML ] 
  | R
      lhs.presXML = presentElementXML @lhs.focusD (RNode @self @lhs.path) @lhs.path "R" [ @view.presXML ] 
  | Mark
      lhs.presXML = presentElementXML @lhs.focusD (MarkNode @self @lhs.path) @lhs.path "Mark" [ @view.presXML ] 
  | DelL
      lhs.presXML = presentElementXML @lhs.focusD (DelLNode @self @lhs.path) @lhs.path "DelL" [ @view1.presXML, @view2.presXML ] 
  | InsL
      lhs.presXML = presentElementXML @lhs.focusD (InsLNode @self @lhs.path) @lhs.path "InsL" [ @view1.presXML, @view2.presXML ] 
  | SndP
      lhs.presXML = presentElementXML @lhs.focusD (SndPNode @self @lhs.path) @lhs.path "SndP" [ @bool_.presXML, @view1.presXML, @view2.presXML ] 
  | FstP
      lhs.presXML = presentElementXML @lhs.focusD (FstPNode @self @lhs.path) @lhs.path "FstP" [ @bool_.presXML, @view1.presXML, @view2.presXML ] 
  | IfNil
      lhs.presXML = presentElementXML @lhs.focusD (IfNilNode @self @lhs.path) @lhs.path "IfNil" [ @bool_.presXML, @view.presXML ] 
  | Undef
      lhs.presXML = presentElementXML @lhs.focusD (UndefNode @self @lhs.path) @lhs.path "Undef" [  ] 
  | Unit
      lhs.presXML = presentElementXML @lhs.focusD (UnitNode @self @lhs.path) @lhs.path "Unit" [  ] 
  | HoleView     lhs.presXML = presHole @lhs.focusD "View" (HoleViewNode @self @lhs.path) @lhs.path
  | ParseErrView lhs.presXML = presParseErr @node @presentation

SEM String_ [ || presXML : Presentation_Doc_Node_Clip ]
  | String_
      lhs.presXML = presentElementXML @lhs.focusD (String_Node @self @lhs.path) @lhs.path "String_" [ presentPrimXMLString @string ] 
  | HoleString_     lhs.presXML = presHole @lhs.focusD "String_" (HoleString_Node @self @lhs.path) @lhs.path
  | ParseErrString_ lhs.presXML = presParseErr @node @presentation

SEM Bool_ [ || presXML : Presentation_Doc_Node_Clip ]
  | Bool_
      lhs.presXML = presentElementXML @lhs.focusD (Bool_Node @self @lhs.path) @lhs.path "Bool_" [ presentPrimXMLBool @bool ] 
  | HoleBool_     lhs.presXML = presHole @lhs.focusD "Bool_" (HoleBool_Node @self @lhs.path) @lhs.path
  | ParseErrBool_ lhs.presXML = presParseErr @node @presentation

SEM Int_ [ || presXML : Presentation_Doc_Node_Clip ]
  | Int_
      lhs.presXML = presentElementXML @lhs.focusD (Int_Node @self @lhs.path) @lhs.path "Int_" [ presentPrimXMLInt @int ] 
  | HoleInt_     lhs.presXML = presHole @lhs.focusD "Int_" (HoleInt_Node @self @lhs.path) @lhs.path
  | ParseErrInt_ lhs.presXML = presParseErr @node @presentation

SEM List_Decl [ || presXML : Presentation_Doc_Node_Clip ]
  | List_Decl
      lhs.presXML = loc (List_DeclNode @self @lhs.path) $ structural $ presentFocus @lhs.focusD @lhs.path $
                    col @elts.pressXML
  | ParseErrList_Decl
      lhs.presXML = loc (List_DeclNode @self @lhs.path) $ structural $ presentFocus @lhs.focusD @lhs.path $
                    presParseErr @node @presentation
  | HoleList_Decl
      lhs.presXML = loc (List_DeclNode @self @lhs.path) $ structural $ presentFocus @lhs.focusD @lhs.path $
                    presHole @lhs.focusD "List_Decl" (HoleList_DeclNode @self @lhs.path) @lhs.path

SEM ConsList_Decl [ | | pressXML : {[Presentation_Doc_Node_Clip]} ]
  | Cons_Decl     lhs.pressXML  = @head.presXML : @tail.pressXML
  | Nil_Decl      lhs.pressXML  = []

SEM List_Alt [ || presXML : Presentation_Doc_Node_Clip ]
  | List_Alt
      lhs.presXML = loc (List_AltNode @self @lhs.path) $ structural $ presentFocus @lhs.focusD @lhs.path $
                    col @elts.pressXML
  | ParseErrList_Alt
      lhs.presXML = loc (List_AltNode @self @lhs.path) $ structural $ presentFocus @lhs.focusD @lhs.path $
                    presParseErr @node @presentation
  | HoleList_Alt
      lhs.presXML = loc (List_AltNode @self @lhs.path) $ structural $ presentFocus @lhs.focusD @lhs.path $
                    presHole @lhs.focusD "List_Alt" (HoleList_AltNode @self @lhs.path) @lhs.path

SEM ConsList_Alt [ | | pressXML : {[Presentation_Doc_Node_Clip]} ]
  | Cons_Alt     lhs.pressXML  = @head.presXML : @tail.pressXML
  | Nil_Alt      lhs.pressXML  = []

SEM List_Exp [ || presXML : Presentation_Doc_Node_Clip ]
  | List_Exp
      lhs.presXML = loc (List_ExpNode @self @lhs.path) $ structural $ presentFocus @lhs.focusD @lhs.path $
                    col @elts.pressXML
  | ParseErrList_Exp
      lhs.presXML = loc (List_ExpNode @self @lhs.path) $ structural $ presentFocus @lhs.focusD @lhs.path $
                    presParseErr @node @presentation
  | HoleList_Exp
      lhs.presXML = loc (List_ExpNode @self @lhs.path) $ structural $ presentFocus @lhs.focusD @lhs.path $
                    presHole @lhs.focusD "List_Exp" (HoleList_ExpNode @self @lhs.path) @lhs.path

SEM ConsList_Exp [ | | pressXML : {[Presentation_Doc_Node_Clip]} ]
  | Cons_Exp     lhs.pressXML  = @head.presXML : @tail.pressXML
  | Nil_Exp      lhs.pressXML  = []

SEM List_Slide [ || presXML : Presentation_Doc_Node_Clip ]
  | List_Slide
      lhs.presXML = loc (List_SlideNode @self @lhs.path) $ structural $ presentFocus @lhs.focusD @lhs.path $
                    col @elts.pressXML
  | ParseErrList_Slide
      lhs.presXML = loc (List_SlideNode @self @lhs.path) $ structural $ presentFocus @lhs.focusD @lhs.path $
                    presParseErr @node @presentation
  | HoleList_Slide
      lhs.presXML = loc (List_SlideNode @self @lhs.path) $ structural $ presentFocus @lhs.focusD @lhs.path $
                    presHole @lhs.focusD "List_Slide" (HoleList_SlideNode @self @lhs.path) @lhs.path

SEM ConsList_Slide [ | | pressXML : {[Presentation_Doc_Node_Clip]} ]
  | Cons_Slide     lhs.pressXML  = @head.presXML : @tail.pressXML
  | Nil_Slide      lhs.pressXML  = []

SEM List_Item [ || presXML : Presentation_Doc_Node_Clip ]
  | List_Item
      lhs.presXML = loc (List_ItemNode @self @lhs.path) $ structural $ presentFocus @lhs.focusD @lhs.path $
                    col @elts.pressXML
  | ParseErrList_Item
      lhs.presXML = loc (List_ItemNode @self @lhs.path) $ structural $ presentFocus @lhs.focusD @lhs.path $
                    presParseErr @node @presentation
  | HoleList_Item
      lhs.presXML = loc (List_ItemNode @self @lhs.path) $ structural $ presentFocus @lhs.focusD @lhs.path $
                    presHole @lhs.focusD "List_Item" (HoleList_ItemNode @self @lhs.path) @lhs.path

SEM ConsList_Item [ | | pressXML : {[Presentation_Doc_Node_Clip]} ]
  | Cons_Item     lhs.pressXML  = @head.presXML : @tail.pressXML
  | Nil_Item      lhs.pressXML  = []




-- Default Tree presentation

SEM Decl [ || presTree : Presentation_Doc_Node_Clip ]
  | Decl
      lhs.presTree = presentElementTree @lhs.focusD (DeclNode @self @lhs.path) @lhs.path "Decl" [ @expanded.presTree, @autoLayout.presTree, @ident.presTree, @exp.presTree ] 
  | BoardDecl
      lhs.presTree = presentElementTree @lhs.focusD (BoardDeclNode @self @lhs.path) @lhs.path "BoardDecl" [ @board.presTree ] 
  | PPPresentationDecl
      lhs.presTree = presentElementTree @lhs.focusD (PPPresentationDeclNode @self @lhs.path) @lhs.path "PPPresentationDecl" [ @pPPresentation.presTree ] 
  | InvDecl
      lhs.presTree = presentElementTree @lhs.focusD (InvDeclNode @self @lhs.path) @lhs.path "InvDecl" [ @inv.presTree ] 
  | HoleDecl     lhs.presTree = presHole @lhs.focusD "Decl" (HoleDeclNode @self @lhs.path) @lhs.path
  | ParseErrDecl lhs.presTree = presParseErr @node @presentation

SEM Ident [ || presTree : Presentation_Doc_Node_Clip ]
  | Ident
      lhs.presTree = presentElementTree @lhs.focusD (IdentNode @self @lhs.path) @lhs.path "Ident" [ @string_.presTree ] 
  | HoleIdent     lhs.presTree = presHole @lhs.focusD "Ident" (HoleIdentNode @self @lhs.path) @lhs.path
  | ParseErrIdent lhs.presTree = presParseErr @node @presentation

SEM Exp [ || presTree : Presentation_Doc_Node_Clip ]
  | PlusExp
      lhs.presTree = presentElementTree @lhs.focusD (PlusExpNode @self @lhs.path) @lhs.path "PlusExp" [ @exp1.presTree, @exp2.presTree ] 
  | TimesExp
      lhs.presTree = presentElementTree @lhs.focusD (TimesExpNode @self @lhs.path) @lhs.path "TimesExp" [ @exp1.presTree, @exp2.presTree ] 
  | DivExp
      lhs.presTree = presentElementTree @lhs.focusD (DivExpNode @self @lhs.path) @lhs.path "DivExp" [ @exp1.presTree, @exp2.presTree ] 
  | PowerExp
      lhs.presTree = presentElementTree @lhs.focusD (PowerExpNode @self @lhs.path) @lhs.path "PowerExp" [ @exp1.presTree, @exp2.presTree ] 
  | BoolExp
      lhs.presTree = presentElementTree @lhs.focusD (BoolExpNode @self @lhs.path) @lhs.path "BoolExp" [ @bool_.presTree ] 
  | IntExp
      lhs.presTree = presentElementTree @lhs.focusD (IntExpNode @self @lhs.path) @lhs.path "IntExp" [ @int_.presTree ] 
  | LamExp
      lhs.presTree = presentElementTree @lhs.focusD (LamExpNode @self @lhs.path) @lhs.path "LamExp" [ @ident.presTree, @exp.presTree ] 
  | AppExp
      lhs.presTree = presentElementTree @lhs.focusD (AppExpNode @self @lhs.path) @lhs.path "AppExp" [ @exp1.presTree, @exp2.presTree ] 
  | CaseExp
      lhs.presTree = presentElementTree @lhs.focusD (CaseExpNode @self @lhs.path) @lhs.path "CaseExp" [ @exp.presTree, @alts.presTree ] 
  | LetExp
      lhs.presTree = presentElementTree @lhs.focusD (LetExpNode @self @lhs.path) @lhs.path "LetExp" [ @decls.presTree, @exp.presTree ] 
  | IdentExp
      lhs.presTree = presentElementTree @lhs.focusD (IdentExpNode @self @lhs.path) @lhs.path "IdentExp" [ @ident.presTree ] 
  | IfExp
      lhs.presTree = presentElementTree @lhs.focusD (IfExpNode @self @lhs.path) @lhs.path "IfExp" [ @exp1.presTree, @exp2.presTree, @exp3.presTree ] 
  | ParenExp
      lhs.presTree = presentElementTree @lhs.focusD (ParenExpNode @self @lhs.path) @lhs.path "ParenExp" [ @exp.presTree ] 
  | ListExp
      lhs.presTree = presentElementTree @lhs.focusD (ListExpNode @self @lhs.path) @lhs.path "ListExp" [ @exps.presTree ] 
  | ProductExp
      lhs.presTree = presentElementTree @lhs.focusD (ProductExpNode @self @lhs.path) @lhs.path "ProductExp" [ @exps.presTree ] 
  | HoleExp     lhs.presTree = presHole @lhs.focusD "Exp" (HoleExpNode @self @lhs.path) @lhs.path
  | ParseErrExp lhs.presTree = presParseErr @node @presentation

SEM Alt [ || presTree : Presentation_Doc_Node_Clip ]
  | Alt
      lhs.presTree = presentElementTree @lhs.focusD (AltNode @self @lhs.path) @lhs.path "Alt" [ @ident.presTree, @exp.presTree ] 
  | HoleAlt     lhs.presTree = presHole @lhs.focusD "Alt" (HoleAltNode @self @lhs.path) @lhs.path
  | ParseErrAlt lhs.presTree = presParseErr @node @presentation

SEM Board [ || presTree : Presentation_Doc_Node_Clip ]
  | Board
      lhs.presTree = presentElementTree @lhs.focusD (BoardNode @self @lhs.path) @lhs.path "Board" [ @r1.presTree, @r2.presTree, @r3.presTree, @r4.presTree, @r5.presTree, @r6.presTree, @r7.presTree, @r8.presTree ] 
  | HoleBoard     lhs.presTree = presHole @lhs.focusD "Board" (HoleBoardNode @self @lhs.path) @lhs.path
  | ParseErrBoard lhs.presTree = presParseErr @node @presentation

SEM BoardRow [ || presTree : Presentation_Doc_Node_Clip ]
  | BoardRow
      lhs.presTree = presentElementTree @lhs.focusD (BoardRowNode @self @lhs.path) @lhs.path "BoardRow" [ @ca.presTree, @cb.presTree, @cc.presTree, @cd.presTree, @ce.presTree, @cf.presTree, @cg.presTree, @ch.presTree ] 
  | HoleBoardRow     lhs.presTree = presHole @lhs.focusD "BoardRow" (HoleBoardRowNode @self @lhs.path) @lhs.path
  | ParseErrBoardRow lhs.presTree = presParseErr @node @presentation

SEM BoardSquare [ || presTree : Presentation_Doc_Node_Clip ]
  | Queen
      lhs.presTree = presentElementTree @lhs.focusD (QueenNode @self @lhs.path) @lhs.path "Queen" [ @color.presTree ] 
  | King
      lhs.presTree = presentElementTree @lhs.focusD (KingNode @self @lhs.path) @lhs.path "King" [ @color.presTree ] 
  | Bishop
      lhs.presTree = presentElementTree @lhs.focusD (BishopNode @self @lhs.path) @lhs.path "Bishop" [ @color.presTree ] 
  | Knight
      lhs.presTree = presentElementTree @lhs.focusD (KnightNode @self @lhs.path) @lhs.path "Knight" [ @color.presTree ] 
  | Rook
      lhs.presTree = presentElementTree @lhs.focusD (RookNode @self @lhs.path) @lhs.path "Rook" [ @color.presTree ] 
  | Pawn
      lhs.presTree = presentElementTree @lhs.focusD (PawnNode @self @lhs.path) @lhs.path "Pawn" [ @color.presTree ] 
  | Empty
      lhs.presTree = presentElementTree @lhs.focusD (EmptyNode @self @lhs.path) @lhs.path "Empty" [  ] 
  | HoleBoardSquare     lhs.presTree = presHole @lhs.focusD "BoardSquare" (HoleBoardSquareNode @self @lhs.path) @lhs.path
  | ParseErrBoardSquare lhs.presTree = presParseErr @node @presentation

SEM PPPresentation [ || presTree : Presentation_Doc_Node_Clip ]
  | PPPresentation
      lhs.presTree = presentElementTree @lhs.focusD (PPPresentationNode @self @lhs.path) @lhs.path "PPPresentation" [ @viewType.presTree, @slides.presTree ] 
  | HolePPPresentation     lhs.presTree = presHole @lhs.focusD "PPPresentation" (HolePPPresentationNode @self @lhs.path) @lhs.path
  | ParseErrPPPresentation lhs.presTree = presParseErr @node @presentation

SEM Slide [ || presTree : Presentation_Doc_Node_Clip ]
  | Slide
      lhs.presTree = presentElementTree @lhs.focusD (SlideNode @self @lhs.path) @lhs.path "Slide" [ @title.presTree, @itemList.presTree ] 
  | HoleSlide     lhs.presTree = presHole @lhs.focusD "Slide" (HoleSlideNode @self @lhs.path) @lhs.path
  | ParseErrSlide lhs.presTree = presParseErr @node @presentation

SEM ItemList [ || presTree : Presentation_Doc_Node_Clip ]
  | ItemList
      lhs.presTree = presentElementTree @lhs.focusD (ItemListNode @self @lhs.path) @lhs.path "ItemList" [ @listType.presTree, @items.presTree ] 
  | HoleItemList     lhs.presTree = presHole @lhs.focusD "ItemList" (HoleItemListNode @self @lhs.path) @lhs.path
  | ParseErrItemList lhs.presTree = presParseErr @node @presentation

SEM ListType [ || presTree : Presentation_Doc_Node_Clip ]
  | Bullet
      lhs.presTree = presentElementTree @lhs.focusD (BulletNode @self @lhs.path) @lhs.path "Bullet" [  ] 
  | Number
      lhs.presTree = presentElementTree @lhs.focusD (NumberNode @self @lhs.path) @lhs.path "Number" [  ] 
  | Alpha
      lhs.presTree = presentElementTree @lhs.focusD (AlphaNode @self @lhs.path) @lhs.path "Alpha" [  ] 
  | HoleListType     lhs.presTree = presHole @lhs.focusD "ListType" (HoleListTypeNode @self @lhs.path) @lhs.path
  | ParseErrListType lhs.presTree = presParseErr @node @presentation

SEM Item [ || presTree : Presentation_Doc_Node_Clip ]
  | StringItem
      lhs.presTree = presentElementTree @lhs.focusD (StringItemNode @self @lhs.path) @lhs.path "StringItem" [ @string.presTree ] 
  | HeliumItem
      lhs.presTree = presentElementTree @lhs.focusD (HeliumItemNode @self @lhs.path) @lhs.path "HeliumItem" [ @exp.presTree ] 
  | ListItem
      lhs.presTree = presentElementTree @lhs.focusD (ListItemNode @self @lhs.path) @lhs.path "ListItem" [ @itemList.presTree ] 
  | HoleItem     lhs.presTree = presHole @lhs.focusD "Item" (HoleItemNode @self @lhs.path) @lhs.path
  | ParseErrItem lhs.presTree = presParseErr @node @presentation

SEM Inv [ || presTree : Presentation_Doc_Node_Clip ]
  | Inv
      lhs.presTree = presentElementTree @lhs.focusD (InvNode @self @lhs.path) @lhs.path "Inv" [ @doc.presTree, @enr.presTree, @eval.presTree, @evalButton.presTree ] 
  | HoleInv     lhs.presTree = presHole @lhs.focusD "Inv" (HoleInvNode @self @lhs.path) @lhs.path
  | ParseErrInv lhs.presTree = presParseErr @node @presentation

SEM EvalButton [ || presTree : Presentation_Doc_Node_Clip ]
  | ReEvaluate1
      lhs.presTree = presentElementTree @lhs.focusD (ReEvaluate1Node @self @lhs.path) @lhs.path "ReEvaluate1" [  ] 
  | ReEvaluate2
      lhs.presTree = presentElementTree @lhs.focusD (ReEvaluate2Node @self @lhs.path) @lhs.path "ReEvaluate2" [  ] 
  | Skip
      lhs.presTree = presentElementTree @lhs.focusD (SkipNode @self @lhs.path) @lhs.path "Skip" [  ] 
  | HoleEvalButton     lhs.presTree = presHole @lhs.focusD "EvalButton" (HoleEvalButtonNode @self @lhs.path) @lhs.path
  | ParseErrEvalButton lhs.presTree = presParseErr @node @presentation

SEM EitherDocView [ || presTree : Presentation_Doc_Node_Clip ]
  | LeftDocView
      lhs.presTree = presentElementTree @lhs.focusD (LeftDocViewNode @self @lhs.path) @lhs.path "LeftDocView" [ @error.presTree ] 
  | RightDocView
      lhs.presTree = presentElementTree @lhs.focusD (RightDocViewNode @self @lhs.path) @lhs.path "RightDocView" [ @doc.presTree ] 
  | HoleEitherDocView     lhs.presTree = presHole @lhs.focusD "EitherDocView" (HoleEitherDocViewNode @self @lhs.path) @lhs.path
  | ParseErrEitherDocView lhs.presTree = presParseErr @node @presentation

SEM View [ || presTree : Presentation_Doc_Node_Clip ]
  | ANil
      lhs.presTree = presentElementTree @lhs.focusD (ANilNode @self @lhs.path) @lhs.path "ANil" [  ] 
  | AN
      lhs.presTree = presentElementTree @lhs.focusD (ANNode @self @lhs.path) @lhs.path "AN" [ @int_.presTree ] 
  | AS
      lhs.presTree = presentElementTree @lhs.focusD (ASNode @self @lhs.path) @lhs.path "AS" [ @string_.presTree ] 
  | Pr
      lhs.presTree = presentElementTree @lhs.focusD (PrNode @self @lhs.path) @lhs.path "Pr" [ @view1.presTree, @view2.presTree ] 
  | Ls
      lhs.presTree = presentElementTree @lhs.focusD (LsNode @self @lhs.path) @lhs.path "Ls" [ @view1.presTree, @view2.presTree ] 
  | Tr
      lhs.presTree = presentElementTree @lhs.focusD (TrNode @self @lhs.path) @lhs.path "Tr" [ @view1.presTree, @view2.presTree ] 
  | L
      lhs.presTree = presentElementTree @lhs.focusD (LNode @self @lhs.path) @lhs.path "L" [ @view.presTree ] 
  | R
      lhs.presTree = presentElementTree @lhs.focusD (RNode @self @lhs.path) @lhs.path "R" [ @view.presTree ] 
  | Mark
      lhs.presTree = presentElementTree @lhs.focusD (MarkNode @self @lhs.path) @lhs.path "Mark" [ @view.presTree ] 
  | DelL
      lhs.presTree = presentElementTree @lhs.focusD (DelLNode @self @lhs.path) @lhs.path "DelL" [ @view1.presTree, @view2.presTree ] 
  | InsL
      lhs.presTree = presentElementTree @lhs.focusD (InsLNode @self @lhs.path) @lhs.path "InsL" [ @view1.presTree, @view2.presTree ] 
  | SndP
      lhs.presTree = presentElementTree @lhs.focusD (SndPNode @self @lhs.path) @lhs.path "SndP" [ @bool_.presTree, @view1.presTree, @view2.presTree ] 
  | FstP
      lhs.presTree = presentElementTree @lhs.focusD (FstPNode @self @lhs.path) @lhs.path "FstP" [ @bool_.presTree, @view1.presTree, @view2.presTree ] 
  | IfNil
      lhs.presTree = presentElementTree @lhs.focusD (IfNilNode @self @lhs.path) @lhs.path "IfNil" [ @bool_.presTree, @view.presTree ] 
  | Undef
      lhs.presTree = presentElementTree @lhs.focusD (UndefNode @self @lhs.path) @lhs.path "Undef" [  ] 
  | Unit
      lhs.presTree = presentElementTree @lhs.focusD (UnitNode @self @lhs.path) @lhs.path "Unit" [  ] 
  | HoleView     lhs.presTree = presHole @lhs.focusD "View" (HoleViewNode @self @lhs.path) @lhs.path
  | ParseErrView lhs.presTree = presParseErr @node @presentation

SEM String_ [ || presTree : Presentation_Doc_Node_Clip ]
  | String_
      lhs.presTree = presentElementTree @lhs.focusD (String_Node @self @lhs.path) @lhs.path "String_" [ presentPrimTreeString @string ] 
  | HoleString_     lhs.presTree = presHole @lhs.focusD "String_" (HoleString_Node @self @lhs.path) @lhs.path
  | ParseErrString_ lhs.presTree = presParseErr @node @presentation

SEM Bool_ [ || presTree : Presentation_Doc_Node_Clip ]
  | Bool_
      lhs.presTree = presentElementTree @lhs.focusD (Bool_Node @self @lhs.path) @lhs.path "Bool_" [ presentPrimTreeBool @bool ] 
  | HoleBool_     lhs.presTree = presHole @lhs.focusD "Bool_" (HoleBool_Node @self @lhs.path) @lhs.path
  | ParseErrBool_ lhs.presTree = presParseErr @node @presentation

SEM Int_ [ || presTree : Presentation_Doc_Node_Clip ]
  | Int_
      lhs.presTree = presentElementTree @lhs.focusD (Int_Node @self @lhs.path) @lhs.path "Int_" [ presentPrimTreeInt @int ] 
  | HoleInt_     lhs.presTree = presHole @lhs.focusD "Int_" (HoleInt_Node @self @lhs.path) @lhs.path
  | ParseErrInt_ lhs.presTree = presParseErr @node @presentation

SEM List_Decl [ || presTree : Presentation_Doc_Node_Clip ]
  | List_Decl
      lhs.presTree = loc (List_DeclNode @self @lhs.path) $ structural $ presentFocus @lhs.focusD @lhs.path $
                       col @elts.pressTree
  | ParseErrList_Decl
      lhs.presTree = loc (List_DeclNode @self @lhs.path) $ structural $ presentFocus @lhs.focusD @lhs.path $
                       presParseErr @node @presentation
  | HoleList_Decl
      lhs.presTree = loc (List_DeclNode @self @lhs.path) $ structural $ presentFocus @lhs.focusD @lhs.path $
                       presHole @lhs.focusD "List_Decl" (HoleList_DeclNode @self @lhs.path) @lhs.path

SEM ConsList_Decl [ | | pressTree : {[Presentation_Doc_Node_Clip]} ]
  | Cons_Decl     lhs.pressTree  = @head.presTree : @tail.pressTree
  | Nil_Decl      lhs.pressTree  = []

SEM List_Alt [ || presTree : Presentation_Doc_Node_Clip ]
  | List_Alt
      lhs.presTree = loc (List_AltNode @self @lhs.path) $ structural $ presentFocus @lhs.focusD @lhs.path $
                       col @elts.pressTree
  | ParseErrList_Alt
      lhs.presTree = loc (List_AltNode @self @lhs.path) $ structural $ presentFocus @lhs.focusD @lhs.path $
                       presParseErr @node @presentation
  | HoleList_Alt
      lhs.presTree = loc (List_AltNode @self @lhs.path) $ structural $ presentFocus @lhs.focusD @lhs.path $
                       presHole @lhs.focusD "List_Alt" (HoleList_AltNode @self @lhs.path) @lhs.path

SEM ConsList_Alt [ | | pressTree : {[Presentation_Doc_Node_Clip]} ]
  | Cons_Alt     lhs.pressTree  = @head.presTree : @tail.pressTree
  | Nil_Alt      lhs.pressTree  = []

SEM List_Exp [ || presTree : Presentation_Doc_Node_Clip ]
  | List_Exp
      lhs.presTree = loc (List_ExpNode @self @lhs.path) $ structural $ presentFocus @lhs.focusD @lhs.path $
                       col @elts.pressTree
  | ParseErrList_Exp
      lhs.presTree = loc (List_ExpNode @self @lhs.path) $ structural $ presentFocus @lhs.focusD @lhs.path $
                       presParseErr @node @presentation
  | HoleList_Exp
      lhs.presTree = loc (List_ExpNode @self @lhs.path) $ structural $ presentFocus @lhs.focusD @lhs.path $
                       presHole @lhs.focusD "List_Exp" (HoleList_ExpNode @self @lhs.path) @lhs.path

SEM ConsList_Exp [ | | pressTree : {[Presentation_Doc_Node_Clip]} ]
  | Cons_Exp     lhs.pressTree  = @head.presTree : @tail.pressTree
  | Nil_Exp      lhs.pressTree  = []

SEM List_Slide [ || presTree : Presentation_Doc_Node_Clip ]
  | List_Slide
      lhs.presTree = loc (List_SlideNode @self @lhs.path) $ structural $ presentFocus @lhs.focusD @lhs.path $
                       col @elts.pressTree
  | ParseErrList_Slide
      lhs.presTree = loc (List_SlideNode @self @lhs.path) $ structural $ presentFocus @lhs.focusD @lhs.path $
                       presParseErr @node @presentation
  | HoleList_Slide
      lhs.presTree = loc (List_SlideNode @self @lhs.path) $ structural $ presentFocus @lhs.focusD @lhs.path $
                       presHole @lhs.focusD "List_Slide" (HoleList_SlideNode @self @lhs.path) @lhs.path

SEM ConsList_Slide [ | | pressTree : {[Presentation_Doc_Node_Clip]} ]
  | Cons_Slide     lhs.pressTree  = @head.presTree : @tail.pressTree
  | Nil_Slide      lhs.pressTree  = []

SEM List_Item [ || presTree : Presentation_Doc_Node_Clip ]
  | List_Item
      lhs.presTree = loc (List_ItemNode @self @lhs.path) $ structural $ presentFocus @lhs.focusD @lhs.path $
                       col @elts.pressTree
  | ParseErrList_Item
      lhs.presTree = loc (List_ItemNode @self @lhs.path) $ structural $ presentFocus @lhs.focusD @lhs.path $
                       presParseErr @node @presentation
  | HoleList_Item
      lhs.presTree = loc (List_ItemNode @self @lhs.path) $ structural $ presentFocus @lhs.focusD @lhs.path $
                       presHole @lhs.focusD "List_Item" (HoleList_ItemNode @self @lhs.path) @lhs.path

SEM ConsList_Item [ | | pressTree : {[Presentation_Doc_Node_Clip]} ]
  | Cons_Item     lhs.pressTree  = @head.presTree : @tail.pressTree
  | Nil_Item      lhs.pressTree  = []