GHC近几年的一个发展趋势是试图将Dependent Types的概念引入Haskell。什么是Dependent Types？简单的说就是依赖于值的类型(types depend on values)。例如[a](或者说List a)在Haskell中是一个列表，它的类型取决于传入的类型(depend on types)而不是传入的值(depend on values)，它可以是[Int]，[Bool]等等。但当有一些额外的要求时，比如我要定义一个列表类型，这个类型的列表长度大于3(List n a where n > 3)，一般来说Haskell是做不到这一点的。很容易想到，这种依赖于值的类型有助于编写更加健壮的程序，很多运行时的bug可以在程序的编译期规避掉，比如如果我有一个保证非零的整数类型，那我可以避免除以零的bug；如果我有非空的列表类型，那可以避免对空列表求head导致的Exception等。

目前为止，Haskell还没有实现完整的对Dependent Types的支持。不过GHC已经做了很多扩展使得部分需求可以实现了。来看一下这些语法扩展：

ExistentialQuantification

Existential Quantification翻译为存在量化。这个扩展和Dependent Types没啥关系，不过可以放在一起说一下。

对于类型变量，如果不做其他声明，Haskell默认有一个隐藏的全称量化(Universal Quantification)。例如

id :: a -> a

实际上等价于

id :: forall a. a -> a

也就是说，a是个类型变量，id对于作为其参数的所有类型都要能返回同样的类型。这个称为全称量化。容易想到这样的函数实际上只能写为id x = x。那如果想写出如下类型的函数呢？

printSomething :: a -> String

很难写出一个有实际意义的函数来(const这种不考虑)，因为a默认是全称量化的，必须要考虑到所有的可能性。但是如果加一些限制进去，例如下面

printSomething :: forall a. Show a => a -> String

那我们马上可以写出printSomething = show。这里的forall a. Show a就是Haskell的存在量词，表示存在一些类型a(是Show的instance)能够提供给printSomething。这样，printSomething就被存在量化了。出于一些原因，Haskell并没有采用exists a.作为存在量词。

还有一种情况是在写类型的构造器时，存在量化允许我们在构造器中引入非参数的类型变量，也就是不出现在等号左边的变量。

如下面的例子：

Prelude > data Foo a = MkFoo a              -- OK
Prelude > data Foo1 = MkFoo1 a              -- 类型变量a必须作为该类型定义的一个参数引入
<interactive>:8:20: error: Not in scope: type variable ‘a’ 

Prelude > :set -XExistentialQuantification
Prelude > data Foo2 = forall a. MkFoo2 a    -- OK

别忘了构造器实际上就是函数。因此我们有

MkFoo2 :: forall a. a -> Foo2               -- 存在某些a，可以用来构造Foo2

这么写，用起来就麻烦了，因为不知道a是什么。所以要使用存在量化一般会跟上constraints，或者利用构造器内提供的各种函数。

fFoo2 :: Foo2 -> Bool
fFoo2 (MkFoo2 x) = ???                          -- 不知道x的类型，无法使用

data Foo3 = forall a. MkFoo3 a (a -> Bool)

fFoo3 :: Foo3 -> Bool
fFoo3 (MkFoo3 x f) = f x                        -- 通过构造器提供的函数f来使用x

如下的两种定义是等价的（当然后一种在Haskell中并不存在）：

data Foo = forall a. MkFoo a (a -> Bool)

data Foo = MkFoo (exists a . (a, a -> Bool))

可以参考：

GHC Manual: ExistentialQuantification

What does the forall keyword in Haskell/GHC do?

Existential quantification

RankNTypes

forall关键词除了用于存在量化，还有一个常见的使用方式，就是rank-n-polymorphism，直译的话叫N阶多态。这里的多态和OOP中的多态不同，指对于函数参数类型的多态性(parametric polymorphism)。还是以id为例子，一般的带类型变量的多态函数我们写成

id :: a -> a
id x = x

如果要定义一个函数，让它接受某个多态函数作为输入呢？

rank2func :: (a -> a) -> (Int, Bool)
rank2func f = (f 0, f True)

这里并不能将id作为参数传入rank2func，虽然看起来类型是匹配的。

