[Haskell] conversiione di un tipo definito da me in un IO()

[Nikopol]

Ciao,
ho scritto un progettino per l'uni e dovrei fare una piccola presentazione.
Il progetto consiste nel scrivere una funzione che inferisce il tipo a una lambda espressione.
Ai fini della presentazione, giusto per comodità, vorrei scrivere alcune funzioncine che invochino la mia funzione su delle lambda espressioni di esempio e gli aggiungano dell'output di controllo.
Ad esempio come output vorrei avere :

lambda termine: (\x f -> f (\y -> x y)(\z t -> x (t z)))
tipo inferito da ghci: (r1 -> r2) -> ((r1 -> r2) -> (r3 -> (r3 -> r1) -> r2) -> r) -> r
tipo inferito da t: (i -> j) -> ((i -> j) -> (h -> (h -> i) -> j) -> k) -> k

dove t è le mia funzione.
Ho pensato di scrivere queste funzioni di esempio in questo modo:

t13 :: IO()
t13 = do putStr "lambda termine: (\\x f -> f(\\y -> x y)(\\z t -> x (t z)))\n"
         putStr "tipo inferito da ghci: (r1 -> r2) -> ((r1 -> r2) -> (r3 -> (r3 -> r1) -> r2) -> r) -> r\n"
         putStr ("tipo inferito dal t: " ++   output di t sulla lambda espressione)

Il punto è che non so come convertire l'output di t in un IO().

t ha tipo
t:: Expr -> Ttype
dove Ttype è definito così:

data Ttype = TArrow Ttype Ttype   --tipo freccia
           | TVar String              --tipo variabile
           deriving (Eq)

e lo mostro a video ridefinendo Show in questo modo:

instance Show Ttype where
    show (TVar x)   = x
    show (TArrow x y) = printPar x ++ " -> " ++ show y

printPar :: Ttype -> String
printPar t = case t of
                        TArrow _ _ -> "(" ++ show t ++ ")"
                         _              -> show t

Sapreste dirmi se è possibile convertire il tipo Ttype in un IO() senza dover modificare il tipo di t?