Functor #

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

-- fmap将函数应用于"容器"内的值
fmap :: (a -> b) -> f a -> f b

-- 类比
-- map :: (a -> b) -> [a] -> [b]
-- fmap是map的泛化版本

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

-- 使用
fmap (*2) (Just 5)  -- Just 10
fmap (*2) Nothing   -- Nothing

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

-- 使用
fmap show (Just 42)  -- Just "42"
fmap length (Just "hello")  -- Just 5
fmap (+1) Nothing  -- Nothing

-- 列表实例
instance Functor [] where
    fmap = map

-- 使用
fmap (*2) [1, 2, 3]  -- [2, 4, 6]
fmap show [1, 2, 3]  -- ["1", "2", "3"]

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

-- 使用
fmap (*2) (Right 5 :: Either String Int)  -- Right 10
fmap (*2) (Left "error" :: Either String Int)  -- Left "error"

-- IO实例
instance Functor IO where
    fmap f action = do
        x <- action
        return (f x)

-- 使用
main :: IO ()
main = do
    line <- fmap (map toUpper) getLine
    putStrLn line

-- 二元组实例（只映射第二个元素）
instance Functor ((,) a) where
    fmap f (x, y) = (x, f y)

-- 使用
fmap (*2) (1, 5)  -- (1, 10)
fmap show (True, 42)  -- (True, "42")

-- 恒等律
-- fmap id == id

-- 验证
fmap id (Just 5)  -- Just 5
id (Just 5)       -- Just 5

fmap id [1, 2, 3]  -- [1, 2, 3]
id [1, 2, 3]       -- [1, 2, 3]

-- 组合律
-- fmap (f . g) == fmap f . fmap g

-- 验证
fmap (show . (*2)) (Just 5)  -- Just "10"
(fmap show . fmap (*2)) (Just 5)  -- Just "10"

-- 符合定律的实现行为可预测
-- 不符合定律的实现可能导致意外行为

-- 错误示例（违反定律）
-- instance Functor Maybe where
--     fmap _ _ = Nothing  -- 违反恒等律

-- <$> 是fmap的中缀形式
(<$>) :: Functor f => (a -> b) -> f a -> f b

-- 使用
(*2) <$> Just 5  -- Just 10
show <$> [1, 2, 3]  -- ["1", "2", "3"]

-- $ 用于普通函数应用
(*2) $ 5  -- 10

-- <$> 用于Functor映射
(*2) <$> Just 5  -- Just 10

-- 链式fmap
show . (*2) <$> Just 5  -- Just "10"

-- 多个Functor操作
addMaybe :: Maybe Int -> Maybe Int -> Maybe Int
addMaybe x y = (+) <$> x <*> y
-- 需要Applicative

-- <$ 用值替换Functor内容
(<$) :: Functor f => a -> f b -> f a

-- 使用
1 <$ Just 5  -- Just 1
1 <$ Nothing  -- Nothing
'a' <$ [1, 2, 3]  -- ['a', 'a', 'a']

-- <$ 实现
x <$ fa = const x <$> fa

-- 示例
1 <$ Just 5
= const 1 <$> Just 5
= Just (const 1 5)
= Just 1

-- 函数是Functor（reader functor）
instance Functor ((->) r) where
    fmap = (.)

-- 类型签名
-- fmap :: (a -> b) -> ((->) r a) -> ((->) r b)
-- 等价于
-- fmap :: (a -> b) -> (r -> a) -> (r -> b)
-- 即函数组合

-- 函数作为Functor
fmap (*2) (+1) 5  -- 12
-- 等价于
(*2) . (+1) $ 5  -- 12

-- 链式
fmap show (+1) 5  -- "6"
show . (+1) $ 5   -- "6"

-- 安全操作链
safeDiv :: Int -> Int -> Maybe Int
safeDiv _ 0 = Nothing
safeDiv x y = Just (x `div` y)

-- 使用fmap
process :: Int -> Int -> Maybe String
process x y = show <$> safeDiv x y

-- 使用
process 10 2  -- Just "5"
process 10 0  -- Nothing

-- 数据转换管道
processData :: [Int] -> [String]
processData = fmap show . fmap (*2) . filter even

-- 等价于
processData' = map show . map (*2) . filter even

-- 使用
processData [1..10]  -- ["4", "8", "12", "16", "20"]

-- 错误处理链
validate :: Int -> Either String Int
validate x
    | x < 0     = Left "Negative"
    | x > 100   = Left "Too large"
    | otherwise = Right x

-- 使用fmap
process :: Int -> Either String String
process x = show <$> validate x

-- 使用
process 50   -- Right "50"
process (-1) -- Left "Negative"

-- IO操作链
readAndProcess :: IO String
readAndProcess = processLine <$> getLine
  where
    processLine = reverse . map toUpper

main :: IO ()
main = do
    result <- readAndProcess
    putStrLn result

-- 嵌套Functor
nested :: Maybe [Int]
nested = Just [1, 2, 3]

-- 两层fmap
fmap (fmap (*2)) nested  -- Just [2, 4, 6]

-- 使用<$>
(*2) <$> (*2) <$> nested  -- Just [4, 8, 12]

-- Compose包装器
newtype Compose f g a = Compose { getCompose :: f (g a) }

instance (Functor f, Functor g) => Functor (Compose f g) where
    fmap f (Compose x) = Compose (fmap (fmap f) x)

-- 使用
-- fmap (*2) (Compose (Just [1, 2, 3]))
-- Compose (Just [2, 4, 6])