本页使用了标题或全文手工转换

Haskell

维基百科,自由的百科全书
(重定向自Haskell语言
跳到导航 跳到搜索
Haskell
Haskell-Logo.svg
编程范型 函数式编程惰性求值多态模組化
发行时间 1990年
型態系統 強型態,靜態,多態
文件扩展名 .hs, .lhs
網站 www.haskell.org
主要實作產品
GHC英语Glasgow Haskell Compiler, Hugs英语Hugs, NHC, JHC, Yhc
啟發語言
Miranda, ML, Gofer英语Gofer programming language
影響語言
Clojure[1] Python

Haskell(发音为/ˈhæskəl/[2]是一种标准化的,通用的纯函數程式語言,有非限定性语义静态类型[3]。它的命名源自美国逻辑学家哈斯凱爾·加里,他在数理逻辑方面上的工作使得函数式编程语言有了广泛的基础。在Haskell中,“函数是第一類物件[4]。作为一门函數程式語言,主要控制结构是函数。Haskell语言是1990年在编程语言Miranda的基础上标准化的,并且以λ演算为基础发展而来。这也是为什么Haskell语言以希腊字母「λ」(Lambda)作为自己的标志。Haskell具有“证明即程序、命题为类型”的特征[5][6][7][8]

历史[编辑]

1985年,Miranda发行后,惰性函数式语言的关注度增长。到1987年前,出现了十多种非限定性、纯函数式语言。其中,Miranda使用的最为广泛,但还没有出现在公共领域。在俄勒冈波特兰的函数式编程语言与计算机结构大会(FPCA '87)上,参加者一致同意形成一个委员会来为这样的语言定义一种开放性标准。该委员会旨在整合已有函数式语言,作为将来的函数式语言设计研究工作的基础。[9]

Haskell 1.0至1.4[编辑]

1990年定义了Haskell的第一个版本(“Haskell 1.0”)。[10]委员会形成了一系列的语言定义(1.0,1.1,1.2,1.3,1.4)。

Haskell 98[编辑]

1997年底,该系列形成了Haskell 98,旨在定义一个稳定、最小化、可移植的语言版本以及相应的标准库,以用于教学和作为将来扩展的基础。委员会明确欢迎创建各种增加或集成实验性特性的Haskell 98的扩展和变种。[9]

1999年2月,Haskell 98语言标准公布,名为《The Haskell 98 Report》。[9]2003年1月,《Haskell 98 Language and Libraries: The Revised Report》公布。[11]接着,Glasgow Haskell Compiler (GHC)英语Glasgow Haskell Compiler实现了当时的事实标准,Haskell快速发展。

Haskell Prime[编辑]

2006年早期,开始了定义Haskell 98标准后续的进程,非正式命名为Haskell Prime[12]这是个修订语言定义的不断增补的过程,每年产生一个新的修订版。第一个修订版于2009年11月完成、2010年7月发布,称作Haskell 2010

Haskell 2010[编辑]

Haskell 2010加入了外部函数接口(Foreign Function Interface英语Foreign Function Interface,FFI)允许绑定到其它编程语言,修正了一些语法问题(在正式语法中的改动)并废除了称为“n加k模式”(换言之,不再允许形如fact (n+1) = (n+1) * fact n的定义)。引入了语言级编译选项语法扩展(Language-Pragma-Syntax-Extension),使得在Haskell源代码中可以明确要求一些扩展功能。Haskell 2010引入的这些扩展的名字是DoAndIfThenElse、HierarchicalModules、EmptyDataDeclarations、FixityResolution、ForeignFunctionInterface、LineCommentSyntax、PatternGuards、RelaxedDependencyAnalysis、LanguagePragma、NoNPlusKPatterns。

特性[编辑]

Haskell是现有的一门开放的、已发布标准的,且有多种实现的语言。[11]支持惰性求值模式匹配列表解析类型类类型多态。它是一门纯函数编程语言,这意味着大体上,Haskell中的函数没有副作用。Haskell用特定的类型来表达副作用,该类型与函数类型相互独立。纯函数可以操作并返回可执行的副作用的类型,但不能够执行它们,只有用于表达副作用的类型才能执行这些副作用,Haskell以此表达其它语言中的非纯函数。

Haskell拥有一个基于Hindley-Milner类型推论静态强类型系统。Haskell在此领域的主要创新就是加入了类型类(type class),原本设想作为重载的主要方式,[13]在之后发现了更多用途。[14]

Haskell的主要实现GHC英语Glasgow Haskell Compiler是个解释器,也是个原生代码编译器。它可以在大多数平台运行,GHC在并发和并行上具有高性能的实现能力,[15]也有丰富的类型系统,如广义代数数据类型和类型族(Type Families)。

单子是一个抽象類型,可以表达不同种类的计算,包括异常处理非确定性语法分析以及软件事务内存,其中一个应用是用于表达副作用的类型。单子定义为普通的数据类型,同时Haskell也为其提供了几种语法糖

Haskell有一个活跃的社区,在线上包仓库Hackage上有豐富的第三方开源库或工具。[16]

语法[编辑]

数据类型[编辑]

Haskell是强类型语言。 Char的字面值用单引号围起; 字符串即[Char]类型,其字面值用双引号括起来。 Int通常为32位整型 Integer是无界整型 Float 表示单精度的浮点数 Double 表示双精度的浮点数 Bool 只有两种值:True 和 False。

List[编辑]

使用[ ]与逗号分隔符,定义一个list的实例。其元素必须具有相同类型。字符串是list的特例。用:把元素与list、其他元素连接(cons)起来。:是右结合的运算符。[1,2,3] 实际上是 1:2:3:[] 的语法糖。两个 List 合并通过 ++ 运算子实现。按照索引取得 List 中的元素,可以使用 !! 运算子,索引的下标为 0。List 中的 List 可以是不同长度,但必须得是相同的型别。['K'..'Z']这样的Range方法快捷定义一个List。[2,4..20]用法给出了Range的第一、第二、最后一个元素。使用 > 和 >= 可以比较 List 的大小。它会先比较第一个元素,若它们的值相等,则比较下一个,以此类推。List常用的函数:

  • head 返回一个 List 的头部,也就是 List 的首个元素。
  • tail 返回一个 List 的尾部,也就是 List 除去头部之后的部分。
  • last 返回一个 List 的最后一个元素。
  • init 返回一个 List 除去最后一个元素的部分。
  • length 返回一个 List 的长度。
  • null 检查一个 List 是否为空。如果是,则返回 True,否则返回 False。
  • reverse 将一个 List 反转
  • take 返回一个 List 的前几个元素。例如take 24 [13,26..]取前24个13的倍数
  • drop 删除一个 List 中的前几个元素
  • maximum 返回一个 List 中最大的元素。
  • minimun 返回最小的元素。
  • sum 返回一个 List 中所有元素的和。
  • product 返回一个 List 中所有元素的积。
  • elem 判断一个元素是否在包含于一个 List,通常以中缀函数的形式调用
  • replicate 得到包含相同元素的 List 。例如:replicate 3 10,得 [10,10,10]。
  • repeat 产生一个元素的无限重复的List
  • cycle 接受一个 List 做参数并返回一个无限 List

list comprehension是指基于一个List,按照规则产生一个新List,例如:[x*2 | x <- [1..10], x*2 >= 12]

Tuple[编辑]

使用( )与逗号分隔符,定义一个tuple的实例。其元素可以使不同类型,但个数是固定的。

Tuple的类型取决于其中项的数目与其各自元素的类型。单元素的 Tuple 被禁止。

  • fst 返回一个序对的首项。
  • snd 返回序对的尾项
  • zip 取两个 List作为参数,然后将它们依次配对,形成一组序对的 List。

运算符[编辑]

基本类似于C语言。但使用not表示逻辑非。

 +  -  *  /  ^    -- 加、減、乘、除、指數
 mod              -- 取餘數
 $                -- 也是表示函數作用的, 但它的優先級最低, 而且作用次序是從右向左的
 ++               -- 兩個List的連接
 .                 -- 函數的複合
 && ||  ==  /=     -- 與、或、等於、不等於
 <=  >=  <  >      -- 小於等於、大於等於、小於、大於
 : //  =  @        -- 一個元素連接List、
 ->               -- 函數類型描述,運算符左邊為參數類型,右邊為結果類型。為右结合。例如:addThree :: Int -> Int -> Int -> Int 
 =>               -- 運算符的左邊表示一個類型變量(通常為單個小寫字母)屬於一個類型類(Typeclass),相當於C++語言的模板參數類型
 ..               -- List的Range限定
 ::               -- 函數/表達式的類型特徵,左側為函數/表達式,右側為類型
 <-             -- List comprehension 的條件限定
 !!             -- 取List的第某個元素,based 0

基本的 Typeclass:

  • Eq 可判断相等性的type
  • Ord 可比较大小的type
  • Show 可表示为字符串的type
  • Read 可从字符串转换出值的type
  • Enum 连续的,也就是可枚举的type。每个值都有后继 (successer) 和前置 (predecesor),分别可以通过 succ 函数和 pred 函数得到。
  • Bounded 有上限和下限。例如:maxBound :: Char 或者 maxBound :: Bool
  • Num 数字
  • Integral
  • Floating

表达式[编辑]

  • let表达式:格式为 let [bindings] in [expressions] 。let 也可以定义局部函数 。在一行中设定多个名字的值,可用分号隔开。List Comprehension 中 let绑定的名字在输出函数及限制条件中都可见;忽略了 let 绑定的 in 部分,因为名字的可见性已经预先定义好了。
  • if then else是表达式
  • Case表达式:
 case expression of pattern -> result  
      pattern -> result  
      pattern -> result  
      ...  

控制结构[编辑]

if then else是分段函数定义时的语法糖。与C语言不同,要求必须有else部分。类似于C语言分支语句的情形,叫做pattern matching,例子如下:

 1 pts :: Int -> Int
 2 pts 1 = 10
 3 pts 2 = 6
 4 pts x
 5     | x <= 6    = 7 - x
 6     | otherwise = 0
 7 
 8 (||) :: Bool -> Bool -> Bool  -- 或操作的类型与定义
 9 True  || _ = True             -- 第二个参数是任何值都匹配。 
10 False || y = y

函数[编辑]

  • 函数调用有最高运算顺序,例如succ 9*10表示(succ 9)*10
  • 函数的调用使用空格符而不是括号。
  • 函数的复合调用是左结合
  • 首字母大写的函数是不允许的
  • 两个参数的函数的调用可以写成中缀形式: param1 `funcName` param2
  • 运算符可以用括号围起来,作为前缀形式:(+) 2 3 的结果为5
  • 在 ghci 下,我们可以使用 ``let`` 关键字来定义一个常量。在 ghci 下执行 ``let a=1`` 与在脚本中编写 ``a=1`` 是等价的。
 1 --funcName arguments = expression  --定义函数的一般形式
 2 area r = pi * r ^ 2 -- 定义了一个函数
 3 area 101 -- 调用了函数
 4 f1 f2 3.14 -- 函数调用是左结合,等效于(f1 f2) 3.14
 5 
 6 --模式匹配方式定义
 7 factorial :: (Integral a) => a -> a  
 8 factorial 0 = 1  
 9 factorial n = n * factorial (n - 1)   
10 
11 as模式,是将一个名字和 @ 置于模式前,可以在按模式分割参数值时仍保留对其整体的引用。如nameGlobal@(x:y:ys)nameGlobal会匹配出与 x:y:ys 对应的东西。as模式在较大的模式中保留对整体的引用,从而减少重复性的工作。
12 
13 heron a b c = sqrt (s * (s - a) * (s - b) * (s - c))
14     where                     -- where在表达式中局部绑定了名字s与一个值。也可以在表达式之前用let ... in语法
15     s = (a + b + c) / 2
16 
17 absolute x                 -- 绝对值函数,使用了分段函数语法糖(称作Guards)
18     | x < 0     = 0 - x
19     | otherwise = x        -- 兜底条件
20 
21 bmiTell :: (RealFloat a) => a -> a -> String  
22 bmiTell weight height  
23     | bmi <= 18.5 = "You're underweight."  
24     | bmi <= 25.0 = "You're normal. "  
25     | bmi <= 30.0 = "You're fat."  
26     | otherwise   = "You're overweight."  
27     where bmi = weight / height ^ 2  -- 使用where定义多个名字来避免重复
28 
29 --where也可以用模式匹配
30 initials :: String -> String -> String  
31 initials firstname lastname = [f] ++ ". " ++ [l] ++ "."  
32     where (f:_) = firstname  
33           (l:_) = lastname  
34 
35 --where可以定义函数。在定义一个函数的时候也写几个辅助函数摆在 where 绑定中。 而每个辅助函数也可以透过 where 拥有各自的辅助函数。
36 calcBmis :: (RealFloat a) => [(a, a)] -> [a]  
37 calcBmis xs = [bmi w h | (w, h) <- xs] 
38     where bmi weight height = weight / height ^ 2  
39 
40 funcName :: type1 -> type2 -> type3 -- 其中,::表示类型特征(type signature),->是右结合,这里等效于type1 -> (type2->type3),给定一个type1的输入参数,返回一个函数(type2->type3)
41 
42 f1 = (absolute .  area)   -- 函数复合运算符是 . (function composition operator)

多态类型(Polymorphic types)类似于C++的模板。例如,算术加法:

1  (+) :: (Num a) => a -> a -> a -- Num是typeclass。 =>表示signature restricts

lambda函数[编辑]

lambda 就是匿名函数。写法是:一个 \ (因为它看起来像是希腊字母λ),后面是用空格分隔的参数,-> 后面是函数体。通常用括号将括起lambda函数,否则它会占据整个右边部分。

例如:(\a b -> (a * 30 + 3) / b)

可以在 lambda 中使用模式匹配,但无法为一个参数设置多个模式,如 [] 和 (x:xs)并用。

使用 lambda 可以更明确地表现出值是个函数,可以用来传递给其他函数作参数。

高阶函数[编辑]

Haskell的所有函数实际上是单参数函数。多参数函数的写法实际上是Curry化的语法糖。即 func a b等价于(func a) b

point free style (也称作 pointless style) 的函数,即通过柯里化 (Currying)省略掉单参数。例如:

sum' :: (Num a) => [a] -> a     
sum' xs = foldl (+) 0 xs   --等号的两端都有个 xs。 
sum'   = foldl (+) 0     --柯里化 (Currying),可以省掉两端的 xs。

中缀运算符可以加括号变为单参数函数。如 (*3) 5 的值为15。 但(-5)表示负值,所以单参数函数需要写为(subtract 5)。

中缀运算符 $,可用于改变函数的调用次序,使其右边的表达式先计算出来。这可以减少一对括号使用。例如 f (g (z x)) 与 f $ g $ z x 等价。其定义是:

($) :: (a -> b) -> a -> b  
f $ x = f x  

$ 还可以将数据作为函数使用。例如:

map ($ 3) [(4+),(10*),(^2),sqrt]

中缀运算符 . 用于函数的复合,其定义是:

(.) :: (b -> c) -> (a -> b) -> a -> c  
f . g = \x -> f (g x)

异常处理[编辑]

提供了处理异常的函数Template:Haskell/Template:Haskell/Template:Haskell/Template:Haskell.

 1 import Prelude hiding(catch)
 2 import Control.Exception
 3 instance Exception Int
 4 instance Exception Double
 5 main = do
 6   catch
 7     (catch
 8       (throw (42::Int))
 9       (\e-> print (0,e::Double)))
10     (\e-> print (1,e::Int))

输出结果

(1,42)

类似于 C++

 1 #include <iostream>
 2 using namespace std;
 3 int main() {
 4     try {
 5         throw (int)42;
 6     } catch (double e) {
 7         cout << "(0," << e << ")" << endl;
 8     } catch (int e) {
 9         cout << "(1," << e << ")" << endl;
10     }
11 }

另外一个例子:

1 do {
2   -- Statements in which errors might be thrown
3 } `catch` \ex -> do {
4   -- Statements that execute in the event of an exception, with 'ex' bound to the exception
5 }

如果仅有一个错误条件,Template:Haskell 类足够用了,确省是Haskell的 Template:Haskell class. 更复杂的出错处理用Template:HaskellTemplate:Haskell monads, 类似功能可用Template:Haskell

示例[编辑]

Haskell的函数结构[编辑]

如下是Haskell语言的"Hello world",注意其中除最后一行外皆可省略。

1 module Main where
2 
3 main :: IO ()
4 main = putStrLn "Hello, World!"

如下是阶乘函数的Haskell实现:

1 fac :: Int -> Int
2 fac 0 = 1
3 fac n = n * fac (n - 1)

它将阶乘描述成有一个基本终止情形的递归函数。这跟数学定义中对阶乘的描述很相似。事实上,Haskell中很多的代码的语法与功能都和数学一致。

上面的递归函数的第一行是可选的,它描述了这个函数的型態types)。它可以读作函数fac的型態為整數至整數(function fac has a int-to-int type)。这就是说,它以一个整型为参数,并且返回另一个整型。

第二行依赖的模式匹配,是Haskell程序中一个重要的部分。注意函数的参数是用空格分隔而不是在括号中。当函数的参数是0时,它会返回整型1。对于其他的情况则尝试第三行。这是一个递归,它会一直执行只到满足基本的情形。负参数会导致无限递归,一个guard英语guard (computing)保证第三行不会执行负参数。

"Prelude"是一个类似C中标准库的小函数集合。使用Prelude,并用无指定参数的写法,它可以改成:

1 fac = product . enumFromTo 1

上面的定义接近于数学中的定义:f = g o h(参见复合函数),这并不是一个对变量赋值的语句。

Haskell的高阶函数[编辑]

Haskell中可以定义高阶函数(Higher-order Function),既将函数作为一个参数来使用,也可以将函数作为结果输出,例如:

1 f :: (Int -> Int) ->(Int -> Int)
2 f g = \x -> g x + 5

这里f就是一个高阶函数,它取一个从Int到Int的函数g作为参数,输出一个从Int到Int的函数。高阶函数的使用在一些情况下将极大的简化代码。

Haskell的编译器[编辑]

参考文献[编辑]

  1. ^ Hickey, Rich. Clojure Bookshelf. Listmania!. Amazon.com. [2017-10-03]. 
  2. ^ Chevalier, Tim. anybody can tell me the pronuncation of "haskell"?. Haskell-cafe (邮件列表). 28 January 2008 [12 March 2011]. 
  3. ^ Haskell Report
  4. ^ Burstall, Rod. Christopher Strachey—Understanding Programming Languages. Higher-Order and Symbolic Computation. 2000, 13 (52). 
  5. ^ Curry, Haskell. Functionality in Combinatory Logic. Proceedings of the National Academy of Sciences 20. 1934: 584–590. 
  6. ^ Curry, Haskell B.; Feys, Robert. Craig, William, 编. Combinatory Logic Vol. I. Amsterdam: North-Holland. 1958. , with 2 sections by William Craig, see paragraph 9E
  7. ^ De Bruijn, Nicolaas. Automath, a language for mathematics. TH-report 68-WSK-05 (Department of Mathematics, Eindhoven University of Technology). 1968.  Reprinted in revised form, with two pages commentary, in: Classical papers on computational logic 1967-1970. Automation and Reasoning 2. Springer Verlag. 1983: 159–200. 
  8. ^ Howard, William A. The formulae-as-types notion of construction. (编) Seldin, Jonathan P.; Hindley, J. Roger. To H.B. Curry: Essays on Combinatory Logic, Lambda Calculus and Formalism. Boston, MA: Academic Press英语Academic Press. 1980年9月: 479–490 [original paper manuscript from 1969]. ISBN 978-0-12-349050-6 .
  9. ^ 9.0 9.1 9.2 Preface. Haskell 98 Language and Libraries: The Revised Report. December 2002. 
  10. ^ Hudak, Paul; Hughes, John; Peyton Jones, Simon; Wadler, Philip. A history of Haskell: being lazy with class. Proceedings of the third ACM SIGPLAN conference on History of programming languages(HOPL III). 2007: 12–1–12–55. ISBN 978-1-59593-766-7. doi:10.1145/1238844.1238856. 
  11. ^ 11.0 11.1 Simon Peyton Jones (editor). Haskell 98 Language and Libraries: The Revised Report. December 2002. 
  12. ^ Welcome to Haskell'. The Haskell' Wiki. (原始内容存档于2009年4月23日). 
  13. ^ Wadler, P.; Blott, S. How to make ad-hoc polymorphism less ad hoc. Proceedings of the 16th ACM SIGPLAN英语SIGPLAN-SIGACT英语SIGACT Symposium on Principles of Programming Languages英语Symposium on Principles of Programming Languages (ACM). 1989: 60–76. ISBN 0-89791-294-2. doi:10.1145/75277.75283. 
  14. ^ Hallgren, T. Fun with Functional Dependencies, or Types as Values in Static Computations in Haskell. Proceedings of the Joint CS/CE Winter Meeting (Varberg, Sweden). January 2001. 
  15. ^ Computer Language Benchmarks Game 互联网档案馆存檔,存档日期2012-08-31.
  16. ^ 存档副本. [2013-06-26]. (原始内容存档于2013-05-03). 

外部連結[编辑]

教學手冊[编辑]