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 :
codice:
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:
codice:
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ì:
codice:
data Ttype = TArrow Ttype Ttype --tipo freccia
| TVar String --tipo variabile
deriving (Eq)
e lo mostro a video ridefinendo Show in questo modo:
codice:
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?