模块_Haskell笔记2

-- 把模块中所有函数加入全局命名空间
import <module>
--  部分引用
import <module> (fn1, fn2)
-- 引入数据类型及其值构造器
import <module> (Datatype(constructor, constructor))
-- 引入所有值构造器
import <module> (Datatype(..))
--  hiding排除
import <module> hiding (fn)
--  保留命名空间
import qualified <module>
--  保留命名空间，并起别名
import qualified <module> as <alias>

import Data.List
import Data.List (nub, sort)
import Data.Tree (Tree(Node, Branch))
import Data.Tree (Tree(..))
import Data.List hiding (nub)
import qualified Data.Map
import qualified Data.Map as M

> :m Data.List
> :m Data.List Data.Map Data.Set

> import qualified Data.Map as M
> M.fromList [('a', 1)]
fromList [('a',1)]

module BTree
-- 声明要暴露出去的函数及数据类型
( Tree
, singleton
, add
, fromList
, find
) where
-- 引入依赖模块
-- 定义数据类型及函数
data Tree a = EmptyTree | Node a (Tree a) (Tree a) deriving (Show, Read, Eq)
singleton x = Node x EmptyTree EmptyTree

module MyModule (Tree(Branch, Leaf)) wheredata Tree a = Branch {left, right :: Tree a} | Leaf a

module MyModule (Tree(..))

module MyModule (Tree, factory)

.
├── main.hs
└── Math
   ├── Number.hs
   └── Vector.hs

-- every，全部为True才True
and :: Foldable t => t Bool -> Bool
-- some，有一个为True就True
or :: Foldable t => t Bool -> Bool
-- 常用的some，List中任意元素满足条件就True
any :: Foldable t => (a -> Bool) -> t a -> Bool
-- 常用的every，List中所有元素满足条件才True
all :: Foldable t => (a -> Bool) -> t a -> Bool

-- 在数组中插入分隔元素
intersperse :: a -> [a] -> [a]
-- 与intersperse类似，在二维数组中插入一维数组作为分隔元素，再打平到一维
intercalate :: [a] -> [[a]] -> [a]
-- 二维数组行列转置
transpose :: [[a]] -> [[a]]
-- 降维（把一组List连接成一个List）
concat :: Foldable t => t [a] -> [a]
-- 先做映射再降维，相当于concat . map
concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
-- 无限递归调用，把返回值再传入
iterate :: (a -> a) -> a -> [a]
-- 按位置断开，返回断开的两部分
splitAt :: Int -> [a] -> ([a], [a])
-- 取元素，直到不满足条件为止
takeWhile :: (a -> Bool) -> [a] -> [a]
-- 删元素，直到不满足条件为止
dropWhile :: (a -> Bool) -> [a] -> [a]
-- 按条件断开（首次不满足条件的位置），类似于takeWhile
span :: (a -> Bool) -> [a] -> ([a], [a])
-- 按条件断开（首次满足条件的位置）
break :: (a -> Bool) -> [a] -> ([a], [a])
-- 递归init，直到List为空
inits :: [a] -> [[a]]
-- 递归tail，直到List为空
tails :: [a] -> [[a]]

-- 归并排序
sort :: Ord a => [a] -> [a]
-- 插入到List中第一个大于等于该元素的元素之前
insert :: Ord a => a -> [a] -> [a]

-- 分组，依据是相邻且值相等
group :: Eq a => [a] -> [[a]]
-- 按条件分组，满足条件的一组，不满足的一组
partition :: (a -> Bool) -> [a] -> ([a], [a])

-- 子串匹配（子List匹配），是否包含指定子串
isInfixOf :: Eq a => [a] -> [a] -> Bool
-- 子串匹配，是否以指定子串开头
isPrefixOf :: Eq a => [a] -> [a] -> Bool
-- 子串匹配，是否以为指定子串结尾
isSuffixOf :: Eq a => [a] -> [a] -> Bool
-- 元素包含性检测，是否包含指定元素
elem :: (Foldable t, Eq a) => a -> t a -> Bool
-- 元素包含性检测，是否不包含指定元素
notElem :: (Foldable t, Eq a) => a -> t a -> Bool

-- 按条件查找，返回第一个满足条件的元素
find :: Foldable t => (a -> Bool) -> t a -> Maybe a
-- 查找，返回第一个匹配元素索引或Nothing
elemIndex :: Eq a => a -> [a] -> Maybe Int
-- 查找所有
elemIndices :: Eq a => a -> [a] -> [Int]
-- 与find类似，但返回第一个满足条件的元素索引
findIndex :: (a -> Bool) -> [a] -> Maybe Int
-- 与find类似，但返回所有满足条件的项的索引
findIndices :: (a -> Bool) -> [a] -> [Int]

-- 组合List，还有zip3 ~ zip7
zip :: [a] -> [b] -> [(a, b)]
-- 组合List，并map一遍，还有zipWith3 ~ zipWith7
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]

-- 字符串按行拆分（\n）
lines :: String -> [String]
-- join换行（\n）
unlines :: [String] -> String
-- 按空白字符拆分
words :: String -> [String]
-- join空格
unwords :: [String] -> String

-- 去重
nub :: Eq a => [a] -> [a]
-- 删掉第一个匹配元素
delete :: Eq a => a -> [a] -> [a]

-- 求差集，有重复元素的话，只删第一个
(\\) :: Eq a => [a] -> [a] -> [a]
-- 求并集
union :: Eq a => [a] -> [a] -> [a]
-- 求交集
intersect :: Eq a => [a] -> [a] -> [a]

