常用标准库 #

-- 身份函数
id :: a -> a
id x = x

-- 常数函数
const :: a -> b -> a
const x _ = x

-- 函数组合
(.) :: (b -> c) -> (a -> b) -> (a -> c)
(f . g) x = f (g x)

-- 翻转参数
flip :: (a -> b -> c) -> b -> a -> c
flip f y x = f x y

-- 函数应用
($) :: (a -> b) -> a -> b
f $ x = f x

-- 列表操作
head :: [a] -> a
tail :: [a] -> [a]
last :: [a] -> a
init :: [a] -> [a]

-- 长度
length :: [a] -> Int

-- 判断
null :: [a] -> Bool
elem :: Eq a => a -> [a] -> Bool

-- 取舍
take :: Int -> [a] -> [a]
drop :: Int -> [a] -> [a]

-- 反转
reverse :: [a] -> [a]

-- 高阶函数
map :: (a -> b) -> [a] -> [b]
filter :: (a -> Bool) -> [a] -> [a]
foldl :: (b -> a -> b) -> b -> [a] -> b
foldr :: (a -> b -> b) -> b -> [a] -> b

-- 逻辑运算
(&&) :: Bool -> Bool -> Bool
(||) :: Bool -> Bool -> Bool
not :: Bool -> Bool

-- 条件
otherwise :: Bool
otherwise = True

-- 基本运算
(+) :: Num a => a -> a -> a
(-) :: Num a => a -> a -> a
(*) :: Num a => a -> a -> a
(/) :: Fractional a => a -> a -> a

-- 其他
negate :: Num a => a -> a
abs :: Num a => a -> a
signum :: Num a => a -> a

-- 整数运算
div :: Integral a => a -> a -> a
mod :: Integral a => a -> a -> a

import Data.List

-- 或选择性导入
import Data.List (sort, nub, group, intersperse)

import Data.List

-- 排序
sort :: Ord a => [a] -> [a]
sort [3, 1, 4, 1, 5]  -- [1, 1, 3, 4, 5]

-- 自定义排序
sortBy :: (a -> a -> Ordering) -> [a] -> [a]
sortBy (flip compare) [1, 2, 3]  -- [3, 2, 1]

-- 排序并分组
sortOn :: Ord b => (a -> b) -> [a] -> [a]
sortOn length ["abc", "de", "fghij"]  -- ["de", "abc", "fghij"]

-- 去除重复
nub :: Eq a => [a] -> [a]
nub [1, 2, 1, 3, 2]  -- [1, 2, 3]

-- 去除相邻重复
nubBy :: (a -> a -> Bool) -> [a] -> [a]

-- 分组相邻相同元素
group :: Eq a => [a] -> [[a]]
group [1, 1, 2, 2, 2, 3]  -- [[1, 1], [2, 2, 2], [3]]

-- 自定义分组
groupBy :: (a -> a -> Bool) -> [a] -> [[a]]
groupBy (\x y -> (x > 0) == (y > 0)) [-1, -2, 1, 2]
-- [[-1, -2], [1, 2]]

-- 查找元素
find :: (a -> Bool) -> [a] -> Maybe a
find (> 3) [1, 2, 3, 4, 5]  -- Just 4

-- 查找位置
elemIndex :: Eq a => a -> [a] -> Maybe Int
elemIndex 3 [1, 2, 3, 4, 5]  -- Just 2

findIndex :: (a -> Bool) -> [a] -> Maybe Int
findIndex (> 3) [1, 2, 3, 4, 5]  -- Just 3

-- 插入
insert :: Ord a => a -> [a] -> [a]
insert 3 [1, 2, 4, 5]  -- [1, 2, 3, 4, 5]

-- 插入分隔
intersperse :: a -> [a] -> [a]
intersperse ',' "abcde"  -- "a,b,c,d,e"

-- 交错插入
intercalate :: [a] -> [[a]] -> [a]
intercalate ", " ["a", "b", "c"]  -- "a, b, c"

-- 前缀后缀
isPrefixOf :: Eq a => [a] -> [a] -> Bool
isSuffixOf :: Eq a => [a] -> [a] -> Bool
isInfixOf :: Eq a => [a] -> [a] -> Bool

import Data.Maybe

import Data.Maybe

-- 从Maybe取值
fromMaybe :: a -> Maybe a -> a
fromMaybe 0 Nothing   -- 0
fromMaybe 0 (Just 5)  -- 5

