View source for Cn/十分钟学会 Haskell

== 概要 ==

Haskell 是函数式（一切通过函数调用来完成）、静态、隐式类型（[[type|类型]]由编译器检测，类型声明不是必需的）、惰性（除非必要，否则什么也不做）的语言。其最大众化的近亲大概是 ML 族语言（不过不是惰性的）。

最流行(common)的 Haskell 编译器是 [[GHC]]，[http://www.haskell.org/ghc/download_ghc_661.html 下载地址]。GHC 在 [[GNU/Linux]], 
[[BSD | FreeBSD]], [[Mac OS X |MacOS]], [[Windows]] 以及 [[Solaris]] 平台上都有可供使用的二进制包。安装 GHC，即获得 <tt>ghc</tt> 和 <tt>[[GHC/GHCi | ghci]]</tt>。前者用于将 Haskell 程序库或应用程序编译成二进制码。后者为解释器，可在编写 Haskell 代码后立即得到反馈.

== 表达式 ==

大部份数学表达式都可以输入 <tt>ghci</tt> 直接解答。<tt>Prelude></tt> 是 GHCi 默认提示符。

  Prelude> <hask>3 * 5</hask>
  15
  Prelude> <hask>4 ^ 2 - 1</hask>
  15
  Prelude> <hask>(1 - 5)^(3 * 2 - 4)</hask>
  16

字符串需要双引号引用，以 <hask>++</hask> 连接。

  Prelude> <hask>"Hello"</hask>
  "Hello"
  Prelude> <hask>"Hello" ++ ", Haskell"</hask>
  "Hello, Haskell"

调用函数时，参数紧接[[function|函数]]即可，其间无须添加括号。

  Prelude> <hask>succ 5</hask>
  6
  Prelude> <hask>truncate 6.59</hask>
  6
  Prelude> <hask>round 6.59</hask>
  7
  Prelude> <hask>sqrt 2</hask>
  1.4142135623730951
  Prelude> <hask>not (5 < 3)</hask>
  True
  Prelude> <hask>gcd 21 14</hask>
  7

== 控制台 ==

调用 [[Introduction to IO |I/O actions]] 进行控制台输入和输出。如：

  Prelude> <hask>putStrLn "Hello, Haskell"</hask>
  Hello, Haskell
  Prelude> <hask>putStr "No newline"</hask>
  No newlinePrelude> <hask>print (5 + 4)</hask>
  9
  Prelude> <hask>print (1 < 2)</hask>
  True

<hask>putStr</hask> 和 <hask>putStrLn</hask> 输出字符串到终端。<hask>print</hask> 输出任意类型的值。（如果 <hask>print</hask> 作用于字符串，输出将用引号引用。)

复杂的 I/O acttions 需要 <hask>do</hask> 语句块，以分号间隔。

  Prelude> <hask>do { putStr "2 + 2 = " ; print (2 + 2) }</hask>
  2 + 2 = 4
  Prelude> <hask>do { putStrLn "ABCDE" ; putStrLn "12345" }</hask>
  ABCDE
  12345

通过 <hask>getLine</hask>（返回字符串）或 <hask>readLn</hask>（返回任意你需要的类型）获得输入。用<hask> <- </hask> 符号给 I/O action 的结果命名。

  Prelude> <hask>do { n <- readLn ; print (n^2) }</hask>
  4
  16

（4 是输入。16 是结果。）

<hask>do</hask> 语句块的另一种方式，以缩进取代花括号和分号。虽然在 <tt>ghci</tt> 中未能获得完美支持，但是可以把它们塞进源文件（如 <tt>Test.hs</tt>）里然后编译：

<haskell>
main = do putStrLn "What is 2 + 2?"
          x <- readLn
          if x == 4
              then putStrLn "You're right!"
              else putStrLn "You're wrong!"
</haskell>

运行 ghc --make Test.hs，得到 Test（[[Windows]] 上是 Test.exe）。顺便接触了 if 语句。