genericLength :: Num i => [a] -> i
genericTake :: Integral i => i -> [a] -> [a]
genericDrop :: Integral i => i -> [a] -> [a]
genericSplitAt :: Integral i => i -> [a] -> ([a], [a])
genericIndex :: Integral i => [a] -> i -> a
genericReplicate :: Integral i => i -> a -> [a]

nubBy :: (a -> a -> Bool) -> [a] -> [a]
deleteBy :: (a -> a -> Bool) -> a -> [a] -> [a]
unionBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
intersectBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
groupBy :: (a -> a -> Bool) -> [a] -> [[a]]
sortBy :: (a -> a -> Ordering) -> [a] -> [a]
insertBy :: (a -> a -> Ordering) -> a -> [a] -> [a]
maximumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a
minimumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a

on :: (b -> b -> c) -> (a -> b) -> a -> a -> c
f `on` g = \x y -> f (g x) (g y)

groupBy ((==) `Data.Function.on` (> 0)) values

sortBy (compare `on` length) xs

(==) `on`
compare `on`

type String = [Char]    -- Defined in ‘GHC.Base’

--  控制字符
isControl :: Char -> Bool
--  空白符
isSpace :: Char -> Bool
-- 小写Unicode字符
isLower :: Char -> Bool
-- 大写Unicode字符
isUpper :: Char -> Bool
-- 字母
isAlpha :: Char -> Bool
-- 字母或数字
isAlphaNum :: Char -> Bool
-- 可打印字符
isPrint :: Char -> Bool
-- ASCII数字，0-9
isDigit :: Char -> Bool
-- 八进制数
isOctDigit :: Char -> Bool
-- 十六进制数
isHexDigit :: Char -> Bool
-- 字母，功能等价于isAlpha，实现方式不同
isLetter :: Char -> Bool
-- Unicode注音字符，比如法文
isMark :: Char -> Bool
-- Unicode数字，包括罗马数字等
isNumber :: Char -> Bool
-- 标点符号
isPunctuation :: Char -> Bool
-- 货币符号
isSymbol :: Char -> Bool
-- Unicode空格或分隔符
isSeparator :: Char -> Bool
-- ASCII字符（Unicode字母表前128位）
isAscii :: Char -> Bool
-- Unicode字母表前256位
isLatin1 :: Char -> Bool
-- 大写ASCII字符
isAsciiUpper :: Char -> Bool
-- 小写ASCII字符
isAsciiLower :: Char -> Bool

generalCategory :: Char -> GeneralCategory

> generalCategory 'a'
LowercaseLetter
> generalCategory ' '
Space

-- 转大写
toUpper :: Char -> Char
-- 转小写
toLower :: Char -> Char
-- 转title形式，与toUpper类似，部分连体字母有区别
toTitle :: Char -> Char
-- 字符转数字，要求[0-9,a-f,A-F]
digitToInt :: Char -> Int
-- 数字转字符
intToDigit :: Int -> Char
-- 字符转Unicode码
ord :: Char -> Int
-- Unicode码转字符
chr :: Int -> Char

encode shift = map $ chr . (+ shift) . ord
decode shift = map $ chr . (subtract shift) . ord
-- 或者技巧性更足的
decode shift = encode $ negate shift

import qualified Data.Map as Map

-- List转Map，有重复key的话，取最后一个value
Map.fromList :: Ord k => [(k, a)] -> Map.Map k a
-- Map转List
Map.toList :: Map.Map k a -> [(k, a)]
-- 与fromList类似，不直接丢弃重复key，允许手动处理
Map.fromListWith :: Ord k => (a -> a -> a) -> [(k, a)] -> Map.Map k a
-- 空Map
Map.empty :: Map.Map k a
-- 插入(k, a)，返回新Map
Map.insert :: Ord k => k -> a -> Map.Map k a -> Map.Map k a
-- 与insert类似，允许处理重复key
Map.insertWith :: Ord k => (a -> a -> a) -> k -> a -> Map.Map k a -> Map.Map k a
-- 单元素Map
Map.singleton :: k -> a -> Map.Map k a
-- 映射到新Map
Map.map :: (a -> b) -> Map.Map k a -> Map.Map k b
-- 滤出新Map
Map.filter :: (a -> Bool) -> Map.Map k a -> Map.Map k a

-- 判空
Map.null :: Map.Map k a -> Bool
-- 长度
Map.size :: Map.Map k a -> Int
-- 取所有key
Map.keys :: Map.Map k a -> [k]
-- 取所有value
Map.elems :: Map.Map k a -> [a]

-- 按key查找
Map.lookup :: Ord k => k -> Map.Map k a -> Maybe a
-- 包含性判断
Map.member :: Ord k => k -> Map.Map k a -> Bool

import qualified Data.Set as Set

-- List转Set
Set.fromList :: Ord a => [a] -> Set.Set a

-- 求交集
Set.intersection :: Ord a => Set.Set a -> Set.Set a -> Set.Set a
-- 求差集
Set.difference :: Ord a => Set.Set a -> Set.Set a -> Set.Set a
-- 求并集
Set.union :: Ord a => Set.Set a -> Set.Set a -> Set.Set a
-- 判断子集
Set.isSubsetOf :: Ord a => Set.Set a -> Set.Set a -> Bool
-- 判断真子集
Set.isProperSubsetOf :: Ord a => Set.Set a -> Set.Set a -> Bool

unique :: Ord a => [a] -> [a]
unique = Set.toList . Set.fromList