-- 可能失败的头
listToMaybe :: [a] -> Maybe a
listToMaybe []     -- Nothing
listToMaybe [1, 2] -- Just 1

-- Maybe转列表
maybeToList :: Maybe a -> [a]
maybeToList Nothing   -- []
maybeToList (Just 5)  -- [5]

-- 过滤Just
catMaybes :: [Maybe a] -> [a]
catMaybes [Just 1, Nothing, Just 2]  -- [1, 2]

-- 映射并过滤
mapMaybe :: (a -> Maybe b) -> [a] -> [b]
mapMaybe (\x -> if x > 0 then Just x else Nothing) [-1, 2, -3, 4]
-- [2, 4]

-- 判断
isJust :: Maybe a -> Bool
isNothing :: Maybe a -> Bool

-- 安全查找
safeHead :: [a] -> Maybe a
safeHead = listToMaybe

-- 安全索引
safeIndex :: [a] -> Int -> Maybe a
safeIndex xs n
    | n < 0 || n >= length xs = Nothing
    | otherwise = Just (xs !! n)

-- 链式操作
process :: Maybe Int -> Maybe Int
process = fmap (*2) . fmap (+1)
-- process (Just 5) = Just 12

import Data.Either

import Data.Either

-- 处理Either
either :: (a -> c) -> (b -> c) -> Either a b -> c
either show show (Left 42)   -- "42"
either show show (Right "hi") -- "\"hi\""

-- 判断
isLeft :: Either a b -> Bool
isRight :: Either a b -> Bool

-- 转换
lefts :: [Either a b] -> [a]
lefts [Left 1, Right "a", Left 2]  -- [1, 2]

rights :: [Either a b] -> [b]
rights [Left 1, Right "a", Left 2]  -- ["a"]

-- 分区
partitionEithers :: [Either a b] -> ([a], [b])
partitionEithers [Left 1, Right "a", Left 2]
-- ([1, 2], ["a"])

-- 安全除法
safeDiv :: Int -> Int -> Either String Int
safeDiv _ 0 = Left "Division by zero"
safeDiv x y = Right (x `div` y)

-- 链式操作
process :: Either String Int -> Either String Int
process (Left err) = Left err
process (Right x) = Right (x * 2)

-- 使用either处理
handleResult :: Either String Int -> String
handleResult = either ("Error: " ++) ("Result: " ++) . fmap show

import Data.Char

import Data.Char

-- 大小写转换
toUpper :: Char -> Char
toLower :: Char -> Char
toTitle :: Char -> Char

-- 判断
isDigit :: Char -> Bool
isLetter :: Char -> Bool
isAlpha :: Char -> Bool
isAlphaNum :: Char -> Bool
isUpper :: Char -> Bool
isLower :: Char -> Bool
isSpace :: Char -> Bool

-- 数值转换
digitToInt :: Char -> Int
intToDigit :: Int -> Char

-- ASCII转换
ord :: Char -> Int
chr :: Int -> Char

-- 清理字符串
clean :: String -> String
clean = filter isAlphaNum . map toLower

-- 统计字母
countLetters :: String -> Int
countLetters = length . filter isLetter

-- 首字母大写
capitalize :: String -> String
capitalize [] = []
capitalize (x:xs) = toUpper x : xs

import Control.Monad

import Control.Monad

-- 序列
sequence :: Monad m => [m a] -> m [a]
sequence [Just 1, Just 2, Just 3]  -- Just [1, 2, 3]
sequence [Just 1, Nothing, Just 3] -- Nothing

-- 序列并丢弃结果
sequence_ :: Monad m => [m a] -> m ()
sequence_ [print 1, print 2, print 3]  -- 打印 1 2 3

-- 映射后序列
mapM :: Monad m => (a -> m b) -> [a] -> m [b]
mapM_ :: Monad m => (a -> m b) -> [a] -> m ()

-- for循环
forM :: Monad m => [a] -> (a -> m b) -> m [b]
forM_ :: Monad m => [a] -> (a -> m b) -> m ()

-- 条件执行
when :: Monad m => Bool -> m () -> m ()
when True (print "yes")  -- 打印 "yes"
when False (print "no")  -- 不执行

unless :: Monad m => Bool -> m () -> m ()
unless False (print "yes")  -- 打印 "yes"

-- 过滤
filterM :: Monad m => (a -> m Bool) -> [a] -> m [a]

-- 折叠
foldM :: Monad m => (b -> a -> m b) -> b -> [a] -> m b