mtl,
        transformers,

import Control.Monad.Except (ExceptT, liftEither, runExceptT, throwError)

import Control.Monad.Trans.Class (lift)

import Text.Read

import Text.Read (readEither)

type App = ExceptT AppError (InputT IO)

main = runInputT defaultSettings go

main = do
    r <- runInputT defaultSettings . runExceptT $ go
    either (hPutStrLn stderr . ("An error occured: " ++) . show) return r

    go :: InputT IO ()

    go :: App ()

        input <- readInput "Income: " (readEither @Int)
        case input of
            Left x -> liftIO $ hPutStrLn stderr ("An error occurred: " ++ show x)
            Right x -> do
                case calculateBudget x of
                    Left e -> liftIO $ hPutStrLn stderr ("An error occured: " ++ show e)
                    Right x -> liftIO $ print x

        income <- readInput "Income: " (readEither @Int)
        budget <- calculateBudget income
        liftIO $ print budget

calculateBudget :: Int -> Either AppError (Budget "USD" '(50, 30, 20))

calculateBudget :: Int -> App (Budget "USD" '(50, 30, 20))

readInput :: String -> (String -> Either String b) -> InputT IO (Either AppError b)

readInput :: String -> (String -> Either String b) -> App b

    input <- getInputLine prompt
    case input of
        Nothing -> return $ Left Interrupted
        Just x -> return . mapLeft ReadError $ f x

    input <- lift $ getInputLine prompt
    maybe (throwError Interrupted) (liftEither . mapLeft ReadError . f) input

mkIncome :: Int -> Either AppError (PosMoney "USD")
mkIncome input = mapLeft (const NegativeIncome) $ eitherPos input >>= return . PosMoney @"USD"

mkIncome :: Int -> App (PosMoney "USD")
mkIncome input = liftEither . mapLeft (const NegativeIncome) $ eitherPos input >>= return . PosMoney @"USD"