do 之后首个非空白字符，如上例 <hask>putStrLn</hask> 的 p，是特别的。每新起一行，行首与之对齐，即视为同一 do 块之新句；缩进较之多则继续前句；较之少则结束此 do 块。是为页面布局（layout），Haskell 以之回避语句结束标记和花括号。（故then 和 else 子句务必缩进，否则将脱离 if 语句，导致错误。）

（注意：切勿使用制表符。从技术上讲，八格制表符可以正常工作，但不是个好主意。也不要使用非等宽字体——显然，有些人在编程的时候会犯此糊涂！）

== 类型 ==

到目前为止，我们一直没有提到过类型声明。那是因为 Haskell 暗中推断，不必声明之。如果非要声明类型，可用 <hask>::</hask> 符号明确指出，如：

  Prelude> <hask>5 :: Int</hask>
  5
  Prelude> <hask>5 :: Double</hask>
  5.0

类型 [[Type|types]]（以及类型类 type [[class]]es，稍后提及）总是以大写开头。变量（variables）总是以小写开头。这是语言规则，而不只是[[Study captials|命名习惯]]。

你也可以让 <tt>ghci</tt> 告诉你选择的内容的类型，这种方法很有用，因为类型声明并不是必需的。

  Prelude> :t <hask>True</hask>
  <hask>True :: Bool</hask>
  Prelude> :t <hask>'X'</hask>
  <hask>'X' :: Char</hask>
  Prelude> :t <hask>"Hello, Haskell"</hask>
  <hask>"Hello, Haskell" :: [Char]</hask>