test.hs:2:16: error:
    • Couldn't match expected type ‘Int’ with actual type ‘a’
      ‘a’ is a rigid type variable bound by
        the type signature for:
          rank2func :: forall a. (a -> a) -> (Int, Bool)
        at test.hs:1:1-36
    • In the expression: f 0
      In the expression: (f 0, f True)
      In an equation for ‘rank2func’: rank2func f = (f 0, f True)
    • Relevant bindings include
        f :: a -> a (bound at test.hs:2:11)
        rank2func :: (a -> a) -> (Int, Bool) (bound at test.hs:2:1)
  |
2 | rank2func f = (f 0, f True)
  |                ^^^

为什么？还是因为Haskell有隐藏的全称量化。如果不做指定，那么类型变量a对于rank2func函数是全称量化的，并且一旦确定a的类型，就无法在rank2func函数体中更改。而逻辑上，对a的全称量化是传入的参数f应该实现的事情，作为consumer我们只考虑怎么利用f。这样，量化的约束就放到了f中，相当于f对rank2func隐藏了a这个类型变量，可以写成：

rank2func' :: (forall a. a -> a) -> (Int, Bool)     -- 记得启用RankNTypes扩展
rank2func' f = (f 0, f True)

最简单的量化了的函数称为一阶多态，依赖于一阶多态的函数就是二阶多态，如上的rank2func'。以此类推，Haskell现在可以支持任意阶多态的函数。

经常用于说明RankNTypes的例子是ST Monad的函数runST。ST Monad是Haskell用于实现内部变量的一种Monad，ST s a表示在一个状态线程s(state thread s)中的一系列操作最后产生a类型的值。和ST s a一起使用的有STRef s a，表示在线程s中的，有着a类型的一个变量。可以看一下相关的函数

runST :: forall a. (forall s. ST s a) -> a

newSTRef   :: a -> ST s (STRef s a)
readSTRef  :: STRef s a -> ST s a
writeSTRef :: STRef s a -> a -> ST s ()
modifySTRef :: STRef s a -> (a -> a) -> ST s () 

从runST的定义可以看出它是一个二阶多态的函数，也就是说，从runST来看，不用管s是什么(它也看不见s)，只负责量化a就可以了。runST保证对于所有类型的a，只要给它一个ST s a，就能生产出一个a。为什么要用到二阶多态？因为逻辑上，不同状态线程之间的STRef不能混用。如果没有rank-2-polymorphism，那么调用runST的时候我们可以自己指定ST s1 (STRef s2 a)，这是不对的。使用rank-2-polymorphism后，runST只负责确定a，不能指定s1或s2。下面的声明会报错：

Prelude Control.Monad.ST Data.STRef > v = runST $ newSTRef True

<interactive>:7:13: error:
    • Couldn't match type ‘a’ with ‘STRef s Bool’
        because type variable ‘s’ would escape its scope
      This (rigid, skolem) type variable is bound by
        a type expected by the context:
          forall s. ST s a
        at <interactive>:7:5-25
      Expected type: ST s a
        Actual type: ST s (STRef s Bool)
    • In the second argument of ‘($)’, namely ‘newSTRef True’
      In the expression: runST $ newSTRef True
      In an equation for ‘v’: v = runST $ newSTRef True
    • Relevant bindings include v :: a (bound at <interactive>:7:1)

虽然我们可以通过newSTRef True拿到一个ST s (STRef s Bool)，但因为括号里的s和前面的s相关，此时a = STRef s Bool。runST对a的全称量化forall a.等价于forall s. STRef s Bool，而根据前面说的，runST无法量化s。要正确的使用runST，确保它不负责指定状态线程s。

import Control.Monad.ST
import Data.STRef

mutateVariable = do
  x <- newSTRef (0 :: Int)
  modifySTRef x (+1)
  readSTRef x

y = runST $ mutateVariable

main = print y

-- the output should be
-- 1

可以参考：

GHC Manual: Arbitrary-rank polymorphism

Wikibook: Haskell/Polymorphism

Wikibook: Haskell/Mutable objects

Lazy Functional State Thread

GADTs

GADT的全称是Generalized Algebraic Data Types。Haskell构造类型的时候可以使用Sum和Product等方式，Algebraic Data Types指使用代数式的方法构造的类型(Sum，Product等名称和类型的inhabitantility有关)。

data Bool = True | False      -- Sum Type
data Pair = (Int, Bool)       -- Product Type
data AFunc = Int -> Bool      -- Func Type

构造类型的时候也可以接受类型变量作为参数，这里可以注意到构造器的返回类型总是全称量化的。

data Maybe a = Nothing | Just a

