类型变量 #

-- a 是类型变量
identity :: a -> a
identity x = x

-- 可以用于任何类型
-- identity 5      :: Int -> Int
-- identity "hi"   :: String -> String
-- identity True   :: Bool -> Bool

-- 常用单字母
a, b, c  -- 通用类型变量
m        -- Monad类型
f        -- Functor类型
t        -- 通用类型

-- 有意义的命名
element  -- 元素类型
key      -- 键类型
value    -- 值类型
result   -- 结果类型

-- 两个类型变量
pair :: a -> b -> (a, b)
pair x y = (x, y)

-- 三个类型变量
triple :: a -> b -> c -> (a, b, c)
triple x y z = (x, y, z)

-- 类型变量可以相同
same :: a -> a -> (a, a)
same x y = (x, y)

-- 完全多态函数
identity :: a -> a
identity x = x

-- 不能对x做任何假设
-- 只能原样返回

-- 长度函数
length :: [a] -> Int
length []     = 0
length (_:xs) = 1 + length xs

-- 反转函数
reverse :: [a] -> [a]
reverse []     = []
reverse (x:xs) = reverse xs ++ [x]

-- 拼接函数
(++) :: [a] -> [a] -> [a]
[]     ++ ys = ys
(x:xs) ++ ys = x : (xs ++ ys)

-- 取第一个元素
fst :: (a, b) -> a
fst (x, _) = x

-- 取第二个元素
snd :: (a, b) -> b
snd (_, y) = y

-- 交换元组
swap :: (a, b) -> (b, a)
swap (x, y) = (y, x)

-- Eq约束
elem :: Eq a => a -> [a] -> Bool
elem _ []     = False
elem x (y:ys) = x == y || elem x ys

-- Ord约束
maximum :: Ord a => [a] -> a
maximum []     = error "empty list"
maximum (x:xs) = foldr max x xs

-- Show约束
print :: Show a => a -> IO ()
print x = putStrLn (show x)

-- 多个约束
sort :: Ord a => [a] -> [a]
sort = ...

-- 多个不同约束
showSorted :: (Ord a, Show a) => [a] -> String
showSorted xs = show (sort xs)

-- 复杂约束
process :: (Eq a, Ord a, Show a) => [a] -> String
process xs = show (nub (sort xs))

-- 约束会传播到调用者
contains :: Eq a => a -> [a] -> Bool
contains x xs = elem x xs  -- elem需要Eq约束

-- 调用者也需要Eq约束
checkList :: Eq a => [a] -> a -> Bool
checkList xs x = contains x xs

-- 类型变量在函数签名内有效
function :: a -> a -> b -> b
function x _ y = y  -- x的类型a与返回类型b无关

-- 不同函数的类型变量独立
func1 :: a -> a
func1 x = x

func2 :: a -> a  -- 这个a与func1的a无关
func2 x = x

-- 数据类型中的类型变量
data Maybe a = Nothing | Just a

data Either a b = Left a | Right b

data List a = Nil | Cons a (List a)

-- 类型类中的类型变量
class Eq a where
    (==) :: a -> a -> Bool
    (/=) :: a -> a -> Bool

class Functor f where
    fmap :: (a -> b) -> f a -> f b

-- Maybe是类型构造器
-- Maybe Int 是具体类型

-- 类型变量可以是类型构造器
class Functor f where
    fmap :: (a -> b) -> f a -> f b

-- f是类型构造器变量
-- Maybe、[]、IO都是Functor实例

-- Kind是类型的类型
-- * 表示具体类型
-- Int :: *
-- String :: *

-- 箭头Kind
-- Maybe :: * -> *
-- [] :: * -> *
-- Either :: * -> * -> *

-- 在GHCi中查看
-- :kind Maybe
-- Maybe :: * -> *

-- Monad类需要 * -> * 的类型
class Monad m where
    return :: a -> m a
    (>>=)  :: m a -> (a -> m b) -> m b

-- Maybe :: * -> *，可以作为Monad
-- Int :: *，不能作为Monad

-- 带类型参数的数据类型
data Maybe a = Nothing | Just a

data Either a b = Left a | Right b

data Pair a b = Pair a b

-- 使用
maybeInt :: Maybe Int
maybeInt = Just 5

eitherStrInt :: Either String Int
eitherStrInt = Right 42

-- 列表
data List a = Nil | Cons a (List a)

-- 二叉树
data Tree a = Leaf | Node a (Tree a) (Tree a)

-- 使用
tree :: Tree Int
tree = Node 5 (Node 3 Leaf Leaf) (Node 7 Leaf Leaf)

-- 带类型参数的记录
data Person a = Person
    { name :: String
    , age  :: Int
    , extra :: a
    }

-- 使用
person :: Person String
person = Person "John" 30 "Developer"

-- map
map :: (a -> b) -> [a] -> [b]
map _ []     = []
map f (x:xs) = f x : map f xs

-- filter
filter :: (a -> Bool) -> [a] -> [a]
filter _ []     = []
filter p (x:xs)
    | p x       = x : filter p xs
    | otherwise = filter p xs

-- foldr
foldr :: (a -> b -> b) -> b -> [a] -> b
foldr _ z []     = z
foldr f z (x:xs) = f x (foldr f z xs)

-- fmap for Maybe
instance Functor Maybe where
    fmap _ Nothing  = Nothing
    fmap f (Just x) = Just (f x)

-- fromMaybe
fromMaybe :: a -> Maybe a -> a
fromMaybe def Nothing  = def
fromMaybe _   (Just x) = x

-- catMaybes
catMaybes :: [Maybe a] -> [a]
catMaybes = map fromJust . filter isJust
  where
    fromJust (Just x) = x
    isJust Nothing  = False
    isJust (Just _) = True

-- fmap for Either
instance Functor (Either e) where
    fmap _ (Left x)  = Left x
    fmap f (Right y) = Right (f y)

-- partition
partitionEithers :: [Either a b] -> ([a], [b])
partitionEithers = foldr select ([], [])
  where
    select (Left x)  (ls, rs) = (x:ls, rs)
    select (Right y) (ls, rs) = (ls, y:rs)

-- 编译器推断类型变量
identity x = x
-- 推断为：a -> a

-- 根据使用推断
apply f x = f x
-- 推断为：(a -> b) -> a -> b

-- 约束推断
isEqual x y = x == y
-- 推断为：Eq a => a -> a -> Bool

-- 没有类型签名的绑定可能受限
-- mono = identity
-- 可能被限制为特定类型

-- 解决方法：添加类型签名
mono :: a -> a
mono = identity

-- 模糊类型使用默认
showNum = show 42
-- 默认为Integer

-- 自定义默认
default (Int, Double)

{-# LANGUAGE ExplicitForAll #-}

-- 显式声明类型变量范围
identity :: forall a. a -> a
identity x = x

-- 多个类型变量
pair :: forall a b. a -> b -> (a, b)
pair x y = (x, y)

{-# LANGUAGE RankNTypes #-}

-- 高阶类型
apply :: (forall a. a -> a) -> Int -> Int
apply f x = f x

-- 使用
test = apply identity 5

{-# LANGUAGE TypeFamilies #-}

-- 关联类型
class Container c where
    type Element c
    empty :: c
    insert :: Element c -> c -> c

instance Container [a] where
    type Element [a] = a
    empty = []
    insert = (:)