--- parse tree ---
[ Code
    "test/typ/compiler/content-field-00.typ"
    ( line 1 , column 2 )
    (Let
       (BasicBind (Just (Identifier "test")))
       (FuncExpr
          [ NormalParam (Identifier "x") , NormalParam (Identifier "y") ]
          (Block
             (CodeBlock
                [ If
                    [ ( Equals (Ident (Identifier "x")) (Ident (Identifier "y"))
                      , Block (Content [ Text "\9989" ])
                      )
                    , ( Literal (Boolean True)
                      , Block
                          (Content
                             [ Text "\10060"
                             , Text "("
                             , Code
                                 "test/typ/compiler/content-field-00.typ"
                                 ( line 1 , column 47 )
                                 (FuncCall
                                    (Ident (Identifier "repr"))
                                    [ NormalArg (Ident (Identifier "x")) ])
                             , Space
                             , Text "/"
                             , Text "="
                             , Space
                             , Code
                                 "test/typ/compiler/content-field-00.typ"
                                 ( line 1 , column 59 )
                                 (FuncCall
                                    (Ident (Identifier "repr"))
                                    [ NormalArg (Ident (Identifier "y")) ])
                             , Text ")"
                             ])
                      )
                    ]
                ]))))
, SoftBreak
, Comment
, SoftBreak
, Code
    "test/typ/compiler/content-field-00.typ"
    ( line 4 , column 2 )
    (LetFunc
       (Identifier "compute")
       [ NormalParam (Identifier "equation")
       , SinkParam (Just (Identifier "vars"))
       ]
       (Block
          (CodeBlock
             [ Let
                 (BasicBind (Just (Identifier "vars")))
                 (FuncCall
                    (FieldAccess
                       (Ident (Identifier "named")) (Ident (Identifier "vars")))
                    [])
             , LetFunc
                 (Identifier "f")
                 [ NormalParam (Identifier "elem") ]
                 (Block
                    (CodeBlock
                       [ Let
                           (BasicBind (Just (Identifier "func")))
                           (FuncCall
                              (FieldAccess
                                 (Ident (Identifier "func")) (Ident (Identifier "elem")))
                              [])
                       , If
                           [ ( Equals (Ident (Identifier "func")) (Ident (Identifier "text"))
                             , Block
                                 (CodeBlock
                                    [ Let
                                        (BasicBind (Just (Identifier "text")))
                                        (FieldAccess
                                           (Ident (Identifier "text")) (Ident (Identifier "elem")))
                                    , If
                                        [ ( InCollection
                                              (FuncCall
                                                 (Ident (Identifier "regex"))
                                                 [ NormalArg (Literal (String "^\\d+$")) ])
                                              (Ident (Identifier "text"))
                                          , Block
                                              (CodeBlock
                                                 [ FuncCall
                                                     (Ident (Identifier "int"))
                                                     [ NormalArg (Ident (Identifier "text")) ]
                                                 ])
                                          )
                                        , ( InCollection
                                              (Ident (Identifier "text"))
                                              (Ident (Identifier "vars"))
                                          , Block
                                              (CodeBlock
                                                 [ FuncCall
                                                     (Ident (Identifier "int"))
                                                     [ NormalArg
                                                         (FuncCall
                                                            (FieldAccess
                                                               (Ident (Identifier "at"))
                                                               (Ident (Identifier "vars")))
                                                            [ NormalArg (Ident (Identifier "text"))
                                                            ])
                                                     ]
                                                 ])
                                          )
                                        , ( Literal (Boolean True)
                                          , Block
                                              (CodeBlock
                                                 [ FuncCall
                                                     (Ident (Identifier "panic"))
                                                     [ NormalArg
                                                         (Plus
                                                            (Literal
                                                               (String "unknown math variable: "))
                                                            (Ident (Identifier "text")))
                                                     ]
                                                 ])
                                          )
                                        ]
                                    ])
                             )
                           , ( Equals
                                 (Ident (Identifier "func"))
                                 (FieldAccess
                                    (Ident (Identifier "attach")) (Ident (Identifier "math")))
                             , Block
                                 (CodeBlock
                                    [ Let
                                        (BasicBind (Just (Identifier "value")))
                                        (FuncCall
                                           (Ident (Identifier "f"))
                                           [ NormalArg
                                               (FieldAccess
                                                  (Ident (Identifier "base"))
                                                  (Ident (Identifier "elem")))
                                           ])
                                    , If
                                        [ ( FuncCall
                                              (FieldAccess
                                                 (Ident (Identifier "has"))
                                                 (Ident (Identifier "elem")))
                                              [ NormalArg (Literal (String "t")) ]
                                          , Block
                                              (CodeBlock
                                                 [ Assign
                                                     (Ident (Identifier "value"))
                                                     (FuncCall
                                                        (FieldAccess
                                                           (Ident (Identifier "pow"))
                                                           (Ident (Identifier "calc")))
                                                        [ NormalArg (Ident (Identifier "value"))
                                                        , NormalArg
                                                            (FuncCall
                                                               (Ident (Identifier "f"))
                                                               [ NormalArg
                                                                   (FieldAccess
                                                                      (Ident (Identifier "t"))
                                                                      (Ident (Identifier "elem")))
                                                               ])
                                                        ])
                                                 ])
                                          )
                                        ]
                                    , Ident (Identifier "value")
                                    ])
                             )
                           , ( FuncCall
                                 (FieldAccess
                                    (Ident (Identifier "has")) (Ident (Identifier "elem")))
                                 [ NormalArg (Literal (String "children")) ]
                             , Block
                                 (CodeBlock
                                    [ FuncCall
                                        (FieldAccess
                                           (Ident (Identifier "fold"))
                                           (FuncCall
                                              (FieldAccess
                                                 (Ident (Identifier "map"))
                                                 (FuncCall
                                                    (FieldAccess
                                                       (Ident (Identifier "split"))
                                                       (FuncCall
                                                          (FieldAccess
                                                             (Ident (Identifier "filter"))
                                                             (FieldAccess
                                                                (Ident (Identifier "children"))
                                                                (Ident (Identifier "elem"))))
                                                          [ NormalArg
                                                              (FuncExpr
                                                                 [ NormalParam (Identifier "v") ]
                                                                 (Not
                                                                    (Equals
                                                                       (Ident (Identifier "v"))
                                                                       (Block
                                                                          (Content [ Space ])))))
                                                          ]))
                                                    [ BlockArg [ EnumListItem Nothing [] ] ]))
                                              [ NormalArg
                                                  (FuncExpr
                                                     [ NormalParam (Identifier "xs") ]
                                                     (FuncCall
                                                        (FieldAccess
                                                           (Ident (Identifier "fold"))
                                                           (Ident (Identifier "xs")))
                                                        [ NormalArg (Literal (Int 1))
                                                        , NormalArg
                                                            (FuncExpr
                                                               [ NormalParam (Identifier "prod")
                                                               , NormalParam (Identifier "v")
                                                               ]
                                                               (Times
                                                                  (Ident (Identifier "prod"))
                                                                  (FuncCall
                                                                     (Ident (Identifier "f"))
                                                                     [ NormalArg
                                                                         (Ident (Identifier "v"))
                                                                     ])))
                                                        ]))
                                              ]))
                                        [ NormalArg (Literal (Int 0))
                                        , NormalArg
                                            (FuncExpr
                                               [ NormalParam (Identifier "sum")
                                               , NormalParam (Identifier "v")
                                               ]
                                               (Plus
                                                  (Ident (Identifier "sum"))
                                                  (Ident (Identifier "v"))))
                                        ]
                                    ])
                             )
                           ]
                       ]))
             , Let
                 (BasicBind (Just (Identifier "result")))
                 (FuncCall
                    (Ident (Identifier "f"))
                    [ NormalArg
                        (FieldAccess
                           (Ident (Identifier "body")) (Ident (Identifier "equation")))
                    ])
             , Block (Content [ Text "With" , Space ])
             , FuncCall
                 (FieldAccess
                    (Ident (Identifier "join"))
                    (FuncCall
                       (FieldAccess
                          (Ident (Identifier "map"))
                          (FuncCall
                             (FieldAccess
                                (Ident (Identifier "pairs")) (Ident (Identifier "vars")))
                             []))
                       [ NormalArg
                           (FuncExpr
                              [ NormalParam (Identifier "p") ]
                              (Block
                                 (Content
                                    [ Equation
                                        False
                                        [ Code
                                            "test/typ/compiler/content-field-00.typ"
                                            ( line 36 , column 17 )
                                            (FuncCall
                                               (FieldAccess
                                                  (Ident (Identifier "first"))
                                                  (Ident (Identifier "p")))
                                               [])
                                        , Text "="
                                        , Code
                                            "test/typ/compiler/content-field-00.typ"
                                            ( line 36 , column 30 )
                                            (FuncCall
                                               (FieldAccess
                                                  (Ident (Identifier "last"))
                                                  (Ident (Identifier "p")))
                                               [])
                                        ]
                                    ])))
                       ]))
                 [ NormalArg (Literal (String ", "))
                 , KeyValArg (Identifier "last") (Literal (String " and "))
                 ]
             , Block
                 (Content [ Space , Text "we" , Space , Text "have" , Text ":" ])
             , Block
                 (Content
                    [ Equation
                        True
                        [ Code
                            "test/typ/compiler/content-field-00.typ"
                            ( line 39 , column 5 )
                            (Ident (Identifier "equation"))
                        , Text "="
                        , Code
                            "test/typ/compiler/content-field-00.typ"
                            ( line 39 , column 16 )
                            (Ident (Identifier "result"))
                        ]
                    ])
             ])))
, ParBreak
, Code
    "test/typ/compiler/content-field-00.typ"
    ( line 42 , column 2 )
    (FuncCall
       (Ident (Identifier "compute"))
       [ NormalArg
           (Block
              (Content
                 [ Equation
                     False
                     [ Text "x"
                     , Text "y"
                     , Text "+"
                     , MAttach Nothing (Just (Text "2")) (Text "y")
                     ]
                 ]))
       , KeyValArg (Identifier "x") (Literal (Int 2))
       , KeyValArg (Identifier "y") (Literal (Int 3))
       ])
, ParBreak
]
"test/typ/compiler/content-field-00.typ" (line 42, column 2):
unexpected end of input
expecting end of input
panicked with: "unknown math variable: +"