import BasicTypes ( IPName )
import TyCon ( TyCon, KindCon, mkFunTyCon, mkKindCon, mkSuperKindCon )
import Class ( Class )
+import Binary
-- others
import PrelNames ( superKindName, superBoxityName, liftedConName,
newtype application as a SourceType; instead as a TyConApp.
+NOTE: currently [March 02] we regard a newtype as 'recursive' if it's in a
+mutually recursive group. That's a bit conservative: only if there's a loop
+consisting only of newtypes do we need consider it as recursive. But it's
+not so easy to discover that, and the situation isn't that common.
+
+
%************************************************************************
%* *
\subsection{The data type}
| SynNote Type -- Used for type synonyms
-- The Type is always a TyConApp, and is the un-expanded form.
-- The type to which the note is attached is the expanded form.
+
\end{code}
-------------------------------------
\begin{code}
liftedBoxity, unliftedBoxity :: Kind -- :: BX
-liftedBoxity = TyConApp (mkKindCon liftedConName superBoxity) []
+liftedBoxity = TyConApp liftedBoxityCon []
+unliftedBoxity = TyConApp unliftedBoxityCon []
-unliftedBoxity = TyConApp (mkKindCon unliftedConName superBoxity) []
+liftedBoxityCon = mkKindCon liftedConName superBoxity
+unliftedBoxityCon = mkKindCon unliftedConName superBoxity
\end{code}
------------------------------------------
mkArrowKinds arg_kinds result_kind = foldr mkArrowKind result_kind arg_kinds
\end{code}
+-----------------------------------------------------------------------------
+Binary kinds for interface files
+
+\begin{code}
+instance Binary Kind where
+ put_ bh k@(TyConApp tc [])
+ | tc == openKindCon = putByte bh 0
+ | tc == usageKindCon = putByte bh 1
+ put_ bh k@(TyConApp tc [TyConApp bc _])
+ | tc == typeCon && bc == liftedBoxityCon = putByte bh 2
+ | tc == typeCon && bc == unliftedBoxityCon = putByte bh 3
+ put_ bh (FunTy f a) = do putByte bh 4; put_ bh f; put_ bh a
+ put_ bh _ = error "Binary.put(Kind): strange-looking Kind"
+
+ get bh = do
+ b <- getByte bh
+ case b of
+ 0 -> return openTypeKind
+ 1 -> return usageTypeKind
+ 2 -> return liftedTypeKind
+ 3 -> return unliftedTypeKind
+ _ -> do f <- get bh; a <- get bh; return (FunTy f a)
+\end{code}
%************************************************************************
%* *
\begin{code}
funTyCon = mkFunTyCon funTyConName (mkArrowKinds [liftedTypeKind, liftedTypeKind] liftedTypeKind)
+ -- You might think that (->) should have type (? -> ? -> *), and you'd be right
+ -- But if we do that we get kind errors when saying
+ -- instance Control.Arrow (->)
+ -- becuase the expected kind is (*->*->*). The trouble is that the
+ -- expected/actual stuff in the unifier does not go contra-variant, whereas
+ -- the kind sub-typing does. Sigh. It really only matters if you use (->) in
+ -- a prefix way, thus: (->) Int# Int#. And this is unusual.
\end{code}
------------------------------------------