proc-do-complex-out.hs

{-# 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
            )