content: {-# LANGUAGE Arrows #-}
  
  foo
      f
      g
      h
      ma =
          proc
              ( (a, b)
                  , (c, d)
                  , (e, f)
                  )
          -> do
              -- Begin do
              (x, y) <- -- GHC parser fails if layed out over multiple lines
                  f -- Call into f
                      ( a
                      , c -- Tuple together arguments
                      )
                      ( b
                      , d
                      )
                      -<
                          ( b + 1 -- Funnel into arrow
                          , d * b
                          )
              if x `mod` y == 0 -- Basic condition
                  then case e of -- Only left case is relevant
                      Left
                          ( z
                              , w
                              ) -> \u -> -- Procs can have lambdas
                              let v =
                                      u -- Actually never used
                                          ^ 2
                               in ( returnA
                                      -<
                                          -- Just do the calculation
                                          (x + y * z)
                                  )
                  else do
                      let u = x -- Let bindings bind expressions, not commands
                      -- Could pattern match directly on x
                      i <- case u of
                          0 -> (g . h -< u)
                          n ->
                              ( ( h . g
                                      -<
                                          y -- First actual use of y
                                )
                              )
                      returnA -< ()
                      -- Sometimes execute effects
                      if i > 0
                          then ma -< ()
                          else returnA -< ()
                      returnA
                          -<
                              ( i
                                  + x
                                  * y -- Just do the calculation
                              )
  
  