如果要让构造器根据a的某些类型返回不同的类型呢？Haskell提供了GADT这种方式，如下看到Eq构造器返回的结果和作为参数的类型变量a已经无关了。这样做的优点在于构造器可以自由选择返回类型，并且后续做pattern matching的时候，GHC能根据构造器推导出a的类型。不过，返回的类型还得和声明的数据类型形式相同，不能在声明A类型的构造器时返回B类型。

{-# LANGUAGE GADTs #-}

data Expr a where               -- 构造器返回类型必须具有Expr a的形式
    I   :: Int  -> Expr Int
    B   :: Bool -> Expr Bool
    Add :: Expr Int -> Expr Int -> Expr Int
    Mul :: Expr Int -> Expr Int -> Expr Int
    Eq  :: Eq a => Expr a -> Expr a -> Expr Bool

eval :: Expr a -> a
eval (I n) = n
eval (B b) = b
eval (Add e1 e2) = eval e1 + eval e2        -- Add构造器只接受Expr Int
                                            -- GHC推导出e1, e2均为Int，允许做加法
eval (Mul e1 e2) = eval e1 * eval e2
eval (Eq  e1 e2) = eval e1 == eval e2       -- 同理，e1, e2类型均为Eq的instance

之前提到的存在量化，也可以用GADT实现：

data Foo = forall a. MkFoo a
-- 等价
data Foo where
  MkFoo :: a -> Foo

可以参考：

GHC Manual: GADTs

Simple unification-based type inference for GADTs

Generalized Algebraic Data Types and Data Kinds

Wikibook: Haskell/GADT

DataKinds

Data, Type, Kind是Haskell的三个抽象层次。在Haskell中，类型的类型被称为Kind。例如Int, Bool, Int -> String这些类型都有着* Kind，接受类型变量并构造新类型的类型（例如Maybe a，Either a b）有着Kind * -> *, * -> * -> *等。实际上，Haskell的Kind只有这几种(GHC另有一种# Kind用来表示unboxed types)。GHC为丰富Haskell的Kinds，提供了DataKinds扩展。顾名思义，DataKinds就是把data声明的类型同时也提升为Kind，通过在构造器名前加上单引号'，把它的构造器提升为类型构造器（之前是值构造器）。

很容易想到，既然Kind是类型的类型，它最大的用处应该是检查类型构造的合法性。当我们用类型变量来构造类型的时候，可以给传入的变量一个限制，而这个限制就是Kind。例如

{-# LANGUAGE DataKinds #-}
{-# LANGUAGE KindSignatures #-}       -- 允许使用*,#表示Kind
{-# LANGUAGE GADTs #-}

data AList a = AEmpty | AListCons a (AList a)       -- AList has kind (* -> *)

data TypeLevelList :: AList * -> * where
  EmptyList :: TypeLevelList 'AEmpty                -- 'AEmpty is a type now. It's type is AList a
  TL :: a -> TypeLevelList as -> TypeLevelList ('AListCons a as)
                                                    -- TL接受一个类型和一个类型列表，返回更长的类型列表

*Main > :type AListCons                         -- AListCons is a type (value constructor)
AListCons :: a -> AList a -> AList a
*Main > :kind 'AListCons                        -- 'AListCons is a kind (type constructor)
'AListCons :: a -> AList a -> AList a

*Main > :type TL
TL :: a -> TypeLevelList as -> TypeLevelList ('AListCons a as)

*Main > :type EmptyList
EmptyList :: TypeLevelList 'AEmpty

*Main > :type (TL 1 EmptyList)
(TL 1 EmptyList) :: Num a => TypeLevelList ('AListCons a 'AEmpty)

*Main > :type (TL 1 (TL True (TL "Hello World!" EmptyList)))
(TL 1 (TL True (TL "Hello World!" EmptyList)))
  :: Num a =>
     TypeLevelList
       ('AListCons a ('AListCons Bool ('AListCons [Char] 'AEmpty)))

事实上Haskell已经提供了type level list的包：HList。

可以参考：

GHC Manual: DataKinds

Giving Haskell a Promotion

Higher-order Type-level Programmingin Haskell

TypeFamilies

Type Family是一种介于具体的类型（如Int，Bool）和多态类型（如Maybe a）之间的类型集合，允许有限程度的多态。TypeFamilies扩展一般指对两种语法的支持：

1. data family：定义一组数据类型的集合
2. type family：定义类型同义词(type synonym)的集合，可以理解为类型化简

{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE KindSignatures #-}

import Data.IntMap

data family PairData a :: * -> *    -- PairData a是一个data family，表示一组(* -> *)的类型

data instance PairData Int  b = PairInt (IntMap b)
                                    -- a为Int时对应PairInt构造器，接受一个IntMap
data instance PairData Bool b = PairBool b
                                    -- a为Bool时对应PairBool构造器

type family Elem c
type instance Elem [e] = e

注意data family需要在typeclass中使用，不能直接用于普通函数。

Even if data families are defined as toplevel declarations, functions that perform different computations for different family instances may still need to be defined as methods of type classes.

class UsePairData a where
  usePairData :: PairData a b -> a -> Maybe b

instance UsePairData Int where
  usePairData (PairInt m) key = Data.IntMap.lookup key m

instance UsePairData Bool where
  usePairData (PairBool t) cond = if fst t then Just (snd t) else Nothing

也可以在typeclass中定义data family和type family，此时family和instance可省略。另外，在typeclass中的data family和type family只能使用typeclass定义时声明的类型变量。例如

class UsePairData a where
  data PairData a :: * -> *
  -- data WrongPairData a b :: * -> * 
  -- won't type check since b is unknown to the type class
  usePairData :: PairData a b -> a -> Maybe b

instance UsePairData Int where
  data PairData Int  b = PairInt (IntMap b)
  usePairData (PairInt m) key = Data.IntMap.lookup key m

instance UsePairData Bool where
  data PairData Bool  b = PairBool b
  usePairData (PairBool b) cond = if cond then Just b else Nothing

class UseElem c where
  type Elem c
  listHead :: c -> Elem c

instance UseElem [c] where
  type Elem [c] = c
  listHead = head

上面的例子举得有点简单，但我一时半会写不出原创的复杂的例子……

可以参考：

GHC Manual: TypeFamilies

GHC/Type families

Type Checking with Open Type Functions

Type Families

其他参考

The Future of Programming is Dependent Types — Programming Word of the Day

Wiki: Dependent type

Intuitionistic Type Theory

Research papers/Type systems

Dependent Types in Haskell

This post is highly inspired by Ollie Charles’s 24 Days of GHC Extensions series. See also:

24 Days of GHC Extensions: Existential Quantification

24 Days of GHC Extensions: Rank N Types

24 Days of GHC Extensions: Type Families

我把一部分原因归于GHC的发展。作为事实上的Haskell编译器，GHC一直在不断引入新特性，使得它实际支持的语法比 Haskell 2010 Report 定义要大得多。翻开GHC的用户手册，第九章 GHC Language Features，里面的小节从9.1一直排到9.40，可怕。当然并不是所有的GHC扩展都同等重要，但某些语法扩展确实比其他的更重要。

因此我想简单写一些关于GHC/Reddit常用或常提及，但又不在LYAH里面被包括的语法和范式，我称之为LYAH Extended。大致分为三块：一是GHC对Haskell类型系统的扩展，二是和应用范畴论相关的一些库和功能，三是Effect System。题目很大，我也知道凭目前的经验我写不好，但我还是想去做。

Hakyll是一个静态的站点生成框架，written by Haskell，更多的信息可以参考 Hakyll Homepage¹。

GHC/Cabal环境搭建

要使用Hakyll，首先必须在本机上配置好Haskell的编译环境。感谢万能的github，我找到了ghcup工具。比起Haskell官网的Haskell Platform来说，ghcup提供了更为简单明了的配置方式。（Haskell Platform as the default recommendation considered harmful）。

按ghcup的说明文档，首先通过脚本下载及编译ghc/cabal：

# complete bootstrap
curl https://raw.githubusercontent.com/haskell/ghcup/master/bootstrap-haskell -sSf | sh

编译完成后，别忘了设置环境变量：

# prepare your environment
. "$HOME/.ghcup/env"
echo '. $HOME/.ghcup/env' >> "$HOME/.bashrc" # or similar

设置好环境变量后就可以使用ghc/cabal了，我安装的版本是ghc 8.6.3/cabal 2.4.1。

~/Blogs/blog/posts$ghc --version
The Glorious Glasgow Haskell Compilation System, version 8.6.3

~/Blogs/blog/posts$cabal --version
cabal-install version 2.4.1.0
compiled using version 2.4.1.0 of the Cabal library

配置中途出过一个问题，cabal编译所需要的内存太多。按stackoverflow上的方法，添加了一些swap space后解决。

安装及配置Hakyll

Hakyll的安装可以参考官网的教程，很简单：

$ cabal install hakyll

之后用hakyll-init $sitedir就建好了一个简单的站点目录。

一些自定义配置

站点主题

我从 Hakyll CSS Garden² 中找了一个bronx主题，修改后替换了$sitedir/css目录下的default.css。不过这个主题挺简陋的，有空的话想把它美化一下。

代码语法高亮

博客中会出现一些代码，需要额外的css文件处理代码的语法高亮。以下是我参考jaspervdj（Hakyll作者）修改和pandoc default syntax style自己改的syntax.css。

div.sourceCode { overflow-x: auto; }
table.sourceCode, tr.sourceCode, td.lineNumbers, td.sourceCode {
  margin: 0; padding: 0; vertical-align: baseline; border: none; }
table.sourceCode { width: 100%; line-height: 100%; }
td.lineNumbers { text-align: right; padding-right: 4px; padding-left: 4px; color: #aaaaaa; border-right: 1px solid #aaaaaa; }
td.sourceCode { padding-left: 5px; }

pre code {
display: block;
background-color: rgb(250,250,250);
padding-left: 4px;
padding-right: 4px;
}

code {
border: 1px solid rgb(200,200,200);
}

.sourceCode span.kw { color: #007020; font-weight: bold; } /* Keyword */
.sourceCode span.dt { color: #902000; } /* DataType */
.sourceCode span.dv { color: #40a070; } /* DecVal */
.sourceCode span.bn { color: #40a070; } /* BaseN */
.sourceCode span.fl { color: #40a070; } /* Float */
.sourceCode span.ch { color: #4070a0; } /* Char */
.sourceCode span.st { color: #4070a0; } /* String */
.sourceCode span.co { color: #60a0b0; font-style: italic; } /* Comment */
.sourceCode span.ot { color: #007020; } /* Other */
.sourceCode span.al { color: #ff0000; font-weight: bold; } /* Alert */
.sourceCode span.fu { color: #06287e; } /* Function */
.sourceCode span.er { color: #ff0000; font-weight: bold; } /* Error */
.sourceCode span.wa { color: #60a0b0; font-weight: bold; font-style: italic; } /* Warning */.sourceCode span.cn { color: #880000; } /* Constant */
.sourceCode span.sc { color: #4070a0; } /* SpecialChar */
.sourceCode span.vs { color: #4070a0; } /* VerbatimString */
.sourceCode span.ss { color: #bb6688; } /* SpecialString */
.sourceCode span.im { } /* Import */
.sourceCode span.va { color: #19177c; } /* Variable */
.sourceCode span.cf { color: #007020; font-weight: bold; } /* ControlFlow */
.sourceCode span.op { color: #666666; } /* Operator */
.sourceCode span.bu { } /* BuiltIn */
.sourceCode span.ex { } /* Extension */
.sourceCode span.pp { color: #bc7a00; } /* Preprocessor */
.sourceCode span.at { color: #7d9029; } /* Attribute */
.sourceCode span.do { color: #ba2121; font-style: italic; } /* Documentation */
.sourceCode span.an { color: #60a0b0; font-weight: bold; font-style: italic; } /* Annotation */
.sourceCode span.cv { color: #60a0b0; font-weight: bold; font-style: italic; } /* CommentVar */
.sourceCode span.in { color: #60a0b0; font-weight: bold; font-style: italic; } /* Information */

把上面的部分加入到$sitedir/templates/default.html中。

<link rel="stylesheet" href="/css/syntax.css" />

Hakyll通过pandoc进行语法解析并打html tag，然后根据语法的css文件做高亮，但我感觉pandoc的解析总是有点问题。比如文章中这段：

高亮颜色就不对。只能以后自己慢慢调整了。

Hakyll与Docker, Github，CircleCI的集成

最后，我需要将站点与github pages同步，参考了 Dr. Hakyll: Create a GitHub page with Hakyll and CircleCI ³ 以及 How to Hakyll CircleCI 2.0 ⁴。

设置Github Pages项目

Github Pages只支持在master branch下的博客站点，而hakyll build后生成的静态站点文件都在$sitedir/_site目录下。文章中用的解决方法是建一个名为hakyll的分支，将本地的源文件推到该分支下。再通过CircleCI脚本编译后，将./_site目录推到master分支下。

$ mkdir username.github.io/
$ cd username.github.io/
$ git init
$ git commit --allow-empty -m "Create master branch"
$ git remote add origin git@github.com:username/username.github.io.git
$ git push -u origin master

$ git checkout --orphan hakyll

$ git submodule add git@github.com:username/username.github.io.git _site
$ git commit -m "Create hakyll branch"
$ git push -u origin hakyll

创建自己的docker image

CircleCI可以对静态站点进行编译并将结果推送至github。然而编译之前需要安装ghc/cabal以及hakyll的库，这个过程会很费时间。因此在集成CircleCI之前，需要先建立一个自己的docker image，将编译所需要的库文件都放进去，节约CircleCI build的时间。

如何安装docker不赘述了，可以参考官方的文档Get Docker CE for Debian。用了一台debian的vps做这个事情。

docker安装好后，编写自己的Dockerfile拉取官方的docker image（我使用的是library/haskell），并加入hakyll库。这些步骤保存在Dockerfile里。

FROM haskell

RUN apt-get update && apt-get install -y ssh && apt-get install git

RUN cabal update
RUN cabal install hakyll -j1

WORKDIR /home

按Dockerfile建立镜像：

$ docker build .

最后将docker image推送到docker hub，供CircleCI拉取。

$ docker login
$ docker push obeliskgolem/hakyll-cabal-image

与CircleCI的集成

CircleCI与Github的集成也不过多赘述了，完成后编辑.circleci/config.yml文件，为CircleCI指定编译任务。

version: 2
jobs:
  build:
    docker:
      - image: obeliskgolem/hakyll-cabal-image
    steps:
      # checkout the code in Github Pages project
      - checkout

      - run:
          name: Generate Static Site
          command: cabal run site build

      - run:
          name: Publish GitHub Pages
          working_directory: './_site'
          command: |
            # initalize repo
            git init
            git config user.name  'obeliskgolem'
            git config user.email 'obeliskgolem@circleci.com'
            # add generated files
            git add .
            git commit -m "publish $CIRCLE_SHA1 [ci skip]"
            # push to pages branch
            git remote add origin "$CIRCLE_REPOSITORY_URL"
            git push --force origin master

最后，将本地的站点源代码推送至Github仓库的hakyll分支：

$ git add --all
$ git commit -m "circle ci integration"
$ git push origin hakyll

经CircleCI编译后，静态站点被输出到_site目录。

大功告成！

TODOs

1. 加入草稿功能
2. 加入评论功能
3. 自动生成rss feed
4. pandoc语法解析改进

参考文献，及一些可能有帮助的文档

Switching from Jekyll to Hakyll

ghcup

ghc/cabal build out of memory

ssh over socks5

https://thoughtbot.com/blog/easy-haskell-development-and-deployment-with-docker

Deploying a Hakyll website using Github Pages and CircleCI 2.0

Integration with Circle CI

Pandoc Syntax Highlighting with CSS description

安装指令

For CentOS 7

查看操作系统版本： lsb_release -a

安装Icinga仓库 yum install epel-release

安装Icinga2:

# yum install icinga2
# systemctl enable icinga2
# systemctl start icinga2

安装插件 # yum install nagios-plugins-all

运行Icinga

首先需要启动，centos使用systemd管理icinga2的服务 # systemctl status icinga2

通过systemd设置icinga2的自启动

#/etc/systemd/system/icinga2.service.d/override.conf

[Service]
Restart=always
RestartSec=1
StartLimitInterval=10
StartLimitBurst=3

重新加载systemctl配置 systemctl daemon-reload && systemctl restart icinga2

安装icinga2专用的SELinux yum install icinga2-selinux

配置语法高亮 yum install vim-icinga2

安装 Icinga Web 2

安装mysql

# yum install mariadb-server mariadb
# systemctl enable mariadb
# systemctl start mariadb
# mysql_secure_installation

安装icinga2的IDM模块（Icinga Data Output） # yum install icinga2-ido-mysql

在mysql中建立用户及表

mysql>  CREATE DATABASE icinga;
mysql>  GRANT SELECT, INSERT, UPDATE, DELETE, DROP, CREATE VIEW, INDEX, EXECUTE ON icinga.* TO 'icinga'@'localhost' IDENTIFIED BY 'icinga';
mysql> quit

导入数据库schema # mysql -u root -p icinga < /usr/share/icinga2-ido-mysql/schema/mysql.sql

启用 IDO MySQL Module并重启icinga服务 # icinga2 feature enable ido-mysql # systemctl restart icinga2

防火墙规则

# firewall-cmd --add-service=http
# firewall-cmd --permanent --add-service=http

启用Icinga的REST API # icinga2 api setup

# vim /etc/icinga2/conf.d/api-users.conf

object ApiUser "icingaweb2" {
  password = "Wijsn8Z9eRs5E25d"
  permissions = [ "status/query", "actions/*", "objects/modify/*", "objects/query/*" ]
}

安装Icinga Web2 yum install icingaweb2 icingacli

安装SELinux for Icinga Web2 yum install centos-release-scl yum install icingaweb2-selinux

安装Web Server

yum install httpd
systemctl start httpd.service
systemctl enable httpd.service

启用PHP-FPM

systemctl start rh-php71-php-fpm.service
systemctl enable rh-php71-php-fpm.service

在/etc/opt/rh/rh-php71/php.ini中设置date.timezone = Asia/Shanghai

安装ImageMagick # yum install ImageMagick

打开页面 http://127.0.0.1/icingaweb2/setup 完成剩下的设置

重启Icinga服务，大功告成！

附：从本地仓库安装Icinga2

首先需要从互联网上下载所有Icinga2的包 根据/etc/yum.repos.d/ICINGA-release.repo定义的yum源进行下载。

定义centos的源，然后用repotrack将Icinga包及其依赖的包全部抓下来。并用这些包建立一个新的yum repo。

repotrack -r epel-6 -r base-6 -r updates-6 -r extras-6 -r centosplus-6 -r icinga-stable-release-el6 nagios-4.3.4-7.el6.x86_64 nagios-plugins-all-2.2.1-4git.el6.x86_64 icinga2-2.8.4-1.el6.icinga.x86_64.rpm

createrepo icinga-stable-release

sftp XXX@aaa.bbb.ccc.ddd:/home/icinga2

sftp> mkdir icinga_repo
sftp> put -r icinga_repo

参考文档

Icinga2 官方安装教程

Icinga Web2 官方安装教程

插件配置

以下内容主要参考 Learn you a Haskell for great good¹.

什么是Functor（函子）？

Functor指的是一个容器所具有的某种性质：这个容器实现了一个称为fmap的函数，可以将某个单参数函数提升为对容器中的元素操作的函数。即：把一个函数应用到容器内部。

如果说容器是一个上下文环境，那么fmap使得你可以将一个上下文无关的函数应用到这个容器，也即：fmap是函数的上下文相关版本。

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

从范畴论到Functor

范畴论的数学基础

范畴的三个组成部分

1. 对象
2. 态射，用以连接范畴中的两个对象
3. 态射的复合，用以将多个态射组合到一起

范畴的三个定律

1. 态射需要满足结合律，即：f.(g.h) = (f.g).h
2. 范畴对于态射的复合来说是封闭的，即：若 f, g 属于某范畴，则f.g也属于该范畴
3. 对每个范畴中的对象，都存在一个恒等的态射

Haskell的范畴：Hask

Haskell的所有类型types，对应Hask的objects。Haskell的所有函数functions，对应Hask的morphisms

范畴论中的函子F是范畴到范畴的变换(transformation)。给定函子 F: C -> D，F 应该： 1. 将C中的所有object映射到 D：A -> F(A)，这个在Hask中对应类型构造器 2. C中的所有态射也映射到 D：f -> F(f)，在Hask中对应高阶函数

函子的定律

函子应该满足两条定律： 1. 范畴C中，任意对象A上的恒等变换id(A)，可以通过F变换为范畴D中的恒等变换，即 F(id(A)) = id(F(A)) 2. 函子对于态射的复合应该满足分配律，即：F(f.g) = F(f).F(g)

Haskell中的函子实际上是从范畴Hask到范畴func的一个变换，其中func是通过函子所定义的一个Hask的子范畴。 对象到对象的映射已经通过函子f完成了，而态射到态射的映射则是通过函子f的一个接口：即前面提到的fmap

范畴论中函子的两条定律，对Haskell中的函子依然适用： 1. 恒等变换：fmap id = id 2. 分配律：fmap (f.g) = fmap f.fmap g

什么是Applicative Functor（应用型函子）？

class (Functor f) => Applicative f where
	pure a :: f a
	(<*>) :: f (a -> b) -> f a -> f b

对于范畴C内的函数(a -> b) ，我们有函子可以将它应用于范畴D。但如果我们只有范畴D内的函数f(a -> b)呢？能不能将它也应用于范畴D呢？

Applicative Functor指的是这样一个容器：它除了具有Functor类型容器的性质外，你还可以 1. 将任意类型用该容器封装。记住functor实际上是个类型的构造器，接受类型作为参数。 2. 对于一个容器内部的函数，你可以将它拿出来并应用于容器内的元素

所以对于Applicative Functor函子，你既可以将外部的普通函数提升为应用于容器元素的函数（满足函子的定义），也可以将容器内部存在的函数拿出来，将其应用于容器元素。另外，pure函数的存在让你可以将任意类型放入容器中，这个任意类型当然也包括函数类型。

Applicative Functor有用的地方在于，它可以存放类型，也可以存放类型到类型的映射。它的应用范围比functor大了很多。

考虑所有的a, b, 以及(a -> b), 它们组成一个范畴C。所有的f a, f b, 以及f (a -> b)，它们也组成一个范畴 C'。而Applicative Functor f就是范畴 C 到 C' 的映射。

Applicative函子的定律

就像函子一样，Applicative函子也有需要满足的定律，它们是

pure id <*> v = v                            -- 恒等
pure f <*> pure x = pure (f x)               -- 同态
u <*> pure y = pure ($ y) <*> u              -- 交换
pure (.) <*> u <*> v <*> w = u <*> (v <*> w) -- 复合

另外，还有一条关于 fmap的性质：

fmap f x = pure f <*> x                      -- fmap

Applicative函子的用途

因为没什么深刻的体会，这里具体的用途只能留待日后补全。书中主要讲了两个使用到应用型函子的地方：liftA2和sequenceA。

liftA2 :: (Applicative f) => (a -> b -> c) -> f a -> f b -> f c
liftA2 f a b = f <$> a <*> b

sequenceA :: (Applicative f) => [f a] -> f [a]
sequenceA [] = pure []
sequenceA (x:xs) = (:) <$> x <*> sequenceA xs

liftA2让我们可以将两个应用型函子作为容器展开，返回一个更大的容器，里面包含了对展开的元素元组应用f的结果。而sequenceA则将一个应用型函子的列表展开，返回一个用应用型函子包起来的列表。

什么是Monad（单子）？

Monad是一类特殊的函子，是范畴到其自身的映射，同时对于范畴中的每一个对象，它都定义了两个态射：

unit(x) :: x -> M(x)
join(x) :: M(M(x)) -> M(x)

这里，unit(x)可以认为是x从范畴C到范畴D的最小上下文映射，而join(x)则是将范畴D中的对象展平。

Haskell中的单子一般通过下面的方式定义：

class (Functor m) => Monad m where
	return :: x -> m x
	x >>= f :: m a -> (a -> m b) -> m b

虽然形式不同，但可以通过一些变换证明，join和绑定>>=是等价的

join x = x >>= id

x >>= f = join (fmap f x)

Monad需要满足的定律

Haskell中Monads需要满足如下定律

m >>= return     =  m                        --右单位元
return x >>= f   =  f x                      --左单位元
(m >>= f) >>= g  =  m >>= (\x -> f x >>= g)  --结合律

什么是Monoid（幺半群）？

class Monoid a where
    mempty  :: a
    mappend :: a -> a -> a

    mconcat :: [a] -> a
    mconcat = foldr mappend mempty

Monoid 是一个包含二元操作符和单位元的类型类，其中二元操作符mappend需要满足结合律。

为什么要搞这么个概念呢？暂时还无法理解，只能安慰自己说Haskell习惯把能抽象的概念都抽象了……

书中一个比较nb的例子是Ordering，它也是个 Monoid ！

data Ordering = LT | EQ | GT

instance Monoid Ordering where
	mempty = EQ
	LT `mappend` _ = LT
	EQ `mappend` y = y
	GT `mappend` _ = GT

Ordering是 Monoid 的事实实际上体现了一个分优先级的比较。要比较a和b，先比较a1和b1。a和b的大小首先取决于a1 b1，以此类推。

一些问题待以后解决

(>>=) 为什么接受 (a -> m b) 而不是 (m a -> m b)？

applcative和monad的区别？

总结

写完这篇博客，还是感觉自己对这几个概念一知半解。虽然很想在理解的更透彻一些后总结，但暂时就此打住吧。期待以后有了更多的实践经验后再来补充。

参考文献

Haskell/Category theory

Monads As Containers

Monads for Curious Programmers

Applicative programming with effects

代码，插入

格式，不对

google，搜索

文档，放弃

blogger，卸载

jekyll，安装

主题，挑选

github pages，启动