(在这个例子中，<hask>[Char]</hask> 是 <hask>String</hask> 的另外一种表达方式。参见后面的 [[#Structured data|section on lists]] 。)

有关数字的例子则更加有趣：

  Prelude> :t <hask>42</hask>
  <hask>42 :: (Num t) => t</hask>
  Prelude> :t <hask>42.0</hask>
  <hask>42.0 :: (Fractional t) => t</hask>
  Prelude> :t <hask>gcd 15 20</hask>
  <hask>gcd 15 20 :: (Integral t) => t</hask>

这些类型用到了 "类型类（type classes）" 含义如下：

* <hask>42</hask> 可作为任意数字(numeric)类型。(这就是为什么我既可以把<hask>5</hask>声明为<hask>Int</hask>类型，也可以声明为<hask>Double</hask>类型的原因。)
* <hask>42.0</hask> 可作为任意分数(fractional)类型，但不能是整数(integral)类型。
* <hask>gcd 15 20</hask> (此为函数调用) 可作为任意整数(integral)类型，但不能是分数类型。

在Haskell "Prelude"(你不需要import任何东西就能使用的那部分库)中有五种数字(numeric)类型:

* <hask>Int</hask> 是一个至少30位(bit)精度的整数。
* <hask>Integer</hask> 是一个无限精度的整数。
* <hask>Float</hask> 是一个单精度浮点数。
* <hask>Double</hask> 是一个双精度浮点数。
* <hask>Rational</hask> 是一个没有舍入误差的分数/小数类型。

上面5个都是<hask>Num</hask>类型的'''实例（instances）'''。其中前两个是<hask>Integral</hask>类型的'''实例'''，后面三种是<hask>Fractional</hask>类型的'''实例'''。

总的一块来看一下，

  Prelude> <hask>gcd 42 35 :: Int</hask>
  7
  Prelude> <hask>gcd 42 35 :: Double</hask>
  
  <interactive>:1:0:
      No instance for (Integral Double)

最后值得一提的类型是<hask>()</hask>，念做"unit"。
它只有一个取值，也写作<hask>()</hask>并念做"unit"。

  Prelude> <hask>()</hask>
  <hask>()</hask>
  Prelude> :t <hask>()</hask>
  <hask>() :: ()</hask>

你可以把它看作类似C语言中的<tt>void</tt>关键字。在一个I/O动作中，如果你不想返回任何东西，你可以返回<hask>()</hask>。

== 有结构的数据 ==

基本数据类型可以很容易的通过两种方式组合在一起：通过 [方括号] 组合的'''列表（lists）'''，和通过 (圆括号) 组合的'''元组（tuples）'''。

列表可以用来储存多个相同类型的值：

  Prelude> <hask>[1, 2, 3]</hask>
  [1,2,3]
  Prelude> <hask>[1 .. 5]</hask>
  [1,2,3,4,5]
  Prelude> <hask>[1, 3 .. 10]</hask>
  [1,3,5,7,9]
  Prelude> <hask>[True, False, True]</hask>
  [True,False,True]

Haskell 中的字符串（String）其实只不过是字符（Character）类型的 List：

  Prelude> <hask>['H', 'e', 'l', 'l', 'o']</hask>
  "Hello"

冒号 <hask>:</hask> 运算符用来把一个项（item）添加到列表的开始处。(相当于LISP语言中的<tt>cons</tt>函数)

  Prelude> <hask>'C' : ['H', 'e', 'l', 'l', 'o']</hask>
  "CHello"

元组则和列表不同，它用来储存固定个数，但类型不同的值。【译者注：列表是类型相同，但个数不固定，甚至还可以是无限个数】

  Prelude> <hask>(1, True)</hask>
  (1,True)
  Prelude> <hask>zip [1 .. 5] ['a' .. 'e']</hask>
  [(1,'a'),(2,'b'),(3,'c'),(4,'d'),(5,'e')]

上面这个例子用到了 <hask>zip</hask> 函数，它可以把两个列表组合成一个元组的列表。

类型一般都符合你的期望：

  Prelude> :t <hask>['a' .. 'c']</hask>
  <hask>['a' .. 'c'] :: [Char]</hask>
  Prelude> :t <hask>[('x', True), ('y', False)]</hask>
  <hask>[('x', True), ('y', False)] :: [(Char, Bool)]</hask>

列表在Haskell中被大量使用。有些函数能够很好地对列表进行运算：

  Prelude> <hask>[1 .. 5]</hask>
  <hask>[1,2,3,4,5]</hask>
  Prelude> <hask>map (+ 2) [1 .. 5]</hask>
  <hask>[3,4,5,6,7]</hask>
  Prelude> <hask>filter (> 2) [1 .. 5]</hask>
  <hask>[3,4,5]</hask>

有两个作用于双元素元组的优美函数：

  Prelude> <hask>fst (1, 2)</hask>
  <hask>1</hask>
  Prelude> <hask>snd (1, 2)</hask>
  <hask>2</hask>
  Prelude> <hask>map fst [(1, 2), (3, 4), (5, 6)]</hask>
  <hask>[1,3,5]</hask>

详见[[how to work on lists|如何使用列表]]

== [[函数]]定义 ==

我们已经定义了一个名为<hask>main</hask>的[[Introduction to Haskell IO/Actions |IO动作]]函数:

<haskell>
main = do putStrLn "What is 2 + 2?"
          x <- readLn
          if x == 4
              then putStrLn "You're right!"
              else putStrLn "You're wrong!"
</haskell>

现在，我们定义一个名为<hask>factorial</hask>(阶乘)的''[[函数]]''对上面的函数做一点补充。我添加了一个模块头部，这是一种良好的风格。

<haskell>
module Main where

factorial n = if n == 0 then 1 else n * factorial (n - 1)

main = do putStrLn "What is 5! ?"
          x <- readLn
          if x == factorial 5
              then putStrLn "You're right!"
              else putStrLn "You're wrong!"
</haskell>

使用命令<tt>ghc --make Test.hs</tt>重新编译。并用下面的命令执行

  $ ./Test
  What is 5! ?
  120
  You're right!

这是一个函数。表现得就和内建函数一样，可以通过<hask>factorial 5</hask>来调用。

现在向<tt>ghci</tt>询问函数<hask>factorial</hask>的[[类型]].

  $ ghci Test.hs
  << GHCi banner >>
  Ok, modules loaded: Main.
  Prelude Main> :t <hask>factorial</hask>
  <hask>factorial :: (Num a) => a -> a</hask>

Function types are written with the argument type, then <hask> -> </hask>, then the result type.  (This also has the type class <hask>Num</hask>.)

<hask>factorial</hask>函数可以通过case得以简化：

<haskell>
factorial 0 = 1
factorial n = n * factorial (n - 1)
</haskell>

== 语法规则 ==
查看[[:Category:Syntax |语法]]以了解更多有用的语法。

<haskell>
secsToWeeks secs = let perMinute = 60
                       perHour   = 60 * perMinute
                       perDay    = 24 * perHour
                       perWeek   =  7 * perday
                   in  secs / perWeek
</haskell>

<hask>let</hask>表达式定义了临时名称。(This is using layout again.  You could use {braces}, and separate the names with semicolons, if you prefer.)

<haskell>
classify age = case age of 0 -> "newborn"
                           1 -> "infant"
                           2 -> "toddler"
                           _ -> "senior citizen"
</haskell>

<hask>case</hask>表达式实现了多路分支。符号<hask>_</hask>表示"任何东西"。

== Using libraries ==

Everything used so far in this tutorial is part of the [[Prelude]], which is the set of Haskell functions that are always there in any program.

The best road from here to becoming a very productive Haskell programmer (aside from practice!) is becoming familiar with other [[Applications and libraries | libraries]] that do the things you need.  Documentation on the standard libraries is at [http://haskell.org/ghc/docs/latest/html/libraries/ http://haskell.org/ghc/docs/latest/html/libraries/].  There are modules there with:

* [[Applications and libraries/Data structures |Useful data structures]]
* [[Applications and libraries/Concurrency and parallelism |Concurrent and parallel programming]]
* [[Applications and libraries/GUI libraries | Graphics and GUI libraries]]
* [[Applications and libraries/Network | Networking, POSIX, and other system-level stuff]]
* Two test frameworks, QuickCheck and HUnit
* Regular expressions and predictive parsers
* More...

<haskell>
module Main where

import qualified Data.Map as M

errorsPerLine = M.fromList
    [ ("Chris", 472), ("Don", 100), ("Simon", -5) ]

main = do putStrLn "Who are you?"
          name <- getLine
          case M.lookup name errorsPerLine of
              Nothing -> putStrLn "I don't know you"
              Just n  -> do putStr "Errors per line: "
                            print n
</haskell>

The <hask>import</hask> says to use code from <hask>Data.Map</hask> and that it will be prefixed by <hask>M</hask>.  (That's necessary because some of the functions have the same names as functions from the prelude.  Most libraries don't need the <hask>as</hask> part.)

If you want something that's not in the standard library, try looking at http://hackage.haskell.org/packages/hackage.html or this wiki's [[applications and libraries]] page.  This is a collection of many different libraries written by a lot of people for Haskell.  Once you've got a library, extract it and switch into that directory and do this:

  runhaskell Setup configure
  runhaskell Setup build
  runhaskell Setup install

On a UNIX system, you may need to be root for that last part.

== Topics that don't fit in 10 minute limit ==

* [[:Category:Language | Advanced data types]]
** Arithmetic lists
** [[List comprehension]]s
** [[Type#Type and newtype | Type synonyms]]
** [[Type|data vs newtype]] (and [[Newtype|here]])
** [[Class |Type classes and instances]]
* [[:Category:Syntax |Advanced syntax]]
** [[Operator]]s
** [[Infix operator |(+) and `foo`]]
** [[Fixity declaration]]s
* Advanced functions
** [[Currying]]
** [[Lambda abstraction]]s
** [[Section of an infix operator |Sections]]
* [[:Category:Monad |Monads]]
* [[Tutorials/Programming Haskell/String IO |File I/O]]
** Reading files
** Writing Files

[[Category:Tutorials]] [[Category:Chinese]]
语言: [[Learn Haskell in 10 minutes|English]] [[Cn/十分钟学会 Haskell|简体中文]]