持续更新中……

####
## 1月23日
- 普通的数据实体类型 (type) 用 * 表示，种类 (kind) 的类型是 (* -> *) ，如 Maybe 和 List 。
- 定义的类型别名 (type synonym) 可以用来定义其他的类型别名，限制是在定义时必须以完整参数表的形式给出定义式。
- 利用 IO 类型是 Monad 实例的特性，文件操作可以简单地使用类似这样的表达式：
    readFile "testdata.txt" >>= \s -> putStrLn (show s)
  * 一个附加问题：Haskell 如何操作二进制文件？
    1.  writeFile
      测试这样的表达式：
        writeFile "data.bfile" $ map (\a -> toEnum a::Char) [0..255]
      其输出文件中，数字 10 被转换为十六进制 0D 0A ，多了一个 0D 。也许是“文本格式”的原因。
    2.  readFile
      测试这样的表达式：
        readFile "data.bfile" >>= putStrLn . show . map fromEnum
      根据输出，0D 0A 被还原为 10 暂且略过。文件读到 1A 就认为是结束了。
      经测试，IO 提供的其他判断文件结束的函数也是同样效果。
- Monad 的几个基本方法：
    class Monad m where
        return  :: a -> m a
        fail    :: String -> m a
        (>>=)   :: m a -> (a -> m b) -> m b
        (>>)    :: m a -> m b -> m b
- IO 实现 do 符号的四个规则 (亦即编译器处理 do 子句的方式) ：
    1.  do {e} →
          e
    2.  do {e; es} →
          e >> do {es}
    3.  do {let decls; es} →
          let decls in do {es}
    4.  do {p <- e; es} →
          let ok p = do {es}
              ok _ = fail "..."
          in  e >>= ok
  这四个规则联合起来实现了 do 子句调用 Monad 的过程。
  换言之，可以直接用 Monad 本身的语法写出无 do 子句的 IO 函数来。（虽然这不够直白）
- Monad 必须满足的三条法则 (若自定义不满足的，就可能有一些内建运算无法使用？也许可以利用这个特性测试编译器？) ：
    1. return a >>= f ≡ f a
    2. f >>= return ≡ f
      <两种展开，乘一律>
    3. f >>= (\x -> g x >>= h) ≡ (f >>= g) >>= h
      <结合律>
      eg. getLine >>= (return . reverse) >>= putStrLn
- §9.3 的例子总结。
  ㈠  证明了一个 Monad 的基础函数符合三条法则。
  ㈡  一个典型的 Monad 构造过程：
      1. 写出一个常规函数。
      2. 比较常规函数和原形函数的差别，把差别抽象成类型。
      3. 定义(实现)抽象类型的“接口”(return 和 bind)。
      4. 将新类型代入常规函数，写出常规函数的 Monad 版本。
      在这个过程中，定义的 Monad 类型不是符合原形中的数据结构类型，而是，对其进行扩展的数据单元类型。
  * 应能对此进行扩展，目前没想到。
-

####
## 1月19日
- §8.4.2 里介绍了一个 Computation 类。此类是 Monad 的一个近似型。而对 OO 语言来讲，它是一个计算接口类。提供了四个接口：success 、failure 、augment 和 combine 。
  这四种方法把某种计算的结果封装到一起，其中包含了可能的成功和失败。这该是 Monad 的主要思想。
  从 Computation 类的定义看：
    class Computation c where
        success :: a -> c a
        failure :: String -> c a
        augment :: c a -> (a -> c b) -> c b
        combine :: c a -> c a -> c a
  success 把一个数据类型 a 封装成匹配 Computation 类的类型 c a ，表示一个成功的计算；
  failure 接受一个字符串，返回一个 Computation 类的量，表达失败的计算；
  augment 接受一个计算，一个将这个计算变为另一个计算的变换，从而产生新的计算。
  combine 接受两个之前的计算，产生一个新的，作为两者的结合。这个运算不是 Monad 必须的接口，但在 MonadPlus 中可以找到。
  在 Monad 类中，success 叫做 return ，failure 叫做 fail 以及 augment 叫做 >>= (bind) 。
  * 上面基本属于直译，因为觉得还是这样说起来稍微好接受点。
-

 

####
## 1月18日
- 两种类型定义：data①、newtype② 和 type③ 。
  ①定义的类型的数据集中含“bottom”；②用来定义自己实现的 Int 类型。
  ①的定义方式没有特别的局限；②的定义格式是受限制的 MyType a 方式。
  ③定义的是一个明确结构的别名。
  ⑴三者都可以实现某类的 instance 。
  ⑵①和③可以 deriving 某类。
-

 

####
## 12月18日
- 对数列的处理。
  两个函数(家族)：zip、unzip
  截取函数：take、drop
  整合参数：curry、uncurry
  数列的另一个定义方式：[ f x | x <- xSet, otherConditions ]
