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
                )
  
  