-- 基本的な使用例
ghci> :t True
True :: Bool

ghci> :t 'a'
'a' :: Char

ghci> :t map
map :: (a -> b) -> [a] -> [b]

-- 自分で定義した式の型も確認できる
ghci> :t \x -> x + 1
\x -> x + 1 :: Num a => a -> a

-- 複雑な式の型も表示可能
ghci> :t foldr (:) []
foldr (:) [] :: [a] -> [a]

-- 関数の情報
ghci> :i map
map :: (a -> b) -> [a] -> [b]  -- 型シグネチャ
        -- Defined in 'GHC.Base'  -- 定義場所

-- 型の情報
ghci> :i Int
data Int = GHC.Types.I# GHC.Prim.Int#  -- 定義
instance Eq Int       -- インスタンス
instance Ord Int
instance Show Int
instance Read Int
instance Enum Int
instance Num Int
...

-- 型クラスの情報
ghci> :i Num
class Num a where  -- クラス定義
  (+) :: a -> a -> a
  (-) :: a -> a -> a
  (*) :: a -> a -> a
  negate :: a -> a
  abs :: a -> a
  signum :: a -> a
  fromInteger :: Integer -> a
        -- Defined in 'GHC.Num'
instance Num Integer  -- インスタンス一覧
instance Num Int
instance Num Float
instance Num Double
...

-- 基本的な型のカインド
ghci> :k Int
Int :: *
-- * は具体的な型（データを持つことができる型）を表す

-- 型コンストラクタのカインド
ghci> :k Maybe
Maybe :: * -> *
-- Maybe は型引数を1つ取り、具体的な型を返す型コンストラクタ

-- 複数の型引数を取る型コンストラクタ
ghci> :k Either
Either :: * -> * -> *
-- Either は型引数を2つ取り、具体的な型を返す型コンストラクタ

-- 型クラスのカインド
ghci> :k Eq
Eq :: * -> Constraint
-- Eq は型引数を1つ取り、型制約を返す

-- Data.Maybeモジュールの内容を表示
ghci> :browse Data.Maybe
catMaybes :: [Maybe a] -> [a]
fromJust :: Maybe a -> a
fromMaybe :: a -> Maybe a -> a
isJust :: Maybe a -> Bool
isNothing :: Maybe a -> Bool
listToMaybe :: [a] -> Maybe a
mapMaybe :: (a -> Maybe b) -> [a] -> [b]
maybeToList :: Maybe a -> [a]
maybe :: b -> (a -> b) -> Maybe a -> b

-- Data.Listモジュールの一部を表示
ghci> :browse Data.List
...
sort :: Ord a => [a] -> [a]
sortBy :: (a -> a -> Ordering) -> [a] -> [a]
...

-- mapのドキュメントを表示
ghci> :doc map
map :: (a -> b) -> [a] -> [b]
  Map a function over all the elements of a list.

-- Maybeのドキュメントを表示
ghci> :doc Maybe
data Maybe a = Nothing | Just a
  The Maybe type encapsulates an optional value. A value of type
  Maybe a either contains a value of type a (represented as Just a),
  or it is empty (represented as Nothing).

-- 具体的な型のカインド
:k Int          -- Int :: *
:k Bool         -- Bool :: *
:k [Int]        -- [Int] :: *  （特定の型のリストは具体的な型）

-- 型コンストラクタのカインド
:k []           -- [] :: * -> *  （リスト型コンストラクタ）
:k Maybe        -- Maybe :: * -> *  （Maybeは型引数を1つ取る）
:k Either       -- Either :: * -> * -> *  （Eitherは型引数を2つ取る）

-- 型クラスのカインド
:k Eq           -- Eq :: * -> Constraint
:k Monad        -- Monad :: (* -> *) -> Constraint  （MonadはMaybeのような型コンストラクタに適用される）

-- 型引数を適用した結果
:k Maybe Int    -- Maybe Int :: *  （型引数を適用すると具体的な型になる）
:k Either Int   -- Either Int :: * -> *  （1つだけ適用すると残り1つの型引数を取る型コンストラクタになる）
:k Either Int Bool  -- Either Int Bool :: *  （両方適用すると具体的な型になる）