- 库中常用数列类型复杂度。
          List    Array   FiniteMap
  insert  O(1)+   O(n)    O(log n)
  update  O(n)    O(n)    O(log n)
  delete  O(n)    O(n)    O(log n)
  find    O(n)    O(1)+   O(log n)
  map     O(n)    O(n)    O(n log n)x
- 可以用 foldx 结合函数运算(“.”等)，简化很多 list 的处理表达式。
-

####
## 12月10日
- 实例定义。
    instance BaseClass MyDataTypeOrClass where
        OneCompleteDefinationMethods ...
    instance BaseClass x => BaseClass (MyDataTypeOrClass x) where
        OneCompleteDefinationMethods ...
  一些常用类的最小完备方法集：
    Eq :  A (==) :: Eq a => a -> a -> Bool
          B (/=) :: Eq a => a -> a -> Bool
    Show :  A show :: Show a => a -> String
            B showsPrec :: Show a => Int -> a -> String -> String
              showList :: Show a => [a] -> String -> String
    Read :  A readsPrec :: Read a => Int -> String -> [(a, String)]
              readList :: String -> [([a], String)]
    Ord : A compare :: Ord a => a -> a -> Ordering
          B (<=) :: Ord a => a -> a -> Bool
          C (>) :: Ord a => a -> a -> Bool
          D (>=) :: Ord a => a -> a -> Bool
          E (<) :: Ord a => a -> a -> Bool
          F min :: Ord a => a -> a -> a
          G max :: Ord a => a -> a -> a
    Enum :    pred :: Enum a => a -> a
              succ :: Enum a => a -> a
            A toEnum :: Enum a => Int -> a
            A fromEnum :: Enum a => a -> Int
              enumFrom :: Enum a => a -> [a]
              enumFromThen :: Enum a => a -> a -> [a]
              enumFromTo :: Enum a => a -> a -> [a]
              enumFromThenTo :: Enum a => a -> a -> a -> [a]
    Num : A (-) :: Num a => a -> a -> a
          A (*) :: Num a => a -> a -> a
          A (+) :: Num a => a -> a -> a
          A negate :: Num a => a -> a
          A signum :: Num a => a -> a
          A abs :: Num a => a -> a
          A fromInteger :: Num a => Integer -> a
-

####
## 12月9日
- 文件操作，多半需要 bracket 作为 wapper 来使用。
- 模块定义：
    module MyModule
    module MyModule ( NoInstanceDataType(),
                      PartValidDataType( PublicDataValue ),
                      FullValidDataTypeA( FullValidDataTypeA ),
                      FullValidDataTypeB( .. ),
                      PublicFunction                            )
  模块引入：
    import MyModule hiding ( PrivateDefinations )
    import qualified MyModule ...              -> MyModule.MyFunction ...
    import qualified MyModule as MyShortName   -> MyShortName.MyFunction ...
  多级模块(非 Haskell 98 标准，GHC 要 -i 参数)：
    import qualified SubDir.MyModule as MyShortName
- 代码的书写，可读性编程(Literate Programming)，.lhs 代码
  Bird-script(有点仿 BBS 或 Email 的回复引文的味道)
    1. 代码行首加“>”字符，其他不加。
    2. 代码行与注释行间有空行分隔。
  LATEX-style markup
    用 \begin{code} 行和 \end{code} 行明确代码行的范围。
- 函数式编程另类指南 http://chn.blogbeta.com/232.html
- where 与 let 。同一， where 子句是转换为 let 子句后进行编译的。
- () 转换运算符为函数。可以映射为省略参数的内嵌函数。
  `` 转换二元的函数为运算符。
- 多参函数可以理解为多阶函数。接受一个参数后，输出一个函数，接收下一参数，类推。
  这种函数可以赋值，可以进行一些函数运算。
- 与 . 运算组合函数类似，$ 运算应用函数。但 $ 运算优先级比较低，可以用以在一些情况下替代括号。
- 通过基于函数的运算，对定义进行纯数学推导。可以优化与分析函数。
- 几个调整参数的函数。
    curry   - 将第二、三个参数做成 pair 给第一个参函数作为参数。取返回值。
    uncurry - 将第二个 pair 参数分解为两个值给第一个参函数作为参数。取返回值。
    flip    - 将第二、三个参数顺序倒置，给第一个参函数作为参数。取返回值。
-

####
## 11月13日
- CPS, 这种机制的实现，除了函数本身工作所需要的参数之外，需要接受一个“继续”函数作为参数，用来决定完成以后如何继续工作。
  * 编译器实现上，用尾递归替代了函数直接返回？是否有额外的系统负担？
-

####
## 11月4日
- Just, Nothing, Nil 与 Cons, Left, Right 等，可以理解为定义类型的时候指定的特别的命名常量或命名运算。
  相应地，data 标识符可以定义一些常量。
- 对于 Either 这种数据类型，需要更详细的例子帮助理解。
-